[genius] Thu Jun 13 00:12:46 2013 Jiri (George) Lebl <jirka 5z com>
- From: George Lebl <jirka src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [genius] Thu Jun 13 00:12:46 2013 Jiri (George) Lebl <jirka 5z com>
- Date: Thu, 13 Jun 2013 05:16:31 +0000 (UTC)
commit 01e3e4433325810e6bd4bcc05d1a8521a02182b9
Author: Jiri (George) Lebl <jirka 5z com>
Date: Thu Jun 13 00:13:41 2013 -0500
Thu Jun 13 00:12:46 2013 Jiri (George) Lebl <jirka 5z com>
* gtkextra/*.c: start updating to gtkextra 3.0.5. Only few files
converted: gtkplotcanvas.[ch], gtkplotpc.[ch], gtkextra.[ch],
gtkplotprint.[ch]. Must slowly work through custom bugfixes and
patches. Note that gtkplotps.[ch] seems broken, so it's even
older than the other files.
Also added gtkplotcairo.[ch] for cairo output which is lots nicer
ChangeLog | 9 +
gtkextra/CONVERTEDTO3 | 7 +
gtkextra/Makefile.am | 3 +
gtkextra/gtkextra-compat.h | 89 +++
gtkextra/gtkextra.c | 4 +-
gtkextra/gtkextra.h | 7 +
gtkextra/gtkextratypebuiltins.c | 4 +-
gtkextra/gtkplotcairo.c | 1163 +++++++++++++++++++++++++++++++++++++++
gtkextra/gtkplotcairo.h | 84 +++
gtkextra/gtkplotcanvas.c | 774 ++++++++++++++++++++------
gtkextra/gtkplotcanvas.h | 36 +-
gtkextra/gtkplotpc.c | 223 +++++++-
gtkextra/gtkplotpc.h | 15 +-
gtkextra/gtkplotprint.c | 161 +++++-
gtkextra/gtkplotprint.h | 3 +
15 files changed, 2344 insertions(+), 238 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 57e918a..f084dc6 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+Thu Jun 13 00:12:46 2013 Jiri (George) Lebl <jirka 5z com>
+
+ * gtkextra/*.c: start updating to gtkextra 3.0.5. Only few files
+ converted: gtkplotcanvas.[ch], gtkplotpc.[ch], gtkextra.[ch],
+ gtkplotprint.[ch]. Must slowly work through custom bugfixes and
+ patches. Note that gtkplotps.[ch] seems broken, so it's even
+ older than the other files.
+ Also added gtkplotcairo.[ch] for cairo output which is lots nicer
+
Wed Jun 12 19:20:51 2013 Jiri (George) Lebl <jirka 5z com>
* src/graphing.c: adaptive step size for line plots, also detect jump
diff --git a/gtkextra/CONVERTEDTO3 b/gtkextra/CONVERTEDTO3
new file mode 100644
index 0000000..d6575d6
--- /dev/null
+++ b/gtkextra/CONVERTEDTO3
@@ -0,0 +1,7 @@
+File VERSION
+gtkplotcairo.[ch] 3.0.5 (was new)
+gtkextra-compat.h 3.0.5 (was new)
+gtkplotcanvas.[ch] 3.0.5
+gtkplotpc.[ch] 3.0.5
+gtkextra.[ch] 3.0.5
+gtkplotprint.[ch] 3.0.5
diff --git a/gtkextra/Makefile.am b/gtkextra/Makefile.am
index 8df7bf5..874ec86 100644
--- a/gtkextra/Makefile.am
+++ b/gtkextra/Makefile.am
@@ -40,6 +40,7 @@ EXTRA_DIST=gtkextra-marshal.list
public_h_sources = \
gtkextra.h \
+ gtkextra-compat.h \
gtkpsfont.h \
gtkplot.h \
gtkplot3d.h \
@@ -59,6 +60,7 @@ public_h_sources = \
gtkplotdt.h \
gtkplotflux.h \
gtkplotgdk.h \
+ gtkplotcairo.h \
gtkplotpc.h \
gtkplotpixmap.h \
gtkplotpolar.h \
@@ -92,6 +94,7 @@ libgtkextra_genius_a_SOURCES = \
gtkplotdt.c \
gtkplotflux.c \
gtkplotgdk.c \
+ gtkplotcairo.c \
gtkplotpc.c \
gtkplotpixmap.c \
gtkplotpolar.c \
diff --git a/gtkextra/gtkextra-compat.h b/gtkextra/gtkextra-compat.h
new file mode 100644
index 0000000..5078b72
--- /dev/null
+++ b/gtkextra/gtkextra-compat.h
@@ -0,0 +1,89 @@
+/* gtkextra-compat - gtk version compatibility stuff
+ * Copyright 1999-2001 Adrian E. Feiguin <feiguin ifir edu ar>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef GTK_EXTRA_COMPAT_H
+#define GTK_EXTRA_COMPAT_H
+
+#include <gtk/gtk.h>
+
+#if !GTK_CHECK_VERSION(2,20,0)
+
+ /* before V2.20 */
+
+# define gtk_widget_get_realized GTK_WIDGET_REALIZED
+# define gtk_widget_get_mapped GTK_WIDGET_MAPPED
+
+# define gtk_widget_get_requisition(widget, requisitionptr) \
+ *(requisitionptr) = GTK_WIDGET(widget)->requisition
+
+# define gtk_widget_set_realized_true(widget) \
+ GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED)
+# define gtk_widget_set_realized_false(widget) \
+ GTK_WIDGET_UNSET_FLAGS(widget, GTK_REALIZED)
+
+# define gtk_widget_set_mapped_true(widget) \
+ GTK_WIDGET_SET_FLAGS(widget, GTK_MAPPED)
+# define gtk_widget_set_mapped_false(widget) \
+ GTK_WIDGET_UNSET_FLAGS(widget, GTK_MAPPED)
+
+#else
+
+ /* from V2.20 */
+
+# define gtk_widget_set_realized_true(widget) \
+ gtk_widget_set_realized(widget, TRUE)
+# define gtk_widget_set_realized_false(widget) \
+ gtk_widget_set_realized(widget, FALSE)
+
+# define gtk_widget_set_mapped_true(widget) \
+ gtk_widget_set_mapped(widget, TRUE)
+# define gtk_widget_set_mapped_false(widget) \
+ gtk_widget_set_mapped(widget, FALSE)
+
+#endif
+
+#if !GTK_CHECK_VERSION(2,22,0)
+
+ /* before V2.22 */
+
+# define GDK_KEY_Return GDK_Return
+# define GDK_KEY_KP_Enter GDK_KP_Enter
+# define GDK_KEY_Escape GDK_Escape
+# define GDK_KEY_Tab GDK_Tab
+# define GDK_KEY_ISO_Left_Tab GDK_ISO_Left_Tab
+# define GDK_KEY_BackSpace GDK_BackSpace
+
+# define GDK_KEY_Up GDK_Up
+# define GDK_KEY_Down GDK_Down
+# define GDK_KEY_Left GDK_Left
+# define GDK_KEY_Right GDK_Right
+# define GDK_KEY_Home GDK_Home
+# define GDK_KEY_End GDK_End
+# define GDK_KEY_Page_Up GDK_Page_Up
+# define GDK_KEY_Page_Down GDK_Page_Down
+
+# define GDK_KEY_Control_L GDK_Control_L
+# define GDK_KEY_Control_R GDK_Control_R
+# define GDK_KEY_Shift_L GDK_Shift_L
+# define GDK_KEY_Shift_R GDK_Shift_R
+
+#endif
+
+
+#endif /* GTK_EXTRA_COMPAT_H */
diff --git a/gtkextra/gtkextra.c b/gtkextra/gtkextra.c
index 302200e..96af92c 100644
--- a/gtkextra/gtkextra.c
+++ b/gtkextra/gtkextra.c
@@ -67,7 +67,7 @@ _gtkextra_signal_test(GtkObject *object, guint signal_id, gint arg1, gint arg2,
g_value_init(instance_and_param + 2, G_TYPE_INT);
g_value_set_int(instance_and_param + 2, arg2);
- g_value_init(&ret, G_TYPE_BOOLEAN);
+ g_value_init(&ret, G_TYPE_BOOLEANEAN);
g_value_set_boolean(&ret, *default_ret);
g_signal_emitv(instance_and_param, signal_id, 0, &ret);
@@ -92,7 +92,7 @@ _gtkextra_signal_emit(GtkObject *object, guint signal_id, ...)
va_start (var_args, signal_id);
- g_value_init(instance_and_params + 0, GTK_OBJECT_TYPE(object));
+ g_value_init(instance_and_params + 0, G_OBJECT_TYPE(object));
g_value_set_instance (instance_and_params + 0, G_OBJECT(object));
g_signal_query(signal_id, &query);
diff --git a/gtkextra/gtkextra.h b/gtkextra/gtkextra.h
index 069d3fc..7fa3b6e 100644
--- a/gtkextra/gtkextra.h
+++ b/gtkextra/gtkextra.h
@@ -24,11 +24,14 @@
#include <gdk/gdk.h>
#include <glib.h>
+#define __GTKEXTRA_H_INSIDE__
+
/* #include <gtkextra/gtkbordercombo.h> */
/* #include <gtkextra/gtkcharsel.h> */
/* #include <gtkextra/gtkcheckitem.h> */
/* #include <gtkextra/gtkcolorcombo.h> */
/* #include <gtkextra/gtkcombobutton.h> */
+/* #include <gtkextra/gtkdataentry.h> */
/* #include <gtkextra/gtkdirtree.h> */
/* #include <gtkextra/gtkextrafeatures.h> */
/* #include <gtkextra/gtkfilelist.h> */
@@ -43,6 +46,8 @@
#include <gtkextra/gtkplotdata.h>
#include <gtkextra/gtkplotarray.h>
#include <gtkextra/gtkplotsurface.h>
+#include <gtkextra/gtkplotcairo.h>
+/* #include <gtkextra/gtkplotcandle.h> */
#include <gtkextra/gtkplotcsurface.h>
#include <gtkextra/gtkplotcanvas.h>
#include <gtkextra/gtkplotcanvasellipse.h>
@@ -65,4 +70,6 @@
/* #include <gtkextra/gtksheet.h> */
/* #include <gtkextra/gtktogglecombo.h> */
+#undef __GTKEXTRA_H_INSIDE__
+
#endif /* GTK_EXTRA_H */
diff --git a/gtkextra/gtkextratypebuiltins.c b/gtkextra/gtkextratypebuiltins.c
index 485ac7e..2709c1e 100644
--- a/gtkextra/gtkextratypebuiltins.c
+++ b/gtkextra/gtkextratypebuiltins.c
@@ -1,5 +1,5 @@
-/* Generated data (by glib-mkenums) */
+
#define GTKEXTRA_ENABLE_BROKEN
#include "gtkextra.h"
@@ -446,5 +446,5 @@ gtk_plot_units_get_type (void)
return etype;
}
-/* Generated data ends here */
+
diff --git a/gtkextra/gtkplotcairo.c b/gtkextra/gtkplotcairo.c
new file mode 100644
index 0000000..ee9ff11
--- /dev/null
+++ b/gtkextra/gtkplotcairo.c
@@ -0,0 +1,1163 @@
+/* gtkplotpc - gtkplot print context - a renderer for printing functions
+ * Copyright 1999-2001 Adrian E. Feiguin <feiguin ifir edu ar>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/**
+ * SECTION: gtkplotcairo
+ * @short_description: Cairo drawing backend.
+ *
+ * Subclass of #GtkPlotPC used for screen drawing.
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <ctype.h>
+#include <time.h>
+#include <gtk/gtk.h>
+#include <cairo.h>
+
+#include "gtkplotpc.h"
+#include "gtkplotcairo.h"
+#include "gtkplot.h"
+#include "gtkpsfont.h"
+#include "gtkplotcanvas.h"
+#include <pango/pango.h>
+
+static void gtk_plot_cairo_init (GtkPlotCairo *pc);
+static void gtk_plot_cairo_class_init (GtkPlotCairoClass *klass);
+static void gtk_plot_cairo_finalize (GObject *object);
+static gboolean gtk_plot_cairo_real_init (GtkPlotPC *pc);
+static void gtk_plot_cairo_set_viewport (GtkPlotPC *pc,
+ gdouble w, gdouble h);
+static void gtk_plot_cairo_leave (GtkPlotPC *pc);
+static void gtk_plot_cairo_gsave (GtkPlotPC *pc);
+static void gtk_plot_cairo_grestore (GtkPlotPC *pc);
+static void gtk_plot_cairo_clip (GtkPlotPC *pc,
+ const GdkRectangle *area);
+static void gtk_plot_cairo_clip_mask (GtkPlotPC *pc,
+ gdouble x,
+ gdouble y,
+ const GdkBitmap *mask);
+static void gtk_plot_cairo_set_color (GtkPlotPC *pc,
+ const GdkColor *color);
+static void gtk_plot_cairo_set_lineattr (GtkPlotPC *pc,
+ gfloat line_width,
+ GdkLineStyle line_style,
+ GdkCapStyle cap_style,
+ GdkJoinStyle join_style);
+static void gtk_plot_cairo_set_dash (GtkPlotPC *pc,
+ gdouble offset_,
+ gdouble *values,
+ gint num_values);
+static void gtk_plot_cairo_draw_point (GtkPlotPC *pc,
+ gdouble x, gdouble y);
+static void gtk_plot_cairo_draw_line (GtkPlotPC *pc,
+ gdouble x1, gdouble y1,
+ gdouble x2, gdouble y2);
+static void gtk_plot_cairo_draw_lines (GtkPlotPC *pc,
+ GtkPlotPoint *points,
+ gint numpoints);
+static void gtk_plot_cairo_draw_rectangle (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble width,
+ gdouble height);
+static void gtk_plot_cairo_draw_polygon (GtkPlotPC *pc,
+ gint filled,
+ GtkPlotPoint *points,
+ gint numpoints);
+static void gtk_plot_cairo_draw_circle (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble size);
+static void gtk_plot_cairo_draw_ellipse (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble width,
+ gdouble height);
+static void gtk_plot_cairo_set_font (GtkPlotPC *pc,
+ GtkPSFont *psfont,
+ gint height);
+static void gtk_plot_cairo_draw_string (GtkPlotPC *pc,
+ gint x, gint y,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ gint border,
+ gint border_space,
+ gint border_width,
+ gint shadow_width,
+ const gchar *font,
+ gint height,
+ GtkJustification just,
+ const gchar *text);
+static void gtk_plot_cairo_draw_pixmap (GtkPlotPC *pc,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask,
+ gint xsrc, gint ysrc,
+ gint xdest, gint ydest,
+ gint width, gint height,
+ gdouble scale_x,
+ gdouble scale_y);
+
+extern inline gint roundint (gdouble x);
+
+static GtkPlotPCClass *parent_class = NULL;
+
+GType
+gtk_plot_cairo_get_type (void)
+{
+ static GType pc_type = 0;
+
+ if (!pc_type)
+ {
+ pc_type = g_type_register_static_simple (
+ gtk_plot_pc_get_type(),
+ "GtkPlotCairo",
+ sizeof (GtkPlotCairoClass),
+ (GClassInitFunc) gtk_plot_cairo_class_init,
+ sizeof (GtkPlotCairo),
+ (GInstanceInitFunc) gtk_plot_cairo_init,
+ 0);
+
+ }
+ return pc_type;
+}
+
+static void
+gtk_plot_cairo_init (GtkPlotCairo *pc)
+{
+ pc->cairo = NULL;
+ /*
+ CairoWindowAttr attributes;
+ gint attributes_mask;
+ CairoScreen *screen;
+
+ attributes.window_type = CAIRO_WINDOW_CHILD;
+ attributes.title = NULL;
+ attributes.wclass = CAIRO_INPUT_OUTPUT;
+ attributes.visual = cairo_visual_get_system ();
+ attributes.colormap = cairo_colormap_get_system ();
+ attributes.event_mask = 0;
+ attributes_mask = CAIRO_WA_VISUAL | CAIRO_WA_COLORMAP;
+ */
+
+ /*
+ pc->window = cairo_window_new (NULL, &attributes, attributes_mask);
+
+ screen = cairo_screen_get_default ();
+ */
+ /*
+ pc->context = cairo_pango_context_get ();
+ */
+ /*
+ pango_context_set_base_dir (pc->context,
+ pc->text_direction == GTK_TEXT_DIR_LTR ?
+ PANGO_DIRECTION_LTR : PANGO_DIRECTION_RTL);
+ */
+
+ /*
+ pango_context_set_language (pc->context, gtk_get_default_language ());
+ pc->layout = pango_layout_new(pc->context);
+ */
+}
+
+
+static void
+gtk_plot_cairo_class_init (GtkPlotCairoClass *klass)
+{
+ GtkObjectClass *object_class;
+ GObjectClass *gobject_class;
+ GtkPlotPCClass *pc_class;
+ GtkPlotCairoClass *cairo_class;
+
+ parent_class = g_type_class_ref (gtk_plot_pc_get_type ());
+
+ object_class = (GtkObjectClass *) klass;
+ gobject_class = (GObjectClass *) klass;
+
+ pc_class = (GtkPlotPCClass *) klass;
+ cairo_class = (GtkPlotCairoClass *) klass;
+
+ gobject_class->finalize = gtk_plot_cairo_finalize;
+
+ pc_class->init = gtk_plot_cairo_real_init;
+ pc_class->leave = gtk_plot_cairo_leave;
+ pc_class->set_viewport = gtk_plot_cairo_set_viewport;
+ pc_class->gsave = gtk_plot_cairo_gsave;
+ pc_class->grestore = gtk_plot_cairo_grestore;
+ pc_class->clip = gtk_plot_cairo_clip;
+ pc_class->clip_mask = gtk_plot_cairo_clip_mask;
+ pc_class->set_color = gtk_plot_cairo_set_color;
+ pc_class->set_dash = gtk_plot_cairo_set_dash;
+ pc_class->set_lineattr = gtk_plot_cairo_set_lineattr;
+ pc_class->draw_point = gtk_plot_cairo_draw_point;
+ pc_class->draw_line = gtk_plot_cairo_draw_line;
+ pc_class->draw_lines = gtk_plot_cairo_draw_lines;
+ pc_class->draw_rectangle = gtk_plot_cairo_draw_rectangle;
+ pc_class->draw_polygon = gtk_plot_cairo_draw_polygon;
+ pc_class->draw_circle = gtk_plot_cairo_draw_circle;
+ pc_class->draw_ellipse = gtk_plot_cairo_draw_ellipse;
+ pc_class->set_font = gtk_plot_cairo_set_font;
+ pc_class->draw_string = gtk_plot_cairo_draw_string;
+ pc_class->draw_pixmap = gtk_plot_cairo_draw_pixmap;
+}
+
+/**
+ * gtk_plot_cairo_new:
+ * @cairo:
+ *
+ *
+ *
+ * Return value:
+ */
+GtkObject *
+gtk_plot_cairo_new (cairo_t *cairo)
+{
+ GtkObject *object;
+
+ object = g_object_new(gtk_plot_cairo_get_type(), NULL);
+ gtk_plot_cairo_construct(GTK_PLOT_CAIRO(object), cairo, NULL);
+ GTK_PLOT_CAIRO(object)->destroy_cairo = FALSE;
+
+ return (object);
+}
+
+/**
+ * gtk_plot_cairo_new_with_drawable:
+ * @drawable:
+ *
+ *
+ *
+ * Return value:
+ */
+GtkObject *
+gtk_plot_cairo_new_with_drawable (GdkDrawable *drawable)
+{
+ GtkObject *object;
+ cairo_t *cairo = NULL;
+
+ object = g_object_new(gtk_plot_cairo_get_type(), NULL);
+ if(drawable) cairo = gdk_cairo_create(drawable);
+ gtk_plot_cairo_construct(GTK_PLOT_CAIRO(object), cairo, NULL);
+ GTK_PLOT_CAIRO(object)->destroy_cairo = TRUE;
+
+ return (object);
+}
+
+/**
+ * gtk_plot_cairo_construct:
+ * @pc: A #GtkPlotCairo.
+ * @cairo:
+ * @context:
+ *
+ *
+ */
+void
+gtk_plot_cairo_construct(GtkPlotCairo *pc,
+ cairo_t *cairo,
+ PangoContext *context)
+{
+
+ gtk_plot_cairo_set_cairo(pc, cairo);
+
+ pc->context = context;
+
+ if (pc->context)
+ {
+ g_object_ref(G_OBJECT(pc->context));
+ }
+ if (pc->layout)
+ {
+ g_object_ref(G_OBJECT(pc->layout));
+ }
+ else
+ {
+ if(pc->cairo) pc->layout = pango_cairo_create_layout(cairo);
+ }
+}
+
+
+static void
+gtk_plot_cairo_finalize (GObject *object)
+{
+ GtkPlotCairo *pc = GTK_PLOT_CAIRO(object);
+
+ if(pc->destroy_cairo && pc->cairo) cairo_destroy(pc->cairo);
+ GTK_PLOT_CAIRO(object)->cairo = NULL;
+
+ if(pc->layout)
+ g_object_unref(G_OBJECT(pc->layout));
+ pc->layout = NULL;
+
+ if(pc->context)
+ g_object_unref(G_OBJECT(pc->context));
+ pc->context = NULL;
+}
+
+static gboolean
+gtk_plot_cairo_real_init (GtkPlotPC *pc)
+{
+ return TRUE;
+}
+
+static void
+gtk_plot_cairo_leave (GtkPlotPC *pc)
+{
+}
+
+/**
+ * gtk_plot_cairo_set_cairo:
+ * @pc: a #GtkPlotCairo
+ * @cairo:
+ *
+ *
+ */
+void
+gtk_plot_cairo_set_cairo(GtkPlotCairo *pc,
+ cairo_t *cairo)
+{
+ if(pc->destroy_cairo && pc->cairo && cairo) cairo_destroy(pc->cairo);
+ pc->cairo = cairo;
+}
+
+static void
+gtk_plot_cairo_set_viewport (GtkPlotPC *pc, gdouble w, gdouble h)
+{
+}
+
+static void
+gtk_plot_cairo_gsave (GtkPlotPC *pc)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+ cairo_save(cairo);
+}
+
+static void
+gtk_plot_cairo_grestore (GtkPlotPC *pc)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+ cairo_restore(cairo);
+}
+
+static void
+gtk_plot_cairo_clip (GtkPlotPC *pc,
+ const GdkRectangle *area)
+{
+ /* discard CairoRectangle* const:
+ * cairo_gc_set_clip_rectangle should have a const arg.
+ * I've checked the code and it doesn't change it or keep it. murrayc.
+ */
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo; /* Shortcut */
+ if (!cairo)
+ return;
+ cairo_reset_clip(cairo);
+ cairo_new_path(cairo);
+ if (area) {
+ cairo_move_to(cairo, area->x, area->y);
+ cairo_line_to(cairo, area->x+area->width, area->y);
+ cairo_line_to(cairo, area->x+area->width, area->y+area->height);
+ cairo_line_to(cairo, area->x, area->y+area->height);
+ cairo_close_path(cairo);
+ cairo_clip(cairo);
+ }
+}
+
+static void
+gtk_plot_cairo_clip_mask (GtkPlotPC *pc,
+ gdouble x,
+ gdouble y,
+ const GdkBitmap *mask)
+{
+ /* TBD: Currently no support for clip mask */
+ return;
+}
+
+static void
+gtk_plot_cairo_set_color (GtkPlotPC *pc,
+ const GdkColor *color)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo; /* Shortcut */
+ if (!cairo)
+ return;
+ cairo_set_source_rgba(cairo,
+ 1.0/65535 * color->red,
+ 1.0/65535 * color->green,
+ 1.0/65535 * color->blue,
+ 1.0); // TBD fix alpha
+}
+
+static void
+gtk_plot_cairo_set_dash (GtkPlotPC *pc,
+ gdouble offset,
+ gdouble *values,
+ gint num_values)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo; /* Shortcut */
+ if (!cairo)
+ return;
+ gchar list[] = {'\0','\1','\2','\3','\4','\5','\6','\7'};
+ double dash[1000];
+ gint i;
+
+ if(num_values == 0){
+ return;
+ }
+
+ /* TBD - Fix this */
+ for(i = 0; i < num_values; i++){
+ gint value;
+ value = values[i];
+ dash[i] = list[value];
+ }
+
+ cairo_set_dash(cairo, dash, num_values, 0);
+}
+
+static void gtk_plot_cairo_set_lineattr (GtkPlotPC *pc,
+ gfloat line_width,
+ GdkLineStyle line_style,
+ GdkCapStyle cap_style,
+ GdkJoinStyle join_style)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo; /* Shortcut */
+
+ if (!cairo)
+ return;
+ if (line_style == GDK_LINE_SOLID)
+ cairo_set_dash(cairo,
+ NULL, 0, 0);
+
+ if (line_width == 0)
+ line_width = 0.5; // What should be the minimum line width?
+ cairo_set_line_width(cairo,
+ line_width);
+
+ if(cap_style == GDK_CAP_NOT_LAST || cap_style == GDK_CAP_PROJECTING)
+ cairo_set_line_cap(cairo, CAIRO_LINE_CAP_SQUARE);
+ if(cap_style == GDK_CAP_BUTT) cairo_set_line_cap(cairo, CAIRO_LINE_CAP_BUTT);
+ if(cap_style == GDK_CAP_ROUND) cairo_set_line_cap(cairo, CAIRO_LINE_CAP_ROUND);
+
+ cairo_set_line_join(cairo,
+ (cairo_line_join_t)join_style);
+}
+
+static void
+gtk_plot_cairo_draw_point (GtkPlotPC *pc,
+ gdouble x, gdouble y)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo; /* Shortcut */
+ if (!cairo)
+ return;
+ /* Move and draw to same point, like in the postscript backend */
+ cairo_move_to(cairo, x,y);
+ cairo_line_to(cairo, x,y);
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_line (GtkPlotPC *pc,
+ gdouble x1, gdouble y1,
+ gdouble x2, gdouble y2)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+ cairo_move_to(cairo, x1,y1);
+ cairo_line_to(cairo, x2,y2);
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_lines (GtkPlotPC *pc,
+ GtkPlotPoint *points,
+ gint numpoints)
+{
+ gint i;
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+
+ cairo_move_to(cairo, points[0].x,points[0].y);
+ for(i = 1; i < numpoints; i++){
+ cairo_line_to(cairo, points[i].x, points[i].y);
+ }
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_rectangle (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble width, gdouble height)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if(!cairo)
+ return;
+
+ cairo_move_to(cairo, x, y);
+ cairo_line_to(cairo, x+width, y);
+ cairo_line_to(cairo, x+width, y+height);
+ cairo_line_to(cairo, x, y+height);
+ cairo_close_path(cairo);
+ if (filled)
+ cairo_fill(cairo);
+ else
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_polygon (GtkPlotPC *pc,
+ gint filled,
+ GtkPlotPoint *points,
+ gint numpoints)
+{
+ gint i;
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+
+ cairo_move_to(cairo, points[0].x,points[0].y);
+ for(i = 1; i < numpoints; i++)
+ cairo_line_to(cairo, points[i].x, points[i].y);
+ cairo_close_path(cairo);
+ if (filled)
+ cairo_fill(cairo);
+ else
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_circle (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble size)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+
+ cairo_arc (cairo, x, y, size/2, 0., 2 * M_PI);
+ if (filled)
+ cairo_fill(cairo);
+ else
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_draw_ellipse (GtkPlotPC *pc,
+ gint filled,
+ gdouble x, gdouble y,
+ gdouble width, gdouble height)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ if (!cairo)
+ return;
+
+ cairo_save(cairo);
+ cairo_translate(cairo, x+width/2.0,y+height/2.0);
+ cairo_scale (cairo, 1. / (height / 2.), 1. / (width / 2.));
+ cairo_arc (cairo, 0., 0., 1., 0., 2 * M_PI);
+ cairo_restore(cairo);
+
+ if (filled)
+ cairo_fill(cairo);
+ else
+ cairo_stroke(cairo);
+}
+
+static void
+gtk_plot_cairo_set_font (GtkPlotPC *pc,
+ GtkPSFont *psfont,
+ gint height)
+{
+}
+
+/* subfunction of gtk_plot_cairo_draw_string(). */
+static gint
+drawstring(GtkPlotPC *pc,
+ gint angle,
+ gint dx, gint dy,
+ GtkPSFont *psfont, gint height,
+ const gchar *text)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ PangoLayout *layout = GTK_PLOT_CAIRO(pc)->layout;
+ PangoFontDescription *font;
+ PangoRectangle rect;
+ PangoFontMap *map;
+ gint ret_value;
+ gint dpi_cairo, dpi_screen;
+ GdkScreen *screen = gdk_screen_get_default();
+
+ if(!text || strlen(text) == 0) return 0;
+ cairo_save(cairo);
+
+ map = pango_cairo_font_map_get_default();
+ dpi_cairo = pango_cairo_font_map_get_resolution(PANGO_CAIRO_FONT_MAP(map));
+ dpi_screen = gdk_screen_get_resolution(screen);
+ if (dpi_screen != -1)
+ height *= (double)dpi_screen/(double)dpi_cairo;
+ font = gtk_psfont_get_font_description(psfont, height);
+ pango_layout_set_font_description(GTK_PLOT_CAIRO(pc)->layout, font);
+ pango_layout_set_text(GTK_PLOT_CAIRO(pc)->layout, text, strlen(text));
+ pango_layout_get_extents(GTK_PLOT_CAIRO(pc)->layout, NULL, &rect);
+
+ if (psfont->i18n_latinfamily && psfont->vertical) {
+ /* vertical-writing CJK postscript fonts. */
+ return rect.height;
+ }
+ else
+ {
+ /* horizontal writing */
+ if(angle == 90)
+// cairo_translate(cairo, dx, dy-PANGO_PIXELS(rect.width));
+ cairo_translate(cairo, dx, dy);
+ else if(angle == 270)
+ cairo_translate(cairo, dx+PANGO_PIXELS(rect.height), dy);
+ else if(angle == 180)
+ cairo_translate(cairo, dx-PANGO_PIXELS(rect.width), dy);
+ else
+ cairo_translate(cairo, dx, dy);
+ }
+ cairo_rotate(cairo, -angle * G_PI / 180);
+ pango_cairo_update_layout(cairo, layout);
+ pango_cairo_show_layout(cairo, layout);
+ cairo_restore(cairo);
+ pango_font_description_free(font);
+ ret_value = (angle == 0 || angle == 180) ? rect.width : rect.height;
+ return PANGO_PIXELS(rect.width);
+}
+
+static void
+gtk_plot_cairo_draw_string (GtkPlotPC *pc,
+ gint tx, gint ty,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ gint border,
+ gint border_space,
+ gint border_width,
+ gint shadow_width,
+ const gchar *font_name,
+ gint font_height,
+ GtkJustification just,
+ const gchar *text)
+{
+ cairo_t *cairo = GTK_PLOT_CAIRO(pc)->cairo;
+ GList *family = NULL;
+ gint x0, y0;
+ gint old_width, old_height;
+ gboolean bold, italic;
+ gint fontsize;
+ gint ascent, descent;
+ gint numf;
+ gint width, height;
+ gint x, y;
+ gint i;
+ PangoFontDescription *font = NULL, *latin_font = NULL;
+ GtkPSFont *psfont, *base_psfont, *latin_psfont;
+ gchar subs[2], insert_char;
+ const gchar *aux = text;
+ const gchar *lastchar = text;
+ const gchar *wtext = text;
+ const gchar *xaux = text;
+ gchar *new_text; /* Support Tiny C compiler : Original : gchar new_text[strlen(text)+1];*/
+ gchar num[4];
+ PangoRectangle rect;
+ PangoLayout *layout = NULL;
+ gint real_x, real_y, real_width, real_height;
+ GdkColor real_fg = *fg;
+ GdkColor real_bg = *bg;
+ gint sign_x = 1, sign_y = 0;
+ gint old_tx = tx, old_ty = ty;
+
+ if (!cairo)
+ return;
+
+ layout = GTK_PLOT_CAIRO(pc)->layout;
+ cairo_save(cairo);
+ gtk_plot_cairo_set_color(pc, fg);
+/*
+ font_name = "sans";
+ desc = pango_font_description_from_string(font_name);
+
+ // Since the name does not contain the size yet... Also there is some
+ // factor that I have to figure out...
+ pango_font_description_set_size (desc, font_height *0.9 * PANGO_SCALE);
+
+ pango_layout_set_font_description(layout, desc);
+ pango_layout_set_text(layout, text, -1);
+ cairo_save(cairo);
+ cairo_translate(cairo, tx, ty);
+ cairo_rotate(cairo, angle * G_PI / 180);
+ gtk_plot_cairo_set_color(pc, fg);
+ pango_cairo_update_layout(cairo, layout);
+ PangoFontMetrics *metrics = NULL;
+
+ metrics = pango_context_get_metrics(pango_layout_get_context(layout), desc, gtk_get_default_language());
+
+ pango_layout_get_size (layout, &width, &height);
+
+ ascent = pango_font_metrics_get_ascent(metrics);
+ descent = pango_font_metrics_get_descent(metrics);
+
+ if (just == GTK_JUSTIFY_RIGHT)
+ cairo_move_to(cairo, -PANGO_PIXELS(width),
+ -PANGO_PIXELS(ascent)
+ );
+ else if (just == GTK_JUSTIFY_CENTER)
+ cairo_move_to(cairo, -PANGO_PIXELS(width)/2.0,
+ -PANGO_PIXELS(ascent)
+ );
+ else if (just == GTK_JUSTIFY_LEFT)
+ cairo_move_to(cairo, 0,
+ -PANGO_PIXELS(ascent)
+ );
+
+ pango_cairo_show_layout(cairo, layout);
+ cairo_restore(cairo);
+*/
+
+
+ gtk_plot_text_get_size(text, angle, font_name, font_height, &width, &height, &ascent, &descent);
+
+ if(height == 0 || width == 0) return;
+
+ old_width = width;
+ old_height = height;
+ if(angle == 90 || angle == 270)
+ {
+ old_width = height;
+ old_height = width;
+ }
+ switch(angle){
+ case 90:
+ sign_x = 0;
+ sign_y = -1;
+ break;
+ case 180:
+ sign_x = -1;
+ sign_y = 0;
+ break;
+ case 270:
+ sign_x = 0;
+ sign_y = 1;
+ break;
+ case 0:
+ default:
+ sign_x = 1;
+ sign_y = 0;
+ break;
+ }
+
+ switch(just){
+ case GTK_JUSTIFY_LEFT:
+ switch(angle){
+ case 0:
+ ty -= ascent;
+ break;
+ case 90:
+ ty -= height;
+ tx -= ascent;
+ break;
+ case 180:
+ tx -= width;
+ ty -= descent;
+ break;
+ case 270:
+ tx -= descent;
+ break;
+ }
+ old_tx = tx;
+ old_ty = ty;
+ break;
+ case GTK_JUSTIFY_RIGHT:
+ switch(angle){
+ case 0:
+ tx -= width;
+ ty -= ascent;
+ old_tx -= width;
+ old_ty -= ascent;
+ break;
+ case 90:
+ tx -= ascent;
+ ty += height;
+ old_tx -= ascent;
+ break;
+ case 180:
+ tx += width;
+ ty -= descent;
+ old_ty -= descent;
+ break;
+ case 270:
+ tx -= descent;
+ old_tx -= descent;
+ old_ty -= height;
+ break;
+ }
+ break;
+ case GTK_JUSTIFY_CENTER:
+ default:
+ switch(angle){
+ case 0:
+ tx -= width / 2.;
+ ty -= ascent;
+ old_tx -= width / 2.;
+ old_ty -= ascent;
+ break;
+ case 90:
+ tx -= ascent;
+ ty += height / 2.;
+ old_tx -= ascent;
+ old_ty -= height / 2.;
+ break;
+ case 180:
+ tx += width / 2.;
+ ty -= descent;
+ old_tx -= width / 2.;
+ old_ty -= descent;
+ break;
+ case 270:
+ tx -= descent;
+ ty -= height / 2.;
+ old_tx -= descent;
+ old_ty -= height / 2.;
+ break;
+ }
+ }
+
+ real_x = tx;
+ real_y = ty;
+ real_width = width;
+ real_height = height;
+
+ if(!transparent){
+ gtk_plot_cairo_set_color(pc, &real_bg);
+ gtk_plot_cairo_draw_rectangle(pc, TRUE, old_tx, old_ty, old_width, old_height);
+ }
+ gtk_psfont_get_families(&family, &numf);
+ base_psfont = psfont = gtk_psfont_get_by_name(font_name);
+ font = gtk_psfont_get_font_description(psfont, font_height);
+ italic = psfont->italic;
+ bold = psfont->bold;
+ fontsize = font_height;
+ x0 = x = 0;
+ y0 = y = 0;
+
+ if (psfont->i18n_latinfamily) {
+ latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily, italic,
+ bold);
+ if(latin_font) pango_font_description_free(latin_font);
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ } else {
+ latin_psfont = NULL;
+ latin_font = NULL;
+ }
+
+ gtk_plot_cairo_set_color(pc, &real_fg);
+ aux = text;
+ while(aux && *aux != '\0' && *aux != '\n'){
+ if(*aux == '\\'){
+ aux = g_utf8_next_char(aux);
+ switch(*aux){
+ case '0': case '1': case '2': case '3':
+ case '4': case '5': case '6': case '7': case '9':
+ psfont = gtk_psfont_get_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic, bold);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ aux = g_utf8_next_char(aux);
+ break;
+ case '8': case 'g':
+ psfont = gtk_psfont_get_by_family("Symbol", italic, bold);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ aux = g_utf8_next_char(aux);
+ break;
+ case 'B':
+ bold = TRUE;
+ psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if(latin_font){
+ latin_font = NULL;
+ }
+ if (psfont->i18n_latinfamily) {
+ latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily,
+ italic, bold);
+ if(latin_font) pango_font_description_free(latin_font);
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ case 'x':
+ xaux = aux + 1;
+ for (i=0; i<3; i++){
+ if (xaux[i] >= '0' && xaux[i] <= '9')
+ num[i] = xaux[i];
+ else
+ break;
+ }
+ if (i < 3){
+ aux = g_utf8_next_char(aux);
+ break;
+ }
+ num[3] = '\0';
+ insert_char = (gchar)atoi(num);
+ subs[0] = insert_char;
+ subs[1] = '\0';
+ pango_layout_set_font_description(layout, font);
+ pango_layout_set_text(layout, subs, 1);
+ pango_layout_get_extents(layout, NULL, &rect);
+ x += sign_x*PANGO_PIXELS(rect.width);
+ y += sign_y*PANGO_PIXELS(rect.width);
+ aux += 4;
+ lastchar = aux - 1;
+ break;
+ case 'i':
+ italic = TRUE;
+ psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if (psfont->i18n_latinfamily) {
+ latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily,
+ italic, bold);
+ if(latin_font) pango_font_description_free(latin_font);
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ case 'S': case '^':
+ fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if (psfont->i18n_latinfamily) {
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ if(angle == 180)
+ y = y0 + fontsize;
+ else if(angle == 270)
+ x = x0 + sign_y*fontsize;
+ aux = g_utf8_next_char(aux);
+ break;
+ case 's': case '_':
+ fontsize = (int)((gdouble)fontsize * 0.6 + 0.5);
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if(angle == 0)
+ y = y0 + fontsize;
+ else if(angle == 90)
+ x = x0 - sign_y*fontsize;
+ if (psfont->i18n_latinfamily) {
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ case '+':
+ fontsize += 3;
+ y -= sign_x*3;
+ x += sign_y*3;
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if (psfont->i18n_latinfamily) {
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ case '-':
+ fontsize -= 3;
+ y += sign_x*3;
+ x -= sign_y*3;
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if (psfont->i18n_latinfamily) {
+ latin_font = gtk_psfont_get_font_description(latin_psfont, fontsize);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ case 'N':
+ psfont = base_psfont;
+ fontsize = font_height;
+ pango_font_description_free(font);
+ font = gtk_psfont_get_font_description(psfont, fontsize);
+ if(angle == 0 || angle == 180)
+ y = y0;
+ else
+ x = x0;
+ italic = psfont->italic;
+ bold = psfont->bold;
+ aux = g_utf8_next_char(aux);
+ break;
+ case 'b':
+ if (lastchar) {
+ const gchar *aux2 = lastchar;
+ gint i = aux2 - g_utf8_prev_char(lastchar);
+ pango_layout_set_text(layout, lastchar, i);
+ pango_layout_get_extents(layout, NULL, &rect);
+ x -= sign_x*PANGO_PIXELS(rect.width);
+ y -= sign_y*PANGO_PIXELS(rect.width);
+
+ if (lastchar == wtext)
+ lastchar = NULL;
+ else
+ lastchar = g_utf8_prev_char(lastchar);
+ } else {
+ pango_layout_set_text(layout, "X", 1);
+ pango_layout_get_extents(layout, NULL, &rect);
+ x -= sign_x*PANGO_PIXELS(rect.width);
+ y -= sign_y*PANGO_PIXELS(rect.width);
+ }
+ aux = g_utf8_next_char(aux);
+ break;
+ default:
+ if(aux && *aux != '\0' && *aux !='\n'){
+ gint new_width = 0;
+ new_width = drawstring(pc, angle, tx+x, ty+y,
+ psfont, fontsize, aux);
+ x += sign_x * new_width;
+ y += sign_y * new_width;
+ lastchar = aux;
+ aux = g_utf8_next_char(aux);
+ }
+ break;
+ }
+ } else {
+ gint new_len = 0;
+ gint new_width = 0;
+ lastchar = aux;
+ while(aux && *aux != '\0' && *aux !='\n' && *aux != '\\'){
+ xaux = aux;
+ new_len += g_utf8_next_char(aux) - xaux;
+ xaux++;
+ aux = g_utf8_next_char(aux);
+ }
+ xaux = lastchar;
+
+ new_text = (gchar *) g_new0(gchar , strlen(text)+1); /* Tiny C Compiler support */
+ for(i = 0; i < new_len; i++) new_text[i] = *xaux++;
+ new_text[new_len] = '\0';
+ new_width = drawstring(pc, angle, tx+x, ty+y,
+ psfont, fontsize, new_text);
+ x += sign_x * new_width;
+ y += sign_y * new_width;
+ lastchar = aux;
+
+ g_free (new_text);
+ }
+ }
+
+ if(latin_font) pango_font_description_free(latin_font);
+
+/* border */
+
+ gtk_plot_cairo_set_color(pc, &real_fg);
+ gtk_plot_pc_set_dash(pc, 0, NULL, 0);
+ gtk_plot_pc_set_lineattr(pc, border_width, 0, 0, 0);
+ switch(border){
+ case GTK_PLOT_BORDER_SHADOW:
+ gtk_plot_pc_draw_rectangle(pc,
+ TRUE,
+ old_tx - border_space + shadow_width,
+ old_ty + height + border_space,
+ width + 2 * border_space, shadow_width);
+ gtk_plot_pc_draw_rectangle(pc,
+ TRUE,
+ old_tx + width + border_space,
+ old_ty - border_space + shadow_width,
+ shadow_width, height + 2 * border_space);
+ case GTK_PLOT_BORDER_LINE:
+ gtk_plot_pc_draw_rectangle(pc,
+ FALSE,
+ old_tx - border_space, old_ty - border_space,
+ width + 2*border_space, height + 2*border_space);
+ case GTK_PLOT_BORDER_NONE:
+ default:
+ break;
+ }
+
+ cairo_restore(cairo);
+ return;
+}
+
+static void gtk_plot_cairo_draw_pixmap (GtkPlotPC *pc,
+ GdkPixmap *pixmap,
+ GdkBitmap *mask,
+ gint xsrc, gint ysrc,
+ gint xdest, gint ydest,
+ gint width, gint height,
+ gdouble scale_x,
+ gdouble scale_y)
+{
+ if (!GTK_PLOT_CAIRO(pc)->cairo)
+ return;
+
+ cairo_surface_t *image_surface = NULL;
+ cairo_surface_t *mask_surface = NULL;
+ cairo_t *cr;
+/* TODO: USE MASK */
+
+ image_surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, (width-xsrc)*scale_x,
(height-ysrc)*scale_y);
+ cr = cairo_create(image_surface);
+ cairo_scale(cr,scale_x,scale_y);
+ gdk_cairo_set_source_pixmap(cr,pixmap,xsrc,ysrc);
+ cairo_paint(cr);
+ cairo_destroy(cr);
+
+/*
+ mask_surface = cairo_image_surface_create(CAIRO_CONTENT_COLOR_ALPHA, (width-xsrc)*scale_x,
(height-ysrc)*scale_y);
+ cr = cairo_create(image_surface);
+ cairo_scale(cr,scale_x,scale_y);
+ gdk_cairo_set_source_pixmap(cr,mask,xsrc,ysrc);
+ cairo_paint(cr);
+ cairo_destroy(cr);
+*/
+ if(mask){
+ mask_surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, (width-xsrc)*scale_x,
(height-ysrc)*scale_y);
+ cr = cairo_create(mask_surface);
+ cairo_set_source_rgb(cr,0,0,0);
+ cairo_scale(cr,scale_x,scale_y);
+ gdk_cairo_set_source_pixmap(cr,pixmap,xsrc,ysrc);
+ cairo_mask_surface(cr,mask_surface,0,0);
+ cairo_fill(cr);
+ cairo_destroy(cr);
+ }
+
+ cairo_save(GTK_PLOT_CAIRO(pc)->cairo);
+/*
+ cairo_rectangle(GTK_PLOT_CAIRO(pc)->cairo,xdest,ydest,(width-xsrc)*scale_x,(height-ysrc)*scale_y);
+ cairo_clip(GTK_PLOT_CAIRO(pc)->cairo);
+*/
+/*
+ if(mask) cairo_mask_surface(GTK_PLOT_CAIRO(pc)->cairo,mask_surface,xdest,ydest);
+*/
+ cairo_set_source_surface(GTK_PLOT_CAIRO(pc)->cairo,image_surface,xdest,ydest);
+ cairo_paint(GTK_PLOT_CAIRO(pc)->cairo);
+
+ cairo_restore(GTK_PLOT_CAIRO(pc)->cairo);
+ cairo_surface_destroy(image_surface);
+ cairo_surface_destroy(mask_surface);
+}
diff --git a/gtkextra/gtkplotcairo.h b/gtkextra/gtkplotcairo.h
new file mode 100644
index 0000000..505d403
--- /dev/null
+++ b/gtkextra/gtkplotcairo.h
@@ -0,0 +1,84 @@
+/* gtkplotpc - gtkplot print context - a renderer for printing functions
+ * Copyright 1999-2001 Adrian E. Feiguin <feiguin ifir edu ar>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_PLOT_CAIRO_H__
+#define __GTK_PLOT_CAIRO_H__
+
+#include <stdio.h>
+#include <pango/pango.h>
+#include "gtkplotpc.h"
+#include "gtkpsfont.h"
+#include "cairo.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GTK_PLOT_CAIRO(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_cairo_get_type (), GtkPlotCairo)
+#define G_TYPE_PLOT_CAIRO (gtk_plot_cairo_get_type ())
+
+#define GTK_PLOT_CAIRO_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_cairo_get_type(),
GtkPlotCairoClass)
+#define GTK_IS_PLOT_CAIRO(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_cairo_get_type ())
+
+
+ typedef struct _GtkPlotCairo GtkPlotCairo;
+ typedef struct _GtkPlotCairoClass GtkPlotCairoClass;
+
+
+/**
+ * GtkPlotCairo:
+ *
+ * The GtkPlotCairo struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
+ struct _GtkPlotCairo
+ {
+ GtkPlotPC pc;
+
+ cairo_t *cairo;
+ PangoContext *context;
+ PangoLayout *layout;
+ gboolean destroy_cairo;
+
+ gint ref_count;
+ };
+
+
+ struct _GtkPlotCairoClass
+ {
+ GtkPlotPCClass parent_class;
+
+ };
+
+ GType gtk_plot_cairo_get_type (void);
+ GtkObject *gtk_plot_cairo_new (cairo_t *cairo);
+ GtkObject *gtk_plot_cairo_new_with_drawable (GdkDrawable *drawable);
+ void gtk_plot_cairo_construct(GtkPlotCairo *pc,
+ cairo_t *cairo,
+ PangoContext *context);
+ void gtk_plot_cairo_set_cairo(GtkPlotCairo *pc,
+ cairo_t *cairo);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_PLOT_CAIRO_H__ */
+
diff --git a/gtkextra/gtkplotcanvas.c b/gtkextra/gtkplotcanvas.c
index 08167de..86016ae 100644
--- a/gtkextra/gtkplotcanvas.c
+++ b/gtkextra/gtkplotcanvas.c
@@ -23,11 +23,21 @@
#include <math.h>
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
+#include "gtkextra-compat.h"
+#include "gtkplotcairo.h"
#include "gtkplotcanvas.h"
#include "gtkplotgdk.h"
#include "gtkplotps.h"
#include "gtkextra-marshal.h"
+/**
+ * SECTION: gtkplotcanvas
+ * @short_description:
+ *
+ * FIXME:: need long description.
+ */
+
+
#define P_(string) string
#define DEFAULT_WIDTH 100
@@ -174,51 +184,41 @@ typedef gboolean (*GtkPlotCanvasSignal3) (GtkObject *object,
static GtkFixedClass *parent_class = NULL;
static guint canvas_signals[LAST_SIGNAL] = {0};
-GtkType
+GType
gtk_plot_canvas_get_type (void)
{
- static GtkType plot_canvas_type = 0;
+ static GType plot_canvas_type = 0;
if (!plot_canvas_type)
{
- GtkTypeInfo plot_canvas_info =
- {
- "GtkPlotCanvas",
- sizeof (GtkPlotCanvas),
- sizeof (GtkPlotCanvasClass),
- (GtkClassInitFunc) gtk_plot_canvas_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_type = gtk_type_unique (gtk_fixed_get_type(), &plot_canvas_info);
+ plot_canvas_type = g_type_register_static_simple (
+ gtk_fixed_get_type(),
+ "GtkPlotCanvas",
+ sizeof (GtkPlotCanvasClass),
+ (GClassInitFunc) gtk_plot_canvas_class_init,
+ sizeof (GtkPlotCanvas),
+ (GInstanceInitFunc) gtk_plot_canvas_init,
+ 0);
}
return plot_canvas_type;
}
-GtkType
+GType
gtk_plot_canvas_child_get_type (void)
{
- static GtkType plot_canvas_child_type = 0;
+ static GType plot_canvas_child_type = 0;
if (!plot_canvas_child_type)
{
- GtkTypeInfo plot_canvas_child_info =
- {
- "GtkPlotCanvasChild",
- sizeof(GtkPlotCanvasChild),
- sizeof(GtkPlotCanvasChildClass),
- (GtkClassInitFunc) gtk_plot_canvas_child_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_child_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_child_type = gtk_type_unique (gtk_object_get_type(),
- &plot_canvas_child_info);
+
+ plot_canvas_child_type = g_type_register_static_simple (
+ gtk_object_get_type(),
+ "GtkPlotCanvasChild",
+ sizeof(GtkPlotCanvasChildClass),
+ (GClassInitFunc) gtk_plot_canvas_child_class_init,
+ sizeof(GtkPlotCanvasChild),
+ (GInstanceInitFunc) gtk_plot_canvas_child_init,
+ 0);
}
return plot_canvas_child_type;
}
@@ -241,6 +241,11 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
gobject_class->get_property = gtk_plot_canvas_child_get_property;
gobject_class->set_property = gtk_plot_canvas_child_set_property;
+ /**
+ * GtkPlotCanvasChild:rx1:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_RX1,
g_param_spec_double ("rx1",
@@ -248,6 +253,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:ry1:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_RY1,
g_param_spec_double ("ry1",
@@ -255,6 +266,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:rx2:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_RX2,
g_param_spec_double ("rx2",
@@ -262,6 +279,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:ry2:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_RY2,
g_param_spec_double ("ry2",
@@ -269,12 +292,24 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:allocation:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_ALLOCATION,
g_param_spec_pointer ("allocation",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:min_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_MIN_WIDTH,
g_param_spec_int ("min_width",
@@ -282,6 +317,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-1,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:min_height:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_MIN_HEIGHT,
g_param_spec_int ("min_height",
@@ -289,6 +330,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
-1,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:state:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_STATE,
g_param_spec_int ("state",
@@ -296,6 +343,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:flags:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_FLAGS,
g_param_spec_int ("flags",
@@ -303,6 +356,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:selection:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_SELECTION,
g_param_spec_int ("selection",
@@ -310,6 +369,12 @@ gtk_plot_canvas_child_class_init (GtkPlotCanvasChildClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasChild:selection_mode:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CHILD_SELECTION_MODE,
g_param_spec_int ("selection_mode",
@@ -432,76 +497,148 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
GtkContainerClass *container_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_fixed_get_type ());
+ parent_class = g_type_class_ref (gtk_fixed_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
container_class = (GtkContainerClass *) klass;
+
+ /**
+ * GtkPlotCanvas::select_item:
+ * @canvas:
+ * @event:
+ * @item:
+ *
+ *
+ *
+ * Return value:
+ */
canvas_signals[SELECT_ITEM] =
- gtk_signal_new ("select_item",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, select_item),
+ g_signal_new ("select_item",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, select_item),
+ NULL, NULL,
gtkextra_BOOLEAN__BOXED_BOXED,
- GTK_TYPE_BOOL, 2, GDK_TYPE_EVENT,
- GTK_TYPE_PLOT_CANVAS_CHILD);
-
+ G_TYPE_BOOLEAN, 2, GDK_TYPE_EVENT,
+ G_TYPE_PLOT_CANVAS_CHILD);
+
+ /**
+ * GtkPlotCanvas::move_item:
+ * @canvas:
+ * @item:
+ * @new_x:
+ * @new_y
+ *
+ *
+ *
+ * Return value:
+ */
canvas_signals[MOVE_ITEM] =
- gtk_signal_new ("move_item",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, move_item),
+ g_signal_new ("move_item",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, move_item),
+ NULL, NULL,
gtkextra_BOOLEAN__BOXED_DOUBLE_DOUBLE,
- GTK_TYPE_BOOL, 3, GTK_TYPE_PLOT_CANVAS_CHILD,
- GTK_TYPE_DOUBLE,
- GTK_TYPE_DOUBLE);
-
+ G_TYPE_BOOLEAN, 3, G_TYPE_PLOT_CANVAS_CHILD,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE);
+
+ /**
+ * GtkPlotCanvas::resize_item:
+ * @canvas:
+ * @item:
+ * @new_width:
+ * @new_height:
+ *
+ *
+ *
+ * Return value:
+ */
canvas_signals[RESIZE_ITEM] =
- gtk_signal_new ("resize_item",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, resize_item),
+ g_signal_new ("resize_item",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, resize_item),
+ NULL, NULL,
gtkextra_BOOLEAN__BOXED_DOUBLE_DOUBLE,
- GTK_TYPE_BOOL, 3, GTK_TYPE_PLOT_CANVAS_CHILD,
- GTK_TYPE_DOUBLE,
- GTK_TYPE_DOUBLE);
-
+ G_TYPE_BOOLEAN, 3, G_TYPE_PLOT_CANVAS_CHILD,
+ G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE);
+
+ /**
+ * GtkPlotCanvas::add_item:
+ * @canvas:
+ * @item:
+ *
+ *
+ */
canvas_signals[ADD_ITEM] =
- gtk_signal_new ("add_item",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, add_item),
+ g_signal_new ("add_item",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, add_item),
+ NULL, NULL,
gtkextra_VOID__POINTER,
- GTK_TYPE_NONE, 1,
- GTK_TYPE_PLOT_CANVAS_CHILD);
-
+ G_TYPE_NONE, 1,
+ G_TYPE_PLOT_CANVAS_CHILD);
+
+ /**
+ * GtkPlotCanvas::delete_item:
+ * @canvas:
+ * @item:
+ *
+ *
+ *
+ * Return value:
+ */
canvas_signals[DELETE_ITEM] =
- gtk_signal_new ("delete_item",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, delete_item),
+ g_signal_new ("delete_item",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, delete_item),
+ NULL, NULL,
gtkextra_BOOL__POINTER,
- GTK_TYPE_BOOL, 1,
- GTK_TYPE_PLOT_CANVAS_CHILD);
-
+ G_TYPE_BOOLEAN, 1,
+ G_TYPE_PLOT_CANVAS_CHILD);
+
+ /**
+ * GtkPlotCanvas::select_region:
+ * @canvas:
+ * @xmin:
+ * @ymin:
+ * @xmax:
+ * @ymax:
+ *
+ *
+ */
canvas_signals[SELECT_REGION] =
- gtk_signal_new ("select_region",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, select_region),
+ g_signal_new ("select_region",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, select_region),
+ NULL, NULL,
gtkextra_VOID__DOUBLE_DOUBLE_DOUBLE_DOUBLE,
- GTK_TYPE_NONE, 4,
- GTK_TYPE_DOUBLE, GTK_TYPE_DOUBLE,
- GTK_TYPE_DOUBLE, GTK_TYPE_DOUBLE);
-
+ G_TYPE_NONE, 4,
+ G_TYPE_DOUBLE, G_TYPE_DOUBLE,
+ G_TYPE_DOUBLE, G_TYPE_DOUBLE);
+
+ /**
+ * GtkPlotCanvas::changed:
+ * @canvas:
+ *
+ *
+ */
canvas_signals[CHANGED] =
- gtk_signal_new("changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotCanvasClass, changed),
+ g_signal_new("changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotCanvasClass, changed),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0);
+ G_TYPE_NONE, 0);
object_class->destroy = gtk_plot_canvas_destroy;
@@ -524,6 +661,11 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
klass->delete_item = NULL;
klass->select_region = NULL;
+ /**
+ * GtkPlotCanvas:flags:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_FLAGS,
g_param_spec_int ("flags",
@@ -531,6 +673,12 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:magnification:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_MAGNIFICATION,
g_param_spec_double ("magnification",
@@ -538,6 +686,12 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
0,G_MAXDOUBLE,1.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_WIDTH,
g_param_spec_int ("width",
@@ -545,6 +699,12 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
0,G_MAXINT,1,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:height:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_HEIGHT,
g_param_spec_int ("height",
@@ -552,6 +712,12 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
0,G_MAXINT,1,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:show_grid:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_SHOW_GRID,
g_param_spec_boolean ("show_grid",
@@ -559,6 +725,12 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:grid_step:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_GRID_STEP,
g_param_spec_double ("grid_step",
@@ -566,18 +738,36 @@ gtk_plot_canvas_class_init (GtkPlotCanvasClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:line_grid:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_LINE_GRID,
g_param_spec_pointer ("line_grid",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:color_bg:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_COLOR_BG,
g_param_spec_pointer ("color_bg",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvas:transparent:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CANVAS_TRANSPARENT,
g_param_spec_boolean ("transparent",
@@ -674,10 +864,13 @@ gtk_plot_canvas_init (GtkPlotCanvas *plot_canvas)
GdkColor color;
widget = GTK_WIDGET(plot_canvas);
- GTK_WIDGET_SET_FLAGS(widget, GTK_CAN_FOCUS);
- gdk_color_black(gtk_widget_get_colormap(widget), &widget->style->black);
- gdk_color_white(gtk_widget_get_colormap(widget), &widget->style->white);
+ gtk_widget_set_can_focus(GTK_WIDGET(widget), TRUE);
+
+ gdk_color_black(gtk_widget_get_colormap(widget),
+ >k_widget_get_style(widget)->black);
+ gdk_color_white(gtk_widget_get_colormap(widget),
+ >k_widget_get_style(widget)->white);
gtk_widget_set_events (widget, gtk_widget_get_events(widget)|
GRAPH_MASK);
@@ -685,7 +878,7 @@ gtk_plot_canvas_init (GtkPlotCanvas *plot_canvas)
plot_canvas->freeze_count = 0;
plot_canvas->cursor = gdk_cursor_new(GDK_TOP_LEFT_ARROW);
- plot_canvas->background = widget->style->white;
+ plot_canvas->background = gtk_widget_get_style(widget)->white;
plot_canvas->transparent = TRUE;
plot_canvas->flags = 0;
@@ -724,15 +917,15 @@ void
gtk_plot_canvas_set_pc(GtkPlotCanvas *canvas, GtkPlotPC *pc)
{
if(canvas->pc)
- gtk_object_unref(GTK_OBJECT(canvas->pc));
+ g_object_unref(GTK_OBJECT(canvas->pc));
if(!pc){
- canvas->pc = GTK_PLOT_PC(gtk_plot_gdk_new(GTK_WIDGET(canvas)));
- gtk_object_ref(GTK_OBJECT(canvas->pc));
+ canvas->pc = (GtkPlotPC *)gtk_plot_cairo_new(NULL);
+ g_object_ref(GTK_OBJECT(canvas->pc));
gtk_object_sink(GTK_OBJECT(canvas->pc));
} else {
canvas->pc = pc;
- gtk_object_ref(GTK_OBJECT(pc));
+ g_object_ref(GTK_OBJECT(pc));
gtk_object_sink(GTK_OBJECT(pc));
}
@@ -742,12 +935,22 @@ gtk_plot_canvas_set_pc(GtkPlotCanvas *canvas, GtkPlotPC *pc)
gtk_plot_pc_set_viewport(canvas->pc, canvas->pixmap_width, canvas->pixmap_height);
}
+/**
+ * gtk_plot_canvas_new:
+ * @width:
+ * @height:
+ * @magnification:
+ *
+ *
+ *
+ * Return value:
+ */
GtkWidget*
gtk_plot_canvas_new (gint width, gint height, gdouble magnification)
{
GtkPlotCanvas *plot_canvas;
- plot_canvas = gtk_type_new (gtk_plot_canvas_get_type ());
+ plot_canvas = g_object_new (gtk_plot_canvas_get_type (), NULL);
gtk_plot_canvas_construct(GTK_PLOT_CANVAS(plot_canvas),
width, height, magnification);
@@ -755,27 +958,48 @@ gtk_plot_canvas_new (gint width, gint height, gdouble magnification)
return GTK_WIDGET (plot_canvas);
}
+/**
+ * gtk_plot_canvas_construct:
+ * @canvas: a #GtkPlotCanvas.
+ * @width:
+ * @height:
+ * @magnification:
+ *
+ *
+ */
void
-gtk_plot_canvas_construct(GtkPlotCanvas *plot_canvas,
+gtk_plot_canvas_construct(GtkPlotCanvas *canvas,
gint width, gint height, gdouble magnification)
{
gdouble m = magnification;
- plot_canvas->width = width;
- plot_canvas->height = height;
- plot_canvas->pixmap_width = roundint(width * m);
- plot_canvas->pixmap_height = roundint(height * m);
- gtk_plot_canvas_set_magnification(plot_canvas, m);
+ canvas->width = width;
+ canvas->height = height;
+ canvas->pixmap_width = roundint(width * m);
+ canvas->pixmap_height = roundint(height * m);
+ gtk_plot_canvas_set_magnification(canvas, m);
- gtk_fixed_set_has_window (GTK_FIXED(plot_canvas), TRUE);
+ gtk_fixed_set_has_window (GTK_FIXED(canvas), TRUE);
}
+/**
+ * gtk_plot_canvas_freeze:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
void
gtk_plot_canvas_freeze(GtkPlotCanvas *canvas)
{
canvas->freeze_count++;
}
+/**
+ * gtk_plot_canvas_thaw:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
void
gtk_plot_canvas_thaw(GtkPlotCanvas *canvas)
{
@@ -797,10 +1021,10 @@ gtk_plot_canvas_destroy (GtkObject *object)
list = plot_canvas->childs;
while(list){
- gtk_signal_emit(GTK_OBJECT(plot_canvas), canvas_signals[DELETE_ITEM],
+ g_signal_emit(GTK_OBJECT(plot_canvas), canvas_signals[DELETE_ITEM], 0,
GTK_PLOT_CANVAS_CHILD(list->data), &veto);
- gtk_object_unref(GTK_OBJECT(list->data));
+ g_object_unref(GTK_OBJECT(list->data));
plot_canvas->childs = g_list_remove_link(plot_canvas->childs, list);
g_list_free_1(list);
@@ -815,7 +1039,7 @@ gtk_plot_canvas_destroy (GtkObject *object)
plot_canvas->cursor = NULL;
}
if( plot_canvas->pc ){
- gtk_object_unref(GTK_OBJECT(plot_canvas->pc));
+ g_object_unref(GTK_OBJECT(plot_canvas->pc));
plot_canvas->pc = NULL;
}
@@ -831,6 +1055,13 @@ gtk_plot_canvas_destroy (GtkObject *object)
gtk_psfont_unref();
}
+/**
+ * gtk_plot_canvas_remove_child:
+ * @canvas: a #GtkPlotCanvas.
+ * @child: a #GtkPlotCanvasChild
+ *
+ *
+ */
void
gtk_plot_canvas_remove_child(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child)
{
@@ -848,7 +1079,7 @@ gtk_plot_canvas_remove_child(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child)
if(veto){
child->parent = NULL;
- gtk_object_unref(GTK_OBJECT(child));
+ g_object_unref(GTK_OBJECT(child));
canvas->childs = g_list_remove_link(canvas->childs, list);
g_list_free_1(list);
}
@@ -866,7 +1097,7 @@ gtk_plot_canvas_draw (GtkWidget *widget, GdkRectangle *area)
canvas = GTK_PLOT_CANVAS(widget);
- if(!GTK_WIDGET_REALIZED(widget)) return;
+ if(!gtk_widget_get_realized(widget)) return;
if(!canvas->pixmap) return;
GTK_WIDGET_CLASS(parent_class)->draw(widget, area);
@@ -876,6 +1107,12 @@ gtk_plot_canvas_draw (GtkWidget *widget, GdkRectangle *area)
}
*/
+/**
+ * gtk_plot_canvas_paint:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
void
gtk_plot_canvas_paint (GtkPlotCanvas *canvas)
{
@@ -884,7 +1121,7 @@ gtk_plot_canvas_paint (GtkPlotCanvas *canvas)
widget = GTK_WIDGET(canvas);
- if(GTK_WIDGET_REALIZED(widget) && !canvas->pixmap) return;
+ if(gtk_widget_get_realized(widget) && !canvas->pixmap) return;
if(canvas->freeze_count > 0) return;
if(!gtk_plot_pc_init(canvas->pc)) return;
@@ -919,22 +1156,28 @@ gtk_plot_canvas_paint (GtkPlotCanvas *canvas)
gtk_plot_pc_leave(canvas->pc);
}
+/**
+ * gtk_plot_canvas_refresh:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
void
gtk_plot_canvas_refresh(GtkPlotCanvas *canvas)
{
GList *children = NULL;
GtkFixed *fixed = GTK_FIXED(canvas);
- if(!GTK_WIDGET_REALIZED(GTK_WIDGET(canvas))) return;
+ if(!gtk_widget_get_realized(GTK_WIDGET(canvas))) return;
if(!canvas->pixmap) return;
if(canvas->freeze_count > 0) return;
- gdk_draw_drawable(GTK_WIDGET(canvas)->window,
- GTK_WIDGET(canvas)->style->fg_gc[GTK_STATE_NORMAL],
- canvas->pixmap,
- 0, 0,
- 0, 0,
- -1, -1);
+ gdk_draw_drawable(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ gtk_widget_get_style(GTK_WIDGET(canvas))->fg_gc[GTK_STATE_NORMAL],
+ canvas->pixmap,
+ 0, 0,
+ 0, 0,
+ -1, -1);
children = fixed->children;
while (children)
@@ -955,7 +1198,7 @@ gtk_plot_canvas_draw_grid(GtkPlotCanvas *canvas)
if(!canvas->pixmap) return;
if(!canvas->show_grid) return;
- if(!GTK_IS_PLOT_GDK(canvas->pc)) return;
+ if(!canvas->pc) return;
if(canvas->freeze_count > 0) return;
gtk_plot_canvas_set_line_attributes(canvas, canvas->grid);
@@ -979,28 +1222,32 @@ gtk_plot_canvas_map(GtkWidget *widget)
GTK_WIDGET_CLASS(parent_class)->map(widget);
if(!plot_canvas->pixmap){
- gtk_plot_canvas_create_pixmap(widget,
- plot_canvas->pixmap_width,
+ gtk_plot_canvas_create_pixmap(widget,
+ plot_canvas->pixmap_width,
plot_canvas->pixmap_height);
+ if (GTK_IS_PLOT_CAIRO(plot_canvas->pc)) {
+ gtk_plot_canvas_set_pc(plot_canvas,
GTK_PLOT_PC(gtk_plot_cairo_new_with_drawable(plot_canvas->pixmap)));
+ }
}
+
gtk_plot_canvas_paint(plot_canvas);
- gdk_window_set_cursor(widget->window, plot_canvas->cursor);
+ gdk_window_set_cursor(gtk_widget_get_window(widget), plot_canvas->cursor);
}
static gint
gtk_plot_canvas_key_press(GtkWidget *widget, GdkEventKey *key)
{
- GtkPlotCanvas *canvas = GTK_PLOT_CANVAS(widget);
+ GtkPlotCanvas *canvas = GTK_PLOT_CANVAS(widget);
- switch(key->keyval){
- case GDK_Escape:
- gtk_plot_canvas_cancel_action(canvas);
- break;
- default:
- break;
- }
+ switch (key->keyval)
+ {
+ case GDK_KEY_Escape:
+ gtk_plot_canvas_cancel_action(canvas);
+ break;
- return TRUE;
+ default: break;
+ }
+ return TRUE;
}
static gint
@@ -1078,7 +1325,7 @@ gtk_plot_canvas_motion (GtkWidget *widget, GdkEventMotion *event)
if(cursor != canvas->cursor->type){
gdk_cursor_destroy(canvas->cursor);
canvas->cursor = gdk_cursor_new(cursor);
- gdk_window_set_cursor(widget->window, canvas->cursor);
+ gdk_window_set_cursor(gtk_widget_get_window(widget), canvas->cursor);
}
@@ -1115,7 +1362,7 @@ gtk_plot_canvas_motion (GtkWidget *widget, GdkEventMotion *event)
}
gdk_cursor_destroy(canvas->cursor);
canvas->cursor = gdk_cursor_new(cursor);
- gdk_window_set_cursor(widget->window, canvas->cursor);
+ gdk_window_set_cursor(gtk_widget_get_window(widget), canvas->cursor);
break;
case GTK_PLOT_CANVAS_BOTTOM_LEFT:
case GTK_PLOT_CANVAS_BOTTOM_RIGHT:
@@ -1214,7 +1461,7 @@ gtk_plot_canvas_button_press(GtkWidget *widget, GdkEventButton *event)
gboolean new_item = FALSE;
GtkPlotCanvasPos pos = GTK_PLOT_CANVAS_OUT;
- gdk_window_get_pointer(widget->window, NULL, NULL, &mods);
+ gdk_window_get_pointer(gtk_widget_get_window(widget), NULL, NULL, &mods);
if(!(mods & GDK_BUTTON1_MASK)) return FALSE;
double_click = (event->button == GDK_2BUTTON_PRESS);
@@ -1228,7 +1475,7 @@ gtk_plot_canvas_button_press(GtkWidget *widget, GdkEventButton *event)
gdk_pointer_ungrab(event->time);
*/
- if(!GTK_WIDGET_HAS_FOCUS(widget)) gtk_widget_grab_focus(widget);
+ if(!gtk_widget_has_focus(widget)) gtk_widget_grab_focus(widget);
gtk_widget_get_pointer(widget, &x, &y);
@@ -1282,7 +1529,7 @@ gtk_plot_canvas_button_press(GtkWidget *widget, GdkEventButton *event)
}
}
if(active_item && veto){
- if((!new_item && active_item->mode == GTK_PLOT_CANVAS_SELECT_CLICK_2) || active_item->mode
== GTK_PLOT_CANVAS_SELECT_CLICK_1) {
+ if((!new_item && active_item->mode == GTK_PLOT_CANVAS_SELECT_CLICK_2) || active_item->mode ==
GTK_PLOT_CANVAS_SELECT_CLICK_1) {
if(GTK_PLOT_CANVAS_CAN_DND(canvas)) {
switch(pos){
@@ -1296,7 +1543,7 @@ gtk_plot_canvas_button_press(GtkWidget *widget, GdkEventButton *event)
canvas->action = GTK_PLOT_CANVAS_ACTION_DRAG;
}
/*
- gdk_pointer_grab (widget->window, FALSE,
+ gdk_pointer_grab (gtk_widget_get_window(widget), FALSE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
@@ -1335,7 +1582,7 @@ gtk_plot_canvas_button_press(GtkWidget *widget, GdkEventButton *event)
canvas->drag_area.width = 0;
canvas->drag_area.height = 0;
/*
- gdk_pointer_grab (widget->window, FALSE,
+ gdk_pointer_grab (gtk_widget_get_window(widget), FALSE,
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON1_MOTION_MASK |
GDK_BUTTON_RELEASE_MASK,
@@ -1399,10 +1646,10 @@ gtk_plot_canvas_button_release(GtkWidget *widget, GdkEventButton *event)
gdk_pointer_ungrab(event->time);
*/
- if(GTK_WIDGET_MAPPED(widget)){
+ if(gtk_widget_get_mapped(widget)){
gdk_cursor_destroy(canvas->cursor);
canvas->cursor = gdk_cursor_new(GDK_TOP_LEFT_ARROW);
- gdk_window_set_cursor(widget->window,
+ gdk_window_set_cursor(gtk_widget_get_window(widget),
canvas->cursor);
}
@@ -1451,7 +1698,7 @@ gtk_plot_canvas_button_release(GtkWidget *widget, GdkEventButton *event)
if(GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(canvas->active_item)))->button_release)
GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(canvas->active_item)))->button_release(canvas,
canvas->active_item);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
canvas->pointer_x = canvas->pointer_y = canvas->drag_x = canvas->drag_y = 0;
gtk_plot_canvas_child_draw_selection(canvas, canvas->active_item, canvas->active_item->drag_area);
canvas->action = GTK_PLOT_CANVAS_ACTION_INACTIVE;
@@ -1470,7 +1717,7 @@ gtk_plot_canvas_button_release(GtkWidget *widget, GdkEventButton *event)
new_width = abs(canvas->pointer_x - canvas->drag_x);
new_height = abs(canvas->pointer_y - canvas->drag_y);
draw_selection(canvas, NULL, canvas->drag_area);
- gtk_signal_emit(GTK_OBJECT(canvas), canvas_signals[SELECT_REGION],
+ g_signal_emit(GTK_OBJECT(canvas), canvas_signals[SELECT_REGION], 0,
x1, y1, x2, y2);
canvas->state = GTK_STATE_NORMAL;
canvas->action = GTK_PLOT_CANVAS_ACTION_INACTIVE;
@@ -1504,6 +1751,13 @@ gtk_plot_canvas_focus_out(GtkWidget *widget, GdkEventFocus *event)
return FALSE;
}
+/**
+ * gtk_plot_canvas_set_transparent:
+ * @canvas: a #GtkPlotCanvas.
+ * @transparent:
+ *
+ *
+ */
void
gtk_plot_canvas_set_transparent (GtkPlotCanvas *canvas, gboolean transparent)
{
@@ -1513,6 +1767,14 @@ gtk_plot_canvas_set_transparent (GtkPlotCanvas *canvas, gboolean transparent)
canvas->transparent = transparent;
}
+/**
+ * gtk_plot_canvas_trasnparent:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_canvas_transparent (GtkPlotCanvas *canvas)
{
@@ -1522,27 +1784,44 @@ gtk_plot_canvas_transparent (GtkPlotCanvas *canvas)
return(canvas->transparent);
}
+/**
+ * gtk_plot_canvas_set_background:
+ * @canvas: a #GtkPlotCanvas.
+ * @bg_color: a GdkColor.
+ *
+ *
+ */
void
-gtk_plot_canvas_set_background (GtkPlotCanvas *canvas, const GdkColor *color)
+gtk_plot_canvas_set_background (GtkPlotCanvas *canvas, const GdkColor *bg_color)
{
g_return_if_fail (canvas != NULL);
g_return_if_fail (GTK_IS_PLOT_CANVAS (canvas));
- if(!color) {
+ if(!bg_color) {
canvas->transparent = TRUE;
return;
} else {
- canvas->background = *color;
+ canvas->background = *bg_color;
canvas->transparent = FALSE;
}
- if(GTK_WIDGET_REALIZED(GTK_WIDGET(canvas)))
+ if(gtk_widget_get_realized(GTK_WIDGET(canvas)))
gtk_plot_canvas_paint(canvas);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_canvas_get_pixel:
+ * @canvas: a #GtkPlotCanvas.
+ * @px:
+ * @py:
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_canvas_get_pixel(GtkPlotCanvas *canvas, gdouble px, gdouble py,
gint *x, gint *y)
@@ -1551,6 +1830,16 @@ gtk_plot_canvas_get_pixel(GtkPlotCanvas *canvas, gdouble px, gdouble py,
*y = roundint(canvas->pixmap_height * py);
}
+/**
+ * gtk_plot_canvas_get_position:
+ * @plot_canvas: a #GtkPlotCanvas.
+ * @x:
+ * @y:
+ * @px:
+ * @py:
+ *
+ *
+ */
void
gtk_plot_canvas_get_position(GtkPlotCanvas *plot_canvas, gint x, gint y,
gdouble *px, gdouble *py)
@@ -1559,6 +1848,12 @@ gtk_plot_canvas_get_position(GtkPlotCanvas *plot_canvas, gint x, gint y,
*py = (gdouble) y / (gdouble) plot_canvas->pixmap_height;
}
+/**
+ * gtk_plot_canvas_unselect:
+ * @plot_canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
void
gtk_plot_canvas_unselect (GtkPlotCanvas *plot_canvas)
{
@@ -1579,14 +1874,21 @@ gtk_plot_canvas_unselect (GtkPlotCanvas *plot_canvas)
}
plot_canvas->active_item = NULL;
- if(GTK_WIDGET_MAPPED(GTK_WIDGET(plot_canvas))){
+ if(gtk_widget_get_mapped(GTK_WIDGET(plot_canvas))){
gdk_cursor_destroy(plot_canvas->cursor);
plot_canvas->cursor = gdk_cursor_new(GDK_TOP_LEFT_ARROW);
- gdk_window_set_cursor(GTK_WIDGET(plot_canvas)->window,
+ gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(plot_canvas)),
plot_canvas->cursor);
}
}
+/**
+ * gtk_plot_canvas_cancel_action:
+ * @plot_canvas: a #GtkPlotCanvas.
+ *
+ *
+ */
+
void
gtk_plot_canvas_cancel_action (GtkPlotCanvas *plot_canvas)
{
@@ -1597,12 +1899,31 @@ gtk_plot_canvas_cancel_action (GtkPlotCanvas *plot_canvas)
}
+/**
+ * gtk_plot_canvas_get_active_item:
+ * @canvas: a #GtkPlotCanvas.
+ *
+ * Return value: (transfer none): the active #GtkPlotCanvasChild
+ */
GtkPlotCanvasChild *
gtk_plot_canvas_get_active_item(GtkPlotCanvas *canvas)
{
return (canvas->active_item);
}
+/**
+ * gtk_plot_canvas_child_get_position:
+ * @canvas: a #GtkPlotCanvas.
+ * @child: a #GtkPlotCanvasChild.
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_canvas_child_get_position(GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child,
@@ -1632,12 +1953,21 @@ gtk_plot_canvas_child_get_position(GtkPlotCanvas *canvas,
}
+/**
+ * gtk_plot_canvas_get_size:
+ * @canvas: a #GtkPlotCanvas.
+ * @width:
+ * @height:
+ *
+ */
void
gtk_plot_canvas_set_size(GtkPlotCanvas *canvas, gint width, gint height)
{
GList *list = NULL;
gdouble m = canvas->magnification;
- GtkAllocation allocation = GTK_WIDGET(canvas)->allocation;
+ GtkAllocation allocation;
+
+ gtk_widget_get_allocation(GTK_WIDGET(canvas), &allocation);
gtk_plot_canvas_cancel_action(canvas);
@@ -1646,19 +1976,20 @@ gtk_plot_canvas_set_size(GtkPlotCanvas *canvas, gint width, gint height)
canvas->pixmap_width = roundint(m * width);
canvas->pixmap_height = roundint(m * height);
- if(GTK_WIDGET_MAPPED(canvas)){
+ if(gtk_widget_get_mapped(GTK_WIDGET(canvas)) && canvas->pixmap){
gtk_plot_canvas_create_pixmap(GTK_WIDGET(canvas),
canvas->pixmap_width,
canvas->pixmap_height);
}
/*
- gtk_widget_set_usize(GTK_WIDGET(canvas),
+ gtk_widget_set_size_request(GTK_WIDGET(canvas),
canvas->pixmap_width, canvas->pixmap_height);
*/
allocation.width = canvas->pixmap_width;
allocation.height = canvas->pixmap_height;
+
gtk_widget_size_allocate(GTK_WIDGET(canvas), &allocation);
list = canvas->childs;
@@ -1670,7 +2001,7 @@ gtk_plot_canvas_set_size(GtkPlotCanvas *canvas, gint width, gint height)
}
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
static void
@@ -1681,19 +2012,23 @@ gtk_plot_canvas_create_pixmap(GtkWidget *widget, gint width, gint height)
canvas = GTK_PLOT_CANVAS(widget);
if (!canvas->pixmap){
- canvas->pixmap = gdk_pixmap_new (widget->window,
+ canvas->pixmap = gdk_pixmap_new (gtk_widget_get_window(widget),
width,
height, -1);
}else{
gdk_window_get_size(canvas->pixmap, &pixmap_width, &pixmap_height);
if(width != pixmap_width || height != pixmap_height){
gdk_pixmap_unref(canvas->pixmap);
- canvas->pixmap = gdk_pixmap_new (widget->window,
+ canvas->pixmap = gdk_pixmap_new (gtk_widget_get_window(widget),
width,
height, -1);
}
}
+ if (canvas->pc && GTK_IS_PLOT_CAIRO(canvas->pc)) {
+ gtk_plot_canvas_set_pc(canvas, GTK_PLOT_PC(gtk_plot_cairo_new_with_drawable(canvas->pixmap)));
+ }
+
if(canvas->pc && GTK_IS_PLOT_GDK(canvas->pc)){
GTK_PLOT_GDK(canvas->pc)->drawable = canvas->pixmap;
}
@@ -1706,7 +2041,7 @@ gtk_plot_canvas_expose(GtkWidget *widget, GdkEventExpose *event)
GtkPlotCanvas *canvas;
GdkPixmap *pixmap;
- if(!GTK_WIDGET_DRAWABLE(widget)) return FALSE;
+ if(!gtk_widget_is_drawable(widget)) return FALSE;
canvas = GTK_PLOT_CANVAS(widget);
@@ -1719,8 +2054,8 @@ gtk_plot_canvas_expose(GtkWidget *widget, GdkEventExpose *event)
}
pixmap = canvas->pixmap;
- gdk_draw_pixmap(GTK_WIDGET(canvas)->window,
- widget->style->fg_gc[GTK_STATE_NORMAL],
+ gdk_draw_pixmap(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ gtk_widget_get_style(widget)->fg_gc[GTK_STATE_NORMAL],
pixmap,
event->area.x,
event->area.y,
@@ -1744,11 +2079,19 @@ gtk_plot_canvas_size_request (GtkWidget *widget, GtkRequisition *requisition)
GTK_WIDGET_CLASS(parent_class)->size_request(widget, requisition);
- widget->requisition.width = MAX(canvas->pixmap_width, requisition->width);
- widget->requisition.height = MAX(canvas->pixmap_height, requisition->height);
+ gtk_widget_set_size_request(widget,
+ MAX(canvas->pixmap_width, requisition->width),
+ MAX(canvas->pixmap_height, requisition->height));
}
+/**
+ * gtk_plot_canvas_set_magnification:
+ * @canvas: a #GtkPlotCanvas.
+ * @magnification:
+ *
+ *
+ */
void
gtk_plot_canvas_set_magnification(GtkPlotCanvas *canvas,
gdouble magnification)
@@ -1770,7 +2113,7 @@ gtk_plot_canvas_set_magnification(GtkPlotCanvas *canvas,
gtk_plot_canvas_set_size(canvas,
canvas->width,
canvas->height);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
static void
@@ -1786,11 +2129,11 @@ draw_selection(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation a
GdkGC *xor_gc = NULL;
GdkGCValues values;
- gdk_gc_get_values(GTK_WIDGET(canvas)->style->fg_gc[0], &values);
+ gdk_gc_get_values(gtk_widget_get_style(GTK_WIDGET(canvas))->fg_gc[0], &values);
values.function = GDK_INVERT;
- values.foreground = GTK_WIDGET(canvas)->style->white;
+ values.foreground = gtk_widget_get_style(GTK_WIDGET(canvas))->white;
values.subwindow_mode = GDK_INCLUDE_INFERIORS;
- xor_gc = gdk_gc_new_with_values(GTK_WIDGET(canvas)->window,
+ xor_gc = gdk_gc_new_with_values(gtk_widget_get_window(GTK_WIDGET(canvas)),
&values,
GDK_GC_FOREGROUND |
GDK_GC_FUNCTION |
@@ -1802,22 +2145,22 @@ draw_selection(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation a
area.y += area.height / 2 - 10;
area.width = 20;
area.height = 20;
- gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
+ gdk_draw_rectangle (gtk_widget_get_window(GTK_WIDGET(canvas)),
xor_gc,
FALSE,
area.x, area.y,
area.width, area.height);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
area.x + 1, area.y + area.height/2,
area.x + 6, area.y + area.height/2);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
area.x + area.width - 1, area.y + area.height / 2,
area.x + area.width - 6, area.y + area.height / 2);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
area.x + area.width/2, area.y + 1,
area.x + area.width/2, area.y + 6);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
area.x + area.width/2, area.y + area.height - 1,
area.x + area.width/2, area.y + area.height - 6);
@@ -1827,7 +2170,7 @@ draw_selection(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation a
if(canvas->active_item->selection == GTK_PLOT_CANVAS_SELECT_MARKERS){
- gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
+ gdk_draw_rectangle (gtk_widget_get_window(GTK_WIDGET(canvas)),
xor_gc,
FALSE,
area.x, area.y,
@@ -1850,7 +2193,7 @@ draw_selection(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, GtkAllocation a
} else {
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0 ,0 );
- gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
+ gdk_draw_rectangle (gtk_widget_get_window(GTK_WIDGET(canvas)),
xor_gc,
FALSE,
area.x, area.y,
@@ -1864,13 +2207,14 @@ draw_marker(GtkPlotCanvas *canvas, GdkGC *gc, gint x, gint y)
{
GdkDrawable *darea;
- darea = GTK_WIDGET(canvas)->window;
+ darea = gtk_widget_get_window(GTK_WIDGET(canvas));
gdk_draw_rectangle(darea, gc, TRUE,
x - DEFAULT_MARKER_SIZE / 2, y - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
}
+/* FIXME:: Is this private or public */
GtkPlotCanvasPos
possible_selection(GtkAllocation area, gint x, gint y)
{
@@ -1926,20 +2270,43 @@ possible_selection(GtkAllocation area, gint x, gint y)
/**********************************************************************/
+/**
+ * gtk_plot_canvas_grid_set_visible:
+ * @canvas: a #GtkPlotCanvas.
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_canvas_grid_set_visible(GtkPlotCanvas *canvas, gboolean visible)
{
canvas->show_grid= visible;
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_canvas_grid_set_step:
+ * @canvas: a #GtkPlotCanvas.
+ * @step:
+ *
+ *
+ */
void
gtk_plot_canvas_grid_set_step(GtkPlotCanvas *canvas, gdouble step)
{
canvas->grid_step = step;
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_canvas_grid_set_attributes:
+ * @canvas: a #GtkPlotCanvas.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_canvas_grid_set_attributes(GtkPlotCanvas *canvas,
GtkPlotLineStyle style,
@@ -1950,10 +2317,21 @@ gtk_plot_canvas_grid_set_attributes(GtkPlotCanvas *canvas,
canvas->grid.color = *color;
canvas->grid.line_width = width;
canvas->grid.line_style = style;
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
/**********************************************************************/
+
+/**
+ * gtk_plot_canvas_put_child:
+ * @canvas: a #GtkPlotCanvas.
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ *
+ *
+ */
void
gtk_plot_canvas_put_child(GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child,
@@ -1967,17 +2345,27 @@ gtk_plot_canvas_put_child(GtkPlotCanvas *canvas,
child->parent = canvas;
canvas->childs = g_list_append(canvas->childs, child);
- gtk_object_ref(GTK_OBJECT(child));
+ g_object_ref(GTK_OBJECT(child));
gtk_object_sink(GTK_OBJECT(child));
if(GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(child)))->size_allocate)
GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(child)))->size_allocate(canvas, child);
- if(GTK_WIDGET_REALIZED(canvas) && GTK_WIDGET_VISIBLE(canvas))
+ if(gtk_widget_get_realized(GTK_WIDGET(canvas)) &&
+ gtk_widget_get_visible(GTK_WIDGET(canvas)))
gtk_plot_canvas_child_draw(canvas, child);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
- gtk_signal_emit(GTK_OBJECT(canvas), canvas_signals[ADD_ITEM], child);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
+ g_signal_emit(GTK_OBJECT(canvas), canvas_signals[ADD_ITEM], 0, child);
}
+/**
+ * gtk_plot_canvas_child_move:
+ * @canvas: a #GtkPlotCanvas.
+ * @child: a #GtkPlotCanvasChild
+ * @x1:
+ * @y1:
+ *
+ *
+ */
void
gtk_plot_canvas_child_move(GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child,
@@ -1993,9 +2381,19 @@ gtk_plot_canvas_child_move(GtkPlotCanvas *canvas,
GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(child)))->size_allocate(canvas, child);
gtk_plot_canvas_paint(canvas);
gtk_plot_canvas_refresh(canvas);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_canvas_child_move_resize:
+ * @canvas: a #GtkPlotCanvas.
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ *
+ *
+ */
void
gtk_plot_canvas_child_move_resize(GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child,
@@ -2012,7 +2410,7 @@ gtk_plot_canvas_child_move_resize(GtkPlotCanvas *canvas,
GTK_PLOT_CANVAS_CHILD_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(child)))->size_allocate(canvas, child);
gtk_plot_canvas_paint(canvas);
gtk_plot_canvas_refresh(canvas);
- gtk_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(canvas), canvas_signals[CHANGED], 0);
}
static void
@@ -2028,6 +2426,13 @@ gtk_plot_canvas_child_size_allocate(GtkPlotCanvas *canvas, GtkPlotCanvasChild *c
child->allocation.height = abs(y1 - y2);
}
+/**
+ * gtk_plot_canvas_set_selection:
+ * @child: a #GtkPlotCanvasChild.
+ * @selection: a #GtkPlotCanvasSelection
+ *
+ *
+ */
void
gtk_plot_canvas_child_set_selection (GtkPlotCanvasChild *child,
GtkPlotCanvasSelection selection)
@@ -2036,6 +2441,13 @@ gtk_plot_canvas_child_set_selection (GtkPlotCanvasChild *child,
child->selection = selection;
}
+/**
+ * gtk_plot_canvas_child_set_selection_mode:
+ * @child: a #GtkPlotCanvasChild.
+ * @mode:
+ *
+ *
+ */
void
gtk_plot_canvas_child_set_selection_mode (GtkPlotCanvasChild *child,
GtkPlotCanvasSelectionMode mode)
@@ -2044,6 +2456,13 @@ gtk_plot_canvas_child_set_selection_mode (GtkPlotCanvasChild *child,
child->mode = mode;
}
+/**
+ * gtk_plot_canvas_child_draw:
+ * @canvas: a #GtkPlotCanvas.
+ * @child: a #GtkPlotCanvasChild.
+ *
+ *
+ */
void
gtk_plot_canvas_child_draw(GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child)
@@ -2057,6 +2476,13 @@ gtk_plot_canvas_child_draw(GtkPlotCanvas *canvas,
gtk_plot_pc_grestore(canvas->pc);
}
+/**
+ * gtk_plot_canvas_set_line_attributes:
+ * @canvas: a #GtkPlotCanvas.
+ * @line:
+ *
+ *
+ */
void
gtk_plot_canvas_set_line_attributes(GtkPlotCanvas *canvas, GtkPlotLine line)
{
diff --git a/gtkextra/gtkplotcanvas.h b/gtkextra/gtkplotcanvas.h
index f482d80..8e0c1b9 100644
--- a/gtkextra/gtkplotcanvas.h
+++ b/gtkextra/gtkplotcanvas.h
@@ -84,10 +84,10 @@ typedef enum
#define GTK_PLOT_CANVAS_DND_FLAGS (GTK_PLOT_CANVAS_CAN_SELECT_ITEM | \
GTK_PLOT_CANVAS_CAN_DND )
-#define GTK_PLOT_CANVAS(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_get_type (), GtkPlotCanvas)
-#define GTK_PLOT_CANVAS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_get_type(),
GtkPlotCanvasClass)
-#define GTK_IS_PLOT_CANVAS(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_get_type ())
-#define GTK_TYPE_PLOT_CANVAS (gtk_plot_canvas_get_type ())
+#define GTK_PLOT_CANVAS(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_get_type (),
GtkPlotCanvas)
+#define GTK_PLOT_CANVAS_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_canvas_get_type(),
GtkPlotCanvasClass)
+#define GTK_IS_PLOT_CANVAS(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_get_type ())
+#define G_TYPE_PLOT_CANVAS (gtk_plot_canvas_get_type ())
#define GTK_PLOT_CANVAS_FLAGS(canvas) (GTK_PLOT_CANVAS(canvas)->flags)
#define GTK_PLOT_CANVAS_SET_FLAGS(canvas, flags) (GTK_PLOT_CANVAS_FLAGS(canvas) |= (flags))
@@ -98,10 +98,10 @@ typedef enum
#define GTK_PLOT_CANVAS_CAN_SELECT_ITEM(canvas) (GTK_PLOT_CANVAS_FLAGS(canvas) &
GTK_PLOT_CANVAS_CAN_SELECT_ITEM)
#define GTK_PLOT_CANVAS_CAN_SELECT(canvas) (GTK_PLOT_CANVAS_FLAGS(canvas) & GTK_PLOT_CANVAS_CAN_SELECT)
-#define GTK_PLOT_CANVAS_CHILD(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_child_get_type (),
GtkPlotCanvasChild)
-#define GTK_PLOT_CANVAS_CHILD_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_child_get_type(),
GtkPlotCanvasChildClass)
-#define GTK_IS_PLOT_CANVAS_CHILD(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_child_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_CHILD (gtk_plot_canvas_child_get_type ())
+#define GTK_PLOT_CANVAS_CHILD(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_child_get_type
(), GtkPlotCanvasChild)
+#define GTK_PLOT_CANVAS_CHILD_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_canvas_child_get_type(),
GtkPlotCanvasChildClass)
+#define GTK_IS_PLOT_CANVAS_CHILD(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_child_get_type ())
+#define G_TYPE_PLOT_CANVAS_CHILD (gtk_plot_canvas_child_get_type ())
typedef struct _GtkPlotCanvas GtkPlotCanvas;
@@ -109,6 +109,12 @@ typedef struct _GtkPlotCanvasClass GtkPlotCanvasClass;
typedef struct _GtkPlotCanvasChild GtkPlotCanvasChild;
typedef struct _GtkPlotCanvasChildClass GtkPlotCanvasChildClass;
+/**
+ * GtkPlotCanvasChild:
+ *
+ * The GtkPlotCanvasChild struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasChild
{
GtkObject object;
@@ -148,6 +154,12 @@ struct _GtkPlotCanvasChildClass
void (*set_magnification) (GtkPlotCanvas *canvas, GtkPlotCanvasChild *child, gdouble m);
};
+/**
+ * GtkPlotCanvas:
+ *
+ * The GtkPlotCanvas struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvas
{
GtkFixed fixed;
@@ -218,8 +230,8 @@ struct _GtkPlotCanvasClass
};
-GtkType gtk_plot_canvas_get_type (void);
-GtkType gtk_plot_canvas_child_get_type (void);
+GType gtk_plot_canvas_get_type (void);
+GType gtk_plot_canvas_child_get_type (void);
GtkWidget* gtk_plot_canvas_new (gint width, gint height,
gdouble magnification);
void gtk_plot_canvas_construct (GtkPlotCanvas *canvas,
@@ -252,8 +264,8 @@ void gtk_plot_canvas_set_transparent (GtkPlotCanvas *canvas,
gboolean transparent);
gboolean gtk_plot_canvas_transparent (GtkPlotCanvas *canvas);
void gtk_plot_canvas_set_background (GtkPlotCanvas *canvas,
- const GdkColor *background);
-void gtk_plot_canvas_get_pixel (GtkPlotCanvas *plot_canvas,
+ const GdkColor *bg_color);
+void gtk_plot_canvas_get_pixel (GtkPlotCanvas *canvas,
gdouble px, gdouble py,
gint *x, gint *y);
void gtk_plot_canvas_get_position (GtkPlotCanvas *plot_canvas,
diff --git a/gtkextra/gtkplotpc.c b/gtkextra/gtkplotpc.c
index 4d32c4e..6197b2e 100644
--- a/gtkextra/gtkplotpc.c
+++ b/gtkextra/gtkplotpc.c
@@ -17,6 +17,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotpc
+ * @short_description: Plot Context
+ *
+ * Base Class for #GtkPlotCairo, #GtkPlotGdk and #GtkPlotPS.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -36,26 +43,22 @@ static void gtk_plot_pc_real_init (GtkPlotPC *pc);
static GtkObjectClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_pc_get_type (void)
{
- static GtkType pc_type = 0;
+ static GType pc_type = 0;
if (!pc_type)
{
- GtkTypeInfo pc_info =
- {
- "GtkPlotPC",
- sizeof (GtkPlotPC),
- sizeof (GtkPlotPCClass),
- (GtkClassInitFunc) gtk_plot_pc_class_init,
- (GtkObjectInitFunc) gtk_plot_pc_real_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- pc_type = gtk_type_unique (GTK_TYPE_OBJECT, &pc_info);
+
+ pc_type = g_type_register_static_simple (
+ gtk_object_get_type(),
+ "GtkPlotPC",
+ sizeof (GtkPlotPCClass),
+ (GClassInitFunc) gtk_plot_pc_class_init,
+ sizeof (GtkPlotPC),
+ (GInstanceInitFunc) gtk_plot_pc_real_init,
+ 0);
}
return pc_type;
}
@@ -66,7 +69,7 @@ gtk_plot_pc_class_init (GtkPlotPCClass *klass)
GtkObjectClass *object_class;
GtkPlotPCClass *pc_class;
- parent_class = gtk_type_class (gtk_object_get_type ());
+ parent_class = g_type_class_ref (gtk_object_get_type ());
object_class = (GtkObjectClass *) klass;
pc_class = (GtkPlotPCClass *) klass;
@@ -89,11 +92,19 @@ gtk_plot_pc_new (void)
{
GtkObject *object;
- object = gtk_type_new (gtk_plot_pc_get_type());
+ object = g_object_new (gtk_plot_pc_get_type(), NULL);
return (object);
}
+/**
+ * gtk_plot_pc_init:
+ * @pc:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean gtk_plot_pc_init (GtkPlotPC *pc)
{
pc->init_count++;
@@ -102,6 +113,12 @@ gboolean gtk_plot_pc_init (GtkPlotPC *pc)
return(GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->init(pc));
}
+/**
+ * gtk_plot_pc_leave:
+ * @pc:
+ *
+ *
+ */
void gtk_plot_pc_leave (GtkPlotPC *pc)
{
pc->init_count--;
@@ -110,6 +127,14 @@ void gtk_plot_pc_leave (GtkPlotPC *pc)
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->leave(pc);
}
+/**
+ * gtk_plot_pc_set_viewport:
+ * @pc:
+ * @w:
+ * @h:
+ *
+ *
+ */
void gtk_plot_pc_set_viewport (GtkPlotPC *pc, gdouble w, gdouble h)
{
pc->width = w;
@@ -117,22 +142,50 @@ void gtk_plot_pc_set_viewport (GtkPlotPC *pc, gdouble w, gdouble h)
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->set_viewport(pc, w, h);
}
+/**
+ * gtk_plot_pc_gsave:
+ * @pc:
+ *
+ *
+ */
void gtk_plot_pc_gsave (GtkPlotPC *pc)
{
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->gsave(pc);
}
+/**
+ * gtk_plot_pc_grestore:
+ * @pc:
+ *
+ *
+ */
void gtk_plot_pc_grestore (GtkPlotPC *pc)
{
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->grestore(pc);
}
+/**
+ * gtk_plot_pc_clip:
+ * @pc:
+ * @area:
+ *
+ *
+ */
void gtk_plot_pc_clip (GtkPlotPC *pc,
GdkRectangle *area)
{
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->clip(pc, area);
}
+/**
+ * gtk_plot_pc_clip_mask:
+ * @pc:
+ * @x:
+ * @y:
+ * @mask:
+ *
+ *
+ */
void gtk_plot_pc_clip_mask (GtkPlotPC *pc,
gdouble x,
gdouble y,
@@ -141,6 +194,13 @@ void gtk_plot_pc_clip_mask (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->clip_mask(pc, x, y, mask);
}
+/**
+ * gtk_plot_pc_set_color:
+ * @pc:
+ * @color:
+ *
+ *
+ */
void gtk_plot_pc_set_color (GtkPlotPC *pc,
GdkColor *color)
{
@@ -148,6 +208,16 @@ void gtk_plot_pc_set_color (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->set_color(pc, color);
}
+/**
+ * gtk_plot_pc_set_lineattr:
+ * @pc:
+ * @line_width:
+ * @line_style:
+ * @cap_style:
+ * @join_style:
+ *
+ *
+ */
void gtk_plot_pc_set_lineattr (GtkPlotPC *pc,
gfloat line_width,
GdkLineStyle line_style,
@@ -157,6 +227,15 @@ void gtk_plot_pc_set_lineattr (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->set_lineattr(pc, line_width, line_style,
cap_style, join_style);
}
+/**
+ * gtk_plot_pc_set_dash:
+ * @pc:
+ * @offset_:
+ * @values:
+ * @num_values:
+ *
+ *
+ */
void gtk_plot_pc_set_dash (GtkPlotPC *pc,
gdouble offset_,
gdouble *values,
@@ -165,6 +244,16 @@ void gtk_plot_pc_set_dash (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->set_dash(pc, offset_, values, num_values);
}
+/**
+ * gtk_plot_pc_draw_line:
+ * @pc:
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ *
+ *
+ */
void gtk_plot_pc_draw_line (GtkPlotPC *pc,
gdouble x1, gdouble y1,
gdouble x2, gdouble y2)
@@ -172,6 +261,13 @@ void gtk_plot_pc_draw_line (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_line(pc, x1, y1, x2, y2);
}
+/**
+ * gtk_plot_pc_draw_lines:
+ * @points:
+ * @numpoints:
+ *
+ *
+ */
void gtk_plot_pc_draw_lines (GtkPlotPC *pc,
GtkPlotPoint *points,
gint numpoints)
@@ -180,12 +276,31 @@ void gtk_plot_pc_draw_lines (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_lines(pc, points, numpoints);
}
+/**
+ * gtk_plot_pc_draw_point:
+ * @pc:
+ * @x:
+ * @y:
+ *
+ *
+ */
void gtk_plot_pc_draw_point (GtkPlotPC *pc,
gdouble x, gdouble y)
{
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_point(pc, x, y);
}
+/**
+ * gtk_plot_pc_draw_rectangle:
+ * @pc:
+ * @filled:
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ *
+ */
void gtk_plot_pc_draw_rectangle (GtkPlotPC *pc,
gint filled,
gdouble x, gdouble y,
@@ -195,6 +310,14 @@ void gtk_plot_pc_draw_rectangle (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_rectangle(pc, filled, x, y, width, height);
}
+/**
+ * gtk_plot_pc_draw_polygon:
+ * @pc:
+ * @filled:
+ * @points:
+ *
+ *
+ */
void gtk_plot_pc_draw_polygon (GtkPlotPC *pc,
gint filled,
GtkPlotPoint *points,
@@ -204,6 +327,16 @@ void gtk_plot_pc_draw_polygon (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_polygon(pc, filled, points, numpoints);
}
+/**
+ * gtk_plot_pc_draw_circle:
+ * @pc:
+ * @filled:
+ * @x:
+ * @y:
+ * @size:
+ *
+ *
+ */
void gtk_plot_pc_draw_circle (GtkPlotPC *pc,
gint filled,
gdouble x, gdouble y,
@@ -212,6 +345,17 @@ void gtk_plot_pc_draw_circle (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_circle(pc, filled, x, y, size);
}
+/**
+ * gtk_plot_pc_draw_ellipse:
+ * @pc:
+ * @filled:
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ *
+ */
void gtk_plot_pc_draw_ellipse (GtkPlotPC *pc,
gint filled,
gdouble x, gdouble y,
@@ -221,6 +365,14 @@ void gtk_plot_pc_draw_ellipse (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->draw_ellipse(pc, filled, x, y, width, height);
}
+/**
+ * gtk_plot_pc_set_font:
+ * @pc:
+ * @psfont:
+ * @height:
+ *
+ *
+ */
void gtk_plot_pc_set_font (GtkPlotPC *pc,
GtkPSFont *psfont,
gint height)
@@ -228,6 +380,26 @@ void gtk_plot_pc_set_font (GtkPlotPC *pc,
GTK_PLOT_PC_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(pc)))->set_font(pc, psfont, height);
}
+/**
+ * gtk_plot_pc_draw_string:
+ * @pc:
+ * @x:
+ * @y:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @border:
+ * @border_space:
+ * @border_width:
+ * @shadow_width:
+ * @font:
+ * @height:
+ * @just:
+ * @text:
+ *
+ *
+ */
void gtk_plot_pc_draw_string (GtkPlotPC *pc,
gint x, gint y,
gint angle,
@@ -263,7 +435,22 @@ void gtk_plot_pc_draw_string (GtkPlotPC *pc,
}
-
+/**
+ * gtk_plot_pc_draw_pixmap:
+ * @pc:
+ * @pixmap:
+ * @mask:
+ * @xsrc:
+ * @ysrc:
+ * @xdest:
+ * @ydest:
+ * @width:
+ * @height:
+ * @scale_x:
+ * @scale_y:
+ *
+ *
+ */
void gtk_plot_pc_draw_pixmap (GtkPlotPC *pc,
GdkPixmap *pixmap,
GdkBitmap *mask,
diff --git a/gtkextra/gtkplotpc.h b/gtkextra/gtkplotpc.h
index 0e69012..8b23ff0 100644
--- a/gtkextra/gtkplotpc.h
+++ b/gtkextra/gtkplotpc.h
@@ -28,11 +28,11 @@ extern "C" {
#endif /* __cplusplus */
-#define GTK_PLOT_PC(obj) GTK_CHECK_CAST (obj, gtk_plot_pc_get_type (), GtkPlotPC)
+#define GTK_PLOT_PC(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_pc_get_type (), GtkPlotPC)
#define GTK_TYPE_PLOT_PC (gtk_plot_pc_get_type ())
-#define GTK_PLOT_PC_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_pc_get_type(), GtkPlotPCClass)
-#define GTK_IS_PLOT_PC(obj) GTK_CHECK_TYPE (obj, gtk_plot_pc_get_type ())
+#define GTK_PLOT_PC_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_pc_get_type(), GtkPlotPCClass)
+#define GTK_IS_PLOT_PC(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_pc_get_type ())
/* Page size */
@@ -77,8 +77,15 @@ typedef struct _GtkPlotPC GtkPlotPC;
typedef struct _GtkPlotPCClass GtkPlotPCClass;
typedef struct _GtkPlotPoint GtkPlotPoint;
+/**
+ * GtkPlotPoint:
+ *
+ * The GtkPlotPoint struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotPoint
{
+ /*< private >*/
gdouble x, y;
};
@@ -193,7 +200,7 @@ struct _GtkPlotPCClass
gdouble scale_y);
};
-GtkType gtk_plot_pc_get_type (void);
+GType gtk_plot_pc_get_type (void);
GtkObject *gtk_plot_pc_new (void);
gboolean gtk_plot_pc_init (GtkPlotPC *pc);
diff --git a/gtkextra/gtkplotprint.c b/gtkextra/gtkplotprint.c
index 73d318e..66e689b 100644
--- a/gtkextra/gtkplotprint.c
+++ b/gtkextra/gtkplotprint.c
@@ -17,6 +17,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotprint
+ * @short_description:
+ *
+ * FIXME:: Need long description.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -34,13 +41,28 @@
#include "gtkplotps.h"
#include "gtkplotdt.h"
#include "gtkplotsurface.h"
+#include "gtkplotcairo.h"
#include "gtkplotcanvas.h"
static void recalc_pixels(GtkPlot *plot);
+
+
+/**
+ * gtk_plot_export_ps:
+ * @plot: a #GtkPlot
+ * @file_name:
+ * @orient:
+ * @epsflag:
+ * @page_size:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_export_ps (GtkPlot *plot,
- char *psname,
+ char *file_name,
GtkPlotPageOrientation orient,
gboolean epsflag,
GtkPlotPageSize page_size)
@@ -49,22 +71,25 @@ gtk_plot_export_ps (GtkPlot *plot,
GtkPlotPS *ps;
gdouble scalex, scaley;
gdouble m;
+ GtkAllocation allocation;
m = plot->magnification;
- ps = GTK_PLOT_PS(gtk_plot_ps_new(psname, orient, epsflag, page_size, 1.0, 1.0));
+ ps = GTK_PLOT_PS(gtk_plot_ps_new(file_name, orient, epsflag, page_size, 1.0, 1.0));
+
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
if(orient == GTK_PLOT_PORTRAIT){
scalex = (gfloat)ps->page_width /
- (gfloat)GTK_WIDGET(plot)->allocation.width;
+ (gfloat)allocation.width;
scaley = (gfloat)ps->page_height /
- (gfloat)GTK_WIDGET(plot)->allocation.height;
+ (gfloat)allocation.height;
}else{
scalex = (gfloat)ps->page_width /
- (gfloat)GTK_WIDGET(plot)->allocation.height;
+ (gfloat)allocation.height;
scaley = (gfloat)ps->page_height /
- (gfloat)GTK_WIDGET(plot)->allocation.width;
+ (gfloat)allocation.width;
}
gtk_plot_ps_set_scale(ps, scalex, scaley);
@@ -85,9 +110,23 @@ gtk_plot_export_ps (GtkPlot *plot,
return TRUE;
}
+/**
+ * gtk_plot_export_ps_with_size:
+ * @plot: a #GtkPlot
+ * @file_name:
+ * @orient:
+ * @epsflag:
+ * @units:
+ * @width:
+ * @height:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_export_ps_with_size (GtkPlot *plot,
- char *psname,
+ char *file_name,
GtkPlotPageOrientation orient,
gboolean epsflag,
GtkPlotUnits units,
@@ -98,24 +137,26 @@ gtk_plot_export_ps_with_size (GtkPlot *plot,
GtkPlotPS *ps;
gdouble scalex, scaley;
gdouble m;
+ GtkAllocation allocation;
m = plot->magnification;
- ps = GTK_PLOT_PS(gtk_plot_ps_new_with_size(psname, orient, epsflag,
+ ps = GTK_PLOT_PS(gtk_plot_ps_new_with_size(file_name, orient, epsflag,
units,
width, height,
1.0 , 1.0));
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
if(orient == GTK_PLOT_PORTRAIT){
scalex = (gfloat)ps->page_width /
- (gfloat)GTK_WIDGET(plot)->allocation.width;
+ (gfloat)allocation.width;
scaley = (gfloat)ps->page_height /
- (gfloat)GTK_WIDGET(plot)->allocation.height;
+ (gfloat)allocation.height;
}else{
scalex = (gfloat)ps->page_width /
- (gfloat)GTK_WIDGET(plot)->allocation.height;
+ (gfloat)allocation.height;
scaley = (gfloat)ps->page_height /
- (gfloat)GTK_WIDGET(plot)->allocation.width;
+ (gfloat)allocation.width;
}
gtk_plot_ps_set_scale(ps, scalex, scaley);
@@ -136,23 +177,34 @@ gtk_plot_export_ps_with_size (GtkPlot *plot,
return TRUE;
}
+/**
+ * gtk_plot_canvas_export_ps:
+ * @canvas: a #GtkPlotCanvas .
+ * @file_name:
+ * @orient:
+ * @epsflag:
+ * @page_size:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_canvas_export_ps (GtkPlotCanvas *canvas,
- char *psname,
+ char *file_name,
GtkPlotPageOrientation orient,
gboolean epsflag,
GtkPlotPageSize page_size)
{
GtkPlotPC *pc;
GtkPlotPS *ps;
- gint old_width, old_height;
gdouble scalex, scaley;
gdouble m;
GdkPixmap *pixmap;
m = canvas->magnification;
- ps = GTK_PLOT_PS(gtk_plot_ps_new(psname, orient, epsflag, page_size, 1.0, 1.0));
+ ps = GTK_PLOT_PS(gtk_plot_ps_new(file_name, orient, epsflag, page_size, 1.0, 1.0));
if(orient == GTK_PLOT_PORTRAIT){
scalex = (gfloat)ps->page_width / (gfloat)canvas->width;
@@ -164,30 +216,45 @@ gtk_plot_canvas_export_ps (GtkPlotCanvas *canvas,
gtk_plot_ps_set_scale(ps, scalex, scaley);
- old_width = canvas->pixmap_width;
- old_height = canvas->pixmap_height;
-
pc = canvas->pc;
- canvas->pc = GTK_PLOT_PC(ps);
pixmap = canvas->pixmap;
canvas->pixmap = NULL;
+ canvas->pc = NULL;
gtk_plot_canvas_set_magnification(canvas, 1.0);
+ canvas->pc = GTK_PLOT_PC(ps);
+ canvas->pixmap = pixmap;
gtk_plot_canvas_paint(canvas);
+
+ canvas->pixmap = NULL;
+ canvas->pc = NULL;
gtk_plot_canvas_set_magnification(canvas, m);
- gdk_pixmap_unref(canvas->pixmap);
canvas->pixmap = pixmap;
-
canvas->pc = pc;
+
gtk_object_destroy(GTK_OBJECT(ps));
return TRUE;
}
+/**
+ * gtk_plot_canvas_export_ps_with_size:
+ * @canvas: a #GtkPlotCanvas .
+ * @file_name:
+ * @orient:
+ * @epsflag:
+ * @units:
+ * @width:
+ * @height:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_canvas_export_ps_with_size (GtkPlotCanvas *canvas,
- char *psname,
+ char *file_name,
GtkPlotPageOrientation orient,
gboolean epsflag,
GtkPlotUnits units,
@@ -202,7 +269,7 @@ gtk_plot_canvas_export_ps_with_size (GtkPlotCanvas *canvas,
m = canvas->magnification;
- ps = GTK_PLOT_PS(gtk_plot_ps_new_with_size(psname, orient, epsflag,
+ ps = GTK_PLOT_PS(gtk_plot_ps_new_with_size(file_name, orient, epsflag,
units,
width, height,
1.0 , 1.0));
@@ -218,22 +285,27 @@ gtk_plot_canvas_export_ps_with_size (GtkPlotCanvas *canvas,
gtk_plot_ps_set_scale(ps, scalex, scaley);
pc = canvas->pc;
- canvas->pc = GTK_PLOT_PC(ps);
pixmap = canvas->pixmap;
canvas->pixmap = NULL;
+ canvas->pc = NULL;
gtk_plot_canvas_set_magnification(canvas, 1.0);
+ canvas->pc = GTK_PLOT_PC(ps);
+ canvas->pixmap = pixmap;
+
gtk_plot_canvas_paint(canvas);
+
+ canvas->pixmap = NULL;
+ canvas->pc = NULL;
gtk_plot_canvas_set_magnification(canvas, m);
- gdk_pixmap_unref(canvas->pixmap);
canvas->pixmap = pixmap;
-
canvas->pc = pc;
gtk_object_destroy(GTK_OBJECT(ps));
return TRUE;
}
+
static void
recalc_pixels(GtkPlot *plot)
{
@@ -266,3 +338,40 @@ recalc_pixels(GtkPlot *plot)
}
}
+/**
+ * gtk_plot_canvas_export_cairo:
+ * @canvas: a #GtkPlotCanvas .
+ * @cairo:
+ *
+ *
+ *
+ * Return value:
+ */
+
+gboolean
+gtk_plot_canvas_export_cairo (GtkPlotCanvas *canvas,
+ cairo_t *cairo)
+{
+ GdkPixmap *pixmap;
+ GtkPlotPC *pc, *new_pc;
+ gdouble m;
+
+ m = canvas->magnification;
+ pc = canvas->pc;
+ new_pc = GTK_PLOT_PC(gtk_plot_cairo_new(cairo));
+
+ pixmap = canvas->pixmap;
+ canvas->pixmap = NULL;
+ canvas->pc = NULL;
+ gtk_plot_canvas_set_magnification(canvas, 1.);
+ canvas->pc = new_pc;
+ canvas->pixmap = pixmap;
+ gtk_plot_canvas_paint(canvas);
+ canvas->pc = pc;
+ gtk_plot_canvas_set_magnification(canvas, m);
+ g_object_unref(new_pc);
+
+ return TRUE;
+}
+
+
diff --git a/gtkextra/gtkplotprint.h b/gtkextra/gtkplotprint.h
index 65d31d7..d80477b 100644
--- a/gtkextra/gtkplotprint.h
+++ b/gtkextra/gtkplotprint.h
@@ -55,6 +55,9 @@ gtk_plot_canvas_export_ps_with_size (GtkPlotCanvas *canvas,
gint width,
gint height);
+gboolean
+gtk_plot_canvas_export_cairo (GtkPlotCanvas *canvas,
+ cairo_t *cairo);
#ifdef __cplusplus
}
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
