[genius] Thu Jun 13 16:42:42 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 16:42:42 2013 Jiri (George) Lebl <jirka 5z com>
- Date: Thu, 13 Jun 2013 21:44:24 +0000 (UTC)
commit a30256513f26e8cdea9915dbbbad33192fc13d2a
Author: Jiri (George) Lebl <jirka 5z com>
Date: Thu Jun 13 16:44:05 2013 -0500
Thu Jun 13 16:42:42 2013 Jiri (George) Lebl <jirka 5z com>
* gtkextra/*: copied lots of the files from 3.0.5, only gtkplot3d,
gtkplotdt and gtkplotsurface remain unupdated
* gtkextra/gtkplotps.c: updated to the 3.0.5 version part way, the
new one is still broken so the new geometry stuff is not there (it
is drawn still upside down and then rotated). Also
a fix from James Cloos to change the EPS header to EPSF from PCF,
seems to fix PDF conversion.
* src/graphing.c: allow PDF export by calling ps2pdf properly,
also don't show the epsi checkbox unless we are exporting to EPS
ChangeLog | 18 +-
NEWS | 1 +
gtkextra/CONVERTEDTO3 | 21 +
gtkextra/gtkplot.c | 2147 ++++++++++++++++++++++++++++++++-----
gtkextra/gtkplot.h | 1327 ++++++++++++-----------
gtkextra/gtkplotarray.c | 73 +-
gtkextra/gtkplotarray.h | 38 +-
gtkextra/gtkplotbar.c | 95 ++-
gtkextra/gtkplotbar.h | 16 +-
gtkextra/gtkplotbox.c | 69 +-
gtkextra/gtkplotbox.h | 16 +-
gtkextra/gtkplotcanvasellipse.c | 81 +-
gtkextra/gtkplotcanvasellipse.h | 16 +-
gtkextra/gtkplotcanvasline.c | 159 +++-
gtkextra/gtkplotcanvasline.h | 17 +-
gtkextra/gtkplotcanvaspixmap.c | 48 +-
gtkextra/gtkplotcanvaspixmap.h | 18 +-
gtkextra/gtkplotcanvasplot.c | 67 +-
gtkextra/gtkplotcanvasplot.h | 16 +-
gtkextra/gtkplotcanvasrectangle.c | 81 ++-
gtkextra/gtkplotcanvasrectangle.h | 16 +-
gtkextra/gtkplotcanvastext.c | 66 +-
gtkextra/gtkplotcanvastext.h | 18 +-
gtkextra/gtkplotcsurface.c | 205 +++-
gtkextra/gtkplotcsurface.h | 25 +-
gtkextra/gtkplotdata.c | 1709 ++++++++++++++++++++++++++---
gtkextra/gtkplotdata.h | 106 +-
gtkextra/gtkplotflux.c | 228 ++++-
gtkextra/gtkplotflux.h | 20 +-
gtkextra/gtkplotgdk.c | 73 +-
gtkextra/gtkplotgdk.h | 18 +-
gtkextra/gtkplotpixmap.c | 77 +-
gtkextra/gtkplotpixmap.h | 20 +-
gtkextra/gtkplotpolar.c | 136 ++-
gtkextra/gtkplotpolar.h | 16 +-
gtkextra/gtkplotps.c | 233 +++--
gtkextra/gtkplotps.h | 10 +-
gtkextra/gtkpsfont.c | 141 +++-
gtkextra/gtkpsfont.h | 15 +-
src/graphing.c | 111 ++-
40 files changed, 5894 insertions(+), 1673 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index f084dc6..55522ce 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+Thu Jun 13 16:42:42 2013 Jiri (George) Lebl <jirka 5z com>
+
+ * gtkextra/*: copied lots of the files from 3.0.5, only gtkplot3d,
+ gtkplotdt and gtkplotsurface remain unupdated
+
+ * gtkextra/gtkplotps.c: updated to the 3.0.5 version part way, the
+ new one is still broken so the new geometry stuff is not there (it
+ is drawn still upside down and then rotated). Also
+ a fix from James Cloos to change the EPS header to EPSF from PCF,
+ seems to fix PDF conversion.
+
+ * src/graphing.c: allow PDF export by calling ps2pdf properly,
+ also don't show the epsi checkbox unless we are exporting to EPS
+
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
@@ -964,7 +978,7 @@ Mon Mar 02 02:07:52 2009 Jiri (George) Lebl <jirka 5z com>
* src/graphing.c: fix bad drawing of very vertical functions. Our
new hack in gtkextra handles lines way off screen more sanely so
- we needent worry much here.
+ we needn't worry much here.
Fri Feb 27 14:42:12 2009 Jiri (George) Lebl <jirka 5z com>
@@ -1817,7 +1831,7 @@ Sat Nov 03 20:51:37 2007 Jiri (George) Lebl <jirka 5z com>
hanging behaviour.
* gtkextra/*: copy new files from cvs version of gtk extra except
- for gtkpslot which is broken, so keep our old version which works
+ for gtkplotps which is broken, so keep our old version which works
* gtkextra/gtkplot3d.[ch]: fix up the axis mess
diff --git a/NEWS b/NEWS
index 225a8dd..5d3eb3c 100644
--- a/NEWS
+++ b/NEWS
@@ -9,6 +9,7 @@ Changes to 1.0.17
* All plots are now antialiased on the screen.
(Obtained by updating pieces of internal GtkExtra updated to obtain Cairo
drawing)
+* Add export of graphs to PDF
* Completion for "help on function" in the GUI
* Fix FindRootBisection and FindRootMullersMethod
* Factors is now a lot faster on very large numbers (as fast as Factorize)
diff --git a/gtkextra/CONVERTEDTO3 b/gtkextra/CONVERTEDTO3
index d6575d6..7ce1a15 100644
--- a/gtkextra/CONVERTEDTO3
+++ b/gtkextra/CONVERTEDTO3
@@ -5,3 +5,24 @@ gtkplotcanvas.[ch] 3.0.5
gtkplotpc.[ch] 3.0.5
gtkextra.[ch] 3.0.5
gtkplotprint.[ch] 3.0.5
+gtkplotps.[ch] 3.0.5 (but parts are not updated, the new geometry was not working, needs
fixing up)
+gtkplotarray.[ch] 3.0.5
+gtkplotbar.[ch] 3.0.5
+gtkplotbox.[ch] 3.0.5
+gtkplotcanvasellipse.[ch] 3.0.5
+gtkplotcanvastext.[ch] 3.0.5
+gtkplotcanvasline.[ch] 3.0.5
+gtkplotcanvaspixmap.[ch] 3.0.5
+gtkplotcanvasrectangle.[ch] 3.0.5
+gtkplotcanvasplot.[ch] 3.0.5
+gtkplotcsurface.[ch] 3.0.5
+gtkplotflux.[ch] 3.0.5
+gtkplotpixmap.[ch] 3.0.5
+gtkplotpolar.[ch] 3.0.5
+gtkplotgdk.[ch] 3.0.5
+gtkplotdata.[ch] 3.0.5
+gtkplot.[ch] 3.0.5
+
+gtkplot3d.[ch] 2.? svn
+gtkplotdt.[ch] 2.? svn
+gtkplotsurface.[ch] 2.? svn
diff --git a/gtkextra/gtkplot.c b/gtkextra/gtkplot.c
index f416f0c..3a2264a 100644
--- a/gtkextra/gtkplot.c
+++ b/gtkextra/gtkplot.c
@@ -17,6 +17,17 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplot
+ * @short_description: 2d scientific plots widget
+ *
+ * GtkPlot allows to draw high quality scientific plots in two dimensions with a look and feel very similar
to Microcal Origin for Windows.
+ * The distribution includes GtkPlotCanvas subclass, and a demo program showing two layered plots with
different kind of curves.
+ * You can choose between a number of symbol types, lines, connectors -straight lines, steps, splines-, and
change their attributes -color, size, width.
+ * You can also plot functions, add error bars, edit legends, rotate and move axis titles, change axis
properties, etc.
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -26,6 +37,7 @@
#include "gtkplotdata.h"
#include "gtkpsfont.h"
#include "gtkplotgdk.h"
+#include "gtkplotcairo.h"
#include "gtkextra-marshal.h"
#define DEFAULT_WIDTH 420
@@ -227,26 +239,21 @@ static guint plot_signals[LAST_SIGNAL] = {0};
static guint axis_signals[LAST_AXIS_SIGNAL] = {0};
-GtkType
+GType
gtk_plot_get_type (void)
{
- static GtkType plot_type = 0;
+ static GType plot_type = 0;
if (!plot_type)
{
- GtkTypeInfo plot_info =
- {
- "GtkPlot",
- sizeof (GtkPlot),
- sizeof (GtkPlotClass),
- (GtkClassInitFunc) gtk_plot_class_init,
- (GtkObjectInitFunc) gtk_plot_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_type = gtk_type_unique (GTK_TYPE_MISC, &plot_info);
+ plot_type = g_type_register_static_simple (
+ gtk_misc_get_type (),
+ "GtkPlot",
+ sizeof (GtkPlotClass),
+ (GClassInitFunc) gtk_plot_class_init,
+ sizeof (GtkPlot),
+ (GInstanceInitFunc) gtk_plot_init,
+ 0);
}
return plot_type;
}
@@ -259,7 +266,7 @@ gtk_plot_class_init (GtkPlotClass *klass)
GtkPlotClass *plot_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_widget_get_type ());
+ parent_class = g_type_class_ref (gtk_widget_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -269,53 +276,103 @@ gtk_plot_class_init (GtkPlotClass *klass)
widget_class->size_request = gtk_plot_size_request;
widget_class->size_allocate = gtk_plot_size_allocate;
+
+ /**
+ * GtkPlot::add_data:
+ * @plot: a #GtkPlot widget.
+ * @plotdata: a #GtkPlotData.
+ *
+ *
+ *
+ * Return value:
+ */
plot_signals[ADD_DATA] =
- gtk_signal_new("add_data",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, add_data),
+ g_signal_new("add_data",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, add_data),
+ NULL, NULL,
gtkextra_BOOL__POINTER,
- GTK_TYPE_BOOL, 1, GTK_TYPE_PLOT_DATA);
-
+ G_TYPE_BOOLEAN, 1, G_TYPE_PLOT_DATA);
+
+ /**
+ * GtkPlot::changed:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ */
plot_signals[CHANGED] =
- gtk_signal_new("changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, changed),
+ g_signal_new("changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, changed),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0);
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkPlot::update:
+ * @plot: a #GtkPlot widget.
+ * @new_range:
+ *
+ *
+ */
plot_signals[UPDATE] =
- gtk_signal_new("update",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, update),
+ g_signal_new("update",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, update),
+ NULL, NULL,
gtkextra_VOID__BOOL,
- GTK_TYPE_NONE, 1, GTK_TYPE_BOOL);
-
+ G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+
+ /**
+ * GtkPlot::moved:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ *
+ *
+ *
+ * Return value:
+ */
plot_signals[MOVED] =
- gtk_signal_new("moved",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, moved),
+ g_signal_new("moved",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, moved),
+ NULL, NULL,
gtkextra_BOOL__POINTER_POINTER,
- GTK_TYPE_BOOL, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER);
-
+ G_TYPE_BOOLEAN, 2, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ /**
+ * GtkPlot::resized:
+ * @plot: a #GtkPlot widget.
+ * @width:
+ * @height:
+ *
+ *
+ *
+ * Return value:
+ */
plot_signals[RESIZED] =
- gtk_signal_new("resized",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, resized),
+ g_signal_new("resized",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, resized),
+ NULL, NULL,
gtkextra_BOOL__POINTER_POINTER,
- GTK_TYPE_BOOL, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER);
+ G_TYPE_BOOLEAN, 2, G_TYPE_POINTER, G_TYPE_POINTER);
plot_signals[PLOT_AXIS_CHANGED] =
- gtk_signal_new("axis_changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotClass, moved),
+ g_signal_new("axis_changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotClass, moved),
+ NULL, NULL,
gtkextra_BOOL__POINTER,
- GTK_TYPE_BOOL, 1, GTK_TYPE_PLOT_AXIS);
+ G_TYPE_BOOLEAN, 1, G_TYPE_PLOT_AXIS);
object_class->destroy = gtk_plot_destroy;
gobject_class->set_property = gtk_plot_set_property;
@@ -334,34 +391,64 @@ gtk_plot_class_init (GtkPlotClass *klass)
plot_class->get_point = gtk_plot_real_get_point;
plot_class->get_pixel = gtk_plot_real_get_pixel;
+
+ /**
+ * GtkPlot:bottom_axis:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BOTTOM,
g_param_spec_object ("bottom_axis",
P_(""),
P_(""),
- GTK_TYPE_PLOT_AXIS,
+ G_TYPE_PLOT_AXIS,
G_PARAM_READABLE));
+
+ /**
+ * GtkPlot:top_axis:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TOP,
g_param_spec_object ("top_axis",
P_(""),
P_(""),
- GTK_TYPE_PLOT_AXIS,
+ G_TYPE_PLOT_AXIS,
G_PARAM_READABLE));
+
+ /**
+ * GtkPlot:left_axis:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEFT,
g_param_spec_object ("left_axis",
P_(""),
P_(""),
- GTK_TYPE_PLOT_AXIS,
+ G_TYPE_PLOT_AXIS,
G_PARAM_READABLE));
+
+ /**
+ * GtkPlot:right_axis:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_RIGHT,
g_param_spec_object ("right_axis",
P_(""),
P_(""),
- GTK_TYPE_PLOT_AXIS,
+ G_TYPE_PLOT_AXIS,
G_PARAM_READABLE));
+
+ /**
+ * GtkPlot:allocation_x:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_ALLOCATION_X,
g_param_spec_int ("allocation_x",
@@ -369,6 +456,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXINT,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:allocation_y:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_ALLOCATION_Y,
g_param_spec_int ("allocation_y",
@@ -376,6 +469,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXINT,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:allocation_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_ALLOCATION_WIDTH,
g_param_spec_int ("allocation_width",
@@ -383,6 +482,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXINT,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:allocation_height:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_ALLOCATION_HEIGHT,
g_param_spec_int ("allocation_height",
@@ -390,6 +495,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXINT,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:use_pixmap:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_USE_PIXMAP,
g_param_spec_boolean ("use_pixmap",
@@ -397,12 +508,24 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:bg_pixmap:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BG_PIXMAP,
g_param_spec_pointer ("bg_pixmap",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:transparent:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TRANSPARENT,
g_param_spec_boolean ("transparent",
@@ -410,6 +533,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:magnification:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_MAGNIFICATION,
g_param_spec_double ("magnification",
@@ -417,6 +546,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:clip_data:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_CLIP_DATA,
g_param_spec_boolean ("clip_data",
@@ -424,12 +559,24 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:bg_color:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BG,
g_param_spec_pointer ("bg_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:grids_on_top:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_GRIDS_ON_TOP,
g_param_spec_boolean ("grids_on_top",
@@ -437,6 +584,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:show_x0:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SHOW_X0,
g_param_spec_boolean ("show_x0",
@@ -444,6 +597,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:show_y0:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SHOW_Y0,
g_param_spec_boolean ("show_y0",
@@ -451,18 +610,37 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:x0_line:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_X0_LINE,
g_param_spec_pointer ("x0_line",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:y0_line:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_Y0_LINE,
g_param_spec_pointer ("y0_line",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+
+ /**
+ * GtkPlot:xmin:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_XMIN,
g_param_spec_double ("xmin",
@@ -470,6 +648,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:xmax:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_XMAX,
g_param_spec_double ("xmax",
@@ -477,6 +661,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:ymin:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_YMIN,
g_param_spec_double ("ymin",
@@ -484,6 +674,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:ymax:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_YMAX,
g_param_spec_double ("ymax",
@@ -491,6 +687,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:x:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_X,
g_param_spec_double ("x",
@@ -498,6 +700,13 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:y:
+ *
+ *
+ **/
+
g_object_class_install_property(gobject_class,
ARG_Y,
g_param_spec_double ("y",
@@ -505,6 +714,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_WIDTH,
g_param_spec_double ("width",
@@ -512,6 +727,13 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:height:
+ *
+ *
+ **/
+
g_object_class_install_property(gobject_class,
ARG_HEIGHT,
g_param_spec_double ("height",
@@ -519,6 +741,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:xscale:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_XSCALE,
g_param_spec_int ("xscale",
@@ -526,6 +754,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:yscale:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_YSCALE,
g_param_spec_int ("yscale",
@@ -533,6 +767,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:reflect_x:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_REFLECT_X,
g_param_spec_boolean ("reflect_x",
@@ -540,6 +780,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:reflect_y:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_REFLECT_Y,
g_param_spec_boolean ("reflect_y",
@@ -547,6 +793,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:bottom_align:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BOTTOM_ALIGN,
g_param_spec_double ("bottom_align",
@@ -554,6 +806,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:top_align:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TOP_ALIGN,
g_param_spec_double ("top_align",
@@ -561,6 +819,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:left_align:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEFT_ALIGN,
g_param_spec_double ("left_align",
@@ -568,6 +832,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:right_align:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_RIGHT_ALIGN,
g_param_spec_double ("right_align",
@@ -575,6 +845,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_x:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_X,
g_param_spec_double ("legends_x",
@@ -582,6 +858,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_y:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_Y,
g_param_spec_double ("legends_y",
@@ -589,6 +871,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_WIDTH,
g_param_spec_int ("legends_width",
@@ -596,6 +884,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_height:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_HEIGHT,
g_param_spec_int ("legends_height",
@@ -603,6 +897,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_border:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_BORDER,
g_param_spec_int ("legends_border",
@@ -610,6 +910,13 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+
+ /**
+ * GtkPlot:legends_line_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_LINE_WIDTH,
g_param_spec_int ("legends_line_width",
@@ -617,6 +924,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_border_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_BORDER_WIDTH,
g_param_spec_int ("legends_border_width",
@@ -624,6 +937,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_shadow_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_SHADOW_WIDTH,
g_param_spec_int ("legends_shadow_width",
@@ -631,6 +950,12 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_show:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_SHOW,
g_param_spec_boolean ("legends_show",
@@ -638,12 +963,24 @@ gtk_plot_class_init (GtkPlotClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_attr_text:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_ATTR,
g_param_spec_pointer ("legends_attr_text",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlot:legends_transparent:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LEGENDS_TRANSPARENT,
g_param_spec_boolean ("legends_transparent",
@@ -653,26 +990,21 @@ gtk_plot_class_init (GtkPlotClass *klass)
G_PARAM_READABLE|G_PARAM_WRITABLE));
}
-GtkType
+GType
gtk_plot_axis_get_type (void)
{
- static GtkType axis_type = 0;
+ static GType axis_type = 0;
if (!axis_type)
{
- GtkTypeInfo axis_info =
- {
- "GtkPlotAxis",
- sizeof (GtkPlotAxis),
- sizeof (GtkPlotAxisClass),
- (GtkClassInitFunc) gtk_plot_axis_class_init,
- (GtkObjectInitFunc) gtk_plot_axis_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- axis_type = gtk_type_unique (GTK_TYPE_OBJECT, &axis_info);
+ axis_type = g_type_register_static_simple (
+ gtk_object_get_type(),
+ "GtkPlotAxis",
+ sizeof (GtkPlotAxisClass),
+ (GClassInitFunc) gtk_plot_axis_class_init,
+ sizeof (GtkPlotAxis),
+ (GInstanceInitFunc) gtk_plot_axis_init,
+ 0);
}
return axis_type;
}
@@ -688,21 +1020,42 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
object_class = (GtkObjectClass *) klass;
axis_class = (GtkPlotAxisClass *) klass;
+ /**
+ * GtkPlotAxis::tick_label:
+ * @axis:
+ * @tick:
+ * @label:
+ *
+ *
+ *
+ * Return value:
+ */
axis_signals[TICK_LABEL] =
- gtk_signal_new("tick_label",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotAxisClass, tick_label),
+ g_signal_new("tick_label",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotAxisClass, tick_label),
+ NULL, NULL,
gtkextra_BOOL__POINTER_POINTER,
- GTK_TYPE_BOOL, 2, GTK_TYPE_POINTER, GTK_TYPE_POINTER);
+ G_TYPE_BOOLEAN, 2, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ /**
+ * GtkPlotAxis::changed:
+ * @axis:
+ *
+ *
+ *
+ * Return value:
+ */
axis_signals[AXIS_CHANGED] =
- gtk_signal_new("changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotAxisClass, changed),
+ g_signal_new("changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotAxisClass, changed),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0);
+ G_TYPE_NONE, 0);
object_class->destroy = gtk_plot_axis_destroy;
gobject_class->set_property = gtk_plot_axis_set_property;
@@ -710,6 +1063,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
axis_class->tick_label = NULL;
+
+ /**
+ * GtkPlotAxis:visible:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_VISIBLE,
g_param_spec_boolean ("visible",
@@ -717,12 +1076,24 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:title_text:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TITLE,
g_param_spec_pointer ("title_text",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:title_visible:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TITLE_VISIBLE,
g_param_spec_boolean ("title_visible",
@@ -730,6 +1101,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:orientation:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_ORIENTATION,
g_param_spec_int ("orientation",
@@ -737,24 +1114,49 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,2,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+
+ /**
+ * GtkPlotAxis:line:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LINE,
g_param_spec_pointer ("line",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:major_grid_line:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_MAJOR_GRID,
g_param_spec_pointer ("major_grid_line",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:minor_grid_line:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_MINOR_GRID,
g_param_spec_pointer ("minor_grid_line",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:major_mask:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_MAJOR_MASK,
g_param_spec_int ("major_mask",
@@ -762,6 +1164,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:minor_mask:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_MINOR_MASK,
g_param_spec_int ("minor_mask",
@@ -769,6 +1177,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:ticks_length:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TICKS_LENGTH,
g_param_spec_int ("ticks_length",
@@ -776,6 +1190,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:ticks_width:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TICKS_WIDTH,
g_param_spec_double ("ticks_width",
@@ -783,6 +1203,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:custom_labels:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_CUSTOM_LABELS,
g_param_spec_boolean ("custom_labels",
@@ -790,13 +1216,26 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+
+ /**
+ * GtkPlotAxis:labels_array:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TICK_LABELS,
g_param_spec_object ("labels_array",
P_(""),
P_(""),
- GTK_TYPE_PLOT_ARRAY,
+ G_TYPE_PLOT_ARRAY,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_offset:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_OFFSET,
g_param_spec_int ("labels_offset",
@@ -804,6 +1243,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_prefix:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_PREFIX,
g_param_spec_string ("labels_prefix",
@@ -811,6 +1256,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_suffix:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_SUFFIX,
g_param_spec_string ("labels_suffix",
@@ -818,6 +1269,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:show_major_grid:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SHOW_MAJOR_GRID,
g_param_spec_boolean ("show_major_grid",
@@ -825,6 +1282,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:show_minor_grid:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SHOW_MINOR_GRID,
g_param_spec_boolean ("show_minor_grid",
@@ -832,12 +1295,24 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_text:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_ATTR,
g_param_spec_pointer ("labels_text",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_precision:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_PRECISION,
g_param_spec_int ("labels_precision",
@@ -845,6 +1320,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_style:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_STYLE,
g_param_spec_int ("labels_style",
@@ -852,6 +1333,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:labels_mask:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_LABELS_MASK,
g_param_spec_int ("labels_mask",
@@ -859,6 +1346,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:min:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TICKS_MIN,
g_param_spec_double ("min",
@@ -866,6 +1359,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:max:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_TICKS_MAX,
g_param_spec_double ("max",
@@ -873,6 +1372,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:scale:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SCALE,
g_param_spec_int ("scale",
@@ -880,6 +1385,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:nmajorticks:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_NMAJORTICKS,
g_param_spec_int ("nmajorticks",
@@ -887,6 +1398,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:nminorticks:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_NMINORTICKS,
g_param_spec_int ("nminorticks",
@@ -894,6 +1411,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:nticks:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_NTICKS,
g_param_spec_int ("nticks",
@@ -901,6 +1424,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:step:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_STEP,
g_param_spec_double ("step",
@@ -908,6 +1437,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:nminor:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_NMINOR,
g_param_spec_int ("nminor",
@@ -915,6 +1450,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:apply_break:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_APPLY_BREAK,
g_param_spec_boolean ("apply_break",
@@ -922,6 +1463,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_scale:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_SCALE,
g_param_spec_int ("break_scale",
@@ -929,6 +1476,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_min:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_MIN,
g_param_spec_double ("break_min",
@@ -936,6 +1489,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_max:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_MAX,
g_param_spec_double ("break_max",
@@ -943,6 +1502,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_step:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_STEP,
g_param_spec_double ("break_step",
@@ -950,6 +1515,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_nminor:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_NMINOR,
g_param_spec_int ("break_nminor",
@@ -957,6 +1528,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:break_position:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BREAK_POSITION,
g_param_spec_double ("break_position",
@@ -964,6 +1541,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:set_limits:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_SET_LIMITS,
g_param_spec_boolean ("set_limits",
@@ -971,6 +1554,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:begin:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_BEGIN,
g_param_spec_double ("begin",
@@ -978,6 +1567,12 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotAxis:end:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_END,
g_param_spec_double ("end",
@@ -990,18 +1585,21 @@ gtk_plot_axis_class_init (GtkPlotAxisClass *klass)
static void
axis_changed(GtkPlotAxis *axis, GtkPlot *plot)
{
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
static void
gtk_plot_init (GtkPlot *plot)
{
GtkWidget *widget;
- GTK_WIDGET_SET_FLAGS(plot, GTK_NO_WINDOW);
+
+ gtk_widget_set_has_window(GTK_WIDGET(plot), FALSE);
widget = GTK_WIDGET(plot);
- gdk_color_black(gtk_widget_get_colormap(widget), &widget->style->black);
- gdk_color_white(gtk_widget_get_colormap(widget), &widget->style->white);
+ 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);
plot->bg_pixmap = NULL;
plot->transparent = FALSE;
@@ -1022,25 +1620,29 @@ gtk_plot_init (GtkPlot *plot)
plot->show_y0 = FALSE;
plot->right = GTK_PLOT_AXIS(gtk_plot_axis_new(GTK_PLOT_AXIS_Y));
- gtk_object_ref(GTK_OBJECT(plot->right));
- gtk_object_sink(GTK_OBJECT(plot->right));
- gtk_signal_connect(GTK_OBJECT(plot->right), "changed",
- GTK_SIGNAL_FUNC(axis_changed), plot);
+ g_object_ref(GTK_OBJECT(plot->right));
+ g_object_ref_sink(GTK_OBJECT(plot->right));
+ g_object_unref(GTK_OBJECT(plot->right));
+ g_signal_connect(GTK_OBJECT(plot->right), "changed",
+ (void *)axis_changed, plot);
plot->left = GTK_PLOT_AXIS(gtk_plot_axis_new(GTK_PLOT_AXIS_Y));
- gtk_object_ref(GTK_OBJECT(plot->left));
- gtk_object_sink(GTK_OBJECT(plot->left));
- gtk_signal_connect(GTK_OBJECT(plot->left), "changed",
- GTK_SIGNAL_FUNC(axis_changed), plot);
+ g_object_ref(GTK_OBJECT(plot->left));
+ g_object_ref_sink(GTK_OBJECT(plot->left));
+ g_object_unref(GTK_OBJECT(plot->left));
+ g_signal_connect(GTK_OBJECT(plot->left), "changed",
+ (void *)axis_changed, plot);
plot->top = GTK_PLOT_AXIS(gtk_plot_axis_new(GTK_PLOT_AXIS_X));
- gtk_object_ref(GTK_OBJECT(plot->top));
- gtk_object_sink(GTK_OBJECT(plot->top));
- gtk_signal_connect(GTK_OBJECT(plot->top), "changed",
- GTK_SIGNAL_FUNC(axis_changed), plot);
+ g_object_ref(GTK_OBJECT(plot->top));
+ g_object_ref_sink(GTK_OBJECT(plot->top));
+ g_object_unref(GTK_OBJECT(plot->top));
+ g_signal_connect(GTK_OBJECT(plot->top), "changed",
+ (void *)axis_changed, plot);
plot->bottom = GTK_PLOT_AXIS(gtk_plot_axis_new(GTK_PLOT_AXIS_X));
- gtk_object_ref(GTK_OBJECT(plot->bottom));
- gtk_object_sink(GTK_OBJECT(plot->bottom));
- gtk_signal_connect(GTK_OBJECT(plot->bottom), "changed",
- GTK_SIGNAL_FUNC(axis_changed), plot);
+ g_object_ref(GTK_OBJECT(plot->bottom));
+ g_object_ref_sink(GTK_OBJECT(plot->bottom));
+ g_object_unref(GTK_OBJECT(plot->bottom));
+ g_signal_connect(GTK_OBJECT(plot->bottom), "changed",
+ (void *)axis_changed, plot);
plot->left->labels_attr.justification = GTK_JUSTIFY_RIGHT;
plot->right->labels_attr.justification = GTK_JUSTIFY_LEFT;
@@ -1060,13 +1662,13 @@ gtk_plot_init (GtkPlot *plot)
plot->x0_line.cap_style = 0;
plot->x0_line.join_style = 0;
plot->x0_line.line_width = 0;
- plot->x0_line.color = widget->style->black;
+ plot->x0_line.color = gtk_widget_get_style(widget)->black;
plot->y0_line.line_style = GTK_PLOT_LINE_SOLID;
plot->y0_line.line_width = 0;
plot->y0_line.cap_style = 0;
plot->y0_line.join_style = 0;
- plot->y0_line.color = widget->style->black;
+ plot->y0_line.color = gtk_widget_get_style(widget)->black;
plot->legends_x = .6;
plot->legends_y = .1;
@@ -1080,14 +1682,14 @@ gtk_plot_init (GtkPlot *plot)
plot->legends_attr.text = NULL;
plot->legends_attr.font = g_strdup(DEFAULT_FONT);
plot->legends_attr.height = DEFAULT_FONT_HEIGHT;
- plot->legends_attr.fg = widget->style->black;
- plot->legends_attr.bg = widget->style->white;
+ plot->legends_attr.fg = gtk_widget_get_style(widget)->black;
+ plot->legends_attr.bg = gtk_widget_get_style(widget)->white;
plot->legends_attr.transparent = FALSE;
plot->legends_attr.border = 0;
plot->legends_attr.border_width = 0;
plot->legends_attr.shadow_width = 0;
- plot->background = widget->style->white;
+ plot->background = gtk_widget_get_style(widget)->white;
plot->xscale = GTK_PLOT_SCALE_LINEAR;
plot->yscale = GTK_PLOT_SCALE_LINEAR;
@@ -1405,6 +2007,13 @@ gtk_plot_set_property (GObject *object,
}
}
+/**
+ * gtk_plot_set_pc:
+ * @plot: a #GtkPlot widget
+ * @pc: a #GtkPlotPc
+ *
+ *
+ */
void
gtk_plot_set_pc(GtkPlot *plot, GtkPlotPC *pc)
{
@@ -1415,16 +2024,18 @@ static void
gtk_plot_real_set_pc(GtkPlot *plot, GtkPlotPC *pc)
{
if(plot->pc)
- gtk_object_unref(GTK_OBJECT(plot->pc));
+ g_object_unref(GTK_OBJECT(plot->pc));
if(!pc){
- plot->pc = GTK_PLOT_PC(gtk_plot_gdk_new(GTK_WIDGET(plot)));
- gtk_object_ref(GTK_OBJECT(plot->pc));
- gtk_object_sink(GTK_OBJECT(plot->pc));
+ plot->pc = (GtkPlotPC *)gtk_plot_cairo_new(NULL);
+ g_object_ref(GTK_OBJECT(plot->pc));
+ g_object_ref_sink(GTK_OBJECT(plot->pc));
+ g_object_unref(GTK_OBJECT(plot->pc));
} else {
plot->pc = pc;
- gtk_object_ref(GTK_OBJECT(plot->pc));
- gtk_object_sink(GTK_OBJECT(plot->pc));
+ g_object_ref(GTK_OBJECT(plot->pc));
+ g_object_ref_sink(GTK_OBJECT(plot->pc));
+ g_object_unref(GTK_OBJECT(plot->pc));
}
}
@@ -1821,13 +2432,13 @@ gtk_plot_destroy (GtkObject *object)
plot = GTK_PLOT (object);
if (plot->top)
- gtk_object_unref(GTK_OBJECT(plot->top));
+ g_object_unref(GTK_OBJECT(plot->top));
if (plot->bottom)
- gtk_object_unref(GTK_OBJECT(plot->bottom));
+ g_object_unref(GTK_OBJECT(plot->bottom));
if (plot->left)
- gtk_object_unref(GTK_OBJECT(plot->left));
+ g_object_unref(GTK_OBJECT(plot->left));
if (plot->right)
- gtk_object_unref(GTK_OBJECT(plot->right));
+ g_object_unref(GTK_OBJECT(plot->right));
plot->top = plot->bottom = plot->left = plot->right = NULL;
if(plot->legends_attr.font) g_free (plot->legends_attr.font);
@@ -1852,7 +2463,7 @@ gtk_plot_destroy (GtkObject *object)
list = plot->data_sets;
while(list){
- gtk_widget_unref(GTK_WIDGET(list->data));
+ g_object_unref(GTK_WIDGET(list->data));
plot->data_sets = g_list_remove_link(plot->data_sets, list);
g_list_free_1(list);
@@ -1864,7 +2475,7 @@ gtk_plot_destroy (GtkObject *object)
(* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
if(plot->pc)
- gtk_object_unref(GTK_OBJECT(plot->pc));
+ g_object_unref(GTK_OBJECT(plot->pc));
plot->pc = NULL;
gtk_psfont_unref();
@@ -1923,6 +2534,12 @@ gtk_plot_show_all (GtkWidget *widget)
gtk_widget_show (widget);
}
+/**
+ * gtk_plot_paint:
+ * @plot: a #GtkPlot widget
+ *
+ *
+ */
void
gtk_plot_paint (GtkPlot *plot)
{
@@ -2099,37 +2716,46 @@ gtk_plot_real_paint (GtkWidget *widget)
gtk_plot_pc_grestore(plot->pc);
}
+/**
+ * gtk_plot_refresh:
+ * @plot: a #GtkPlot widget
+ * @drawing_area: a GdkRectangle
+ *
+ *
+ */
void
gtk_plot_refresh (GtkPlot *plot, GdkRectangle *drawing_area)
{
GtkWidget *widget;
GdkPixmap *pixmap;
GdkRectangle area;
+ GtkAllocation allocation;
widget = GTK_WIDGET(plot);
- if(!GTK_WIDGET_VISIBLE(widget)) return;
+ if(!gtk_widget_get_visible(widget)) return;
if(!plot->drawable) return;
pixmap = plot->drawable;
+ gtk_widget_get_allocation(widget, &allocation);
if(drawing_area == NULL){
- area.x = widget->allocation.x;
- area.y = widget->allocation.y;
- area.width = widget->allocation.width;
- area.height = widget->allocation.height;
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
} else {
area = *drawing_area;
}
- gdk_draw_pixmap(widget->window,
- widget->style->fg_gc[GTK_STATE_NORMAL],
+ gdk_draw_pixmap(gtk_widget_get_window(widget),
+ gtk_widget_get_style(widget)->fg_gc[GTK_STATE_NORMAL],
pixmap,
area.x,
area.y,
- widget->allocation.x,
- widget->allocation.y,
- widget->allocation.width,
- widget->allocation.height);
+ allocation.x,
+ allocation.y,
+ allocation.width,
+ allocation.height);
}
@@ -2145,34 +2771,51 @@ gtk_plot_size_request (GtkWidget *widget, GtkRequisition *requisition)
}
static void
-gtk_plot_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+gtk_plot_size_allocate (GtkWidget *widget, GtkAllocation *arg_allocation)
{
GtkPlot *plot;
+ GtkAllocation allocation;
plot = GTK_PLOT(widget);
- widget->allocation = *allocation;
+ gtk_widget_set_allocation(widget, arg_allocation);
- plot->internal_allocation.x = GTK_WIDGET(plot)->allocation.x + roundint(plot->x *
GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.y = GTK_WIDGET(plot)->allocation.y + roundint(plot->y *
GTK_WIDGET(plot)->allocation.height);
- plot->internal_allocation.width = roundint(plot->width * GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.height = roundint(plot->height * GTK_WIDGET(plot)->allocation.height);
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ plot->internal_allocation.x = allocation.x + roundint(plot->x * allocation.width);
+ plot->internal_allocation.y = allocation.y + roundint(plot->y * allocation.height);
+ plot->internal_allocation.width = roundint(plot->width * allocation.width);
+ plot->internal_allocation.height = roundint(plot->height * allocation.height);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], FALSE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, FALSE);
}
+/**
+ * gtk_plot_axis_new:
+ * @orientation:
+ *
+ *
+ *
+ * Return value:
+ */
GtkObject*
gtk_plot_axis_new (GtkPlotOrientation orientation)
{
GtkObject *axis;
- axis = gtk_type_new (gtk_plot_axis_get_type ());
+ axis = g_object_new (gtk_plot_axis_get_type (), NULL);
gtk_plot_axis_construct(GTK_PLOT_AXIS(axis), orientation);
return GTK_OBJECT (axis);
}
+/**
+ * gtk_plot_axis_construct:
+ * @axis:
+ * @orientation:
+ *
+ *
+ */
void
gtk_plot_axis_construct(GtkPlotAxis *axis, GtkPlotOrientation orientation)
{
@@ -2219,21 +2862,37 @@ gtk_plot_axis_construct(GtkPlotAxis *axis, GtkPlotOrientation orientation)
}
}
+/**
+ * gtk_plot_new:
+ * @drawable: a Gdk drawable
+ *
+ *
+ *
+ * Return value:
+ */
GtkWidget*
gtk_plot_new (GdkDrawable *drawable)
{
- GtkPlot *plot;
+ GtkWidget *plot;
- plot = gtk_type_new (gtk_plot_get_type ());
+ plot = gtk_widget_new (gtk_plot_get_type (), NULL);
gtk_plot_construct(GTK_PLOT(plot), drawable);
return GTK_WIDGET (plot);
}
+/**
+ * gtk_plot_construct:
+ * @plot: a #GtkPlot widget
+ * @drawable: a Gdk drawable
+ *
+ *
+ */
void
gtk_plot_construct(GtkPlot *plot, GdkDrawable *drawable)
{
+ GtkAllocation allocation;
gtk_plot_set_drawable(plot, drawable);
plot->x = .15;
@@ -2241,10 +2900,11 @@ gtk_plot_construct(GtkPlot *plot, GdkDrawable *drawable)
plot->width = .6;
plot->height = .6;
- plot->internal_allocation.x = GTK_WIDGET(plot)->allocation.x + roundint(plot->x *
GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.y = GTK_WIDGET(plot)->allocation.y + roundint(plot->y *
GTK_WIDGET(plot)->allocation.height);
- plot->internal_allocation.width = roundint(plot->width * GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.height = roundint(plot->height * GTK_WIDGET(plot)->allocation.height);
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ plot->internal_allocation.x = allocation.x + roundint(plot->x * allocation.width);
+ plot->internal_allocation.y = allocation.y + roundint(plot->y * allocation.height);
+ plot->internal_allocation.width = roundint(plot->width * allocation.width);
+ plot->internal_allocation.height = roundint(plot->height * allocation.height);
plot->left->title.x = plot->x;
plot->left->title.y = plot->y + plot->height / 2.;
@@ -2261,18 +2921,35 @@ gtk_plot_construct(GtkPlot *plot, GdkDrawable *drawable)
plot->bottom->title.y += 35. / (gdouble)DEFAULT_HEIGHT;
}
+/**
+ * gtk_plot_new_with_size:
+ * @drawable: a Gdk drawable
+ * @width: plot widget width
+ * @height: plot widget height
+ *
+ * Returns: the plot widget
+ */
GtkWidget*
gtk_plot_new_with_size (GdkDrawable *drawable, gdouble width, gdouble height)
{
GtkWidget *plot;
- plot = gtk_type_new (gtk_plot_get_type ());
+ plot = gtk_widget_new (gtk_plot_get_type (), NULL);
gtk_plot_construct_with_size(GTK_PLOT(plot), drawable, width, height);
return(plot);
}
+/**
+ * gtk_plot_construct_with_size:
+ * @plot: a #GtkPlot widget
+ * @drawable: a Gdk drawable
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_construct_with_size (GtkPlot *plot,
GdkDrawable *drawable,
@@ -2283,6 +2960,13 @@ gtk_plot_construct_with_size (GtkPlot *plot,
gtk_plot_resize (GTK_PLOT(plot), width, height);
}
+/**
+ * gtk_plot_set_drawable:
+ * @plot: a #GtkPlot widget
+ * @drawable: a Gdk drawable
+ *
+ *
+ */
void
gtk_plot_set_drawable (GtkPlot *plot, GdkDrawable *drawable)
{
@@ -2294,16 +2978,33 @@ gtk_plot_real_set_drawable (GtkPlot *plot, GdkDrawable *drawable)
{
plot->drawable = drawable;
- if(GTK_IS_PLOT_GDK(plot->pc))
- gtk_plot_gdk_set_drawable(GTK_PLOT_GDK(plot->pc), drawable);
+ if(GTK_IS_PLOT_CAIRO(plot->pc)) {
+ if (gtk_widget_get_window(GTK_WIDGET(plot))) {
+ gtk_plot_set_pc(plot,GTK_PLOT_PC(gtk_plot_cairo_new_with_drawable(drawable)));
+ }
+ }
+
}
+/**
+ * gtk_plot_get_drawable:
+ * @plot: a #GtkPlot widget
+ *
+ * Return value: (transfer none) the #GdkDrawable of the plot
+ */
GdkDrawable *
gtk_plot_get_drawable (GtkPlot *plot)
{
return(plot->drawable);
}
+/**
+ * gtk_plot_set_background_pixmap:
+ * @plot: a #GtkPlot widget
+ * @pixmap: a Gdk pixmap
+ *
+ *
+ */
void
gtk_plot_set_background_pixmap (GtkPlot *plot, GdkPixmap *pixmap)
{
@@ -2313,12 +3014,27 @@ gtk_plot_set_background_pixmap (GtkPlot *plot, GdkPixmap *pixmap)
if(pixmap) gdk_pixmap_ref(pixmap);
}
+/**
+ * gtk_plot_set_transparent:
+ * @plot: a #GtkPlot widget
+ * @transparent:
+ *
+ *
+ */
void
gtk_plot_set_transparent (GtkPlot *plot, gboolean transparent)
{
plot->transparent = transparent;
}
+/**
+ * gtk_plot_is_transparent:
+ * @plot: a #GtkPlot widget
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_is_transparent (GtkPlot *plot)
{
@@ -2563,6 +3279,7 @@ gtk_plot_draw_labels(GtkPlot *plot,
gdouble px, py;
gdouble y;
gint n = 0;
+ GtkAllocation allocation;
widget = GTK_WIDGET(plot);
xp = plot->internal_allocation.x;
@@ -2634,18 +3351,19 @@ gtk_plot_draw_labels(GtkPlot *plot,
tick.x = px;
tick.y = py + y;
+ gtk_widget_get_allocation(widget, &allocation);
if(axis->label_mask & GTK_PLOT_LABEL_IN){
tick.x = tick.x + tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y + tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
if(axis->label_mask & GTK_PLOT_LABEL_OUT){
tick.x = tick.x - tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y - tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
}
@@ -2659,6 +3377,17 @@ gtk_plot_draw_labels(GtkPlot *plot,
}
}
+/**
+ * gtk_plot_draw_line:
+ * @plot: a #GtkPlot widget
+ * @line:
+ * @x1:
+ * @y1:
+ * @x2:
+ * @y2:
+ *
+ *
+ */
void
gtk_plot_draw_line(GtkPlot *plot,
GtkPlotLine line,
@@ -2674,6 +3403,13 @@ gtk_plot_draw_line(GtkPlot *plot,
}
+/**
+ * gtk_plot_set_line_attributes:
+ * @plot: a #GtkPlot widget
+ * @line:
+ *
+ *
+ */
void
gtk_plot_set_line_attributes(GtkPlot *plot,
GtkPlotLine line)
@@ -2772,7 +3508,7 @@ gtk_plot_draw_legends (GtkWidget *widget)
{
dataset = GTK_PLOT_DATA(datasets->data);
- if(GTK_WIDGET_VISIBLE(GTK_WIDGET(dataset)) && dataset->show_legend)
+ if(gtk_widget_get_visible(GTK_WIDGET(dataset)) && dataset->show_legend)
{
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(dataset)))->get_legend_size(dataset, &lwidth,
&lheight);
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(dataset)))->draw_legend(dataset, x, y);
@@ -2818,7 +3554,7 @@ gtk_plot_draw_legends (GtkWidget *widget)
{
dataset = GTK_PLOT_DATA(datasets->data);
- if(GTK_WIDGET_VISIBLE(GTK_WIDGET(dataset)) && dataset->show_gradient)
+ if(gtk_widget_get_visible(GTK_WIDGET(dataset)) && dataset->show_gradient)
{
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(dataset)))->draw_gradient(dataset);
}
@@ -2855,18 +3591,46 @@ gtk_plot_axis_ticks_autoscale (GtkPlotAxis *axis,
axis->ticks_autoscale(axis, xmin, xmax, precision);
}
+/**
+ * gtk_plot_axis_ticks_transform:
+ * @axis:
+ * @y:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_axis_ticks_transform (GtkPlotAxis *axis, gdouble y)
{
return (axis->ticks_transform(axis, y));
}
+/**
+ * gtk_plot_axis_ticks_inverse:
+ * @axis:
+ * @x:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_axis_ticks_inverse (GtkPlotAxis *axis, gdouble x)
{
return (axis->ticks_inverse(axis, x));
}
+/**
+ * gtk_plot_axis_parse_label:
+ * @axis:
+ * @val:
+ * @precision:
+ * @style:
+ * @label:
+ *
+ *
+ */
void
gtk_plot_axis_parse_label (GtkPlotAxis *axis,
gdouble val,
@@ -2877,6 +3641,15 @@ gtk_plot_axis_parse_label (GtkPlotAxis *axis,
axis->parse_label(axis, val, precision, style, label);
}
+/**
+ * gtk_plot_ticks_transform:
+ * @axis:
+ * @x:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_ticks_transform(GtkPlotAxis *axis, gdouble x)
{
@@ -2934,7 +3707,15 @@ gtk_plot_ticks_transform(GtkPlotAxis *axis, gdouble x)
return(position);
}
-
+/**
+ * gtk_plot_ticks_inverse:
+ * @axis:
+ * @x:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_ticks_inverse(GtkPlotAxis *axis, gdouble x)
{
@@ -2977,6 +3758,16 @@ roundint (gdouble x)
return (x+.50999999471);
}
+/**
+ * gtk_plot_parse_label:
+ * @axis:
+ * @val:
+ * @precision:
+ * @style:
+ * @label:
+ *
+ *
+ */
void
gtk_plot_parse_label(GtkPlotAxis *axis, gdouble val, gint precision, gint style, gchar *label)
{
@@ -3029,18 +3820,27 @@ gtk_plot_parse_label(GtkPlotAxis *axis, gdouble val, gint precision, gint style,
}
+/**
+ * gtk_plot_draw_text:
+ * @plot:
+ * @text:
+ *
+ *
+ */
void
gtk_plot_draw_text(GtkPlot *plot,
GtkPlotText text)
{
gint x, y;
+ GtkAllocation allocation;
if(!text.text) return;
if(strlen(text.text) == 0) return;
if(plot->drawable == NULL) return;
- x = text.x * GTK_WIDGET(plot)->allocation.width;
- y = text.y * GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ x = text.x * allocation.width;
+ y = text.y * allocation.height;
gtk_plot_paint_text(plot, x, y, text);
}
@@ -3071,12 +3871,25 @@ gtk_plot_paint_text(GtkPlot *plot,
text.justification,
text.text);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED],0);
}
+/**
+ * gtk_plot_text_get_size:
+ * @text:
+ * @angle:
+ * @text_font:
+ * @text_height:
+ * @width:
+ * @height:
+ * @ascent:
+ * @descent:
+ *
+ *
+ */
void
gtk_plot_text_get_size(const gchar *text, gint angle,
- const gchar* text_font,
+ const gchar *text_font,
gint text_height,
gint *width, gint *height,
gint *ascent, gint *descent)
@@ -3265,7 +4078,7 @@ gtk_plot_text_get_size(const gchar *text, gint angle,
case 'b':
if(lastchar){
const gchar *aux2 = lastchar;
- gint i = g_utf8_next_char(lastchar) != ++aux2 ? 2 : 1;
+ gint i = g_utf8_next_char(aux) - aux2;
pango_layout_set_text(layout, lastchar, i);
pango_layout_get_extents(layout, NULL, &rect);
x -= PANGO_PIXELS(rect.width);
@@ -3306,7 +4119,7 @@ gtk_plot_text_get_size(const gchar *text, gint angle,
default:
if(aux && *aux != '\0' && *aux !='\n'){
const gchar *aux2 = aux;
- gint i = g_utf8_next_char(aux) != ++aux2 ? 2 : 1;
+ gint i = g_utf8_next_char(aux) - aux2;
pango_layout_set_font_description(layout, font);
pango_layout_set_text(layout, aux, i);
pango_layout_get_extents(layout, NULL, &rect);
@@ -3319,7 +4132,7 @@ gtk_plot_text_get_size(const gchar *text, gint angle,
} else {
if(aux && *aux != '\0' && *aux != '\n'){
const gchar *aux2 = aux;
- gint i = g_utf8_next_char(aux) != ++aux2 ? 2 : 1;
+ gint i = g_utf8_next_char(aux) - aux2;
pango_layout_set_font_description(layout, font);
pango_layout_set_text(layout, aux, i);
pango_layout_get_extents(layout, NULL, &rect);
@@ -3345,9 +4158,23 @@ gtk_plot_text_get_size(const gchar *text, gint angle,
}
}
+/**
+ * gtk_plot_text_get_area:
+ * @text:
+ * @angle:
+ * @just:
+ * @font_name:
+ * @font_size:
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_text_get_area(const gchar *text, gint angle, GtkJustification just,
- const gchar *font, gint font_height,
+ const gchar *font_name, gint font_size,
gint *x, gint *y,
gint *width, gint *height)
{
@@ -3355,8 +4182,8 @@ gtk_plot_text_get_area(const gchar *text, gint angle, GtkJustification just,
if(text == NULL) return;
- gtk_plot_text_get_size(text, angle, font,
- font_height,
+ gtk_plot_text_get_size(text, angle, font_name,
+ font_size,
width, height, &ascent, &descent);
*x = 0;
@@ -3439,12 +4266,28 @@ gtk_plot_text_get_area(const gchar *text, gint angle, GtkJustification just,
* gtk_plot_set_yscale
* gtk_plot_draw_text
******************************************/
+
+/**
+ * gtk_plot_clip_data:
+ * @plot: a #GtkPlot widget.
+ * @clip:
+ *
+ *
+ */
void
gtk_plot_clip_data (GtkPlot *plot, gboolean clip)
{
plot->clip_data = clip;
}
+/**
+ * gtk_plot_get_position:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y
+ *
+ *
+ */
void
gtk_plot_get_position (GtkPlot *plot, gdouble *x, gdouble *y)
{
@@ -3452,6 +4295,13 @@ gtk_plot_get_position (GtkPlot *plot, gdouble *x, gdouble *y)
*y = plot->y;
}
+/**
+ * gtk_plot_get_size:
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_get_size (GtkPlot *plot, gdouble *width, gdouble *height)
{
@@ -3459,26 +4309,47 @@ gtk_plot_get_size (GtkPlot *plot, gdouble *width, gdouble *height)
*height = plot->height;
}
+/**
+ * gtk_plot_get_internal_allocation:
+ * @plot: a #GtkPlot widget.
+ *
+ * Return value: (transfer none) internal_allocation
+ */
GtkAllocation
gtk_plot_get_internal_allocation (GtkPlot *plot)
{
return(plot->internal_allocation);
}
+/**
+ * gtk_plot_set_background:
+ * @plot: a #GtkPlot widget.
+ * @bg_color:
+ *
+ *
+ */
void
-gtk_plot_set_background(GtkPlot *plot, const GdkColor *color)
+gtk_plot_set_background(GtkPlot *plot, const GdkColor *bg_color)
{
- plot->background = *color;
+ plot->background = *bg_color;
gtk_plot_paint(plot);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED],0);
}
+/**
+ * gtk_plot_clip_move:
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_move (GtkPlot *plot, gdouble x, gdouble y)
{
gboolean veto = TRUE;
+ GtkAllocation allocation;
_gtkextra_signal_emit (GTK_OBJECT(plot), plot_signals[MOVED],
&x, &y, &veto);
@@ -3497,18 +4368,28 @@ gtk_plot_move (GtkPlot *plot, gdouble x, gdouble y)
plot->x = x;
plot->y = y;
- plot->internal_allocation.x = GTK_WIDGET(plot)->allocation.x + roundint(plot->x *
GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.y = GTK_WIDGET(plot)->allocation.y + roundint(plot->y *
GTK_WIDGET(plot)->allocation.height);
- plot->internal_allocation.width = roundint(plot->width * GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.height = roundint(plot->height * GTK_WIDGET(plot)->allocation.height);
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ plot->internal_allocation.x = allocation.x + roundint(plot->x * allocation.width);
+ plot->internal_allocation.y = allocation.y + roundint(plot->y * allocation.height);
+ plot->internal_allocation.width = roundint(plot->width * allocation.width);
+ plot->internal_allocation.height = roundint(plot->height * allocation.height);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_resize:
+ * @plot: a #GtkPlot widget.a #GtkPlot widget.
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_resize (GtkPlot *plot, gdouble width, gdouble height)
{
gboolean veto = TRUE;
+ GtkAllocation allocation;
_gtkextra_signal_emit (GTK_OBJECT(plot), plot_signals[RESIZED],
&width, &height, &veto);
@@ -3525,32 +4406,52 @@ gtk_plot_resize (GtkPlot *plot, gdouble width, gdouble height)
plot->width = width;
plot->height = height;
- plot->internal_allocation.x = GTK_WIDGET(plot)->allocation.x + roundint(plot->x *
GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.y = GTK_WIDGET(plot)->allocation.y + roundint(plot->y *
GTK_WIDGET(plot)->allocation.height);
- plot->internal_allocation.width = roundint(plot->width * GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.height = roundint(plot->height * GTK_WIDGET(plot)->allocation.height);
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ plot->internal_allocation.x = allocation.x + roundint(plot->x * allocation.width);
+ plot->internal_allocation.y = allocation.y + roundint(plot->y * allocation.height);
+ plot->internal_allocation.width = roundint(plot->width * allocation.width);
+ plot->internal_allocation.height = roundint(plot->height * allocation.height);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], FALSE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, FALSE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_set_magnification:
+ * @plot: a #GtkPlot widget.
+ * @magnification:
+ *
+ *
+ */
void
gtk_plot_set_magnification (GtkPlot *plot, gdouble magnification)
{
GtkWidget *widget;
+ GtkAllocation allocation;
widget = GTK_WIDGET(plot);
plot->magnification = magnification;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
- plot->internal_allocation.x = GTK_WIDGET(plot)->allocation.x + roundint(plot->x *
GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.y = GTK_WIDGET(plot)->allocation.y + roundint(plot->y *
GTK_WIDGET(plot)->allocation.height);
- plot->internal_allocation.width = roundint(plot->width * GTK_WIDGET(plot)->allocation.width);
- plot->internal_allocation.height = roundint(plot->height * GTK_WIDGET(plot)->allocation.height);
+ plot->internal_allocation.x = allocation.x + roundint(plot->x * allocation.width);
+ plot->internal_allocation.y = allocation.y + roundint(plot->y * allocation.height);
+ plot->internal_allocation.width = roundint(plot->width * allocation.width);
+ plot->internal_allocation.height = roundint(plot->height * allocation.height);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], FALSE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, FALSE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_move_resize:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_move_resize (GtkPlot *plot,
gdouble x, gdouble y,
@@ -3559,15 +4460,35 @@ gtk_plot_move_resize (GtkPlot *plot,
gtk_plot_move(plot, x, y);
gtk_plot_resize(plot, width, height);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_get_pixel:
+ * @plot: a #GtkPlot widget.
+ * @xx:
+ * @yy:
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_get_pixel(GtkPlot *plot, gdouble xx, gdouble yy, gdouble *x, gdouble *y)
{
GTK_PLOT_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(plot)))->get_pixel (GTK_WIDGET(plot), xx, yy, x, y);
}
+/**
+ * gtk_plot_get_point:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ * @xx:
+ * @yy:
+ *
+ *
+ */
void
gtk_plot_get_point(GtkPlot *plot, gint x, gint y, gdouble *xx, gdouble *yy)
{
@@ -3582,6 +4503,7 @@ gtk_plot_real_get_pixel(GtkWidget *widget,
{
GtkPlot *plot;
gint xp, yp, width, height;
+ GtkAllocation allocation;
plot = GTK_PLOT(widget);
xp = plot->internal_allocation.x;
@@ -3592,15 +4514,16 @@ gtk_plot_real_get_pixel(GtkWidget *widget,
*y = gtk_plot_ticks_transform(plot->left, yy)*height;
*x = gtk_plot_ticks_transform(plot->bottom, xx)*width;
+ gtk_widget_get_allocation(widget, &allocation);
if(!plot->reflect_x)
- *x = widget->allocation.x + xp + *x;
+ *x = allocation.x + xp + *x;
else
- *x = widget->allocation.x + xp + width - *x;
+ *x = allocation.x + xp + width - *x;
if(!plot->reflect_y)
- *y = widget->allocation.y + yp + height - *y;
+ *y = allocation.y + yp + height - *y;
else
- *y = widget->allocation.y + yp + *y;
+ *y = allocation.y + yp + *y;
}
static void
@@ -3612,6 +4535,8 @@ gtk_plot_real_get_point(GtkWidget *widget,
gdouble xx, yy;
gdouble xp, yp, width, height;
gdouble rx, ry;
+ GtkAllocation allocation;
+
plot = GTK_PLOT(widget);
xp = plot->internal_allocation.x;
@@ -3619,15 +4544,16 @@ gtk_plot_real_get_point(GtkWidget *widget,
width = plot->internal_allocation.width;
height = plot->internal_allocation.height;
+ gtk_widget_get_allocation(widget, &allocation);
if(!plot->reflect_x)
- xx = x - widget->allocation.x - xp;
+ xx = x - allocation.x - xp;
else
- xx = width - (x - widget->allocation.x - xp);
+ xx = width - (x - allocation.x - xp);
if(!plot->reflect_y)
- yy = widget->allocation.y + yp + height - y;
+ yy = allocation.y + yp + height - y;
else
- yy = y - widget->allocation.y - yp;
+ yy = y - allocation.y - yp;
rx = plot->bottom->ticks.max - plot->bottom->ticks.min;
ry = plot->left->ticks.max - plot->left->ticks.min;
@@ -3636,6 +4562,14 @@ gtk_plot_real_get_point(GtkWidget *widget,
*py = gtk_plot_axis_ticks_inverse(plot->left, yy / height);
}
+/**
+ * gtk_plot_set_xrange:
+ * @plot: a #GtkPlot widget.
+ * @xmin:
+ * @xmax:
+ *
+ *
+ */
void
gtk_plot_set_xrange (GtkPlot *plot,
gdouble xmin, gdouble xmax)
@@ -3650,10 +4584,18 @@ gtk_plot_set_xrange (GtkPlot *plot,
plot->top->ticks.min = xmin;
plot->top->ticks.max = xmax;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], TRUE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, TRUE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_set_yrange:
+ * @plot: a #GtkPlot widget.
+ * @ymin:
+ * @ymax:
+ *
+ *
+ */
void
gtk_plot_set_yrange (GtkPlot *plot,
gdouble ymin, gdouble ymax)
@@ -3668,11 +4610,21 @@ gtk_plot_set_yrange (GtkPlot *plot,
plot->right->ticks.min = ymin;
plot->right->ticks.max = ymax;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], TRUE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, TRUE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_set_range:
+ * @plot: a #GtkPlot widget.
+ * @xmin:
+ * @xmax:
+ * @ymin:
+ * @ymax:
+ *
+ *
+ */
void
gtk_plot_set_range (GtkPlot *plot,
gdouble xmin, gdouble xmax,
@@ -3698,10 +4650,19 @@ gtk_plot_set_range (GtkPlot *plot,
gtk_plot_axis_ticks_recalc(plot->top);
gtk_plot_axis_ticks_recalc(plot->left);
gtk_plot_axis_ticks_recalc(plot->right);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], TRUE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, TRUE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_ticks_autoscale:
+ * @axis:
+ * @xmin:
+ * @xmax:
+ * @precision:
+ *
+ *
+ */
void
gtk_plot_ticks_autoscale(GtkPlotAxis *axis, gdouble xmin, gdouble xmax, gint *precision)
{
@@ -3767,6 +4728,12 @@ gtk_plot_ticks_autoscale(GtkPlotAxis *axis, gdouble xmin, gdouble xmax, gint *pr
axis->label_precision = *precision;
}
+/**
+ * gtk_plot_autoscale:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ */
void
gtk_plot_autoscale(GtkPlot *plot)
{
@@ -3821,10 +4788,18 @@ gtk_plot_autoscale(GtkPlot *plot)
plot->ymin = plot->left->ticks.min;
plot->ymax = plot->left->ticks.max;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], TRUE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, TRUE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_get_xrange:
+ * @plot: a #GtkPlot widget.
+ * @xmin:
+ * @xmax:
+ *
+ *
+ */
void
gtk_plot_get_xrange (GtkPlot *plot,
gdouble *xmin, gdouble *xmax)
@@ -3833,6 +4808,14 @@ gtk_plot_get_xrange (GtkPlot *plot,
*xmin = plot->xmin;
}
+/**
+ * gtk_plot_get_yrange:
+ * @plot: a #GtkPlot widget.
+ * @ymin:
+ * @ymax:
+ *
+ *
+ */
void
gtk_plot_get_yrange (GtkPlot *plot,
gdouble *ymin, gdouble *ymax)
@@ -3841,6 +4824,13 @@ gtk_plot_get_yrange (GtkPlot *plot,
*ymin = plot->ymin;
}
+/**
+ * gtk_plot_set_xscale:
+ * @plot: a #GtkPlot widget.
+ * @scale_type:
+ *
+ *
+ */
void
gtk_plot_set_xscale (GtkPlot *plot, GtkPlotScale scale_type)
{
@@ -3848,10 +4838,17 @@ gtk_plot_set_xscale (GtkPlot *plot, GtkPlotScale scale_type)
plot->bottom->ticks.scale = scale_type;
plot->top->ticks.scale = scale_type;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], FALSE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, FALSE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_set_yscale:
+ * @plot: a #GtkPlot widget.
+ * @scale_type:
+ *
+ *
+ */
void
gtk_plot_set_yscale (GtkPlot *plot, GtkPlotScale scale_type)
{
@@ -3859,40 +4856,86 @@ gtk_plot_set_yscale (GtkPlot *plot, GtkPlotScale scale_type)
plot->left->ticks.scale = scale_type;
plot->right->ticks.scale = scale_type;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], FALSE);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[UPDATE], 0, FALSE);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_get_xscale:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotScale
gtk_plot_get_xscale (GtkPlot *plot)
{
return plot->bottom->ticks.scale;
}
+/**
+ * gtk_plot_get_yscale:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotScale
gtk_plot_get_yscale (GtkPlot *plot)
{
return plot->left->ticks.scale;
}
+/**
+ * gtk_plot_reflect_x:
+ * @plot: a #GtkPlot widget.
+ * @reflect:
+ *
+ *
+ */
void
gtk_plot_reflect_x (GtkPlot *plot, gboolean reflect)
{
plot->reflect_x = reflect;
}
+/**
+ * gtk_plot_reflect_y:
+ * @plot: a #GtkPlot widget.
+ * @reflect:
+ *
+ *
+ */
void
gtk_plot_reflect_y (GtkPlot *plot, gboolean reflect)
{
plot->reflect_y = reflect;
}
+/**
+ * gtk_plot_is_x_reflected:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_is_x_reflected (GtkPlot *plot)
{
return plot->reflect_x;
}
+/**
+ * gtk_plot_is_y_reflected:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_is_y_reflected (GtkPlot *plot)
{
@@ -3917,6 +4960,22 @@ gtk_plot_thaw (GtkPlot *plot)
gtk_plot_axis_thaw (plot->right);
}
+/**
+ * gtk_plot_put_text:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ * @text:
+ *
+ * Return value: (transfer none) the #GtkPlotText
+ */
GtkPlotText *
gtk_plot_put_text (GtkPlot *plot, gdouble x, gdouble y,
const gchar *font, gint height, gint angle,
@@ -3928,20 +4987,23 @@ gtk_plot_put_text (GtkPlot *plot, gdouble x, gdouble y,
GtkWidget *widget;
GtkPlotText *text_attr;
GdkRectangle area;
+ GtkAllocation allocation;
+
widget = GTK_WIDGET(plot);
text_attr = g_new0(GtkPlotText, 1);
- area.x = widget->allocation.x;
- area.y = widget->allocation.y;
+ gtk_widget_get_allocation(widget, &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
text_attr->x = x;
text_attr->y = y;
text_attr->angle = angle;
text_attr->justification = justification;
- text_attr->fg = widget->style->black;
- text_attr->bg = widget->style->white;
+ text_attr->fg = gtk_widget_get_style(widget)->black;
+ text_attr->bg = gtk_widget_get_style(widget)->white;
text_attr->transparent = transparent;
text_attr->border = 0;
text_attr->border_space = 2;
@@ -3968,10 +5030,24 @@ gtk_plot_put_text (GtkPlot *plot, gdouble x, gdouble y,
plot->text = g_list_append(plot->text, text_attr);
gtk_plot_draw_text(plot, *text_attr);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
return text_attr;
}
+/**
+ * gtk_plot_text_set_attributes:
+ * @text_attr:
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ * @text:
+ *
+ *
+ */
void
gtk_plot_text_set_attributes (GtkPlotText *text_attr,
const gchar *font,
@@ -4009,6 +5085,16 @@ gtk_plot_text_set_attributes (GtkPlotText *text_attr,
}
+/**
+ * gtk_plot_text_set_border:
+ * @text:
+ * @border:
+ * @border_space:
+ * @border_width:
+ * @shadow_width:
+ *
+ *
+ */
void
gtk_plot_text_set_border (GtkPlotText *text,
GtkPlotBorderStyle border,
@@ -4025,6 +5111,16 @@ gtk_plot_text_set_border (GtkPlotText *text,
}
/******************************************/
+
+/**
+ * gtk_plot_set_ticks:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ * @major_step:
+ * @nminor:
+ *
+ *
+ */
void gtk_plot_set_ticks (GtkPlot *plot,
GtkPlotOrientation orientation,
gdouble major_step,
@@ -4039,6 +5135,14 @@ void gtk_plot_set_ticks (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_set_major_ticks:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ * @major_step:
+ *
+ *
+ */
void gtk_plot_set_major_ticks (GtkPlot *plot,
GtkPlotOrientation orientation,
gdouble major_step)
@@ -4052,6 +5156,14 @@ void gtk_plot_set_major_ticks (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_set_minor_ticks:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ * @nminor:
+ *
+ *
+ */
void gtk_plot_set_minor_ticks (GtkPlot *plot,
GtkPlotOrientation orientation,
gint nminor)
@@ -4065,6 +5177,16 @@ void gtk_plot_set_minor_ticks (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_set_ticks_limits:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ * @begin:
+ * @end:
+ *
+ *
+ */
+
void gtk_plot_set_ticks_limits (GtkPlot *plot,
GtkPlotOrientation orientation,
gdouble begin, gdouble end)
@@ -4078,6 +5200,13 @@ void gtk_plot_set_ticks_limits (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_unset_ticks_limits:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ *
+ *
+ */
void gtk_plot_unset_ticks_limits (GtkPlot *plot,
GtkPlotOrientation orientation)
{
@@ -4090,15 +5219,28 @@ void gtk_plot_unset_ticks_limits (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_set_break:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ * @min:
+ * @max:
+ * @step_after:
+ * @nminor_after:
+ * @scale_after:
+ * @pos:
+ *
+ *
+ */
void gtk_plot_set_break (GtkPlot *plot,
- GtkPlotOrientation orient,
+ GtkPlotOrientation orientation,
gdouble min, gdouble max,
gdouble step_after,
gint nminor_after,
GtkPlotScale scale_after,
gdouble pos)
{
- if(orient == GTK_PLOT_AXIS_X){
+ if(orientation== GTK_PLOT_AXIS_X){
gtk_plot_axis_set_break(plot->top, min, max, step_after, nminor_after, scale_after, pos);
gtk_plot_axis_set_break(plot->bottom, min, max, step_after, nminor_after, scale_after, pos);
} else {
@@ -4107,10 +5249,17 @@ void gtk_plot_set_break (GtkPlot *plot,
}
}
+/**
+ * gtk_plot_remove_break:
+ * @plot: a #GtkPlot widget.
+ * @orientation:
+ *
+ *
+ */
void gtk_plot_remove_break (GtkPlot *plot,
- GtkPlotOrientation orient)
+ GtkPlotOrientation orientation)
{
- if(orient == GTK_PLOT_AXIS_X){
+ if(orientation == GTK_PLOT_AXIS_X){
gtk_plot_axis_remove_break(plot->top);
gtk_plot_axis_remove_break(plot->bottom);
} else {
@@ -4144,6 +5293,14 @@ void gtk_plot_remove_break (GtkPlot *plot,
* gtk_plot_axis_labels_set_numbers
******************************************/
+/**
+ * gtk_plot_get_axis:
+ * @plot: a #GtkPlot widget.
+ * @axis: a #GtkPlotAxis.
+ *
+ * Return value: (transfer none) the #GtkPlotAxis at the given
+ * position
+ */
GtkPlotAxis *
gtk_plot_get_axis (GtkPlot *plot, GtkPlotAxisPos axis)
{
@@ -4166,6 +5323,14 @@ gtk_plot_get_axis (GtkPlot *plot, GtkPlotAxisPos axis)
return aux;
}
+
+/**
+ * gtk_plot_axis_set_visible:
+ * @axis: a #GtkPlotAxis.
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_axis_set_visible (GtkPlotAxis *axis, gboolean visible)
{
@@ -4173,9 +5338,17 @@ gtk_plot_axis_set_visible (GtkPlotAxis *axis, gboolean visible)
aux->is_visible = visible;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_visible:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_axis_visible (GtkPlotAxis *axis)
{
@@ -4185,6 +5358,13 @@ gtk_plot_axis_visible (GtkPlotAxis *axis)
}
+/**
+ * gtk_plot_axis_set_title:
+ * @axis: a #GtkPlotAxis.
+ * @title
+ *
+ *
+ */
void
gtk_plot_axis_set_title (GtkPlotAxis *axis, const gchar *title)
{
@@ -4195,9 +5375,15 @@ gtk_plot_axis_set_title (GtkPlotAxis *axis, const gchar *title)
aux->title.text = g_strdup(title);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_show_title:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ */
void
gtk_plot_axis_show_title (GtkPlotAxis *axis)
{
@@ -4205,9 +5391,15 @@ gtk_plot_axis_show_title (GtkPlotAxis *axis)
aux->title_visible = TRUE;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_hide_title:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ */
void
gtk_plot_axis_hide_title (GtkPlotAxis *axis)
{
@@ -4215,9 +5407,18 @@ gtk_plot_axis_hide_title (GtkPlotAxis *axis)
aux->title_visible = FALSE;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_move_title:
+ * @axis: a #GtkPlotAxis.
+ * @angle:
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_axis_move_title (GtkPlotAxis *axis, gint angle, gdouble x, gdouble y)
{
@@ -4227,9 +5428,16 @@ gtk_plot_axis_move_title (GtkPlotAxis *axis, gint angle, gdouble x, gdouble y)
aux->title.x = x;
aux->title.y = y;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_justify_title:
+ * @axis: a #GtkPlotAxis.
+ * @justification:
+ *
+ *
+ */
void
gtk_plot_axis_justify_title (GtkPlotAxis *axis, GtkJustification justification)
{
@@ -4237,9 +5445,17 @@ gtk_plot_axis_justify_title (GtkPlotAxis *axis, GtkJustification justification)
aux->title.justification = justification;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_attributes:
+ * @axis: a #GtkPlotAxis.
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_axis_set_attributes (GtkPlotAxis *axis,
gfloat width, const GdkColor *color)
@@ -4250,9 +5466,17 @@ gtk_plot_axis_set_attributes (GtkPlotAxis *axis,
aux->line.color = *color;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_get_attributes:
+ * @axis: a #GtkPlotAxis.
+ * @width:
+ * color:
+ *
+ *
+ */
void
gtk_plot_axis_get_attributes (GtkPlotAxis *axis,
gfloat *width, GdkColor *color)
@@ -4263,6 +5487,14 @@ gtk_plot_axis_get_attributes (GtkPlotAxis *axis,
*color = aux->line.color;
}
+/**
+ * gtk_plot_axis_set_ticks:
+ * @axis: a #GtkPlotAxis.
+ * @major_step:
+ * @nminor:
+ *
+ *
+ */
void
gtk_plot_axis_set_ticks (GtkPlotAxis *axis,
gdouble major_step,
@@ -4271,44 +5503,80 @@ gtk_plot_axis_set_ticks (GtkPlotAxis *axis,
axis->ticks.step = major_step;
axis->ticks.nminor = nminor;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_major_ticks:
+ * @axis: a #GtkPlotAxis.
+ * @major_step:
+ *
+ *
+ */
void
gtk_plot_axis_set_major_ticks (GtkPlotAxis *axis,
gdouble major_step)
{
axis->ticks.step = major_step;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_minor_ticks:
+ * @axis: a #GtkPlotAxis.
+ * @nminor:
+ *
+ *
+ */
void
gtk_plot_axis_set_minor_ticks (GtkPlotAxis *axis,
gint nminor)
{
axis->ticks.nminor = nminor;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_ticks_length:
+ * @axis: a #GtkPlotAxis.
+ * @length:
+ *
+ *
+ */
void
gtk_plot_axis_set_ticks_length (GtkPlotAxis *axis, gint length)
{
GtkPlotAxis *aux = axis;
aux->ticks_length = length;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_ticks_width:
+ * @axis: a #GtkPlotAxis.
+ * @width:
+ *
+ *
+ */
void
gtk_plot_axis_set_ticks_width (GtkPlotAxis *axis, gfloat width)
{
GtkPlotAxis *aux = axis;
aux->ticks_width = width;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_show_ticks:
+ * @axis: a #GtkPlotAxis.
+ * @major_mask:
+ * @minor_mask:
+ *
+ *
+ */
void
gtk_plot_axis_show_ticks (GtkPlotAxis *axis,
gint major_mask,
@@ -4319,9 +5587,17 @@ gtk_plot_axis_show_ticks (GtkPlotAxis *axis,
aux->major_mask = major_mask;
aux->minor_mask = minor_mask;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_ticks_limits:
+ * @axis: a #GtkPlotAxis.
+ * @begin:
+ * @end:
+ *
+ *
+ */
void
gtk_plot_axis_set_ticks_limits (GtkPlotAxis *axis,
gdouble begin, gdouble end)
@@ -4333,18 +5609,31 @@ gtk_plot_axis_set_ticks_limits (GtkPlotAxis *axis,
axis->ticks.set_limits = TRUE;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_unset_ticks_limits:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ */
void
gtk_plot_axis_unset_ticks_limits (GtkPlotAxis *axis)
{
axis->ticks.set_limits = FALSE;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_ticks_labels:
+ * @axis: a #GtkPlotAxis.
+ * @labels:
+ *
+ *
+ */
void
gtk_plot_axis_set_tick_labels (GtkPlotAxis *axis, GtkPlotArray *labels)
{
@@ -4358,6 +5647,18 @@ gtk_plot_axis_set_tick_labels (GtkPlotAxis *axis, GtkPlotArray *labels)
}
}
+/**
+ * gtk_plot_axis_set_break:
+ * @axis: a #GtkPlotAxis.
+ * @min:
+ * @max:
+ * @step_after:
+ * @nminor_after:
+ * @scale_after:
+ * @pos:
+ *
+ *
+ */
void
gtk_plot_axis_set_break (GtkPlotAxis *axis,
gdouble min, gdouble max,
@@ -4375,27 +5676,53 @@ gtk_plot_axis_set_break (GtkPlotAxis *axis,
axis->ticks.break_scale = scale_after;
gtk_plot_axis_ticks_recalc(axis);
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_remove_break:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ */
void
gtk_plot_axis_remove_break (GtkPlotAxis *axis)
{
axis->ticks.apply_break = FALSE;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_show_labels:
+ * @axis: a #GtkPlotAxis.
+ * @labels_mask:
+ *
+ *
+ */
void
-gtk_plot_axis_show_labels (GtkPlotAxis *axis, gint mask)
+gtk_plot_axis_show_labels (GtkPlotAxis *axis, gint labels_mask)
{
GtkPlotAxis *aux = axis;
- aux->label_mask = mask;
+ aux->label_mask = labels_mask;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_title_set_attributes:
+ * @axis: a #GtkPlotAxis.
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ *
+ *
+ */
void
gtk_plot_axis_title_set_attributes (GtkPlotAxis *axis,
const gchar *font,
@@ -4429,9 +5756,16 @@ gtk_plot_axis_title_set_attributes (GtkPlotAxis *axis,
aux->title.transparent = transparent;
aux->title.justification = justification;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_labels_offset:
+ * @axis: a #GtkPlotAxis.
+ * @offset:
+ *
+ *
+ */
void
gtk_plot_axis_set_labels_offset (GtkPlotAxis *axis,
gint offset)
@@ -4439,9 +5773,17 @@ gtk_plot_axis_set_labels_offset (GtkPlotAxis *axis,
GtkPlotAxis *aux = axis;
aux->labels_offset = offset;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_get_labels_offset:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_axis_get_labels_offset (GtkPlotAxis *axis)
{
@@ -4450,6 +5792,19 @@ gtk_plot_axis_get_labels_offset (GtkPlotAxis *axis)
return(aux->labels_offset);
}
+/**
+ * gtk_plot_axis_set_labels_attributes:
+ * @axis: a #GtkPlotAxis.
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ *
+ *
+ */
void
gtk_plot_axis_set_labels_attributes (GtkPlotAxis *axis,
const gchar *font,
@@ -4484,9 +5839,17 @@ gtk_plot_axis_set_labels_attributes (GtkPlotAxis *axis,
aux->labels_attr.transparent = transparent;
aux->labels_attr.justification = justification;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_labels_style:
+ * @axis: a #GtkPlotAxis.
+ * @style:
+ * @precision:
+ *
+ *
+ */
void
gtk_plot_axis_set_labels_style (GtkPlotAxis *axis,
GtkPlotLabelStyle style,
@@ -4497,18 +5860,32 @@ gtk_plot_axis_set_labels_style (GtkPlotAxis *axis,
aux->label_style = style;
aux->label_precision = precision;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_use_custom_ticks_labels:
+ * @axis: a #GtkPlotAxis.
+ * @use:
+ *
+ *
+ */
void
gtk_plot_axis_use_custom_tick_labels (GtkPlotAxis *axis,
gboolean use)
{
axis->custom_labels = use;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_labels_prefix:
+ * @axis: a #GtkPlotAxis.
+ * @text:
+ *
+ *
+ */
void
gtk_plot_axis_set_labels_prefix (GtkPlotAxis *axis,
const gchar *text)
@@ -4520,9 +5897,16 @@ gtk_plot_axis_set_labels_prefix (GtkPlotAxis *axis,
else
axis->labels_prefix = NULL;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_set_labels_suffix:
+ * @axis: a #GtkPlotAxis.
+ * @text:
+ *
+ *
+ */
void
gtk_plot_axis_set_labels_suffix (GtkPlotAxis *axis,
const gchar *text)
@@ -4534,15 +5918,31 @@ gtk_plot_axis_set_labels_suffix (GtkPlotAxis *axis,
else
axis->labels_suffix = NULL;
- gtk_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED]);
+ g_signal_emit (GTK_OBJECT(axis), axis_signals[AXIS_CHANGED], 0);
}
+/**
+ * gtk_plot_axis_get_labels_prefix:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ *
+ * Return value:
+ */
gchar *
gtk_plot_axis_get_labels_prefix (GtkPlotAxis *axis)
{
return (axis->labels_prefix);
}
+/**
+ * gtk_plot_axis_get_labels_suffix:
+ * @axis: a #GtkPlotAxis.
+ *
+ *
+ *
+ * Return value:
+ */
gchar *
gtk_plot_axis_get_labels_suffix (GtkPlotAxis *axis)
{
@@ -4558,46 +5958,101 @@ gtk_plot_axis_get_labels_suffix (GtkPlotAxis *axis)
* gtk_plot_minor_hgrid_set_attributes
******************************************/
+/**
+ * gtk_plot_x0_set_visible:
+ * @plot: a #GtkPlot widget.
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_x0_set_visible(GtkPlot *plot, gboolean visible)
{
plot->show_x0 = visible;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_x0_visible:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_x0_visible(GtkPlot *plot)
{
return plot->show_x0;
}
+/**
+ * gtk_plot_y0_set_visible:
+ * @plot: a #GtkPlot widget.
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_y0_set_visible(GtkPlot *plot, gboolean visible)
{
plot->show_y0 = visible;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_y0_visible:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_y0_visible(GtkPlot *plot)
{
return plot->show_y0;
}
+/**
+ * gtk_plot_grids_set_on_top:
+ * @plot: a #GtkPlot widget.
+ * @on_top:
+ *
+ *
+ */
void
gtk_plot_grids_set_on_top(GtkPlot *plot, gboolean on_top)
{
plot->grids_on_top = on_top;
}
+/**
+ * gtk_plot_grids_on_top:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_grids_on_top(GtkPlot *plot)
{
return(plot->grids_on_top);
}
+/**
+ * gtk_plot_grids_set_visible:
+ * @plot: a #GtkPlot widget.
+ * @vmajor:
+ * @vminor:
+ * @hmajor:
+ * @hminor:
+ *
+ *
+ */
void
gtk_plot_grids_set_visible(GtkPlot *plot,
gboolean vmajor, gboolean vminor,
@@ -4608,10 +6063,19 @@ gtk_plot_grids_set_visible(GtkPlot *plot,
plot->left->show_major_grid = hmajor;
plot->left->show_minor_grid = hminor;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
-
+/**
+ * gtk_plot_grids_visible:
+ * @plot: a #GtkPlot widget.
+ * @vmajor:
+ * @vminor:
+ * @hmajor:
+ * @hminor:
+ *
+ *
+ */
void
gtk_plot_grids_visible(GtkPlot *plot,
gboolean *vmajor, gboolean *vminor,
@@ -4623,6 +6087,15 @@ gtk_plot_grids_visible(GtkPlot *plot,
*hminor = plot->left->show_minor_grid;
}
+/**
+ * gtk_plot_x0line_set_visible:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_x0line_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4633,9 +6106,18 @@ gtk_plot_x0line_set_attributes(GtkPlot *plot,
plot->x0_line.line_width = width;
if(color) plot->x0_line.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_y0line_set_attributes:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_y0line_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4646,9 +6128,18 @@ gtk_plot_y0line_set_attributes(GtkPlot *plot,
plot->y0_line.line_width = width;
if(color) plot->y0_line.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_major_vgrid_set_Attributes:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_major_vgrid_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4659,9 +6150,18 @@ gtk_plot_major_vgrid_set_attributes(GtkPlot *plot,
plot->bottom->major_grid.line_width = width;
if(color) plot->bottom->major_grid.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_minor_vgrid_set_attributes:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_minor_vgrid_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4672,9 +6172,18 @@ gtk_plot_minor_vgrid_set_attributes(GtkPlot *plot,
plot->bottom->minor_grid.line_width = width;
if(color) plot->bottom->minor_grid.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_major_hgrid_set_attributes:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_major_hgrid_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4685,9 +6194,18 @@ gtk_plot_major_hgrid_set_attributes(GtkPlot *plot,
plot->left->major_grid.line_width = width;
if(color) plot->left->major_grid.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_minor_hgrid_set_attributes:
+ * @plot: a #GtkPlot widget.
+ * @line_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_minor_hgrid_set_attributes(GtkPlot *plot,
GtkPlotLineStyle line_style,
@@ -4698,7 +6216,7 @@ gtk_plot_minor_hgrid_set_attributes(GtkPlot *plot,
plot->left->minor_grid.line_width = width;
if(color) plot->left->minor_grid.color = *color;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
/******************************************
@@ -4712,23 +6230,42 @@ gtk_plot_minor_hgrid_set_attributes(GtkPlot *plot,
* gtk_plot_set_legends_attributes
******************************************/
+/**
+ * gtk_plot_show_legends:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ */
void
gtk_plot_show_legends(GtkPlot *plot)
{
plot->show_legends = TRUE;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
-
+/**
+ * gtk_plot_hide_legends:
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ */
void
gtk_plot_hide_legends(GtkPlot *plot)
{
plot->show_legends = FALSE;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_set_legends_border:
+ * @plot: a #GtkPlot widget.
+ * @legends_border:
+ * @shadow_width:
+ *
+ *
+ */
void
gtk_plot_set_legends_border(GtkPlot *plot,
GtkPlotBorderStyle legends_border,
@@ -4737,18 +6274,33 @@ gtk_plot_set_legends_border(GtkPlot *plot,
plot->legends_border = legends_border;
plot->legends_shadow_width = shadow_width;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_legends_move:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_legends_move(GtkPlot *plot, gdouble x, gdouble y)
{
plot->legends_x = x;
plot->legends_y = y;
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_legends_get_position:
+ * @plot: a #GtkPlot widget.
+ * @x:
+ * @y:
+ *
+ */
void
gtk_plot_legends_get_position(GtkPlot *plot, gdouble *x, gdouble *y)
{
@@ -4756,6 +6308,12 @@ gtk_plot_legends_get_position(GtkPlot *plot, gdouble *x, gdouble *y)
*y = plot->legends_y;
}
+/**
+ * gtk_plot_legends_get_allocation:
+ * @plot: a #GtkPlot widget.
+ *
+ * Return value: (transfer full) the #GtkAllocation
+ */
GtkAllocation
gtk_plot_legends_get_allocation(GtkPlot *plot)
{
@@ -4768,10 +6326,11 @@ gtk_plot_legends_get_allocation(GtkPlot *plot)
widget = GTK_WIDGET(plot);
m = plot->magnification;
- x = widget->allocation.x + plot->x * widget->allocation.width +
- plot->legends_x * plot->width * widget->allocation.width;
- y = widget->allocation.y + plot->y * widget->allocation.height +
- plot->legends_y * plot->height * widget->allocation.height;
+ gtk_widget_get_allocation(widget, &allocation);
+ x = allocation.x + plot->x * allocation.width +
+ plot->legends_x * plot->width * allocation.width;
+ y = allocation.y + plot->y * allocation.height +
+ plot->legends_y * plot->height * allocation.height;
width = 24 * m;
height = 8 * m;
@@ -4784,7 +6343,7 @@ gtk_plot_legends_get_allocation(GtkPlot *plot)
dataset = GTK_PLOT_DATA(datasets->data);
- if(GTK_WIDGET_VISIBLE(GTK_WIDGET(dataset)) && dataset->show_legend)
+ if(gtk_widget_get_visible(GTK_WIDGET(dataset)) && dataset->show_legend)
{
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(dataset)))->get_legend_size(dataset, &lwidth,
&lheight);
width = MAX(width, lwidth);
@@ -4802,6 +6361,16 @@ gtk_plot_legends_get_allocation(GtkPlot *plot)
return(allocation);
}
+/**
+ * gtk_plot_legends_set_attributes:
+ * @plot: a #GtkPlot widget.
+ * @font:
+ * @height:
+ * @foreground:
+ * @background:
+ *
+ *
+ */
void
gtk_plot_legends_set_attributes(GtkPlot *plot, const gchar *font, gint height,
const GdkColor *foreground, const GdkColor *background)
@@ -4816,8 +6385,8 @@ gtk_plot_legends_set_attributes(GtkPlot *plot, const gchar *font, gint height,
plot->legends_attr.font = g_strdup(font);
plot->legends_attr.height = height;
}
- plot->legends_attr.fg = GTK_WIDGET(plot)->style->black;
- plot->legends_attr.bg = GTK_WIDGET(plot)->style->white;
+ plot->legends_attr.fg = gtk_widget_get_style(GTK_WIDGET(plot))->black;
+ plot->legends_attr.bg = gtk_widget_get_style(GTK_WIDGET(plot))->white;
if(foreground != NULL)
plot->legends_attr.fg = *foreground;
@@ -4828,9 +6397,16 @@ gtk_plot_legends_set_attributes(GtkPlot *plot, const gchar *font, gint height,
plot->legends_attr.transparent = FALSE;
}
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_legends_add_data:
+ * @plot: a #GtkPlot widget.
+ * @dataset:
+ *
+ *
+ */
void
gtk_plot_add_data(GtkPlot *plot,
GtkPlotData *dataset)
@@ -4839,15 +6415,24 @@ gtk_plot_add_data(GtkPlot *plot,
_gtkextra_signal_emit (GTK_OBJECT(plot), plot_signals[ADD_DATA], dataset, &veto);
plot->data_sets = g_list_append(plot->data_sets, dataset);
- gtk_widget_ref(GTK_WIDGET(dataset));
- gtk_object_sink(GTK_OBJECT(dataset));
+ g_object_ref(GTK_WIDGET(dataset));
+ g_object_ref_sink(GTK_OBJECT(dataset));
+ g_object_unref(GTK_OBJECT(dataset));
dataset->plot = plot;
- gtk_signal_emit_by_name (GTK_OBJECT(dataset), "add_to_plot", plot, &veto);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit_by_name (GTK_OBJECT(dataset), "add_to_plot", plot, &veto);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
}
+/**
+ * gtk_plot_add_function:
+ * @plot: a #GtkPlot widget.
+ * @function: (scope async): the dataset generation function
+ *
+ * Return value: (transfer none) the #GtkPlotData
+ */
+
GtkPlotData *
gtk_plot_add_function(GtkPlot *plot, GtkPlotFunc function)
{
@@ -4860,6 +6445,15 @@ gtk_plot_add_function(GtkPlot *plot, GtkPlotFunc function)
return (dataset);
}
+/**
+ * gtk_plot_remove_data:
+ * @plot: a #GtkPlot widget.
+ * @dataset:
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_remove_data(GtkPlot *plot, GtkPlotData *dataset)
{
@@ -4873,10 +6467,10 @@ gtk_plot_remove_data(GtkPlot *plot, GtkPlotData *dataset)
data = datasets->data;
if(GTK_PLOT_DATA(data) == dataset){
- gtk_widget_unref(GTK_WIDGET(dataset));
+ g_object_unref(GTK_WIDGET(dataset));
plot->data_sets = g_list_remove_link(plot->data_sets, datasets);
g_list_free_1(datasets);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
return TRUE;
}
datasets = datasets->next;
@@ -4885,6 +6479,15 @@ gtk_plot_remove_data(GtkPlot *plot, GtkPlotData *dataset)
return FALSE;
}
+/**
+ * gtk_plot_remove_text:
+ * @plot: a #GtkPlot widget.
+ * @text:
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_remove_text(GtkPlot *plot, GtkPlotText *text)
{
@@ -4900,7 +6503,7 @@ gtk_plot_remove_text(GtkPlot *plot, GtkPlotText *text)
if((GtkPlotText *)data == text){
plot->text = g_list_remove_link(plot->text, list);
g_list_free_1(list);
- gtk_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED]);
+ g_signal_emit (GTK_OBJECT(plot), plot_signals[CHANGED], 0);
return TRUE;
}
list = list->next;
@@ -5084,6 +6687,12 @@ printf("%f %f\n",max/ticks->step,ceil(max/ticks->step));
*/
}
+/**
+ * gtk_plot_ticks_recalc:
+ * @axis:
+ *
+ *
+ */
void
gtk_plot_ticks_recalc(GtkPlotAxis *axis)
{
@@ -5146,7 +6755,7 @@ update_datasets(GtkPlot *plot, gboolean new_range)
list = plot->data_sets;
while(list) {
- gtk_signal_emit_by_name(GTK_OBJECT(list->data), "update", new_range);
+ g_signal_emit_by_name(GTK_OBJECT(list->data), "update", new_range);
list = list->next;
}
diff --git a/gtkextra/gtkplot.h b/gtkextra/gtkplot.h
index 01db4ec..4cf021b 100644
--- a/gtkextra/gtkplot.h
+++ b/gtkextra/gtkplot.h
@@ -20,22 +20,23 @@
#define __GTK_PLOT_H__
#ifdef __cplusplus
-extern "C" {
+extern "C"
+{
#endif /* __cplusplus */
#include "gtkplotpc.h"
#include "gtkplotarray.h"
-#define GTK_PLOT(obj) GTK_CHECK_CAST (obj, gtk_plot_get_type (), GtkPlot)
+#define GTK_PLOT(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_get_type (), GtkPlot)
-#define GTK_TYPE_PLOT (gtk_plot_get_type ())
+#define G_TYPE_PLOT (gtk_plot_get_type ())
-#define GTK_PLOT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_get_type(), GtkPlotClass)
-#define GTK_IS_PLOT(obj) GTK_CHECK_TYPE (obj, gtk_plot_get_type ())
-#define GTK_PLOT_AXIS(obj) GTK_CHECK_CAST (obj, gtk_plot_axis_get_type (), GtkPlotAxis)
+#define GTK_PLOT_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_get_type(), GtkPlotClass)
+#define GTK_IS_PLOT(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_get_type ())
+#define GTK_PLOT_AXIS(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_axis_get_type (), GtkPlotAxis)
-#define GTK_TYPE_PLOT_AXIS (gtk_plot_axis_get_type ())
-#define GTK_IS_PLOT_AXIS(obj) GTK_CHECK_TYPE (obj, gtk_plot_axis_get_type ())
+#define G_TYPE_PLOT_AXIS (gtk_plot_axis_get_type ())
+#define GTK_IS_PLOT_AXIS(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_axis_get_type ())
typedef struct _GtkPlot GtkPlot;
typedef struct _GtkPlotClass GtkPlotClass;
@@ -52,468 +53,543 @@ typedef struct _GtkPlotVector GtkPlotVector;
typedef struct _GtkPlotMarker GtkPlotMarker;
-typedef gdouble (*GtkPlotFunc) (GtkPlot *plot,
- GtkPlotData *data,
- gdouble x,
- gboolean *error);
-
-typedef gdouble (*GtkPlotFunc3D) (GtkPlot *plot,
- GtkPlotData *data,
- gdouble x, gdouble y,
- gboolean *error);
-
-typedef void (*GtkPlotIterator) (GtkPlot *plot,
- GtkPlotData *data,
- gint iter,
- gdouble *x,
- gdouble *y,
- gdouble *z,
- gdouble *a,
- gdouble *dx,
- gdouble *dy,
- gdouble *dz,
- gdouble *da,
- gchar **label,
- gboolean *error);
+typedef gdouble(*GtkPlotFunc)(GtkPlot *plot,
+ GtkPlotData *data,
+ gdouble x,
+ gboolean *error);
+
+typedef gdouble(*GtkPlotFunc3D)(GtkPlot *plot,
+ GtkPlotData *data,
+ gdouble x, gdouble y,
+ gboolean *error);
+
+typedef void (*GtkPlotIterator)(GtkPlot *plot,
+ GtkPlotData *data,
+ gint iter,
+ gdouble *x,
+ gdouble *y,
+ gdouble *z,
+ gdouble *a,
+ gdouble *dx,
+ gdouble *dy,
+ gdouble *dz,
+ gdouble *da,
+ gchar **label,
+ gboolean *error);
enum
{
- GTK_PLOT_DATA_X = 1 << 0,
- GTK_PLOT_DATA_Y = 1 << 1,
- GTK_PLOT_DATA_Z = 1 << 2,
- GTK_PLOT_DATA_A = 1 << 3,
- GTK_PLOT_DATA_DX = 1 << 4,
- GTK_PLOT_DATA_DY = 1 << 5,
- GTK_PLOT_DATA_DZ = 1 << 6,
- GTK_PLOT_DATA_DA = 1 << 7,
- GTK_PLOT_DATA_LABELS = 1 << 8,
+ GTK_PLOT_DATA_X = 1 << 0,
+ GTK_PLOT_DATA_Y = 1 << 1,
+ GTK_PLOT_DATA_Z = 1 << 2,
+ GTK_PLOT_DATA_A = 1 << 3,
+ GTK_PLOT_DATA_DX = 1 << 4,
+ GTK_PLOT_DATA_DY = 1 << 5,
+ GTK_PLOT_DATA_DZ = 1 << 6,
+ GTK_PLOT_DATA_DA = 1 << 7,
+ GTK_PLOT_DATA_LABELS = 1 << 8,
};
typedef enum
{
- GTK_PLOT_SCALE_LINEAR ,
- GTK_PLOT_SCALE_LOG10
+ GTK_PLOT_SCALE_LINEAR,
+ GTK_PLOT_SCALE_LOG10
} GtkPlotScale;
typedef enum
{
- GTK_PLOT_SYMBOL_NONE ,
- GTK_PLOT_SYMBOL_SQUARE ,
- GTK_PLOT_SYMBOL_CIRCLE ,
- GTK_PLOT_SYMBOL_UP_TRIANGLE ,
- GTK_PLOT_SYMBOL_DOWN_TRIANGLE ,
- GTK_PLOT_SYMBOL_RIGHT_TRIANGLE ,
- GTK_PLOT_SYMBOL_LEFT_TRIANGLE ,
- GTK_PLOT_SYMBOL_DIAMOND ,
- GTK_PLOT_SYMBOL_PLUS ,
- GTK_PLOT_SYMBOL_CROSS ,
- GTK_PLOT_SYMBOL_STAR ,
- GTK_PLOT_SYMBOL_DOT ,
- GTK_PLOT_SYMBOL_IMPULSE ,
+ GTK_PLOT_SYMBOL_NONE,
+ GTK_PLOT_SYMBOL_SQUARE,
+ GTK_PLOT_SYMBOL_CIRCLE,
+ GTK_PLOT_SYMBOL_UP_TRIANGLE,
+ GTK_PLOT_SYMBOL_DOWN_TRIANGLE,
+ GTK_PLOT_SYMBOL_RIGHT_TRIANGLE,
+ GTK_PLOT_SYMBOL_LEFT_TRIANGLE,
+ GTK_PLOT_SYMBOL_DIAMOND,
+ GTK_PLOT_SYMBOL_PLUS,
+ GTK_PLOT_SYMBOL_CROSS,
+ GTK_PLOT_SYMBOL_STAR,
+ GTK_PLOT_SYMBOL_DOT,
+ GTK_PLOT_SYMBOL_IMPULSE,
} GtkPlotSymbolType;
typedef enum
{
- GTK_PLOT_SYMBOL_EMPTY ,
- GTK_PLOT_SYMBOL_FILLED ,
- GTK_PLOT_SYMBOL_OPAQUE
+ GTK_PLOT_SYMBOL_EMPTY,
+ GTK_PLOT_SYMBOL_FILLED,
+ GTK_PLOT_SYMBOL_OPAQUE
} GtkPlotSymbolStyle;
typedef enum
{
- GTK_PLOT_BORDER_NONE ,
- GTK_PLOT_BORDER_LINE ,
- GTK_PLOT_BORDER_SHADOW ,
+ GTK_PLOT_BORDER_NONE,
+ GTK_PLOT_BORDER_LINE,
+ GTK_PLOT_BORDER_SHADOW,
} GtkPlotBorderStyle;
typedef enum
{
- GTK_PLOT_LINE_NONE ,
- GTK_PLOT_LINE_SOLID ,
- GTK_PLOT_LINE_DOTTED ,
- GTK_PLOT_LINE_DASHED ,
- GTK_PLOT_LINE_DOT_DASH ,
- GTK_PLOT_LINE_DOT_DOT_DASH ,
- GTK_PLOT_LINE_DOT_DASH_DASH
+ GTK_PLOT_LINE_NONE,
+ GTK_PLOT_LINE_SOLID,
+ GTK_PLOT_LINE_DOTTED,
+ GTK_PLOT_LINE_DASHED,
+ GTK_PLOT_LINE_DOT_DASH,
+ GTK_PLOT_LINE_DOT_DOT_DASH,
+ GTK_PLOT_LINE_DOT_DASH_DASH
} GtkPlotLineStyle;
typedef enum
{
- GTK_PLOT_CONNECT_NONE ,
- GTK_PLOT_CONNECT_STRAIGHT ,
- GTK_PLOT_CONNECT_SPLINE ,
- GTK_PLOT_CONNECT_HV_STEP ,
- GTK_PLOT_CONNECT_VH_STEP ,
- GTK_PLOT_CONNECT_MIDDLE_STEP
+ GTK_PLOT_CONNECT_NONE,
+ GTK_PLOT_CONNECT_STRAIGHT,
+ GTK_PLOT_CONNECT_SPLINE,
+ GTK_PLOT_CONNECT_HV_STEP,
+ GTK_PLOT_CONNECT_VH_STEP,
+ GTK_PLOT_CONNECT_MIDDLE_STEP
} GtkPlotConnector;
typedef enum
{
- GTK_PLOT_LABEL_NONE = 0,
- GTK_PLOT_LABEL_IN = 1 << 0,
- GTK_PLOT_LABEL_OUT = 1 << 1,
+ GTK_PLOT_LABEL_NONE = 0,
+ GTK_PLOT_LABEL_IN = 1 << 0,
+ GTK_PLOT_LABEL_OUT = 1 << 1,
}GtkPlotLabelPos;
typedef enum
{
- GTK_PLOT_ERROR_DIV_ZERO,
- GTK_PLOT_ERROR_LOG_NEG
+ GTK_PLOT_ERROR_DIV_ZERO,
+ GTK_PLOT_ERROR_LOG_NEG
} GtkPlotError;
typedef enum
{
- GTK_PLOT_AXIS_X ,
- GTK_PLOT_AXIS_Y ,
- GTK_PLOT_AXIS_Z ,
+ GTK_PLOT_AXIS_X,
+ GTK_PLOT_AXIS_Y,
+ GTK_PLOT_AXIS_Z,
} GtkPlotOrientation;
typedef enum
{
- GTK_PLOT_AXIS_LEFT ,
- GTK_PLOT_AXIS_RIGHT ,
- GTK_PLOT_AXIS_TOP ,
- GTK_PLOT_AXIS_BOTTOM
+ GTK_PLOT_AXIS_LEFT,
+ GTK_PLOT_AXIS_RIGHT,
+ GTK_PLOT_AXIS_TOP,
+ GTK_PLOT_AXIS_BOTTOM
} GtkPlotAxisPos;
typedef enum
{
- GTK_PLOT_LABEL_FLOAT ,
- GTK_PLOT_LABEL_EXP ,
- GTK_PLOT_LABEL_POW
+ GTK_PLOT_LABEL_FLOAT,
+ GTK_PLOT_LABEL_EXP,
+ GTK_PLOT_LABEL_POW
} GtkPlotLabelStyle;
typedef enum
{
- GTK_PLOT_TICKS_NONE = 0,
- GTK_PLOT_TICKS_IN = 1 << 0,
- GTK_PLOT_TICKS_OUT = 1 << 1
+ GTK_PLOT_TICKS_NONE = 0,
+ GTK_PLOT_TICKS_IN = 1 << 0,
+ GTK_PLOT_TICKS_OUT = 1 << 1
} GtkPlotTicksPos;
enum
{
- GTK_PLOT_GRADIENT_H = 1 << 0,
- GTK_PLOT_GRADIENT_V = 1 << 1,
- GTK_PLOT_GRADIENT_S = 1 << 2,
+ GTK_PLOT_GRADIENT_H = 1 << 0,
+ GTK_PLOT_GRADIENT_V = 1 << 1,
+ GTK_PLOT_GRADIENT_S = 1 << 2,
};
+/**
+ * GtkPlotMarker:
+ *
+ * The GtkPlotMarker struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotMarker
{
- GtkPlotData *data;
- gint point;
+ /*< private >*/
+ GtkPlotData *data;
+ gint point;
};
+/**
+ * GtkPlotText:
+ *
+ * The GtkPlotText struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotText
{
- gdouble x, y;
- gint angle; /* 0, 90, 180, 270 */
- GdkColor fg;
- GdkColor bg;
-
- gboolean transparent;
-
- GtkPlotBorderStyle border;
- gint border_width;
- gint shadow_width;
- gint border_space;
-
- gchar *font;
- gint height;
-
- gchar *text;
-
- GtkJustification justification;
+ /*< private >*/
+ gdouble x, y;
+ gint angle; /* 0, 90, 180, 270 */
+ GdkColor fg;
+ GdkColor bg;
+
+ gboolean transparent;
+
+ GtkPlotBorderStyle border;
+ gint border_width;
+ gint shadow_width;
+ gint border_space;
+
+ gchar *font;
+ gint height;
+
+ gchar *text;
+
+ GtkJustification justification;
};
+/**
+ * GtkPlotLine:
+ *
+ * The GtkPlotLine struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotLine
{
- GtkPlotLineStyle line_style;
- GdkCapStyle cap_style;
- GdkJoinStyle join_style;
+ /*< private >*/
+ GtkPlotLineStyle line_style;
+ GdkCapStyle cap_style;
+ GdkJoinStyle join_style;
- gfloat line_width;
- GdkColor color;
+ gfloat line_width;
+ GdkColor color;
};
+/**
+ * GtkPlotSymbol:
+ *
+ * The GtkPlotSymbol struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotSymbol
{
- GtkPlotSymbolType symbol_type;
- GtkPlotSymbolStyle symbol_style;
+ /*< private >*/
+ GtkPlotSymbolType symbol_type;
+ GtkPlotSymbolStyle symbol_style;
- gint size;
+ gint size;
- GdkColor color;
- GtkPlotLine border;
+ GdkColor color;
+ GtkPlotLine border;
};
+/**
+ * GtkPlotVector:
+ *
+ * The GtkPlotVector struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotVector
{
- gdouble x, y, z;
+ /*< private >*/
+ gdouble x, y, z;
};
+/**
+ * GtkPlotTick:
+ *
+ * The GtkPlotTick struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotTick
{
- gdouble value;
- gboolean minor;
+ /*< private >*/
+ gdouble value;
+ gboolean minor;
};
+/**
+ * GtkPlotTicks:
+ *
+ * The GtkPlotTicks struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotTicks
{
- gdouble min;
- gdouble max;
+ /*< private >*/
+ gdouble min;
+ gdouble max;
- GtkPlotScale scale;
+ GtkPlotScale scale;
- gint nmajorticks; /* Number of major ticks drawn */
- gint nminorticks; /* Number of minor ticks drawn */
- gint nticks; /* total number of ticks */
+ gint nmajorticks; /* Number of major ticks drawn */
+ gint nminorticks; /* Number of minor ticks drawn */
+ gint nticks; /* total number of ticks */
- gdouble step; /* major ticks step */
- gint nminor; /* number of minor ticks between major ticks */
+ gdouble step; /* major ticks step */
+ gint nminor; /* number of minor ticks between major ticks */
- gboolean apply_break;
- GtkPlotScale break_scale;
- gdouble break_step;
- gint break_nminor;
- gdouble break_min;
- gdouble break_max;
- gdouble break_position;
+ gboolean apply_break;
+ GtkPlotScale break_scale;
+ gdouble break_step;
+ gint break_nminor;
+ gdouble break_min;
+ gdouble break_max;
+ gdouble break_position;
- GtkPlotTick *values;
+ GtkPlotTick *values;
- gboolean set_limits;
- gdouble begin, end;
+ gboolean set_limits;
+ gdouble begin, end;
};
+typedef void (*GtkPlotTicksRecalcFunc)(GtkPlotAxis *axis);
+
+typedef void (*GtkPlotTicksAutoscaleFunc)(GtkPlotAxis *axis,
+ gdouble xmin, gdouble xmax,
+ gint *precision);
+
+typedef gdouble(*GtkPlotTicksTransformFunc)(GtkPlotAxis *axis, gdouble y);
+typedef gdouble(*GtkPlotTicksInverseFunc)(GtkPlotAxis *axis, gdouble y);
+
+typedef void (*GtkPlotParseLabelFunc)(GtkPlotAxis *axis,
+ gdouble val,
+ gint precision,
+ gint style,
+ gchar *label);
+
+/**
+ * GtkPlotAxis:
+ *
+ * The GtkPlotAxis struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
+
struct _GtkPlotAxis
{
- GtkObject object;
+ /*< private >*/
+ GtkObject object;
+
+ gboolean is_visible;
- gboolean is_visible;
+ GtkPlotVector origin;
+ GtkPlotVector direction;
- GtkPlotVector origin;
- GtkPlotVector direction;
+ GtkPlotText title;
+ gboolean title_visible;
- GtkPlotText title;
- gboolean title_visible;
+ GtkPlotTicks ticks;
- GtkPlotTicks ticks;
+ GtkPlotOrientation orientation;
- GtkPlotOrientation orientation;
-
- GtkPlotLine line;
- GtkPlotLine major_grid;
- GtkPlotLine minor_grid;
+ GtkPlotLine line;
+ GtkPlotLine major_grid;
+ GtkPlotLine minor_grid;
- gint major_mask;
- gint minor_mask;
- gint ticks_length;
- gfloat ticks_width;
+ gint major_mask;
+ gint minor_mask;
+ gint ticks_length;
+ gfloat ticks_width;
- gboolean custom_labels;
+ gboolean custom_labels;
- gint labels_offset;
+ gint labels_offset;
- gchar *labels_prefix;
- gchar *labels_suffix;
+ gchar *labels_prefix;
+ gchar *labels_suffix;
- gboolean show_major_grid;
- gboolean show_minor_grid;
+ gboolean show_major_grid;
+ gboolean show_minor_grid;
- GtkPlotText labels_attr;
+ GtkPlotText labels_attr;
- gint label_precision;
- gint label_style;
- gint label_mask;
+ gint label_precision;
+ gint label_style;
+ gint label_mask;
- GtkPlotArray *tick_labels;
+ GtkPlotArray *tick_labels;
- void (*ticks_recalc) (GtkPlotAxis *axis);
- void (*ticks_autoscale) (GtkPlotAxis *axis,
- gdouble xmin, gdouble xmax,
- gint *precision);
- gdouble (*ticks_transform) (GtkPlotAxis *axis, gdouble y);
- gdouble (*ticks_inverse) (GtkPlotAxis *axis, gdouble y);
- void (*parse_label) (GtkPlotAxis *axis,
- gdouble val,
- gint precision,
- gint style,
- gchar *label);
- gboolean frozen; /* don't recalc ticks to avoid
+ GtkPlotTicksRecalcFunc ticks_recalc;
+ GtkPlotTicksAutoscaleFunc ticks_autoscale;
+ GtkPlotTicksTransformFunc ticks_transform;
+ GtkPlotTicksInverseFunc ticks_inverse;
+ GtkPlotParseLabelFunc parse_label;
+
+ gboolean frozen; /* don't recalc ticks to avoid
huge memory leaks when changing range */
};
+/**
+ * GtkPlotData:
+ *
+ * The GtkPlotData struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotData
{
- GtkWidget widget;
+ /*< private >*/
+ GtkWidget widget;
- gboolean is_function;
- gboolean is_iterator;
+ gboolean is_function;
+ gboolean is_iterator;
- guint16 iterator_mask;
+ guint16 iterator_mask;
- gboolean show_legend;
- gboolean show_labels;
- gboolean fill_area;
+ gboolean show_legend;
+ gboolean show_labels;
+ gboolean fill_area;
- gchar *name;
- gchar *legend;
+ gchar *name;
+ gchar *legend;
- GtkPlot *plot;
+ GtkPlot *plot;
- GtkPlotSymbol symbol;
- GtkPlotLine line;
- GtkPlotConnector line_connector;
+ GtkPlotSymbol symbol;
+ GtkPlotLine line;
+ GtkPlotConnector line_connector;
- GtkPlotLine x_line;
- GtkPlotLine y_line;
- GtkPlotLine z_line;
+ GtkPlotLine x_line;
+ GtkPlotLine y_line;
+ GtkPlotLine z_line;
- gboolean show_xerrbars;
- gint xerrbar_width;
- gint xerrbar_caps;
+ gboolean show_xerrbars;
+ gint xerrbar_width;
+ gint xerrbar_caps;
- gboolean show_yerrbars;
- gint yerrbar_width;
- gint yerrbar_caps;
+ gboolean show_yerrbars;
+ gint yerrbar_width;
+ gint yerrbar_caps;
- gboolean show_zerrbars;
- gint zerrbar_width;
- gint zerrbar_caps;
+ gboolean show_zerrbars;
+ gint zerrbar_width;
+ gint zerrbar_caps;
- gint num_points;
+ gint num_points;
- GtkPlotArrayList *data;
+ GtkPlotArrayList *data;
- gint labels_offset;
- GtkPlotText labels_attr;
+ gint labels_offset;
+ GtkPlotText labels_attr;
- GtkPlotFunc function;
- GtkPlotFunc3D function3d;
- GtkPlotIterator iterator;
+ GtkPlotFunc function;
+ GtkPlotFunc3D function3d;
+ GtkPlotIterator iterator;
- gdouble x_step;
- gdouble y_step;
- gdouble z_step;
+ gdouble x_step;
+ gdouble y_step;
+ gdouble z_step;
- GdkColor color_min, color_max;
- GdkColor color_lt_min, color_gt_max;
- gint gradient_mask;
- GtkPlotAxis * gradient;
- gboolean gradient_custom;
- GdkColor *gradient_colors;
+ GdkColor color_min, color_max;
+ GdkColor color_lt_min, color_gt_max;
+ gboolean gradient_show_lt_gt;
+ gint gradient_mask;
+ GtkPlotAxis *gradient;
+ gboolean gradient_custom;
+ GdkColor *gradient_colors;
- gboolean show_gradient;
- gint legends_precision;
- GtkPlotLabelStyle legends_style;
+ gboolean show_gradient;
+ gint legends_precision;
+ GtkPlotLabelStyle legends_style;
- gpointer link;
+ gpointer link;
- GList *markers;
- gboolean show_markers;
+ GList *markers;
+ gboolean show_markers;
- gboolean redraw_pending;
+ gboolean redraw_pending;
- GtkPlotAxisPos gradient_title_pos;
- gint gradient_line_width;
- gint gradient_line_height;
- gdouble gradient_x, gradient_y;
+ GtkPlotAxisPos gradient_title_pos;
+ gint gradient_line_width;
+ gint gradient_line_height;
+ gdouble gradient_x, gradient_y;
- GtkPlotBorderStyle gradient_border;
- gint gradient_border_offset;
- gint gradient_border_width;
- gint gradient_shadow_width;
+ GtkPlotBorderStyle gradient_border;
+ gint gradient_border_offset;
+ gint gradient_border_width;
+ gint gradient_shadow_width;
};
struct _GtkPlot
{
- GtkWidget widget;
+ GtkWidget widget;
- GtkAllocation internal_allocation;
+ GtkAllocation internal_allocation;
- GdkDrawable *drawable;
+ GdkDrawable *drawable;
- GdkPixmap *bg_pixmap;
- gboolean use_pixmap;
+ GdkPixmap *bg_pixmap;
+ gboolean use_pixmap;
- gboolean transparent;
+ gboolean transparent;
- gdouble magnification;
+ gdouble magnification;
- gboolean clip_data;
+ gboolean clip_data;
- GdkColor background;
+ GdkColor background;
- gboolean grids_on_top;
- gboolean show_x0;
- gboolean show_y0;
+ gboolean grids_on_top;
+ gboolean show_x0;
+ gboolean show_y0;
- /* location and size in percentage of the widget's size */
- gdouble x, y, width, height;
+ /* location and size in percentage of the widget's size */
+ gdouble x, y, width, height;
- gdouble xmin, xmax;
- gdouble ymin, ymax;
+ gdouble xmin, xmax;
+ gdouble ymin, ymax;
- GtkPlotScale xscale, yscale;
+ GtkPlotScale xscale, yscale;
- GtkPlotAxis *bottom;
- GtkPlotAxis *top;
- GtkPlotAxis *left;
- GtkPlotAxis *right;
+ GtkPlotAxis *bottom;
+ GtkPlotAxis *top;
+ GtkPlotAxis *left;
+ GtkPlotAxis *right;
- gboolean reflect_x;
- gboolean reflect_y;
+ gboolean reflect_x;
+ gboolean reflect_y;
- gfloat bottom_align;
- gfloat top_align;
- gfloat left_align;
- gfloat right_align;
+ gfloat bottom_align;
+ gfloat top_align;
+ gfloat left_align;
+ gfloat right_align;
- GtkPlotLine x0_line;
- GtkPlotLine y0_line;
+ GtkPlotLine x0_line;
+ GtkPlotLine y0_line;
- gdouble legends_x, legends_y; /* position in % */
- gint legends_width, legends_height; /* absolute size */
+ gdouble legends_x, legends_y; /* position in % */
+ gint legends_width, legends_height; /* absolute size */
- GtkPlotBorderStyle legends_border;
- gint legends_line_width;
- gint legends_border_width;
- gint legends_shadow_width;
- gboolean show_legends;
- GtkPlotText legends_attr;
+ GtkPlotBorderStyle legends_border;
+ gint legends_line_width;
+ gint legends_border_width;
+ gint legends_shadow_width;
+ gboolean show_legends;
+ GtkPlotText legends_attr;
- GList *data_sets;
- GList *text;
+ GList *data_sets;
+ GList *text;
- GtkPlotPC *pc;
+ GtkPlotPC *pc;
};
struct _GtkPlotClass
{
- GtkWidgetClass parent_class;
+ GtkWidgetClass parent_class;
- void (* set_pc) (GtkPlot *plot, GtkPlotPC *pc);
- void (* set_drawable) (GtkPlot *plot, GdkDrawable *drawable);
- gboolean (* add_data) (GtkPlot *plot, GtkPlotData *data);
- void (* update) (GtkPlot *plot, gboolean new_range);
- void (* changed) (GtkPlot *plot);
+ void (*set_pc)(GtkPlot *plot, GtkPlotPC *pc);
+ void (*set_drawable)(GtkPlot *plot, GdkDrawable *drawable);
+ gboolean(*add_data)(GtkPlot *plot, GtkPlotData *data);
+ void (*update)(GtkPlot *plot, gboolean new_range);
+ void (*changed)(GtkPlot *plot);
- gboolean (* moved) (GtkPlot *plot,
- gdouble *x, gdouble *y);
+ gboolean(*moved)(GtkPlot *plot,
+ gdouble *x, gdouble *y);
- gboolean (* resized) (GtkPlot *plot,
- gdouble *width, gdouble *height);
+ gboolean(*resized)(GtkPlot *plot,
+ gdouble *width, gdouble *height);
- void (* plot_paint) (GtkWidget *plot);
+ void (*plot_paint)(GtkWidget *plot);
- void (* draw_legends) (GtkWidget *plot);
+ void (*draw_legends)(GtkWidget *plot);
- void (* get_pixel) (GtkWidget *plot,
- gdouble x, gdouble y,
- gdouble *px, gdouble *py);
+ void (*get_pixel)(GtkWidget *plot,
+ gdouble x, gdouble y,
+ gdouble *px, gdouble *py);
- void (* get_point) (GtkWidget *plot,
- gint px, gint py,
- gdouble *x, gdouble *y);
+ void (*get_point)(GtkWidget *plot,
+ gint px, gint py,
+ gdouble *x, gdouble *y);
/*
void (* error) (GtkPlot *plot, gint errno);
@@ -522,30 +598,30 @@ struct _GtkPlotClass
struct _GtkPlotDataClass
{
- GtkWidgetClass parent_class;
-
- gboolean (* add_to_plot) (GtkPlotData *data, GtkPlot *plot);
- void (* update) (GtkPlotData *data, gboolean new_range);
- void (* gradient_changed) (GtkPlotData *data);
- void (* gradient_colors_changed) (GtkPlotData *data);
- void (* draw_data) (GtkPlotData *data);
- void (* draw_symbol) (GtkPlotData *data,
- gdouble x,
- gdouble y,
- gdouble z,
- gdouble a,
- gdouble dx,
- gdouble dy,
- gdouble dz,
- gdouble da);
- void (* draw_legend) (GtkPlotData *data, gint x, gint y);
- void (* get_legend_size) (GtkPlotData *data,
- gint *width, gint *height);
- void (* draw_gradient) (GtkPlotData *data);
- void (* get_gradient_size) (GtkPlotData *data,
- gint *width, gint *height);
-
- void (* clone) (GtkPlotData *data, GtkPlotData *copy);
+ GtkWidgetClass parent_class;
+
+ gboolean(*add_to_plot)(GtkPlotData *data, GtkPlot *plot);
+ void (*update)(GtkPlotData *data, gboolean new_range);
+ void (*gradient_changed)(GtkPlotData *data);
+ void (*gradient_colors_changed)(GtkPlotData *data);
+ void (*draw_data)(GtkPlotData *data);
+ void (*draw_symbol)(GtkPlotData *data,
+ gdouble x,
+ gdouble y,
+ gdouble z,
+ gdouble a,
+ gdouble dx,
+ gdouble dy,
+ gdouble dz,
+ gdouble da);
+ void (*draw_legend)(GtkPlotData *data, gint x, gint y);
+ void (*get_legend_size)(GtkPlotData *data,
+ gint *width, gint *height);
+ void (*draw_gradient)(GtkPlotData *data);
+ void (*get_gradient_size)(GtkPlotData *data,
+ gint *width, gint *height);
+
+ void (*clone)(GtkPlotData *data, GtkPlotData *copy);
/*
void (* error) (GtkPlotData *data, gint errno);
*/
@@ -553,336 +629,337 @@ struct _GtkPlotDataClass
struct _GtkPlotAxisClass
{
- GtkObjectClass parent_class;
+ GtkObjectClass parent_class;
- gboolean (* tick_label) (GtkPlotAxis *axis,
- gdouble *tick,
- gchar *label);
- gboolean (* changed) (GtkPlotAxis *axis);
+ gboolean(*tick_label)(GtkPlotAxis *axis,
+ gdouble *tick,
+ gchar *label);
+ gboolean(*changed)(GtkPlotAxis *axis);
};
/* Plot */
-GtkType gtk_plot_get_type (void);
-GtkWidget* gtk_plot_new (GdkDrawable *drawable);
-GtkWidget* gtk_plot_new_with_size (GdkDrawable *drawable,
- gdouble width, gdouble height);
-void gtk_plot_construct (GtkPlot *plot,
- GdkDrawable *drawable);
-void gtk_plot_construct_with_size (GtkPlot *plot,
- GdkDrawable *drawable,
- gdouble width, gdouble height);
-void gtk_plot_set_drawable (GtkPlot *plot,
- GdkDrawable *drawable);
-GdkDrawable * gtk_plot_get_drawable (GtkPlot *plot);
-void gtk_plot_set_pc (GtkPlot *plot,
- GtkPlotPC *pc);
-void gtk_plot_set_background_pixmap (GtkPlot *plot,
- GdkPixmap *pixmap);
-void gtk_plot_set_transparent (GtkPlot *plot,
- gboolean transparent);
-gboolean gtk_plot_is_transparent (GtkPlot *plot);
-void gtk_plot_get_position (GtkPlot *plot,
- gdouble *x, gdouble *y);
-void gtk_plot_get_size (GtkPlot *plot,
- gdouble *width,
- gdouble *height);
+GType gtk_plot_get_type(void);
+GtkWidget *gtk_plot_new(GdkDrawable *drawable);
+GtkWidget *gtk_plot_new_with_size(GdkDrawable *drawable,
+ gdouble width, gdouble height);
+void gtk_plot_construct(GtkPlot *plot,
+ GdkDrawable *drawable);
+void gtk_plot_construct_with_size(GtkPlot *plot,
+ GdkDrawable *drawable,
+ gdouble width, gdouble height);
+void gtk_plot_set_drawable(GtkPlot *plot,
+ GdkDrawable *drawable);
+GdkDrawable *gtk_plot_get_drawable(GtkPlot *plot);
+void gtk_plot_set_pc(GtkPlot *plot,
+ GtkPlotPC *pc);
+void gtk_plot_set_background_pixmap(GtkPlot *plot,
+ GdkPixmap *pixmap);
+void gtk_plot_set_transparent(GtkPlot *plot,
+ gboolean transparent);
+gboolean gtk_plot_is_transparent(GtkPlot *plot);
+void gtk_plot_get_position(GtkPlot *plot,
+ gdouble *x, gdouble *y);
+void gtk_plot_get_size(GtkPlot *plot,
+ gdouble *width,
+ gdouble *height);
GtkAllocation gtk_plot_get_internal_allocation(GtkPlot *plot);
-void gtk_plot_set_background (GtkPlot *plot,
- const GdkColor *background);
-void gtk_plot_paint (GtkPlot *plot);
-void gtk_plot_refresh (GtkPlot *plot,
- GdkRectangle *area);
-void gtk_plot_move (GtkPlot *plot,
- gdouble x, gdouble y);
-void gtk_plot_resize (GtkPlot *plot,
- gdouble width, gdouble height);
-void gtk_plot_set_magnification (GtkPlot *plot,
- gdouble magnification);
-void gtk_plot_move_resize (GtkPlot *plot,
- gdouble x, gdouble y,
- gdouble width, gdouble height);
-void gtk_plot_get_pixel (GtkPlot *plot,
- gdouble xx, gdouble yy,
- gdouble *x, gdouble *y);
-void gtk_plot_get_point (GtkPlot *plot,
- gint x, gint y,
- gdouble *xx, gdouble *yy);
-void gtk_plot_clip_data (GtkPlot *plot, gboolean clip);
-void gtk_plot_set_xrange (GtkPlot *plot,
- gdouble xmin, gdouble xmax);
-void gtk_plot_set_yrange (GtkPlot *plot,
- gdouble ymin, gdouble ymax);
-void gtk_plot_set_range (GtkPlot *plot,
- gdouble xmin, gdouble xmax,
- gdouble ymin, gdouble ymax);
-void gtk_plot_autoscale (GtkPlot *plot);
-void gtk_plot_get_xrange (GtkPlot *plot,
- gdouble *xmin, gdouble *xmax);
-void gtk_plot_get_yrange (GtkPlot *plot,
- gdouble *ymin, gdouble *ymax);
-void gtk_plot_set_xscale (GtkPlot *plot,
- GtkPlotScale scale_type);
-void gtk_plot_set_yscale (GtkPlot *plot,
- GtkPlotScale scale_type);
-GtkPlotScale gtk_plot_get_xscale (GtkPlot *plot);
-GtkPlotScale gtk_plot_get_yscale (GtkPlot *plot);
-void gtk_plot_reflect_x (GtkPlot *plot,
- gboolean reflect);
-void gtk_plot_reflect_y (GtkPlot *plot,
- gboolean reflect);
-gboolean gtk_plot_is_x_reflected (GtkPlot *plot);
-gboolean gtk_plot_is_y_reflected (GtkPlot *plot);
-GtkPlotText * gtk_plot_put_text (GtkPlot *plot,
- gdouble x, gdouble y,
- const gchar *font,
- gint height,
- gint angle,
- const GdkColor *foreground,
- const GdkColor *background,
- gboolean transparent,
- GtkJustification justification,
- const gchar *text);
-gint gtk_plot_remove_text (GtkPlot *plot,
- GtkPlotText *text);
-
-void gtk_plot_text_get_size (const gchar *text,
- gint angle,
- const gchar *font_name,
- gint font_size,
- gint *width, gint *height,
- gint *ascent, gint *descent);
-void gtk_plot_text_get_area (const gchar *text,
- gint angle,
- GtkJustification just,
- const gchar *font_name,
- gint font_size,
- gint *x, gint *y,
- gint *width, gint *height);
-void gtk_plot_text_set_attributes (GtkPlotText *text_attr,
- const gchar *font,
- gint height,
- gint angle,
- const GdkColor *fg,
- const GdkColor *bg,
- gboolean transparent,
- GtkJustification justification,
- const gchar *text);
-void gtk_plot_text_set_border (GtkPlotText *text,
- GtkPlotBorderStyle border,
- gint border_space,
- gint border_width,
- gint shadow_width);
-void gtk_plot_draw_line (GtkPlot *plot,
- GtkPlotLine line,
- gdouble x1, gdouble y1,
- gdouble x2, gdouble y2);
-void gtk_plot_draw_text (GtkPlot *plot,
- GtkPlotText text);
-void gtk_plot_set_ticks (GtkPlot *plot,
- GtkPlotOrientation orientation,
gdouble major_step,
- gint nminor);
-void gtk_plot_set_major_ticks (GtkPlot *plot,
- GtkPlotOrientation orientation,
gdouble major_step);
-void gtk_plot_set_minor_ticks (GtkPlot *plot,
- GtkPlotOrientation orientation,
gint nminor);
-void gtk_plot_set_ticks_limits (GtkPlot *plot,
- GtkPlotOrientation orientation,
gdouble begin, gdouble end);
+void gtk_plot_set_background(GtkPlot *plot,
+ const GdkColor *bg_color);
+void gtk_plot_paint(GtkPlot *plot);
+void gtk_plot_refresh(GtkPlot *plot,
+ GdkRectangle *drawing_area);
+void gtk_plot_move(GtkPlot *plot,
+ gdouble x, gdouble y);
+void gtk_plot_resize(GtkPlot *plot,
+ gdouble width, gdouble height);
+void gtk_plot_set_magnification(GtkPlot *plot,
+ gdouble magnification);
+void gtk_plot_move_resize(GtkPlot *plot,
+ gdouble x, gdouble y,
+ gdouble width, gdouble height);
+void gtk_plot_get_pixel(GtkPlot *plot,
+ gdouble xx, gdouble yy,
+ gdouble *x, gdouble *y);
+void gtk_plot_get_point(GtkPlot *plot,
+ gint x, gint y,
+ gdouble *xx, gdouble *yy);
+void gtk_plot_clip_data(GtkPlot *plot, gboolean clip);
+void gtk_plot_set_xrange(GtkPlot *plot,
+ gdouble xmin, gdouble xmax);
+void gtk_plot_set_yrange(GtkPlot *plot,
+ gdouble ymin, gdouble ymax);
+void gtk_plot_set_range(GtkPlot *plot,
+ gdouble xmin, gdouble xmax,
+ gdouble ymin, gdouble ymax);
+void gtk_plot_autoscale(GtkPlot *plot);
+void gtk_plot_get_xrange(GtkPlot *plot,
+ gdouble *xmin, gdouble *xmax);
+void gtk_plot_get_yrange(GtkPlot *plot,
+ gdouble *ymin, gdouble *ymax);
+void gtk_plot_set_xscale(GtkPlot *plot,
+ GtkPlotScale scale_type);
+void gtk_plot_set_yscale(GtkPlot *plot,
+ GtkPlotScale scale_type);
+GtkPlotScale gtk_plot_get_xscale(GtkPlot *plot);
+GtkPlotScale gtk_plot_get_yscale(GtkPlot *plot);
+void gtk_plot_reflect_x(GtkPlot *plot,
+ gboolean reflect);
+void gtk_plot_reflect_y(GtkPlot *plot,
+ gboolean reflect);
+gboolean gtk_plot_is_x_reflected(GtkPlot *plot);
+gboolean gtk_plot_is_y_reflected(GtkPlot *plot);
+GtkPlotText *gtk_plot_put_text(GtkPlot *plot,
+ gdouble x, gdouble y,
+ const gchar *font,
+ gint height,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ GtkJustification justification,
+ const gchar *text);
+gint gtk_plot_remove_text(GtkPlot *plot,
+ GtkPlotText *text);
+
+void gtk_plot_text_get_size(const gchar *text,
+ gint angle,
+ const gchar *text_font,
+ gint text_height,
+ gint *width, gint *height,
+ gint *ascent, gint *descent);
+void gtk_plot_text_get_area(const gchar *text,
+ gint angle,
+ GtkJustification just,
+ const gchar *font_name,
+ gint font_size,
+ gint *x, gint *y,
+ gint *width, gint *height);
+void gtk_plot_text_set_attributes(GtkPlotText *text_attr,
+ const gchar *font,
+ gint height,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ GtkJustification justification,
+ const gchar *text);
+void gtk_plot_text_set_border(GtkPlotText *text,
+ GtkPlotBorderStyle border,
+ gint border_space,
+ gint border_width,
+ gint shadow_width);
+void gtk_plot_draw_line(GtkPlot *plot,
+ GtkPlotLine line,
+ gdouble x1, gdouble y1,
+ gdouble x2, gdouble y2);
+void gtk_plot_draw_text(GtkPlot *plot,
+ GtkPlotText text);
+void gtk_plot_set_ticks(GtkPlot *plot,
+ GtkPlotOrientation orientation, gdouble major_step,
+ gint nminor);
+void gtk_plot_set_major_ticks(GtkPlot *plot,
+ GtkPlotOrientation orientation, gdouble major_step);
+void gtk_plot_set_minor_ticks(GtkPlot *plot,
+ GtkPlotOrientation orientation, gint nminor);
+void gtk_plot_set_ticks_limits(GtkPlot *plot,
+ GtkPlotOrientation orientation, gdouble begin, gdouble
end);
void gtk_plot_unset_ticks_limits(GtkPlot *plot,
- GtkPlotOrientation orientation);
-void gtk_plot_set_break (GtkPlot *plot,
- GtkPlotOrientation orient,
- gdouble min, gdouble max,
- gdouble step_after,
- gint nminor_after,
- GtkPlotScale scale_after,
- gdouble pos);
-void gtk_plot_remove_break (GtkPlot *plot,
- GtkPlotOrientation orient);
+ GtkPlotOrientation orientation);
+void gtk_plot_set_break(GtkPlot *plot,
+ GtkPlotOrientation orientation,
+ gdouble min, gdouble max,
+ gdouble step_after,
+ gint nminor_after,
+ GtkPlotScale scale_after,
+ gdouble pos);
+void gtk_plot_remove_break(GtkPlot *plot,
+ GtkPlotOrientation orientation);
+
/* Freeze/thaw all axis */
void gtk_plot_freeze (GtkPlot *plot);
void gtk_plot_thaw (GtkPlot *plot);
/* Axis */
-GtkType gtk_plot_axis_get_type (void);
-GtkObject* gtk_plot_axis_new (GtkPlotOrientation orientation);
-void gtk_plot_axis_construct (GtkPlotAxis *axis,
- GtkPlotOrientation orientation);
-GtkPlotAxis * gtk_plot_get_axis (GtkPlot *plot,
- GtkPlotAxisPos axis);
-void gtk_plot_axis_set_visible (GtkPlotAxis *axis,
- gboolean visible);
-gboolean gtk_plot_axis_visible (GtkPlotAxis *axis);
-void gtk_plot_axis_set_title (GtkPlotAxis *axis,
- const gchar *title);
-void gtk_plot_axis_show_title (GtkPlotAxis *axis);
-void gtk_plot_axis_hide_title (GtkPlotAxis *axis);
-void gtk_plot_axis_move_title (GtkPlotAxis *axis,
- gint angle,
- gdouble x, gdouble y);
-void gtk_plot_axis_justify_title (GtkPlotAxis *axis,
- GtkJustification justification);
-void gtk_plot_axis_set_attributes (GtkPlotAxis *axis,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_axis_get_attributes (GtkPlotAxis *axis,
- gfloat *width,
- GdkColor *color);
-void gtk_plot_axis_set_ticks (GtkPlotAxis *axis,
- gdouble major_step,
- gint nminor);
-void gtk_plot_axis_set_major_ticks (GtkPlotAxis *axis,
- gdouble major_step);
-void gtk_plot_axis_set_minor_ticks (GtkPlotAxis *axis,
- gint nminor);
-void gtk_plot_axis_set_ticks_length (GtkPlotAxis *axis,
- gint length);
-void gtk_plot_axis_set_ticks_width (GtkPlotAxis *axis,
- gfloat width);
-void gtk_plot_axis_show_ticks (GtkPlotAxis *axis,
- gint major_mask,
- gint minor_mask);
-void gtk_plot_axis_set_ticks_limits (GtkPlotAxis *axis,
- gdouble begin, gdouble end);
+GType gtk_plot_axis_get_type(void);
+GtkObject *gtk_plot_axis_new(GtkPlotOrientation orientation);
+void gtk_plot_axis_construct(GtkPlotAxis *axis,
+ GtkPlotOrientation orientation);
+GtkPlotAxis *gtk_plot_get_axis(GtkPlot *plot,
+ GtkPlotAxisPos axis);
+void gtk_plot_axis_set_visible(GtkPlotAxis *axis,
+ gboolean visible);
+gboolean gtk_plot_axis_visible(GtkPlotAxis *axis);
+void gtk_plot_axis_set_title(GtkPlotAxis *axis,
+ const gchar *title);
+void gtk_plot_axis_show_title(GtkPlotAxis *axis);
+void gtk_plot_axis_hide_title(GtkPlotAxis *axis);
+void gtk_plot_axis_move_title(GtkPlotAxis *axis,
+ gint angle,
+ gdouble x, gdouble y);
+void gtk_plot_axis_justify_title(GtkPlotAxis *axis,
+ GtkJustification justification);
+void gtk_plot_axis_set_attributes(GtkPlotAxis *axis,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_axis_get_attributes(GtkPlotAxis *axis,
+ gfloat *width,
+ GdkColor *color);
+void gtk_plot_axis_set_ticks(GtkPlotAxis *axis,
+ gdouble major_step,
+ gint nminor);
+void gtk_plot_axis_set_major_ticks(GtkPlotAxis *axis,
+ gdouble major_step);
+void gtk_plot_axis_set_minor_ticks(GtkPlotAxis *axis,
+ gint nminor);
+void gtk_plot_axis_set_ticks_length(GtkPlotAxis *axis,
+ gint length);
+void gtk_plot_axis_set_ticks_width(GtkPlotAxis *axis,
+ gfloat width);
+void gtk_plot_axis_show_ticks(GtkPlotAxis *axis,
+ gint major_mask,
+ gint minor_mask);
+void gtk_plot_axis_set_ticks_limits(GtkPlotAxis *axis,
+ gdouble begin, gdouble end);
void gtk_plot_axis_unset_ticks_limits(GtkPlotAxis *axis);
-void gtk_plot_axis_set_tick_labels (GtkPlotAxis *axis,
- GtkPlotArray *array);
-void gtk_plot_axis_set_break (GtkPlotAxis *axis,
- gdouble min, gdouble max,
- gdouble step_after,
- gint nminor_after,
- GtkPlotScale scale_after,
- gdouble pos);
-void gtk_plot_axis_remove_break (GtkPlotAxis *axis);
-void gtk_plot_axis_show_labels (GtkPlotAxis *axis,
- gint labels_mask);
-void gtk_plot_axis_title_set_attributes
- (GtkPlotAxis *axis,
- const gchar *font,
- gint height,
- gint angle,
- const GdkColor *foreground,
- const GdkColor *background,
- gboolean transparent,
- GtkJustification justification);
-void gtk_plot_axis_set_labels_attributes
- (GtkPlotAxis *axis,
- const gchar *font,
- gint height,
- gint angle,
- const GdkColor *foreground,
- const GdkColor *background,
- gboolean transparent,
- GtkJustification justification);
+void gtk_plot_axis_set_tick_labels(GtkPlotAxis *axis,
+ GtkPlotArray *array);
+void gtk_plot_axis_set_break(GtkPlotAxis *axis,
+ gdouble min, gdouble max,
+ gdouble step_after,
+ gint nminor_after,
+ GtkPlotScale scale_after,
+ gdouble pos);
+void gtk_plot_axis_remove_break(GtkPlotAxis *axis);
+void gtk_plot_axis_show_labels(GtkPlotAxis *axis,
+ gint labels_mask);
+void gtk_plot_axis_title_set_attributes
+(GtkPlotAxis *axis,
+ const gchar *font,
+ gint height,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ GtkJustification justification);
+void gtk_plot_axis_set_labels_attributes
+(GtkPlotAxis *axis,
+ const gchar *font,
+ gint height,
+ gint angle,
+ const GdkColor *fg,
+ const GdkColor *bg,
+ gboolean transparent,
+ GtkJustification justification);
#define gtk_plot_axis_set_labels_numbers gtk_plot_axis_set_labels_style
-void gtk_plot_axis_set_labels_style (GtkPlotAxis *axis,
- GtkPlotLabelStyle style,
- gint precision);
-void gtk_plot_axis_set_labels_offset (GtkPlotAxis *axis,
- gint offset);
-gint gtk_plot_axis_get_labels_offset (GtkPlotAxis *axis);
-void gtk_plot_axis_use_custom_tick_labels
- (GtkPlotAxis *axis,
- gboolean use);
-void gtk_plot_axis_set_labels_suffix (GtkPlotAxis *axis,
- const gchar *text);
-void gtk_plot_axis_set_labels_prefix (GtkPlotAxis *axis,
- const gchar *text);
-gchar * gtk_plot_axis_get_labels_suffix (GtkPlotAxis *axis);
-gchar * gtk_plot_axis_get_labels_prefix (GtkPlotAxis *axis);
+void gtk_plot_axis_set_labels_style(GtkPlotAxis *axis,
+ GtkPlotLabelStyle style,
+ gint precision);
+void gtk_plot_axis_set_labels_offset(GtkPlotAxis *axis,
+ gint offset);
+gint gtk_plot_axis_get_labels_offset(GtkPlotAxis *axis);
+void gtk_plot_axis_use_custom_tick_labels
+(GtkPlotAxis *axis,
+ gboolean use);
+void gtk_plot_axis_set_labels_suffix(GtkPlotAxis *axis,
+ const gchar *text);
+void gtk_plot_axis_set_labels_prefix(GtkPlotAxis *axis,
+ const gchar *text);
+gchar *gtk_plot_axis_get_labels_suffix(GtkPlotAxis *axis);
+gchar *gtk_plot_axis_get_labels_prefix(GtkPlotAxis *axis);
/* Avoid recalcing ticks all the time since doing it between setting the
* range and ticks cal lead to memory leaks and jsut bad stuff all around */
void gtk_plot_axis_freeze (GtkPlotAxis *axis);
void gtk_plot_axis_thaw (GtkPlotAxis *axis);
-void gtk_plot_axis_ticks_recalc (GtkPlotAxis *axis);
-void gtk_plot_axis_ticks_autoscale (GtkPlotAxis *axis,
- gdouble xmin, gdouble xmax,
- gint *precision);
-gdouble gtk_plot_axis_ticks_transform (GtkPlotAxis *axis,
- gdouble y);
-gdouble gtk_plot_axis_ticks_inverse (GtkPlotAxis *axis,
- gdouble x);
-void gtk_plot_axis_parse_label (GtkPlotAxis *axis,
- gdouble val,
- gint precision,
- gint style,
- gchar *label);
+void gtk_plot_axis_ticks_recalc(GtkPlotAxis *axis);
+void gtk_plot_axis_ticks_autoscale(GtkPlotAxis *axis,
+ gdouble xmin, gdouble xmax,
+ gint *precision);
+gdouble gtk_plot_axis_ticks_transform(GtkPlotAxis *axis,
+ gdouble y);
+gdouble gtk_plot_axis_ticks_inverse(GtkPlotAxis *axis,
+ gdouble x);
+void gtk_plot_axis_parse_label(GtkPlotAxis *axis,
+ gdouble val,
+ gint precision,
+ gint style,
+ gchar *label);
/* Grids */
-void gtk_plot_x0_set_visible (GtkPlot *plot,
- gboolean visible);
-gboolean gtk_plot_x0_visible (GtkPlot *plot);
-void gtk_plot_y0_set_visible (GtkPlot *plot,
- gboolean visible);
-gboolean gtk_plot_y0_visible (GtkPlot *plot);
-void gtk_plot_grids_set_on_top (GtkPlot *plot,
- gboolean on_top);
-gboolean gtk_plot_grids_on_top (GtkPlot *plot);
-void gtk_plot_grids_set_visible (GtkPlot *plot,
- gboolean vmajor,
- gboolean vminor,
- gboolean hmajor,
- gboolean hminor);
-void gtk_plot_grids_visible (GtkPlot *plot,
- gboolean *vmajor,
- gboolean *vminor,
- gboolean *hmajor,
- gboolean *hminor);
-void gtk_plot_y0line_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_x0line_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_major_vgrid_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_minor_vgrid_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_major_hgrid_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
-void gtk_plot_minor_hgrid_set_attributes (GtkPlot *plot,
- GtkPlotLineStyle style,
- gfloat width,
- const GdkColor *color);
+void gtk_plot_x0_set_visible(GtkPlot *plot,
+ gboolean visible);
+gboolean gtk_plot_x0_visible(GtkPlot *plot);
+void gtk_plot_y0_set_visible(GtkPlot *plot,
+ gboolean visible);
+gboolean gtk_plot_y0_visible(GtkPlot *plot);
+void gtk_plot_grids_set_on_top(GtkPlot *plot,
+ gboolean on_top);
+gboolean gtk_plot_grids_on_top(GtkPlot *plot);
+void gtk_plot_grids_set_visible(GtkPlot *plot,
+ gboolean vmajor,
+ gboolean vminor,
+ gboolean hmajor,
+ gboolean hminor);
+void gtk_plot_grids_visible(GtkPlot *plot,
+ gboolean *vmajor,
+ gboolean *vminor,
+ gboolean *hmajor,
+ gboolean *hminor);
+void gtk_plot_y0line_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle line_style,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_x0line_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle line_style,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_major_vgrid_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle style,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_minor_vgrid_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle line_style,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_major_hgrid_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle line_style,
+ gfloat width,
+ const GdkColor *color);
+void gtk_plot_minor_hgrid_set_attributes(GtkPlot *plot,
+ GtkPlotLineStyle line_style,
+ gfloat width,
+ const GdkColor *color);
/* Legends */
-void gtk_plot_show_legends (GtkPlot *plot);
-void gtk_plot_hide_legends (GtkPlot *plot);
-void gtk_plot_set_legends_border (GtkPlot *plot,
- GtkPlotBorderStyle border,
- gint shadow_width);
-void gtk_plot_legends_move (GtkPlot *plot,
- gdouble x, gdouble y);
-void gtk_plot_legends_get_position (GtkPlot *plot,
- gdouble *x, gdouble *y);
-GtkAllocation gtk_plot_legends_get_allocation (GtkPlot *plot);
-void gtk_plot_legends_set_attributes (GtkPlot *plot,
- const gchar *font,
- gint height,
- const GdkColor *foreground,
- const GdkColor *background);
-void gtk_plot_set_line_attributes (GtkPlot *plot,
- GtkPlotLine line);
+void gtk_plot_show_legends(GtkPlot *plot);
+void gtk_plot_hide_legends(GtkPlot *plot);
+void gtk_plot_set_legends_border(GtkPlot *plot,
+ GtkPlotBorderStyle legends_border,
+ gint shadow_width);
+void gtk_plot_legends_move(GtkPlot *plot,
+ gdouble x, gdouble y);
+void gtk_plot_legends_get_position(GtkPlot *plot,
+ gdouble *x, gdouble *y);
+GtkAllocation gtk_plot_legends_get_allocation(GtkPlot *plot);
+void gtk_plot_legends_set_attributes(GtkPlot *plot,
+ const gchar *font,
+ gint height,
+ const GdkColor *foreground,
+ const GdkColor *background);
+void gtk_plot_set_line_attributes(GtkPlot *plot,
+ GtkPlotLine line);
/* Datasets */
-void gtk_plot_add_data (GtkPlot *plot,
- GtkPlotData *data);
-gint gtk_plot_remove_data (GtkPlot *plot,
- GtkPlotData *data);
-GtkPlotData * gtk_plot_add_function (GtkPlot *plot,
- GtkPlotFunc function);
+void gtk_plot_add_data(GtkPlot *plot,
+ GtkPlotData *data);
+gint gtk_plot_remove_data(GtkPlot *plot,
+ GtkPlotData *dataset);
+GtkPlotData *gtk_plot_add_function(GtkPlot *plot,
+ GtkPlotFunc function);
#ifdef __cplusplus
}
diff --git a/gtkextra/gtkplotarray.c b/gtkextra/gtkplotarray.c
index 4a49cdf..a3db67b 100644
--- a/gtkextra/gtkplotarray.c
+++ b/gtkextra/gtkplotarray.c
@@ -83,8 +83,9 @@ gtk_plot_array_get_type (void)
NULL,
};
- array_type = g_type_register_static (G_TYPE_OBJECT, "GtkPlotArray",
- &array_info, 0);
+ array_type = g_type_register_static (G_TYPE_OBJECT,
+ "GtkPlotArray",
+ &array_info, 0);
}
return array_type;
@@ -278,7 +279,7 @@ gtk_plot_array_init (GtkPlotArray *array)
array->name = NULL;
array->label = NULL;
array->description = NULL;
- array->type = GTK_TYPE_DOUBLE;
+ array->type = G_TYPE_DOUBLE;
array->own_data = FALSE;
array->required = FALSE;
array->independent = FALSE;
@@ -287,7 +288,7 @@ gtk_plot_array_init (GtkPlotArray *array)
}
GObject*
-gtk_plot_array_new (const gchar *name, gpointer data, gint size, GtkType type, gboolean own_data)
+gtk_plot_array_new (const gchar *name, gpointer data, gint size, GType type, gboolean own_data)
{
GObject *object;
@@ -352,25 +353,25 @@ gtk_plot_array_set_required(GtkPlotArray *array, gboolean required)
}
void
-gtk_plot_array_set(GtkPlotArray *array, gpointer data, gint size, GtkType type)
+gtk_plot_array_set(GtkPlotArray *array, gpointer data, gint size, GType type)
{
if(array->own_data) gtk_plot_array_free(array);
array->type = type;
array->size = size;
switch(type){
- case GTK_TYPE_DOUBLE:
+ case G_TYPE_DOUBLE:
array->data.data_double = (gdouble *)data;
break;
- case GTK_TYPE_FLOAT:
+ case G_TYPE_FLOAT:
array->data.data_float = (gfloat *)data;
break;
- case GTK_TYPE_INT:
+ case G_TYPE_INT:
array->data.data_int = (gint *)data;
break;
- case GTK_TYPE_BOOL:
+ case G_TYPE_BOOLEAN:
array->data.data_bool = (gboolean *)data;
break;
- case GTK_TYPE_STRING:
+ case G_TYPE_STRING:
array->data.data_string = (gchar **)data;
break;
default:
@@ -384,23 +385,23 @@ gtk_plot_array_free(GtkPlotArray *array)
gint i = 0;
switch(array->type){
- case GTK_TYPE_DOUBLE:
+ case G_TYPE_DOUBLE:
g_free(array->data.data_double);
array->data.data_double = NULL;
break;
- case GTK_TYPE_FLOAT:
+ case G_TYPE_FLOAT:
g_free(array->data.data_float);
array->data.data_float = NULL;
break;
- case GTK_TYPE_INT:
+ case G_TYPE_INT:
g_free(array->data.data_int);
array->data.data_int = NULL;
break;
- case GTK_TYPE_BOOL:
+ case G_TYPE_BOOLEAN:
g_free(array->data.data_bool);
array->data.data_bool = NULL;
break;
- case GTK_TYPE_STRING:
+ case G_TYPE_STRING:
for(i = 0; i < array->size; i++)
if(array->data.data_string && array->data.data_string[i])
g_free(array->data.data_string[i]);
@@ -436,7 +437,7 @@ gtk_plot_array_independent(GtkPlotArray *array)
return array->independent;
}
-GtkType
+GType
gtk_plot_array_get_data_type(GtkPlotArray *array)
{
return array->type;
@@ -463,42 +464,54 @@ gtk_plot_array_get_description(GtkPlotArray *array)
gboolean *
gtk_plot_array_get_bool(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_BOOL) return NULL;
+ if(array->type != G_TYPE_BOOLEAN) return NULL;
return array->data.data_bool;
}
gdouble *
gtk_plot_array_get_double(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_DOUBLE) return NULL;
+ if(array->type != G_TYPE_DOUBLE) return NULL;
return array->data.data_double;
}
gfloat *
gtk_plot_array_get_float(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_FLOAT) return NULL;
+ if(array->type != G_TYPE_FLOAT) return NULL;
return array->data.data_float;
}
gint *
gtk_plot_array_get_int(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_INT) return NULL;
+ if(array->type != G_TYPE_INT) return NULL;
return array->data.data_int;
}
+/**
+ * gtk_plot_array_get_string:
+ * @array: the #GtkPlotArray
+ *
+ * Returns: (transfer none) the data string array
+ */
gchar **
gtk_plot_array_get_string(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_STRING) return NULL;
+ if(array->type != G_TYPE_STRING) return NULL;
return array->data.data_string;
}
+/**
+ * gtk_plot_array_get_pointer:
+ * @array: the #GtkPlotArray
+ *
+ * Returns: (transfer none) the data pointer array
+ */
gpointer *
gtk_plot_array_get_pointer(GtkPlotArray *array)
{
- if(array->type != GTK_TYPE_POINTER) return NULL;
+ if(array->type != G_TYPE_POINTER) return NULL;
return array->data.data_pointer;
}
@@ -523,8 +536,9 @@ gtk_plot_array_list_get_type (void)
NULL
};
- array_list_type = g_type_register_static (G_TYPE_OBJECT, "GtkPlotArrayList",
- &data_info, 0);
+ array_list_type = g_type_register_static (G_TYPE_OBJECT,
+ "GtkPlotArrayList",
+ &data_info, 0);
}
return array_list_type;
}
@@ -611,11 +625,18 @@ gtk_plot_array_list_remove(GtkPlotArrayList *array_list, GtkPlotArray *array)
}
}
+/**
+ * gtk_plot_array_list_get:
+ * @set: a #GtkPlotArrayList
+ * @name: the name to be searched for
+ *
+ * Returns: (transfer none) the named #GtkPlotArray or NULL
+ */
GtkPlotArray *
-gtk_plot_array_list_get(GtkPlotArrayList *array_list, const gchar *name)
+gtk_plot_array_list_get(GtkPlotArrayList *set, const gchar *name)
{
GList *list = NULL;;
- list = find_array(array_list, name);
+ list = find_array(set, name);
if(list) return GTK_PLOT_ARRAY(list->data);
return NULL;
}
diff --git a/gtkextra/gtkplotarray.h b/gtkextra/gtkplotarray.h
index fe16234..fc381e2 100644
--- a/gtkextra/gtkplotarray.h
+++ b/gtkextra/gtkplotarray.h
@@ -24,15 +24,15 @@
extern "C" {
#endif /* __cplusplus */
-#define GTK_PLOT_ARRAY_LIST(obj) GTK_CHECK_CAST (obj, gtk_plot_array_list_get_type (),
GtkPlotArrayList)
-#define GTK_TYPE_PLOT_ARRAY_LIST (gtk_plot_array_list_get_type ())
-#define GTK_PLOT_ARRAY_LIST_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_array_list_get_type(),
GtkPlotArrayListClass)
-#define GTK_IS_PLOT_ARRAY_LIST(obj) GTK_CHECK_TYPE (obj, gtk_plot_array_list_get_type ())
+#define GTK_PLOT_ARRAY_LIST(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_array_list_get_type (),
GtkPlotArrayList)
+#define G_TYPE_PLOT_ARRAY_LIST (gtk_plot_array_list_get_type ())
+#define GTK_PLOT_ARRAY_LIST_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_array_list_get_type(),
GtkPlotArrayListClass)
+#define GTK_IS_PLOT_ARRAY_LIST(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_array_list_get_type ())
-#define GTK_PLOT_ARRAY(obj) GTK_CHECK_CAST (obj, gtk_plot_array_get_type (), GtkPlotArray)
-#define GTK_TYPE_PLOT_ARRAY (gtk_plot_array_get_type ())
-#define GTK_PLOT_ARRAY_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_array_get_type(),
GtkPlotArrayClass)
-#define GTK_IS_PLOT_ARRAY(obj) GTK_CHECK_TYPE (obj, gtk_plot_array_get_type ())
+#define GTK_PLOT_ARRAY(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_array_get_type (), GtkPlotArray)
+#define G_TYPE_PLOT_ARRAY (gtk_plot_array_get_type ())
+#define GTK_PLOT_ARRAY_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_array_get_type(),
GtkPlotArrayClass)
+#define GTK_IS_PLOT_ARRAY(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_array_get_type ())
typedef struct _GtkPlotArrayList GtkPlotArrayList;
typedef struct _GtkPlotArrayListClass GtkPlotArrayListClass;
@@ -49,8 +49,15 @@ typedef union
gpointer *data_pointer;
} GtkPlotArrayArg;
+/**
+ * GtkPlotArrayList:
+ *
+ * The GtkPlotArrayList struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotArrayList
{
+ /*< private >*/
GObject object;
GList *arrays;
@@ -61,7 +68,12 @@ struct _GtkPlotArrayListClass
GObjectClass parent_class;
};
-
+/**
+ * GtkPlotArray:
+ *
+ * The GtkPlotArray struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotArray
{
GObject object;
@@ -71,7 +83,7 @@ struct _GtkPlotArray
gchar *description;
GtkPlotArrayArg data;
- GtkType type;
+ GType type;
gboolean own_data;
gint size;
@@ -91,12 +103,12 @@ GType gtk_plot_array_get_type (void);
GObject* gtk_plot_array_new (const gchar *name,
gpointer array,
gint size,
- GtkType type,
+ GType type,
gboolean own_data);
void gtk_plot_array_set (GtkPlotArray *array,
gpointer data_array,
gint size,
- GtkType type);
+ GType type);
void gtk_plot_array_set_label (GtkPlotArray *array,
const gchar *label);
void gtk_plot_array_set_description (GtkPlotArray *array,
@@ -107,7 +119,7 @@ void gtk_plot_array_set_required (GtkPlotArray *array,
gboolean required);
void gtk_plot_array_set_independent (GtkPlotArray *array,
gboolean independent);
-GtkType gtk_plot_array_get_data_type (GtkPlotArray *array);
+GType gtk_plot_array_get_data_type (GtkPlotArray *array);
const gchar * gtk_plot_array_get_name (GtkPlotArray *array);
const gchar * gtk_plot_array_get_label (GtkPlotArray *array);
const gchar * gtk_plot_array_get_description (GtkPlotArray *array);
diff --git a/gtkextra/gtkplotbar.c b/gtkextra/gtkplotbar.c
index db85ff3..b04fb89 100644
--- a/gtkextra/gtkplotbar.c
+++ b/gtkextra/gtkplotbar.c
@@ -17,6 +17,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotbar
+ * @short_description: 3d scientific plots widget for GTK.
+ *
+ * FIXME:: Need long description.
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -65,26 +73,21 @@ enum {
static GtkPlotDataClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_bar_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotBar",
- sizeof (GtkPlotBar),
- sizeof (GtkPlotBarClass),
- (GtkClassInitFunc) gtk_plot_bar_class_init,
- (GtkObjectInitFunc) gtk_plot_bar_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (gtk_plot_data_get_type(), &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_plot_data_get_type(),
+ "GtkPlotBar",
+ sizeof (GtkPlotBarClass),
+ (GClassInitFunc) gtk_plot_bar_class_init,
+ sizeof (GtkPlotBar),
+ (GInstanceInitFunc) gtk_plot_bar_init,
+ 0);
}
return data_type;
}
@@ -97,7 +100,7 @@ gtk_plot_bar_class_init (GtkPlotBarClass *klass)
GtkPlotDataClass *data_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_data_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_data_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -119,7 +122,8 @@ gtk_plot_bar_class_init (GtkPlotBarClass *klass)
g_param_spec_enum ("orientation",
P_("Orientation"),
P_("Orientation"),
- GTK_TYPE_ORIENTATION, 0,
+ gtk_orientation_get_type (),
+ 0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
data_class->clone = gtk_plot_bar_clone;
@@ -199,18 +203,34 @@ gtk_plot_bar_init (GtkPlotBar *dataset)
dataset->width = .05;
}
+
+/**
+ * gtk_plot_bar_new:
+ * @orientation: GTK_ORIENTATION_HORIZONTAL or GTK_ORIENTATION_VERTICAL.
+ *
+ * Create a new GtkPlotBar widget.
+ *
+ * Return value: a new GtkWidget.
+ */
GtkWidget*
gtk_plot_bar_new (GtkOrientation orientation)
{
GtkWidget *widget;
- widget = gtk_type_new (gtk_plot_bar_get_type ());
+ widget = gtk_widget_new (gtk_plot_bar_get_type (), NULL);
gtk_plot_bar_construct(GTK_PLOT_BAR(widget), orientation);
return (widget);
}
+/**
+ * gtk_plot_bar_construct:
+ * @bar: a #GtkPlotBar widget.
+ * @orientation: GTK_ORIENTATION_HORIZONTAL or GTK_ORIENTATION_VERTICAL.
+ *
+ * Initializes a #GtkPlotBar structure.
+ */
void
gtk_plot_bar_construct(GtkPlotBar *bar, GtkOrientation orientation)
{
@@ -237,14 +257,16 @@ gtk_plot_bar_draw_symbol(GtkPlotData *dataset,
gdouble px, py, px0, py0;
gdouble x1 = 0.0, y1 = 0.0, width = 0.0, height = 0.0;
gdouble ex, ey;
+ GtkAllocation allocation;
bar = GTK_PLOT_BAR(dataset);
plot = dataset->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
@@ -327,19 +349,21 @@ gtk_plot_bar_draw_legend(GtkPlotData *data, gint x, gint y)
GdkRectangle area;
gint lascent, ldescent, lheight, lwidth;
gdouble m;
+ GtkAllocation allocation;
bar = GTK_PLOT_BAR(data);
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- g_return_if_fail(GTK_WIDGET_VISIBLE(data));
- g_return_if_fail(GTK_WIDGET_VISIBLE(data->plot));
+ g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(data)));
+ g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(data->plot)));
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
@@ -389,6 +413,13 @@ gtk_plot_bar_draw_legend(GtkPlotData *data, gint x, gint y)
}
+/**
+ * gtk_plot_bar_set_width:
+ * @bar: a #GtkPlotBar widget.
+ * @width: widget width.
+ *
+ * Set the width of a GtkPlotBar widget.
+ */
void
gtk_plot_bar_set_width (GtkPlotBar *bar, gdouble width)
{
@@ -397,6 +428,14 @@ gtk_plot_bar_set_width (GtkPlotBar *bar, gdouble width)
bar->width = width;
}
+/**
+ * gtk_plot_bar_get_width:
+ * @bar: a #GtkPlotBar widget.
+ *
+ * Set the width of a GtkPlotBar widget.
+ *
+ * Return value: widget width.
+ */
gdouble
gtk_plot_bar_get_width (GtkPlotBar *bar)
{
diff --git a/gtkextra/gtkplotbar.h b/gtkextra/gtkplotbar.h
index 7302594..ffaa132 100644
--- a/gtkextra/gtkplotbar.h
+++ b/gtkextra/gtkplotbar.h
@@ -26,10 +26,10 @@ extern "C" {
#include "gtkplot.h"
-#define GTK_PLOT_BAR(obj) GTK_CHECK_CAST (obj, gtk_plot_bar_get_type (), GtkPlotBar)
-#define GTK_TYPE_PLOT_BAR (gtk_plot_bar_get_type ())
-#define GTK_PLOT_BAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_bar_get_type(), GtkPlotBarClass)
-#define GTK_IS_PLOT_BAR(obj) GTK_CHECK_TYPE (obj, gtk_plot_bar_get_type ())
+#define GTK_PLOT_BAR(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_bar_get_type (), GtkPlotBar)
+#define G_TYPE_PLOT_BAR (gtk_plot_bar_get_type ())
+#define GTK_PLOT_BAR_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_bar_get_type(), GtkPlotBarClass)
+#define GTK_IS_PLOT_BAR(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_bar_get_type ())
typedef struct _GtkPlotBar GtkPlotBar;
typedef struct _GtkPlotBarClass GtkPlotBarClass;
@@ -41,6 +41,12 @@ typedef enum
GTK_PLOT_BAR_ABSOLUTE,
} GtkPlotBarUnits;
+/**
+ * GtkPlotBar:
+ *
+ * The GtkPlotBar struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotBar
{
GtkPlotData data;
@@ -55,7 +61,7 @@ struct _GtkPlotBarClass
};
-GtkType gtk_plot_bar_get_type (void);
+GType gtk_plot_bar_get_type (void);
GtkWidget* gtk_plot_bar_new (GtkOrientation orientation);
void gtk_plot_bar_construct (GtkPlotBar *bar,
diff --git a/gtkextra/gtkplotbox.c b/gtkextra/gtkplotbox.c
index 3b54d05..c6ee1bd 100644
--- a/gtkextra/gtkplotbox.c
+++ b/gtkextra/gtkplotbox.c
@@ -17,11 +17,20 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotbox
+ * @short_description:
+ *
+ * FIXME:: need long description.
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <gtk/gtk.h>
+#include "gtkextra-compat.h"
#include "gtkplot.h"
#include "gtkplot3d.h"
#include "gtkplotdata.h"
@@ -62,26 +71,21 @@ enum {
static GtkPlotDataClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_box_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotBox",
- sizeof (GtkPlotBox),
- sizeof (GtkPlotBoxClass),
- (GtkClassInitFunc) gtk_plot_box_class_init,
- (GtkObjectInitFunc) gtk_plot_box_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (gtk_plot_data_get_type(), &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_plot_data_get_type(),
+ "GtkPlotBox",
+ sizeof (GtkPlotBoxClass),
+ (GClassInitFunc) gtk_plot_box_class_init,
+ sizeof (GtkPlotBox),
+ (GInstanceInitFunc) gtk_plot_box_init,
+ 0);
}
return data_type;
}
@@ -94,7 +98,7 @@ gtk_plot_box_class_init (GtkPlotBoxClass *klass)
GtkPlotDataClass *data_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_data_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_data_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -108,7 +112,8 @@ gtk_plot_box_class_init (GtkPlotBoxClass *klass)
g_param_spec_enum ("orientation",
P_("Orientation"),
P_("Orientation"),
- GTK_TYPE_ORIENTATION, 0,
+ gtk_orientation_get_type (),
+ 0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
data_class->clone = gtk_plot_box_clone;
@@ -180,18 +185,34 @@ gtk_plot_box_init (GtkPlotBox *dataset)
GTK_PLOT_DATA(dataset)->line.color = black;
}
+/**
+ * gtk_plot_box_new:
+ * @orientation: GTK_ORIENTATION_HORIZONTAL or GTK_ORIENTATION_VERTICAL.
+ *
+ * Create a new GtkPlotBox widget.
+ *
+ * Return value: a new GtkWidget.
+ */
+
GtkWidget*
gtk_plot_box_new (GtkOrientation orientation)
{
GtkWidget *widget;
- widget = gtk_type_new (gtk_plot_box_get_type ());
+ widget = gtk_widget_new (gtk_plot_box_get_type (), NULL);
gtk_plot_box_construct(GTK_PLOT_BOX(widget), orientation);
return (widget);
}
+/**
+ * gtk_plot_box_construct:
+ * @box: a #GtkPlotBox widget.
+ * @orientation: GTK_ORIENTATION_HORIZONTAL or GTK_ORIENTATION_VERTICAL.
+ *
+ * Initializes a #GtkPlotBar structure.
+ */
void
gtk_plot_box_construct (GtkPlotBox *box, GtkOrientation orientation)
{
@@ -380,18 +401,20 @@ gtk_plot_box_draw_legend(GtkPlotData *data, gint x, gint y)
GdkRectangle area;
gint lascent, ldescent, lheight, lwidth;
gdouble m;
+ GtkAllocation allocation;
box = GTK_PLOT_BOX(data);
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- g_return_if_fail(GTK_WIDGET_REALIZED(data->plot));
+ //g_return_if_fail(gtk_widget_get_realized(data->plot)); // is this required?? RRR
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
diff --git a/gtkextra/gtkplotbox.h b/gtkextra/gtkplotbox.h
index 23198f7..d269b42 100644
--- a/gtkextra/gtkplotbox.h
+++ b/gtkextra/gtkplotbox.h
@@ -26,14 +26,20 @@ extern "C" {
#include "gtkplot.h"
-#define GTK_PLOT_BOX(obj) GTK_CHECK_CAST (obj, gtk_plot_box_get_type (), GtkPlotBox)
-#define GTK_TYPE_PLOT_BOX (gtk_plot_box_get_type ())
-#define GTK_PLOT_BOX_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_box_get_type(), GtkPlotBoxClass)
-#define GTK_IS_PLOT_BOX(obj) GTK_CHECK_TYPE (obj, gtk_plot_box_get_type ())
+#define GTK_PLOT_BOX(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_box_get_type (), GtkPlotBox)
+#define G_TYPE_PLOT_BOX (gtk_plot_box_get_type ())
+#define GTK_PLOT_BOX_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_box_get_type(), GtkPlotBoxClass)
+#define GTK_IS_PLOT_BOX(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_box_get_type ())
typedef struct _GtkPlotBox GtkPlotBox;
typedef struct _GtkPlotBoxClass GtkPlotBoxClass;
+/**
+ * GtkPlotBox:
+ *
+ * The GtkPlotBox struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotBox
{
GtkPlotData data;
@@ -47,7 +53,7 @@ struct _GtkPlotBoxClass
};
-GtkType gtk_plot_box_get_type (void);
+GType gtk_plot_box_get_type (void);
GtkWidget* gtk_plot_box_new (GtkOrientation orientation);
void gtk_plot_box_construct (GtkPlotBox *box,
GtkOrientation orientation);
diff --git a/gtkextra/gtkplotcanvasellipse.c b/gtkextra/gtkplotcanvasellipse.c
index e4999a2..0dd6379 100644
--- a/gtkextra/gtkplotcanvasellipse.c
+++ b/gtkextra/gtkplotcanvasellipse.c
@@ -17,6 +17,7 @@
* Boston, MA 02111-1307, USA.
*/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -28,6 +29,14 @@
#include "gtkplotgdk.h"
#include "gtkplotps.h"
+/**
+ * SECTION: gtkplotcanvasellipse
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
+
#define DEFAULT_MARKER_SIZE 6
#define P_(string) string
@@ -65,26 +74,21 @@ static void gtk_plot_canvas_ellipse_set_property(GObject *object,
extern inline gint roundint (gdouble x);
static GtkPlotCanvasChildClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_canvas_ellipse_get_type (void)
{
- static GtkType plot_canvas_ellipse_type = 0;
+ static GType plot_canvas_ellipse_type = 0;
if (!plot_canvas_ellipse_type)
{
- GtkTypeInfo plot_canvas_ellipse_info =
- {
- "GtkPlotCanvasEllipse",
- sizeof (GtkPlotCanvasEllipse),
- sizeof (GtkPlotCanvasEllipseClass),
- (GtkClassInitFunc) gtk_plot_canvas_ellipse_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_ellipse_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_ellipse_type = gtk_type_unique (gtk_plot_canvas_child_get_type(),
&plot_canvas_ellipse_info);
+ plot_canvas_ellipse_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasEllipse",
+ sizeof (GtkPlotCanvasEllipseClass),
+ (GClassInitFunc) gtk_plot_canvas_ellipse_class_init,
+ sizeof (GtkPlotCanvasEllipse),
+ (GInstanceInitFunc) gtk_plot_canvas_ellipse_init,
+ 0);
}
return plot_canvas_ellipse_type;
}
@@ -98,7 +102,7 @@ gtk_plot_canvas_ellipse_new (GtkPlotLineStyle style,
{
GtkPlotCanvasEllipse *ellipse;
- ellipse = gtk_type_new (gtk_plot_canvas_ellipse_get_type ());
+ ellipse = g_object_new (gtk_plot_canvas_ellipse_get_type (), NULL);
ellipse->line.line_width = width;
if(fg) ellipse->line.color = *fg;
@@ -124,7 +128,7 @@ gtk_plot_canvas_ellipse_class_init (GtkPlotCanvasChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
klass->draw = gtk_plot_canvas_ellipse_draw;
klass->move = gtk_plot_canvas_ellipse_move;
@@ -133,13 +137,25 @@ gtk_plot_canvas_ellipse_class_init (GtkPlotCanvasChildClass *klass)
gobject_class->get_property = gtk_plot_canvas_ellipse_get_property;
gobject_class->set_property = gtk_plot_canvas_ellipse_set_property;
-
+
+
+ /**
+ * GtkPlotCanvasEllipse:line:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE,
g_param_spec_pointer ("line",
P_("Line"),
P_("Line Attributes"),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasEllipse:filled:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_FILLED,
g_param_spec_boolean ("filled",
@@ -147,6 +163,12 @@ gtk_plot_canvas_ellipse_class_init (GtkPlotCanvasChildClass *klass)
P_("Fill Figure"),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasEllipse:color_bg:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_BG,
g_param_spec_pointer ("color_bg",
@@ -227,7 +249,7 @@ 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,
@@ -240,17 +262,17 @@ gtk_plot_canvas_ellipse_select(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child,
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 |
GDK_GC_SUBWINDOW);
- gdk_draw_rectangle (GTK_WIDGET(canvas)->window,
+ gdk_draw_rectangle (gtk_widget_get_window(GTK_WIDGET(canvas)),
xor_gc,
FALSE,
area.x, area.y,
@@ -271,7 +293,7 @@ gtk_plot_canvas_ellipse_select(GtkPlotCanvas *canvas, GtkPlotCanvasChild *child,
}
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
- gdk_draw_arc (GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_arc (gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
FALSE,
roundint(area.x), roundint(area.y),
roundint(area.width), roundint(area.height), 0, 25000);
@@ -297,6 +319,17 @@ gtk_plot_canvas_ellipse_resize (GtkPlotCanvas *canvas,
return;
}
+/**
+ * gtk_plot_canvas_ellipse_set_attributes:
+ * @ellipse: a #GtkPlotCanvasEllipse widget.
+ * @style:
+ * @width:
+ * @fg:
+ * @bg:
+ * @fill:
+ *
+ *
+ */
void
gtk_plot_canvas_ellipse_set_attributes (GtkPlotCanvasEllipse *ellipse,
GtkPlotLineStyle style,
diff --git a/gtkextra/gtkplotcanvasellipse.h b/gtkextra/gtkplotcanvasellipse.h
index 1c1e5d3..2166759 100644
--- a/gtkextra/gtkplotcanvasellipse.h
+++ b/gtkextra/gtkplotcanvasellipse.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_ELLIPSE_H__
#define __GTK_PLOT_CANVAS_ELLIPSE_H__
-#define GTK_PLOT_CANVAS_ELLIPSE(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_ellipse_get_type (),
GtkPlotCanvasEllipse)
-#define GTK_PLOT_CANVAS_ELLIPSE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass,
gtk_plot_canvas_ellipse_get_type(), GtkPlotCanvasEllipseClass)
-#define GTK_IS_PLOT_CANVAS_ELLIPSE(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_ellipse_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_ELLIPSE (gtk_plot_canvas_ellipse_get_type ())
+#define GTK_PLOT_CANVAS_ELLIPSE(obj) G_TYPE_CHECK_INSTANCE_CAST (obj,
gtk_plot_canvas_ellipse_get_type (), GtkPlotCanvasEllipse)
+#define GTK_PLOT_CANVAS_ELLIPSE_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass,
gtk_plot_canvas_ellipse_get_type(), GtkPlotCanvasEllipseClass)
+#define GTK_IS_PLOT_CANVAS_ELLIPSE(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj,
gtk_plot_canvas_ellipse_get_type ())
+#define G_TYPE_PLOT_CANVAS_ELLIPSE (gtk_plot_canvas_ellipse_get_type ())
#include <gdk/gdk.h>
@@ -36,6 +36,12 @@ extern "C" {
typedef struct _GtkPlotCanvasEllipse GtkPlotCanvasEllipse;
typedef struct _GtkPlotCanvasEllipseClass GtkPlotCanvasEllipseClass;
+/**
+ * GtkPlotCanvasEllipse:
+ *
+ * The GtkPlotCanvasEllipse struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasEllipse
{
GtkPlotCanvasChild parent;
@@ -51,7 +57,7 @@ struct _GtkPlotCanvasEllipseClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_ellipse_get_type (void);
+GType gtk_plot_canvas_ellipse_get_type (void);
GtkPlotCanvasChild *
gtk_plot_canvas_ellipse_new (GtkPlotLineStyle style,
gfloat width,
diff --git a/gtkextra/gtkplotcanvasline.c b/gtkextra/gtkplotcanvasline.c
index 042b453..39cd495 100644
--- a/gtkextra/gtkplotcanvasline.c
+++ b/gtkextra/gtkplotcanvasline.c
@@ -17,6 +17,7 @@
* Boston, MA 02111-1307, USA.
*/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -28,6 +29,14 @@
#include "gtkplotgdk.h"
#include "gtkplotps.h"
+/**
+ * SECTION: gtkplotcanvasline
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
+
#define DEFAULT_MARKER_SIZE 6
#define P(string) string
@@ -79,26 +88,21 @@ static void gtk_plot_canvas_line_set_property(GObject *object,
static GtkPlotCanvasChildClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_canvas_line_get_type (void)
{
- static GtkType plot_canvas_line_type = 0;
+ static GType plot_canvas_line_type = 0;
if (!plot_canvas_line_type)
{
- GtkTypeInfo plot_canvas_line_info =
- {
- "GtkPlotCanvasLine",
- sizeof (GtkPlotCanvasLine),
- sizeof (GtkPlotCanvasLineClass),
- (GtkClassInitFunc) gtk_plot_canvas_line_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_line_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_line_type = gtk_type_unique (gtk_plot_canvas_child_get_type(), &plot_canvas_line_info);
+ plot_canvas_line_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasLine",
+ sizeof (GtkPlotCanvasLineClass),
+ (GClassInitFunc) gtk_plot_canvas_line_class_init,
+ sizeof (GtkPlotCanvasLine),
+ (GInstanceInitFunc) gtk_plot_canvas_line_init,
+ 0);
}
return plot_canvas_line_type;
}
@@ -111,7 +115,7 @@ gtk_plot_canvas_line_new (GtkPlotLineStyle style,
{
GtkPlotCanvasLine *line;
- line = gtk_type_new (gtk_plot_canvas_line_get_type ());
+ line = g_object_new (gtk_plot_canvas_line_get_type (), NULL);
line->line.line_width = width;
if(color) line->line.color = *color;
@@ -140,7 +144,7 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
klass->draw = gtk_plot_canvas_line_draw;
klass->draw_selection = gtk_plot_canvas_line_draw_selection;
@@ -152,13 +156,25 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
gobject_class->get_property = gtk_plot_canvas_line_get_property;
gobject_class->set_property = gtk_plot_canvas_line_set_property;
-
+
+
+ /**
+ * GtkPlotCanvasLine:line:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE,
g_param_spec_pointer ("line",
P("Line Attributes"),
P("Line Attributes"),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:x1:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_X1,
g_param_spec_double ("x1",
@@ -166,6 +182,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Coordinate X of the first point"),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:y1:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_Y1,
g_param_spec_double ("y1",
@@ -173,6 +195,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Coordinate Y of the first point"),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:x2:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_X2,
g_param_spec_double ("x2",
@@ -180,6 +208,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Coordinate X of the second point"),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:y2:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_Y2,
g_param_spec_double ("y2",
@@ -187,6 +221,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Coordinate Y of the second point"),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:pos:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_POS,
g_param_spec_int ("pos",
@@ -194,6 +234,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:arrow_mask:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ARROW_MASK,
g_param_spec_int ("arrow_mask",
@@ -201,6 +247,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Arrow Mask"),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:arrow_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ARROW_WIDTH,
g_param_spec_int ("arrow_width",
@@ -208,6 +260,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Arrow Width"),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:arrow_length:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ARROW_LENGTH,
g_param_spec_int ("arrow_length",
@@ -215,6 +273,12 @@ gtk_plot_canvas_line_class_init (GtkPlotCanvasChildClass *klass)
P("Arrow Length"),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasLine:arrow_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ARROW_STYLE,
g_param_spec_int ("arrow_style",
@@ -397,11 +461,11 @@ gtk_plot_canvas_line_draw_selection (GtkPlotCanvas *canvas,
dx = canvas->pointer_x - canvas->drag_x;
dy = canvas->pointer_y - canvas->drag_y;
- 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 |
@@ -411,47 +475,55 @@ gtk_plot_canvas_line_draw_selection (GtkPlotCanvas *canvas,
gtk_plot_canvas_get_pixel(canvas, line->x2, line->y2, &x2, &y2);
if(line->pos == GTK_PLOT_CANVAS_TOP_LEFT){
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
- x2 - DEFAULT_MARKER_SIZE / 2,
- y2 - DEFAULT_MARKER_SIZE / 2,
- DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
-
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
+ x2 - DEFAULT_MARKER_SIZE / 2,
+ y2 - DEFAULT_MARKER_SIZE / 2,
+ DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
+
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
x1 + dx - DEFAULT_MARKER_SIZE / 2,
y1 + dy - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc, x2, y2, x1 + dx, y1 + dy);
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, x2, y2, x1 + dx, y1 + dy);
} else if(line->pos == GTK_PLOT_CANVAS_BOTTOM_RIGHT){
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
x1 - DEFAULT_MARKER_SIZE / 2,
y1 - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
x2 + dx - DEFAULT_MARKER_SIZE / 2,
y2 + dy - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc, x1, y1, x2 + dx, y2 + dy);
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, x1, y1, x2 + dx, y2 + dy);
} else {
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
x1 + dx - DEFAULT_MARKER_SIZE / 2,
y1 + dy - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
- gdk_draw_rectangle(GTK_WIDGET(canvas)->window, xor_gc, TRUE,
+ gdk_draw_rectangle(gtk_widget_get_window(GTK_WIDGET(canvas)),
+ xor_gc, TRUE,
x2 + dx - DEFAULT_MARKER_SIZE / 2,
y2 + dy - DEFAULT_MARKER_SIZE / 2,
DEFAULT_MARKER_SIZE + 1, DEFAULT_MARKER_SIZE + 1);
gdk_gc_set_line_attributes(xor_gc, 1, 1, 0, 0);
- gdk_draw_line(GTK_WIDGET(canvas)->window, xor_gc,
+ gdk_draw_line(gtk_widget_get_window(GTK_WIDGET(canvas)), xor_gc,
x1 + dx, y1 + dy, x2 + dx, y2 + dy);
}
@@ -581,6 +653,15 @@ gtk_plot_canvas_line_button_release (GtkPlotCanvas *canvas,
gtk_plot_canvas_refresh(canvas);
}
+/**
+ * gtk_plot_canvas_line_set_attributes:
+ * @line: a #GtkPlotCanvasLine widget.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_canvas_line_set_attributes(GtkPlotCanvasLine *line,
GtkPlotLineStyle style,
@@ -592,6 +673,16 @@ gtk_plot_canvas_line_set_attributes(GtkPlotCanvasLine *line,
line->line.line_style = style;
}
+/**
+ * gtk_plot_canvas_line_set_arrow:
+ * @line: a #GtkPlotCanvasLine widget.
+ * @style:
+ * @width:
+ * @length:
+ * @mask:
+ *
+ *
+ */
void
gtk_plot_canvas_line_set_arrow(GtkPlotCanvasLine *line,
GtkPlotSymbolStyle style,
diff --git a/gtkextra/gtkplotcanvasline.h b/gtkextra/gtkplotcanvasline.h
index 3d6cad2..11dca3d 100644
--- a/gtkextra/gtkplotcanvasline.h
+++ b/gtkextra/gtkplotcanvasline.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_LINE_H__
#define __GTK_PLOT_CANVAS_LINE_H__
-#define GTK_PLOT_CANVAS_LINE(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_line_get_type (),
GtkPlotCanvasLine)
-#define GTK_PLOT_CANVAS_LINE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_line_get_type(),
GtkPlotCanvasLineClass)
-#define GTK_IS_PLOT_CANVAS_LINE(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_line_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_LINE (gtk_plot_canvas_line_get_type ())
+#define GTK_PLOT_CANVAS_LINE(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_line_get_type (),
GtkPlotCanvasLine)
+#define GTK_PLOT_CANVAS_LINE_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_canvas_line_get_type(),
GtkPlotCanvasLineClass)
+#define GTK_IS_PLOT_CANVAS_LINE(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_line_get_type ())
+#define G_TYPE_PLOT_CANVAS_LINE (gtk_plot_canvas_line_get_type ())
#include <gdk/gdk.h>
@@ -43,8 +43,15 @@ typedef enum
GTK_PLOT_CANVAS_ARROW_END = 1 << 1
} GtkPlotCanvasArrow;
+/**
+ * GtkPlotCanvasLine:
+ *
+ * The GtkPlotCanvasLine struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasLine
{
+ /*< private >*/
GtkPlotCanvasChild parent;
GtkPlotLine line;
@@ -63,7 +70,7 @@ struct _GtkPlotCanvasLineClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_line_get_type (void);
+GType gtk_plot_canvas_line_get_type (void);
GtkPlotCanvasChild *
gtk_plot_canvas_line_new (GtkPlotLineStyle style,
gfloat width,
diff --git a/gtkextra/gtkplotcanvaspixmap.c b/gtkextra/gtkplotcanvaspixmap.c
index 4399a30..9d84baa 100644
--- a/gtkextra/gtkplotcanvaspixmap.c
+++ b/gtkextra/gtkplotcanvaspixmap.c
@@ -17,6 +17,7 @@
* Boston, MA 02111-1307, USA.
*/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -28,6 +29,13 @@
#include "gtkplotgdk.h"
#include "gtkplotps.h"
+/**
+ * SECTION: gtkplotcanvaspixmap
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
#define P_(string) string
enum {
@@ -59,36 +67,40 @@ static void gtk_plot_canvas_pixmap_set_property(GObject *object,
static GtkPlotCanvasChildClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_canvas_pixmap_get_type (void)
{
- static GtkType plot_canvas_pixmap_type = 0;
+ static GType plot_canvas_pixmap_type = 0;
if (!plot_canvas_pixmap_type)
{
- GtkTypeInfo plot_canvas_pixmap_info =
- {
- "GtkPlotCanvasPixmap",
- sizeof (GtkPlotCanvasPixmap),
- sizeof (GtkPlotCanvasPixmapClass),
- (GtkClassInitFunc) gtk_plot_canvas_pixmap_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_pixmap_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_pixmap_type = gtk_type_unique (gtk_plot_canvas_child_get_type(), &plot_canvas_pixmap_info);
+ plot_canvas_pixmap_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasPixmap",
+ sizeof (GtkPlotCanvasPixmapClass),
+ (GClassInitFunc) gtk_plot_canvas_pixmap_class_init,
+ sizeof (GtkPlotCanvasPixmap),
+ (GInstanceInitFunc) gtk_plot_canvas_pixmap_init,
+ 0);
}
return plot_canvas_pixmap_type;
}
+/**
+ * gtk_plot_canvas_pixmap_new:
+ * @_pixmap: a GdkPixmap.
+ * @mask:
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotCanvasChild*
gtk_plot_canvas_pixmap_new (GdkPixmap *_pixmap, GdkBitmap *mask)
{
GtkPlotCanvasPixmap *pixmap;
- pixmap = gtk_type_new (gtk_plot_canvas_pixmap_get_type ());
+ pixmap = g_object_new (gtk_plot_canvas_pixmap_get_type (), NULL);
pixmap->pixmap = _pixmap;
pixmap->mask = mask;
@@ -123,7 +135,7 @@ gtk_plot_canvas_pixmap_class_init (GtkPlotCanvasChildClass *klass)
GtkObjectClass *object_class = (GtkObjectClass *)klass;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
object_class->destroy = gtk_plot_canvas_pixmap_destroy;
@@ -194,7 +206,7 @@ gtk_plot_canvas_pixmap_draw (GtkPlotCanvas *canvas,
{
GtkPlotCanvasPixmap *pixmap = GTK_PLOT_CANVAS_PIXMAP(child);
- g_return_if_fail(GTK_WIDGET_VISIBLE(GTK_WIDGET(canvas)));
+ g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(canvas)));
if(pixmap->pixmap){
gdouble scale_x, scale_y;
diff --git a/gtkextra/gtkplotcanvaspixmap.h b/gtkextra/gtkplotcanvaspixmap.h
index dc07c28..4ac9321 100644
--- a/gtkextra/gtkplotcanvaspixmap.h
+++ b/gtkextra/gtkplotcanvaspixmap.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_PIXMAP_H__
#define __GTK_PLOT_CANVAS_PIXMAP_H__
-#define GTK_PLOT_CANVAS_PIXMAP(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_pixmap_get_type (),
GtkPlotCanvasPixmap)
-#define GTK_PLOT_CANVAS_PIXMAP_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_pixmap_get_type(),
GtkPlotCanvasPixmapClass)
-#define GTK_IS_PLOT_CANVAS_PIXMAP(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_pixmap_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_PIXMAP (gtk_plot_canvas_pixmap_get_type ())
+#define GTK_PLOT_CANVAS_PIXMAP(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_pixmap_get_type
(), GtkPlotCanvasPixmap)
+#define GTK_PLOT_CANVAS_PIXMAP_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass,
gtk_plot_canvas_pixmap_get_type(), GtkPlotCanvasPixmapClass)
+#define GTK_IS_PLOT_CANVAS_PIXMAP(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_pixmap_get_type
())
+#define G_TYPE_PLOT_CANVAS_PIXMAP (gtk_plot_canvas_pixmap_get_type ())
#include <gdk/gdk.h>
@@ -36,6 +36,12 @@ extern "C" {
typedef struct _GtkPlotCanvasPixmap GtkPlotCanvasPixmap;
typedef struct _GtkPlotCanvasPixmapClass GtkPlotCanvasPixmapClass;
+/**
+ * GtkPlotCanvasPixmap:
+ *
+ * The GtkPlotCanvasPixmap struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasPixmap
{
GtkPlotCanvasChild parent;
@@ -49,9 +55,9 @@ struct _GtkPlotCanvasPixmapClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_pixmap_get_type (void);
+GType gtk_plot_canvas_pixmap_get_type (void);
GtkPlotCanvasChild *
- gtk_plot_canvas_pixmap_new(GdkPixmap *pixmap, GdkBitmap *mask);
+ gtk_plot_canvas_pixmap_new(GdkPixmap *_pixmap, GdkBitmap *mask);
#ifdef __cplusplus
}
diff --git a/gtkextra/gtkplotcanvasplot.c b/gtkextra/gtkplotcanvasplot.c
index 92a1d66..92b9cf1 100644
--- a/gtkextra/gtkplotcanvasplot.c
+++ b/gtkextra/gtkplotcanvasplot.c
@@ -17,6 +17,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotcanvasplot
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -65,36 +73,39 @@ static GtkPlotCanvasChildClass *parent_class = NULL;
extern GtkPlotCanvasPos possible_selection (GtkAllocation area,
gint x, gint y);
-GtkType
+GType
gtk_plot_canvas_plot_get_type (void)
{
- static GtkType plot_canvas_plot_type = 0;
+ static GType plot_canvas_plot_type = 0;
if (!plot_canvas_plot_type)
{
- GtkTypeInfo plot_canvas_plot_info =
- {
- "GtkPlotCanvasPlot",
- sizeof (GtkPlotCanvasPlot),
- sizeof (GtkPlotCanvasPlotClass),
- (GtkClassInitFunc) gtk_plot_canvas_plot_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_plot_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_plot_type = gtk_type_unique (gtk_plot_canvas_child_get_type(), &plot_canvas_plot_info);
+ plot_canvas_plot_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasPlot",
+ sizeof (GtkPlotCanvasPlotClass),
+ (GClassInitFunc) gtk_plot_canvas_plot_class_init,
+ sizeof (GtkPlotCanvasPlot),
+ (GInstanceInitFunc) gtk_plot_canvas_plot_init,
+ 0);
}
return plot_canvas_plot_type;
}
+/**
+ * gtk_plot_canvas_plot_new:
+ * @plot: a #GtkPlot.
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotCanvasChild*
gtk_plot_canvas_plot_new (GtkPlot *plot)
{
GtkPlotCanvasPlot *child;
- child = gtk_type_new (gtk_plot_canvas_plot_get_type ());
+ child = g_object_new (gtk_plot_canvas_plot_get_type (), NULL);
child->plot = plot;
return GTK_PLOT_CANVAS_CHILD (child);
@@ -117,7 +128,7 @@ gtk_plot_canvas_plot_class_init (GtkPlotCanvasChildClass *klass)
{
GtkObjectClass *object_class = (GtkObjectClass *)klass;
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
klass->draw = gtk_plot_canvas_plot_draw;
klass->move = gtk_plot_canvas_plot_move;
@@ -135,7 +146,7 @@ static void
gtk_plot_canvas_plot_destroy(GtkObject *object)
{
GtkWidget *widget = GTK_WIDGET(GTK_PLOT_CANVAS_PLOT(object)->plot);
- gtk_widget_unref(widget);
+ g_object_unref(widget);
widget->parent = NULL;
}
@@ -149,14 +160,16 @@ gtk_plot_canvas_plot_draw (GtkPlotCanvas *canvas,
gint height = child->allocation.height;
gdouble m = canvas->magnification;
GtkPlotPC *pc;
+ GtkAllocation allocation;
if(width == 0 && height == 0) return;
gtk_plot_set_drawable(plot, canvas->pixmap);
- GTK_WIDGET(plot)->allocation.x = 0;
- GTK_WIDGET(plot)->allocation.y = 0;
- GTK_WIDGET(plot)->allocation.width = canvas->pixmap_width;
- GTK_WIDGET(plot)->allocation.height = canvas->pixmap_height;
+ allocation.x = 0;
+ allocation.y = 0;
+ allocation.width = canvas->pixmap_width;
+ allocation.height = canvas->pixmap_height;
+ gtk_widget_set_allocation(GTK_WIDGET(plot), &allocation);
gtk_plot_set_magnification(plot, m);
reset_plot_allocation(canvas, plot_child);
@@ -374,16 +387,18 @@ static void
gtk_plot_canvas_plot_size_allocate (GtkPlotCanvas *canvas,
GtkPlotCanvasChild *child)
{
+ GtkAllocation allocation;
GtkPlot *plot = GTK_PLOT_CANVAS_PLOT(child)->plot;
if(!plot) return;
switch(GTK_PLOT_CANVAS_PLOT(child)->pos){
case GTK_PLOT_CANVAS_PLOT_IN_PLOT:
case GTK_PLOT_CANVAS_PLOT_OUT:
- GTK_WIDGET(plot)->allocation.x = 0;
- GTK_WIDGET(plot)->allocation.y = 0;
- GTK_WIDGET(plot)->allocation.width = canvas->pixmap_width;
- GTK_WIDGET(plot)->allocation.height = canvas->pixmap_height;
+ allocation.x = 0;
+ allocation.y = 0;
+ allocation.width = canvas->pixmap_width;
+ allocation.height = canvas->pixmap_height;
+ gtk_widget_set_allocation(GTK_WIDGET(plot), &allocation);
if(!GTK_WIDGET(plot)->parent)
gtk_widget_set_parent(GTK_WIDGET(plot), GTK_WIDGET(canvas));
diff --git a/gtkextra/gtkplotcanvasplot.h b/gtkextra/gtkplotcanvasplot.h
index d22ae26..f5a9101 100644
--- a/gtkextra/gtkplotcanvasplot.h
+++ b/gtkextra/gtkplotcanvasplot.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_PLOT_H__
#define __GTK_PLOT_CANVAS_PLOT_H__
-#define GTK_PLOT_CANVAS_PLOT(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_plot_get_type (),
GtkPlotCanvasPlot)
-#define GTK_PLOT_CANVAS_PLOT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_plot_get_type(),
GtkPlotCanvasPlotClass)
-#define GTK_IS_PLOT_CANVAS_PLOT(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_plot_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_PLOT (gtk_plot_canvas_plot_get_type ())
+#define GTK_PLOT_CANVAS_PLOT(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_plot_get_type (),
GtkPlotCanvasPlot)
+#define GTK_PLOT_CANVAS_PLOT_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_canvas_plot_get_type(),
GtkPlotCanvasPlotClass)
+#define GTK_IS_PLOT_CANVAS_PLOT(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_plot_get_type ())
+#define G_TYPE_PLOT_CANVAS_PLOT (gtk_plot_canvas_plot_get_type ())
#define GTK_PLOT_CANVAS_PLOT_SELECT_POINT(plot) (plot->flags & GTK_PLOT_CANVAS_PLOT_SELECT_POINT)
#define GTK_PLOT_CANVAS_PLOT_DND_POINT(plot) (plot->flags & GTK_PLOT_CANVAS_PLOT_DND_POINT)
#define GTK_PLOT_CANVAS_PLOT_FLAGS(plot) (GTK_PLOT_CANVAS_PLOT(plot)->flags)
@@ -62,6 +62,12 @@ enum
GTK_PLOT_CANVAS_PLOT_DND_POINT = 1 << 1, /* DnD point */
};
+/**
+ * GtkPlotCanvasPlot:
+ *
+ * The GtkPlotBar struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasPlot
{
GtkPlotCanvasChild parent;
@@ -83,7 +89,7 @@ struct _GtkPlotCanvasPlotClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_plot_get_type (void);
+GType gtk_plot_canvas_plot_get_type (void);
GtkPlotCanvasChild *
gtk_plot_canvas_plot_new (GtkPlot *plot);
diff --git a/gtkextra/gtkplotcanvasrectangle.c b/gtkextra/gtkplotcanvasrectangle.c
index 56815bf..6c32d76 100644
--- a/gtkextra/gtkplotcanvasrectangle.c
+++ b/gtkextra/gtkplotcanvasrectangle.c
@@ -17,6 +17,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotcanvasrectangle
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -63,26 +71,21 @@ static void gtk_plot_canvas_rectangle_set_property(GObject *object,
extern inline gint roundint (gdouble x);
static GtkPlotCanvasChildClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_canvas_rectangle_get_type (void)
{
- static GtkType plot_canvas_rectangle_type = 0;
+ static GType plot_canvas_rectangle_type = 0;
if (!plot_canvas_rectangle_type)
{
- GtkTypeInfo plot_canvas_rectangle_info =
- {
- "GtkPlotCanvasRectangle",
- sizeof (GtkPlotCanvasRectangle),
- sizeof (GtkPlotCanvasRectangleClass),
- (GtkClassInitFunc) gtk_plot_canvas_rectangle_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_rectangle_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_rectangle_type = gtk_type_unique (gtk_plot_canvas_child_get_type(),
&plot_canvas_rectangle_info);
+ plot_canvas_rectangle_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasRectangle",
+ sizeof (GtkPlotCanvasRectangleClass),
+ (GClassInitFunc) gtk_plot_canvas_rectangle_class_init,
+ sizeof (GtkPlotCanvasRectangle),
+ (GInstanceInitFunc) gtk_plot_canvas_rectangle_init,
+ 0);
}
return plot_canvas_rectangle_type;
}
@@ -151,7 +154,7 @@ gtk_plot_canvas_rectangle_new (GtkPlotLineStyle style,
{
GtkPlotCanvasRectangle *rectangle;
- rectangle = gtk_type_new (gtk_plot_canvas_rectangle_get_type ());
+ rectangle = g_object_new (gtk_plot_canvas_rectangle_get_type (), NULL);
rectangle->line.line_width = width;
if(fg) rectangle->line.color = *fg;
@@ -180,7 +183,7 @@ gtk_plot_canvas_rectangle_class_init (GtkPlotCanvasChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
klass->draw = gtk_plot_canvas_rectangle_draw;
klass->move = gtk_plot_canvas_rectangle_move;
@@ -188,13 +191,25 @@ gtk_plot_canvas_rectangle_class_init (GtkPlotCanvasChildClass *klass)
gobject_class->get_property = gtk_plot_canvas_rectangle_get_property;
gobject_class->set_property = gtk_plot_canvas_rectangle_set_property;
-
+
+
+ /**
+ * GtkPlotCanvasRectangle:line:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE,
g_param_spec_pointer ("line",
P_("Line Attributes"),
P_("Line Attributes"),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasRectangle:filled:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_FILLED,
g_param_spec_boolean ("filled",
@@ -202,6 +217,12 @@ gtk_plot_canvas_rectangle_class_init (GtkPlotCanvasChildClass *klass)
P_("Fill Figure"),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasRectangle:border:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_BORDER,
g_param_spec_int ("border",
@@ -209,6 +230,12 @@ gtk_plot_canvas_rectangle_class_init (GtkPlotCanvasChildClass *klass)
P_("Border Width"),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasRectangle:shadow_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHADOW_WIDTH,
g_param_spec_int ("shadow_width",
@@ -216,6 +243,12 @@ gtk_plot_canvas_rectangle_class_init (GtkPlotCanvasChildClass *klass)
P_("Shadow Width"),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCanvasRectangle:color_bg:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_BG,
g_param_spec_pointer ("color_bg",
@@ -279,6 +312,18 @@ gtk_plot_canvas_rectangle_resize (GtkPlotCanvas *canvas,
return;
}
+/**
+ * gtk_plot_canvas_rectangle_set_attributes:
+ * @rectangle: a #GtkPlotCanvasRectangle
+ * @style:
+ * @width:
+ * @fg:
+ * @bg:
+ * @border:
+ * @fill:
+ *
+ *
+ */
void
gtk_plot_canvas_rectangle_set_attributes(GtkPlotCanvasRectangle *rectangle,
GtkPlotLineStyle style,
diff --git a/gtkextra/gtkplotcanvasrectangle.h b/gtkextra/gtkplotcanvasrectangle.h
index e30e615..b5196e9 100644
--- a/gtkextra/gtkplotcanvasrectangle.h
+++ b/gtkextra/gtkplotcanvasrectangle.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_RECTANGLE_H__
#define __GTK_PLOT_CANVAS_RECTANGLE_H__
-#define GTK_PLOT_CANVAS_RECTANGLE(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_rectangle_get_type (),
GtkPlotCanvasRectangle)
-#define GTK_PLOT_CANVAS_RECTANGLE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass,
gtk_plot_canvas_rectangle_get_type(), GtkPlotCanvasRectangleClass)
-#define GTK_IS_PLOT_CANVAS_RECTANGLE(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_rectangle_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_RECTANGLE (gtk_plot_canvas_rectangle_get_type ())
+#define GTK_PLOT_CANVAS_RECTANGLE(obj) G_TYPE_CHECK_INSTANCE_CAST (obj,
gtk_plot_canvas_rectangle_get_type (), GtkPlotCanvasRectangle)
+#define GTK_PLOT_CANVAS_RECTANGLE_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass,
gtk_plot_canvas_rectangle_get_type(), GtkPlotCanvasRectangleClass)
+#define GTK_IS_PLOT_CANVAS_RECTANGLE(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj,
gtk_plot_canvas_rectangle_get_type ())
+#define G_TYPE_PLOT_CANVAS_RECTANGLE (gtk_plot_canvas_rectangle_get_type ())
#include <gdk/gdk.h>
@@ -36,6 +36,12 @@ extern "C" {
typedef struct _GtkPlotCanvasRectangle GtkPlotCanvasRectangle;
typedef struct _GtkPlotCanvasRectangleClass GtkPlotCanvasRectangleClass;
+/**
+ * GtkPlotCanvasRectangle:
+ *
+ * The GtkPlotCanvasRectangle struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasRectangle
{
GtkPlotCanvasChild parent;
@@ -54,7 +60,7 @@ struct _GtkPlotCanvasRectangleClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_rectangle_get_type (void);
+GType gtk_plot_canvas_rectangle_get_type (void);
GtkPlotCanvasChild *
gtk_plot_canvas_rectangle_new (GtkPlotLineStyle style,
gfloat width,
diff --git a/gtkextra/gtkplotcanvastext.c b/gtkextra/gtkplotcanvastext.c
index 67893a2..61b2db6 100644
--- a/gtkextra/gtkplotcanvastext.c
+++ b/gtkextra/gtkplotcanvastext.c
@@ -17,6 +17,7 @@
* Boston, MA 02111-1307, USA.
*/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -28,6 +29,13 @@
#include "gtkplotgdk.h"
#include "gtkplotps.h"
+/**
+ * SECTION: gtkplotcanvastext
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
static gchar DEFAULT_FONT[] = "Helvetica";
#define DEFAULT_FONT_HEIGHT 12
#define P_(string) string
@@ -56,30 +64,40 @@ static void gtk_plot_canvas_text_set_property(GObject *object,
extern inline gint roundint (gdouble x);
static GtkPlotCanvasChildClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_canvas_text_get_type (void)
{
- static GtkType plot_canvas_text_type = 0;
+ static GType plot_canvas_text_type = 0;
if (!plot_canvas_text_type)
{
- GtkTypeInfo plot_canvas_text_info =
- {
- "GtkPlotCanvasText",
- sizeof (GtkPlotCanvasText),
- sizeof (GtkPlotCanvasTextClass),
- (GtkClassInitFunc) gtk_plot_canvas_text_class_init,
- (GtkObjectInitFunc) gtk_plot_canvas_text_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_canvas_text_type = gtk_type_unique (gtk_plot_canvas_child_get_type(), &plot_canvas_text_info);
+ plot_canvas_text_type = g_type_register_static_simple (
+ gtk_plot_canvas_child_get_type(),
+ "GtkPlotCanvasText",
+ sizeof (GtkPlotCanvasTextClass),
+ (GClassInitFunc) gtk_plot_canvas_text_class_init,
+ sizeof (GtkPlotCanvasText),
+ (GInstanceInitFunc) gtk_plot_canvas_text_init,
+ 0);
}
return plot_canvas_text_type;
}
+/**
+ * gtk_plot_canvas_text_new:
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ * @real_text:
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotCanvasChild*
gtk_plot_canvas_text_new (const gchar *font, gint height, gint angle,
const GdkColor *fg, const GdkColor *bg,
@@ -90,7 +108,7 @@ gtk_plot_canvas_text_new (const gchar *font, gint height, gint angle,
GtkPlotCanvasText *text;
GtkPlotText *text_attr;
- text = gtk_type_new (gtk_plot_canvas_text_get_type ());
+ text = g_object_new (gtk_plot_canvas_text_get_type (), NULL);
text_attr = &text->text;
@@ -148,7 +166,7 @@ gtk_plot_canvas_text_class_init (GtkPlotCanvasChildClass *klass)
GtkObjectClass *object_class = (GtkObjectClass *)klass;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_canvas_child_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_canvas_child_get_type ());
klass->draw = gtk_plot_canvas_text_draw;
klass->move = NULL;
@@ -284,6 +302,20 @@ gtk_plot_canvas_text_size_allocate(GtkPlotCanvas *canvas, GtkPlotCanvasChild *ch
}
+/**
+ * gtk_plot_canvas_text_set_attributes:
+ * @text: a #GtkPlotCanvasText.
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ * @transparent:
+ * @justification:
+ * @real_text:
+ *
+ *
+ */
void
gtk_plot_canvas_text_set_attributes(GtkPlotCanvasText *text,
const gchar *font, gint height, gint angle,
diff --git a/gtkextra/gtkplotcanvastext.h b/gtkextra/gtkplotcanvastext.h
index acad9d0..b9fbd90 100644
--- a/gtkextra/gtkplotcanvastext.h
+++ b/gtkextra/gtkplotcanvastext.h
@@ -20,10 +20,10 @@
#ifndef __GTK_PLOT_CANVAS_TEXT_H__
#define __GTK_PLOT_CANVAS_TEXT_H__
-#define GTK_PLOT_CANVAS_TEXT(obj) GTK_CHECK_CAST (obj, gtk_plot_canvas_text_get_type (),
GtkPlotCanvasText)
-#define GTK_PLOT_CANVAS_TEXT_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_canvas_text_get_type(),
GtkPlotCanvasTextClass)
-#define GTK_IS_PLOT_CANVAS_TEXT(obj) GTK_CHECK_TYPE (obj, gtk_plot_canvas_text_get_type ())
-#define GTK_TYPE_PLOT_CANVAS_TEXT (gtk_plot_canvas_text_get_type ())
+#define GTK_PLOT_CANVAS_TEXT(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_canvas_text_get_type (),
GtkPlotCanvasText)
+#define GTK_PLOT_CANVAS_TEXT_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_canvas_text_get_type(),
GtkPlotCanvasTextClass)
+#define GTK_IS_PLOT_CANVAS_TEXT(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_canvas_text_get_type ())
+#define G_TYPE_PLOT_CANVAS_TEXT (gtk_plot_canvas_text_get_type ())
#include <gdk/gdk.h>
@@ -36,6 +36,12 @@ extern "C" {
typedef struct _GtkPlotCanvasText GtkPlotCanvasText;
typedef struct _GtkPlotCanvasTextClass GtkPlotCanvasTextClass;
+/**
+ * GtkPlotCanvasText:
+ *
+ * The GtkPlotCanvasText struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCanvasText
{
GtkPlotCanvasChild parent;
@@ -48,7 +54,7 @@ struct _GtkPlotCanvasTextClass
GtkPlotCanvasChildClass parent_class;
};
-GtkType gtk_plot_canvas_text_get_type (void);
+GType gtk_plot_canvas_text_get_type (void);
GtkPlotCanvasChild *
gtk_plot_canvas_text_new (const gchar *font,
gint height,
@@ -57,7 +63,7 @@ GtkPlotCanvasChild *
const GdkColor *bg,
gboolean transparent,
GtkJustification justification,
- const gchar *text);
+ const gchar *real_text);
void gtk_plot_canvas_text_set_attributes
(GtkPlotCanvasText *text,
diff --git a/gtkextra/gtkplotcsurface.c b/gtkextra/gtkplotcsurface.c
index d7437fe..534f2b3 100644
--- a/gtkextra/gtkplotcsurface.c
+++ b/gtkextra/gtkplotcsurface.c
@@ -17,6 +17,7 @@
* Boston, MA 02111-1307, USA.
*/
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -29,6 +30,15 @@
#include "gtkplotcsurface.h"
#include "gtkpsfont.h"
+/**
+ * SECTION: gtkplotcsurface
+ * @short_description:
+ *
+ * FIXME:: need long description
+ */
+
+
+
#define P_(string) string
typedef struct
@@ -113,26 +123,21 @@ enum {
static GtkPlotSurfaceClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_csurface_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotCSurface",
- sizeof (GtkPlotCSurface),
- sizeof (GtkPlotCSurfaceClass),
- (GtkClassInitFunc) gtk_plot_csurface_class_init,
- (GtkObjectInitFunc) gtk_plot_csurface_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (gtk_plot_surface_get_type(), &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_plot_surface_get_type(),
+ "GtkPlotCSurface",
+ sizeof (GtkPlotCSurfaceClass),
+ (GClassInitFunc) gtk_plot_csurface_class_init,
+ sizeof (GtkPlotCSurface),
+ (GInstanceInitFunc) gtk_plot_csurface_init,
+ 0);
}
return data_type;
}
@@ -146,7 +151,7 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
GtkPlotSurfaceClass *surface_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_surface_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_surface_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -158,6 +163,12 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
gobject_class->set_property = gtk_plot_csurface_set_property;
gobject_class->get_property = gtk_plot_csurface_get_property;
+
+ /**
+ * GtkPlotCSurface:lines_visible:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINES_VISIBLE,
g_param_spec_int ("lines_visible",
@@ -165,6 +176,12 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:projection:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_PROJECTION,
g_param_spec_int ("projection",
@@ -172,6 +189,12 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:levels_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LEVELS_STYLE,
g_param_spec_int ("levels_style",
@@ -179,6 +202,13 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:levels_width:
+ *
+ *
+ **/
+
g_object_class_install_property (gobject_class,
ARG_LEVELS_WIDTH,
g_param_spec_double ("levels_width",
@@ -186,12 +216,24 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:levels_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LEVELS_COLOR,
g_param_spec_pointer ("levels_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:sublevels_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SUBLEVELS_STYLE,
g_param_spec_int ("sublevels_style",
@@ -199,6 +241,12 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:sublevels_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SUBLEVELS_WIDTH,
g_param_spec_double ("sublevels_width",
@@ -206,6 +254,12 @@ gtk_plot_csurface_class_init (GtkPlotCSurfaceClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotCSurface:sublevels_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SUBLEVELS_COLOR,
g_param_spec_pointer ("sublevels_color",
@@ -321,7 +375,7 @@ gtk_plot_csurface_init (GtkPlotCSurface *dataset)
GdkColormap *colormap;
GtkPlotArray *dim;
- GTK_WIDGET_SET_FLAGS(dataset, GTK_NO_WINDOW);
+ gtk_widget_set_has_window(GTK_WIDGET(dataset), FALSE);
widget = GTK_WIDGET(dataset);
colormap = gtk_widget_get_colormap(widget);
@@ -366,23 +420,33 @@ gtk_plot_csurface_new (void)
{
GtkPlotData *data;
- data = gtk_type_new (gtk_plot_csurface_get_type ());
+ data = g_object_new (gtk_plot_csurface_get_type (), NULL);
return GTK_WIDGET (data);
}
+/**
+ * gtk_plot_csurface_new_function:
+ * @function: (scope async): a #GtkPlotFunc3D
+ *
+ *
+ */
GtkWidget*
gtk_plot_csurface_new_function (GtkPlotFunc3D function)
{
GtkWidget *data;
- data = gtk_type_new (gtk_plot_csurface_get_type ());
+ data = gtk_widget_new (gtk_plot_csurface_get_type (), NULL);
gtk_plot_csurface_construct_function(GTK_PLOT_CSURFACE(data), function);
return data;
}
+/**
+ * gtk_plot_csurface_construct_function:
+ * @function: (scope async): a #GtkPlotFunc3D
+ */
void
gtk_plot_csurface_construct_function (GtkPlotCSurface *data,
GtkPlotFunc3D function)
@@ -409,6 +473,8 @@ gtk_plot_csurface_draw_private (GtkPlotData *data)
GtkPlotSurface *surface;
GtkPlotCSurface *csurface;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data))) return;
+
surface = GTK_PLOT_SURFACE(data);
csurface = GTK_PLOT_CSURFACE(data);
plot = data->plot;
@@ -602,6 +668,7 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
if(csurface->projection == GTK_PLOT_PROJECT_FULL){
gtk_plot_data_get_gradient_level(data, data->gradient->ticks.min - 1., &color);
gtk_plot_pc_set_color(data->plot->pc, &color);
+
gtk_plot_pc_draw_rectangle (plot->pc, TRUE,
clip_area.x, clip_area.y,
clip_area.width, clip_area.height);
@@ -693,6 +760,7 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
}
if(data->show_labels){
+ gtk_plot_pc_clip(plot->pc, NULL);
list = lines;
while(list){
GtkPlotContourLine *s = (GtkPlotContourLine *)list->data;
@@ -745,7 +813,6 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
}
*/
- gtk_plot_pc_clip(plot->pc, NULL);
if(bb.x >= plot->internal_allocation.x && bb.x + bb.width <= plot->internal_allocation.x +
plot->internal_allocation.width && bb.y + bb.height < plot->internal_allocation.y +
plot->internal_allocation.height && bb.y > plot->internal_allocation.y){
GList *aux = labels;
gboolean overlap = FALSE;
@@ -757,23 +824,25 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
}
if(!overlap){
+ GtkAllocation allocation;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
prev = pos;
new_bb = g_new0(GtkAllocation, 1);
*new_bb = bb;
labels = g_list_append(labels, new_bb);
- label.x = GTK_WIDGET(plot)->allocation.x + x;
- label.y = GTK_WIDGET(plot)->allocation.y + y;
- label.x /= GTK_WIDGET(plot)->allocation.width;
- label.y /= GTK_WIDGET(plot)->allocation.height;
+ label.x = allocation.x + x;
+ label.y = allocation.y + y;
+ label.x /= allocation.width;
+ label.y /= allocation.height;
gtk_plot_draw_text(plot, label);
if(i != 0) break;
}
}
- gtk_plot_pc_clip(plot->pc, &clip_area);
}
}
list = list->next;
}
+ gtk_plot_pc_clip(plot->pc, &clip_area);
}
@@ -785,9 +854,12 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
GtkPlotPoint *p1 = NULL, *p2 = NULL;
gint i, n = 0, x = 0;
GtkAllocation *aux_bb = NULL;
- GtkPlotPoint line[s->n1];
+ GtkPlotPoint *line = NULL;
gboolean prev_x = 0;
+ if(!line)
+ line = (GtkPlotPoint *) g_new0(GtkPlotPoint,s->n1 +1); /* Tiny C Compiler support */
+
if(s->sublevel){
if(csurface->sublevels_line.line_style == GTK_PLOT_LINE_NONE)
{ list = list->next; continue; }
@@ -816,7 +888,7 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
aux = labels;
while(aux){
- gdouble t1, t2;
+ gdouble t1 = 0., t2 = 0.;
aux_bb = (GtkAllocation *)aux->data;
prev_x = x;
x = line_intersect(aux_bb,p1,p2,&x1,&x2,&t1,&t2);
@@ -870,6 +942,9 @@ gtk_plot_csurface_draw_lines(GtkPlotData *data)
}
list = list->next;
+
+ if(!list)
+ g_free (line);
}
}
@@ -1592,6 +1667,7 @@ gtk_plot_csurface_draw_legend(GtkPlotData *data, gint x, gint y)
GdkRectangle area;
gint lascent = 0, ldescent = 0, lheight = 0, lwidth = 0;
gdouble m;
+ GtkAllocation allocation;
surface = GTK_PLOT_SURFACE(data);
csurface = GTK_PLOT_CSURFACE(data);
@@ -1600,10 +1676,11 @@ gtk_plot_csurface_draw_legend(GtkPlotData *data, gint x, gint y)
g_return_if_fail(GTK_IS_PLOT(data->plot));
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
@@ -1783,30 +1860,69 @@ rgb_to_hsv (gdouble r, gdouble g, gdouble b,
***********************************/
+/**
+ * gtk_plot_csurface_set_lines_visible:
+ * @csurface: a #GtkPlotCSurface/
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_csurface_set_lines_visible (GtkPlotCSurface *csurface, gboolean visible)
{
csurface->lines_visible = visible;
}
+/**
+ * gtk_plot_csurface_get_lines_visible:
+ * @csurface: a #GtkPlotCSurface.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_csurface_get_lines_visible (GtkPlotCSurface *csurface)
{
return (csurface->lines_visible);
}
+/**
+ * gtk_plot_csurface_set_projection:
+ * @csurface: a #GtkPlotCSurface.
+ * @proj:
+ *
+ *
+ */
void
gtk_plot_csurface_set_projection (GtkPlotCSurface *csurface, GtkPlotProjection proj)
{
csurface->projection = proj;
}
+/**
+ * gtk_plot_csurface_projection:
+ * @csurface: a #GtkPlotCSurface.
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotProjection
gtk_plot_csurface_projection (GtkPlotCSurface *csurface)
{
return (csurface->projection);
}
+/**
+ * gtk_plot_csurface_set_levels_attributes:
+ * @dataset: a #GtkPlotCSurface.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_csurface_set_levels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle style,
@@ -1818,6 +1934,15 @@ gtk_plot_csurface_set_levels_attributes (GtkPlotCSurface *dataset,
dataset->levels_line.color = *color;
}
+/**
+ * gtk_plot_csurface_set_sublevels_attributes:
+ * @dataset: a #GtkPlotCSurface.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_csurface_set_sublevels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle style,
@@ -1829,6 +1954,15 @@ gtk_plot_csurface_set_sublevels_attributes (GtkPlotCSurface *dataset,
dataset->sublevels_line.color = *color;
}
+/**
+ * gtk_plot_csurface_get_levels_attributes:
+ * @dataset: a #GtkPlotCSurface.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_csurface_get_levels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle *style,
@@ -1840,6 +1974,15 @@ gtk_plot_csurface_get_levels_attributes (GtkPlotCSurface *dataset,
*color = dataset->levels_line.color;
}
+/**
+ * gtk_plot_csurface_get_sublevels_attributes:
+ * @dataset: a #GtkPlotCSurface.
+ * @style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_csurface_get_sublevels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle *style,
diff --git a/gtkextra/gtkplotcsurface.h b/gtkextra/gtkplotcsurface.h
index c495159..ca529eb 100644
--- a/gtkextra/gtkplotcsurface.h
+++ b/gtkextra/gtkplotcsurface.h
@@ -30,10 +30,10 @@ extern "C" {
#include "gtkplotpc.h"
-#define GTK_PLOT_CSURFACE(obj) GTK_CHECK_CAST (obj, gtk_plot_csurface_get_type (), GtkPlotCSurface)
-#define GTK_TYPE_PLOT_CSURFACE (gtk_plot_csurface_get_type ())
-#define GTK_PLOT_CSURFACE_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_csurface_get_type,
GtkPlotCSurfaceClass)
-#define GTK_IS_PLOT_CSURFACE(obj) GTK_CHECK_TYPE (obj, gtk_plot_csurface_get_type ())
+#define GTK_PLOT_CSURFACE(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_csurface_get_type (),
GtkPlotCSurface)
+#define G_TYPE_PLOT_CSURFACE (gtk_plot_csurface_get_type ())
+#define GTK_PLOT_CSURFACE_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_csurface_get_type,
GtkPlotCSurfaceClass)
+#define GTK_IS_PLOT_CSURFACE(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_csurface_get_type ())
typedef struct _GtkPlotCSurface GtkPlotCSurface;
typedef struct _GtkPlotCSurfaceClass GtkPlotCSurfaceClass;
@@ -49,6 +49,13 @@ typedef enum
GTK_PLOT_PROJECT_FULL, /* draw filled contours */
} GtkPlotProjection;
+
+/**
+ * GtkPlotCSurface:
+ *
+ * The GtkPlotCSurface struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotCSurface
{
GtkPlotSurface surface;
@@ -74,7 +81,7 @@ struct _GtkPlotCSurfaceClass
/* PlotCSurface */
-GtkType gtk_plot_csurface_get_type (void);
+GType gtk_plot_csurface_get_type (void);
GtkWidget* gtk_plot_csurface_new (void);
GtkWidget* gtk_plot_csurface_new_function (GtkPlotFunc3D function);
@@ -87,19 +94,19 @@ gboolean gtk_plot_csurface_get_lines_visible (GtkPlotCSurface *csurface);
void gtk_plot_csurface_set_projection (GtkPlotCSurface *csurface,
GtkPlotProjection proj);
GtkPlotProjection gtk_plot_csurface_projection (GtkPlotCSurface *csurface);
-void gtk_plot_csurface_set_levels_attributes (GtkPlotCSurface *data,
+void gtk_plot_csurface_set_levels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle style,
gfloat width,
const GdkColor *color);
-void gtk_plot_csurface_set_sublevels_attributes (GtkPlotCSurface *data,
+void gtk_plot_csurface_set_sublevels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle style,
gfloat width,
const GdkColor *color);
-void gtk_plot_csurface_get_levels_attributes (GtkPlotCSurface *data,
+void gtk_plot_csurface_get_levels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle *style,
gfloat *width,
GdkColor *color);
-void gtk_plot_csurface_get_sublevels_attributes (GtkPlotCSurface *data,
+void gtk_plot_csurface_get_sublevels_attributes (GtkPlotCSurface *dataset,
GtkPlotLineStyle *style,
gfloat *width,
GdkColor *color);
diff --git a/gtkextra/gtkplotdata.c b/gtkextra/gtkplotdata.c
index e988d24..fed9c49 100644
--- a/gtkextra/gtkplotdata.c
+++ b/gtkextra/gtkplotdata.c
@@ -17,6 +17,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotdata
+ * @short_description:
+ *
+ * FIXME:: Need long description.
+ */
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -250,55 +257,46 @@ enum {
ARG_GRADIENT_BREAK_SCALE,
ARG_GRADIENT_BREAK_POSITION,
ARG_GRADIENT,
+ ARG_GRADIENT_SHOW_LT_GT,
};
static GtkWidgetClass *parent_class = NULL;
static guint data_signals[LAST_SIGNAL] = { 0 };
-GtkType
+GType
gtk_plot_marker_get_type (void)
{
- static GtkType marker_type = 0;
+ static GType marker_type = 0;
if (!marker_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotMarker",
- 0,
- 0,
- (GtkClassInitFunc) NULL,
- (GtkObjectInitFunc) NULL,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- marker_type = gtk_type_unique (GTK_TYPE_BOXED, &data_info);
+ marker_type = g_type_register_static_simple (
+ G_TYPE_BOXED,
+ "GtkPlotMarker",
+ 0,
+ (GClassInitFunc) NULL,
+ 0,
+ (GInstanceInitFunc) NULL,
+ 0);
}
return marker_type;
}
-GtkType
+GType
gtk_plot_data_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotData",
- sizeof (GtkPlotData),
- sizeof (GtkPlotDataClass),
- (GtkClassInitFunc) gtk_plot_data_class_init,
- (GtkObjectInitFunc) gtk_plot_data_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (GTK_TYPE_WIDGET, &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_widget_get_type (),
+ "GtkPlotData",
+ sizeof (GtkPlotDataClass),
+ (GClassInitFunc) gtk_plot_data_class_init,
+ sizeof (GtkPlotData),
+ (GInstanceInitFunc) gtk_plot_data_init,
+ 0);
}
return data_type;
}
@@ -311,7 +309,7 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
GtkPlotDataClass *data_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_widget_get_type ());
+ parent_class = g_type_class_ref (gtk_widget_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -322,6 +320,11 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
gobject_class->set_property = gtk_plot_data_set_property;
gobject_class->get_property = gtk_plot_data_get_property;
+ /**
+ * GtkPlotData:name:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_NAME,
g_param_spec_string ("name",
@@ -329,6 +332,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:legend:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LEGEND,
g_param_spec_string ("legend",
@@ -336,6 +345,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:is_iterator:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ITERATOR,
g_param_spec_boolean ("is_iterator",
@@ -343,6 +358,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:is_function:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_FUNCTION,
g_param_spec_boolean ("is_function",
@@ -350,6 +371,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:iterator_mask:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ITERATOR_MASK,
g_param_spec_int ("iterator_mask",
@@ -357,6 +384,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:num_points:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_NUM_POINTS,
g_param_spec_int ("num_points",
@@ -364,6 +397,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:fill_area:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_FILL_AREA,
g_param_spec_boolean ("fill_area",
@@ -371,6 +410,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xstep:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XSTEP,
g_param_spec_double ("xstep",
@@ -378,6 +423,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:ystep:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YSTEP,
g_param_spec_double ("ystep",
@@ -385,6 +436,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zstep:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZSTEP,
g_param_spec_double ("zstep",
@@ -392,6 +449,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_type:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_TYPE,
g_param_spec_int ("symbol_type",
@@ -399,6 +462,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_STYLE,
g_param_spec_int ("symbol_style",
@@ -406,6 +475,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_size:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_SIZE,
g_param_spec_int ("symbol_size",
@@ -413,12 +488,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_COLOR,
g_param_spec_pointer ("symbol_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_border_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_BORDER_WIDTH,
g_param_spec_double ("symbol_border_width",
@@ -426,12 +513,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:symbol_border_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SYMBOL_BORDER_COLOR,
g_param_spec_pointer ("symbol_border_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_STYLE,
g_param_spec_int ("line_style",
@@ -439,6 +538,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_cap:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_CAP,
g_param_spec_int ("line_cap",
@@ -446,6 +551,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_join:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_JOIN,
g_param_spec_int ("line_join",
@@ -453,6 +564,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_WIDTH,
g_param_spec_double ("line_width",
@@ -460,12 +577,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_COLOR,
g_param_spec_pointer ("line_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:line_connector:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LINE_CONNECTOR,
g_param_spec_int ("line_connector",
@@ -473,6 +602,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xline_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XLINE_STYLE,
g_param_spec_int ("xline_style",
@@ -480,6 +615,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xline_cap:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XLINE_CAP,
g_param_spec_int ("xline_cap",
@@ -487,6 +628,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xline_join:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XLINE_JOIN,
g_param_spec_int ("xline_join",
@@ -494,6 +641,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xline_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XLINE_WIDTH,
g_param_spec_double ("xline_width",
@@ -501,12 +654,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xline_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XLINE_COLOR,
g_param_spec_pointer ("xline_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yline_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YLINE_STYLE,
g_param_spec_int ("yline_style",
@@ -514,6 +679,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yline_cap:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YLINE_CAP,
g_param_spec_int ("yline_cap",
@@ -521,6 +692,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yline_join:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YLINE_JOIN,
g_param_spec_int ("yline_join",
@@ -528,6 +705,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yline_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YLINE_WIDTH,
g_param_spec_double ("yline_width",
@@ -535,12 +718,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yline_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YLINE_COLOR,
g_param_spec_pointer ("yline_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zline_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZLINE_STYLE,
g_param_spec_int ("zline_style",
@@ -548,6 +743,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zline_cap:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZLINE_CAP,
g_param_spec_int ("zline_cap",
@@ -555,6 +756,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zline_join:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZLINE_JOIN,
g_param_spec_int ("zline_join",
@@ -562,6 +769,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zline_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZLINE_WIDTH,
g_param_spec_double ("zline_width",
@@ -569,12 +782,24 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zline_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZLINE_COLOR,
g_param_spec_pointer ("zline_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_xerrbars:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_XERRBARS,
g_param_spec_boolean ("show_xerrbars",
@@ -582,6 +807,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xerrbar_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XERRBARS_WIDTH,
g_param_spec_int ("xerrbar_width",
@@ -589,6 +820,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:xerrbar_caps:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_XERRBARS_CAPS,
g_param_spec_int ("xerrbar_caps",
@@ -596,6 +833,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_yerrbars:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_YERRBARS,
g_param_spec_boolean ("show_yerrbars",
@@ -603,6 +846,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yerrbar_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YERRBARS_WIDTH,
g_param_spec_int ("yerrbar_width",
@@ -610,6 +859,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:yerrbar_caps:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_YERRBARS_CAPS,
g_param_spec_int ("yerrbar_caps",
@@ -617,6 +872,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_zerrbars:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_ZERRBARS,
g_param_spec_boolean ("show_zerrbars",
@@ -624,6 +885,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zerrbar_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZERRBARS_WIDTH,
g_param_spec_int ("zerrbar_width",
@@ -631,6 +898,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:zerrbar_caps:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ZERRBARS_CAPS,
g_param_spec_int ("zerrbar_caps",
@@ -638,6 +911,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_legends:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_LEGENDS,
g_param_spec_boolean ("show_legends",
@@ -645,6 +924,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
TRUE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:legends_precision:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LEGENDS_PRECISION,
g_param_spec_int ("legends_precision",
@@ -652,6 +937,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:legends_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LEGENDS_STYLE,
g_param_spec_int ("legends_style",
@@ -659,6 +950,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_labels:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_LABELS,
g_param_spec_boolean ("show_labels",
@@ -666,6 +963,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
TRUE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_border:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_BORDER,
g_param_spec_int ("labels_border",
@@ -673,6 +976,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_border_space:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_BORDER_SPACE,
g_param_spec_int ("labels_border_space",
@@ -680,6 +989,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_border_width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_BORDER_WIDTH,
g_param_spec_int ("labels_border_width",
@@ -687,6 +1002,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_border_shadow:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_BORDER_SHADOW,
g_param_spec_int ("labels_border_shadow",
@@ -694,6 +1015,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_transparent:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_TRANSPARENT,
g_param_spec_boolean ("labels_transparent",
@@ -701,18 +1028,36 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
TRUE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_fg_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_FG,
g_param_spec_pointer ("labels_fg_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_bg_color:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_BG,
g_param_spec_pointer ("labels_bg_color",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_angle:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_ANGLE,
g_param_spec_int ("labels_angle",
@@ -720,6 +1065,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,270,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_offset:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_OFFSET,
g_param_spec_int ("labels_offset",
@@ -727,6 +1078,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_size:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_SIZE,
g_param_spec_int ("labels_size",
@@ -734,6 +1091,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_font:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_FONT,
g_param_spec_string ("labels_font",
@@ -741,6 +1104,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:labels_text:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABELS_TEXT,
g_param_spec_string ("labels_text",
@@ -748,6 +1117,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:show_gradient:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_GRADIENT,
g_param_spec_boolean ("show_gradient",
@@ -755,6 +1130,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
TRUE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_custom:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_CUSTOM,
g_param_spec_boolean ("gradient_custom",
@@ -762,6 +1143,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_mask:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_MASK,
g_param_spec_int ("gradient_mask",
@@ -769,30 +1156,73 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_show_lt_gt:
+ *
+ *
+ **/
+ g_object_class_install_property (gobject_class,
+ ARG_GRADIENT_SHOW_LT_GT,
+ g_param_spec_boolean ("gradient_show_lt_gt",
+ P_(""),
+ P_(""),
+ TRUE,
+ G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:color_min:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_COLOR_MIN,
g_param_spec_pointer ("color_min",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:color_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_COLOR_MAX,
g_param_spec_pointer ("color_max",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:color_lt_min:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_COLOR_LT_MIN,
g_param_spec_pointer ("color_lt_min",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:color_gt_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_COLOR_GT_MAX,
g_param_spec_pointer ("color_gt_max",
P_(""),
P_(""),
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_MAX,
g_param_spec_double ("gradient_max",
@@ -800,6 +1230,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_min:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_MIN,
g_param_spec_double ("gradient_min",
@@ -807,6 +1243,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_step:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_STEP,
g_param_spec_double ("gradient_step",
@@ -814,6 +1256,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_nminor:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_NMINOR,
g_param_spec_int ("gradient_nminor",
@@ -821,6 +1269,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_nmajor:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_NMAJOR,
g_param_spec_int ("gradient_nmajor",
@@ -828,6 +1282,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_scale:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_SCALE,
g_param_spec_int ("gradient_scale",
@@ -835,6 +1295,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK,
g_param_spec_boolean ("gradient_break",
@@ -842,6 +1308,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_MAX,
g_param_spec_double ("gradient_break_max",
@@ -849,6 +1321,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_min:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_MIN,
g_param_spec_double ("gradient_break_min",
@@ -856,6 +1334,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_step:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_STEP,
g_param_spec_double ("gradient_break_step",
@@ -863,6 +1347,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
-G_MAXDOUBLE,G_MAXDOUBLE,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_nminor:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_NMINOR,
g_param_spec_int ("gradient_break_nminor",
@@ -870,6 +1360,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_scale:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_SCALE,
g_param_spec_int ("gradient_break_scale",
@@ -877,6 +1373,12 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:gradient_break_position:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_GRADIENT_BREAK_POSITION,
g_param_spec_double ("gradient_break_position",
@@ -884,12 +1386,18 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
P_(""),
0.,1.,0.0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotData:bottom_axis:
+ *
+ *
+ **/
g_object_class_install_property(gobject_class,
ARG_GRADIENT,
g_param_spec_object ("bottom_axis",
P_(""),
P_(""),
- GTK_TYPE_PLOT_AXIS,
+ G_TYPE_PLOT_AXIS,
G_PARAM_READABLE));
data_class->clone = gtk_plot_data_real_clone;
@@ -904,45 +1412,84 @@ gtk_plot_data_class_init (GtkPlotDataClass *klass)
data_class->get_legend_size = gtk_plot_data_get_legend_size;
data_class->get_gradient_size = gtk_plot_data_get_gradient_size;
+ /**
+ * GtkPlotData::add_to_plot:
+ * @data: a #GtkPlotData widget.
+ * @plot: a #GtkPlot widget.
+ *
+ *
+ *
+ * Return value:
+ */
data_signals[ADD_TO_PLOT] =
- gtk_signal_new ("add_to_plot",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotDataClass, add_to_plot),
+ g_signal_new ("add_to_plot",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotDataClass, add_to_plot),
+ NULL, NULL,
gtkextra_BOOL__POINTER,
- GTK_TYPE_BOOL, 1, GTK_TYPE_PLOT);
-
+ G_TYPE_BOOLEAN, 1, G_TYPE_PLOT);
+
+ /**
+ * GtkPlotData::update:
+ * @data: a #GtkPlotData widget.
+ * @new_range:
+ *
+ *
+ */
data_signals[UPDATE] =
- gtk_signal_new ("update",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotDataClass, update),
+ g_signal_new ("update",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotDataClass, update),
+ NULL, NULL,
gtkextra_VOID__BOOL,
- GTK_TYPE_NONE, 1, GTK_TYPE_BOOL);
+ G_TYPE_NONE, 1, G_TYPE_BOOLEAN);
+ /**
+ * GtkPlotData::draw_data:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
data_signals[DRAW_DATA] =
- gtk_signal_new ("draw_data",
- GTK_RUN_FIRST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotDataClass, draw_data),
+ g_signal_new ("draw_data",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (GtkPlotDataClass, draw_data),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0, GTK_TYPE_NONE);
+ G_TYPE_NONE, 0, G_TYPE_NONE);
+ /**
+ * GtkPlotData::gradient_changed:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
data_signals[GRADIENT_CHANGED] =
- gtk_signal_new ("gradient_changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotDataClass, gradient_changed),
+ g_signal_new ("gradient_changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotDataClass, gradient_changed),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0);
-
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkPlotData::gradient_colors_changed:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
data_signals[GRADIENT_COLORS_CHANGED] =
- gtk_signal_new ("gradient_colors_changed",
- GTK_RUN_LAST,
- GTK_CLASS_TYPE(object_class),
- GTK_SIGNAL_OFFSET (GtkPlotDataClass, gradient_colors_changed),
+ g_signal_new ("gradient_colors_changed",
+ G_TYPE_FROM_CLASS(object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (GtkPlotDataClass, gradient_colors_changed),
+ NULL, NULL,
gtkextra_VOID__VOID,
- GTK_TYPE_NONE, 0);
+ G_TYPE_NONE, 0);
}
@@ -953,7 +1500,7 @@ gtk_plot_data_init (GtkPlotData *dataset)
GdkColormap *colormap;
GdkColor black, white, color;
- GTK_WIDGET_SET_FLAGS(dataset, GTK_NO_WINDOW);
+ gtk_widget_set_has_window(GTK_WIDGET(dataset), FALSE);
widget = GTK_WIDGET(dataset);
colormap = gtk_widget_get_colormap(widget);
@@ -962,7 +1509,7 @@ gtk_plot_data_init (GtkPlotData *dataset)
gdk_color_white(colormap, &white);
dataset->gradient = GTK_PLOT_AXIS(gtk_plot_axis_new(GTK_PLOT_AXIS_Y));
- gtk_object_ref(GTK_OBJECT(dataset->gradient));
+ g_object_ref(GTK_OBJECT(dataset->gradient));
gtk_object_sink(GTK_OBJECT(dataset->gradient));
dataset->color_lt_min = white;
@@ -995,13 +1542,14 @@ gtk_plot_data_init (GtkPlotData *dataset)
dataset->gradient->label_style = GTK_PLOT_LABEL_FLOAT;
dataset->gradient->labels_offset = 4;
dataset->gradient_mask = GTK_PLOT_GRADIENT_H;
+ dataset->gradient_show_lt_gt = FALSE;
dataset->gradient_title_pos = GTK_PLOT_AXIS_RIGHT;
dataset->gradient_x = .6;
dataset->gradient_y = .05;
dataset->gradient->orientation = GTK_ORIENTATION_VERTICAL;
dataset->gradient->label_mask = GTK_PLOT_LABEL_OUT;
- dataset->gradient->labels_attr.fg = widget->style->black;
- dataset->gradient->labels_attr.bg = widget->style->white;
+ dataset->gradient->labels_attr.fg = gtk_widget_get_style(widget)->black;
+ dataset->gradient->labels_attr.bg = gtk_widget_get_style(widget)->white;
dataset->gradient->labels_attr.transparent = FALSE;
dataset->gradient->labels_attr.border = 0;
dataset->gradient->labels_attr.border_width = 0;
@@ -1110,15 +1658,15 @@ gtk_plot_data_init (GtkPlotData *dataset)
dataset->data = GTK_PLOT_ARRAY_LIST(gtk_plot_array_list_new());
g_object_ref(G_OBJECT(dataset->data));
- gtk_plot_data_add_dimension(dataset, "x", "X" , "X points", GTK_TYPE_DOUBLE, TRUE, TRUE);
- gtk_plot_data_add_dimension(dataset, "y", "Y" , "Y points", GTK_TYPE_DOUBLE, TRUE, FALSE);
- gtk_plot_data_add_dimension(dataset, "z", "Z" , "Z points", GTK_TYPE_DOUBLE, TRUE, FALSE);
- gtk_plot_data_add_dimension(dataset, "a", "Size" , "Symbol size", GTK_TYPE_DOUBLE, FALSE, FALSE);
- gtk_plot_data_add_dimension(dataset, "da", "Amp" , "Amplitude", GTK_TYPE_DOUBLE, FALSE, FALSE);
- gtk_plot_data_add_dimension(dataset, "dx", "ErrX" , "Error in X", GTK_TYPE_DOUBLE, FALSE, FALSE);
- gtk_plot_data_add_dimension(dataset, "dy", "ErrY" , "Error in Y", GTK_TYPE_DOUBLE, FALSE, FALSE);
- gtk_plot_data_add_dimension(dataset, "dz", "ErrZ" , "Error in Z", GTK_TYPE_DOUBLE, FALSE, FALSE);
- gtk_plot_data_add_dimension(dataset, "labels", "Labels" , "Data labels", GTK_TYPE_STRING, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "x", "X" , "X points", G_TYPE_DOUBLE, TRUE, TRUE);
+ gtk_plot_data_add_dimension(dataset, "y", "Y" , "Y points", G_TYPE_DOUBLE, TRUE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "z", "Z" , "Z points", G_TYPE_DOUBLE, TRUE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "a", "Size" , "Symbol size", G_TYPE_DOUBLE, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "da", "Amp" , "Amplitude", G_TYPE_DOUBLE, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "dx", "ErrX" , "Error in X", G_TYPE_DOUBLE, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "dy", "ErrY" , "Error in Y", G_TYPE_DOUBLE, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "dz", "ErrZ" , "Error in Z", G_TYPE_DOUBLE, FALSE, FALSE);
+ gtk_plot_data_add_dimension(dataset, "labels", "Labels" , "Data labels", G_TYPE_STRING, FALSE, FALSE);
}
static void
@@ -1140,7 +1688,7 @@ gtk_plot_data_destroy (GtkObject *object)
if(data->name) g_free(data->name);
data->name = NULL;
- if(data->gradient) gtk_object_unref(GTK_OBJECT(data->gradient));
+ if(data->gradient) g_object_unref(GTK_OBJECT(data->gradient));
data->gradient = NULL;
if(data->gradient_colors){
@@ -1373,6 +1921,9 @@ gtk_plot_data_set_property (GObject *object,
case ARG_GRADIENT_MASK:
data->gradient_mask = g_value_get_int(value);
break;
+ case ARG_GRADIENT_SHOW_LT_GT:
+ data->gradient_show_lt_gt = g_value_get_boolean(value);
+ break;
case ARG_COLOR_MIN:
data->color_min = *((GdkColor *)g_value_get_pointer(value));
break;
@@ -1659,6 +2210,9 @@ gtk_plot_data_get_property (GObject *object,
case ARG_GRADIENT_MASK:
g_value_set_int(value, data->gradient_mask);
break;
+ case ARG_GRADIENT_SHOW_LT_GT:
+ g_value_set_boolean(value, data->gradient_show_lt_gt);
+ break;
case ARG_COLOR_MIN:
g_value_set_pointer(value, &data->color_min);
break;
@@ -1737,23 +2291,34 @@ gtk_plot_data_new (void)
{
GtkWidget *widget;
- widget = gtk_type_new (gtk_plot_data_get_type ());
+ widget = gtk_widget_new (gtk_plot_data_get_type (), NULL);
return (widget);
}
+/**
+ * gtk_plot_data_new_function:
+ * @function: (scope async): a #GtkPlotFunc.
+ *
+ * Return value: (transfer none): the #GtkPlotData Widget
+ */
GtkWidget*
gtk_plot_data_new_function (GtkPlotFunc function)
{
GtkWidget *dataset;
- dataset = gtk_type_new (gtk_plot_data_get_type ());
+ dataset = gtk_widget_new (gtk_plot_data_get_type (), NULL);
gtk_plot_data_construct_function (GTK_PLOT_DATA(dataset), function);
return (dataset);
}
+/**
+ * gtk_plot_data_construct_function:
+ * @data: a #GtkPlotData widget.
+ * @function: (scope notified): a #GtkPlotFunc.
+ */
void
gtk_plot_data_construct_function (GtkPlotData *data, GtkPlotFunc function)
{
@@ -1761,18 +2326,33 @@ gtk_plot_data_construct_function (GtkPlotData *data, GtkPlotFunc function)
data->function = function;
}
+/**
+ * gtk_plot_data_new_iterator:
+ * @iterator: (scope async): a #GtkPlotIterator.
+ * @npoints:
+ * @mask:
+ *
+ * Return value: (transfer full) a new #GtkPlotData.
+ */
GtkWidget*
gtk_plot_data_new_iterator (GtkPlotIterator iterator, gint npoints, guint16 mask)
{
GtkWidget *dataset;
- dataset = gtk_type_new (gtk_plot_data_get_type ());
+ dataset = gtk_widget_new (gtk_plot_data_get_type (), NULL);
gtk_plot_data_construct_iterator (GTK_PLOT_DATA(dataset), iterator, npoints, mask);
return (dataset);
}
+/**
+ * gtk_plot_data_construct_iterator:
+ * @data: a #GtkPlotData widget.
+ * @iterator: (scope async): a #GtkPlotIterator.
+ * @npoints:
+ * @mask:
+ */
void
gtk_plot_data_construct_iterator (GtkPlotData *data,
GtkPlotIterator iterator, gint npoints, guint16 mask)
@@ -1783,12 +2363,25 @@ gtk_plot_data_construct_iterator (GtkPlotData *data,
data->num_points = npoints;
}
+/**
+ * gtk_plot_data_clone:
+ * @data: a #GtkPlotData widget.
+ * @copy:
+ *
+ *
+ */
void
gtk_plot_data_clone (GtkPlotData *data, GtkPlotData *copy)
{
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(data)))->clone(data, copy);
}
+/**
+ * gtk_plot_data_update:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_update(GtkPlotData *data)
{
@@ -1811,8 +2404,8 @@ update_gradient(GtkPlotData *data)
static void
gtk_plot_data_draw (GtkWidget *widget, GdkRectangle *area)
{
- if(!GTK_WIDGET_VISIBLE(widget)) return;
- gtk_signal_emit(GTK_OBJECT(widget), data_signals[DRAW_DATA], NULL);
+ if(!gtk_widget_get_visible(widget)) return;
+ g_signal_emit(GTK_OBJECT(widget), data_signals[DRAW_DATA], 0, NULL);
GTK_PLOT_DATA_CLASS(GTK_OBJECT_GET_CLASS(GTK_OBJECT(widget)))->draw_data(GTK_PLOT_DATA(widget));
GTK_PLOT_DATA(widget)->redraw_pending = FALSE;
@@ -1871,7 +2464,7 @@ draw_marker(GtkPlotData *data, GtkPlotMarker *marker)
void
gtk_plot_data_paint (GtkPlotData *data)
{
- gtk_signal_emit(GTK_OBJECT(data), data_signals[DRAW_DATA], NULL);
+ g_signal_emit(GTK_OBJECT(data), data_signals[DRAW_DATA], 0, NULL);
data->redraw_pending = FALSE;
}
@@ -1917,11 +2510,12 @@ gtk_plot_data_real_draw (GtkPlotData *dataset,
gchar **fl = NULL;
gboolean error;
gdouble m;
+ GtkAllocation allocation;
g_return_if_fail(GTK_IS_PLOT_DATA(dataset));
g_return_if_fail(dataset->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(dataset->plot));
- if(!GTK_WIDGET_VISIBLE(dataset)) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(dataset))) return;
plot = dataset->plot;
widget = GTK_WIDGET(plot);
@@ -1931,10 +2525,11 @@ gtk_plot_data_real_draw (GtkPlotData *dataset,
m = plot->magnification;
- area.x = widget->allocation.x;
- area.y = widget->allocation.y;
- area.width = widget->allocation.width;
- area.height = widget->allocation.height;
+ gtk_widget_get_allocation(widget, &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
@@ -2087,6 +2682,7 @@ gtk_plot_data_real_real_draw (GtkPlotData *dataset,
gdouble a_scale = 1., y_scale = 1., z_scale = 1.;
gint n;
gdouble m;
+ GtkAllocation allocation;
g_return_if_fail(GTK_IS_PLOT_DATA(dataset));
g_return_if_fail(dataset->plot != NULL);
@@ -2096,10 +2692,11 @@ gtk_plot_data_real_real_draw (GtkPlotData *dataset,
widget = GTK_WIDGET(plot);
colormap = gdk_colormap_get_system();
- area.x = widget->allocation.x;
- area.y = widget->allocation.y;
- area.width = widget->allocation.width;
- area.height = widget->allocation.height;
+ gtk_widget_get_allocation(widget, &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
gtk_plot_pc_gsave(plot->pc);
@@ -2195,17 +2792,19 @@ gtk_plot_data_draw_legend(GtkPlotData *data, gint x, gint y)
GdkRectangle area;
gint lascent = 0, ldescent = 0, lheight = 0, lwidth = 0;
gdouble m;
+ GtkAllocation allocation;
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- if(!GTK_WIDGET_VISIBLE(data->plot)) return;
- if(!GTK_WIDGET_VISIBLE(data)) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data->plot))) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data))) return;
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
@@ -2309,19 +2908,21 @@ draw_gradient_vertical(GtkPlotData *data, gdouble px, gdouble py)
gint width = 0, height = 0;
gint nmajor = 0;
gint y_max = 0;
+ GtkAllocation allocation;
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- if(!GTK_WIDGET_VISIBLE(data->plot)) return;
- if(!GTK_WIDGET_VISIBLE(data)) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data->plot))) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data))) return;
if(!data->show_gradient) return;
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
x = x_orig = roundint(plot->internal_allocation.x + plot->internal_allocation.width * px);
y = y_orig = roundint(plot->internal_allocation.y + plot->internal_allocation.height * py);
@@ -2470,9 +3071,15 @@ draw_gradient_vertical(GtkPlotData *data, gdouble px, gdouble py)
gtk_plot_data_get_gradient_level(data, h, &color);
gtk_plot_pc_set_color(plot->pc, &color);
+ gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
+ x, cy,
+ roundint(data->gradient_line_width * m),
+ 1);
+/*
gtk_plot_pc_draw_line(plot->pc,
x, cy,
x + roundint(data->gradient_line_width * m), cy);
+*/
cy++;
}
@@ -2562,7 +3169,7 @@ draw_gradient_vertical(GtkPlotData *data, gdouble px, gdouble py)
gtk_plot_draw_text(plot, legend);
}
if(data->gradient->label_mask & GTK_PLOT_LABEL_OUT){
- legend.x = (gdouble)(area.x + x + roundint((data->gradient_line_width +
data->gradient->labels_offset) * m)) / (gdouble)area.width;
+ legend.x = (gdouble)(area.x + x + roundint(data->gradient_line_width * m) +
roundint(data->gradient->labels_offset * m)) / (gdouble)area.width;
legend.justification = GTK_JUSTIFY_LEFT;
gtk_plot_draw_text(plot, legend);
}
@@ -2571,7 +3178,7 @@ draw_gradient_vertical(GtkPlotData *data, gdouble px, gdouble py)
x, ry,
x + roundint(data->gradient->ticks_length * m), ry);
gtk_plot_pc_draw_line(plot->pc,
- x + roundint((data->gradient_line_width - data->gradient->ticks_length)* m),
+ x + roundint(data->gradient_line_width * m) -
roundint(data->gradient->ticks_length * m),
ry,
x + roundint(data->gradient_line_width * m),
ry);
@@ -2593,7 +3200,7 @@ draw_gradient_vertical(GtkPlotData *data, gdouble px, gdouble py)
case GTK_PLOT_AXIS_RIGHT:
legend = data->gradient->title;
legend.angle = 270;
- legend.x = (gdouble)(area.x + x + lwidth + roundint((data->gradient_line_width +
2*data->gradient_border_offset) * m)) / (gdouble)area.width;
+ legend.x = (gdouble)(area.x + x + lwidth + roundint(data->gradient_line_width) * m +
roundint(2*data->gradient_border_offset * m)) / (gdouble)area.width;
legend.y = (gdouble)(area.y + y_orig + height / 2.)/(gdouble)area.height;
legend.justification = GTK_JUSTIFY_CENTER;
gtk_plot_draw_text(plot, legend);
@@ -2644,19 +3251,21 @@ draw_gradient_horizontal(GtkPlotData *data, gdouble px, gdouble py)
gint nmajor = 0;
gint ncolors = 0;
gint x_max = 0;
+ GtkAllocation allocation;
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- if(!GTK_WIDGET_VISIBLE(data->plot)) return;
- if(!GTK_WIDGET_VISIBLE(data)) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data->plot))) return;
+ if(!gtk_widget_get_visible(GTK_WIDGET(data))) return;
if(!data->show_gradient) return;
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
x = x_orig = roundint(plot->internal_allocation.x + plot->internal_allocation.width * px);
y = y_orig = roundint(plot->internal_allocation.y + plot->internal_allocation.height * py);
@@ -2809,9 +3418,14 @@ draw_gradient_horizontal(GtkPlotData *data, gdouble px, gdouble py)
gtk_plot_data_get_gradient_level(data, h, &color);
gtk_plot_pc_set_color(plot->pc, &color);
+ gtk_plot_pc_draw_rectangle(plot->pc, TRUE,
+ cx, y,
+ 1, roundint(data->gradient_line_height * m));
+/*
gtk_plot_pc_draw_line(plot->pc,
cx, y,
cx, y + roundint(data->gradient_line_height * m));
+*/
cx++;
}
@@ -2901,7 +3515,7 @@ draw_gradient_horizontal(GtkPlotData *data, gdouble px, gdouble py)
gtk_plot_draw_text(plot, legend);
}
if(data->gradient->label_mask & GTK_PLOT_LABEL_OUT){
- legend.y = (gdouble)(area.y + y + lheight + roundint((data->gradient_line_height +
data->gradient->labels_offset) * m)) / (gdouble)area.height;
+ legend.y = (gdouble)(area.y + y + lheight + roundint(data->gradient_line_height * m ) +
roundint(data->gradient->labels_offset * m)) / (gdouble)area.height;
legend.justification = GTK_JUSTIFY_CENTER;
gtk_plot_draw_text(plot, legend);
}
@@ -2910,7 +3524,7 @@ draw_gradient_horizontal(GtkPlotData *data, gdouble px, gdouble py)
rx, y,
rx, y + roundint(data->gradient->ticks_length * m));
gtk_plot_pc_draw_line(plot->pc,
- rx, y + roundint((data->gradient_line_height - data->gradient->ticks_length)* m),
+ rx, y + roundint(data->gradient_line_height * m) -
roundint(data->gradient->ticks_length * m),
rx,
y + roundint(data->gradient_line_height * m));
}
@@ -2990,20 +3604,40 @@ gtk_plot_data_get_legend_size(GtkPlotData *data, gint *width, gint *height)
}
}
+/**
+ * gtk_plot_data_gradient:
+ * @data: a #GtkPlotData widget.
+ *
+ * Return value: (transfer none) the gradient #GtkPlotAxis
+ */
GtkPlotAxis *
gtk_plot_data_gradient (GtkPlotData *data)
{
return data->gradient;
}
+/**
+ * gtk_plot_data_move_gradient:
+ * @data: a #GtkPlotData widget.
+ * @x:
+ * @y:
+ *
+ *
+ */
void
gtk_plot_data_move_gradient(GtkPlotData *data, gdouble x, gdouble y)
{
data->gradient_x = x;
data->gradient_y = y;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_CHANGED], 0);
}
+/**
+ * gtk_plot_data_get_gradient_allocation:
+ * @data: a #GtkPlotData widget
+ *
+ * Return value: (transfer full) the gradient #GtkAllocation
+ */
GtkAllocation
gtk_plot_data_get_gradient_allocation(GtkPlotData *data)
{
@@ -3011,10 +3645,12 @@ gtk_plot_data_get_gradient_allocation(GtkPlotData *data)
GtkAllocation allocation;
GtkPlot *plot = NULL;
gint width, height;
+ GtkAllocation plot_allocation;
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &plot_allocation);
+ area.x = plot_allocation.x;
+ area.y = plot_allocation.y;
allocation.x = roundint(area.x + plot->internal_allocation.x + plot->internal_allocation.width *
data->gradient_x);
allocation.y = roundint(area.y + plot->internal_allocation.y + plot->internal_allocation.height *
data->gradient_y);
@@ -3024,7 +3660,13 @@ gtk_plot_data_get_gradient_allocation(GtkPlotData *data)
return allocation;
}
-
+/**
+ * gtk_plot_data_set_gradient_size:
+ * @data: a #GtkPlotData widget.
+ * @size:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient_size(GtkPlotData *data, gint size)
{
@@ -3333,6 +3975,14 @@ gtk_plot_data_real_draw_symbol (GtkPlotData *data,
}
+/**
+ * gtk_plot_data_draw_symbol:
+ * @data: a #GtkPlotData widget.
+ * @px:
+ * @py:
+ *
+ *
+ */
void
gtk_plot_data_draw_symbol (GtkPlotData *data, gdouble px, gdouble py)
{
@@ -3463,6 +4113,7 @@ gtk_plot_data_draw_xyz (GtkPlotData *dataset, gint npoints)
gdouble px, py;
gdouble x0, y0;
gdouble *array_x = NULL, *array_y = NULL, *array_z = NULL;
+ GtkAllocation allocation;
plot = dataset->plot;
widget = GTK_WIDGET(plot);
@@ -3479,15 +4130,16 @@ gtk_plot_data_draw_xyz (GtkPlotData *dataset, gint npoints)
widget = GTK_WIDGET(plot);
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(widget, &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
- clip_area.x = area.x + roundint(plot->x * widget->allocation.width);
- clip_area.y = area.y + roundint(plot->y * widget->allocation.height);
- clip_area.width = roundint(plot->width * widget->allocation.width);
- clip_area.height = roundint(plot->height * widget->allocation.height);
+ clip_area.x = area.x + roundint(plot->x * allocation.width);
+ clip_area.y = area.y + roundint(plot->y * allocation.height);
+ clip_area.width = roundint(plot->width * allocation.width);
+ clip_area.height = roundint(plot->height * allocation.height);
if(plot->clip_data && !GTK_IS_PLOT3D(plot)) gtk_plot_pc_clip(plot->pc, &clip_area);
@@ -4022,19 +4674,20 @@ gtk_plot_data_connect_points(GtkPlotData *dataset, gint npoints)
gdouble xmin, xmax;
gint num_points = dataset->num_points;
gint first = 0, last = num_points;
+ GtkAllocation allocation;
plot = dataset->plot;
widget = GTK_WIDGET(plot);
+ gtk_widget_get_allocation(widget, &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
- area.x = widget->allocation.x;
- area.y = widget->allocation.y;
- area.width = widget->allocation.width;
- area.height = widget->allocation.height;
-
- clip_area.x = area.x + roundint(plot->x * widget->allocation.width);
- clip_area.y = area.y + roundint(plot->y * widget->allocation.height);
- clip_area.width = roundint(plot->width * widget->allocation.width);
- clip_area.height = roundint(plot->height * widget->allocation.height);
+ clip_area.x = area.x + roundint(plot->x * allocation.width);
+ clip_area.y = area.y + roundint(plot->y * allocation.height);
+ clip_area.width = roundint(plot->width * allocation.width);
+ clip_area.height = roundint(plot->height * allocation.height);
if(dataset->line.line_style == GTK_PLOT_LINE_NONE) return;
npoints = MIN(npoints, dataset->num_points);
@@ -4249,6 +4902,15 @@ gtk_plot_data_connect_points(GtkPlotData *dataset, gint npoints)
}
/* New implementation */
+
+/**
+ * gtk_plot_data_find_dimension:
+ * @data: a #GtkPlotData widget.
+ * @name: dimension name to be searched for
+ *
+ * Return value: (transfer none): the #GtkPlotArray with the
+ * given name
+ */
GtkPlotArray *
gtk_plot_data_find_dimension(GtkPlotData *data, const gchar *name)
{
@@ -4265,12 +4927,24 @@ gtk_plot_data_find_dimension(GtkPlotData *data, const gchar *name)
return NULL;
}
+/**
+ * gtk_plot_data_add_dimension:
+ * @data: a #GtkPlotData widget.
+ * @label:
+ * @name:
+ * @desc:
+ * @value_type:
+ * @required:
+ * @independent:
+ *
+ *
+ */
void
gtk_plot_data_add_dimension(GtkPlotData *data,
const gchar *name,
const gchar *label,
const gchar *desc,
- GtkType value_type,
+ GType value_type,
gboolean required,
gboolean independent)
{
@@ -4287,6 +4961,13 @@ gtk_plot_data_add_dimension(GtkPlotData *data,
}
}
+/**
+ * gtk_plot_data_remove_dimension:
+ * @data: a #GtkPlotData widget.
+ * @name:
+ *
+ *
+ */
void
gtk_plot_data_remove_dimension(GtkPlotData *data,
const gchar *name)
@@ -4305,6 +4986,14 @@ gtk_plot_data_remove_dimension(GtkPlotData *data,
}
}
+/**
+ * gtk_plot_data_dimension_set_array:
+ * @data: a #GtkPlotData widget.
+ * @name:
+ * @array:
+ *
+ *
+ */
void
gtk_plot_data_dimension_set_array(GtkPlotData *data,
const gchar *name,
@@ -4320,19 +5009,35 @@ gtk_plot_data_dimension_set_array(GtkPlotData *data,
}
}
+/**
+ * gtk_plot_data_dimension_set_points:
+ * @data: a #GtkPlotData widget.
+ * @name: the dimension name affected
+ * @points:
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_dimension_set_points(GtkPlotData *data,
const gchar *name, gdouble *points)
{
GtkPlotArray *dim;
dim = gtk_plot_data_find_dimension(data, name);
- if(dim && dim->type == GTK_TYPE_DOUBLE){
+ if(dim && dim->type == G_TYPE_DOUBLE){
dim->data.data_double = points;
dim->own_data = FALSE;
}
return dim;
}
+/**
+ * gtk_plot_data_dimension_get_array:
+ * @data: a #GtkPlotData widget.
+ * @name: the dimension name to be searched
+ *
+ * Return value: (transfer none) the #GtkPlotArray with the
+ * given name
+ */
GtkPlotArray *
gtk_plot_data_dimension_get_array(GtkPlotData *data,
const gchar *name)
@@ -4342,6 +5047,14 @@ gtk_plot_data_dimension_get_array(GtkPlotData *data,
return dim;
}
+/**
+ * gtk_plot_data_required_dimensions:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
guint
gtk_plot_data_required_dimensions(GtkPlotData *data)
{
@@ -4356,6 +5069,14 @@ gtk_plot_data_required_dimensions(GtkPlotData *data)
return n;
}
+/**
+ * gtk_plot_data_independent_dimensions:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
guint
gtk_plot_data_independent_dimensions(GtkPlotData *data)
{
@@ -4410,12 +5131,30 @@ gtk_plot_data_independent_dimensions(GtkPlotData *data)
* gtk_plot_data_hide
******************************************/
+/**
+ * gtk_plot_data_draw_points:
+ * @data: a #GtkPlotData widget.
+ * @npoints:
+ *
+ *
+ */
void
gtk_plot_data_draw_points(GtkPlotData *data, gint npoints)
{
gtk_plot_data_real_draw(data, npoints);
}
+/**
+ * gtk_plot_data_set_points:
+ * @data: a #GtkPlotData widget.
+ * @x:
+ * @y:
+ * @dx:
+ * @dy:
+ * num_points:
+ *
+ *
+ */
void
gtk_plot_data_set_points(GtkPlotData *data,
gdouble *x, gdouble *y,
@@ -4429,20 +5168,48 @@ gtk_plot_data_set_points(GtkPlotData *data,
gtk_plot_data_set_numpoints(data, num_points);
}
+/**
+ * gtk_plot_data_get_points:
+ * @dataset: a #GtkPlotData widget.
+ * @x:
+ * @y:
+ * @dx:
+ * @dy:
+ * @num_points:
+ *
+ *
+ */
void
-gtk_plot_data_get_points(GtkPlotData *data,
+gtk_plot_data_get_points(GtkPlotData *dataset,
gdouble **x, gdouble **y,
gdouble **dx, gdouble **dy,
gint *num_points)
{
gint n;
- *x = gtk_plot_data_get_x(data, &n);
- *y = gtk_plot_data_get_y(data, &n);
- *dx = gtk_plot_data_get_dx(data, &n);
- *dy = gtk_plot_data_get_dy(data, &n);
- *num_points = data->num_points;
-}
-
+ *x = gtk_plot_data_get_x(dataset, &n);
+ *y = gtk_plot_data_get_y(dataset, &n);
+ *dx = gtk_plot_data_get_dx(dataset, &n);
+ *dy = gtk_plot_data_get_dy(dataset, &n);
+ *num_points = dataset->num_points;
+}
+
+/**
+ * gtk_plot_data_get_point:
+ * @dataset: a #GtkPlotData widget.
+ * @n:
+ * @x:
+ * @y:
+ * @z:
+ * @a:
+ * @dx:
+ * @dy:
+ * @dz:
+ * @da:
+ * @label:
+ * @error:
+ *
+ *
+ */
void
gtk_plot_data_get_point(GtkPlotData *dataset, gint n,
gdouble *x, gdouble *y, gdouble *z, gdouble *a,
@@ -4496,6 +5263,13 @@ gtk_plot_data_get_point(GtkPlotData *dataset, gint n,
}
}
+/**
+ * gtk_plot_data_set_x:
+ * @data: a #GtkPlotData widget.
+ * @x: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_x(GtkPlotData *data,
gdouble *x)
@@ -4505,6 +5279,13 @@ gtk_plot_data_set_x(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_y:
+ * @data: a #GtkPlotData widget.
+ * @y: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_y(GtkPlotData *data,
gdouble *y)
@@ -4514,6 +5295,13 @@ gtk_plot_data_set_y(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_z:
+ * @data: a #GtkPlotData widget.
+ * @z: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_z(GtkPlotData *data,
gdouble *z)
@@ -4523,6 +5311,13 @@ gtk_plot_data_set_z(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_a:
+ * @data: a #GtkPlotData widget.
+ * @a: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_a(GtkPlotData *data,
gdouble *a)
@@ -4532,6 +5327,13 @@ gtk_plot_data_set_a(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_dx:
+ * @data: a #GtkPlotData widget.
+ * @dx: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_dx(GtkPlotData *data,
gdouble *dx)
@@ -4541,6 +5343,13 @@ gtk_plot_data_set_dx(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_dy:
+ * @data: a #GtkPlotData widget.
+ * @dy: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_dy(GtkPlotData *data,
gdouble *dy)
@@ -4550,16 +5359,29 @@ gtk_plot_data_set_dy(GtkPlotData *data,
return array;
}
-
+/**
+ * gtk_plot_data_set_dz:
+ * @data: a #GtkPlotData widget.
+ * @dz: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_dz(GtkPlotData *data,
gdouble *dz)
{
GtkPlotArray *array;
- array = gtk_plot_data_dimension_set_points(data, "ErrZ", dz);
+ array = gtk_plot_data_dimension_set_points(data, "dz", dz);
return array;
}
+/**
+ * gtk_plot_data_set_da:
+ * @data: a #GtkPlotData widget.
+ * @da: value to be updated
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_da(GtkPlotData *data,
gdouble *da)
@@ -4569,6 +5391,13 @@ gtk_plot_data_set_da(GtkPlotData *data,
return array;
}
+/**
+ * gtk_plot_data_set_a_scale:
+ * @data: a #GtkPlotData widget.
+ * @a_scale:
+ *
+ *
+ */
void
gtk_plot_data_set_a_scale(GtkPlotData *data, gdouble a_scale)
{
@@ -4576,7 +5405,13 @@ gtk_plot_data_set_a_scale(GtkPlotData *data, gdouble a_scale)
if(dim) gtk_plot_array_set_scale(dim, a_scale);
}
-
+/**
+ * gtk_plot_data_set_labels:
+ * @data: a #GtkPlotData widget.
+ * @labels: labels to be set
+ *
+ * Return value: (transfer none) the affected #GtkPlotArray
+ */
GtkPlotArray *
gtk_plot_data_set_labels(GtkPlotData *data,
gchar **labels)
@@ -4592,7 +5427,15 @@ gtk_plot_data_set_labels(GtkPlotData *data,
return dim;
}
-
+/**
+ * gtk_plot_data_get_x:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_x(GtkPlotData *dataset, gint *num_points)
{
@@ -4605,6 +5448,15 @@ gtk_plot_data_get_x(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_y:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_y(GtkPlotData *dataset, gint *num_points)
{
@@ -4617,6 +5469,15 @@ gtk_plot_data_get_y(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_z:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_z(GtkPlotData *dataset, gint *num_points)
{
@@ -4629,6 +5490,15 @@ gtk_plot_data_get_z(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_a:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_a(GtkPlotData *dataset, gint *num_points)
{
@@ -4641,6 +5511,15 @@ gtk_plot_data_get_a(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_dx:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_dx(GtkPlotData *dataset, gint *num_points)
{
@@ -4653,6 +5532,15 @@ gtk_plot_data_get_dx(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_dy:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_dy(GtkPlotData *dataset, gint *num_points)
{
@@ -4665,11 +5553,20 @@ gtk_plot_data_get_dy(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_dz:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_dz(GtkPlotData *dataset, gint *num_points)
{
GtkPlotArray *array;
- array = gtk_plot_data_dimension_get_array(dataset, "ErrZ");
+ array = gtk_plot_data_dimension_get_array(dataset, "dz");
if(array){
*num_points = gtk_plot_array_get_size(array);
return gtk_plot_array_get_double(array);
@@ -4677,6 +5574,15 @@ gtk_plot_data_get_dz(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_da:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ *
+ * Return value:
+ */
gdouble *
gtk_plot_data_get_da(GtkPlotData *dataset, gint *num_points)
{
@@ -4689,6 +5595,14 @@ gtk_plot_data_get_da(GtkPlotData *dataset, gint *num_points)
return NULL;
}
+/**
+ * gtk_plot_data_get_a_scale:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_data_get_a_scale(GtkPlotData *dataset)
{
@@ -4697,7 +5611,13 @@ gtk_plot_data_get_a_scale(GtkPlotData *dataset)
return 0.;
}
-
+/**
+ * gtk_plot_data_get_labels:
+ * @dataset: a #GtkPlotData widget.
+ * @show_labels: (out): current setting
+ *
+ * Return value: (transfer none) the label string array
+ */
gchar **
gtk_plot_data_get_labels(GtkPlotData *dataset, gboolean *show_labels)
{
@@ -4708,12 +5628,30 @@ gtk_plot_data_get_labels(GtkPlotData *dataset, gboolean *show_labels)
return NULL;
}
+/**
+ * gtk_plot_data_show_labels:
+ * @dataset: a #GtkPlotData widget.
+ * @show_labels:
+ *
+ *
+ */
void
gtk_plot_data_show_labels(GtkPlotData *dataset, gboolean show_labels)
{
dataset->show_labels = show_labels;
}
+/**
+ * gtk_plot_data_labels_set_attributes:
+ * @data: a #GtkPlotData widget.
+ * @font:
+ * @height:
+ * @angle:
+ * @fg:
+ * @bg:
+ *
+ *
+ */
void
gtk_plot_data_labels_set_attributes (GtkPlotData *data,
const gchar *font,
@@ -4742,26 +5680,52 @@ gtk_plot_data_labels_set_attributes (GtkPlotData *data,
}
-
+/**
+ * gtk_plot_data_set_numpoints:
+ * @dataset: a #GtkPlotData widget.
+ * @num_points:
+ *
+ *
+ */
void
-gtk_plot_data_set_numpoints(GtkPlotData *dataset, gint numpoints)
+gtk_plot_data_set_numpoints(GtkPlotData *dataset, gint num_points)
{
GList *list;
- dataset->num_points = numpoints;
+ dataset->num_points = num_points;
list = dataset->data->arrays;
while(list){
GtkPlotArray *array = GTK_PLOT_ARRAY(list->data);
- array->size = numpoints;
+ array->size = num_points;
list = list->next;
}
}
+/**
+ * gtk_plot_data_data_get_numpoints:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_data_get_numpoints(GtkPlotData *dataset)
{
return(dataset->num_points);
}
+/**
+ * gtk_plot_data_set_symbol:
+ * @dataset: a #GtkPlotData widget.
+ * @type:
+ * @style:
+ * @size:
+ * @line_width:
+ * @color:
+ * @border_color:
+ *
+ *
+ */
void
gtk_plot_data_set_symbol (GtkPlotData *dataset,
GtkPlotSymbolType type,
@@ -4777,6 +5741,18 @@ gtk_plot_data_set_symbol (GtkPlotData *dataset,
dataset->symbol.color = *color;
}
+/**
+ * gtk_plot_data_get_symbol:
+ * @dataset: a #GtkPlotData widget.
+ * @type:
+ * @style:
+ * @size:
+ * @line_width:
+ * @color:
+ * @border_color:
+ *
+ *
+ */
void
gtk_plot_data_get_symbol (GtkPlotData *dataset,
GtkPlotSymbolType *type,
@@ -4792,6 +5768,17 @@ gtk_plot_data_get_symbol (GtkPlotData *dataset,
*border_color = dataset->symbol.border.color;
}
+/**
+ * gtk_plot_data_set_line_attributes:
+ * @dataset: a #GtkPlotData widget.
+ * @style:
+ * @cap_style:
+ * @join_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_set_line_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
@@ -4807,6 +5794,17 @@ gtk_plot_data_set_line_attributes (GtkPlotData *dataset,
dataset->line.color = *color;
}
+/**
+ * gtk_plot_data_get_line_attributes:
+ * @dataset: a #GtkPlotData widget.
+ * @style:
+ * @cap_style:
+ * @join_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_get_line_attributes (GtkPlotData *dataset,
GtkPlotLineStyle *style,
@@ -4823,6 +5821,13 @@ gtk_plot_data_get_line_attributes (GtkPlotData *dataset,
}
+/**
+ * gtk_plot_data_set_connector:
+ * @dataset: a #GtkPlotData widget.
+ * @connector:
+ *
+ *
+ */
void
gtk_plot_data_set_connector (GtkPlotData *dataset,
GtkPlotConnector connector)
@@ -4830,12 +5835,31 @@ gtk_plot_data_set_connector (GtkPlotData *dataset,
dataset->line_connector = connector;
}
+/**
+ * gtk_plot_data_get_connector:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_data_get_connector (GtkPlotData *dataset)
{
return (dataset->line_connector);
}
+/**
+ * gtk_plot_data_set_x_attributes:
+ * @dataset: a #GtkPlotData widget.
+ * @style:
+ * @cap_style:
+ * @join_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_set_x_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
@@ -4851,6 +5875,17 @@ gtk_plot_data_set_x_attributes (GtkPlotData *dataset,
dataset->x_line.color = *color;
}
+/**
+ * gtk_plot_data_set_y_attributes:
+ * @dataset: a #GtkPlotData widget.
+ * @style:
+ * @cap_style:
+ * @join_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_set_y_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
@@ -4866,6 +5901,17 @@ gtk_plot_data_set_y_attributes (GtkPlotData *dataset,
dataset->y_line.color = *color;
}
+/**
+ * gtk_plot_data_set_z_attributes:
+ * @dataset: a #GtkPlotData widget.
+ * @style:
+ * @cap_style:
+ * @join_style:
+ * @width:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_set_z_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
@@ -4882,67 +5928,136 @@ gtk_plot_data_set_z_attributes (GtkPlotData *dataset,
}
+/**
+ * gtk_plot_data_show_xerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_show_xerrbars(GtkPlotData *dataset)
{
dataset->show_xerrbars = TRUE;
}
+/**
+ * gtk_plot_data_show_yerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_show_yerrbars(GtkPlotData *dataset)
{
dataset->show_yerrbars = TRUE;
}
+/**
+ * gtk_plot_data_show_zerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_show_zerrbars(GtkPlotData *dataset)
{
dataset->show_zerrbars = TRUE;
}
-
+/**
+ * gtk_plot_data_hide_xerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_hide_xerrbars(GtkPlotData *dataset)
{
dataset->show_xerrbars = FALSE;
}
+/**
+ * gtk_plot_data_hide_yerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_hide_yerrbars(GtkPlotData *dataset)
{
dataset->show_yerrbars = FALSE;
}
+/**
+ * gtk_plot_data_hide_zerrbars:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_hide_zerrbars(GtkPlotData *dataset)
{
dataset->show_zerrbars = FALSE;
}
+/**
+ * gtk_plot_data_fill_area:
+ * @dataset: a #GtkPlotData widget.
+ * @fill:
+ *
+ *
+ */
void
gtk_plot_data_fill_area(GtkPlotData *dataset, gboolean fill)
{
dataset->fill_area = fill;
}
+/**
+ * gtk_plot_data_area_is_filled:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_data_area_is_filled(GtkPlotData *dataset)
{
return (dataset->fill_area);
}
+/**
+ * gtk_plot_data_whow_legend:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_show_legend(GtkPlotData *dataset)
{
dataset->show_legend = TRUE;
}
+/**
+ * gtk_plot_data_hide_legend:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_hide_legend(GtkPlotData *dataset)
{
dataset->show_legend = FALSE;
}
+/**
+ * gtk_plot_data_set_legend:
+ * @dataset: a #GtkPlotData widget.
+ * @legend:
+ *
+ *
+ */
void
gtk_plot_data_set_legend(GtkPlotData *dataset,
const gchar *legend)
@@ -4953,13 +6068,26 @@ gtk_plot_data_set_legend(GtkPlotData *dataset,
}
}
+/**
+ * gtk_plot_data_set_legend_precision:
+ * @dataset: a #GtkPlotData widget.
+ * @precision:
+ *
+ *
+ */
void
-gtk_plot_data_set_legend_precision (GtkPlotData *data,
+gtk_plot_data_set_legend_precision (GtkPlotData *dataset,
gint precision)
{
- data->legends_precision = precision;
+ dataset->legends_precision = precision;
}
+/**
+ * gtk_plot_data_get_legend_precision:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
gint
gtk_plot_data_get_legend_precision (GtkPlotData *data)
{
@@ -4967,7 +6095,13 @@ gtk_plot_data_get_legend_precision (GtkPlotData *data)
return (data->legends_precision);
}
-
+/**
+ * gtk_plot_data_set_name:
+ * @dataset: a #GtkPlotData widget.
+ * @name:
+ *
+ *
+ */
void
gtk_plot_data_set_name(GtkPlotData *dataset, const gchar *name)
{
@@ -4977,49 +6111,132 @@ gtk_plot_data_set_name(GtkPlotData *dataset, const gchar *name)
dataset->name = g_strdup(name);
}
+/**
+ * gtk_plot_data_set_link:
+ * @dataset: a #GtkPlotData widget.
+ * @link:
+ *
+ *
+ */
void
gtk_plot_data_set_link(GtkPlotData *dataset, gpointer link)
{
dataset->link = link;
}
+/**
+ * gtk_plot_data_get_link:
+ * @dataset: a #GtkPlotData widget.
+ *
+ * Returns: (transfer none) link pointer
+ */
gpointer
gtk_plot_data_get_link(GtkPlotData *dataset)
{
return(dataset->link);
}
+/**
+ * gtk_plot_data_remove_link:
+ * @dataset: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_remove_link(GtkPlotData *dataset)
{
dataset->link = NULL;
}
+/**
+ * gtk_plot_data_set_gradient_show_lt_gt:
+ * @data: a #GtkPlotData widget.
+ * @show:
+ *
+ *
+ */
+void
+gtk_plot_data_set_gradient_show_lt_gt (GtkPlotData *data, gboolean show)
+{
+ data->gradient_show_lt_gt = show;
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
+}
+
+/**
+ * gtk_plot_data_gradient_show_lt_gt:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
+gboolean
+gtk_plot_data_gradient_show_lt_gt (GtkPlotData *data)
+{
+ return (data->gradient_show_lt_gt);
+}
+
+/**
+ * gtk_plot_data_set_gradient_mask:
+ * @data: a #GtkPlotData widget.
+ * @mask:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient_mask (GtkPlotData *data, gint mask)
{
data->gradient_mask = mask;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
}
+/**
+ * gtk_plot_data_get_gradient_mask:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gint
gtk_plot_data_get_gradient_mask (GtkPlotData *data)
{
return (data->gradient_mask);
}
+/**
+ * gtk_plot_data_set_visible:
+ * @data: a #GtkPlotData widget.
+ * @visible:
+ *
+ *
+ */
void
gtk_plot_data_gradient_set_visible (GtkPlotData *data, gboolean visible)
{
data->show_gradient = visible;
}
+/**
+ * gtk_plot_data_gradient_visible:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_data_gradient_visible (GtkPlotData *data)
{
return(data->show_gradient);
}
+/**
+ * gtk_plot_data_gradient_auoscale_a:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_gradient_autoscale_a (GtkPlotData *data)
{
@@ -5048,6 +6265,12 @@ gtk_plot_data_gradient_autoscale_a (GtkPlotData *data)
real_autoscale_gradient(data, amin, amax);
}
+/**
+ * gtk_plot_data_gradient_autoscale_da:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_gradient_autoscale_da (GtkPlotData *data)
{
@@ -5075,6 +6298,12 @@ gtk_plot_data_gradient_autoscale_da (GtkPlotData *data)
real_autoscale_gradient(data, amin, amax);
}
+/**
+ * gtk_plot_data_gradient_autoscale_z:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_gradient_autoscale_z (GtkPlotData *data)
{
@@ -5112,6 +6341,14 @@ real_autoscale_gradient(GtkPlotData *data, gdouble xmin, gdouble xmax)
data->legends_style = data->gradient->ticks.scale == GTK_PLOT_SCALE_LINEAR ? GTK_PLOT_LABEL_FLOAT :
GTK_PLOT_LABEL_EXP;
}
+/**
+ * gtk_plot_data_set_gradient_colors:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient_colors (GtkPlotData *data,
const GdkColor *min,
@@ -5119,9 +6356,17 @@ gtk_plot_data_set_gradient_colors (GtkPlotData *data,
{
data->color_min= *min;
data->color_max = *max;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
}
+/**
+ * gtk_plot_data_get_gradient_colors:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ *
+ *
+ */
void
gtk_plot_data_get_gradient_colors (GtkPlotData *data,
GdkColor *min,
@@ -5131,6 +6376,14 @@ gtk_plot_data_get_gradient_colors (GtkPlotData *data,
max = &data->color_max;
}
+/**
+ * gtk_plot_data_set_gradient_nth_color:
+ * @data: a #GtkPlotData widget.
+ * @level:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient_nth_color (GtkPlotData *data,
guint level,
@@ -5140,9 +6393,18 @@ gtk_plot_data_set_gradient_nth_color (GtkPlotData *data,
if(level > data->gradient->ticks.nticks) return;
data->gradient_colors[level] = *color;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
}
+/**
+ * gtk_plot_data_get_gradient_nth_color:
+ * @data: a #GtkPlotData widget.
+ * @level:
+ *
+ *
+ *
+ * Return value:
+ */
const GdkColor *
gtk_plot_data_get_gradient_nth_color (GtkPlotData *data,
guint level)
@@ -5151,6 +6413,14 @@ gtk_plot_data_get_gradient_nth_color (GtkPlotData *data,
return &data->gradient_colors[level];
}
+/**
+ * gtk_plot_data_set_gradient_outer_colors:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient_outer_colors (GtkPlotData *data,
const GdkColor *min,
@@ -5158,9 +6428,17 @@ gtk_plot_data_set_gradient_outer_colors (GtkPlotData *data,
{
data->color_lt_min = *min;
data->color_gt_max = *max;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
}
+/**
+ * gtk_plot_data_get_gradient_outer_colors:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ *
+ *
+ */
void
gtk_plot_data_get_gradient_outer_colors (GtkPlotData *data,
GdkColor *min,
@@ -5170,6 +6448,16 @@ gtk_plot_data_get_gradient_outer_colors (GtkPlotData *data,
max = &data->color_gt_max;
}
+/**
+ * gtk_plot_data_set_gradient:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ * @nlevels:
+ * @nsublevels:
+ *
+ *
+ */
void
gtk_plot_data_set_gradient (GtkPlotData *data,
gdouble min, gdouble max,
@@ -5185,6 +6473,16 @@ gtk_plot_data_set_gradient (GtkPlotData *data,
gtk_plot_data_reset_gradient(data);
}
+/**
+ * gtk_plot_data_get_gradient:
+ * @data: a #GtkPlotData widget.
+ * @min:
+ * @max:
+ * @nlevels:
+ * @nsublevels:
+ *
+ *
+ */
void
gtk_plot_data_get_gradient (GtkPlotData *data,
gdouble *min, gdouble *max,
@@ -5196,6 +6494,14 @@ gtk_plot_data_get_gradient (GtkPlotData *data,
*nsublevels = data->gradient->ticks.nminor;
}
+/**
+ * gtk_plot_data_get_gradient_level:
+ * @data: a #GtkPlotData widget.
+ * @level:
+ * @color:
+ *
+ *
+ */
void
gtk_plot_data_get_gradient_level (GtkPlotData *data, gdouble level, GdkColor *color)
{
@@ -5271,15 +6577,30 @@ gtk_plot_data_get_gradient_level (GtkPlotData *data, gdouble level, GdkColor *co
gdk_color_alloc(gtk_widget_get_colormap(GTK_WIDGET(data)), color);
}
+/**
+ * gtk_plot_data_gradient_set_style:
+ * @data: a #GtkPlotData widget.
+ * @style:
+ * @precision:
+ *
+ *
+ */
void
gtk_plot_data_gradient_set_style (GtkPlotData *data,
GtkPlotLabelStyle style,
gint precision)
{
- data->gradient->label_style = style;
+ data->gradient->label_style = style,
data->gradient->label_precision = precision;
}
+/**
+ * gtk_plot_data_gradient_set_scale:
+ * @data: a #GtkPlotData widget.
+ * @scale:
+ *
+ *
+ */
void gtk_plot_data_gradient_set_scale (GtkPlotData *data,
GtkPlotScale scale)
{
@@ -5465,8 +6786,6 @@ spline_eval (int n, gdouble x[], gdouble y[], gdouble y2[], gdouble val)
void
gtk_plot_data_reset_gradient(GtkPlotData *data)
{
- gdouble min, max;
- gint nmajorticks = data->gradient->ticks.nmajorticks;
data->gradient->ticks.step = (data->gradient->ticks.max -
data->gradient->ticks.min)/data->gradient->ticks.nmajorticks;
gtk_plot_axis_ticks_recalc(data->gradient);
@@ -5483,11 +6802,17 @@ gtk_plot_data_reset_gradient(GtkPlotData *data)
data->gradient->ticks.values[0].value = min;
data->gradient->ticks.values[data->gradient->ticks.nticks-1].value = max;
*/
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_CHANGED], 0);
gtk_plot_data_reset_gradient_colors(data);
}
+/**
+ * gtk_plot_data_reset_gradient_colors:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_reset_gradient_colors(GtkPlotData *data)
{
@@ -5530,21 +6855,45 @@ gtk_plot_data_reset_gradient_colors(GtkPlotData *data)
data->gradient->ticks.min = min;
data->gradient_custom = custom;
data->gradient->ticks.nminor = nminor;
- gtk_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED]);
+ g_signal_emit(GTK_OBJECT(data), data_signals[GRADIENT_COLORS_CHANGED], 0);
}
+/**
+ * gtk_plot_data_gradient_use_custom_colors:
+ * @data: a #GtkPlotData widget.
+ * @custom:
+ *
+ *
+ */
void
gtk_plot_data_gradient_use_custom_colors(GtkPlotData *data, gboolean custom)
{
data->gradient_custom = custom;
}
+/**
+ * gtk_plot_data_gradient_custom_colors:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_data_gradient_custom_colors(GtkPlotData *data)
{
return(data->gradient_custom);
}
+/**
+ * gtk_plot_data_add_marker:
+ * @data: a #GtkPlotData widget.
+ * @point:
+ *
+ *
+ *
+ * Return value:
+ */
GtkPlotMarker *
gtk_plot_data_add_marker(GtkPlotData *data, guint point)
{
@@ -5573,6 +6922,15 @@ gtk_plot_data_add_marker(GtkPlotData *data, guint point)
return (marker);
}
+/**
+ * gtk_plot_data_remove_marker:
+ * @data: a #GtkPlotData widget.
+ * @marker:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_data_remove_marker(GtkPlotData *data, GtkPlotMarker *marker)
{
@@ -5595,6 +6953,12 @@ gtk_plot_data_remove_marker(GtkPlotData *data, GtkPlotMarker *marker)
return FALSE;
}
+/**
+ * gtk_plot_data_remove_markers:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ */
void
gtk_plot_data_remove_markers(GtkPlotData *data)
{
@@ -5611,12 +6975,27 @@ gtk_plot_data_remove_markers(GtkPlotData *data)
data->markers = NULL;
}
+/**
+ * gtk_plot_data_show_markers:
+ * @data: a #GtkPlotData widget.
+ * @show:
+ *
+ *
+ */
void
gtk_plot_data_show_markers(GtkPlotData *data, gboolean show)
{
data->show_markers = show;
}
+/**
+ * gtk_plot_data_markers_visible:
+ * @data: a #GtkPlotData widget.
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_data_markers_visible(GtkPlotData *data)
{
diff --git a/gtkextra/gtkplotdata.h b/gtkextra/gtkplotdata.h
index 2191d0d..ab778f2 100644
--- a/gtkextra/gtkplotdata.h
+++ b/gtkextra/gtkplotdata.h
@@ -26,24 +26,26 @@ extern "C" {
#include "gtkplot.h"
-#define GTK_PLOT_DATA(obj) GTK_CHECK_CAST (obj, gtk_plot_data_get_type (), GtkPlotData)
-#define GTK_TYPE_PLOT_DATA (gtk_plot_data_get_type ())
-#define GTK_PLOT_DATA_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_data_get_type(), GtkPlotDataClass)
-#define GTK_IS_PLOT_DATA(obj) GTK_CHECK_TYPE (obj, gtk_plot_data_get_type ())
+#define GTK_PLOT_DATA(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_data_get_type (), GtkPlotData)
+#define G_TYPE_PLOT_DATA (gtk_plot_data_get_type ())
+#define GTK_PLOT_DATA_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_data_get_type(),
GtkPlotDataClass)
+#define GTK_IS_PLOT_DATA(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_data_get_type ())
-GtkType gtk_plot_data_get_type (void);
+GType gtk_plot_data_get_type (void);
+GType gtk_plot_marker_get_type (void);
+
GtkWidget* gtk_plot_data_new (void);
GtkWidget* gtk_plot_data_new_function (GtkPlotFunc function);
void gtk_plot_data_construct_function (GtkPlotData *data,
GtkPlotFunc function);
-GtkWidget* gtk_plot_data_new_iterator (GtkPlotIterator iter,
+GtkWidget* gtk_plot_data_new_iterator (GtkPlotIterator iterator,
gint npoints,
- guint16 iterator_mask);
+ guint16 mask);
void gtk_plot_data_construct_iterator (GtkPlotData *data,
- GtkPlotIterator iter,
+ GtkPlotIterator iterator,
gint npoints,
- guint16 iterator_mask);
+ guint16 mask);
void gtk_plot_data_clone (GtkPlotData *data,
GtkPlotData *copy);
/* required dimensions, private use */
@@ -51,7 +53,7 @@ void gtk_plot_data_add_dimension (GtkPlotData *data,
const gchar *name,
const gchar *label,
const gchar *desc,
- GtkType data_type,
+ GType value_type,
gboolean required,
gboolean independent);
void gtk_plot_data_remove_dimension (GtkPlotData *data,
@@ -64,9 +66,9 @@ guint gtk_plot_data_independent_dimensions (GtkPlotData *data);
void gtk_plot_data_paint (GtkPlotData *data);
void gtk_plot_data_update (GtkPlotData *data);
void gtk_plot_data_draw_points (GtkPlotData *data,
- gint n);
+ gint npoints);
void gtk_plot_data_draw_symbol (GtkPlotData *data,
- gdouble x, gdouble y);
+ gdouble px, gdouble py);
GtkPlotArray * gtk_plot_data_dimension_set_points(GtkPlotData *data,
const gchar *name,
gdouble *points);
@@ -87,11 +89,11 @@ void gtk_plot_data_set_points (GtkPlotData *data,
gdouble *x, gdouble *y,
gdouble *dx, gdouble *dy,
gint num_points);
-void gtk_plot_data_get_points (GtkPlotData *data,
+void gtk_plot_data_get_points (GtkPlotData *dataset,
gdouble **x, gdouble **y,
gdouble **dx, gdouble **dy,
gint *num_points);
-void gtk_plot_data_get_point (GtkPlotData *data,
+void gtk_plot_data_get_point (GtkPlotData *dataset,
gint n,
gdouble *x, gdouble *y,
gdouble *z, gdouble *a,
@@ -106,7 +108,7 @@ GtkPlotArray * gtk_plot_data_set_y (GtkPlotData *data,
GtkPlotArray * gtk_plot_data_set_z (GtkPlotData *data,
gdouble *z);
GtkPlotArray * gtk_plot_data_set_a (GtkPlotData *data,
- gdouble *z);
+ gdouble *a);
GtkPlotArray * gtk_plot_data_set_dx (GtkPlotData *data,
gdouble *dx);
GtkPlotArray * gtk_plot_data_set_dy (GtkPlotData *data,
@@ -119,101 +121,101 @@ void gtk_plot_data_set_a_scale (GtkPlotData *data,
gdouble a_scale);
GtkPlotArray * gtk_plot_data_set_labels (GtkPlotData *data,
gchar **labels);
-gdouble * gtk_plot_data_get_x (GtkPlotData *data,
+gdouble * gtk_plot_data_get_x (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_y (GtkPlotData *data,
+gdouble * gtk_plot_data_get_y (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_z (GtkPlotData *data,
+gdouble * gtk_plot_data_get_z (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_a (GtkPlotData *data,
+gdouble * gtk_plot_data_get_a (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_dx (GtkPlotData *data,
+gdouble * gtk_plot_data_get_dx (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_dy (GtkPlotData *data,
+gdouble * gtk_plot_data_get_dy (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_dz (GtkPlotData *data,
+gdouble * gtk_plot_data_get_dz (GtkPlotData *dataset,
gint *num_points);
-gdouble * gtk_plot_data_get_da (GtkPlotData *data,
+gdouble * gtk_plot_data_get_da (GtkPlotData *dataset,
gint *num_points);
-gdouble gtk_plot_data_get_a_scale (GtkPlotData *data);
+gdouble gtk_plot_data_get_a_scale (GtkPlotData *dataset);
/*------------------------------------------------------------------------*/
-gchar ** gtk_plot_data_get_labels (GtkPlotData *data,
+gchar ** gtk_plot_data_get_labels (GtkPlotData *dataset,
gboolean *show_labels);
-void gtk_plot_data_show_labels (GtkPlotData *data,
+void gtk_plot_data_show_labels (GtkPlotData *dataset,
gboolean show_labels);
void gtk_plot_data_labels_set_attributes (GtkPlotData *data,
const gchar *font,
gint height,
gint angle,
- const GdkColor *foreground,
- const GdkColor *background);
-void gtk_plot_data_set_numpoints (GtkPlotData *data,
+ const GdkColor *fg,
+ const GdkColor *bg);
+void gtk_plot_data_set_numpoints (GtkPlotData *dataset,
gint num_points);
gint gtk_plot_data_get_numpoints (GtkPlotData *data);
-void gtk_plot_data_set_symbol (GtkPlotData *data,
+void gtk_plot_data_set_symbol (GtkPlotData *dataset,
GtkPlotSymbolType type,
GtkPlotSymbolStyle style,
gint size,
gfloat line_width,
const GdkColor *color,
const GdkColor *border_color);
-void gtk_plot_data_get_symbol (GtkPlotData *data,
+void gtk_plot_data_get_symbol (GtkPlotData *dataset,
GtkPlotSymbolType *type,
GtkPlotSymbolStyle *style,
gint *size,
gfloat *line_width,
GdkColor *color,
GdkColor *border_color);
-void gtk_plot_data_set_connector (GtkPlotData *data,
+void gtk_plot_data_set_connector (GtkPlotData *dataset,
GtkPlotConnector connector);
-gint gtk_plot_data_get_connector (GtkPlotData *data);
-void gtk_plot_data_set_line_attributes (GtkPlotData *data,
+gint gtk_plot_data_get_connector (GtkPlotData *dataset);
+void gtk_plot_data_set_line_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
GdkCapStyle cap_style,
GdkJoinStyle join_style,
gfloat width,
const GdkColor *color);
-void gtk_plot_data_get_line_attributes (GtkPlotData *data,
+void gtk_plot_data_get_line_attributes (GtkPlotData *dataset,
GtkPlotLineStyle *style,
GdkCapStyle *cap_style,
GdkJoinStyle *join_style,
gfloat *width,
GdkColor *color);
-void gtk_plot_data_set_x_attributes (GtkPlotData *data,
+void gtk_plot_data_set_x_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
GdkCapStyle cap_style,
GdkJoinStyle join_style,
gfloat width,
const GdkColor *color);
-void gtk_plot_data_set_y_attributes (GtkPlotData *data,
+void gtk_plot_data_set_y_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
GdkCapStyle cap_style,
GdkJoinStyle join_style,
gfloat width,
const GdkColor *color);
-void gtk_plot_data_set_z_attributes (GtkPlotData *data,
+void gtk_plot_data_set_z_attributes (GtkPlotData *dataset,
GtkPlotLineStyle style,
GdkCapStyle cap_style,
GdkJoinStyle join_style,
gfloat width,
const GdkColor *color);
-void gtk_plot_data_show_xerrbars (GtkPlotData *data);
-void gtk_plot_data_show_yerrbars (GtkPlotData *data);
-void gtk_plot_data_show_zerrbars (GtkPlotData *data);
-void gtk_plot_data_hide_xerrbars (GtkPlotData *data);
-void gtk_plot_data_hide_yerrbars (GtkPlotData *data);
-void gtk_plot_data_hide_zerrbars (GtkPlotData *data);
-void gtk_plot_data_fill_area (GtkPlotData *data,
+void gtk_plot_data_show_xerrbars (GtkPlotData *dataset);
+void gtk_plot_data_show_yerrbars (GtkPlotData *dataset);
+void gtk_plot_data_show_zerrbars (GtkPlotData *dataset);
+void gtk_plot_data_hide_xerrbars (GtkPlotData *dataset);
+void gtk_plot_data_hide_yerrbars (GtkPlotData *dataset);
+void gtk_plot_data_hide_zerrbars (GtkPlotData *dataset);
+void gtk_plot_data_fill_area (GtkPlotData *dataset,
gboolean fill);
-gboolean gtk_plot_data_area_is_filled (GtkPlotData *data);
+gboolean gtk_plot_data_area_is_filled (GtkPlotData *dataset);
void gtk_plot_data_show_legend (GtkPlotData *data);
-void gtk_plot_data_hide_legend (GtkPlotData *data);
+void gtk_plot_data_hide_legend (GtkPlotData *dataset);
void gtk_plot_data_set_legend (GtkPlotData *dataset,
const gchar *legend);
void gtk_plot_data_set_legend_precision (GtkPlotData *dataset,
gint precision);
-gint gtk_plot_data_get_legend_precision (GtkPlotData *dataset);
-void gtk_plot_data_set_name (GtkPlotData *data,
+gint gtk_plot_data_get_legend_precision (GtkPlotData *data);
+void gtk_plot_data_set_name (GtkPlotData *dataset,
const gchar *name);
GtkPlotAxis * gtk_plot_data_gradient (GtkPlotData *data);
GtkAllocation gtk_plot_data_get_gradient_allocation (GtkPlotData *data);
@@ -270,10 +272,10 @@ void gtk_plot_data_gradient_set_style (GtkPlotData *data,
gint precision);
void gtk_plot_data_gradient_set_scale (GtkPlotData *data,
GtkPlotScale scale);
-void gtk_plot_data_set_link (GtkPlotData *data,
+void gtk_plot_data_set_link (GtkPlotData *dataset,
gpointer link);
-gpointer gtk_plot_data_get_link (GtkPlotData *data);
-void gtk_plot_data_remove_link (GtkPlotData *data);
+gpointer gtk_plot_data_get_link (GtkPlotData *dataset);
+void gtk_plot_data_remove_link (GtkPlotData *dataset);
/* Markers */
diff --git a/gtkextra/gtkplotflux.c b/gtkextra/gtkplotflux.c
index 9f52571..b5ccd82 100644
--- a/gtkextra/gtkplotflux.c
+++ b/gtkextra/gtkplotflux.c
@@ -17,6 +17,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotflux
+ * @short_description:
+ *
+ * FIXME:: Need long description.
+ */
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -34,13 +41,13 @@ static void gtk_plot_flux_class_init (GtkPlotFluxClass *klass);
static void gtk_plot_flux_init (GtkPlotFlux *data);
static void gtk_plot_flux_destroy (GtkObject *data);
static void gtk_plot_flux_get_property (GObject *object,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
static void gtk_plot_flux_set_property (GObject *object,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
static void gtk_plot_flux_get_legend_size(GtkPlotData *data,
gint *width, gint *height);
@@ -79,26 +86,21 @@ enum {
static GtkPlotDataClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_flux_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotFlux",
- sizeof (GtkPlotFlux),
- sizeof (GtkPlotFluxClass),
- (GtkClassInitFunc) gtk_plot_flux_class_init,
- (GtkObjectInitFunc) gtk_plot_flux_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (gtk_plot_data_get_type(), &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_plot_data_get_type(),
+ "GtkPlotFlux",
+ sizeof (GtkPlotFluxClass),
+ (GClassInitFunc) gtk_plot_flux_class_init,
+ sizeof (GtkPlotFlux),
+ (GInstanceInitFunc) gtk_plot_flux_init,
+ 0);
}
return data_type;
}
@@ -111,7 +113,7 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
GtkPlotDataClass *data_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_data_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_data_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -121,6 +123,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
gobject_class->get_property = gtk_plot_flux_get_property;
object_class->destroy = gtk_plot_flux_destroy;
+
+ /**
+ * GtkPlotFlux:centered:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_CENTERED,
g_param_spec_boolean ("centered",
@@ -128,6 +136,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_STYLE,
g_param_spec_int ("style",
@@ -135,6 +149,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:width:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_WIDTH,
g_param_spec_int ("width",
@@ -142,6 +162,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:length:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LENGTH,
g_param_spec_int ("length",
@@ -149,6 +175,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:scale_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SCALE_MAX,
g_param_spec_double ("scale_max",
@@ -156,6 +188,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXDOUBLE,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:size_max:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SIZE_MAX,
g_param_spec_int ("size_max",
@@ -163,6 +201,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:show_scale:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_SHOW_SCALE,
g_param_spec_boolean ("show_scale",
@@ -170,6 +214,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
FALSE,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:labels_precision:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABEL_PRECISION,
g_param_spec_int ("labels_precision",
@@ -177,6 +227,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:labels_style:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABEL_STYLE,
g_param_spec_int ("labels_style",
@@ -184,6 +240,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
0,G_MAXINT,0,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:labels_prefix:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABEL_PREFIX,
g_param_spec_string ("labels_prefix",
@@ -191,6 +253,12 @@ gtk_plot_flux_class_init (GtkPlotFluxClass *klass)
P_(""),
NULL,
G_PARAM_READABLE|G_PARAM_WRITABLE));
+
+ /**
+ * GtkPlotFlux:labels_suffix:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_LABEL_SUFFIX,
g_param_spec_string ("labels_suffix",
@@ -368,7 +436,7 @@ gtk_plot_flux_new ()
{
GtkWidget *widget;
- widget = gtk_type_new (gtk_plot_flux_get_type ());
+ widget = gtk_widget_new (gtk_plot_flux_get_type (), NULL);
return (widget);
}
@@ -398,21 +466,23 @@ gtk_plot_flux_draw_symbol(GtkPlotData *dataset,
gdouble m;
gdouble x1 = 0.0, y1 = 0.0, x2 = 0.0, y2=0.0;
gdouble factor, size, xm;
+ GtkAllocation allocation;
g_return_if_fail(GTK_IS_PLOT_FLUX(dataset));
flux = GTK_PLOT_FLUX(dataset);
g_return_if_fail(dataset->plot != NULL);
- g_return_if_fail(GTK_WIDGET_VISIBLE(dataset->plot));
+ g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(dataset->plot)));
plot = dataset->plot;
m = plot->magnification;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation( GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
clip_area.x = area.x + roundint(plot->x * area.width);
clip_area.y = area.y + roundint(plot->y * area.height);
@@ -492,11 +562,11 @@ gtk_plot_flux_get_legend_size(GtkPlotData *data, gint *width, gint *height)
gtk_plot_axis_parse_label(data->gradient, flux->scale_max, flux->labels_precision, flux->labels_style,
text);
if(flux->labels_prefix){
g_snprintf(aux_text, 100, "%s%s", flux->labels_prefix, text);
- strcpy(text, aux_text);
+ g_snprintf(text, 100, "%s", aux_text);
}
if(flux->labels_suffix) {
g_snprintf(aux_text, 100, "%s%s", text, flux->labels_suffix);
- strcpy(text, aux_text);
+ g_snprintf(text, 100, "%s", aux_text);
}
g_snprintf(new_label, 100, "%s", text);
@@ -524,19 +594,21 @@ gtk_plot_flux_draw_legend(GtkPlotData *data, gint x, gint y)
gdouble m;
gint line_width;
gboolean centered;
+ GtkAllocation allocation;
flux = GTK_PLOT_FLUX(data);
centered = flux->centered;
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
- g_return_if_fail(GTK_WIDGET_VISIBLE(data->plot));
+ g_return_if_fail(gtk_widget_get_visible(GTK_WIDGET(data->plot)));
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation( GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
@@ -575,12 +647,12 @@ gtk_plot_flux_draw_legend(GtkPlotData *data, gint x, gint y)
if(flux->labels_prefix){
gchar aux_text[100];
g_snprintf(aux_text, 100, "%s%s", flux->labels_prefix, text_max);
- strcpy(text_max, aux_text);
+ g_snprintf(text_max, 100, "%s", aux_text);
}
if(flux->labels_suffix){
gchar aux_text[100];
g_snprintf(aux_text, 100, "%s%s", text_max, flux->labels_suffix);
- strcpy(text_max, aux_text);
+ g_snprintf(text_max, 100, "%s", aux_text);
}
g_snprintf(new_label, 100, "%s", text_max);
@@ -674,6 +746,15 @@ gtk_plot_flux_draw_arrow(GtkPlotFlux *flux, gdouble x1, gdouble y1, gdouble x2,
}
}
+/**
+ * gtk_plot_flux_set_arrow:
+ * @flux:
+ * @arrow_length:
+ * @arrow_width:
+ * @arrow_style:
+ *
+ *
+ */
void
gtk_plot_flux_set_arrow (GtkPlotFlux *flux,
gint arrow_length,
@@ -685,6 +766,15 @@ gtk_plot_flux_set_arrow (GtkPlotFlux *flux,
flux->arrow_style = arrow_style;
}
+/**
+ * gtk_plot_flux_get_arrow:
+ * @flux:
+ * @arrow_length:
+ * @arrow_width:
+ * @arrow_style:
+ *
+ *
+ */
void
gtk_plot_flux_get_arrow (GtkPlotFlux *flux,
gint *arrow_length,
@@ -696,48 +786,105 @@ gtk_plot_flux_get_arrow (GtkPlotFlux *flux,
*arrow_style = flux->arrow_style;
}
+/**
+ * gtk_plot_flux_center:
+ * @flux:
+ * @center:
+ *
+ *
+ */
void
gtk_plot_flux_center (GtkPlotFlux *flux, gboolean center)
{
flux->centered = center;
}
+/**
+ * gtk_plot_flux_is_centered:
+ * @flux:
+ *
+ *
+ *
+ * Return value:
+ */
gboolean
gtk_plot_flux_is_centered (GtkPlotFlux *flux)
{
return(flux->centered);
}
+/**
+ * gtk_plot_flux_show_scale:
+ * @flux:
+ * @show:
+ *
+ *
+ */
void
gtk_plot_flux_show_scale (GtkPlotFlux *flux, gboolean show)
{
flux->show_scale = show;
}
+/**
+ * gtk_plot_flux_set_scale_max:
+ * @flux:
+ * @scale_max:
+ *
+ *
+ */
void
gtk_plot_flux_set_scale_max (GtkPlotFlux *flux, gdouble scale_max)
{
flux->scale_max = fabs(scale_max);
}
+/**
+ * gtk_plot_flux_set_size_max:
+ * @flux:
+ * @size_max:
+ *
+ *
+ */
void
gtk_plot_flux_set_size_max (GtkPlotFlux *flux, guint size_max)
{
flux->size_max = size_max;
}
+/**
+ * gtk_plot_flux_set_labels_precision:
+ * @flux:
+ * @precision:
+ *
+ *
+ */
void
gtk_plot_flux_set_labels_precision (GtkPlotFlux *flux, gint precision)
{
flux->labels_precision = precision;
}
+/**
+ * gtk_plot_flux_set_labels_style:
+ * @flux:
+ * @style:
+ *
+ *
+ */
void
gtk_plot_flux_set_labels_style (GtkPlotFlux *flux, GtkPlotLabelStyle style)
{
flux->labels_style = style;
}
+/**
+ * gtk_plot_flux_set_labels_prefix:
+ * @flux:
+ * @prefix:
+ *
+ *
+ */
void
gtk_plot_flux_set_labels_prefix (GtkPlotFlux *flux, const gchar *prefix)
{
@@ -747,6 +894,13 @@ gtk_plot_flux_set_labels_prefix (GtkPlotFlux *flux, const gchar *prefix)
flux->labels_prefix = g_strdup(prefix);
}
+/**
+ * gtk_plot_flux_set_labels_suffix:
+ * @flux:
+ * @suffix:
+ *
+ *
+ */
void
gtk_plot_flux_set_labels_suffix (GtkPlotFlux *flux, const gchar *suffix)
{
diff --git a/gtkextra/gtkplotflux.h b/gtkextra/gtkplotflux.h
index 791db6e..3bd3e6c 100644
--- a/gtkextra/gtkplotflux.h
+++ b/gtkextra/gtkplotflux.h
@@ -26,15 +26,21 @@ extern "C" {
#include "gtkplot.h"
-#define GTK_PLOT_FLUX(obj) GTK_CHECK_CAST (obj, gtk_plot_flux_get_type (), GtkPlotFlux)
-#define GTK_TYPE_PLOT_FLUX (gtk_plot_flux_get_type ())
-#define GTK_PLOT_FLUX_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_flux_get_type(), GtkPlotFluxClass)
-#define GTK_IS_PLOT_FLUX(obj) GTK_CHECK_TYPE (obj, gtk_plot_flux_get_type ())
+#define GTK_PLOT_FLUX(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_flux_get_type (), GtkPlotFlux)
+#define G_TYPE_PLOT_FLUX (gtk_plot_flux_get_type ())
+#define GTK_PLOT_FLUX_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_flux_get_type(),
GtkPlotFluxClass)
+#define GTK_IS_PLOT_FLUX(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_flux_get_type ())
typedef struct _GtkPlotFlux GtkPlotFlux;
typedef struct _GtkPlotFluxClass GtkPlotFluxClass;
+/**
+ * GtkPlotFlux:
+ *
+ * The GtkPlotFlux struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotFlux
{
GtkPlotData data;
@@ -63,16 +69,16 @@ struct _GtkPlotFluxClass
};
-GtkType gtk_plot_flux_get_type (void);
+GType gtk_plot_flux_get_type (void);
GtkWidget* gtk_plot_flux_new (void);
void gtk_plot_flux_set_arrow (GtkPlotFlux *flux,
gint arrow_length,
gint arrow_width,
- GtkPlotSymbolStyle style);
+ GtkPlotSymbolStyle arrow_style);
void gtk_plot_flux_get_arrow (GtkPlotFlux *flux,
gint *arrow_length,
gint *arrow_width,
- GtkPlotSymbolStyle *style);
+ GtkPlotSymbolStyle *arrow_style);
void gtk_plot_flux_center (GtkPlotFlux *flux,
gboolean center);
gboolean gtk_plot_flux_is_centered (GtkPlotFlux *flux);
diff --git a/gtkextra/gtkplotgdk.c b/gtkextra/gtkplotgdk.c
index 6e091b3..0050049 100644
--- a/gtkextra/gtkplotgdk.c
+++ b/gtkextra/gtkplotgdk.c
@@ -17,6 +17,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotgdk
+ * @short_description: GDK drawing backend (mapped to Cairo)
+ *
+ * This Subclass of #GtkPlotPC has been rewritten to use Cairo
+ * drawing routines.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -126,26 +134,21 @@ extern inline gint roundint (gdouble x);
static GtkPlotPCClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_gdk_get_type (void)
{
- static GtkType pc_type = 0;
+ static GType pc_type = 0;
if (!pc_type)
{
- GtkTypeInfo pc_info =
- {
- "GtkPlotGdk",
- sizeof (GtkPlotGdk),
- sizeof (GtkPlotGdkClass),
- (GtkClassInitFunc) gtk_plot_gdk_class_init,
- (GtkObjectInitFunc) gtk_plot_gdk_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- pc_type = gtk_type_unique (GTK_TYPE_PLOT_PC, &pc_info);
+ pc_type = g_type_register_static_simple (
+ GTK_TYPE_PLOT_PC,
+ "GtkPlotGdk",
+ sizeof (GtkPlotGdkClass),
+ (GClassInitFunc) gtk_plot_gdk_class_init,
+ sizeof (GtkPlotGdk),
+ (GInstanceInitFunc) gtk_plot_gdk_init,
+ 0);
}
return pc_type;
}
@@ -198,7 +201,7 @@ gtk_plot_gdk_class_init (GtkPlotGdkClass *klass)
GtkPlotPCClass *pc_class;
GtkPlotGdkClass *gdk_class;
- parent_class = gtk_type_class (gtk_plot_pc_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_pc_get_type ());
object_class = (GtkObjectClass *) klass;
gobject_class = (GObjectClass *) klass;
@@ -233,22 +236,37 @@ gtk_plot_gdk_class_init (GtkPlotGdkClass *klass)
}
+/**
+ * gtk_plot_gdk_new:
+ * @widget:
+ *
+ *
+ *
+ * Return value:
+ */
GtkObject *
gtk_plot_gdk_new (GtkWidget *widget)
{
GtkObject *object;
- object = gtk_type_new(gtk_plot_gdk_get_type());
+ object = g_object_new(gtk_plot_gdk_get_type(), NULL);
gtk_plot_gdk_construct(GTK_PLOT_GDK(object), widget);
return (object);
}
+/**
+ * gtk_plot_gdk_construct:
+ * @pc:
+ * @widget:
+ *
+ *
+ */
void
gtk_plot_gdk_construct(GtkPlotGdk *pc, GtkWidget *widget)
{
- pc->window = widget->window;
+ pc->window = gtk_widget_get_window(widget);
pc->context = gtk_widget_get_pango_context (widget);
g_object_ref(G_OBJECT(pc->context));
pc->layout = pango_layout_new(pc->context);
@@ -293,6 +311,13 @@ gtk_plot_gdk_leave (GtkPlotPC *pc)
{
}
+/**
+ * gtk_plot_gdk_set_drawable:
+ * @gdk:
+ * @drawable:
+ *
+ *
+ */
void
gtk_plot_gdk_set_drawable (GtkPlotGdk *gdk, GdkDrawable *drawable)
{
@@ -372,8 +397,8 @@ gtk_plot_gdk_set_dash (GtkPlotPC *pc,
gdouble *values,
gint num_values)
{
- gchar list[] = {'\0','\1','\2','\3','\4','\5','\6','\7'};
- gchar dash[1000] = "";
+ gint list[] = {0, 1, 2, 3, 4, 5, 6, 7};
+ gint8 dash[1000];
gint i;
if(!GTK_PLOT_GDK(pc)->gc) return;
@@ -570,7 +595,7 @@ drawstring(GtkPlotPC *pc,
*/
}
- pango_font_description_free(font);
+ if (font) pango_font_description_free(font);
ret_value = (angle == 0 || angle == 180) ? rect.width : rect.height;
return PANGO_PIXELS(rect.width);
}
@@ -609,7 +634,7 @@ gtk_plot_gdk_draw_string (GtkPlotPC *pc,
const gchar *lastchar = text;
const gchar *wtext = text;
const gchar *xaux = text;
- gchar new_text[strlen(text)+1];
+ gchar *new_text; /* Support Tiny C compiler : Original : gchar new_text[strlen(text)+1];*/
gchar num[4];
PangoRectangle rect;
PangoFontMetrics *metrics = NULL;
@@ -957,6 +982,8 @@ gtk_plot_gdk_draw_string (GtkPlotPC *pc,
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, drawable, gc, angle, tx+x, ty+y,
@@ -964,6 +991,8 @@ gtk_plot_gdk_draw_string (GtkPlotPC *pc,
x += sign_x * new_width;
y += sign_y * new_width;
lastchar = aux;
+
+ g_free (new_text);
}
}
diff --git a/gtkextra/gtkplotgdk.h b/gtkextra/gtkplotgdk.h
index 802734a..7a32066 100644
--- a/gtkextra/gtkplotgdk.h
+++ b/gtkextra/gtkplotgdk.h
@@ -29,16 +29,22 @@ extern "C" {
#endif /* __cplusplus */
-#define GTK_PLOT_GDK(obj) GTK_CHECK_CAST (obj, gtk_plot_gdk_get_type (), GtkPlotGdk)
-#define GTK_TYPE_PLOT_GDK (gtk_plot_gdk_get_type ())
+#define GTK_PLOT_GDK(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_gdk_get_type (), GtkPlotGdk)
+#define G_TYPE_PLOT_GDK (gtk_plot_gdk_get_type ())
-#define GTK_PLOT_GDK_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_gdk_get_type(), GtkPlotGdkClass)
-#define GTK_IS_PLOT_GDK(obj) GTK_CHECK_TYPE (obj, gtk_plot_gdk_get_type ())
+#define GTK_PLOT_GDK_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_gdk_get_type(), GtkPlotGdkClass)
+#define GTK_IS_PLOT_GDK(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_gdk_get_type ())
typedef struct _GtkPlotGdk GtkPlotGdk;
typedef struct _GtkPlotGdkClass GtkPlotGdkClass;
+/**
+ * GtkPlotGdk:
+ *
+ * The GtkPlotGdk struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotGdk
{
GtkPlotPC pc;
@@ -63,11 +69,11 @@ struct _GtkPlotGdkClass
void (* set_drawable) (GtkPlotGdk *gdk, GdkDrawable *drawable);
};
-GtkType gtk_plot_gdk_get_type (void);
+GType gtk_plot_gdk_get_type (void);
GtkObject *gtk_plot_gdk_new (GtkWidget *widget);
void gtk_plot_gdk_construct (GtkPlotGdk *pc,
GtkWidget *widget);
-void gtk_plot_gdk_set_drawable (GtkPlotGdk *pc,
+void gtk_plot_gdk_set_drawable (GtkPlotGdk *gdk,
GdkDrawable *drawable);
#ifdef __cplusplus
diff --git a/gtkextra/gtkplotpixmap.c b/gtkextra/gtkplotpixmap.c
index 58ee3a4..1c893b6 100644
--- a/gtkextra/gtkplotpixmap.c
+++ b/gtkextra/gtkplotpixmap.c
@@ -17,6 +17,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotpixmap
+ * @short_description: Pixmap plots widget.
+ *
+ * FIXME:: Need long description.
+ */
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -71,26 +78,21 @@ extern inline gint roundint (gdouble x);
static GtkPlotDataClass *parent_class = NULL;
-GtkType
+GType
gtk_plot_pixmap_get_type (void)
{
- static GtkType data_type = 0;
+ static GType data_type = 0;
if (!data_type)
{
- GtkTypeInfo data_info =
- {
- "GtkPlotPixmap",
- sizeof (GtkPlotPixmap),
- sizeof (GtkPlotPixmapClass),
- (GtkClassInitFunc) gtk_plot_pixmap_class_init,
- (GtkObjectInitFunc) gtk_plot_pixmap_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- data_type = gtk_type_unique (gtk_plot_data_get_type(), &data_info);
+ data_type = g_type_register_static_simple (
+ gtk_plot_data_get_type(),
+ "GtkPlotPixmap",
+ sizeof (GtkPlotPixmapClass),
+ (GClassInitFunc) gtk_plot_pixmap_class_init,
+ sizeof (GtkPlotPixmap),
+ (GInstanceInitFunc) gtk_plot_pixmap_init,
+ 0);
}
return data_type;
}
@@ -103,7 +105,7 @@ gtk_plot_pixmap_class_init (GtkPlotPixmapClass *klass)
GtkPlotDataClass *data_class;
GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
- parent_class = gtk_type_class (gtk_plot_data_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_data_get_type ());
object_class = (GtkObjectClass *) klass;
widget_class = (GtkWidgetClass *) klass;
@@ -180,18 +182,33 @@ gtk_plot_pixmap_init (GtkPlotPixmap *dataset)
dataset->pixmap = NULL;
}
+/**
+ * gtk_plot_pixmap_new:
+ * @pixmap: a GdkPixmap.
+ * @mask:
+ *
+ * Return value: a new GtkWidget.
+ */
GtkWidget*
gtk_plot_pixmap_new (GdkPixmap *pixmap, GdkBitmap *mask)
{
GtkWidget *widget;
- widget = gtk_type_new (gtk_plot_pixmap_get_type ());
+ widget = gtk_widget_new (gtk_plot_pixmap_get_type (), NULL);
gtk_plot_pixmap_construct(GTK_PLOT_PIXMAP(widget), pixmap, mask);
return (widget);
}
+/**
+ * gtk_plot_pixmap_construct:
+ * @data:
+ * @pixmap: a GdkPixmap
+ * @mask:
+ *
+ *
+ */
void
gtk_plot_pixmap_construct(GtkPlotPixmap *data, GdkPixmap *pixmap, GdkBitmap *mask)
{
@@ -286,6 +303,7 @@ gtk_plot_pixmap_draw_legend(GtkPlotData *data, gint x, gint y)
gint lascent, ldescent, lheight, lwidth;
gdouble m;
gint width, height;
+ GtkAllocation allocation;
g_return_if_fail(data->plot != NULL);
g_return_if_fail(GTK_IS_PLOT(data->plot));
@@ -293,10 +311,11 @@ gtk_plot_pixmap_draw_legend(GtkPlotData *data, gint x, gint y)
pixmap = GTK_PLOT_PIXMAP(data);
plot = data->plot;
- area.x = GTK_WIDGET(plot)->allocation.x;
- area.y = GTK_WIDGET(plot)->allocation.y;
- area.width = GTK_WIDGET(plot)->allocation.width;
- area.height = GTK_WIDGET(plot)->allocation.height;
+ gtk_widget_get_allocation(GTK_WIDGET(plot), &allocation);
+ area.x = allocation.x;
+ area.y = allocation.y;
+ area.width = allocation.width;
+ area.height = allocation.height;
m = plot->magnification;
legend = plot->legends_attr;
@@ -385,12 +404,28 @@ gtk_plot_pixmap_get_legend_size(GtkPlotData *data, gint *width, gint *height)
* Public methods
******************************************************/
+/**
+ * gtk_plot_pixmap_get_pixmap:
+ * @pixmap: a #GdkPlotPixmap
+ *
+ * Get pixmap from #GtkPlotPixmap.
+ *
+ * Return value: (transfer none) the #GdkPixmap
+ */
GdkPixmap *
gtk_plot_pixmap_get_pixmap (GtkPlotPixmap *pixmap)
{
return(pixmap->pixmap);
}
+/**
+ * gtk_plot_pixmap_get_mask:
+ * @pixmap: a #GdkPlotPixmap
+ *
+ * Get mask bitmap from #GtkPlotPixmap.
+ *
+ * Return value: (transfer none) the #GdkBitmap
+ */
GdkBitmap *
gtk_plot_pixmap_get_mask (GtkPlotPixmap *pixmap)
{
diff --git a/gtkextra/gtkplotpixmap.h b/gtkextra/gtkplotpixmap.h
index fd285d9..7a274a2 100644
--- a/gtkextra/gtkplotpixmap.h
+++ b/gtkextra/gtkplotpixmap.h
@@ -26,14 +26,20 @@ extern "C" {
#include "gtkplot.h"
-#define GTK_PLOT_PIXMAP(obj) GTK_CHECK_CAST (obj, gtk_plot_pixmap_get_type (), GtkPlotPixmap)
-#define GTK_TYPE_PLOT_PIXMAP (gtk_plot_pixmap_get_type ())
-#define GTK_PLOT_PIXMAP_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_pixmap_get_type(),
GtkPlotPixmapClass)
-#define GTK_IS_PLOT_PIXMAP(obj) GTK_CHECK_TYPE (obj, gtk_plot_pixmap_get_type ())
+#define GTK_PLOT_PIXMAP(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_pixmap_get_type (),
GtkPlotPixmap)
+#define G_TYPE_PLOT_PIXMAP (gtk_plot_pixmap_get_type ())
+#define GTK_PLOT_PIXMAP_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_pixmap_get_type(),
GtkPlotPixmapClass)
+#define GTK_IS_PLOT_PIXMAP(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_pixmap_get_type ())
typedef struct _GtkPlotPixmap GtkPlotPixmap;
typedef struct _GtkPlotPixmapClass GtkPlotPixmapClass;
+/**
+ * GtkPlotPixmap:
+ *
+ * The GtkPlotPixmap struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotPixmap
{
GtkPlotData data;
@@ -48,7 +54,7 @@ struct _GtkPlotPixmapClass
};
-GtkType gtk_plot_pixmap_get_type (void);
+GType gtk_plot_pixmap_get_type (void);
GtkWidget* gtk_plot_pixmap_new (GdkPixmap *pixmap,
GdkBitmap *mask);
@@ -56,8 +62,8 @@ void gtk_plot_pixmap_construct (GtkPlotPixmap *data,
GdkPixmap *pixmap,
GdkBitmap *mask);
-GdkPixmap* gtk_plot_pixmap_get_pixmap (GtkPlotPixmap *data);
-GdkBitmap* gtk_plot_pixmap_get_mask (GtkPlotPixmap *data);
+GdkPixmap* gtk_plot_pixmap_get_pixmap (GtkPlotPixmap *pixmap);
+GdkBitmap* gtk_plot_pixmap_get_mask (GtkPlotPixmap *pixmap);
#ifdef __cplusplus
}
diff --git a/gtkextra/gtkplotpolar.c b/gtkextra/gtkplotpolar.c
index 8346061..73b3b87 100644
--- a/gtkextra/gtkplotpolar.c
+++ b/gtkextra/gtkplotpolar.c
@@ -17,6 +17,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotpolar
+ * @short_description:
+ *
+ * FIXME:: Need long description.
+ */
+
+
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
@@ -73,26 +81,21 @@ enum
ARG_ROTATION,
};
-GtkType
+GType
gtk_plot_polar_get_type (void)
{
- static GtkType plot_type = 0;
+ static GType plot_type = 0;
if (!plot_type)
{
- GtkTypeInfo plot_info =
- {
- "GtkPlotPolar",
- sizeof (GtkPlotPolar),
- sizeof (GtkPlotPolarClass),
- (GtkClassInitFunc) gtk_plot_polar_class_init,
- (GtkObjectInitFunc) gtk_plot_polar_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- plot_type = gtk_type_unique (gtk_plot_get_type(), &plot_info);
+ plot_type = g_type_register_static_simple (
+ gtk_plot_get_type(),
+ "GtkPlotPolar",
+ sizeof (GtkPlotPolarClass),
+ (GClassInitFunc) gtk_plot_polar_class_init,
+ sizeof (GtkPlotPolar),
+ (GInstanceInitFunc) gtk_plot_polar_init,
+ 0);
}
return plot_type;
}
@@ -104,7 +107,7 @@ gtk_plot_polar_class_init (GtkPlotPolarClass *klass)
GtkWidgetClass *widget_class;
GtkPlotClass *plot_class;
- parent_class = gtk_type_class (gtk_plot_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_get_type ());
gobject_class = G_OBJECT_CLASS(klass);
widget_class = (GtkWidgetClass *) klass;
@@ -117,6 +120,11 @@ gtk_plot_polar_class_init (GtkPlotPolarClass *klass)
plot_class->get_point = gtk_plot_polar_real_get_point;
plot_class->get_pixel = gtk_plot_polar_real_get_pixel;
+ /**
+ * GtkPlotPolar:rotation:
+ *
+ *
+ **/
g_object_class_install_property (gobject_class,
ARG_ROTATION,
g_param_spec_double ("rotation",
@@ -227,7 +235,7 @@ gtk_plot_polar_real_paint (GtkWidget *widget)
gint xoffset, yoffset ;
gdouble min;
- if(!GTK_WIDGET_VISIBLE(widget)) return;
+ if(!gtk_widget_get_visible(widget)) return;
plot = GTK_PLOT(widget);
@@ -319,37 +327,70 @@ gtk_plot_polar_real_paint (GtkWidget *widget)
}
+/**
+ * gtk_plot_polar_new:
+ * @drawable:
+ *
+ *
+ *
+ * Return value:
+ */
GtkWidget*
gtk_plot_polar_new (GdkDrawable *drawable)
{
- GtkPlotPolar *plot;
+ GtkWidget* plot;
- plot = gtk_type_new (gtk_plot_polar_get_type ());
+ plot = gtk_widget_new (gtk_plot_polar_get_type (), NULL);
gtk_plot_polar_construct(GTK_PLOT_POLAR(plot), drawable);
- return GTK_WIDGET (plot);
+ return plot;
}
+/**
+ * gtk_plot_polar_new_with_size:
+ * @drawable:
+ * @width:
+ * @height:
+ *
+ *
+ *
+ * Return value:
+ */
GtkWidget*
gtk_plot_polar_new_with_size (GdkDrawable *drawable, gdouble width, gdouble height)
{
GtkWidget *plot;
- plot = gtk_type_new (gtk_plot_polar_get_type ());
+ plot = gtk_widget_new (gtk_plot_polar_get_type (), NULL);
gtk_plot_polar_construct_with_size(GTK_PLOT_POLAR(plot), drawable,
width, height);
return(plot);
}
-
+/**
+ * gtk_plot_polar_construct:
+ * @plot: a #GtkPlotPolar widget.
+ * @drawable:
+ *
+ *
+ */
void
gtk_plot_polar_construct(GtkPlotPolar *plot, GdkDrawable *drawable)
{
GTK_PLOT(plot)->drawable = drawable;
}
+/**
+ * gtk_plot_polar_construct_with_size:
+ * @plot: a #GtkPlotPolar widget.
+ * @drawable:
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_polar_construct_with_size(GtkPlotPolar *plot, GdkDrawable *drawable, gdouble width, gdouble height)
{
@@ -606,6 +647,8 @@ gtk_plot_polar_draw_labels(GtkPlotPolar *polar,
gdouble m;
gboolean veto = FALSE;
gdouble x0, y0;
+ GtkAllocation allocation;
+
widget = GTK_WIDGET(polar);
plot = GTK_PLOT(polar);
@@ -662,27 +705,27 @@ gtk_plot_polar_draw_labels(GtkPlotPolar *polar,
}
else
{
- gtk_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
+ g_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
&x_tick, label, &veto);
if(!veto)
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
}
tick.text = label;
-
+ gtk_widget_get_allocation (widget, &allocation);
if(axis->label_mask & GTK_PLOT_LABEL_IN){
tick.x = x + xx;
tick.y = y + yy;
tick.x = tick.x + tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y + tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
tick.x = x - xx;
tick.y = y - yy;
tick.x = tick.x + tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y + tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
if(axis->label_mask & GTK_PLOT_LABEL_OUT){
@@ -690,15 +733,15 @@ gtk_plot_polar_draw_labels(GtkPlotPolar *polar,
tick.y = y + yy;
tick.x = tick.x - tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y - tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
tick.x = x - xx;
tick.y = y - yy;
tick.x = tick.x - tick_direction.x*roundint(axis->labels_offset * m);
tick.y = tick.y - tick_direction.y*roundint(axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
}
@@ -730,6 +773,7 @@ gtk_plot_polar_draw_circle(GtkPlotPolar *polar)
gdouble rotation;
gboolean veto = FALSE;
gint sign = 1;
+ GtkAllocation allocation;
widget = GTK_WIDGET(polar);
plot = GTK_PLOT(polar);
@@ -779,7 +823,7 @@ gtk_plot_polar_draw_circle(GtkPlotPolar *polar)
}
else
{
- gtk_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
+ g_signal_emit_by_name(GTK_OBJECT(axis), "tick_label",
&x_tick, label, &veto);
if(!veto)
gtk_plot_axis_parse_label(axis, x_tick, axis->label_precision, axis->label_style, label);
@@ -823,14 +867,15 @@ gtk_plot_polar_draw_circle(GtkPlotPolar *polar)
y1 += text_height / 2;
if((x_tick - rotation) != 360.0 && axis->label_mask != 0){
+ gtk_widget_get_allocation (widget, &allocation);
perp.direction.x = -cos(x_tick * PI / 180. * sign);
perp.direction.y = sin(x_tick * PI / 180. * sign);
tick.x = x1;
tick.y = y1;
tick.x -= roundint(perp.direction.x*axis->labels_offset * m);
tick.y -= roundint(perp.direction.y*axis->labels_offset * m);
- tick.x = (gdouble)tick.x / (gdouble)widget->allocation.width;
- tick.y = (gdouble)tick.y / (gdouble)widget->allocation.height;
+ tick.x = (gdouble)tick.x / (gdouble)allocation.width;
+ tick.y = (gdouble)tick.y / (gdouble)allocation.height;
gtk_plot_draw_text(plot, tick);
}
@@ -958,16 +1003,31 @@ gtk_plot_polar_real_get_point(GtkWidget *widget,
/*******************************************
* gtk_plot_polar_rotate
*******************************************/
+
+/**
+ * gtk_plot_polar_rotate:
+ * @plot: a #GtkPlotPolar widget.
+ * @angle:
+ *
+ *
+ */
void
gtk_plot_polar_rotate(GtkPlotPolar *polar, gdouble angle)
{
polar->rotation = angle;
- gtk_signal_emit_by_name(GTK_OBJECT(polar), "update", TRUE);
- gtk_signal_emit_by_name(GTK_OBJECT(polar), "changed");
+ g_signal_emit_by_name(GTK_OBJECT(polar), "update", TRUE);
+ g_signal_emit_by_name(GTK_OBJECT(polar), "changed");
}
-
+/**
+ * gtk_plot_polar_get_angle:
+ * @plot: a #GtkPlotPolar widget.
+ *
+ *
+ *
+ * Return value:
+ */
gdouble
gtk_plot_polar_get_angle(GtkPlotPolar *polar)
{
diff --git a/gtkextra/gtkplotpolar.h b/gtkextra/gtkplotpolar.h
index bc1e714..2c958f2 100644
--- a/gtkextra/gtkplotpolar.h
+++ b/gtkextra/gtkplotpolar.h
@@ -28,10 +28,10 @@ extern "C" {
#include "gtkplotpc.h"
-#define GTK_PLOT_POLAR(obj) GTK_CHECK_CAST (obj, gtk_plot_polar_get_type (), GtkPlotPolar)
-#define GTK_TYPE_PLOT_POLAR (gtk_plot_polar_get_type ())
-#define GTK_PLOT_POLAR_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_polar_get_type, GtkPlotPolarClass)
-#define GTK_IS_PLOT_POLAR(obj) GTK_CHECK_TYPE (obj, gtk_plot_polar_get_type ())
+#define GTK_PLOT_POLAR(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_polar_get_type (), GtkPlotPolar)
+#define G_TYPE_PLOT_POLAR (gtk_plot_polar_get_type ())
+#define GTK_PLOT_POLAR_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_polar_get_type,
GtkPlotPolarClass)
+#define GTK_IS_PLOT_POLAR(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_polar_get_type ())
#define GTK_PLOT_POLAR_FLAGS(plot) (GTK_PLOT_POLAR(plot)->flags)
#define GTK_PLOT_POLAR_SET_FLAGS(plot,flag) (GTK_PLOT_POLAR_FLAGS(plot) |= (flag))
#define GTK_PLOT_POLAR_UNSET_FLAGS(plot,flag) (GTK_PLOT_POLAR_FLAGS(plot) &= ~(flag))
@@ -41,6 +41,12 @@ extern "C" {
typedef struct _GtkPlotPolar GtkPlotPolar;
typedef struct _GtkPlotPolarClass GtkPlotPolarClass;
+/**
+ * GtkPlotPolar:
+ *
+ * The GtkPlotPolar struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPlotPolar
{
GtkPlot plot;
@@ -58,7 +64,7 @@ struct _GtkPlotPolarClass
/* PlotPolar */
-GtkType gtk_plot_polar_get_type (void);
+GType gtk_plot_polar_get_type (void);
GtkWidget* gtk_plot_polar_new (GdkDrawable *drawable);
GtkWidget* gtk_plot_polar_new_with_size (GdkDrawable *drawable,
gdouble width, gdouble height);
diff --git a/gtkextra/gtkplotps.c b/gtkextra/gtkplotps.c
index 6900c0d..1805a00 100644
--- a/gtkextra/gtkplotps.c
+++ b/gtkextra/gtkplotps.c
@@ -27,6 +27,13 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkplotps
+ * @short_description: postscript driver
+ *
+ * Subclass of #GtkPlotPC used to generate PostScript output.
+ */
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -41,6 +48,7 @@
#include "gtkplotpc.h"
#include "gtkplotps.h"
+
static void gtk_plot_ps_class_init (GtkPlotPSClass *klass);
static void gtk_plot_ps_init (GtkPlotPS *ps);
static void gtk_plot_ps_destroy (GtkObject *object);
@@ -125,26 +133,21 @@ static void color_to_hex (GdkColor color,
static GtkPlotPCClass *parent_class = NULL;
static gchar *locale = NULL;
-GtkType
+GType
gtk_plot_ps_get_type (void)
{
- static GtkType pc_type = 0;
+ static GType pc_type = 0;
if (!pc_type)
{
- GtkTypeInfo pc_info =
- {
- "GtkPlotPS",
- sizeof (GtkPlotPS),
- sizeof (GtkPlotPSClass),
- (GtkClassInitFunc) gtk_plot_ps_class_init,
- (GtkObjectInitFunc) gtk_plot_ps_init,
- /* reserved 1*/ NULL,
- /* reserved 2 */ NULL,
- (GtkClassInitFunc) NULL,
- };
-
- pc_type = gtk_type_unique (GTK_TYPE_PLOT_PC, &pc_info);
+ pc_type = g_type_register_static_simple (
+ GTK_TYPE_PLOT_PC,
+ "GtkPlotPS",
+ sizeof (GtkPlotPSClass),
+ (GClassInitFunc) gtk_plot_ps_class_init,
+ sizeof (GtkPlotPS),
+ (GInstanceInitFunc) gtk_plot_ps_init,
+ 0);
}
return pc_type;
}
@@ -154,6 +157,7 @@ gtk_plot_ps_init (GtkPlotPS *ps)
{
ps->psname = NULL;
ps->gsaved = FALSE;
+ GTK_PLOT_PC(ps)->use_pixmap = FALSE;
}
@@ -164,7 +168,7 @@ gtk_plot_ps_class_init (GtkPlotPSClass *klass)
GObjectClass *gobject_class;
GtkPlotPCClass *pc_class;
- parent_class = gtk_type_class (gtk_plot_pc_get_type ());
+ parent_class = g_type_class_ref (gtk_plot_pc_get_type ());
object_class = (GtkObjectClass *) klass;
gobject_class = (GObjectClass *) klass;
@@ -207,6 +211,20 @@ gtk_plot_ps_destroy(GtkObject *object)
}
}
+
+/**
+ * gtk_plot_ps_new:
+ * @psname:
+ * @orientation:
+ * @epsflag:
+ * @page_size:
+ * @scalex:
+ * @scaley:
+ *
+ *
+ *
+ * Return value: a new GtkObject.
+ */
GtkObject *
gtk_plot_ps_new (const gchar *psname,
gint orientation,
@@ -218,7 +236,7 @@ gtk_plot_ps_new (const gchar *psname,
GtkObject *object;
GtkPlotPS *ps;
- object = gtk_type_new(gtk_plot_ps_get_type());
+ object = g_object_new(gtk_plot_ps_get_type(), NULL);
ps = GTK_PLOT_PS(object);
@@ -227,6 +245,17 @@ gtk_plot_ps_new (const gchar *psname,
return (object);
}
+/**
+ * gtk_plot_ps_construct:
+ * @ps: a #GtkPlotPS
+ * @orientation:
+ * @epsflag:
+ * @page_size:
+ * @scalex:
+ * @scaley:
+ *
+ *
+ */
void
gtk_plot_ps_construct (GtkPlotPS *ps,
const gchar *psname,
@@ -267,6 +296,21 @@ gtk_plot_ps_construct (GtkPlotPS *ps,
gtk_plot_ps_set_size(ps, GTK_PLOT_PSPOINTS, width, height);
}
+/**
+ * gtk_plot_ps_new_with_size:
+ * @psname:
+ * @orientation:
+ * @epsflag:
+ * @units:
+ * @width:
+ * @height:
+ * @scalex:
+ * @scaley:
+ *
+ *
+ *
+ * Return value: a new GtkObject.
+ */
GtkObject *
gtk_plot_ps_new_with_size (const gchar *psname,
gint orientation,
@@ -278,7 +322,7 @@ gtk_plot_ps_new_with_size (const gchar *psname,
GtkObject *object;
GtkPlotPS *ps;
- object = gtk_type_new(gtk_plot_ps_get_type());
+ object = g_object_new(gtk_plot_ps_get_type(), NULL);
ps = GTK_PLOT_PS(object);
@@ -287,6 +331,20 @@ gtk_plot_ps_new_with_size (const gchar *psname,
return object;
}
+/**
+ * gtk_plot_ps_construct_with_size:
+ * @ps: a #GtkPlotPS
+ * @psname:
+ * @orientation:
+ * @epsflag:
+ * @units:
+ * @width:
+ * @height:
+ * @scalex:
+ * @scaley:
+ *
+ *
+ */
void
gtk_plot_ps_construct_with_size (GtkPlotPS *ps,
const gchar *psname,
@@ -301,6 +359,15 @@ gtk_plot_ps_construct_with_size (GtkPlotPS *ps,
gtk_plot_ps_set_size(ps, units, width, height);
}
+/**
+ * gtk_plot_ps_set_size:
+ * @ps: a #GtkPlotPS
+ * @units:
+ * @width:
+ * @height:
+ *
+ *
+ */
void
gtk_plot_ps_set_size (GtkPlotPS *ps,
gint units,
@@ -336,6 +403,14 @@ gtk_plot_ps_set_size (GtkPlotPS *ps,
gtk_plot_pc_set_viewport(GTK_PLOT_PC(ps), ps->page_height, ps->page_width);
}
+/**
+ * gtk_plot_ps_set_scale:
+ * @ps: a #GtkPlotPS
+ * @scalex:
+ * @scaley:
+ *
+ *
+ */
void
gtk_plot_ps_set_scale (GtkPlotPS *ps,
gdouble scalex,
@@ -432,7 +507,7 @@ psinit (GtkPlotPC *pc)
ps->psfile = psout;
if(ps->epsflag)
- fprintf (psout, "%%!PS-Adobe-2.0 PCF-2.0\n");
+ fprintf (psout, "%%!PS-Adobe-2.0 EPSF-2.0\n");
else
fprintf (psout, "%%!PS-Adobe-2.0\n");
@@ -581,6 +656,16 @@ psinit (GtkPlotPC *pc)
ps_reencode_font(psout, "Symbol");
ps_reencode_font(psout, "ZapfChancery-MediumItalic");
ps_reencode_font(psout, "ZapfDingbats");
+
+ fprintf(psout,"%%%%EndProlog\n%%%%BeginSetup\n"
+ "%%%%PageBoundingBox: 0 0 %d %d\n"
+ "%%%%PageOrientation: %s\n"
+ "%%%%PaperSize: %d %d\n",
+ ps->page_width,
+ ps->page_height,
+ (ps->orientation == GTK_PLOT_PORTRAIT) ? "Portrait":"Landscape",
+ ps->page_width,
+ ps->page_height);
if(ps->orientation == GTK_PLOT_PORTRAIT)
fprintf(psout, "%d %d translate\n"
@@ -593,7 +678,7 @@ psinit (GtkPlotPC *pc)
"-90 rotate \n",
ps->scalex, -ps->scaley);
- fprintf(psout,"%%%%EndProlog\n\n\n");
+ fprintf(psout,"%%%%EndSetup\n\n\n");
return TRUE;
}
@@ -736,17 +821,16 @@ psoutputstring (GtkPlotPC *pc,
GtkPSFont *psfont,
GtkPSFont *latin_psfont,
gint height,
- const GdkWChar *wstring,
+ const gchar *wstring,
const gchar *addstring)
{
- const GdkWChar *p;
- GdkWChar wcs[2];
- gint curcode = 0, code; /* 0..neither 1..latin 2..i18n */
+ const gchar *p;
+ gint curcode = 0;
gchar begin[] = { 0, '(', '<' };
gchar end[] = { 0, ')', '>' };
GtkPSFont *fonts[3];
FILE *out = GTK_PLOT_PS(pc)->psfile;
- gchar *mbs, *c;
+ const gchar *c = NULL;
fonts[0] = NULL;
fonts[1] = latin_psfont;
@@ -755,6 +839,8 @@ psoutputstring (GtkPlotPC *pc,
p = wstring;
if (psfont->i18n_latinfamily) {
+ gint code; /* 0..neither 1..latin 2..i18n */
+ gchar wcs[2];
while (*p) {
code = (*p >= 0 && *p <= 0x7f) ? 1 : 2;
if (curcode && curcode != code)
@@ -768,7 +854,7 @@ psoutputstring (GtkPlotPC *pc,
wcs[0] = *p++;
wcs[1] = 0;
- c = mbs = gdk_wcstombs(wcs);
+ c = wcs;
if (code == 2) {
while (*c)
@@ -778,25 +864,27 @@ psoutputstring (GtkPlotPC *pc,
fputc('\\', out);
fputc(*c, out);
}
-
- g_free(mbs);
}
} else {
- c = mbs = gdk_wcstombs(wstring);
+ c = wstring;
- while (*c) {
- if (curcode == 0) {
- pssetfont(pc, psfont, height);
- fputc(begin[1], out);
- curcode = 1;
- }
+ pssetfont(pc, psfont, height);
+ fputc(begin[1], out);
+ curcode = 1;
+ while (*c) {
+ const gchar *aux2 = c;
if (*c == '(' || *c == ')')
fputc('\\', out);
- fputc(*c++, out);
+
+ if(++aux2 != g_utf8_next_char(c)){
+ fprintf(out, ") show <%02x> show (", (unsigned char)(*++c));
+ c++;
+ } else {
+ fputc(*c, out);
+ c = g_utf8_next_char(c);
+ }
}
-
- g_free(mbs);
}
if (curcode)
@@ -833,7 +921,8 @@ psdrawstring (GtkPlotPC *pc,
gint twidth, theight, tdescent, tascent;
gint tx, ty, width, height;
gint i;
- GdkWChar *curstr, *wtext, *lastchar = NULL, bkspchar[2], *aux, *xaux;
+ const gchar *aux, *xaux, *wtext, *lastchar = NULL;
+ gchar *curstr, bkspchar[3];
gchar num[4];
if (text == NULL || strlen(text) == 0) return;
@@ -857,6 +946,7 @@ psdrawstring (GtkPlotPC *pc,
tx += x;
ty += y;
+
if(!transparent){
pssetcolor(pc, bg);
gtk_plot_pc_draw_rectangle(pc,
@@ -911,7 +1001,7 @@ psdrawstring (GtkPlotPC *pc,
c = text;
while(c && *c != '\0' && *c != '\n') {
if(*c == '\\'){
- c++;
+ c = g_utf8_next_char(c);
switch(*c){
case '0': case '1': case '2': case '3':
case '4': case '5': case '6': case '7': case '9':
@@ -923,7 +1013,7 @@ psdrawstring (GtkPlotPC *pc,
break;
}
} else {
- c++;
+ c = g_utf8_next_char(c);
}
}
@@ -966,17 +1056,16 @@ psdrawstring (GtkPlotPC *pc,
return;
}
- i = strlen(text) + 2;
- curstr = g_malloc0(sizeof(GdkWChar) * i);
- aux = wtext = g_malloc0(sizeof(GdkWChar) * i);
- gdk_mbstowcs(wtext, text, i - 1);
+ i = g_utf8_strlen(text, -1) + 2;
+ curstr = g_malloc0(sizeof(gchar) * i);
+ aux = wtext = text;
scale = font_height;
curcnt = 0;
while(aux && *aux != '\0' && *aux != '\n') {
if(*aux == '\\'){
- 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':
@@ -985,7 +1074,7 @@ psdrawstring (GtkPlotPC *pc,
curstr, "show");
curcnt = 0;
psfont = gtk_psfont_get_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic,
bold);
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case '8':case 'g':
curstr[curcnt] = 0;
@@ -993,7 +1082,7 @@ psdrawstring (GtkPlotPC *pc,
curstr, "show");
curcnt = 0;
psfont = gtk_psfont_get_by_family("Symbol", italic, bold);
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 'B':
curstr[curcnt] = 0;
@@ -1004,7 +1093,7 @@ psdrawstring (GtkPlotPC *pc,
psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
if (psfont->i18n_latinfamily)
latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily, italic, bold);
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 'x':
xaux = aux + 1;
@@ -1015,7 +1104,7 @@ psdrawstring (GtkPlotPC *pc,
break;
}
if (i < 3){
- aux++;
+ aux = g_utf8_next_char(aux);
break;
}
num[3] = '\0';
@@ -1040,7 +1129,7 @@ psdrawstring (GtkPlotPC *pc,
psfont = gtk_psfont_get_by_family(psfont->family, italic, bold);
if (psfont->i18n_latinfamily)
latin_psfont = gtk_psfont_get_by_family(psfont->i18n_latinfamily, italic, bold);
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 's':case '_':
curstr[curcnt] = 0;
@@ -1050,7 +1139,7 @@ psdrawstring (GtkPlotPC *pc,
scale = 0.6 * font_height;
offset -= (gint)scale / 2;
fprintf(psout, "0 %d rmoveto\n", -((gint)scale / 2));
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 'S':case '^':
curstr[curcnt] = 0;
@@ -1060,7 +1149,7 @@ psdrawstring (GtkPlotPC *pc,
scale = 0.6 * font_height;
offset += 0.5*font_height;
fprintf(psout, "0 %d rmoveto\n", (gint)(0.5*font_height));
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 'N':
curstr[curcnt] = 0;
@@ -1077,17 +1166,23 @@ psdrawstring (GtkPlotPC *pc,
scale = font_height;
fprintf(psout, "0 %d rmoveto\n", -offset);
offset = 0;
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case 'b':
curstr[curcnt] = '\0';
psoutputstring(pc, psfont, latin_psfont, (gint)scale,
curstr, "show");
curcnt = 0;
- bkspchar[1] = 0;
if (lastchar) {
+ const gchar *aux2 = lastchar;
bkspchar[0] = *lastchar;
- lastchar--;
+ lastchar = g_utf8_prev_char(lastchar);
+ bkspchar[1] = 0;
+ if(--aux2 != lastchar){
+ bkspchar[1] = *lastchar;
+ lastchar = g_utf8_prev_char(lastchar);
+ bkspchar[2] = 0;
+ }
} else {
bkspchar[0] = 'X';
lastchar = NULL;
@@ -1095,7 +1190,7 @@ psdrawstring (GtkPlotPC *pc,
psoutputstring(pc, psfont, latin_psfont, (gint)scale,
bkspchar,
"stringwidth pop 0 exch neg exch rmoveto");
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case '-':
curstr[curcnt] = 0;
@@ -1106,7 +1201,7 @@ psdrawstring (GtkPlotPC *pc,
if (scale < 6) {
scale = 6;
}
- aux++;
+ aux = g_utf8_next_char(aux);
break;
case '+':
curstr[curcnt] = 0;
@@ -1114,21 +1209,27 @@ psdrawstring (GtkPlotPC *pc,
curstr, "show");
curcnt = 0;
scale += 3;
- aux++;
+ aux = g_utf8_next_char(aux);
break;
default:
if(aux && *aux != '\0' && *aux != '\n'){
curstr[curcnt++] = *aux;
- aux++;
+ aux = g_utf8_next_char(aux);
}
break;
}
} else {
if(aux && *aux != '\0' && *aux != '\n'){
- curstr[curcnt++] = *aux;
- lastchar = aux;
- aux++;
-
+ const gchar *aux2 = aux;
+ if(g_utf8_next_char(aux) != ++aux2){
+ curstr[curcnt++] = *aux++;
+// aux = g_utf8_next_char(aux);
+ curstr[curcnt++] = *aux++;
+ } else {
+ curstr[curcnt++] = *aux;
+ lastchar = aux;
+ aux = g_utf8_next_char(aux);
+ }
}
}
}
@@ -1138,8 +1239,6 @@ psdrawstring (GtkPlotPC *pc,
psgrestore(pc);
fprintf(psout, "n\n");
-
- g_free(wtext);
g_free(curstr);
}
@@ -1182,7 +1281,9 @@ psgrestore(GtkPlotPC *pc)
psout = ps->psfile;
+/*
if(!ps->gsaved) return;
+*/
fprintf(psout,"grestore\n");
ps->gsaved = FALSE;
diff --git a/gtkextra/gtkplotps.h b/gtkextra/gtkplotps.h
index 267799b..7c46e00 100644
--- a/gtkextra/gtkplotps.h
+++ b/gtkextra/gtkplotps.h
@@ -31,11 +31,11 @@
extern "C" {
#endif /* __cplusplus */
-#define GTK_PLOT_PS(obj) GTK_CHECK_CAST (obj, gtk_plot_ps_get_type (), GtkPlotPS)
-#define GTK_TYPE_PLOT_PS (gtk_plot_ps_get_type ())
+#define GTK_PLOT_PS(obj) G_TYPE_CHECK_INSTANCE_CAST (obj, gtk_plot_ps_get_type (), GtkPlotPS)
+#define G_TYPE_PLOT_PS (gtk_plot_ps_get_type ())
-#define GTK_PLOT_PS_CLASS(klass) GTK_CHECK_CLASS_CAST (klass, gtk_plot_ps_get_type(), GtkPlotPSClass)
-#define GTK_IS_PLOT_PS(obj) GTK_CHECK_TYPE (obj, gtk_plot_ps_get_type ())
+#define GTK_PLOT_PS_CLASS(klass) G_TYPE_CHECK_CLASS_CAST (klass, gtk_plot_ps_get_type(), GtkPlotPSClass)
+#define GTK_IS_PLOT_PS(obj) G_TYPE_CHECK_INSTANCE_TYPE (obj, gtk_plot_ps_get_type ())
typedef struct _GtkPlotPS GtkPlotPS;
@@ -68,7 +68,7 @@ struct _GtkPlotPSClass
GtkPlotPCClass parent_class;
};
-GtkType gtk_plot_ps_get_type (void);
+GType gtk_plot_ps_get_type (void);
GtkObject *gtk_plot_ps_new (const gchar *psname,
gint orientation,
gint epsflag,
diff --git a/gtkextra/gtkpsfont.c b/gtkextra/gtkpsfont.c
index 3e463f1..2c59fa0 100644
--- a/gtkextra/gtkpsfont.c
+++ b/gtkextra/gtkpsfont.c
@@ -25,6 +25,14 @@
* Boston, MA 02111-1307, USA.
*/
+/**
+ * SECTION: gtkpsfont
+ * @short_description: PostScript Fonts handling.
+ *
+ * Handles Postscript fonts.
+ */
+
+
#include <gtk/gtk.h>
#include <stdio.h>
#include <string.h>
@@ -354,7 +362,11 @@ gtk_psfont_init()
return TRUE;
}
-
+/**
+ * gtk_psfont_unref:
+ *
+ * Unref ps fonts.
+ */
void
gtk_psfont_unref()
{
@@ -383,6 +395,38 @@ gtk_psfont_unref()
psfont_init = FALSE;
}
+/*
+ * gtk_psfont_init:
+ *
+ * Unref ps fonts.
+ *
+void
+gtk_psfont_unref()
+{
+ GList *list;
+
+ if(psfont_refcount <= 0) return;
+
+ psfont_refcount--;
+
+ if(psfont_refcount > 0) return;
+
+ list = psfont_families;
+ while(list){
+ psfont_families = g_list_remove_link(psfont_families, list);
+ g_list_free_1(list);
+ list = psfont_families;
+ }
+*/
+
+/**
+ * gtk_psfont_get_by_name:
+ * @name: font name
+ *
+ * Get PS Font by font name.
+ *
+ * Returns: (transfer none) a #GtkPSFont pointer.
+ */
GtkPSFont *
gtk_psfont_get_by_name(const gchar *name)
{
@@ -400,9 +444,18 @@ gtk_psfont_get_by_name(const gchar *name)
}
}
- return (GtkPSFont *)font;
+ return font;
}
+/**
+ * gtk_psfont_get_by_gdkfont:
+ * @font: a #GtkPSFont
+ * @height: font height
+ *
+ * Get #GdkFOnt by PS Font.
+ *
+ * Returns: a #GdkFont pointer.
+ */
GdkFont *
gtk_psfont_get_gdkfont(GtkPSFont *font, gint height)
{
@@ -434,6 +487,15 @@ gtk_psfont_get_gdkfont(GtkPSFont *font, gint height)
return gdkfont;
}
+/**
+ * gtk_psfont_get_font_description:
+ * @font: a #GtkPSFont
+ * @height: font height
+ *
+ * Get a #PangoDescriptionFont from PS Font.
+ *
+ * Returns: a #PangoFontDescription pointer.
+ */
PangoFontDescription *
gtk_psfont_get_font_description(GtkPSFont *font, gint height)
{
@@ -530,15 +592,34 @@ http://mail.gnome.org/archives/gtk-i18n-list/2003-August/msg00001.html
}
+/**
+ * gtk_psfont_get_psfontname:
+ * @psfont: a #GtkPSFont
+ *
+ * Get font name from PS Font.
+ *
+ * Returns: font name.
+ */
const gchar *
-gtk_psfont_get_psfontname(GtkPSFont *font)
+gtk_psfont_get_psfontname(GtkPSFont *psfont)
{
- g_return_val_if_fail (font != NULL, NULL);
+ g_return_val_if_fail (psfont != NULL, NULL);
- return font->psname;
+ return psfont->psname;
}
+/**
+ * gtk_psfont_add_font:
+ * @fontname: font name
+ * @psname: PS font name
+ * @family: font family
+ * @pango_description: font Pango description
+ * @italic: TRUE or FALSE
+ * @bold: TRUE or FALSE
+ *
+ * Add font in user font list.
+ */
void
gtk_psfont_add_font (const gchar *fontname,
const gchar *psname, const gchar *family,
@@ -561,6 +642,19 @@ gtk_psfont_add_font (const gchar *fontname,
user_fonts = g_list_append(user_fonts, font);
}
+/**
+ * gtk_psfont_add_i18n_font:
+ * @fontname: font name
+ * @psname: PS font name
+ * @family: font family
+ * @i18n_latinfamily: International font family
+ * @pango_description: font Pango description
+ * @italic: TRUE or FALSE
+ * @bold: TRUE or FALSE
+ * @vertical: TRUE or FALSE
+ *
+ * Add international font in user font list.
+ */
void
gtk_psfont_add_i18n_font (const gchar *fontname,
const gchar *psname, const gchar *family,
@@ -584,7 +678,6 @@ gtk_psfont_add_i18n_font (const gchar *fontname,
user_fonts = g_list_append(user_fonts, font);
}
-
static GtkPSFont *
find_psfont(const gchar *name)
{
@@ -628,8 +721,18 @@ find_psfont(const gchar *name)
return fontdata;
}
+/**
+ * gtk_psfont_get_by_family:
+ * @family_name: font name
+ * @italic: TRUE or FALSE
+ * @bold: TRUE or FALSE
+ *
+ * Get #GtkPSFont by family.
+ *
+ * Returns: (transfer none) the #GtkPSFont
+ */
GtkPSFont *
-gtk_psfont_get_by_family(const gchar *name, gboolean italic, gboolean bold)
+gtk_psfont_get_by_family(const gchar *family_name, gboolean italic, gboolean bold)
{
GtkPSFont *fontdata = NULL;
GtkPSFont *data = NULL;
@@ -645,7 +748,7 @@ gtk_psfont_get_by_family(const gchar *name, gboolean italic, gboolean bold)
fonts = user_fonts;
while(fonts){
data = (GtkPSFont *) fonts->data;
- if(strcmp(name, data->family) == 0) {
+ if(strcmp(family_name, data->family) == 0) {
return_data = data;
if(data->italic == italic && data->bold == bold){
fontdata = data;
@@ -657,7 +760,7 @@ gtk_psfont_get_by_family(const gchar *name, gboolean italic, gboolean bold)
if(fontdata == NULL) {
for(i = 0; i < NUM_FONTS; i++){
- if(strcmp(name, font_data[i].family) == 0) {
+ if(strcmp(family_name, font_data[i].family) == 0) {
return_data = &font_data[i];
if(font_data[i].italic == italic && font_data[i].bold == bold){
fontdata = &font_data[i];
@@ -672,6 +775,13 @@ gtk_psfont_get_by_family(const gchar *name, gboolean italic, gboolean bold)
}
+/**
+ * gtk_psfont_get_families:
+ * @families: (element-type gchar*) font families
+ * @num_families: families number
+ *
+ * Get #GtkPSFont by family.
+ */
void
gtk_psfont_get_families(GList **families, gint *num_families)
{
@@ -685,6 +795,19 @@ gtk_psfont_get_families(GList **families, gint *num_families)
}
/* get the width, ascent and descent of a character. */
+
+/**
+ * gtk_psfont_get_char_size:
+ * @psfont: a #GtkPSFont
+ * @font: a #GdkFont
+ * @latin_font: a #GdkFont
+ * @wc: a #GdkWchar
+ * @width: font width
+ * @ascent: font ascent
+ * @descent: font descent
+ *
+ * Get font character size.
+ */
void
gtk_psfont_get_char_size(GtkPSFont *psfont,
GdkFont *font,
diff --git a/gtkextra/gtkpsfont.h b/gtkextra/gtkpsfont.h
index 743a28b..ee5931a 100644
--- a/gtkextra/gtkpsfont.h
+++ b/gtkextra/gtkpsfont.h
@@ -74,7 +74,14 @@ extern "C" {
typedef struct _GtkPSFont GtkPSFont;
+/**
+ * GtkPSFont:
+ *
+ * The GtkPSFont struct contains only private data.
+ * It should only be accessed through the functions described below.
+ */
struct _GtkPSFont {
+ /*< private >*/
gchar *fontname;
gchar *psname;
gchar *family;
@@ -88,7 +95,7 @@ struct _GtkPSFont {
gint gtk_psfont_init ();
void gtk_psfont_unref ();
GtkPSFont* gtk_psfont_get_by_name (const gchar *name);
-GtkPSFont* gtk_psfont_get_by_family (const gchar *family,
+GtkPSFont* gtk_psfont_get_by_family (const gchar *family_name,
gboolean italic,
gboolean bold);
GdkFont* gtk_psfont_get_gdkfont (GtkPSFont *font, gint height);
@@ -98,18 +105,18 @@ const gchar * gtk_psfont_get_psfontname (GtkPSFont *psfont);
void gtk_psfont_add_font (const char *fontname,
const gchar *psname,
const gchar *family,
- const gchar *pango_string,
+ const gchar *pango_description,
gboolean italic,
gboolean bold);
void gtk_psfont_add_i18n_font (const char *fontname,
const gchar *psname,
const gchar *family,
const gchar *i18n_latinfamily,
- const gchar *pango_string,
+ const gchar *pango_description,
gboolean italic,
gboolean bold,
gboolean vertical);
-void gtk_psfont_get_families (GList **family, gint *numf);
+void gtk_psfont_get_families (GList **families, gint *num_families);
void gtk_psfont_get_char_size (GtkPSFont *psfont,
GdkFont *font,
GdkFont *latin_font,
diff --git a/src/graphing.c b/src/graphing.c
index fc80220..2a4162a 100644
--- a/src/graphing.c
+++ b/src/graphing.c
@@ -66,6 +66,7 @@ static GtkWidget *plot_resetzoom_item = NULL;
static GtkWidget *plot_print_item = NULL;
static GtkWidget *plot_exportps_item = NULL;
static GtkWidget *plot_exporteps_item = NULL;
+static GtkWidget *plot_exportpdf_item = NULL;
static GtkWidget *plot_exportpng_item = NULL;
static GtkWidget *view_menu_item = NULL;
@@ -355,6 +356,14 @@ enum {
RESPONSE_CLEAR
};
+enum {
+ EXPORT_PS,
+ EXPORT_EPS,
+ EXPORT_PDF,
+ EXPORT_PNG
+};
+
+
static gboolean
is_letter_or_underscore (char l)
{
@@ -469,6 +478,8 @@ plot_window_setup (void)
gtk_widget_set_sensitive (plot_print_item, ! plot_in_progress);
gtk_widget_set_sensitive (plot_exportps_item, ! plot_in_progress);
gtk_widget_set_sensitive (plot_exporteps_item, ! plot_in_progress);
+ if (plot_exportpdf_item != NULL)
+ gtk_widget_set_sensitive (plot_exportpdf_item, ! plot_in_progress);
gtk_widget_set_sensitive (plot_exportpng_item, ! plot_in_progress);
gtk_widget_set_sensitive (view_menu_item, ! plot_in_progress);
gtk_widget_set_sensitive (solver_menu_item, ! plot_in_progress);
@@ -891,14 +902,14 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
char *s;
char *base;
gboolean ret;
- gboolean eps;
+ int export_type;
char *tmpfile = NULL;
char *file_to_write = NULL;
int fd = -1;
gboolean run_epsi = FALSE;
GtkWidget *w;
- eps = GPOINTER_TO_INT (data);
+ export_type = GPOINTER_TO_INT (data);
if (response != GTK_RESPONSE_OK) {
gtk_widget_destroy (GTK_WIDGET (fs));
@@ -908,10 +919,12 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
}
/* run epsi checkbox */
- w = gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (fs));
- if (w != NULL &&
- gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) {
- run_epsi = TRUE;
+ if (export_type == EXPORT_EPS) {
+ w = gtk_file_chooser_get_extra_widget (GTK_FILE_CHOOSER (fs));
+ if (w != NULL &&
+ gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (w))) {
+ run_epsi = TRUE;
+ }
}
s = g_strdup (gtk_file_chooser_get_filename (fs));
@@ -922,8 +935,10 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
if (base != NULL && base[0] != '\0' &&
strchr (base, '.') == NULL) {
char *n;
- if (eps)
+ if (export_type == EXPORT_EPS)
n = g_strconcat (s, ".eps", NULL);
+ else if (export_type == EXPORT_PDF)
+ n = g_strconcat (s, ".pdf", NULL);
else
n = g_strconcat (s, ".ps", NULL);
g_free (s);
@@ -946,7 +961,14 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
gtk_widget_set_sensitive (graph_window, TRUE);
file_to_write = s;
- if (eps && run_epsi && ve_is_prog_in_path ("ps2epsi")) {
+ if (export_type == EXPORT_EPS && run_epsi && ve_is_prog_in_path ("ps2epsi")) {
+ tmpfile = g_build_filename (g_get_tmp_dir (), "genius-ps-XXXXXX", NULL);
+ fd = g_mkstemp (tmpfile);
+ /* FIXME: tell about errors ?*/
+ if (fd >= 0) {
+ file_to_write = tmpfile;
+ }
+ } else if (export_type == EXPORT_PDF) {
tmpfile = g_build_filename (g_get_tmp_dir (), "genius-ps-XXXXXX", NULL);
fd = g_mkstemp (tmpfile);
/* FIXME: tell about errors ?*/
@@ -964,7 +986,8 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
(GTK_PLOT_CANVAS (plot_canvas),
file_to_write,
GTK_PLOT_PORTRAIT,
- eps /* epsflag */,
+ (export_type == EXPORT_EPS ||
+ export_type == EXPORT_PDF) /* epsflag */,
GTK_PLOT_PSPOINTS,
400, ASPECT * 400);
else
@@ -975,8 +998,8 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
gtk_widget_queue_draw (GTK_WIDGET (plot_canvas));
}
- /* If we used a temporary file, now use ps2epsi */
- if (fd >= 0) {
+ /* If we used a temporary file, now use ps2epsi or ps2pdf */
+ if (fd >= 0 && run_epsi) {
int status;
char *qs = g_shell_quote (s);
char *cmd = g_strdup_printf ("ps2epsi %s %s", tmpfile, qs);
@@ -996,6 +1019,26 @@ really_export_cb (GtkFileChooser *fs, int response, gpointer data)
}
g_free (cmd);
g_free (qs);
+ } else if (fd >= 0 && export_type == EXPORT_PDF) {
+ int status;
+ char *qs = g_shell_quote (s);
+ char *cmd = g_strdup_printf ("ps2pdf -dEPSCrop -dPDFSETTINGS=/prepress %s %s", tmpfile, qs);
+ if ( ! g_spawn_command_line_sync (cmd,
+ NULL /*stdout*/,
+ NULL /*stderr*/,
+ &status,
+ NULL /* error */)) {
+ status = -1;
+ }
+ close (fd);
+ if (status == 0) {
+ unlink (tmpfile);
+ } else {
+ /* EEK, couldn't run ps2pdf for some reason */
+ rename (tmpfile, s);
+ }
+ g_free (cmd);
+ g_free (qs);
}
plot_in_progress --;
@@ -1084,12 +1127,6 @@ really_export_png_cb (GtkFileChooser *fs, int response, gpointer data)
g_free (s);
}
-enum {
- EXPORT_PS,
- EXPORT_EPS,
- EXPORT_PNG
-};
-
static void
do_export_cb (int export_type)
{
@@ -1110,12 +1147,20 @@ do_export_cb (int export_type)
title = _("Export encapsulated postscript");
else if (export_type == EXPORT_PS)
title = _("Export postscript");
+ else if (export_type == EXPORT_PDF)
+ title = _("Export PDF");
else if (export_type == EXPORT_PNG)
title = _("Export PNG");
else
/* should never happen */
title = "Export ???";
+ if (export_type == EXPORT_PDF &&
+ ! ve_is_prog_in_path ("ps2pdf")) {
+ genius_display_error (graph_window, _("Missing ps2pdf command, perhaps ghostscript is not
installed."));
+ return;
+ }
+
fs = gtk_file_chooser_dialog_new (title,
GTK_WINDOW (graph_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
@@ -1134,6 +1179,10 @@ do_export_cb (int export_type)
gtk_file_filter_set_name (filter_ps, _("PS files"));
gtk_file_filter_add_pattern (filter_ps, "*.ps");
gtk_file_filter_add_pattern (filter_ps, "*.PS");
+ } else if (export_type == EXPORT_PDF) {
+ gtk_file_filter_set_name (filter_ps, _("PDF files"));
+ gtk_file_filter_add_pattern (filter_ps, "*.pdf");
+ gtk_file_filter_add_pattern (filter_ps, "*.PDF");
} else if (export_type == EXPORT_PNG) {
gtk_file_filter_set_name (filter_ps, _("PNG files"));
gtk_file_filter_add_pattern (filter_ps, "*.png");
@@ -1148,7 +1197,7 @@ do_export_cb (int export_type)
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (fs), filter_all);
gtk_file_chooser_set_filter (GTK_FILE_CHOOSER (fs), filter_ps);
- if (ve_is_prog_in_path ("ps2epsi")) {
+ if (export_type == EXPORT_EPS && ve_is_prog_in_path ("ps2epsi")) {
GtkWidget *w;
w = gtk_check_button_new_with_label (_("Generate preview in EPS file (with ps2epsi)"));
gtk_widget_show (w);
@@ -1158,14 +1207,12 @@ do_export_cb (int export_type)
g_signal_connect (G_OBJECT (fs), "destroy",
G_CALLBACK (gtk_widget_destroyed), &fs);
- if (export_type == EXPORT_EPS) {
+ if (export_type == EXPORT_EPS ||
+ export_type == EXPORT_PS ||
+ export_type == EXPORT_PDF) {
g_signal_connect (G_OBJECT (fs), "response",
G_CALLBACK (really_export_cb),
- GINT_TO_POINTER (TRUE /*eps*/));
- } else if (export_type == EXPORT_PS) {
- g_signal_connect (G_OBJECT (fs), "response",
- G_CALLBACK (really_export_cb),
- GINT_TO_POINTER (FALSE /*eps*/));
+ GINT_TO_POINTER (export_type));
} else if (export_type == EXPORT_PNG) {
g_signal_connect (G_OBJECT (fs), "response",
G_CALLBACK (really_export_png_cb),
@@ -1198,6 +1245,12 @@ plot_exporteps_cb (void)
}
static void
+plot_exportpdf_cb (void)
+{
+ do_export_cb (EXPORT_PDF);
+}
+
+static void
plot_exportpng_cb (void)
{
do_export_cb (EXPORT_PNG);
@@ -2004,6 +2057,16 @@ ensure_window (gboolean do_window_present)
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
plot_exporteps_item = item;
+ if (ve_is_prog_in_path ("ps2pdf")) {
+ item = gtk_menu_item_new_with_mnemonic (_("Export P_DF..."));
+ g_signal_connect (G_OBJECT (item), "activate",
+ G_CALLBACK (plot_exportpdf_cb), NULL);
+ gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
+ plot_exportpdf_item = item;
+ } else {
+ plot_exportpdf_item = NULL;
+ }
+
item = gtk_menu_item_new_with_mnemonic (_("Export P_NG..."));
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (plot_exportpng_cb), NULL);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
