예제 #1
0
static void
add_connection_point (ShapeRenderer *renderer, 
                      Point *point, gboolean design_connection, 
                      gboolean main) 
{
  xmlNodePtr node;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
  
  /* Use connection points, drop the auto ones */
  if(design_connection && !renderer->design_connection) {
	  renderer->design_connection = design_connection;
	  node = renderer->connection_root->parent;
	  xmlUnlinkNode(renderer->connection_root);
	  xmlFree(renderer->connection_root);
	  xmlNewChild(node, NULL, (const xmlChar *)"connections", NULL);
  }
  if(!design_connection && renderer->design_connection)
  	return;
  
  node = xmlNewChild(renderer->connection_root, NULL, (const xmlChar *)"point", NULL);
  g_ascii_formatd(buf, sizeof(buf), "%g", point->x);
  xmlSetProp(node, (const xmlChar *)"x", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf), "%g", point->y);
  xmlSetProp(node, (const xmlChar *)"y", (xmlChar *) buf);
  if (main) {
	  xmlSetProp(node, (const xmlChar *)"main", (xmlChar *)"yes");
  }
  
}
예제 #2
0
파일: dxf-export.c 프로젝트: GNOME/dia
static void
draw_string(DiaRenderer *self,
	    const char *text,
	    Point *pos, Alignment alignment,
	    Color *colour)
{
    DxfRenderer *renderer = DXF_RENDERER(self);
    gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

    fprintf(renderer->file, "  0\nTEXT\n");
    fprintf(renderer->file, "  8\n%s\n", renderer->layername);
    fprintf(renderer->file, "  6\n%s\n", renderer->lcurrent.style);
    fprintf(renderer->file, " 10\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", pos->x));
    fprintf(renderer->file, " 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (-1)*pos->y));
    fprintf(renderer->file, " 40\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", renderer->tcurrent.font_height)); /* Text height */
    fprintf(renderer->file, " 50\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", 0.0)); /* Text rotation */
    switch(alignment) {
    case ALIGN_LEFT :
	fprintf(renderer->file, " 72\n%d\n", 0);
        break;
    case ALIGN_RIGHT :
   	fprintf(renderer->file, " 72\n%d\n", 2);
        break;
    case ALIGN_CENTER :
    default:
   	fprintf(renderer->file, " 72\n%d\n", 1);
        break;
    }
    fprintf(renderer->file, "  7\n%s\n", "0"); /* Text style */
    fprintf(renderer->file, "  1\n%s\n", text);
    fprintf(renderer->file, " 39\n%d\n", (int)(MAGIC_THICKNESS_FACTOR*renderer->lcurrent.width)); /* Thickness */
    fprintf(renderer->file, " 62\n%d\n", dxf_color(colour));
}
예제 #3
0
파일: shape-export.c 프로젝트: UIKit0/dia
/* complete overwrite, necessary code duplication */
static void
draw_polygon(DiaRenderer *self, 
	      Point *points, int num_points, 
	      Color *line_colour)
{
  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
  int i;
  xmlNodePtr node;
  GString *str;
  Point center;
  gchar px_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar py_buf[G_ASCII_DTOSTR_BUF_SIZE];

  node = xmlNewChild(renderer->root, renderer->svg_name_space, (const xmlChar *)"polygon", NULL);
  
  xmlSetProp(node, (const xmlChar *)"style", 
             (xmlChar *) DIA_SVG_RENDERER_GET_CLASS(renderer)->get_draw_style(renderer, line_colour));

  str = g_string_new(NULL);
  for (i = 0; i < num_points; i++) {
    g_string_append_printf(str, "%s,%s ",
			   g_ascii_formatd(px_buf, sizeof(px_buf), "%g", points[i].x),
			   g_ascii_formatd(py_buf, sizeof(py_buf), "%g", points[i].y) );
    add_connection_point(SHAPE_RENDERER(self), &points[i], FALSE, FALSE);
  }
  for(i = 1; i < num_points; i++) {
    center.x = (points[i].x + points[i-1].x)/2;
    center.y = (points[i].y + points[i-1].y)/2;
    add_connection_point(SHAPE_RENDERER(self), &center, FALSE, FALSE);
  }
  xmlSetProp(node, (const xmlChar *)"points", (xmlChar *) str->str);
  g_string_free(str, TRUE);
}
예제 #4
0
파일: hb-misc.c 프로젝트: maxiwell/homebank
void hb_strfnum(gchar *outstr, gint outlen, gdouble value, guint32 kcur, gboolean minor)
{
gchar formatd_buf[outlen];
Currency *cur;
gdouble monval;

	if(minor == FALSE)
	{
		cur = hb_strfmon_check(outstr, kcur);
		if(cur != NULL)
		{
			monval = hb_amount_round(value, cur->frac_digits);
			g_ascii_formatd(formatd_buf, outlen, "%.2f", monval);
			hb_str_formatd(outstr, outlen, formatd_buf, cur, TRUE);
		}
	}
	else
	{
		cur = &PREFS->minor_cur;
		monval = hb_amount_to_euro(value);
		g_ascii_formatd(formatd_buf, outlen, "%.2f", monval);
		hb_str_formatd(outstr, outlen, formatd_buf, cur, TRUE);
	}

	
}
예제 #5
0
파일: dxf-export.c 프로젝트: GNOME/dia
static void
draw_arc(DiaRenderer *self,
	 Point *center,
	 real width, real height,
	 real angle1, real angle2,
	 Color *colour)
{
    DxfRenderer *renderer = DXF_RENDERER(self);
    gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
    /* DXF arcs are preferably counter-clockwise, so we might need to swap angles
     * According to my reading of the specs header section group code 70 might allow
     * clockwise arcs with $ANGDIR = 1 but it's not supported on the single arc level
     */
    if (angle2 < angle1) {
	real tmp = angle1;
	angle1 = angle2;
	angle2 = tmp;
    }
    if(width != 0.0){
	fprintf(renderer->file, "  0\nARC\n");
	fprintf(renderer->file, "  8\n%s\n", renderer->layername);
	fprintf(renderer->file, "  6\n%s\n", renderer->lcurrent.style);
	fprintf(renderer->file, " 10\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", center->x));
	fprintf(renderer->file, " 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (-1)*center->y));
	fprintf(renderer->file, " 40\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", width/2)); /* radius */
	fprintf(renderer->file, " 39\n%d\n", (int)(MAGIC_THICKNESS_FACTOR*renderer->lcurrent.width)); /* Thickness */
	/* From specification: "output in degrees to DXF files". */
	fprintf(renderer->file, " 100\nAcDbArc\n");
	fprintf(renderer->file, " 50\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (angle1 ))); /* start angle */
	fprintf(renderer->file, " 51\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (angle2 ))); /* end angle */
    }
    fprintf(renderer->file, " 62\n%d\n", dxf_color (colour));
}
예제 #6
0
파일: dxf-export.c 프로젝트: GNOME/dia
static void
draw_polygon (DiaRenderer *self,
              Point *points, int num_points,
              Color *fill, Color *stroke)
{
  Color *color = fill ? fill : stroke;
  DxfRenderer *renderer = DXF_RENDERER(self);
  /* We could emulate all polygons with multiple SOLID but it might not be
   * worth the effort. Following the easy part of polygons with 3 or 4 points.
   */
  int idx3[4] = {0, 1, 2, 2}; /* repeating last point is by specification
                                    and should not be necessary but it helps
				    limited importers */
  int idx4[4] = {0, 1, 3, 2}; /* SOLID point order differs from Dia's */
  int *idx;
  int i;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar buf2[G_ASCII_DTOSTR_BUF_SIZE];

  g_return_if_fail (color != NULL);

  if (num_points == 3)
    idx = idx3;
  else if (num_points == 4)
    idx = idx4;
  else
    return; /* dont even try */
  fprintf(renderer->file, "  0\nSOLID\n");
  fprintf(renderer->file, "  8\n%s\n", renderer->layername);
  fprintf(renderer->file, " 62\n%d\n", dxf_color (color));
  for (i = 0; i < 4; ++i)
    fprintf(renderer->file, " %d\n%s\n %d\n%s\n",
            10+i, g_ascii_formatd (buf, sizeof(buf), "%g", points[idx[i]].x),
	    20+i, g_ascii_formatd (buf2, sizeof(buf2), "%g", -points[idx[i]].y));
}
예제 #7
0
파일: dxf-export.c 프로젝트: GNOME/dia
static void
draw_polyline(DiaRenderer *self,
              Point *points, int num_points,
              Color *color)
{
    DxfRenderer *renderer = DXF_RENDERER(self);
    int i;
    gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
    gchar buf2[G_ASCII_DTOSTR_BUF_SIZE];

    fprintf(renderer->file, "  0\nPOLYLINE\n");
    fprintf(renderer->file, "  6\n%s\n", renderer->lcurrent.style);
    fprintf(renderer->file, "  8\n%s\n", renderer->layername);
    /* start and end width are the same */
    fprintf(renderer->file, " 41\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", renderer->lcurrent.width));
    fprintf(renderer->file, " 42\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", renderer->lcurrent.width));
    fprintf(renderer->file, " 62\n%d\n", dxf_color (color));
    /* vertices-follow flag */
    fprintf(renderer->file, " 66\n1\n");

    for (i = 0; i < num_points; ++i)
        fprintf(renderer->file, "  0\nVERTEX\n 10\n%s\n 20\n%s\n",
	        g_ascii_formatd (buf, sizeof(buf), "%g", points[i].x),
		g_ascii_formatd (buf2, sizeof(buf2), "%g", -points[i].y));

    fprintf(renderer->file, "  0\nSEQEND\n");
}
예제 #8
0
파일: diasvgrenderer.c 프로젝트: mpuels/dia
/*!
 * \brief creation of rectangles with corner radius
 * \memberof SvgRenderer
 */
static void
draw_rounded_rect (DiaRenderer *self, 
		   Point *ul_corner, Point *lr_corner,
		   Color *fill, Color *stroke, real rounding)
{
  DiaSvgRenderer *renderer = DIA_SVG_RENDERER (self);
  xmlNodePtr node;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

  node = xmlNewChild(renderer->root, NULL, (const xmlChar *)"rect", NULL);

  xmlSetProp(node, (const xmlChar *)"style",
	     (const xmlChar *)DIA_SVG_RENDERER_GET_CLASS(self)->get_draw_style (renderer, fill, stroke));

  g_ascii_formatd(buf, sizeof(buf), "%g", ul_corner->x * renderer->scale);
  xmlSetProp(node, (const xmlChar *)"x", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf), "%g", ul_corner->y * renderer->scale);
  xmlSetProp(node, (const xmlChar *)"y", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf), "%g", (lr_corner->x - ul_corner->x) * renderer->scale);
  xmlSetProp(node, (const xmlChar *)"width", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf), "%g", (lr_corner->y - ul_corner->y) * renderer->scale);
  xmlSetProp(node, (const xmlChar *)"height", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf),"%g", (rounding * renderer->scale));
  xmlSetProp(node, (const xmlChar *)"rx", (xmlChar *) buf);
  xmlSetProp(node, (const xmlChar *)"ry", (xmlChar *) buf);
}
예제 #9
0
void draw_bezier_outline(DiaPsRenderer *renderer,
			 int dpi_x,
			 FT_Face face,
			 FT_UInt glyph_index,
			 double pos_x,
			 double pos_y
			 )
{
  FT_Int load_flags = FT_LOAD_DEFAULT|FT_LOAD_NO_BITMAP;
  FT_Glyph glyph;
  FT_Error error;
  gchar px_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar py_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar d1_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar d2_buf[G_ASCII_DTOSTR_BUF_SIZE];

  /* Need to transform */

  /* Output outline */
  FT_Outline_Funcs outlinefunc = 
    {
      paps_move_to,
      paps_line_to,
      paps_conic_to,
      paps_cubic_to
    };
  OutlineInfo outline_info;

  outline_info.glyph_origin.x = pos_x;
  outline_info.glyph_origin.y = pos_y;
  outline_info.dpi = dpi_x;
  outline_info.OUT = renderer->file;

  fprintf(renderer->file, 
	  "gsave %s %s translate %s %s scale\n",
	  g_ascii_formatd(px_buf, sizeof(px_buf), "%f", pos_x),
	  g_ascii_formatd(py_buf, sizeof(py_buf), "%f", pos_y),
	  g_ascii_formatd(d1_buf, sizeof(d1_buf), "%f", 2.54/72.0),
	  g_ascii_formatd(d2_buf, sizeof(d2_buf), "%f", -2.54/72.0) );
  fprintf(renderer->file, "start_ol\n");

  if ((error=FT_Load_Glyph(face, glyph_index, load_flags))) {
    fprintf(stderr, "Can't load glyph: %d\n", error);
    return;
  }
  if ((error=FT_Get_Glyph (face->glyph, &glyph))) {
    fprintf(stderr, "Can't get glyph: %d\n", error);
    FT_Done_Glyph (glyph);
    return;
  }
  if (face->glyph->format == FT_GLYPH_FORMAT_OUTLINE)
    FT_Outline_Decompose (&(((FT_OutlineGlyph)glyph)->outline),
                          &outlinefunc, &outline_info);
  fprintf(renderer->file, "end_ol grestore \n");
  
  FT_Done_Glyph (glyph);
}
예제 #10
0
파일: dxf-export.c 프로젝트: GNOME/dia
static void
draw_ellipse(DiaRenderer *self,
	     Point *center,
	     real width, real height,
	     Color *fill, Color *stroke)
{
    DxfRenderer *renderer = DXF_RENDERER(self);
    gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
    Color *color = fill ? fill : stroke; /* emulate fill by SOLID? */

    /* draw a circle instead of an ellipse, if it's one */
    if(width == height){
        fprintf(renderer->file, "  0\nCIRCLE\n");
        fprintf(renderer->file, "  8\n%s\n", renderer->layername);
        fprintf(renderer->file, "  6\n%s\n", renderer->lcurrent.style);
        fprintf(renderer->file, " 10\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", center->x));
        fprintf(renderer->file, " 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (-1)*center->y));
        fprintf(renderer->file, " 40\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", height/2));
        fprintf(renderer->file, " 39\n%d\n", (int)(MAGIC_THICKNESS_FACTOR*renderer->lcurrent.width)); /* Thickness */
    }
    else if(height != 0.0){
        fprintf(renderer->file, "  0\nELLIPSE\n");
        fprintf(renderer->file, "  8\n%s\n", renderer->layername);
        fprintf(renderer->file, "  6\n%s\n", renderer->lcurrent.style);
        fprintf(renderer->file, " 10\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", center->x));
        fprintf(renderer->file, " 20\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", (-1)*center->y));
        fprintf(renderer->file, " 11\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", width/2)); /* Endpoint major axis relative to center X*/
        fprintf(renderer->file, " 40\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", height/width)); /*Ratio major/minor axis*/
        fprintf(renderer->file, " 39\n%d\n", (int)(MAGIC_THICKNESS_FACTOR*renderer->lcurrent.width)); /* Thickness */
        fprintf(renderer->file, " 41\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", 0.0)); /*Start Parameter full ellipse */
        fprintf(renderer->file, " 42\n%s\n", g_ascii_formatd (buf, sizeof(buf), "%g", 2.0*3.14)); /* End Parameter full ellipse */
    }
    fprintf(renderer->file, " 62\n%d\n", dxf_color (color));
}
예제 #11
0
파일: diasvgrenderer.c 프로젝트: mpuels/dia
static void
_gradient_do (gpointer key,
	      gpointer value,
	      gpointer user_data)
{
  DiaPattern *pattern = (DiaPattern *)value;
  GradientData *gd = (GradientData *)user_data;
  DiaSvgRenderer *renderer = gd->renderer;
  xmlNodePtr parent = gd->node;
  xmlNodePtr gradient;
  DiaPatternType pt;
  guint flags;
  Point p1, p2;
  gchar vbuf[DTOSTR_BUF_SIZE];
  real scale = renderer->scale;

  dia_pattern_get_settings (pattern, &pt, &flags);
  if ((flags & DIA_PATTERN_USER_SPACE)==0)
    scale = 1.0;
  dia_pattern_get_points (pattern, &p1, &p2);
  if (pt == DIA_LINEAR_GRADIENT) {
    gradient = xmlNewChild (parent, parent->ns, (const xmlChar *)"linearGradient", NULL);
    xmlSetProp (gradient, (const xmlChar *)"x1", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p1.x * scale));
    xmlSetProp (gradient, (const xmlChar *)"y1", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p1.y * scale));
    xmlSetProp (gradient, (const xmlChar *)"x2", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p2.x * scale));
    xmlSetProp (gradient, (const xmlChar *)"y2", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p2.y * scale));
  } else if  (pt == DIA_RADIAL_GRADIENT) {
    real r;
    dia_pattern_get_radius (pattern, &r);
    gradient = xmlNewChild (parent, parent->ns, (const xmlChar *)"radialGradient", NULL);
    xmlSetProp (gradient, (const xmlChar *)"cx", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p1.x * scale));
    xmlSetProp (gradient, (const xmlChar *)"cy", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p1.y * scale));
    xmlSetProp (gradient, (const xmlChar *)"fx", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p2.x * scale));
    xmlSetProp (gradient, (const xmlChar *)"fy", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", p2.y * scale));
    xmlSetProp (gradient, (const xmlChar *)"r", (const xmlChar *)g_ascii_formatd(vbuf,sizeof(vbuf),"%g", r * scale));
  } else {
    gradient = xmlNewChild (parent, parent->ns, (const xmlChar *)"pattern", NULL);
  }
  /* don't miss to set the id */
  {
    gchar *id = _make_pattern_key (pattern);
    xmlSetProp (gradient, (const xmlChar *)"id", (const xmlChar *)id);
    g_free (id);
  }
  if (flags & DIA_PATTERN_USER_SPACE)
    xmlSetProp (gradient, (const xmlChar *)"gradientUnits", (const xmlChar *)"userSpaceOnUse");
  if (flags & DIA_PATTERN_EXTEND_REPEAT)
    xmlSetProp (gradient, (const xmlChar *)"spreadMethod", (const xmlChar *)"repeat");
  else if (flags & DIA_PATTERN_EXTEND_REFLECT)
    xmlSetProp (gradient, (const xmlChar *)"spreadMethod", (const xmlChar *)"reflect");
  else if (flags & DIA_PATTERN_EXTEND_PAD)
    xmlSetProp (gradient, (const xmlChar *)"spreadMethod", (const xmlChar *)"pad");

  if (pt == DIA_LINEAR_GRADIENT || pt == DIA_RADIAL_GRADIENT) {
    dia_pattern_foreach (pattern, _color_stop_do, gradient);
  } else {
    g_warning ("SVG pattern data not implemented");
  }
}
예제 #12
0
파일: color-history.c 프로젝트: frne/gimp
void
color_history_save (Gimp *gimp)
{
  GimpConfigWriter *writer;
  GFile            *file;
  gint              i;

  g_return_if_fail (GIMP_IS_GIMP (gimp));

  file = gimp_personal_rc_gfile ("colorrc");

  if (gimp->be_verbose)
    g_print ("Writing '%s'\n", gimp_file_get_utf8_name (file));

  writer = gimp_config_writer_new_gfile (file,
                                         TRUE,
                                         "GIMP colorrc\n\n"
                                         "This file holds a list of "
                                         "recently used colors.",
                                         NULL);
  g_object_unref (file);

  if (!writer)
    return;

  if (! color_history_initialized)
    color_history_init ();

  gimp_config_writer_open (writer, "color-history");

  for (i = 0; i < COLOR_HISTORY_SIZE; i++)
    {
      gchar buf[4][G_ASCII_DTOSTR_BUF_SIZE];

      g_ascii_formatd (buf[0],
                       G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].r);
      g_ascii_formatd (buf[1],
                       G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].g);
      g_ascii_formatd (buf[2],
                       G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].b);
      g_ascii_formatd (buf[3],
                       G_ASCII_DTOSTR_BUF_SIZE, "%f", color_history[i].a);

      gimp_config_writer_open (writer, "color-rgba");
      gimp_config_writer_printf (writer, "%s %s %s %s",
                                 buf[0], buf[1], buf[2], buf[3]);
      gimp_config_writer_close (writer);
    }

  gimp_config_writer_close (writer);

  gimp_config_writer_finish (writer, "end of colorrc", NULL);
}
예제 #13
0
static void
add_connection_point (ShapeRenderer *renderer, 
                      Point *point) 
{
  xmlNodePtr node;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];
  
  node = xmlNewChild(renderer->connection_root, NULL, (const xmlChar *)"point", NULL);
  g_ascii_formatd(buf, sizeof(buf), "%g", point->x);
  xmlSetProp(node, (const xmlChar *)"x", (xmlChar *) buf);
  g_ascii_formatd(buf, sizeof(buf), "%g", point->y);
  xmlSetProp(node, (const xmlChar *)"y", (xmlChar *) buf);
}
예제 #14
0
static gchar *
_str_point (const Point *point)
{
  gchar *buffer;
  gchar px_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar py_buf[G_ASCII_DTOSTR_BUF_SIZE];

  g_ascii_formatd(px_buf, sizeof(px_buf), "%g", point->x);
  g_ascii_formatd(py_buf, sizeof(py_buf), "%g", point->y);
  buffer = g_strconcat(px_buf, ",", py_buf, NULL);

  return buffer;
}
예제 #15
0
static void
_string_append_point (GString *str, Point *pt, gboolean first)
{
  gchar value[G_ASCII_DTOSTR_BUF_SIZE];

  if (!first)
    g_string_append (str, " ");
  g_ascii_formatd (value, sizeof(value), "%g", pt->x);
  g_string_append (str, value);
  g_string_append (str, ",");
  g_ascii_formatd (value, sizeof(value), "%g", pt->y);
  g_string_append (str, value);
}
예제 #16
0
파일: diasvgrenderer.c 프로젝트: mpuels/dia
/* the return value of this function should not be saved anywhere */
static const gchar *
get_draw_style(DiaSvgRenderer *renderer,
	       Color *fill,
	       Color *stroke)
{
  static GString *str = NULL;
  gchar linewidth_buf[DTOSTR_BUF_SIZE];
  gchar alpha_buf[DTOSTR_BUF_SIZE];

  if (!str)
    str = g_string_new(NULL);
  g_string_truncate(str, 0);

  /* we only append a semicolon with the second attribute */
  if (fill) {
    if (renderer->active_pattern) {
      gchar *key = _make_pattern_key (renderer->active_pattern);
      g_string_printf(str, "fill:url(#%s)", key);
      g_free (key);
    } else {
      g_string_printf(str, "fill: #%02x%02x%02x; fill-opacity: %s",
		      (int)(255*fill->red), (int)(255*fill->green),
		      (int)(255*fill->blue), 
		      g_ascii_formatd(alpha_buf, sizeof(alpha_buf), "%g", fill->alpha));
    }
  } else {
    g_string_printf(str, "fill: none");
  }

  if (stroke) {
    g_string_append_printf(str, "; stroke-opacity: %s; stroke-width: %s",
			   g_ascii_formatd (alpha_buf, sizeof(alpha_buf), "%g", stroke->alpha), 
			   dia_svg_dtostr(linewidth_buf, renderer->linewidth) );
    if (strcmp(renderer->linecap, "butt"))
      g_string_append_printf(str, "; stroke-linecap: %s", renderer->linecap);
    if (strcmp(renderer->linejoin, "miter"))
      g_string_append_printf(str, "; stroke-linejoin: %s", renderer->linejoin);
    if (renderer->linestyle)
      g_string_append_printf(str, "; stroke-dasharray: %s", renderer->linestyle);

    g_string_append_printf(str, "; stroke: #%02x%02x%02x",
			   (int)(255*stroke->red), 
			   (int)(255*stroke->green),
			   (int)(255*stroke->blue));
  } else {
    g_string_append_printf(str, "; stroke: none");
  }
  return str->str;
}
예제 #17
0
static gboolean
gimp_levels_tool_settings_save (GimpImageMapTool *image_map_tool,
                                gpointer          fp)
{
  GimpLevelsTool *tool = GIMP_LEVELS_TOOL (image_map_tool);
  FILE           *file = fp;
  gint            i;

  fprintf (file, "# GIMP Levels File\n");

  for (i = 0; i < 5; i++)
    {
      gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

      fprintf (file, "%d %d %d %d %s\n",
               tool->levels->low_input[i],
               tool->levels->high_input[i],
               tool->levels->low_output[i],
               tool->levels->high_output[i],
               g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, "%f",
                                tool->levels->gamma[i]));
    }

  return TRUE;
}
예제 #18
0
extern void
SetMovefilterCommands ( const char *sz,
                 movefilter aamfNew[ MAX_FILTER_PLIES ][ MAX_FILTER_PLIES ], 
                 movefilter aamfOld[ MAX_FILTER_PLIES ][ MAX_FILTER_PLIES ] ) {

  int i, j;
  char *szCmd;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

  for ( i = 0; i < MAX_FILTER_PLIES; ++i )
    for ( j = 0; j <= i; ++j ) {
      if (memcmp(&aamfNew[i][j], &aamfOld[i][j], sizeof(movefilter)) != 0)
	  {
        szCmd = g_strdup_printf ( "%s %d %d %d %d %s",
                                  sz, i + 1, j,
                                  aamfNew[ i ][ j ].Accept,
                                  aamfNew[ i ][ j ].Extra,
                                  g_ascii_formatd( buf, G_ASCII_DTOSTR_BUF_SIZE, "%0.3f", (double)aamfNew[ i ][ j ].Threshold ));
        UserCommand ( szCmd );
        g_free ( szCmd );
      }
      
    }
  UserCommand("save settings");

}
예제 #19
0
gboolean
gimp_levels_config_save_cruft (GimpLevelsConfig  *config,
                               gpointer           fp,
                               GError           **error)
{
  FILE *file = fp;
  gint  i;

  g_return_val_if_fail (GIMP_IS_LEVELS_CONFIG (config), FALSE);
  g_return_val_if_fail (file != NULL, FALSE);
  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);

  fprintf (file, "# GIMP Levels File\n");

  for (i = 0; i < 5; i++)
    {
      gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

      fprintf (file, "%d %d %d %d %s\n",
               (gint) (config->low_input[i]   * 255.999),
               (gint) (config->high_input[i]  * 255.999),
               (gint) (config->low_output[i]  * 255.999),
               (gint) (config->high_output[i] * 255.999),
               g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, "%f",
                                config->gamma[i]));
    }

  return TRUE;
}
예제 #20
0
파일: shape-export.c 프로젝트: UIKit0/dia
static void
add_connection_point (ShapeRenderer *renderer, 
                      Point *point, gboolean design_connection, 
                      gboolean main) 
{
  xmlNodePtr node;
  xmlChar *propx, *propy;
  gchar bufx[G_ASCII_DTOSTR_BUF_SIZE], bufy[G_ASCII_DTOSTR_BUF_SIZE];
  
  /* Use connection points, drop the auto ones */
  if(design_connection && !renderer->design_connection) {
	  renderer->design_connection = design_connection;
	  node = renderer->connection_root->parent;
	  xmlUnlinkNode(renderer->connection_root);
	  xmlFree(renderer->connection_root);
	  renderer->connection_root = xmlNewChild(node, NULL, (const xmlChar *)"connections", NULL);
  }
  if(!design_connection && renderer->design_connection)
  	return;

  g_ascii_formatd(bufx, sizeof(bufx), "%g", point->x);
  g_ascii_formatd(bufy, sizeof(bufy), "%g", point->y);

  /* Remove duplicates */
  for (node = renderer->connection_root->children; node; node = node->next) {
    if ((XML_ELEMENT_NODE == node->type) && xmlStrEqual((const xmlChar *)"point", node->name)) {
      propx = xmlGetProp(node, (const xmlChar *)"x");
      propy = xmlGetProp(node, (const xmlChar *)"y");
      if (xmlStrEqual((const xmlChar *)propx, (const xmlChar *)bufx) &&
          xmlStrEqual((const xmlChar *)propy, (const xmlChar *)bufy)) {
	if(propx) xmlFree(propx);
        if(propy) xmlFree(propy);
        return;
      }
      if(propx) xmlFree(propx);
      if(propy) xmlFree(propy);
    }
  }
  
  node = xmlNewChild(renderer->connection_root, NULL, (const xmlChar *)"point", NULL);
  xmlSetProp(node, (const xmlChar *)"x", (xmlChar *) bufx);
  xmlSetProp(node, (const xmlChar *)"y", (xmlChar *) bufy);
  if (main) {
	  xmlSetProp(node, (const xmlChar *)"main", (xmlChar *)"yes");
  }
  
}
예제 #21
0
파일: prop_matrix.c 프로젝트: UIKit0/dia
static void
_matrix_xml_add_val (DataNode data_node, const char* name, real val)
{
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

  g_ascii_formatd(buf, sizeof(buf), "%g", val);
  xmlSetProp(data_node, (const xmlChar *)name, (xmlChar *)buf);
}
예제 #22
0
static void
_node_set_real (xmlNodePtr node, const char *name, real v)
{
  gchar value[G_ASCII_DTOSTR_BUF_SIZE];

  g_ascii_formatd (value, sizeof(value), "%g", v);
  xmlSetProp (node, (const xmlChar *)name, (xmlChar *)value);
}
예제 #23
0
static void
gwy_gl_material_dump_component(GString *str,
                               const GwyRGBA *rgba)
{
    gchar buffer[G_ASCII_DTOSTR_BUF_SIZE];

    /* this is ugly.  I hate locales */
    g_ascii_formatd(buffer, sizeof(buffer), "%.6g", rgba->r);
    g_string_append(str, buffer);
    g_string_append_c(str, ' ');
    g_ascii_formatd(buffer, sizeof(buffer), "%.6g", rgba->g);
    g_string_append(str, buffer);
    g_string_append_c(str, ' ');
    g_ascii_formatd(buffer, sizeof(buffer), "%.6g", rgba->b);
    g_string_append(str, buffer);
    g_string_append_c(str, ' ');
    g_ascii_formatd(buffer, sizeof(buffer), "%g", rgba->a);
    g_string_append(str, buffer);
    g_string_append_c(str, '\n');
}
예제 #24
0
파일: diasvgrenderer.c 프로젝트: mpuels/dia
static gboolean
_color_stop_do (real         ofs,
		const Color *col,
		gpointer     user_data)
{
  xmlNodePtr parent = (xmlNodePtr)user_data;
  xmlNodePtr stop = xmlNewChild (parent, parent->ns, (const xmlChar *)"stop", NULL);
  gchar vbuf[DTOSTR_BUF_SIZE];

  g_ascii_formatd(vbuf,sizeof(vbuf),"%g", ofs);
  xmlSetProp (stop, (const xmlChar *)"offset", (const xmlChar *)vbuf);

  g_sprintf (vbuf, "#%02x%02x%02x", (int)(255*col->red), (int)(255*col->green), (int)(255*col->blue));
  xmlSetProp (stop, (const xmlChar *)"stop-color", (const xmlChar *)vbuf);

  g_ascii_formatd(vbuf,sizeof(vbuf),"%g", col->alpha);
  xmlSetProp (stop, (const xmlChar *)"stop-opacity", (const xmlChar *)vbuf);

  return TRUE;
}
예제 #25
0
static void
gimp_vectors_export_image_size (const GimpImage *image,
                                GString         *str)
{
  GimpUnit     unit;
  const gchar *abbrev;
  gchar        wbuf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar        hbuf[G_ASCII_DTOSTR_BUF_SIZE];
  gdouble      xres;
  gdouble      yres;
  gdouble      w, h;

  gimp_image_get_resolution (image, &xres, &yres);

  w = (gdouble) gimp_image_get_width  (image) / xres;
  h = (gdouble) gimp_image_get_height (image) / yres;

  /*  FIXME: should probably use the display unit here  */
  unit = gimp_image_get_unit (image);
  switch (unit)
    {
    case GIMP_UNIT_INCH:  abbrev = "in";  break;
    case GIMP_UNIT_MM:    abbrev = "mm";  break;
    case GIMP_UNIT_POINT: abbrev = "pt";  break;
    case GIMP_UNIT_PICA:  abbrev = "pc";  break;
    default:              abbrev = "cm";
      unit = GIMP_UNIT_MM;
      w /= 10.0;
      h /= 10.0;
      break;
    }

  g_ascii_formatd (wbuf, sizeof (wbuf),
                   "%g", w * _gimp_unit_get_factor (image->gimp, unit));
  g_ascii_formatd (hbuf, sizeof (hbuf),
                   "%g", h * _gimp_unit_get_factor (image->gimp, unit));

  g_string_append_printf (str,
                          "width=\"%s%s\" height=\"%s%s\"",
                          wbuf, abbrev, hbuf, abbrev);
}
예제 #26
0
static void
test_number (gdouble num, gchar *fmt, gchar *str)
{
  int l;
  gchar buf[G_ASCII_DTOSTR_BUF_SIZE];

  for (l = 0; l < G_N_ELEMENTS (locales); l++)
    {
      g_ascii_formatd (buf, G_ASCII_DTOSTR_BUF_SIZE, fmt, num);
      g_assert (strcmp (buf, str) == 0);
    }
}
예제 #27
0
/**
 * lgl_xml_set_prop_double:
 * @node:        the libxml2 #xmlNodePtr of the node
 * @property:    the property name
 * @val:         the value to set
 *
 * Set a property from a double.
 *
 */
void
lgl_xml_set_prop_double (xmlNodePtr    node,
			 const gchar  *property,
			 gdouble       val)
{
	gchar  *string, buffer[G_ASCII_DTOSTR_BUF_SIZE];

	/* Guarantee "C" locale by use of g_ascii_formatd */
	string = g_ascii_formatd (buffer, G_ASCII_DTOSTR_BUF_SIZE, "%g", val);

	xmlSetProp (node, (xmlChar *)property, (xmlChar *)string);
}
void
swfdec_system_query (SwfdecAsContext *cx, SwfdecAsObject *object,
    guint argc, SwfdecAsValue *argv, SwfdecAsValue *retval)
{
  SwfdecPlayer *player = SWFDEC_PLAYER (cx);
  SwfdecAsValue val;
  guint i;
  GString *server;

  if (object == NULL) {
    SWFDEC_WARNING ("no this object in Query()");
    return;
  }

  server = g_string_new ("");
  for (i = 0; i < G_N_ELEMENTS (queries); i++) {
    queries[i].get (player, &val);
    swfdec_as_object_set_variable (object, queries[i].name, &val);
    if (queries[i].name == SWFDEC_AS_STR_screenResolutionY) {
      g_string_append_printf (server, "x%d", (int) SWFDEC_AS_VALUE_GET_NUMBER (val));
    } else if (queries[i].name == SWFDEC_AS_STR_pixelAspectRatio) {
      char buffer[10];
      g_ascii_formatd (buffer, sizeof (buffer), "%.1f",
	  SWFDEC_AS_VALUE_GET_NUMBER (val));
      g_string_append (server, "&AR=");
      g_string_append (server, buffer);
    } else if (queries[i].name == SWFDEC_AS_STR_manufacturer) {
      char *s = swfdec_as_string_escape (cx, player->priv->system->server_manufacturer);
      g_string_append_printf (server, "&M=%s", s);
      g_free (s);
    } else {
      g_assert (queries[i].server_string);
      if (i > 0)
	g_string_append_c (server, '&');
      g_string_append (server, queries[i].server_string);
      g_string_append_c (server, '=');
      if (SWFDEC_AS_VALUE_IS_BOOLEAN (val)) {
	g_string_append_c (server, SWFDEC_AS_VALUE_GET_BOOLEAN (val) ? 't' : 'f');
      } else if (SWFDEC_AS_VALUE_IS_NUMBER (val)) {
	g_string_append_printf (server, "%d", (int) SWFDEC_AS_VALUE_GET_NUMBER (val));
      } else if (SWFDEC_AS_VALUE_IS_STRING (val)) {
	char *s = swfdec_as_string_escape (cx, SWFDEC_AS_VALUE_GET_STRING (val));
	g_string_append (server, s);
	g_free (s);
      } else {
	g_assert_not_reached ();
      }
    }
  }
  SWFDEC_AS_VALUE_SET_STRING (&val, swfdec_as_context_give_string (cx, g_string_free (server, FALSE)));
  swfdec_as_object_set_variable (object, SWFDEC_AS_STR_serverString, &val);
}
예제 #29
0
/* request geotagged wikipedia entries for current map view */
void maep_geonames_entry_request(coord_t *pt1, coord_t *pt2,
                                 MaepGeonamesRequestCallback cb, gpointer obj)
{
  request_cb_t *context;
  /* create ascii (dot decimal point) strings */
  char str[4][16];
  g_ascii_formatd(str[0], sizeof(str[0]), "%.07f", rad2deg(pt1->rlat));
  g_ascii_formatd(str[1], sizeof(str[1]), "%.07f", rad2deg(pt2->rlat));
  g_ascii_formatd(str[2], sizeof(str[2]), "%.07f", rad2deg(pt1->rlon));
  g_ascii_formatd(str[3], sizeof(str[3]), "%.07f", rad2deg(pt2->rlon));

  gchar *locale, lang[3] = { 0,0,0 };
  gchar *lang_avail[] = {"de", "en", "es", "fr", "it", "nl", "pl", "pt", "ru", "zh", NULL};
  int i;
  locale = setlocale (LC_MESSAGES, NULL);
  g_utf8_strncpy (lang, locale, 2);

  /* currently only "de" and "en" are supported by geonames.org */
  /* force to "en" in any other case */
  g_message("Look for entries in %s", lang);
  for (i = 0; lang_avail[i] && strcasecmp(lang, lang_avail[i]); i++);
  if (!lang_avail[i]) 
    strncpy(lang, "en", 2);
      
  /* build complete url for request */
  char *url = g_strdup_printf(
      GEONAMES "wikipediaBoundingBox?"
      "north=%s&south=%s&west=%s&east=%s&lang=%s&maxRows=%u&username="******"start asynchronous geonames download.");
  context = g_malloc0(sizeof(request_cb_t));
  context->cb = cb;
  context->obj = obj;
  net_io_download_async(url, geonames_request_cb, context);

  g_free(url);
}
예제 #30
0
/** Add rectangle data to an attribute node.
 * @param attr The attribute node.
 * @param rect The value to set.
 */
void
data_add_rectangle(AttributeNode attr, const Rectangle *rect)
{
  DataNode data_node;
  gchar *buffer;
  gchar rl_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar rr_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar rt_buf[G_ASCII_DTOSTR_BUF_SIZE];
  gchar rb_buf[G_ASCII_DTOSTR_BUF_SIZE];

  g_ascii_formatd(rl_buf, sizeof(rl_buf), "%g", rect->left);
  g_ascii_formatd(rr_buf, sizeof(rr_buf), "%g", rect->right);
  g_ascii_formatd(rt_buf, sizeof(rt_buf), "%g", rect->top);
  g_ascii_formatd(rb_buf, sizeof(rb_buf), "%g", rect->bottom);

  buffer = g_strconcat(rl_buf, ",", rt_buf, ";", rr_buf, ",", rb_buf, NULL);

  data_node = xmlNewChild(attr, NULL, (const xmlChar *)"rectangle", NULL);
  xmlSetProp(data_node, (const xmlChar *)"val", (xmlChar *)buffer);

  g_free(buffer);
}