void operator()(std::ostream& out) const {
typename GraphGraphAttributes::const_iterator
gi = g_attributes.begin(),
gend = g_attributes.end();
if ( gi != gend ) {
out << "graph [";
write_attributes(g_attributes, out);
out << "];" << std::endl;
}
//write node [......]; if need
typename GraphNodeAttributes::const_iterator
ni = n_attributes.begin(),
nend = n_attributes.end();
if ( ni != nend ) {
out << "node [";
write_attributes(n_attributes, out);
out << "];" << std::endl;
}
//write edge[....]; if need
typename GraphEdgeAttributes::const_iterator
ei = e_attributes.begin(),
eend = e_attributes.end();
if ( ei != eend ) {
out << "edge [";
write_attributes(e_attributes, out);
out << "];" << std::endl;
}
}
void XMLWriter::write_post(StackEntry& entry)
{
if (entry._state < ATTRIBUTES)
write_attributes(entry);
if (entry._children || !entry._content.empty()) {
if (entry._state < PRE_CLOSED)
close_pre(entry);
_out << entry._content;
//entry._state = CONTENT;
if (_format._pretty>=PRETTY_LINEFEED && entry._content.empty())
_out << _format._endl;
if (_format._pretty==PRETTY_INDENT && entry._content.empty()) {
for(size_t i=_stack.size(); --i>0; )
_out << XML_INDENT_SPACE;
}
_out << "</" << EncodeXMLString(entry._node_name) << ">";
} else {
_out << "/>";
}
entry._state = POST;
}
void operator()(std::ostream& out, const VorE& e) const {
if (!attributes[e].empty()) {
out << "[";
write_attributes(attributes[e], out);
out << "]";
}
}
static void
attrd_cib_replaced_cb(const char *event, xmlNode * msg)
{
crm_notice("Updating all attributes after %s event", event);
if(election_state(writer) == election_won) {
write_attributes(TRUE, FALSE);
}
}
void test_object_blob_fromchunks__creating_a_blob_from_chunks_honors_the_attributes_directives(void)
{
write_attributes(repo);
assert_named_chunked_blob("321cbdf08803c744082332332838df6bd160f8f9", "dummy.data");
assert_named_chunked_blob("e9671e138a780833cb689753570fd10a55be84fb", "dummy.txt");
assert_named_chunked_blob("e9671e138a780833cb689753570fd10a55be84fb", "dummy.dunno");
}
void write_attribute(std::ostream& out,
const AttributeSequence& seq) const
{
if (!seq.empty()) {
out << "[";
write_attributes(seq, out);
out << "]";
}
}
inline void write_all_attributes(Attributes attributes,
const std::string& name,
std::ostream& out)
{
typename Attributes::const_iterator i = attributes.begin(),
end = attributes.end();
if (i != end) {
out << name << " [\n";
write_attributes(attributes, out);
out << "];\n";
}
}
gboolean
attrd_election_cb(gpointer user_data)
{
attrd_declare_winner();
/* Update the peers after an election */
attrd_peer_sync(NULL, NULL);
/* Update the CIB after an election */
write_attributes(TRUE, FALSE);
return FALSE;
}
//++++++++++++++++++++++++++++++++++
void view_edit_search::write(){
//
if(!_active_result)
return;
//
_text_query->setText( _active_result->_filter );
//
write_attributes();
}
gboolean
attrd_election_cb(gpointer user_data)
{
free(peer_writer);
peer_writer = strdup(attrd_cluster->uname);
/* Update the peers after an election */
attrd_peer_sync(NULL, NULL);
/* Update the CIB after an election */
write_attributes(TRUE, FALSE);
return FALSE;
}
/***********************************************************************//**
* @brief Write CTA cube background model into XML element
*
* @param[in] xml XML element.
*
* Write CTA cube background model information into an XML element.
* The XML element will have the following structure
*
* <source name="..." type="..." instrument="...">
* <spectrum type="...">
* ...
* </spectrum>
* </source>
*
* If the model contains a non-constant temporal model, the temporal
* component will also be written following the syntax
*
* <source name="..." type="..." instrument="...">
* <spectrum type="...">
* ...
* </spectrum>
* <temporalModel type="...">
* ...
* </temporalModel>
* </source>
*
* If no temporal component is found a constant model is assumed.
***************************************************************************/
void GCTAModelCubeBackground::write(GXmlElement& xml) const
{
// Initialise pointer on source
GXmlElement* src = NULL;
// Search corresponding source
int n = xml.elements("source");
for (int k = 0; k < n; ++k) {
GXmlElement* element = xml.element("source", k);
if (element->attribute("name") == name()) {
src = element;
break;
}
}
// If we have a temporal model that is either not a constant, or a
// constant with a normalization value that differs from 1.0 then
// write the temporal component into the XML element. This logic
// assures compatibility with the Fermi/LAT format as this format
// does not handle temporal components.
bool write_temporal = ((m_temporal != NULL) &&
(m_temporal->type() != "Constant" ||
(*m_temporal)[0].value() != 1.0));
// If no source with corresponding name was found then append one
if (src == NULL) {
src = xml.append("source");
if (spectral() != NULL) src->append(GXmlElement("spectrum"));
if (write_temporal) src->append(GXmlElement("temporalModel"));
}
// Write spectral model
if (spectral() != NULL) {
GXmlElement* spec = src->element("spectrum", 0);
spectral()->write(*spec);
}
// Optionally write temporal model
if (write_temporal) {
if (dynamic_cast<GModelTemporalConst*>(temporal()) == NULL) {
GXmlElement* temp = src->element("temporalModel", 0);
temporal()->write(*temp);
}
}
// Write model attributes
write_attributes(*src);
// Return
return;
}
static void
attrd_cib_replaced_cb(const char *event, xmlNode * msg)
{
if (attrd_shutting_down()) {
return;
}
if (attrd_election_won()) {
crm_notice("Updating all attributes after %s event", event);
write_attributes(TRUE, FALSE);
}
// Check for changes in alerts
mainloop_set_trigger(attrd_config_read);
}
/*!
* \internal
* \brief Respond to a client refresh request (i.e. write out all attributes)
*
* \return void
*/
void
attrd_client_refresh(void)
{
GHashTableIter iter;
attribute_t *a = NULL;
/* 'refresh' forces a write of the current value of all attributes
* Cancel any existing timers, we're writing it NOW
*/
g_hash_table_iter_init(&iter, attributes);
while (g_hash_table_iter_next(&iter, NULL, (gpointer *) & a)) {
mainloop_timer_stop(a->timer);
}
crm_info("Updating all attributes");
write_attributes(TRUE, FALSE);
}
/***********************************************************************//**
* @brief Write CTA exposure cube into FITS object.
*
* @param[in] fits FITS file.
*
* Writes the exposure cube image, the energy boundaries and the Good Time
* Intervals into the FITS object.
***************************************************************************/
void GCTACubeExposure::write(GFits& fits) const
{
// Write cube
m_cube.write(fits);
// Get last HDU and write attributes
GFitsHDU& hdu = *fits[fits.size()-1];
write_attributes(hdu);
// Write energy boundaries
m_ebounds.write(fits);
// Write GTIs
m_gti.write(fits);
// Return
return;
}
void XMLWriter::create(const XS_String& name)
{
if (!_stack.empty()) {
StackEntry& last = _stack.top();
if (last._state < PRE_CLOSED) {
write_attributes(last);
close_pre(last);
}
++last._children;
}
StackEntry entry;
entry._node_name = name;
_stack.push(entry);
write_pre(entry);
}
/**
* Program entrypoint.
*/
int main(int argc, char **argv)
{
QApplication app(argc, argv);
QWidget window;
unsigned char *raw_data;
unsigned char *buf;
int *color_freqs;
int *unique_pals;
int unique_pals_count;
int *pal_indexes;
unsigned char *pal_data;
int *pal_sizes;
unsigned char *tile_data;
int tile_data_sz;
unsigned char *attrib_data;
int attrib_data_sz;
const char *input_filename = 0;
const char *chr_output_filename = 0;
const char *pal_output_filename = 0;
const char *attrib_output_filename = 0;
int width = -1;
int height = -1;
/* Process arguments. */
if (!process_args(argv, &input_filename, &chr_output_filename, &pal_output_filename,
&attrib_output_filename, &width, &height)) {
return(-1);
}
/* check arguments */
if (!input_filename) {
fprintf(stderr, "img2nes: no filename given\n");
return(-1);
}
#if 0
if (width == -1 || height == -1) {
fprintf(stderr, "img2nes: please specify width and height of image\n");
return(-1);
}
if (width % 16 || height % 16) {
fprintf(stderr, "img2nes: width and height must be multiples of 16\n");
return(-1);
}
#endif
QImage originalImage = QImage(input_filename).convertToFormat(QImage::Format_RGB32);
if (originalImage.isNull()) {
fprintf(stderr, "img2nes: unable to read image '%s'\n", input_filename);
return(-1);
}
width = originalImage.width();
height = originalImage.height();
/* allocate some buffers */
raw_data = (unsigned char *)malloc(width * height * 3);
buf = (unsigned char *)malloc(width * height);
tile_data_sz = (height / 8) * (width / 8) * 16 * sizeof(unsigned char);
tile_data = (unsigned char *)malloc(tile_data_sz);
if (!raw_data || !buf || !tile_data) {
fprintf(stderr, "img2nes: failed to allocate memory for image data\n");
return(0);
}
#if 0
/* read input image */
if (!read_image(input_filename, width, height, /*has_alpha=*/0, raw_data))
return(-1);
#endif
/* convert raw RGB to nes palette indices */
convert_to_nes_colors(originalImage.bits(), width, height, /*has_alpha=*/1, buf);
QImage originalNesImage = to_qimage(buf, width, height);
QImage reducedColorsImage;
QImage reducedPalettesImage;
/* that was the easy part */
{
int i, j;
int cw = width / 16;
int ch = height / 16;
color_freqs = (int*)calloc(cw * ch, 64 * sizeof(int));
pal_data = (unsigned char *)malloc(cw * ch * 4 * sizeof(unsigned char));
pal_sizes = (int*)malloc(cw * ch * sizeof(int));
/* process all 16x16 blocks */
for (i = 0; i < ch; ++i) {
for (j = 0; j < cw; ++j) {
int num_colors;
unsigned char pal[64];
int *f = &color_freqs[(i*cw+j)*64];
/* count frequency of colors */
count_nes_color_frequencies(&buf[i*16*width+(j*16)], 16, 16, width, f);
f[0x0F] = INT_MAX;
/* record the colors that are actually used */
nes_palette_from_color_frequencies(f, pal, &num_colors);
#if 0
{
printf("palette: ");
for (int k = 0; k < num_colors; ++k) {
printf("%.2X ", pal[k]);
}
printf("\n");
}
#endif
/* reduce number of colors if necessary */
reduce_colors(&buf[i*16*width+(j*16)], 16, 16, width, f, pal, &num_colors);
/* sort the palette so that different palettes can be easily compared */
qsort(pal, num_colors, sizeof(unsigned char), compare_nes_colors);
#if 0
{
printf("sorted palette: ");
for (int k = 0; k < num_colors; ++k) {
printf("%.2X ", pal[k]);
}
printf("\n");
}
#endif
/* store the final palette for this 16x16 block */
assert(num_colors <= 4);
memcpy(&pal_data[(i*cw+j)*4], pal, num_colors * sizeof(unsigned char));
pal_sizes[i*cw+j] = num_colors;
}
}
reducedColorsImage = to_qimage(buf, width, height);
/* now each 16x16 block uses max 4 unique colors
the next step is to reduce the number of 4-color palettes, if necessary */
unique_pals = (int*)malloc(cw * ch * sizeof(int));
unique_pals_count = 0;
pal_indexes = (int*)malloc(cw * ch * sizeof(int));
/* find unique palettes and record their usage */
find_unique_palettes(pal_data, cw * ch, pal_sizes, unique_pals, &unique_pals_count, pal_indexes);
/* printf("unique palettes: %d\n", unique_pals_count); */
/* reduce number of palettes used if necessary */
reduce_palettes(buf, width, height, pal_data, pal_sizes, unique_pals, &unique_pals_count, pal_indexes);
reducedPalettesImage = to_qimage(buf, width, height);
/* encode tiles */
encode_nes_tiles(buf, width, height, pal_data, pal_sizes, unique_pals, pal_indexes, tile_data);
/* write tiles */
write_tiles(chr_output_filename, tile_data, tile_data_sz);
/* write palette data */
write_palettes(pal_output_filename, pal_data, pal_sizes, unique_pals, unique_pals_count);
/* encode attribute data */
attrib_data_sz = (cw/2)*(ch/2);
attrib_data = (unsigned char *)malloc(attrib_data_sz);
encode_nes_attributes(cw, ch, pal_indexes, attrib_data);
/* write attribute data */
write_attributes(attrib_output_filename, attrib_data, attrib_data_sz);
}
QHBoxLayout *box = new QHBoxLayout(&window);
box->addWidget(create_label(originalImage));
box->addWidget(create_label(originalNesImage));
box->addWidget(create_label(reducedColorsImage));
box->addWidget(create_label(reducedPalettesImage));
window.show();
app.exec();
/* Cleanup */
free(raw_data);
free(buf);
free(tile_data);
free(pal_data);
free(pal_sizes);
free(unique_pals);
free(pal_indexes);
free(color_freqs);
free(attrib_data);
/* All done. */
return 0;
}
/*!
* \brief Write a footprint with two pads for a RESM package.
*
* \return \c EXIT_FAILURE when errors were encountered,
* \c EXIT_SUCCESS when OK.
*/
int
resm_write_footprint ()
{
gdouble xmax;
gdouble xmin;
gdouble ymax;
gdouble ymin;
gdouble x_text;
gdouble y_text;
gchar *pin_pad_flags = g_strdup ("");
/* Attempt to open a file with write permission. */
fp = fopen (footprint_filename, "w");
if (!fp)
{
if (verbose)
{
g_log ("", G_LOG_LEVEL_WARNING,
_("could not open file for %s footprint: %s."),
footprint_type, footprint_filename);
}
fclose (fp);
return (EXIT_FAILURE);
}
/* Print a license if requested. */
if (license_in_footprint)
{
write_license ();
}
/* Determine (extreme) courtyard dimensions based on pin/pad
* properties */
xmin = multiplier * ((-pitch_x / 2.0) - (pad_length / 2.0) - pad_solder_mask_clearance);
xmax = multiplier * (pitch_x / 2.0 + pad_length / 2.0 + pad_solder_mask_clearance);
ymin = multiplier * ((-pad_width / 2.0) - pad_solder_mask_clearance);
ymax = multiplier * (pad_width / 2.0 + pad_solder_mask_clearance);
/* Determine (extreme) courtyard dimensions based on package
* properties */
if ((multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package)) < xmin)
{
xmin = (multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package)) > xmax)
{
xmax = (multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package));
}
if ((multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package)) < ymin)
{
ymin = (multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package)) > ymax)
{
ymax = (multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package));
}
/* If the user input is using even more real-estate then use it */
if (multiplier * (-courtyard_length / 2.0) < xmin)
{
xmin = multiplier * (-courtyard_length / 2.0);
}
if (multiplier * (courtyard_length / 2.0) > xmax)
{
xmax = multiplier * (courtyard_length / 2.0);
}
if (multiplier * (-courtyard_width / 2.0) < ymin)
{
ymin = multiplier * (-courtyard_width / 2.0);
}
if (multiplier * (courtyard_width / 2.0) > ymax)
{
ymax = multiplier * (courtyard_width / 2.0);
}
/* Write element header
* Guess for a place where to put the refdes text */
x_text = 0.0 ; /* already in mil/100 */
y_text = (ymin - 10000.0); /* already in mil/100 */
write_element_header (x_text, y_text);
/* Write pin and/or pad entities */
if (!strcmp (pad_shape, "rectangular pad"))
{
pin_pad_flags = g_strdup ("square");
}
if (pad_length > pad_width) /* Write pads parallel to x-axis */
{
/* Pad #1 */
write_pad
(
1, /* pad number */
"", /* pad name */
multiplier * ((-pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((-pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_width + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
/* Write pin #1 with a square pad if checked */
(pin1_square) ? "square" : pin_pad_flags /* flags */
);
/* Pad #2 */
write_pad
(
2, /* pad number */
"", /* pad name */
multiplier * ((pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_width + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
}
else /* write pads perpendiclar to x-axis */
{
/* Pad #1 */
write_pad
(
1, /* pad number */
"", /* pad name */
multiplier * (-pitch_x / 2.0), /* x0-coordinate */
multiplier * ((pad_width - pad_length) / 2.0), /* y0-coordinate */
multiplier * (-pitch_x / 2), /* x1-coordinate */
multiplier * ((-pad_width + pad_length) / 2.0), /* y1-coordinate */
multiplier * pad_length, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_length + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
/* Write pin #1 with a square pad if checked */
(pin1_square) ? "square" : pin_pad_flags /* flags */
);
/* Pad #2 */
write_pad
(
2, /* pad number */
"", /* pad name */
multiplier * (pitch_x / 2.0), /* x0-coordinate */
multiplier * ((pad_width - pad_length) / 2.0), /* y0-coordinate */
multiplier * (pitch_x / 2.0), /* x1-coordinate */
multiplier * ((-pad_width + pad_length) / 2.0), /* y1-coordinate */
multiplier * pad_length, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_length + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
}
/* Write a package body on the silkscreen */
if (silkscreen_package_outline && package_body_width)
{
fprintf (fp, "# Write a package body on the silkscreen\n");
if (pad_width >= package_body_width)
{
write_element_line
(
multiplier * (((-pitch_x + pad_length) / 2.0) + pad_solder_mask_clearance + silkscreen_line_width),
multiplier * (package_body_width / 2.0),
multiplier * (((pitch_x - pad_length) / 2.0) - pad_solder_mask_clearance - silkscreen_line_width),
multiplier * (package_body_width / 2.0),
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (((-pitch_x + pad_length) / 2.0) + pad_solder_mask_clearance + silkscreen_line_width),
multiplier * (-package_body_width / 2.0),
multiplier * (((pitch_x - pad_length) / 2.0) - pad_solder_mask_clearance - silkscreen_line_width),
multiplier * (-package_body_width / 2.0),
multiplier * silkscreen_line_width
);
}
else
{
/* lines parallel to X-axis */
write_element_line
(
multiplier * (-package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (-package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * silkscreen_line_width
);
/* lines perpendicular to X-axis */
write_element_line
(
multiplier * (-package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * (-package_body_length / 2.0),
multiplier * (((-pad_width - silkscreen_line_width) / 2.0) - pad_solder_mask_clearance),
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (-package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * (-package_body_length / 2.0),
multiplier * (((pad_width + silkscreen_line_width) / 2.0) + pad_solder_mask_clearance),
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (((-pad_width - silkscreen_line_width) / 2.0) - pad_solder_mask_clearance),
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (((pad_width + silkscreen_line_width) / 2.0) + pad_solder_mask_clearance),
multiplier * silkscreen_line_width
);
}
}
/* Write a pin #1 marker on the silkscreen */
if (silkscreen_indicate_1)
{
fprintf (fp, "# Write a pin 1 marker on the silkscreen\n");
if (pad_width >= package_body_width)
{
write_element_line
(
multiplier * (((-pitch_x + pad_length) / 2.0) + pad_solder_mask_clearance + silkscreen_line_width),
multiplier * (-package_body_width / 2.0),
multiplier * (((-pitch_x + pad_length) / 2.0) + pad_solder_mask_clearance + silkscreen_line_width),
multiplier * (package_body_width / 2.0),
multiplier * silkscreen_line_width
);
}
else
{
write_element_arc
(
multiplier * (((-package_body_length) / 2.0) - 2 * silkscreen_line_width),
multiplier * (-package_body_width / 2.0),
multiplier * 0.5 * silkscreen_line_width,
multiplier * 0.5 * silkscreen_line_width,
0,
360,
multiplier * silkscreen_line_width
);
}
}
/* Write a courtyard on the silkscreen */
if (courtyard)
{
fprintf (fp, "# Write a courtyard on the silkscreen\n");
write_rectangle
(
xmin, /* already in mil/100 */
ymin, /* already in mil/100 */
xmax, /* already in mil/100 */
ymax, /* already in mil/100 */
multiplier * courtyard_line_width
);
}
/* Write attributes to the footprint file. */
if (attributes_in_footprint)
{
write_attributes ();
}
/* Finishing touch. */
fprintf (fp, "\n");
fprintf (fp, ")\n");
fclose (fp);
/* We are ready creating a footprint. */
if (verbose)
{
g_log ("", G_LOG_LEVEL_INFO,
_("wrote a footprint for a %s package: %s."),
footprint_type,
footprint_filename);
}
return (EXIT_SUCCESS);
}
int main()
{
write_attributes();
}
/*!
\brief Write OGR feature
\param Map pointer to Map_info structure
\param type feature type (GV_POINT, GV_LINE, ...)
\param bpoints feature geometry
\param cats feature categories
\param ipoints isle geometry for polygons on NULL
\param nisles number of isles
\return feature offset into file
\return -1 on error
*/
off_t write_feature(struct Map_info *Map, int type,
const struct line_pnts **p_points, int nparts,
const struct line_cats *cats)
{
int i, cat, ret;
struct field_info *Fi;
const struct line_pnts *points;
struct Format_info_ogr *ogr_info;
struct Format_info_offset *offset_info;
off_t offset;
OGRGeometryH Ogr_geometry;
OGRFeatureH Ogr_feature;
OGRFeatureDefnH Ogr_featuredefn;
OGRwkbGeometryType Ogr_geom_type;
ogr_info = &(Map->fInfo.ogr);
offset_info = &(ogr_info->offset);
if (nparts < 1)
return -1;
points = p_points[0]; /* feature geometry */
if (!ogr_info->layer) {
/* create OGR layer if doesn't exist */
if (create_ogr_layer(Map, type) < 0)
return -1;
}
if (!points)
return 0;
cat = -1; /* no attributes to be written */
if (cats->n_cats > 0 && Vect_get_num_dblinks(Map) > 0) {
/* check for attributes */
Fi = Vect_get_dblink(Map, 0);
if (Fi) {
if (!Vect_cat_get(cats, Fi->number, &cat))
G_warning(_("No category defined for layer %d"), Fi->number);
if (cats->n_cats > 1) {
G_warning(_("Feature has more categories, using "
"category %d (from layer %d)"),
cat, cats->field[0]);
}
}
}
Ogr_featuredefn = OGR_L_GetLayerDefn(ogr_info->layer);
Ogr_geom_type = OGR_FD_GetGeomType(Ogr_featuredefn);
/* determine matching OGR feature geometry type */
if (type & (GV_POINT | GV_KERNEL)) {
if (Ogr_geom_type != wkbPoint &&
Ogr_geom_type != wkbPoint25D) {
G_warning(_("Feature is not a point. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPoint);
}
else if (type & GV_LINE) {
if (Ogr_geom_type != wkbLineString &&
Ogr_geom_type != wkbLineString25D) {
G_warning(_("Feature is not a line. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbLineString);
}
else if (type & GV_BOUNDARY) {
if (Ogr_geom_type != wkbPolygon) {
G_warning(_("Feature is not a polygon. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPolygon);
}
else if (type & GV_FACE) {
if (Ogr_geom_type != wkbPolygon25D) {
G_warning(_("Feature is not a face. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPolygon25D);
}
else {
G_warning(_("Unsupported feature type (%d)"), type);
return -1;
}
G_debug(3, "V1_write_line_ogr(): type = %d", type);
if (Ogr_geom_type == wkbPolygon || Ogr_geom_type == wkbPolygon25D) {
int iring, npoints;
/* add rings (first is exterior ring) */
for (iring = 0; iring < nparts; iring++) {
OGRGeometryH Ogr_ring;
points = p_points[iring];
npoints = points->n_points - 1;
Ogr_ring = OGR_G_CreateGeometry(wkbLinearRing);
if (points->x[0] != points->x[npoints] ||
points->y[0] != points->y[npoints] ||
points->z[0] != points->z[npoints]) {
G_warning(_("Boundary is not closed. Feature skipped."));
return -1;
}
/* add points */
for (i = 0; i < npoints; i++) {
OGR_G_AddPoint(Ogr_ring, points->x[i], points->y[i],
points->z[i]);
}
G_debug(4, " ring(%d): n_points = %d", iring, npoints);
OGR_G_AddGeometry(Ogr_geometry, Ogr_ring);
}
}
else {
for (i = 0; i < points->n_points; i++) {
OGR_G_AddPoint(Ogr_geometry, points->x[i], points->y[i],
points->z[i]);
}
G_debug(4, " n_points = %d", points->n_points);
}
/* create feature & set geometry */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
/* write attributes */
if (cat > -1 && ogr_info->dbdriver) {
if (0 > write_attributes(ogr_info->dbdriver,
cat, Fi, ogr_info->layer, Ogr_feature))
G_warning(_("Unable to writes feature attributes"));
G_free(Fi);
}
/* write feature into layer */
ret = OGR_L_CreateFeature(ogr_info->layer, Ogr_feature);
/* update offset array */
if (offset_info->array_num >= offset_info->array_alloc) {
offset_info->array_alloc += 1000;
offset_info->array = (int *) G_realloc(offset_info->array,
offset_info->array_alloc *
sizeof(int));
}
offset = offset_info->array_num;
offset_info->array[offset_info->array_num++] = (int) OGR_F_GetFID(Ogr_feature);
if (Ogr_geom_type == wkbPolygon || Ogr_geom_type == wkbPolygon25D) {
/* register exterior ring in offset array */
offset_info->array[offset_info->array_num++] = 0;
}
/* destroy */
OGR_G_DestroyGeometry(Ogr_geometry);
OGR_F_Destroy(Ogr_feature);
if (ret != OGRERR_NONE)
return -1;
G_debug(3, "write_feature(): -> offset = %lu offset_num = %d cat = %d",
(unsigned long) offset, offset_info->array_num, cat);
return offset;
}
void
attrd_peer_update(crm_node_t *peer, xmlNode *xml, bool filter)
{
bool changed = FALSE;
attribute_value_t *v = NULL;
const char *host = crm_element_value(xml, F_ATTRD_HOST);
const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);
const char *value = crm_element_value(xml, F_ATTRD_VALUE);
attribute_t *a = g_hash_table_lookup(attributes, attr);
if(a == NULL) {
a = create_attribute(xml);
}
v = g_hash_table_lookup(a->values, host);
if(v == NULL) {
crm_trace("Setting %s[%s] to %s from %s", attr, host, value, peer->uname);
v = calloc(1, sizeof(attribute_value_t));
if(value) {
v->current = strdup(value);
}
v->nodename = strdup(host);
crm_element_value_int(xml, F_ATTRD_IS_REMOTE, &v->is_remote);
g_hash_table_replace(a->values, v->nodename, v);
if (v->is_remote == TRUE) {
crm_remote_peer_cache_add(host);
}
changed = TRUE;
} else if(filter
&& safe_str_neq(v->current, value)
&& safe_str_eq(host, attrd_cluster->uname)) {
xmlNode *sync = create_xml_node(NULL, __FUNCTION__);
crm_notice("%s[%s]: local value '%s' takes priority over '%s' from %s",
a->id, host, v->current, value, peer->uname);
crm_xml_add(sync, F_ATTRD_TASK, "sync-response");
v = g_hash_table_lookup(a->values, host);
build_attribute_xml(sync, a->id, a->set, a->uuid, a->timeout_ms, a->user, v->nodename, v->nodeid, v->current);
crm_xml_add_int(sync, F_ATTRD_WRITER, election_state(writer));
send_cluster_message(peer, crm_msg_attrd, sync, TRUE);
free_xml(sync);
} else if(safe_str_neq(v->current, value)) {
crm_info("Setting %s[%s]: %s -> %s from %s", attr, host, v->current, value, peer->uname);
free(v->current);
if(value) {
v->current = strdup(value);
} else {
v->current = NULL;
}
changed = TRUE;
} else {
crm_trace("Unchanged %s[%s] from %s is %s", attr, host, peer->uname, value);
}
a->changed |= changed;
/* this only involves cluster nodes. */
if(v->nodeid == 0 && (v->is_remote == FALSE)) {
if(crm_element_value_int(xml, F_ATTRD_HOST_ID, (int*)&v->nodeid) == 0) {
/* Create the name/id association */
crm_node_t *peer = crm_get_peer(v->nodeid, host);
crm_trace("We know %s's node id now: %s", peer->uname, peer->uuid);
if(election_state(writer) == election_won) {
write_attributes(FALSE, TRUE);
return;
}
}
}
if(changed) {
if(a->timer) {
crm_trace("Delayed write out (%dms) for %s", a->timeout_ms, a->id);
mainloop_timer_start(a->timer);
} else {
write_or_elect_attribute(a);
}
}
}
void
attrd_peer_update(crm_node_t *peer, xmlNode *xml, const char *host, bool filter)
{
bool changed = FALSE;
attribute_t *a;
attribute_value_t *v = NULL;
int dampen = 0;
const char *op = crm_element_value(xml, F_ATTRD_TASK);
const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);
const char *value = crm_element_value(xml, F_ATTRD_VALUE);
const char *dvalue = crm_element_value(xml, F_ATTRD_DAMPEN);
if (attr == NULL) {
crm_warn("Peer update did not specify attribute");
return;
}
a = g_hash_table_lookup(attributes, attr);
if(a == NULL) {
if (op == NULL /* The xml children from an ATTRD_OP_SYNC_RESPONSE have no F_ATTRD_TASK */
|| safe_str_eq(op, ATTRD_OP_UPDATE)
|| safe_str_eq(op, ATTRD_OP_UPDATE_BOTH)) {
a = create_attribute(xml);
} else {
crm_warn("Update error (attribute %s not found)", attr);
return;
}
}
if (op == NULL /* The xml children from an ATTRD_OP_SYNC_RESPONSE have no F_ATTRD_TASK */
|| safe_str_eq(op, ATTRD_OP_UPDATE_BOTH)
|| safe_str_eq(op, ATTRD_OP_UPDATE_DELAY)) {
if (dvalue) {
dampen = crm_get_msec(dvalue);
if (dampen >= 0) {
if (a->timeout_ms != dampen) {
mainloop_timer_stop(a->timer);
mainloop_timer_del(a->timer);
a->timeout_ms = dampen;
if (dampen > 0) {
a->timer = mainloop_timer_add(a->id, a->timeout_ms, FALSE, attribute_timer_cb, a);
crm_info("Update attribute %s with delay %dms (%s)", a->id, dampen, dvalue);
} else {
a->timer = NULL;
crm_info("Update attribute %s with not delay", a->id);
}
//if dampen is changed, attrd writes in a current value immediately.
write_or_elect_attribute(a);
if (safe_str_eq(op, ATTRD_OP_UPDATE_DELAY)) {
return;
}
} else {
if (safe_str_eq(op, ATTRD_OP_UPDATE_DELAY)) {
crm_trace("Unchanged attribute %s with delay %dms (%s).(ATTRD_OP_UPDATE_DELAY)", a->id, dampen, dvalue);
return;
}
}
} else {
crm_warn("Update error (A positive number is necessary for delay parameter. attribute %s : %dms (%s))", a->id, dampen, dvalue);
return;
}
} else {
crm_warn("Update error (delay parameter is necessary for the update of the attribute %s)", a->id);
return;
}
}
if(host == NULL) {
GHashTableIter vIter;
g_hash_table_iter_init(&vIter, a->values);
crm_debug("Setting %s for all hosts to %s", attr, value);
xml_remove_prop(xml, F_ATTRD_HOST_ID);
while (g_hash_table_iter_next(&vIter, (gpointer *) & host, NULL)) {
attrd_peer_update(peer, xml, host, filter);
}
return;
}
v = attrd_lookup_or_create_value(a->values, host, xml);
if(filter
&& safe_str_neq(v->current, value)
&& safe_str_eq(host, attrd_cluster->uname)) {
xmlNode *sync = create_xml_node(NULL, __FUNCTION__);
crm_notice("%s[%s]: local value '%s' takes priority over '%s' from %s",
a->id, host, v->current, value, peer->uname);
crm_xml_add(sync, F_ATTRD_TASK, ATTRD_OP_SYNC_RESPONSE);
v = g_hash_table_lookup(a->values, host);
build_attribute_xml(sync, a->id, a->set, a->uuid, a->timeout_ms, a->user, a->is_private,
v->nodename, v->nodeid, v->current);
crm_xml_add_int(sync, F_ATTRD_WRITER, election_state(writer));
send_attrd_message(peer, sync);
free_xml(sync);
} else if(safe_str_neq(v->current, value)) {
crm_info("Setting %s[%s]: %s -> %s from %s", attr, host, v->current, value, peer->uname);
free(v->current);
if(value) {
v->current = strdup(value);
} else {
v->current = NULL;
}
changed = TRUE;
} else {
crm_trace("Unchanged %s[%s] from %s is %s", attr, host, peer->uname, value);
}
a->changed |= changed;
if(changed) {
if(a->timer) {
crm_trace("Delayed write out (%dms) for %s", a->timeout_ms, a->id);
mainloop_timer_start(a->timer);
} else {
write_or_elect_attribute(a);
}
}
/* this only involves cluster nodes. */
if(v->nodeid == 0 && (v->is_remote == FALSE)) {
if(crm_element_value_int(xml, F_ATTRD_HOST_ID, (int*)&v->nodeid) == 0) {
/* Create the name/id association */
crm_node_t *peer = crm_get_peer(v->nodeid, host);
crm_trace("We know %s's node id now: %s", peer->uname, peer->uuid);
if(election_state(writer) == election_won) {
write_attributes(FALSE, TRUE);
return;
}
}
}
}
/*!
* \brief Write a SIP pin through hole footprint.
*
* The pin/pad numbering scheme of the SIP package is: \n
* 1 \n
* 2 \n
* 3 \n
* 4 \n
*
* \return \c EXIT_FAILURE when errors were encountered,
* \c EXIT_SUCCESS when OK.
*/
int
sip_write_footprint ()
{
gdouble xmax;
gdouble xmin;
gdouble ymax;
gdouble ymin;
gdouble x_text;
gdouble y_text;
gint pin_number;
gchar *pin_pad_name = g_strdup ("");
gchar *pin_pad_flags = g_strdup ("");
gint i;
number_of_columns = 1;
/* Attempt to open a file with write permission. */
fp = fopen (footprint_filename, "w");
if (!fp)
{
g_log ("", G_LOG_LEVEL_WARNING,
_("could not open file for %s footprint: %s."),
footprint_type, footprint_filename);
fclose (fp);
return (EXIT_FAILURE);
}
/* Print a license if requested. */
if (license_in_footprint)
{
write_license ();
}
/* Determine (extreme) courtyard dimensions based on pin/pad
* properties */
xmin = multiplier *
(
(((pad_diameter > pad_length) ? pad_diameter : pad_length) / -2.0) - pad_solder_mask_clearance
);
xmax = multiplier *
(
(((pad_diameter > pad_length) ? pad_diameter : pad_length) / 2.0) + pad_solder_mask_clearance
);
ymin = multiplier *
(
(((-number_of_rows + 1) / 2.0) * pitch_y) -
(((pad_diameter > pad_width) ? pad_diameter : pad_width) / 2.0) -
pad_solder_mask_clearance
);
ymax = multiplier *
(
(((number_of_rows - 1 ) / 2.0) * pitch_y) +
(((pad_diameter > pad_width) ? pad_diameter : pad_width) / 2.0) +
pad_solder_mask_clearance
);
/* Determine (extreme) courtyard dimensions based on package
* properties */
if ((multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package)) < xmin)
{
xmin = (multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package)) > xmax)
{
xmax = (multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package));
}
if ((multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package)) < ymin)
{
ymin = (multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package)) > ymax)
{
ymax = (multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package));
}
/* If the user input is using even more real-estate then use it */
if (multiplier * (-courtyard_length / 2.0) < xmin)
{
xmin = multiplier * (-courtyard_length / 2.0);
}
if (multiplier * (courtyard_length / 2.0) > xmax)
{
xmax = multiplier * (courtyard_length / 2.0);
}
if (multiplier * (-courtyard_width / 2.0) < ymin)
{
ymin = multiplier * (-courtyard_width / 2.0);
}
if (multiplier * (courtyard_width / 2.0) > ymax)
{
ymax = multiplier * (courtyard_width / 2.0);
}
/* Write element header
* Guess for a place where to put the refdes text */
x_text = 0.0 ; /* already in mil/100 */
y_text = (ymin - 10000.0); /* already in mil/100 */
write_element_header (x_text, y_text);
/* Write pin and/or pad entities */
for (i = 0; (i < number_of_rows); i++)
{
pin_number = 1 + i;
write_pin
(
pin_number, /* pin number */
pin_pad_name, /* pin name */
0, /* x0 coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) +1 + i) * pitch_y), /* y0-coordinate */
multiplier * pad_diameter, /* width of the annulus ring (pad) */
multiplier * 2 * pad_clearance, /* clearance */
multiplier * (pad_diameter + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
multiplier * pin_drill_diameter, /* pin drill diameter */
(pin1_square && (pin_number == 1)) ? "square" : pin_pad_flags /* flags */
);
if (!strcmp (pad_shape, "rounded pad, elongated"))
{
if (!strcmp (pin_pad_flags, ""))
pin_pad_flags = g_strconcat (pin_pad_flags, "onsolder", NULL);
else
pin_pad_flags = g_strconcat (pin_pad_flags, ",onsolder", NULL);
write_pad
(
pin_number, /* pad number = pin_number */
pin_pad_name, /* pad name */
multiplier * (-pad_width + pad_length) / 2.0, /* x0 coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) + 1 + i) * pitch_y), /* y0-coordinate */
multiplier * (pad_width - pad_length) / 2.0, /* x1 coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) + 1 + i) * pitch_y), /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * 2 * pad_clearance, /* clearance */
multiplier * (pad_width + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
}
}
/* Write a package body on the silkscreen */
if (silkscreen_package_outline)
{
fprintf (fp, "# Write a package body on the silkscreen\n");
write_rectangle
(
multiplier * ((-package_body_length) / 2.0), /* xmin-coordinate */
multiplier * ((-package_body_width) / 2.0), /* ymin-coordinate */
multiplier * ((package_body_length) / 2.0), /* xmax-coordinate */
multiplier * ((package_body_width) / 2.0), /* ymax-coordiante */
multiplier * silkscreen_line_width
);
}
/* Write a pin #1 marker on the silkscreen */
if (silkscreen_indicate_1)
{
fprintf (fp, "# Write a pin 1 marker on the silkscreen\n");
/* Write a marker around pin #1 inside the package outline */
write_element_line
(
multiplier * (-package_body_length / 2.0), /* x0-coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) + 1.5) * pitch_y), /* y0-coordinate */
multiplier * (package_body_length / 2.0), /* x1-coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) + 1.5) * pitch_y), /* y1-coordinate */
multiplier * (silkscreen_line_width)
);
/* Write a triangle shaped marker between package outline and maximum used real estate */
if (xmax > ((multiplier * package_body_length) / 2))
{
write_element_line
(
multiplier * (-package_body_length / 2.0), /* x0-coordinate */
multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y), /* y0-coordinate */
(multiplier * (-package_body_length / 2.0)) - 2500 , /* x1-coordinate */
(multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y)) - 1250, /* y1-coordinate */
multiplier * (silkscreen_line_width)
);
write_element_line
(
multiplier * (-package_body_length / 2.0), /* x0-coordinate */
multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y), /* y0-coordinate */
(multiplier * (-package_body_length / 2.0)) - 2500 , /* x1-coordinate */
(multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y)) + 1250, /* y1-coordinate */
multiplier * (silkscreen_line_width)
);
write_element_line
(
(multiplier * (-package_body_length / 2.0)) - 2500 , /* x0-coordinate */
(multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y)) - 1250, /* y0-coordinate */
(multiplier * (-package_body_length / 2.0)) - 2500 , /* x1-coordinate */
(multiplier * (((-number_of_rows + 1) / 2.0) * pitch_y)) + 1250, /* y1-coordinate */
multiplier * (silkscreen_line_width)
);
}
}
/* Write a courtyard on the silkscreen */
if (courtyard)
{
fprintf (fp, "# Write a courtyard on the silkscreen\n");
write_rectangle
(
xmin, /* already in mil/100 */
ymin, /* already in mil/100 */
xmax, /* already in mil/100 */
ymax, /* already in mil/100 */
multiplier * courtyard_line_width
);
}
/* Write attributes to the footprint file. */
if (attributes_in_footprint)
{
write_attributes ();
}
/* Finishing touch. */
fprintf (fp, "\n");
fprintf (fp, ")\n");
fclose (fp);
/* We are ready creating a footprint. */
if (verbose)
{
g_log ("", G_LOG_LEVEL_INFO,
_("wrote a footprint for a %s package: %s."),
footprint_type,
footprint_filename);
}
return (EXIT_SUCCESS);
}
void
attrd_peer_update(crm_node_t *peer, xmlNode *xml, const char *host, bool filter)
{
bool changed = FALSE;
attribute_value_t *v = NULL;
const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);
const char *value = crm_element_value(xml, F_ATTRD_VALUE);
attribute_t *a = g_hash_table_lookup(attributes, attr);
if(a == NULL) {
a = create_attribute(xml);
}
if(host == NULL) {
GHashTableIter vIter;
g_hash_table_iter_init(&vIter, a->values);
crm_debug("Setting %s for all hosts to %s", attr, value);
xml_remove_prop(xml, F_ATTRD_HOST_ID);
while (g_hash_table_iter_next(&vIter, (gpointer *) & host, NULL)) {
attrd_peer_update(peer, xml, host, filter);
}
return;
}
v = attrd_lookup_or_create_value(a->values, host, xml);
if(filter
&& safe_str_neq(v->current, value)
&& safe_str_eq(host, attrd_cluster->uname)) {
xmlNode *sync = create_xml_node(NULL, __FUNCTION__);
crm_notice("%s[%s]: local value '%s' takes priority over '%s' from %s",
a->id, host, v->current, value, peer->uname);
crm_xml_add(sync, F_ATTRD_TASK, ATTRD_OP_SYNC_RESPONSE);
v = g_hash_table_lookup(a->values, host);
build_attribute_xml(sync, a->id, a->set, a->uuid, a->timeout_ms, a->user, a->is_private,
v->nodename, v->nodeid, v->current);
crm_xml_add_int(sync, F_ATTRD_WRITER, election_state(writer));
send_attrd_message(peer, sync);
free_xml(sync);
} else if(safe_str_neq(v->current, value)) {
crm_info("Setting %s[%s]: %s -> %s from %s", attr, host, v->current, value, peer->uname);
free(v->current);
if(value) {
v->current = strdup(value);
} else {
v->current = NULL;
}
changed = TRUE;
} else {
crm_trace("Unchanged %s[%s] from %s is %s", attr, host, peer->uname, value);
}
a->changed |= changed;
if(changed) {
if(a->timer) {
crm_trace("Delayed write out (%dms) for %s", a->timeout_ms, a->id);
mainloop_timer_start(a->timer);
} else {
write_or_elect_attribute(a);
}
}
/* this only involves cluster nodes. */
if(v->nodeid == 0 && (v->is_remote == FALSE)) {
if(crm_element_value_int(xml, F_ATTRD_HOST_ID, (int*)&v->nodeid) == 0) {
/* Create the name/id association */
crm_node_t *peer = crm_get_peer(v->nodeid, host);
crm_trace("We know %s's node id now: %s", peer->uname, peer->uuid);
if(election_state(writer) == election_won) {
write_attributes(FALSE, TRUE);
return;
}
}
}
}
//++++++++++++++++++++++++++++++++++
void view_new_search::write(){
//
write_attributes();
}
/*!
\brief Writes feature on level 1 (OGR interface)
\param Map pointer to Map_info structure
\param type feature type
\param points pointer to line_pnts structure (feature geometry)
\param cats pointer to line_cats structure (feature categories)
\return feature offset into file
\return -1 on error
*/
off_t V1_write_line_ogr(struct Map_info *Map, int type,
const struct line_pnts *points,
const struct line_cats *cats)
{
int i, cat, ret;
struct field_info *Fi;
struct Format_info_ogr *fInfo;
OGRGeometryH Ogr_geometry;
OGRFeatureH Ogr_feature;
OGRFeatureDefnH Ogr_featuredefn;
OGRwkbGeometryType Ogr_geom_type;
if (!Map->fInfo.ogr.layer) {
if (V2_open_new_ogr(Map, type) < 0)
return -1;
}
cat = -1; /* no attributes to be written */
if (cats->n_cats > 0) {
/* check for attributes */
Fi = Vect_get_dblink(Map, 0);
if (Fi) {
if (!Vect_cat_get(cats, Fi->number, &cat))
G_warning(_("No category defined for layer %d"), Fi->number);
if (cats->n_cats > 1) {
G_warning(_("Feature has more categories, using "
"category %d (from layer %d)"),
cat, cats->field[0]);
}
}
}
fInfo = &(Map->fInfo.ogr);
Ogr_featuredefn = OGR_L_GetLayerDefn(fInfo->layer);
Ogr_geom_type = OGR_FD_GetGeomType(Ogr_featuredefn);
/* determine matching OGR feature geometry type */
/* NOTE: centroids are not supported in OGR,
* pseudotopo holds virtual centroids */
/* NOTE: boundaries are not supported in OGR,
* pseudotopo treats polygons as boundaries */
if (type & (GV_POINT | GV_KERNEL)) {
if (Ogr_geom_type != wkbPoint &&
Ogr_geom_type != wkbPoint25D) {
G_warning(_("Feature is not a point. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPoint);
}
else if (type & GV_LINE) {
if (Ogr_geom_type != wkbLineString &&
Ogr_geom_type != wkbLineString25D) {
G_warning(_("Feature is not a line. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbLineString);
}
else if (type & GV_BOUNDARY) {
if (Ogr_geom_type != wkbPolygon) {
G_warning(_("Feature is not a polygon. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPolygon);
}
else if (type & GV_FACE) {
if (Ogr_geom_type != wkbPolygon25D) {
G_warning(_("Feature is not a face. Skipping."));
return -1;
}
Ogr_geometry = OGR_G_CreateGeometry(wkbPolygon25D);
}
else {
G_warning(_("Unsupported feature type (%d)"), type);
return -1;
}
G_debug(3, "V1_write_line_ogr(): type = %d", type);
if (Ogr_geom_type == wkbPolygon || Ogr_geom_type == wkbPolygon25D) {
/* create exterior ring */
OGRGeometryH Ogr_ring;
int npoints;
npoints = points->n_points - 1;
Ogr_ring = OGR_G_CreateGeometry(wkbLinearRing);
if (points->x[0] != points->x[npoints] ||
points->y[0] != points->y[npoints] ||
points->z[0] != points->z[npoints]) {
G_warning(_("Boundary is not closed. Skipping."));
return -1;
}
/* add points */
for (i = 0; i < points->n_points; i++) {
OGR_G_AddPoint(Ogr_ring, points->x[i], points->y[i],
points->z[i]);
}
OGR_G_AddGeometry(Ogr_geometry, Ogr_ring);
}
else {
for (i = 0; i < points->n_points; i++) {
OGR_G_AddPoint(Ogr_geometry, points->x[i], points->y[i],
points->z[i]);
}
}
G_debug(4, " n_points = %d", points->n_points);
/* create feature & set geometry */
Ogr_feature = OGR_F_Create(Ogr_featuredefn);
OGR_F_SetGeometry(Ogr_feature, Ogr_geometry);
/* write attributes */
if (cat > -1 && fInfo->dbdriver) {
write_attributes(fInfo->dbdriver,
cat, Fi, fInfo->layer, Ogr_feature);
G_free(Fi);
}
/* write feature into layer */
ret = OGR_L_CreateFeature(fInfo->layer, Ogr_feature);
/* update offset array */
if (fInfo->offset_num >= fInfo->offset_alloc) {
fInfo->offset_alloc += 1000;
fInfo->offset = (int *) G_realloc(fInfo->offset,
fInfo->offset_alloc *
sizeof(int));
}
/* how to deal with OGRNullFID ? */
fInfo->offset[fInfo->offset_num] = (int)OGR_F_GetFID(Ogr_feature);
/* destroy */
OGR_G_DestroyGeometry(Ogr_geometry);
OGR_F_Destroy(Ogr_feature);
if (ret != OGRERR_NONE)
return -1;
return fInfo->offset_num++;
}
void
attrd_client_message(crm_client_t *client, xmlNode *xml)
{
bool broadcast = FALSE;
static int plus_plus_len = 5;
const char *op = crm_element_value(xml, F_ATTRD_TASK);
if(safe_str_eq(op, "peer-remove")) {
const char *host = crm_element_value(xml, F_ATTRD_HOST);
crm_info("Client %s is requesting all values for %s be removed", client->name, host);
if(host) {
broadcast = TRUE;
}
} else if(safe_str_eq(op, "update")) {
attribute_t *a = NULL;
attribute_value_t *v = NULL;
char *key = crm_element_value_copy(xml, F_ATTRD_KEY);
char *set = crm_element_value_copy(xml, F_ATTRD_SET);
char *host = crm_element_value_copy(xml, F_ATTRD_HOST);
const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);
const char *value = crm_element_value(xml, F_ATTRD_VALUE);
const char *regex = crm_element_value(xml, F_ATTRD_REGEX);
if(attr == NULL && regex) {
GHashTableIter aIter;
regex_t *r_patt = calloc(1, sizeof(regex_t));
crm_debug("Setting %s to %s", regex, value);
if (regcomp(r_patt, regex, REG_EXTENDED)) {
crm_err("Bad regex '%s' for update", regex);
} else {
g_hash_table_iter_init(&aIter, attributes);
while (g_hash_table_iter_next(&aIter, (gpointer *) & attr, NULL)) {
int status = regexec(r_patt, attr, 0, NULL, 0);
if(status == 0) {
crm_trace("Matched %s with %s", attr, regex);
crm_xml_add(xml, F_ATTRD_ATTRIBUTE, attr);
send_attrd_message(NULL, xml);
}
}
}
free(key);
free(set);
free(host);
regfree(r_patt);
free(r_patt);
return;
} else if(host == NULL) {
crm_trace("Inferring host");
host = strdup(attrd_cluster->uname);
crm_xml_add(xml, F_ATTRD_HOST, host);
crm_xml_add_int(xml, F_ATTRD_HOST_ID, attrd_cluster->nodeid);
}
a = g_hash_table_lookup(attributes, attr);
if (value) {
int offset = 1;
int int_value = 0;
int value_len = strlen(value);
if (value_len < (plus_plus_len + 2)
|| value[plus_plus_len] != '+'
|| (value[plus_plus_len + 1] != '+' && value[plus_plus_len + 1] != '=')) {
goto send;
}
if(a) {
v = g_hash_table_lookup(a->values, host);
}
if(v) {
int_value = char2score(v->current);
}
if (value[plus_plus_len + 1] != '+') {
const char *offset_s = value + (plus_plus_len + 2);
offset = char2score(offset_s);
}
int_value += offset;
if (int_value > INFINITY) {
int_value = INFINITY;
}
crm_info("Expanded %s=%s to %d", attr, value, int_value);
crm_xml_add_int(xml, F_ATTRD_VALUE, int_value);
}
send:
if(peer_writer == NULL && election_state(writer) != election_in_progress) {
crm_info("Starting an election to determine the writer");
election_vote(writer);
}
crm_debug("Broadcasting %s[%s] = %s%s", attr, host, value, election_state(writer) == election_won?" (writer)":"");
broadcast = TRUE;
free(key);
free(set);
free(host);
} else if(safe_str_eq(op, "refresh")) {
crm_info("Updating all attributes");
write_attributes(TRUE, FALSE);
}
if(broadcast) {
/* Ends up at attrd_peer_message() */
send_attrd_message(NULL, xml);
}
}
void
attrd_client_message(crm_client_t *client, xmlNode *xml)
{
bool broadcast = FALSE;
static int plus_plus_len = 5;
const char *op = crm_element_value(xml, F_ATTRD_TASK);
if(safe_str_eq(op, "peer-remove")) {
const char *host = crm_element_value(xml, F_ATTRD_HOST);
crm_info("Client %s is requesting all values for %s be removed", client->name, host);
if(host) {
broadcast = TRUE;
}
} else if(safe_str_eq(op, "update")) {
attribute_t *a = NULL;
attribute_value_t *v = NULL;
char *key = crm_element_value_copy(xml, F_ATTRD_KEY);
char *set = crm_element_value_copy(xml, F_ATTRD_SET);
char *host = crm_element_value_copy(xml, F_ATTRD_HOST);
const char *attr = crm_element_value(xml, F_ATTRD_ATTRIBUTE);
const char *value = crm_element_value(xml, F_ATTRD_VALUE);
a = g_hash_table_lookup(attributes, attr);
if(host == NULL) {
crm_trace("Inferring host");
host = strdup(attrd_cluster->uname);
crm_xml_add(xml, F_ATTRD_HOST, host);
crm_xml_add_int(xml, F_ATTRD_HOST_ID, attrd_cluster->nodeid);
}
if (value) {
int offset = 1;
int int_value = 0;
int value_len = strlen(value);
if (value_len < (plus_plus_len + 2)
|| value[plus_plus_len] != '+'
|| (value[plus_plus_len + 1] != '+' && value[plus_plus_len + 1] != '=')) {
goto send;
}
if(a) {
v = g_hash_table_lookup(a->values, host);
}
if(v) {
int_value = char2score(v->current);
}
if (value[plus_plus_len + 1] != '+') {
const char *offset_s = value + (plus_plus_len + 2);
offset = char2score(offset_s);
}
int_value += offset;
if (int_value > INFINITY) {
int_value = INFINITY;
}
crm_info("Expanded %s=%s to %d", attr, value, int_value);
crm_xml_add_int(xml, F_ATTRD_VALUE, int_value);
}
send:
if(peer_writer == NULL && election_state(writer) != election_in_progress) {
crm_info("Starting an election to determine the writer");
election_vote(writer);
}
crm_debug("Broadcasting %s[%s] = %s%s", attr, host, value, election_state(writer) == election_won?" (writer)":"");
broadcast = TRUE;
free(key);
free(set);
free(host);
} else if(safe_str_eq(op, "refresh")) {
crm_info("Updating all attributes");
write_attributes(TRUE, FALSE);
}
if(broadcast) {
send_attrd_message(NULL, xml);
}
}
/*!
* \brief Write a footprint for a PGA package.
*
* \return \c EXIT_FAILURE when errors were encountered,
* \c EXIT_SUCCESS when OK.
*/
int
pga_write_footprint ()
{
gdouble xmax;
gdouble xmin;
gdouble ymax;
gdouble ymin;
gdouble x_text;
gdouble y_text;
gdouble dx;
gint pin_number;
gchar *pin_pad_name = g_strdup ("");
gchar *pin_pad_flags = g_strdup ("");
gint i;
gint j;
/* Attempt to open a file with write permission. */
fp = fopen (footprint_filename, "w");
if (!fp)
{
g_log ("", G_LOG_LEVEL_WARNING,
_("could not open file for %s footprint: %s."),
footprint_type, footprint_filename);
fclose (fp);
return (EXIT_FAILURE);
}
/* Print a license if requested. */
if (license_in_footprint)
{
write_license ();
}
/* Determine (extreme) courtyard dimensions based on pin/pad
* properties */
xmin = multiplier *
(
((-pitch_x * number_of_columns) / 2.0) -
(pad_diameter / 2.0) -
pad_solder_mask_clearance
);
xmax = multiplier *
(
((pitch_x * number_of_columns) / 2.0) +
(pad_diameter / 2.0) +
pad_solder_mask_clearance
);
ymin = multiplier *
(
((-pitch_y * number_of_rows) / 2.0) -
(pad_diameter / 2.0) -
pad_solder_mask_clearance
);
ymax = multiplier *
(
((pitch_y * number_of_rows) / 2.0) +
(pad_diameter / 2.0) +
pad_solder_mask_clearance
);
/* Determine (extreme) courtyard dimensions based on package
* properties */
if ((multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package)) < xmin)
xmin = (multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package));
if ((multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package)) > xmax)
xmax = (multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package));
if ((multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package)) < ymin)
ymin = (multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package));
if ((multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package)) > ymax)
ymax = (multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package));
/* If the user input is using even more real-estate then use it */
if (multiplier * (-courtyard_length / 2.0) < xmin)
xmin = multiplier * (-courtyard_length / 2.0);
if (multiplier * (courtyard_length / 2.0) > xmax)
xmax = multiplier * (courtyard_length / 2.0);
if (multiplier * (-courtyard_width / 2.0) < ymin)
ymin = multiplier * (-courtyard_width / 2.0);
if (multiplier * (courtyard_width / 2.0) > ymax)
ymax = multiplier * (courtyard_width / 2.0);
/* Write element header
* Guess for a place where to put the refdes text */
x_text = 0.0 ; /* already in mil/100 */
y_text = (ymin - 10000.0); /* already in mil/100 */
write_element_header (x_text, y_text);
/* Write pin and/or pad entities */
pin_number = 1;
for (i = 0; (i < number_of_rows); i++)
/* one row at a time [A .. ZZ ..] etc.
* where i is one or more letters of the alphabet,
* excluding "I", "O", "Q", "S" and "Z" */
{
for (j = 0; (j < number_of_columns); j++)
/* all columns of a row [1 .. n]
* where j is a member of the positive Natural numbers (N) */
{
if (pin1_square && (pin_number == 1))
pin_pad_flags = g_strdup ("square");
else
pin_pad_flags = g_strdup ("");
pin_pad_name = g_strdup_printf ("%s%d", (row_letters[i]), (j + 1));
if (get_pin_pad_exception (pin_pad_name))
{
write_pin
(
pin_number, /* pin number */
pin_pad_name, /* pin name */
multiplier * ((((- number_of_columns -1) / 2.0) + 1 + j) * pitch_x), /* x0 coordinate */
multiplier * ((((-number_of_rows - 1) / 2.0) + 1 + i) * pitch_y), /* y0-coordinate */
multiplier * pad_diameter, /* width of the annulus ring (pad) */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_diameter + pad_solder_mask_clearance), /* solder mask clearance */
multiplier * pin_drill_diameter, /* pin drill diameter */
pin_pad_flags /* flags */
);
}
pin_number++;
}
}
/* Write a package body on the silkscreen */
if (silkscreen_package_outline)
{
fprintf (fp, "# Write a package body on the silkscreen\n");
write_rectangle
(
multiplier * (-package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * silkscreen_line_width
);
}
/* Write a pin #1 marker on the silkscreen */
if (silkscreen_indicate_1)
{
fprintf (fp, "# Write a pin 1 marker on the silkscreen\n");
for (dx = 0.0; dx < (pitch_x / 2.0); dx = dx + silkscreen_line_width)
{
write_element_line
(
multiplier * (-package_body_length / 2.0),
multiplier * ((-package_body_width / 2.0) + dx),
multiplier * ((-package_body_length / 2.0) + dx),
multiplier * (-package_body_width / 2.0),
multiplier * (silkscreen_line_width)
);
}
}
/* Write a courtyard on the silkscreen */
if (courtyard)
{
fprintf (fp, "# Write a courtyard on the silkscreen\n");
write_rectangle
(
xmin, /* already in mil/100 */
ymin, /* already in mil/100 */
xmax, /* already in mil/100 */
ymax, /* already in mil/100 */
multiplier * courtyard_line_width
);
}
/* Write attributes to the footprint file. */
if (attributes_in_footprint)
{
write_attributes ();
}
/* Finishing touch. */
fprintf (fp, "\n");
fprintf (fp, ")\n");
fclose (fp);
/* We are ready creating a footprint. */
if (verbose)
{
g_log ("", G_LOG_LEVEL_INFO,
_("wrote a footprint for a %s package: %s."),
footprint_type,
footprint_filename);
}
return (EXIT_SUCCESS);
}
/* Encodes the bag into a SafeContents structure, and puts the output in
* the given datum. Enc is set to non zero if the data are encrypted;
*/
int
_pkcs12_encode_safe_contents (gnutls_pkcs12_bag_t bag, ASN1_TYPE * contents,
int *enc)
{
ASN1_TYPE c2 = ASN1_TYPE_EMPTY;
int result;
int i;
const char *oid;
if (bag->element[0].type == GNUTLS_BAG_ENCRYPTED && enc)
{
*enc = 1;
return 0; /* ENCRYPTED BAG, do nothing. */
}
else if (enc)
*enc = 0;
/* Step 1. Create the SEQUENCE.
*/
if ((result = asn1_create_element
(_gnutls_get_pkix (), "PKIX1.pkcs-12-SafeContents",
&c2)) != ASN1_SUCCESS)
{
gnutls_assert ();
result = _gnutls_asn2err (result);
goto cleanup;
}
for (i = 0; i < bag->bag_elements; i++)
{
oid = bag_to_oid (bag->element[i].type);
if (oid == NULL)
{
gnutls_assert ();
continue;
}
result = asn1_write_value (c2, "", "NEW", 1);
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
result = _gnutls_asn2err (result);
goto cleanup;
}
/* Copy the bag type.
*/
result = asn1_write_value (c2, "?LAST.bagId", oid, 1);
if (result != ASN1_SUCCESS)
{
gnutls_assert ();
result = _gnutls_asn2err (result);
goto cleanup;
}
/* Set empty attributes
*/
result = write_attributes (bag, i, c2, "?LAST.bagAttributes");
if (result < 0)
{
gnutls_assert ();
goto cleanup;
}
/* Copy the Bag Value
*/
if (bag->element[i].type == GNUTLS_BAG_CERTIFICATE ||
bag->element[i].type == GNUTLS_BAG_SECRET ||
bag->element[i].type == GNUTLS_BAG_CRL)
{
gnutls_datum_t tmp;
/* in that case encode it to a CertBag or
* a CrlBag.
*/
result =
_pkcs12_encode_crt_bag (bag->element[i].type,
&bag->element[i].data, &tmp);
if (result < 0)
{
gnutls_assert ();
goto cleanup;
}
result = _gnutls_x509_write_value (c2, "?LAST.bagValue", &tmp, 0);
_gnutls_free_datum (&tmp);
}
else
{
result = _gnutls_x509_write_value (c2, "?LAST.bagValue",
&bag->element[i].data, 0);
}
if (result < 0)
{
gnutls_assert ();
goto cleanup;
}
}
/* Encode the data and copy them into the datum
*/
*contents = c2;
return 0;
cleanup:
if (c2)
asn1_delete_structure (&c2);
return result;
}
/*!
* \brief Write a TH footprint for a DIOAD package.
*
* \return \c EXIT_FAILURE when errors were encountered,
* \c EXIT_SUCCESS when OK.
*/
int
dioad_write_footprint ()
{
gdouble xmax;
gdouble xmin;
gdouble ymax;
gdouble ymin;
gdouble x_text;
gdouble y_text;
gdouble dx;
gchar *pin_pad_flags = g_strdup ("");
/* Attempt to open a file with write permission. */
fp = fopen (footprint_filename, "w");
if (!fp)
{
g_log ("", G_LOG_LEVEL_WARNING,
(_("could not open file for %s footprint: %s.")),
footprint_type, footprint_filename);
fclose (fp);
return (EXIT_FAILURE);
}
/* Print a license if requested. */
if (license_in_footprint)
{
write_license ();
}
/* Determine (extreme) courtyard dimensions based on pin/pad
* properties */
if (pad_shapes_type == ROUND_ELONGATED)
{
xmin = multiplier *
(
(-pitch_x / 2.0) -
(pad_length / 2.0) -
pad_solder_mask_clearance
);
xmax = multiplier *
(
(pitch_x / 2.0) +
(pad_length / 2.0) +
pad_solder_mask_clearance
);
ymin = multiplier *
(
(-pitch_y / 2.0) -
(pad_width / 2.0) -
pad_solder_mask_clearance
);
ymax = multiplier *
(
(pitch_y / 2.0) +
(pad_width / 2.0) +
pad_solder_mask_clearance
);
}
else
{
xmin = multiplier *
(
(-pitch_x / 2.0) -
(pad_diameter / 2.0) -
pad_solder_mask_clearance
);
xmax = multiplier *
(
(pitch_x / 2.0) +
(pad_diameter / 2.0) +
pad_solder_mask_clearance
);
ymin = multiplier *
(
(-pitch_y / 2.0) -
(pad_diameter / 2.0) -
pad_solder_mask_clearance
);
ymax = multiplier *
(
(pitch_y / 2.0) +
(pad_diameter / 2.0) +
pad_solder_mask_clearance
);
}
/* Determine (extreme) courtyard dimensions based on package
* properties */
if ((multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package)) < xmin)
{
xmin = (multiplier * ((-package_body_length / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package)) > xmax)
{
xmax = (multiplier * ((package_body_length / 2.0) + courtyard_clearance_with_package));
}
if ((multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package)) < ymin)
{
ymin = (multiplier * ((-package_body_width / 2.0) - courtyard_clearance_with_package));
}
if ((multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package)) > ymax)
{
ymax = (multiplier * ((package_body_width / 2.0) + courtyard_clearance_with_package));
}
/* If the user input is using even more real-estate then use it */
if (multiplier * (-courtyard_length / 2.0) < xmin)
{
xmin = multiplier * (-courtyard_length / 2.0);
}
if (multiplier * (courtyard_length / 2.0) > xmax)
{
xmax = multiplier * (courtyard_length / 2.0);
}
if (multiplier * (-courtyard_width / 2.0) < ymin)
{
ymin = multiplier * (-courtyard_width / 2.0);
}
if (multiplier * (courtyard_width / 2.0) > ymax)
{
ymax = multiplier * (courtyard_width / 2.0);
}
/* Write element header
* Guess for a place where to put the refdes text */
x_text = 0.0 ; /* already in mil/100 */
y_text = (ymin - 10000.0); /* already in mil/100 */
write_element_header (x_text, y_text);
/* Write pin and/or pad entities */
if (pad_shapes_type == SQUARE)
{
pin_pad_flags = g_strdup ("square");
}
else if (pad_shapes_type == OCTAGONAL)
{
pin_pad_flags = g_strdup ("octagon");
}
else
{
pin_pad_flags = g_strdup ("");
}
write_pin
(
2, /* pin number */
"A", /* pin name */
multiplier * ((pitch_x + pad_diameter) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * pad_diameter, /* width of the annulus ring (pad) */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_diameter + pad_solder_mask_clearance), /* solder mask clearance */
multiplier * pin_drill_diameter, /* pin drill diameter */
pin_pad_flags /* flags */
);
/* Overrule previous settings in favour of pin 1 square setting */
if (pin1_square)
{
pin_pad_flags = g_strdup ("square");
}
write_pin
(
1, /* pin number */
"C", /* pin name */
multiplier * ((-pitch_x - pad_diameter) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * pad_diameter, /* width of the annulus ring (pad) */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_diameter + pad_solder_mask_clearance), /* solder mask clearance */
multiplier * pin_drill_diameter, /* pin drill diameter */
pin_pad_flags /* flags */
);
if (pad_shapes_type == ROUND_ELONGATED)
{
/* Add pads on component side */
pin_pad_flags = g_strdup ("");
write_pad
(
1, /* pad number */
"C", /* pad name */
multiplier * ((-pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((-pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_width + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
write_pad
(
2, /* pad number */
"A", /* pad name */
multiplier * ((pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * ((pad_length > pad_width ? pad_width : pad_length) + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
/* Add pads on solder side */
pin_pad_flags = g_strdup ("onsolder");
write_pad
(
1, /* pad number */
"C", /* pad name */
multiplier * ((-pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((-pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * (pad_width + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
write_pad
(
2, /* pad number */
"A", /* pad name */
multiplier * ((pitch_x - pad_length + pad_width) / 2.0), /* x0 coordinate */
0, /* y0-coordinate */
multiplier * ((pitch_x + pad_length - pad_width) / 2.0), /* x1 coordinate */
0, /* y1-coordinate */
multiplier * pad_width, /* width of the pad */
multiplier * pad_clearance, /* clearance */
multiplier * ((pad_length > pad_width ? pad_width : pad_length) + (2 * pad_solder_mask_clearance)), /* solder mask clearance */
pin_pad_flags /* flags */
);
}
/* Write package body on silkscreen */
if (silkscreen_package_outline)
{
fprintf (fp, (_("# Write a package body on the silkscreen\n")));
write_rectangle
(
multiplier * (-package_body_length / 2.0),
multiplier * (-package_body_width / 2.0),
multiplier * (package_body_length / 2.0),
multiplier * (package_body_width / 2.0),
multiplier * silkscreen_line_width
);
/* Now draw some leads if available real estate allows for it. */
if (package_body_length < ((pitch_x - pad_diameter - pad_solder_mask_clearance) / 2.0) - silkscreen_line_width)
{
write_element_line
(
multiplier * (package_body_length / 2.0),
0,
multiplier * (((pitch_x - pad_diameter - pad_solder_mask_clearance) / 2.0) - silkscreen_line_width),
0,
multiplier * silkscreen_line_width
);
write_element_line
(
multiplier * (-package_body_length / 2.0),
0,
multiplier * (((-pitch_x + pad_diameter + pad_solder_mask_clearance) / 2.0) + silkscreen_line_width),
0,
multiplier * silkscreen_line_width
);
}
}
/* Write a pin #1 marker on the silkscreen */
if (silkscreen_indicate_1)
{
for (dx = 0.0; dx = (3.0 * silkscreen_line_width); dx = dx + silkscreen_line_width)
{
write_element_line
(
multiplier * ((-package_body_length / 2.0) + dx),
multiplier * (package_body_width / 2.0) ,
multiplier * ((-package_body_length / 2.0) + dx),
multiplier * (-package_body_width / 2.0),
multiplier * silkscreen_line_width
);
}
}
/* Write a courtyard on the silkscreen */
if (courtyard)
{
fprintf (fp, (_("# Write a courtyard on the silkscreen\n")));
write_rectangle
(
xmin, /* already in mil/100 */
ymin, /* already in mil/100 */
xmax, /* already in mil/100 */
ymax, /* already in mil/100 */
multiplier * courtyard_line_width
);
}
/* Write attributes to the footprint file. */
if (attributes_in_footprint)
{
write_attributes ();
}
/* Finishing touch. */
fprintf (fp, "\n");
fprintf (fp, ")\n");
fclose (fp);
/* We are ready creating a footprint. */
if (verbose)
{
g_log ("", G_LOG_LEVEL_INFO,
(_("wrote a footprint for a %s package: %s.")),
footprint_type,
footprint_filename);
}
return (EXIT_SUCCESS);
}