예제 #1
0
파일: wpg-import.c 프로젝트: AmiGanguli/dia
static void
_do_bezier (WpgImportRenderer *ren, WPGPoint *pts, int iNum)
{
  int num_points = (iNum + 2) / 3;
  int i;
  int ofs = ren->Box.Height;
  BezPoint *bps;

  g_return_if_fail (num_points > 1);

  bps = g_alloca (num_points * sizeof(BezPoint));

  bps[0].type = BEZ_MOVE_TO;
  bps[0].p1.x = pts[0].x / WPU_PER_DCM;
  bps[0].p1.y = (ofs - pts[0].y) / WPU_PER_DCM;
  for (i = 1; i < num_points; ++i) {
    bps[i].type = BEZ_CURVE_TO;
    /* although declared as unsigned (WORD) these values have to be treaded
     * as signed, because they can move in both directions.
     */
    bps[i].p1.x =        (gint16)pts[i*3-2].x  / WPU_PER_DCM;
    bps[i].p1.y = (ofs - (gint16)pts[i*3-2].y) / WPU_PER_DCM;
    bps[i].p2.x =        (gint16)pts[i*3-1].x  / WPU_PER_DCM;
    bps[i].p2.y = (ofs - (gint16)pts[i*3-1].y) / WPU_PER_DCM;
    bps[i].p3.x =        (gint16)pts[i*3  ].x  / WPU_PER_DCM;
    bps[i].p3.y = (ofs - (gint16)pts[i*3  ].y) / WPU_PER_DCM;
  }
  /* XXX: should we fold this calls into one? What's closing a WPG PolyCurve? */
  if (ren->LineAttr.Type != WPG_LA_NONE)
    DIA_RENDERER_GET_CLASS(ren)->draw_bezier (DIA_RENDERER(ren),
					      bps, num_points, &ren->stroke);
  if (ren->FillAttr.Type != WPG_FA_HOLLOW)
    DIA_RENDERER_GET_CLASS(ren)->draw_beziergon (DIA_RENDERER(ren),
					         bps, num_points, &ren->fill, NULL);
}
예제 #2
0
파일: wpg-import.c 프로젝트: AmiGanguli/dia
static void
_do_ellipse (WpgImportRenderer *ren, WPGEllipse* pEll)
{
  int    h = ren->Box.Height;
  Point center;
  center.x = pEll->x / WPU_PER_DCM;
  center.y = (h - pEll->y) / WPU_PER_DCM;
  
  if (fabs(pEll->EndAngle - pEll->StartAngle) < 360) {
    /* WPG arcs are counter-clockwise so ensure that end is bigger than start */
    real arcEnd = pEll->EndAngle;
    if (arcEnd < pEll->StartAngle)
      arcEnd += 360;
    if (ren->LineAttr.Type != WPG_LA_NONE)
      DIA_RENDERER_GET_CLASS(ren)->draw_arc (DIA_RENDERER(ren), &center,
					     2 * pEll->rx / WPU_PER_DCM,
					     2 * pEll->ry / WPU_PER_DCM,
					     pEll->StartAngle, arcEnd,
					     &ren->stroke);
    if (ren->FillAttr.Type != WPG_FA_HOLLOW)
      DIA_RENDERER_GET_CLASS(ren)->fill_arc (DIA_RENDERER(ren), &center,
					     2 * pEll->rx / WPU_PER_DCM,
					     2 * pEll->ry / WPU_PER_DCM,
					     pEll->StartAngle, arcEnd,
					     &ren->fill);
  } else {
    DIA_RENDERER_GET_CLASS(ren)->draw_ellipse (DIA_RENDERER(ren), &center,
						 2 * pEll->rx / WPU_PER_DCM,
						 2 * pEll->ry / WPU_PER_DCM,
						 (ren->FillAttr.Type != WPG_FA_HOLLOW) ? &ren->fill : NULL,
						 (ren->LineAttr.Type != WPG_LA_NONE) ? &ren->stroke : NULL);
  }
}
예제 #3
0
파일: handle_ops.c 프로젝트: UIKit0/dia
void
handle_draw(Handle *handle, DDisplay *ddisp)
{
  gboolean some_selected;
  int x,y;
  DiaRenderer *renderer = ddisp->renderer;
  DiaInteractiveRendererInterface *irenderer =
    DIA_GET_INTERACTIVE_RENDERER_INTERFACE (ddisp->renderer);
  const Color *color;

  ddisplay_transform_coords(ddisp, handle->pos.x, handle->pos.y, &x, &y);
  /* change handle color to reflect different behaviour for multiple selected */
  /* this code relies on the fact that only selected objects get their handles drawn */
  some_selected = g_list_length (ddisp->diagram->data->selected) > 1;

  if  (handle->connected_to != NULL) {
    color = &handle_color_connected[handle->type + (some_selected ? NUM_HANDLE_TYPES : 0)];
  } else {
    color = &handle_color[handle->type + (some_selected ? NUM_HANDLE_TYPES : 0)];
  }

  DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0.0);
  DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_SOLID);
  DIA_RENDERER_GET_CLASS(renderer)->set_linejoin(renderer, LINEJOIN_MITER);
  DIA_RENDERER_GET_CLASS(renderer)->set_fillstyle(renderer, FILLSTYLE_SOLID);
  

  irenderer->fill_pixel_rect(renderer,
			     x - HANDLE_SIZE/2 + 1,
			     y - HANDLE_SIZE/2 + 1,
			     HANDLE_SIZE-2, HANDLE_SIZE-2,
			     /* it does not change the color, but does not reflect taht in the signature */
			     (Color *)color);
  
  irenderer->draw_pixel_rect(renderer,
			     x - HANDLE_SIZE/2,
			     y - HANDLE_SIZE/2,
			     HANDLE_SIZE-1, HANDLE_SIZE-1,
			     &color_black);

    
  
  if (handle->connect_type != HANDLE_NONCONNECTABLE) {
    irenderer->draw_pixel_line
                         (renderer,
			  x - HANDLE_SIZE/2, y - HANDLE_SIZE/2,
			  x + HANDLE_SIZE/2, y + HANDLE_SIZE/2,
			  &color_black);
    irenderer->draw_pixel_line
                         (renderer,
			  x - HANDLE_SIZE/2, y + HANDLE_SIZE/2,
			  x + HANDLE_SIZE/2, y - HANDLE_SIZE/2,
			  &color_black);
  }
}
예제 #4
0
void
pagebreak_draw(DDisplay *ddisp, Rectangle *update)
{
  DiaRenderer *renderer = ddisp->renderer;
  DiaInteractiveRendererInterface *irenderer;

  int width = dia_renderer_get_width_pixels(ddisp->renderer);
  int height = dia_renderer_get_height_pixels(ddisp->renderer);
  
  irenderer = DIA_GET_INTERACTIVE_RENDERER_INTERFACE (renderer);
  if (prefs.pagebreak.visible) {
    Diagram *dia = ddisp->diagram;
    real origx = 0, origy = 0, pos;
    real pwidth = dia->data->paper.width;
    real pheight = dia->data->paper.height;
    int x,y;

    DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0.0);
    if (prefs.pagebreak.solid)
      DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
    else
      DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_DOTTED,
						      ddisplay_untransform_length(ddisp, 31));

    if (dia->data->paper.fitto) {
      origx = dia->data->extents.left;
      origy = dia->data->extents.top;
    }

    /* vertical lines ... */
    pos = origx + ceil((update->left - origx) / pwidth) * pwidth;
    while (pos <= update->right) {
      ddisplay_transform_coords(ddisp, pos,0,&x,&y);
      irenderer->draw_pixel_line(renderer,
                                 x, 0, x, height,
				 &dia->pagebreak_color);
      pos += pwidth;
    }
    /* Horizontal lines: */
    pos = origy + ceil((update->top - origy) / pheight) * pheight;
    while (pos <= update->bottom) {
      ddisplay_transform_coords(ddisp, 0,pos,&x,&y);
      irenderer->draw_pixel_line(renderer,
				 0, y, width, y,
				 &dia->pagebreak_color);
      pos += pheight;
    }
  }
}
예제 #5
0
static void
grid_draw_horizontal_lines(DDisplay *ddisp, Rectangle *update, real length) 
{
  int x, y;
  real pos;
  int height, width;
  guint major_lines = ddisp->diagram->grid.major_lines;
  DiaRenderer *renderer = ddisp->renderer;
  DiaInteractiveRendererInterface *irenderer;
  int major_count = 0;

  irenderer = DIA_GET_INTERACTIVE_RENDERER_INTERFACE (renderer);

  pos = ceil( update->top / length ) * length;
  ddisplay_transform_coords(ddisp, update->left, pos, &x, &y);
  ddisplay_transform_coords(ddisp, update->right, update->bottom, &width, &height);

  /*
    Explanatory note from Lawrence Withers ([email protected]):
    Think about it in terms of the maths and the modulo arithmetic; we
    have a number P such that P < 0, and we want to find a number Q
    such that Q >= 0, but (P % major_count) == (Q % major_count). To
    do this, we say Q = P - (P * major_count), which is guaranteed to
    give a correct answer if major_count > 0 (since the addition of
    anf multiple of major_count won't alter the modulo).
  */

  if (major_lines) {
    major_count = ROUND (pos/length);
    if(major_count < 0) major_count -= major_lines * major_count;
    major_count %= major_lines;
  }

  while (y < height) {
    if (major_lines) {
      if (major_count == 0)
	DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
      else
	DIA_RENDERER_GET_CLASS(renderer)->set_linestyle(renderer, LINESTYLE_DOTTED,
							ddisplay_untransform_length(ddisp, 31));
      major_count = (major_count+1)%major_lines;
    }
    irenderer->draw_pixel_line(renderer, x, y, width, y,
			       &ddisp->diagram->grid.colour);
    pos += length;
    ddisplay_transform_coords(ddisp, update->left, pos, &x, &y);
  }
}
예제 #6
0
파일: bus.c 프로젝트: krattai/monoflow
static void
bus_draw(Bus *bus, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Point *endpoints;
  int i;
  
  assert(bus != NULL);
  assert(renderer != NULL);

  endpoints = &bus->real_ends[0];
  
  renderer_ops->set_linewidth(renderer, LINE_WIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);
  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);

  renderer_ops->draw_line(renderer,
			   &endpoints[0], &endpoints[1],
 			   &bus->line_color);

  for (i=0;i<bus->num_handles;i++) {
    renderer_ops->draw_line(renderer,
			     &bus->parallel_points[i],
			     &bus->handles[i]->pos,
			     &bus->line_color);
  }
}
예제 #7
0
파일: beziergon.c 프로젝트: brunetton/dia
static void
beziergon_draw(Beziergon *beziergon, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);

  BezierShape *bez = &beziergon->bezier;
  BezPoint *points;
  int n;
  
  points = &bez->bezier.points[0];
  n = bez->bezier.num_points;

  renderer_ops->set_linewidth(renderer, beziergon->line_width);
  renderer_ops->set_linestyle(renderer, beziergon->line_style);
  renderer_ops->set_dashlength(renderer, beziergon->dashlength);
  renderer_ops->set_linejoin(renderer, beziergon->line_join);
  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);

  if (beziergon->show_background)
    renderer_ops->fill_bezier(renderer, points, n, &beziergon->inner_color);

  renderer_ops->draw_bezier(renderer, points, n, &beziergon->line_color);

  /* these lines should only be displayed when object is selected.
   * Unfortunately the draw function is not aware of the selected
   * state.  This is a compromise until I fix this properly. */
  if (renderer->is_interactive &&
      dia_object_is_selected((DiaObject*)beziergon)) {
    bezier_draw_control_lines (beziergon->bezier.bezier.num_points, beziergon->bezier.bezier.points, renderer);
  }
}
예제 #8
0
파일: aadlpackage.c 프로젝트: mpuels/dia
static void aadlpackage_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point points[9];

  assert(aadlbox != NULL);
  assert(renderer != NULL);

  elem = &aadlbox->element;

  x = elem->corner.x;
  y = elem->corner.y;
  w = elem->width;
  h = elem->height;

  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);

  points[0].x = x;                 points[0].y = y;
  points[1].x = x + 0.03 * w ;     points[1].y = y;
  points[2].x = x + 0.08 * w ;     points[2].y = y -  AADL_PORT_MAX_OUT;
  points[3].x = x + 0.40 * w ;     points[3].y = y -  AADL_PORT_MAX_OUT;
  points[4].x = x + 0.45 * w ;     points[4].y = y;
  points[5].x = x + w - 0.05 * w;  points[5].y = y;
  points[6].x = x + w;             points[6].y = y + 0.05 * h;
  points[7].x = x + w;             points[7].y = y + h;
  points[8].x = x ;                points[8].y = y + h;

  renderer_ops->draw_polygon(renderer, points, 9, &aadlbox->fill_color, &aadlbox->line_color);
}
예제 #9
0
파일: newgroup.c 프로젝트: krattai/monoflow
static void
newgroup_draw(NewGroup *group, DiaRenderer *renderer)
{
  Point lr_corner;
  Element *elem;
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);

  
  assert(group != NULL);
  assert(renderer != NULL);

  elem = &group->element;

  lr_corner.x = elem->corner.x + elem->width;
  lr_corner.y = elem->corner.y + elem->height;

  renderer_ops->set_linewidth(renderer, 0.01);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);
  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);

  renderer_ops->draw_rect(renderer, 
			  &elem->corner,
			  &lr_corner, 
			  &color_black);
}
예제 #10
0
파일: layer.c 프로젝트: AmiGanguli/dia
/*! The default object renderer.
 * @param obj An object to render.
 * @param renderer The renderer to render on.
 * @param active_layer The layer containing the object.
 * @param data The diagram containing the layer.
 * \ingroup DiagramStructure
 */
static void
normal_render(DiaObject *obj, DiaRenderer *renderer,
	      int active_layer,
	      gpointer data)
{
  DIA_RENDERER_GET_CLASS(renderer)->draw_object(renderer, obj, NULL);
}
예제 #11
0
파일: zigzagline.c 프로젝트: brunetton/dia
static void
zigzagline_draw(Zigzagline *zigzagline, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  OrthConn *orth = &zigzagline->orth;
  Point *points;
  int n;
  
  points = &orth->points[0];
  n = orth->numpoints;
  
  renderer_ops->set_linewidth(renderer, zigzagline->line_width);
  renderer_ops->set_linestyle(renderer, zigzagline->line_style);
  renderer_ops->set_dashlength(renderer, zigzagline->dashlength);
  renderer_ops->set_linejoin(renderer, zigzagline->line_join);
  renderer_ops->set_linecaps(renderer, zigzagline->line_caps);

  renderer_ops->draw_rounded_polyline_with_arrows(renderer,
						  points, n,
						  zigzagline->line_width,
						  &zigzagline->line_color,
						  &zigzagline->start_arrow,
						  &zigzagline->end_arrow,
						  zigzagline->corner_radius);

}
예제 #12
0
파일: polyline.c 프로젝트: mpuels/dia
static void
polyline_draw(Polyline *polyline, DiaRenderer *renderer)
{
  Point gap_endpoints[2];
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  PolyConn *poly = &polyline->poly;
  Point *points;
  int n;
  
  points = &poly->points[0];
  n = poly->numpoints;
  renderer_ops->set_linewidth(renderer, polyline->line_width);
  renderer_ops->set_linestyle(renderer, polyline->line_style, polyline->dashlength);
  renderer_ops->set_linejoin(renderer, polyline->line_join);
  renderer_ops->set_linecaps(renderer, polyline->line_caps);

  polyline_calculate_gap_endpoints(polyline, gap_endpoints);
  polyline_exchange_gap_points(polyline, gap_endpoints);
  renderer_ops->draw_rounded_polyline_with_arrows(renderer,
						  points, n,
						  polyline->line_width,
						  &polyline->line_color,
						  &polyline->start_arrow,
						  &polyline->end_arrow,
						  polyline->corner_radius);
  polyline_exchange_gap_points(polyline, gap_endpoints);
}
예제 #13
0
파일: dia-renderer.cpp 프로젝트: UIKit0/dia
// specialized draw_rounded_polyline() for renderers with an own concept of Arrow
void 
dia::Renderer::draw_rounded_polyline_with_arrows (Point *points, int num_points, real line_width, Color *color,
					          Arrow *start_arrow, Arrow *end_arrow, real radius)
{
    assert (self);
    DIA_RENDERER_GET_CLASS(self)->draw_rounded_polyline_with_arrows (self, points, num_points, line_width, color, start_arrow, end_arrow, radius);
}
예제 #14
0
파일: line.c 프로젝트: mpuels/dia
static void
line_draw(Line *line, DiaRenderer *renderer)
{
  Point gap_endpoints[2];

  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  
  assert(line != NULL);
  assert(renderer != NULL);

  renderer_ops->set_linewidth(renderer, line->line_width);
  renderer_ops->set_linestyle(renderer, line->line_style, line->dashlength);
  renderer_ops->set_linecaps(renderer, line->line_caps);

  if (line->absolute_start_gap || line->absolute_end_gap ) {
    line_adjust_for_absolute_gap(line, gap_endpoints);

    renderer_ops->draw_line_with_arrows(renderer,
					&gap_endpoints[0], &gap_endpoints[1],
					line->line_width,
					&line->line_color,
					&line->start_arrow,
					&line->end_arrow);
  } else {
        renderer_ops->draw_line_with_arrows(renderer,
					    &line->connection.endpoints[0], 
					    &line->connection.endpoints[1],
					    line->line_width,
					    &line->line_color,
					    &line->start_arrow,
					    &line->end_arrow);

  }
}
예제 #15
0
파일: arrow.c 프로젝트: montsuqi/monpe
static void draw_dot(DiaRenderer *renderer,
		     Point *end, Point *vect, Color *col)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Point vv,vp,vt,pt;
  real vlen;
  vv = *end;
  point_sub(&vv,vect);
  vlen = distance_point_point(vect,end);
  if (vlen < 1E-7) return;
  point_scale(&vv,1/vlen);

  vp.y = vv.x;
  vp.x = -vv.y;

  pt = *end;
    vt = vp;
  point_scale(&vt,ARROW_DOT_WOFFSET);
  point_add(&pt,&vt);
  vt = vv;
  point_scale(&vt,-ARROW_DOT_LOFFSET);
  point_add(&pt,&vt);
  
  renderer_ops->set_fillstyle(renderer,FILLSTYLE_SOLID);
  renderer_ops->fill_ellipse(renderer,&pt,
			 ARROW_DOT_RADIUS,ARROW_DOT_RADIUS,
			 col);
}
예제 #16
0
파일: activity.c 프로젝트: krattai/monoflow
static void
state_draw(State *state, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point p1, p2;

  assert(state != NULL);
  assert(renderer != NULL);

  elem = &state->element;

  x = elem->corner.x;
  y = elem->corner.y;
  w = elem->width;
  h = elem->height;
  
  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, STATE_LINEWIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);

   p1.x = x;
   p1.y = y;
   p2.x = x + w;
   p2.y = y + h;
   renderer_ops->fill_rounded_rect(renderer, &p1, &p2,
				   &state->fill_color, 1.0);
   renderer_ops->draw_rounded_rect(renderer, &p1, &p2,
				   &state->line_color, 1.0);
   
   text_draw(state->text, renderer);
}
예제 #17
0
static void aadlsubprogram_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point center;

  assert(aadlbox != NULL);
  assert(renderer != NULL);

  elem = &aadlbox->element;

  x = elem->corner.x;
  y = elem->corner.y;
  w = elem->width;
  h = elem->height;

  center.x = x + 0.5*w;
  center.y = y + 0.5*h;

  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);

  renderer_ops->fill_ellipse(renderer, &center, w, h, &aadlbox->fill_color);
  renderer_ops->draw_ellipse(renderer, &center, w, h, &aadlbox->line_color);

}
예제 #18
0
파일: branch.c 프로젝트: UIKit0/dia
static void branch_draw(Branch *branch, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real w, h;
  Point points[4];
  
  assert(branch != NULL);
  assert(renderer != NULL);

  elem = &branch->element;
  w = elem->width/2;
  h = elem->height/2;
  points[0].x = elem->corner.x,       points[0].y = elem->corner.y + h;
  points[1].x = elem->corner.x + w,   points[1].y = elem->corner.y;
  points[2].x = elem->corner.x + 2*w, points[2].y = elem->corner.y + h;
  points[3].x = elem->corner.x + w,   points[3].y = elem->corner.y + 2*h;
  
  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, BRANCH_BORDERWIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);

  renderer_ops->fill_polygon(renderer, points, 4, &branch->fill_color);
  renderer_ops->draw_polygon(renderer, points, 4, &branch->line_color);
}
예제 #19
0
void
grid_draw(DDisplay *ddisp, Rectangle *update)
{
  Grid *grid = &ddisp->grid;
  DiaRenderer *renderer = ddisp->renderer;

  if (grid->visible) {
    /* distance between visible grid lines */
    real width_x = ddisp->diagram->grid.width_x;
    real width_y = ddisp->diagram->grid.width_y;
    real width_w = ddisp->diagram->grid.width_w;
    if (ddisp->diagram->grid.dynamic) {
      calculate_dynamic_grid(ddisp, &width_x, &width_y);
    } else {
      width_x = ddisp->diagram->grid.width_x *
	ddisp->diagram->grid.visible_x;
      width_y = ddisp->diagram->grid.width_y *
	ddisp->diagram->grid.visible_y;
    }

    DIA_RENDERER_GET_CLASS(renderer)->set_linewidth(renderer, 0.0);
    
    if (ddisp->diagram->grid.hex) {
      grid_draw_hex(ddisp, update, width_w);
    } else {
      if (ddisplay_transform_length(ddisp, width_y) >= 2.0 &&
	  ddisplay_transform_length(ddisp, width_x) >= 2.0) {
	/* Vertical lines: */
	grid_draw_vertical_lines(ddisp, update, width_x);
	/* Horizontal lines: */
	grid_draw_horizontal_lines(ddisp, update, width_y);
      }
    }
  }
}
예제 #20
0
파일: eimage.c 프로젝트: montsuqi/monpe
static void
image_draw(EImage *image, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Point ul_corner, lr_corner;
  Element *elem;
  
  assert(image != NULL);
  assert(renderer != NULL);

  elem = &image->element;
  
  lr_corner.x = elem->corner.x + elem->width + image->border_width/2;
  lr_corner.y = elem->corner.y + elem->height + image->border_width/2;
  
  ul_corner.x = elem->corner.x - image->border_width/2;
  ul_corner.y = elem->corner.y - image->border_width/2;

  if (image->draw_border) {
    renderer_ops->set_linewidth(renderer, image->border_width);
    renderer_ops->set_linestyle(renderer, image->line_style);
    renderer_ops->set_dashlength(renderer, image->dashlength);
    renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
    
    renderer_ops->draw_rect(renderer, 
			     &ul_corner,
			     &lr_corner, 
			     &image->border_color);
  }
  /* Draw the image */
  if (image->image) {
    if (image->keep_orig_aspect) {
      real aspect;
      real width,height;
      Point corner;
      
      aspect = (real)dia_image_width(image->image) / 
        (real)dia_image_height(image->image);

      width = elem->height * aspect;
      if (width < elem->width) {
        height = elem->height;
      } else {
        width = elem->width;
        height = elem->width * (1.0/aspect);
      }
      corner.x = elem->corner.x + elem->width / 2.0 - width / 2.0;
      corner.y = elem->corner.y + elem->height / 2.0 - height / 2.0;
      renderer_ops->draw_image(renderer,&corner,width,height,image->image);
    } else {
      renderer_ops->draw_image(renderer, &elem->corner, elem->width,
	  		      elem->height, image->image);
    }
  } else {
    DiaImage *broken = dia_image_get_broken();
    renderer_ops->draw_image(renderer, &elem->corner, elem->width,
			      elem->height, broken);
    dia_image_unref(broken);
  }
}
예제 #21
0
파일: constraint.c 프로젝트: AmiGanguli/dia
static void
constraint_draw(Constraint *constraint, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Point *endpoints;
  Arrow arrow;

  assert(constraint != NULL);
  assert(renderer != NULL);

  endpoints = &constraint->connection.endpoints[0];
  
  renderer_ops->set_linewidth(renderer, constraint->line_width);
  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED, CONSTRAINT_DASHLEN);
  renderer_ops->set_linecaps(renderer, LINECAPS_BUTT);

  arrow.type = ARROW_LINES;
  arrow.length = CONSTRAINT_ARROWLEN;
  arrow.width = CONSTRAINT_ARROWWIDTH;

  renderer_ops->draw_line_with_arrows(renderer,
				       &endpoints[0], &endpoints[1],
				       constraint->line_width,
				       &constraint->line_color,
				       NULL, &arrow);
  
  renderer_ops->set_font(renderer, constraint->font,
			  constraint->font_height);
  renderer_ops->draw_string(renderer,
			     constraint->brtext,
			     &constraint->text_pos, ALIGN_LEFT,
			     &constraint->text_color);
}
예제 #22
0
파일: grid_object.c 프로젝트: brunetton/dia
static void
grid_object_draw(Grid_Object *grid_object, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  Point lr_corner;
  
  g_assert(grid_object != NULL);
  g_assert(renderer != NULL);

  elem = &grid_object->element;

  lr_corner.x = elem->corner.x + elem->width;
  lr_corner.y = elem->corner.y + elem->height;

  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);

  /* draw background */
  if (grid_object->show_background)
    renderer_ops->fill_rect(renderer,&elem->corner,
                                &lr_corner,
                                &grid_object->inner_color);

  /* draw gridlines */
  renderer_ops->set_linewidth(renderer, grid_object->gridline_width);
  grid_object_draw_gridlines(grid_object, renderer, &lr_corner);
  
  /* draw outline */
  renderer_ops->set_linewidth(renderer, grid_object->border_line_width);
  renderer_ops->draw_rect(renderer,&elem->corner,
                              &lr_corner,
                              &grid_object->border_color);
}
예제 #23
0
파일: dia-renderer.cpp 프로젝트: UIKit0/dia
// specialized draw_line() for renderers with an own concept of Arrow
void 
dia::Renderer::draw_arc_with_arrows  (Point *start, Point *end, Point *midpoint, real line_width, Color *color,
                                      Arrow *start_arrow, Arrow *end_arrow)
{
    assert (self);
    DIA_RENDERER_GET_CLASS(self)->draw_arc_with_arrows (self, start, end, midpoint, line_width, color, start_arrow, end_arrow);
}
예제 #24
0
파일: aadldata.c 프로젝트: mpuels/dia
static void
aadldata_draw_borders(Aadlbox *aadlbox, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point points[2];

  assert(aadlbox != NULL);
  assert(renderer != NULL);

  elem = &aadlbox->element;

  x = elem->corner.x;
  y = elem->corner.y;
  w = elem->width;
  h = elem->height;

  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);

  points[0].x = x;     points[0].y = y;
  points[1].x = x + w; points[1].y = y + h;

  renderer_ops->draw_rect(renderer, points, points + 1, &aadlbox->fill_color, &aadlbox->line_color);
}
예제 #25
0
파일: dia-renderer.cpp 프로젝트: UIKit0/dia
// specialized draw_bezier() for renderers with an own concept of Arrow
void 
dia::Renderer::draw_bezier_with_arrows (BezPoint *points, int num_points, real line_width, Color *color,
                                        Arrow *start_arrow, Arrow *end_arrow)
{
    assert (self);
    DIA_RENDERER_GET_CLASS(self)->draw_bezier_with_arrows (self, points, num_points, line_width, color, start_arrow, end_arrow);
}
예제 #26
0
파일: requirement.c 프로젝트: UIKit0/dia
/** draw is here */
static void
req_draw(Requirement *req, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point c;

  assert(req != NULL);
  assert(renderer != NULL);

  elem = &req->element;

  x = elem->corner.x;
  y = elem->corner.y;

  w = elem->width;
  h = elem->height;
  c.x = x + w/2.0;
  c.y = y + h/2.0;

  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, REQ_LINEWIDTH);

  renderer_ops->set_dashlength(renderer, REQ_DASHLEN);
  renderer_ops->set_linestyle(renderer, LINESTYLE_DASHED);

  renderer_ops->fill_ellipse(renderer, &c, w, h, &color_white);
  renderer_ops->draw_ellipse(renderer, &c, w, h, &color_black);

  text_draw(req->text, renderer);
}
예제 #27
0
파일: ellipse.c 프로젝트: brunetton/dia
static void
ellipse_draw(Ellipse *ellipse, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  Point center;
  
  assert(ellipse != NULL);
  assert(renderer != NULL);

  elem = &ellipse->element;

  center.x = elem->corner.x + elem->width/2;
  center.y = elem->corner.y + elem->height/2;

  if (ellipse->show_background) {
    renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  
    renderer_ops->fill_ellipse(renderer, &center,
				elem->width, elem->height,
				&ellipse->inner_color);
  }

  renderer_ops->set_linewidth(renderer, ellipse->border_width);
  renderer_ops->set_linestyle(renderer, ellipse->line_style);
  renderer_ops->set_dashlength(renderer, ellipse->dashlength);
  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);

  renderer_ops->draw_ellipse(renderer, &center,
			      elem->width, elem->height,
			      &ellipse->border_color);

  text_draw(ellipse->text, renderer);
}
예제 #28
0
파일: goal.c 프로젝트: AmiGanguli/dia
/* drawing stuff */
static void
goal_draw(Goal *goal, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Point p1,p2;
  BezPoint bpl[5];
  Element *elem;

  /* some asserts */
  assert(goal != NULL);
  assert(renderer != NULL);

  elem = &goal->element;

  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID, 0.0);
  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);
  renderer_ops->set_linewidth(renderer, GOAL_LINE_WIDTH);

  if (goal->type==GOAL) {  /* goal */
    p1.x=elem->corner.x;
    p1.y= elem->corner.y;
    p2.x=p1.x+elem->width;
    p2.y=p1.y+elem->height;
    renderer_ops->draw_rounded_rect (renderer,&p1,&p2,
				     &GOAL_BG_COLOR, &GOAL_FG_COLOR,
				     elem->height/2.0);
  } else {                 /* softgoal */
     compute_cloud(goal,bpl);
     renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
     renderer_ops->draw_beziergon(renderer,bpl,5,&GOAL_BG_COLOR,&GOAL_FG_COLOR);
  }

  /* drawing text */
  text_draw(goal->text, renderer);
}
예제 #29
0
파일: chronoref.c 프로젝트: UIKit0/dia
static void
chronoref_draw(Chronoref *chronoref, DiaRenderer *renderer)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  Point lr_corner;
  real t;
  Point p1,p2,p3;

  assert(renderer != NULL);

  elem = &chronoref->element;
  
  renderer_ops->set_linestyle(renderer, LINESTYLE_SOLID);
  renderer_ops->set_linejoin(renderer, LINEJOIN_MITER);


  lr_corner.x = elem->corner.x + elem->width;
  lr_corner.y = elem->corner.y + elem->height;

  p1.y = p2.y = elem->corner.y;

  renderer_ops->set_font(renderer, chronoref->font, chronoref->font_size);
  p3.y = p2.y + chronoref->majgrad_height + 
    dia_font_ascent("1",chronoref->font, chronoref->font_size);

  renderer_ops->set_linewidth(renderer, chronoref->light_lwidth);
  if (chronoref->time_lstep > 0.0) {
    p2.y = p1.y + chronoref->mingrad_height;
    for (t = chronoref->firstmaj, p1.x = chronoref->firstmin_x; 
	 p1.x <= lr_corner.x; 
	 t += chronoref->time_lstep, p1.x += chronoref->mingrad) {
      p2.x = p1.x;
    
      renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
    }
  }

  renderer_ops->set_linewidth(renderer, chronoref->main_lwidth);
  if (chronoref->time_step > 0.0) {
    p2.y = p1.y + chronoref->majgrad_height;

    for (t = chronoref->firstmaj, p1.x = chronoref->firstmaj_x; 
	 p1.x <= lr_corner.x; 
	 t += chronoref->time_step, p1.x += chronoref->majgrad) {
      char time[10];
      p3.x = p2.x = p1.x;
    
      renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
      g_snprintf(time,sizeof(time),"%.*f",chronoref->spec,t);
      renderer_ops->draw_string(renderer,time,&p3,ALIGN_CENTER,
				 &chronoref->font_color);
    }
  }
  p1.x = elem->corner.x;
  p2.x = lr_corner.x;
  p1.y = p2.y = elem->corner.y;

  renderer_ops->draw_line(renderer,&p1,&p2,&chronoref->color);
}
예제 #30
0
void aadlbox_draw_inclined_box(Aadlbox *aadlbox, DiaRenderer *renderer,
				      LineStyle linestyle)
{
  DiaRendererClass *renderer_ops = DIA_RENDERER_GET_CLASS (renderer);
  Element *elem;
  real x, y, w, h;
  Point points[4];

  assert(aadlbox != NULL);
  assert(renderer != NULL);

  elem = &aadlbox->element;

  x = elem->corner.x;
  y = elem->corner.y;
  w = elem->width;
  h = elem->height;

  points[0].x = x + w * AADLBOX_INCLINE_FACTOR;
  points[1].x = x + w;
  points[0].y = points[1].y = y;

  points[3].x = x;
  points[2].x = x + w - w * AADLBOX_INCLINE_FACTOR;
  points[3].y = points[2].y = y + h;

  renderer_ops->set_fillstyle(renderer, FILLSTYLE_SOLID);
  renderer_ops->set_linewidth(renderer, AADLBOX_BORDERWIDTH);
  renderer_ops->set_linestyle(renderer, linestyle);
  renderer_ops->set_dashlength(renderer, AADLBOX_DASH_LENGTH);

  renderer_ops->fill_polygon(renderer, points, 4, &aadlbox->fill_color);
  renderer_ops->draw_polygon(renderer, points, 4, &aadlbox->line_color);
}