static void
gtk_plot_canvas_ellipse_draw (GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child)
{
GtkPlotCanvasEllipse *ellipse = GTK_PLOT_CANVAS_ELLIPSE(child);
gint width = child->allocation.width;
gint height = child->allocation.height;
if(width == 0 && height == 0) return;
if(ellipse->filled){
gtk_plot_pc_set_color(canvas->pc, &ellipse->bg);
gtk_plot_pc_draw_ellipse(canvas->pc, TRUE,
child->allocation.x, child->allocation.y,
width, height);
}
gtk_plot_canvas_set_line_attributes(canvas, ellipse->line);
if(ellipse->line.line_style != GTK_PLOT_LINE_NONE)
gtk_plot_pc_draw_ellipse(canvas->pc, FALSE,
child->allocation.x, child->allocation.y,
width, height);
}
static void
gtk_plot_canvas_rectangle_draw (GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child)
{
GtkPlotCanvasRectangle *rectangle = GTK_PLOT_CANVAS_RECTANGLE(child);
gint width = child->allocation.width;
gint height = child->allocation.height;
gdouble m = canvas->magnification;
if(width == 0 && height == 0) return;
if(rectangle->filled){
gtk_plot_pc_set_color(canvas->pc, &rectangle->bg);
gtk_plot_pc_draw_rectangle(canvas->pc, TRUE,
child->allocation.x, child->allocation.y,
width, height);
}
if(rectangle->line.line_style != GTK_PLOT_LINE_NONE &&
rectangle->border != GTK_PLOT_BORDER_NONE){
gtk_plot_canvas_set_line_attributes(canvas, rectangle->line);
gtk_plot_pc_draw_rectangle(canvas->pc, FALSE,
child->allocation.x, child->allocation.y,
width, height);
if(rectangle->border == GTK_PLOT_BORDER_SHADOW){
gtk_plot_pc_draw_rectangle(canvas->pc,
TRUE,
child->allocation.x + roundint(rectangle->shadow_width * m),
child->allocation.y + height,
width, roundint(rectangle->shadow_width * m));
gtk_plot_pc_draw_rectangle(canvas->pc,
TRUE,
child->allocation.x + width,
child->allocation.y + roundint(rectangle->shadow_width * m),
roundint(rectangle->shadow_width * m), height); }
}
}
static void
gtk_plot_bar_draw_legend(GtkPlotData *data, gint x, gint y)
{
GtkPlotBar *bar;
GtkPlot *plot = NULL;
GtkPlotText legend;
GdkRectangle area;
gint lascent, ldescent, lheight, lwidth;
gdouble m;
bar = GTK_PLOT_BAR(data);
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
g_return_if_fail(GTK_WIDGET_VISIBLE(data));
g_return_if_fail(GTK_WIDGET_VISIBLE(data->plot));
plot = data->plot;
area.x = GTK_WIDGET(plot)->allocation.x;
area.y = GTK_WIDGET(plot)->allocation.y;
area.width = GTK_WIDGET(plot)->allocation.width;
area.height = GTK_WIDGET(plot)->allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
if(data->legend)
legend.text = data->legend;
else
legend.text = "";
gtk_plot_text_get_size(legend.text, legend.angle, legend.font,
roundint(legend.height * m),
&lwidth, &lheight,
&lascent, &ldescent);
legend.x = (gdouble)(area.x + x + roundint((plot->legends_line_width + 4) * m))
/ (gdouble)area.width;
legend.y = (gdouble)(area.y + y + lascent) / (gdouble)area.height;
gtk_plot_draw_text(plot, legend);
if(data->symbol.symbol_style == GTK_PLOT_SYMBOL_OPAQUE){
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
}
gtk_plot_pc_set_lineattr (plot->pc, data->symbol.border.line_width, 0, 0, 0);
gtk_plot_pc_set_dash(plot->pc, 0, 0, 0);
if(data->symbol.symbol_style == GTK_PLOT_SYMBOL_FILLED){
gtk_plot_pc_set_color(plot->pc, &data->symbol.color);
gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
}
gtk_plot_pc_set_color(plot->pc, &data->symbol.border.color);
gtk_plot_pc_draw_rectangle(plot->pc, FALSE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
}
static void
gtk_plot_candle_draw_legend(GtkPlotData *data, gint x, gint y)
{
GtkPlotCandle *box;
GtkPlot *plot = NULL;
GtkPlotText legend;
GdkRectangle area;
gint lascent, ldescent, lheight, lwidth;
gdouble m;
box = GTK_PLOT_CANDLE(data);
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
if(!GTK_WIDGET_REALIZED(data->plot)) return;
plot = data->plot;
area.x = GTK_WIDGET(plot)->allocation.x;
area.y = GTK_WIDGET(plot)->allocation.y;
area.width = GTK_WIDGET(plot)->allocation.width;
area.height = GTK_WIDGET(plot)->allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
if(data->legend)
legend.text = data->legend;
else
legend.text = "";
gtk_plot_text_get_size(legend.text, legend.angle, legend.font,
roundint(legend.height * m),
&lwidth, &lheight,
&lascent, &ldescent);
legend.x = (gdouble)(area.x + x + roundint((plot->legends_line_width + 4) * m))
/ (gdouble)area.width;
legend.y = (gdouble)(area.y + y + lascent) / (gdouble)area.height;
gtk_plot_draw_text(plot, legend);
gtk_plot_pc_set_lineattr (plot->pc, data->symbol.border.line_width, 0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
gtk_plot_pc_set_color(plot->pc, &data->symbol.color);
if(data->symbol.symbol_style == GTK_PLOT_SYMBOL_EMPTY){
gtk_plot_pc_draw_line(plot->pc,
x,
y + (lascent + ldescent) / 2,
x + roundint(plot->legends_line_width * m),
y + (lascent + ldescent) / 2);
} else {
gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
gtk_plot_pc_set_color(plot->pc, &data->symbol.border.color);
gtk_plot_pc_draw_rectangle(plot->pc, FALSE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
}
}
static void
gtk_plot_bar_draw_symbol(GtkPlotData *dataset,
gdouble x, gdouble y, gdouble z, gdouble a,
gdouble dx, gdouble dy, gdouble dz, gdouble da)
{
GtkPlot *plot;
GtkPlotBar *bar;
GdkRectangle area, clip_area;
gdouble px, py, px0, py0;
gdouble x1 = 0.0, y1 = 0.0, width = 0.0, height = 0.0;
gdouble ex, ey;
bar = GTK_PLOT_BAR(dataset);
plot = dataset->plot;
area.x = GTK_WIDGET(plot)->allocation.x;
area.y = GTK_WIDGET(plot)->allocation.y;
area.width = GTK_WIDGET(plot)->allocation.width;
area.height = GTK_WIDGET(plot)->allocation.height;
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
clip_area.width = roundint(plot->width * area.width);
clip_area.height = roundint(plot->height * area.height);
gtk_plot_pc_clip(plot->pc, &clip_area);
if(GTK_IS_PLOT3D(plot)){
} else {
switch(bar->orientation){
case GTK_ORIENTATION_VERTICAL:
gtk_plot_get_pixel(plot, x-bar->width, y, &px, &py);
gtk_plot_get_pixel(plot, x+bar->width, MAX(0., plot->ymin), &px0, &py0);
if(dataset->show_yerrbars)
gtk_plot_get_pixel(plot, x, y + dy, &ex, &ey);
break;
case GTK_ORIENTATION_HORIZONTAL:
gtk_plot_get_pixel(plot, y, x+bar->width, &px, &py);
gtk_plot_get_pixel(plot, MAX(0., plot->xmin), x-bar->width, &px0, &py0);
if(dataset->show_xerrbars)
gtk_plot_get_pixel(plot, y + dy, x, &ex, &ey);
break;
}
x1 = MIN(px, px0);
y1 = MIN(py, py0);
if(GTK_IS_PLOT_PS(plot->pc)){
width = fabs(px - px0);
height = fabs(py0 - py);
}
else
{
width = abs(roundint(px - px0));
height = abs(roundint(py0 - py));
}
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_OPAQUE){
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width, height);
}
gtk_plot_pc_set_lineattr (plot->pc, dataset->symbol.border.line_width,
0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_FILLED){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width, height);
}
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_pc_draw_rectangle (plot->pc,
FALSE,
x1, y1, width, height);
if(dataset->show_yerrbars){
gtk_plot_pc_draw_line(plot->pc, ex, py, ex, ey);
gtk_plot_pc_draw_line(plot->pc, px, ey, px0, ey);
}
if(dataset->show_xerrbars){
gtk_plot_pc_draw_line(plot->pc, px, ey, ex, ey);
gtk_plot_pc_draw_line(plot->pc, ex, py, ex, py0);
}
}
gtk_plot_pc_clip(plot->pc, NULL);
}
static void
gtk_plot_surface_draw_legend(GtkPlotData *data, gint x, gint y)
{
GtkPlotSurface *surface;
GtkPlot *plot = NULL;
GtkPlotText legend;
GdkRectangle area;
gint lascent, ldescent, lheight, lwidth;
gdouble m;
surface = GTK_PLOT_SURFACE(data);
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
plot = data->plot;
area.x = GTK_WIDGET(plot)->allocation.x;
area.y = GTK_WIDGET(plot)->allocation.y;
area.width = GTK_WIDGET(plot)->allocation.width;
area.height = GTK_WIDGET(plot)->allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
if(data->legend)
legend.text = data->legend;
else
legend.text = "";
gtk_plot_text_get_size(legend.text, legend.angle, legend.font,
roundint(legend.height * m),
&lwidth, &lheight,
&lascent, &ldescent);
if(!surface->height_gradient){
gtk_plot_pc_set_color(plot->pc, &surface->color);
gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
x, y,
roundint(plot->legends_line_width * m),
lascent + ldescent);
}else{
gdouble level, step;
gint lx = x, lstep;
step = (data->gradient.end - data->gradient.begin) / 10;
lstep = roundint(plot->legends_line_width * m / 10.);
for(level = data->gradient.begin; level < data->gradient.end; level += step){
GdkColor color;
gtk_plot_data_get_gradient_level(data, level, &color);
gtk_plot_pc_set_color(plot->pc, &color);
gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
lx, y,
lstep, lascent + ldescent);
lx += lstep;
}
}
legend.x = (gdouble)(area.x + x + roundint((plot->legends_line_width + 4) * m))
/ (gdouble)area.width;
legend.y = (gdouble)(area.y + y + lascent) / (gdouble)area.height;
gtk_plot_draw_text(plot, legend);
y += 2*lheight;
gtk_plot_data_draw_gradient(data, x, y);
}
static void
gtk_plot_candle_draw_symbol(GtkPlotData *dataset,
gdouble x, gdouble y, gdouble z, gdouble a,
gdouble dx, gdouble dy, gdouble dz, gdouble da)
{
GtkPlot *plot;
GtkPlotCandle *box = NULL;
gdouble px, py, pz, ex, ey, ez;
gdouble x1 = 0.0, y1 = 0.0, width = 0.0, height = 0.0;
gdouble m;
gboolean filled;
gdouble a_scale;
g_return_if_fail(GTK_IS_PLOT_CANDLE(dataset));
box = GTK_PLOT_CANDLE(dataset);
g_return_if_fail(dataset->plot != NULL);
plot = dataset->plot;
a_scale = gtk_plot_data_get_a_scale(dataset);
m = plot->magnification * a_scale;
gtk_plot_pc_set_lineattr (plot->pc, dataset->symbol.border.line_width,
0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
if(x >= plot->xmin && x <= plot->xmax){
if(GTK_IS_PLOT3D(plot)){
}else if(dataset->show_zerrbars){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_get_pixel(plot, x, y, &px, &py);
gtk_plot_get_pixel(plot, x, z, &px, &pz);
width = m * dataset->symbol.size / 2;
x1 = px - width;
y1 = MIN(py, pz);
filled = z < y;
height = abs(py - pz);
gtk_plot_get_pixel(plot, x, dy, &ex, &ey);
gtk_plot_get_pixel(plot, x, dz, &ex, &ez);
gtk_plot_pc_draw_line(plot->pc, px, py, px, ey);
gtk_plot_pc_draw_line(plot->pc, px, pz, px, ez);
if(!filled && dataset->symbol.symbol_style != GTK_PLOT_SYMBOL_EMPTY){
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width * 2, height);
}
if(dataset->symbol.symbol_style == GTK_PLOT_SYMBOL_EMPTY){
GtkPlotPoint lines[4];
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
lines[0].x = px - width;
lines[0].y = py;
lines[1].x = px;
lines[1].y = py;
lines[2].x = px;
lines[2].y = pz;
lines[3].x = px + width;
lines[3].y = pz;
gtk_plot_pc_draw_lines(plot->pc, lines, 4);
} else {
if(filled){
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.color);
gtk_plot_pc_draw_rectangle (plot->pc,
TRUE,
x1, y1, width * 2, height);
}
gtk_plot_pc_set_color(plot->pc, &dataset->symbol.border.color);
gtk_plot_pc_draw_rectangle (plot->pc,
FALSE,
x1, y1, width * 2, height);
}
}
}
}
static void
gtk_plot_surface_draw_triangle (GtkPlotSurface *surface,
GtkPlotDTtriangle *triangle,
gint sign)
{
GtkPlot *plot;
GtkPlotVector side1, side2, light, normal;
GtkPlotVector points[3];
GtkPlotPoint t[3];
GdkDrawable *drawable;
GdkColor color, real_color;
gdouble factor, norm;
gboolean visible = TRUE;
plot = GTK_PLOT(GTK_PLOT_DATA(surface)->plot);
drawable = plot->drawable;
points[0].x = triangle->na->x;
points[0].y = triangle->na->y;
points[0].z = triangle->na->z;
points[1].x = triangle->nb->x;
points[1].y = triangle->nb->y;
points[1].z = triangle->nb->z;
points[2].x = triangle->nc->x;
points[2].y = triangle->nc->y;
points[2].z = triangle->nc->z;
t[0].x = triangle->na->px;
t[0].y = triangle->na->py;
t[1].x = triangle->nb->px;
t[1].y = triangle->nb->py;
t[2].x = triangle->nc->px;
t[2].y = triangle->nc->py;
side1.x = (points[1].x - points[0].x) * sign;
side1.y = (points[1].y - points[0].y) * sign;
side1.z = (points[1].z - points[0].z) * sign;
side2.x = (points[2].x - points[0].x) * sign;
side2.y = (points[2].y - points[0].y) * sign;
side2.z = (points[2].z - points[0].z) * sign;
if(surface->height_gradient){
gtk_plot_data_get_gradient_level(GTK_PLOT_DATA(surface),
(triangle->na->z +
triangle->nb->z +
triangle->nc->z) / 3.0,
&real_color);
}else{
color = surface->color;
light = surface->light;
norm = sqrt(light.x*light.x + light.y*light.y + light.z*light.z);
light.x /= norm;
light.y /= norm;
light.z /= norm;
if(GTK_IS_PLOT3D(plot)){
normal.x = side1.y * side2.z - side1.z * side2.y;
normal.y = side1.z * side2.x - side1.x * side2.z;
normal.z = side1.x * side2.y - side1.y * side2.x;
norm = sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z);
factor = (normal.x*light.x + normal.y*light.y + normal.z*light.z) / norm;
} else {
factor = 1.0;
}
gtk_plot_surface_lighting(&color, &real_color,
factor, surface->ambient);
}
if(GTK_IS_PLOT3D(plot))
if(((t[1].x-t[0].x)*(t[2].y-t[0].y) - (t[1].y-t[0].y)*(t[2].x-t[0].x))*sign > 0)
visible = FALSE;
if(visible)
gtk_plot_pc_set_color(plot->pc, &real_color);
else
gtk_plot_pc_set_color(plot->pc, &surface->shadow);
gtk_plot_pc_draw_polygon(plot->pc, !surface->transparent, t, 3);
if(visible)
gtk_plot_pc_set_color(plot->pc, &surface->grid_foreground);
else
gtk_plot_pc_set_color(plot->pc, &surface->grid_background);
if(surface->show_mesh || !surface->dt->quadrilateral)
gtk_plot_pc_draw_polygon(plot->pc, FALSE, t, 3);
if(!surface->show_mesh && surface->show_grid && surface->dt->quadrilateral)
gtk_plot_pc_draw_line(plot->pc,
t[1].x, t[1].y, t[2].x, t[2].y);
}
static void
gtk_plot_polar_draw_circle(GtkPlotPolar *polar)
{
GtkWidget *widget;
GtkPlot *plot;
GtkPlotAxis *axis, perp;
GtkPlotText tick;
gchar label[100];
gdouble x, y;
gint line_width;
gdouble xp, yp, width, height, size;
gint ntick;
gdouble m;
gdouble x_tick = 0.;
gdouble x1, y1;
gdouble ox, oy;
gint text_height, text_width, ascent, descent;
gdouble rotation;
gboolean veto = FALSE;
gint sign = 1;
GtkAllocation allocation;
widget = GTK_WIDGET(polar);
plot = GTK_PLOT(polar);
m = plot->magnification;
rotation = polar->rotation;
if(plot->reflect_y) sign = -1;
xp = plot->internal_allocation.x;
yp = plot->internal_allocation.y;
width = plot->internal_allocation.width;
height = plot->internal_allocation.height;
ox = width / 2.;
oy = height / 2.;
x = xp + ox;
y = yp + oy;
axis = plot->bottom;
line_width = axis->line.line_width;
gtk_plot_pc_set_color(plot->pc, &axis->line.color);
gtk_plot_pc_set_lineattr(plot->pc, axis->line.line_width, 0, 3, 0);
gtk_plot_get_pixel(plot,
plot->ymax,
90.0 - rotation,
&x1, &size);
size = fabs(size - y);
gtk_plot_pc_draw_circle (plot->pc,
FALSE,
x, y,
2 * size);
gtk_plot_pc_set_lineattr(plot->pc, axis->ticks_width, 0, 1, 0);
gtk_plot_text_get_size("0", 0, axis->labels_attr.font, roundint(axis->labels_attr.height * m), &text_width, &text_height, &ascent, &descent);
for(ntick = 0; ntick < axis->ticks.nticks; ntick++){
x_tick = axis->ticks.values[ntick].value;
if(!axis->ticks.values[ntick].minor && x_tick >= axis->ticks.min){
if(!axis->custom_labels){
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
}
else
{
g_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
&x_tick, label, &veto);
if(!veto)
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
}
gtk_plot_get_pixel(plot,
plot->ymax,
x_tick,
&x1, &y1);
x_tick += rotation;
if(axis->major_mask & GTK_PLOT_TICKS_IN){
perp.direction.x = cos(x_tick * PI / 180. * sign);
perp.direction.y = -sin(x_tick * PI / 180. * sign);
gtk_plot_pc_draw_line(plot->pc,
x1,
y1,
x1 + perp.direction.x*m*axis->ticks_length,
y1 + perp.direction.y*m*axis->ticks_length);
}
if(axis->major_mask & GTK_PLOT_TICKS_OUT){
perp.direction.x = -cos(x_tick * PI / 180. * sign);
perp.direction.y = sin(x_tick * PI / 180. * sign);
gtk_plot_pc_draw_line(plot->pc,
x1,
y1,
x1 - perp.direction.x*m*axis->ticks_length,
y1 - perp.direction.y*m*axis->ticks_length);
}
tick = axis->labels_attr;
tick.text = label;
if((x_tick >= 0.0 && x_tick < 90.0) || (x_tick > 270.0 && x_tick <= 360.0))
tick.justification = GTK_JUSTIFY_LEFT;
if(x_tick > 90.0 && x_tick < 270.0)
tick.justification = GTK_JUSTIFY_RIGHT;
if(x_tick == 90.0 || x_tick == 270.0)
tick.justification = GTK_JUSTIFY_CENTER;
y1 += text_height / 2;
if((x_tick - rotation) != 360.0 && axis->label_mask != 0){
gtk_widget_get_allocation (widget, &allocation);
perp.direction.x = -cos(x_tick * PI / 180. * sign);
perp.direction.y = sin(x_tick * PI / 180. * sign);
tick.x = x1;
tick.y = y1;
tick.x -= roundint(perp.direction.x*axis->labels_offset * m);
tick.y -= roundint(perp.direction.y*axis->labels_offset * m);
tick.x = (gdouble)tick.x / (gdouble)allocation.width;
tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
}
if(axis->ticks.values[ntick].minor && x_tick >= axis->ticks.min){
gtk_plot_get_pixel(plot,
plot->ymax,
x_tick,
&x1, &y1);
x_tick += rotation;
if(axis->minor_mask & GTK_PLOT_TICKS_IN){
perp.direction.x = cos(x_tick * PI / 180. * sign);
perp.direction.y = -sin(x_tick * PI / 180. * sign);
gtk_plot_pc_draw_line(plot->pc,
x1,
y1,
x1 + perp.direction.x*m*axis->ticks_length/2.,
y1 + perp.direction.y*m*axis->ticks_length/2.);
}
if(axis->minor_mask & GTK_PLOT_TICKS_OUT){
perp.direction.x = -cos(x_tick * PI / 180. * sign);
perp.direction.y = sin(x_tick * PI / 180. * sign);
gtk_plot_pc_draw_line(plot->pc,
x1,
y1,
x1 - perp.direction.x*m*axis->ticks_length/2.,
y1 - perp.direction.y*m*axis->ticks_length/2.);
}
}
}
}
static void
gtk_plot_polar_draw_labels(GtkPlotPolar *polar,
GtkPlotAxis *axis,
GtkPlotVector tick_direction)
{
GtkWidget *widget;
GtkPlot *plot;
GtkPlotText title, tick;
gchar label[100];
gdouble x_tick;
gint x, y;
gdouble xx, yy;
gint ox, oy;
gint text_height, text_width, ascent, descent;
gint xp, yp, width, height;
gint ntick;
gdouble m;
gboolean veto = FALSE;
gdouble x0, y0;
GtkAllocation allocation;
widget = GTK_WIDGET(polar);
plot = GTK_PLOT(polar);
m = plot->magnification;
xp = plot->internal_allocation.x;
yp = plot->internal_allocation.y;
width = plot->internal_allocation.width;
height = plot->internal_allocation.height;
ox = width / 2.;
oy = height / 2.;
x = xp + ox * axis->direction.x + axis->origin.x;
y = yp + oy * axis->direction.y + axis->origin.y;
gtk_plot_pc_set_color(plot->pc, &axis->labels_attr.fg);
gtk_plot_text_get_size("0", 0, axis->labels_attr.font, roundint(axis->labels_attr.height * m), &text_width, &text_height, &ascent, &descent);
switch(axis->labels_attr.angle){
case 0:
y += text_height / 2.;
break;
case 90:
break;
case 180:
y -= text_height / 2.;
break;
case 270:
break;
}
if(axis->direction.x == 0)
gtk_plot_get_pixel(plot, 0, -polar->rotation+90, &x0, &y0);
else
gtk_plot_get_pixel(plot, 0, -polar->rotation, &y0, &x0);
tick = axis->labels_attr;
for(ntick = 0; ntick < axis->ticks.nticks; ntick++){
if(axis->ticks.values[ntick].minor) continue;
x_tick = axis->ticks.values[ntick].value;
if(axis->direction.x == 0)
gtk_plot_get_pixel(plot, x_tick, -polar->rotation+90, &xx, &yy);
else
gtk_plot_get_pixel(plot, x_tick, -polar->rotation, &yy, &xx);
yy = yy - y0;
xx = axis->direction.x * yy;
yy = axis->direction.y * yy;
if(x_tick >= axis->ticks.min-1.e-9){
if(!axis->custom_labels){
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
}
else
{
g_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
&x_tick, label, &veto);
if(!veto)
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
}
tick.text = label;
gtk_widget_get_allocation (widget, &allocation);
if(axis->label_mask & GTK_PLOT_LABEL_IN){
tick.x = x + xx;
tick.y = y + yy;
tick.x = tick.x + tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y + tick_direction.y*roundint(axis->labels_offset * m);
tick.x = (gdouble)tick.x / (gdouble)allocation.width;
tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
tick.x = x - xx;
tick.y = y - yy;
tick.x = tick.x + tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y + tick_direction.y*roundint(axis->labels_offset * m);
tick.x = (gdouble)tick.x / (gdouble)allocation.width;
tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
if(axis->label_mask & GTK_PLOT_LABEL_OUT){
tick.x = x + xx;
tick.y = y + yy;
tick.x = tick.x - tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y - tick_direction.y*roundint(axis->labels_offset * m);
tick.x = (gdouble)tick.x / (gdouble)allocation.width;
tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
tick.x = x - xx;
tick.y = y - yy;
tick.x = tick.x - tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y - tick_direction.y*roundint(axis->labels_offset * m);
tick.x = (gdouble)tick.x / (gdouble)allocation.width;
tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
}
}
if(axis->title_visible && axis->title.text)
{
title = axis->title;
gtk_plot_draw_text(plot, title);
}
}
static void
gtk_plot_polar_real_paint (GtkWidget *widget)
{
GtkPlot *plot;
GtkPlotText *child_text;
GtkStyle *style;
GdkPixmap *pixmap;
GList *dataset;
GList *text;
gint width, height;
gint xoffset, yoffset ;
gdouble min;
if(!gtk_widget_get_visible(widget)) return;
plot = GTK_PLOT(widget);
xoffset = plot->internal_allocation.x;
yoffset = plot->internal_allocation.y;
width = plot->internal_allocation.width;
height = plot->internal_allocation.height;
style = gtk_widget_get_style(widget);
pixmap = plot->drawable;
gtk_plot_pc_gsave(plot->pc);
gtk_plot_pc_set_color(plot->pc, &plot->background);
if(!gtk_plot_is_transparent(GTK_PLOT(plot)))
gtk_plot_pc_draw_rectangle (plot->pc, TRUE,
xoffset, yoffset,
width , height);
/* draw frame to guide the eyes*/
/* gdk_draw_rectangle (pixmap, gc, FALSE,
xoffset, yoffset,
width , height);
*/
/* draw the ticks & grid lines */
min = plot->left->ticks.min;
plot->left->ticks.min = 0.0;
gtk_plot_axis_ticks_recalc(plot->left);
gtk_plot_axis_ticks_recalc(plot->bottom);
plot->left->ticks.min = min;
if(plot->left->is_visible)
{
GtkPlotVector tick_direction;
tick_direction.x = 1.;
tick_direction.y = 0.;
plot->left->origin.x = (gfloat)width*plot->left_align;
plot->left->origin.y = height;
gtk_plot_polar_draw_axis(GTK_PLOT_POLAR(plot), plot->left, tick_direction);
gtk_plot_polar_draw_labels(GTK_PLOT_POLAR(plot), plot->left, tick_direction);
}
if(plot->top->is_visible)
{
GtkPlotVector tick_direction;
tick_direction.x = 0.;
tick_direction.y = 1.;
plot->left->direction.x = 1;
plot->left->direction.y = 0;
plot->left->origin.x = 0;
plot->left->origin.y = (gfloat)height*plot->left_align;
gtk_plot_polar_draw_axis(GTK_PLOT_POLAR(plot), plot->left, tick_direction);
gtk_plot_polar_draw_labels(GTK_PLOT_POLAR(plot), plot->left, tick_direction);
plot->left->direction.x = 0;
plot->left->direction.y = -1;
}
if(plot->bottom->is_visible)
{
gtk_plot_polar_draw_circle(GTK_PLOT_POLAR(plot));
}
gtk_plot_polar_draw_grids(GTK_PLOT_POLAR(plot));
dataset = plot->data_sets;
while(dataset)
{
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(dataset->data)))->draw_data(GTK_PLOT_DATA(dataset->data));
dataset = dataset->next;
}
text = plot->text;
while(text)
{
child_text = (GtkPlotText *) text->data;
gtk_plot_draw_text(plot, *child_text);
text = text->next;
}
GTK_PLOT_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(plot)))->draw_legends(widget);
gtk_plot_pc_grestore(plot->pc);
}
static void
gtk_plot_flux_draw_arrow(GtkPlotFlux *flux, gdouble x1, gdouble y1, gdouble x2, gdouble y2)
{
GtkPlot *plot;
GtkPlotData *data;
GtkPlotPoint arrow[3];
gdouble xm, ym;
gdouble width, height;
gdouble arrow_width;
gdouble line_width;
gdouble angle;
gdouble length;
gdouble m;
data = GTK_PLOT_DATA(flux);
plot = data->plot;
m = plot->magnification;
width = fabs(x2 - x1);
height = fabs(y2 - y1);
/* This is a nan */
if (width != width || height != height) return;
if(width == 0 && height == 0) return;
if(width != 0)
angle = atan2((y2 - y1), (x2 - x1));
else
angle = asin((y2 - y1)/height);
length = (y2 - y1)*(y2 - y1) + (x2 - x1)*(x2 - x1);
if (length > 0.0) length = sqrt(length);
arrow_width = flux->arrow_width;
line_width = data->symbol.border.line_width;
gtk_plot_pc_set_color(plot->pc, &data->symbol.color);
gtk_plot_pc_set_lineattr (plot->pc, line_width, 0, 0, 0);
gtk_plot_pc_set_dash (plot->pc, 0, 0, 0);
if(flux->centered && width != 0){
x1 -= cos(angle) * length / 2.0;
x2 -= cos(angle) * length / 2.0;
}
if(flux->centered && height != 0){
y1 -= sin(angle) * length / 2.0;
y2 -= sin(angle) * length / 2.0;
}
if(flux->arrow_style == GTK_PLOT_SYMBOL_EMPTY)
gtk_plot_pc_draw_line(plot->pc, x1, y1, x2, y2);
else
gtk_plot_pc_draw_line(plot->pc, x1, y1,
x2 - flux->arrow_length * m * cos(angle) / 2.,
y2 - flux->arrow_length * m * sin(angle) / 2.);
arrow[1].x = x2;
arrow[1].y = y2;
xm = x2 - cos(angle) * flux->arrow_length * m;
ym = y2 - sin(angle) * flux->arrow_length * m;
arrow[0].x = xm - sin(angle)* arrow_width * m / 2.0;
arrow[0].y = ym + cos(angle)* arrow_width * m / 2.0;
arrow[2].x = xm + sin(angle)* arrow_width * m / 2.0;
arrow[2].y = ym - cos(angle)* arrow_width * m / 2.0;
switch(flux->arrow_style){
case GTK_PLOT_SYMBOL_EMPTY:
gtk_plot_pc_draw_lines (plot->pc, arrow, 3);
break;
case GTK_PLOT_SYMBOL_OPAQUE:
gtk_plot_pc_set_color(plot->pc, &plot->background);
gtk_plot_pc_draw_polygon (plot->pc, TRUE, arrow, 3);
gtk_plot_pc_set_color(plot->pc, &data->symbol.color);
gtk_plot_pc_draw_polygon (plot->pc, FALSE, arrow, 3);
break;
case GTK_PLOT_SYMBOL_FILLED:
gtk_plot_pc_draw_polygon (plot->pc, TRUE, arrow, 3);
}
}
