自学教程：C++ DIA_RENDERER_GET_CLASS函数代码示例

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);}

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);  }}

voidhandle_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);  }}

static voidbus_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);  }}

static voidbeziergon_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);  }}

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);}

static voidnewgroup_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);}

/*! 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 voidnormal_render(DiaObject *obj, DiaRenderer *renderer,	      int active_layer,	      gpointer data){  DIA_RENDERER_GET_CLASS(renderer)->draw_object(renderer, obj, NULL);}

static voidzigzagline_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);}

static voidpolyline_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);}

// specialized draw_rounded_polyline() for renderers with an own concept of Arrowvoid 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);}

static voidline_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);  }}

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);}

static voidstate_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);}

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);}

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);}

static voidimage_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);  }}

static voidconstraint_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);}

static voidgrid_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);}

static voidaadldata_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);}

/** draw is here */static voidreq_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);}

static voidellipse_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);}

/* drawing stuff */static voidgoal_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);}

static voidchronoref_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);}

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);}