[gegl-gtk] Normalize coding style
- From: Jon Nordby <jonnor src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gegl-gtk] Normalize coding style
- Date: Sat, 15 Oct 2011 21:08:31 +0000 (UTC)
commit a2a5c4eb5996bbad5a2ac98a71cf05e72441be4f
Author: Jon Nordby <jononor gmail com>
Date: Sat Oct 15 22:35:17 2011 +0200
Normalize coding style
Command used:
astyle --pad-oper --pad-header --unpad-paren --style=kr --convert-tabs --align-pointer=name
examples/c/gegl-gtk-basic.c | 66 +++---
examples/c/gegl-gtk-display-op.c | 70 ++++----
examples/c/gegl-gtk-paint.c | 299 ++++++++++++++---------------
examples/c/gegl-gtk-scroll.c | 74 ++++----
gegl-gtk/gegl-gtk-enums.h | 8 +-
gegl-gtk/gegl-gtk-view.c | 398 +++++++++++++++++++-------------------
gegl-gtk/gegl-gtk-view.h | 18 +-
gegl-gtk/internal/view-helper.c | 266 +++++++++++++-------------
gegl-gtk/internal/view-helper.h | 34 ++--
operations/gegl-gtk-display.c | 158 +++++++--------
tests/test-view-helper.c | 63 +++---
tests/test-view.c | 77 ++++----
tests/utils.c | 22 ++-
13 files changed, 766 insertions(+), 787 deletions(-)
---
diff --git a/examples/c/gegl-gtk-basic.c b/examples/c/gegl-gtk-basic.c
index 010c1c0..1c5c487 100644
--- a/examples/c/gegl-gtk-basic.c
+++ b/examples/c/gegl-gtk-basic.c
@@ -24,47 +24,47 @@
#include <gegl-gtk.h>
gint
-main (gint argc,
- gchar **argv)
+main(gint argc,
+ gchar **argv)
{
- GtkWidget *window = NULL;
- GtkWidget *view = NULL;
- GeglNode *graph = NULL;
- GeglNode *node = NULL;
+ GtkWidget *window = NULL;
+ GtkWidget *view = NULL;
+ GeglNode *graph = NULL;
+ GeglNode *node = NULL;
- g_thread_init (NULL);
- gtk_init (&argc, &argv);
- gegl_init (&argc, &argv);
+ g_thread_init(NULL);
+ gtk_init(&argc, &argv);
+ gegl_init(&argc, &argv);
- if (argc != 2) {
- g_print ("Usage: %s <FILENAME>\n", argv[0]);
- exit(1);
- }
+ if (argc != 2) {
+ g_print("Usage: %s <FILENAME>\n", argv[0]);
+ exit(1);
+ }
- /* Build graph that loads an image */
- graph = gegl_node_new ();
- node = gegl_node_new_child (graph,
- "operation", "gegl:load",
- "path", argv[1], NULL);
+ /* Build graph that loads an image */
+ graph = gegl_node_new();
+ node = gegl_node_new_child(graph,
+ "operation", "gegl:load",
+ "path", argv[1], NULL);
- gegl_node_process (node);
+ gegl_node_process(node);
- /* Setup */
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "GEGL-GTK basic example");
+ /* Setup */
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(window), "GEGL-GTK basic example");
- view = GTK_WIDGET(gegl_gtk_view_new_for_node(node));
- gtk_container_add (GTK_CONTAINER (window), view);
+ view = GTK_WIDGET(gegl_gtk_view_new_for_node(node));
+ gtk_container_add(GTK_CONTAINER(window), view);
- g_signal_connect (window, "destroy",
- G_CALLBACK (gtk_main_quit), NULL);
- gtk_widget_show_all (window);
+ g_signal_connect(window, "destroy",
+ G_CALLBACK(gtk_main_quit), NULL);
+ gtk_widget_show_all(window);
- /* Run */
- gtk_main ();
+ /* Run */
+ gtk_main();
- /* Cleanup */
- g_object_unref (graph);
- gegl_exit ();
- return 0;
+ /* Cleanup */
+ g_object_unref(graph);
+ gegl_exit();
+ return 0;
}
diff --git a/examples/c/gegl-gtk-display-op.c b/examples/c/gegl-gtk-display-op.c
index 903fd5c..2c0ff72 100644
--- a/examples/c/gegl-gtk-display-op.c
+++ b/examples/c/gegl-gtk-display-op.c
@@ -22,40 +22,40 @@
#include <gegl.h>
gint
-main (gint argc,
- gchar **argv)
+main(gint argc,
+ gchar **argv)
{
- GeglNode *graph = NULL;
- GeglNode *node = NULL;
- GeglNode *display = NULL;
-
- g_thread_init (NULL);
- gegl_init (&argc, &argv);
-
- if (argc != 2) {
- g_print ("Usage: %s <FILENAME>\n", argv[0]);
- exit(1);
- }
-
- /* Build graph that loads an image */
- graph = gegl_node_new ();
- node = gegl_node_new_child (graph,
- "operation", "gegl:load",
- "path", argv[1], NULL);
- display = gegl_node_new_child (graph,
- "operation", "gegl-gtk2:display", NULL);
- gegl_node_link_many (node, display, NULL);
-
- gegl_node_process (display);
-
- /* FIXME: operation must spin the gtk mainloop itself */
- while (gtk_events_pending ())
- gtk_main_iteration ();
-
- sleep (2);
-
- /* Cleanup */
- g_object_unref (graph);
- gegl_exit ();
- return 0;
+ GeglNode *graph = NULL;
+ GeglNode *node = NULL;
+ GeglNode *display = NULL;
+
+ g_thread_init(NULL);
+ gegl_init(&argc, &argv);
+
+ if (argc != 2) {
+ g_print("Usage: %s <FILENAME>\n", argv[0]);
+ exit(1);
+ }
+
+ /* Build graph that loads an image */
+ graph = gegl_node_new();
+ node = gegl_node_new_child(graph,
+ "operation", "gegl:load",
+ "path", argv[1], NULL);
+ display = gegl_node_new_child(graph,
+ "operation", "gegl-gtk2:display", NULL);
+ gegl_node_link_many(node, display, NULL);
+
+ gegl_node_process(display);
+
+ /* FIXME: operation must spin the gtk mainloop itself */
+ while (gtk_events_pending())
+ gtk_main_iteration();
+
+ sleep(2);
+
+ /* Cleanup */
+ g_object_unref(graph);
+ gegl_exit();
+ return 0;
}
diff --git a/examples/c/gegl-gtk-paint.c b/examples/c/gegl-gtk-paint.c
index 48a5545..8672d4d 100644
--- a/examples/c/gegl-gtk-paint.c
+++ b/examples/c/gegl-gtk-paint.c
@@ -42,213 +42,206 @@ static GeglNode *stroke = NULL;
/* Transform the input coordinate from view coordinates to model coordinates
+ * Returns TRUE if the transformation was successfull, else FALSE */
gboolean
-transform_view_to_model_coordinate (gdouble *x, gdouble *y)
+transform_view_to_model_coordinate(gdouble *x, gdouble *y)
{
- GeglMatrix3 matrix;
- gegl_gtk_view_get_transformation (GEGL_GTK_VIEW (view), &matrix);
+ GeglMatrix3 matrix;
+ gegl_gtk_view_get_transformation(GEGL_GTK_VIEW(view), &matrix);
- if (gegl_matrix3_determinant (&matrix) == 0.0) {
- return FALSE;
- }
+ if (gegl_matrix3_determinant(&matrix) == 0.0) {
+ return FALSE;
+ }
- gegl_matrix3_invert (&matrix);
- gegl_matrix3_transform_point (&matrix, x, y);
+ gegl_matrix3_invert(&matrix);
+ gegl_matrix3_transform_point(&matrix, x, y);
- return TRUE;
+ return TRUE;
}
-static gboolean paint_press (GtkWidget *widget,
- GdkEventButton *event)
+static gboolean paint_press(GtkWidget *widget,
+ GdkEventButton *event)
{
- gdouble x = event->x;
- gdouble y = event->y;
- transform_view_to_model_coordinate (&x, &y);
-
- if (event->button == 1)
- {
- vector = gegl_path_new ();
-
- over = gegl_node_new_child (gegl, "operation", "gegl:over", NULL);
- stroke = gegl_node_new_child (gegl, "operation", "gegl:path",
- "d", vector,
- "fill-opacity", 0.0,
- "stroke", gegl_color_new (COLOR),
- "stroke-width", LINEWIDTH,
- "stroke-hardness", HARDNESS,
- NULL);
- gegl_node_link_many (top, over, out, NULL);
- gegl_node_connect_to (stroke, "output", over, "aux");
- gegl_path_append (vector, 'M', x, y);
-
- pen_down = TRUE;
-
- return TRUE;
+ gdouble x = event->x;
+ gdouble y = event->y;
+ transform_view_to_model_coordinate(&x, &y);
+
+ if (event->button == 1) {
+ vector = gegl_path_new();
+
+ over = gegl_node_new_child(gegl, "operation", "gegl:over", NULL);
+ stroke = gegl_node_new_child(gegl, "operation", "gegl:path",
+ "d", vector,
+ "fill-opacity", 0.0,
+ "stroke", gegl_color_new(COLOR),
+ "stroke-width", LINEWIDTH,
+ "stroke-hardness", HARDNESS,
+ NULL);
+ gegl_node_link_many(top, over, out, NULL);
+ gegl_node_connect_to(stroke, "output", over, "aux");
+ gegl_path_append(vector, 'M', x, y);
+
+ pen_down = TRUE;
+
+ return TRUE;
}
- return FALSE;
+ return FALSE;
}
-static gboolean paint_motion (GtkWidget *widget,
- GdkEventMotion *event)
+static gboolean paint_motion(GtkWidget *widget,
+ GdkEventMotion *event)
{
- gdouble x = event->x;
- gdouble y = event->y;
+ gdouble x = event->x;
+ gdouble y = event->y;
- transform_view_to_model_coordinate (&x, &y);
+ transform_view_to_model_coordinate(&x, &y);
- if (event->state & GDK_BUTTON1_MASK)
- {
- if (!pen_down)
- {
- return TRUE;
+ if (event->state & GDK_BUTTON1_MASK) {
+ if (!pen_down) {
+ return TRUE;
}
- gegl_path_append (vector, 'L', x, y);
- return TRUE;
+ gegl_path_append(vector, 'L', x, y);
+ return TRUE;
}
- return FALSE;
+ return FALSE;
}
-static gboolean paint_release (GtkWidget *widget,
- GdkEventButton *event)
+static gboolean paint_release(GtkWidget *widget,
+ GdkEventButton *event)
{
- if (event->button == 1)
- {
- gdouble x0, x1, y0, y1;
- GeglProcessor *processor;
- GeglNode *writebuf;
- GeglRectangle roi;
+ if (event->button == 1) {
+ gdouble x0, x1, y0, y1;
+ GeglProcessor *processor;
+ GeglNode *writebuf;
+ GeglRectangle roi;
- gegl_path_get_bounds (vector, &x0, &x1, &y0, &y1);
+ gegl_path_get_bounds(vector, &x0, &x1, &y0, &y1);
- roi.x = x0 - LINEWIDTH;
- roi.y = y0 - LINEWIDTH;
- roi.width = x1 - x0 + LINEWIDTH * 2;
- roi.height = y1 - y0 + LINEWIDTH * 2;
+ roi.x = x0 - LINEWIDTH;
+ roi.y = y0 - LINEWIDTH;
+ roi.width = x1 - x0 + LINEWIDTH * 2;
+ roi.height = y1 - y0 + LINEWIDTH * 2;
- writebuf = gegl_node_new_child (gegl,
- "operation", "gegl:write-buffer",
- "buffer", buffer,
- NULL);
- gegl_node_link_many (over, writebuf, NULL);
+ writebuf = gegl_node_new_child(gegl,
+ "operation", "gegl:write-buffer",
+ "buffer", buffer,
+ NULL);
+ gegl_node_link_many(over, writebuf, NULL);
- processor = gegl_node_new_processor (writebuf, &roi);
- while (gegl_processor_work (processor, NULL)) ;
+ processor = gegl_node_new_processor(writebuf, &roi);
+ while (gegl_processor_work(processor, NULL)) ;
- gegl_processor_destroy (processor);
- g_object_unref (writebuf);
+ gegl_processor_destroy(processor);
+ g_object_unref(writebuf);
- gegl_node_link_many (top, out, NULL);
- g_object_unref (over);
- g_object_unref (stroke);
+ gegl_node_link_many(top, out, NULL);
+ g_object_unref(over);
+ g_object_unref(stroke);
- over = NULL;
- stroke = NULL;
- pen_down = FALSE;
+ over = NULL;
+ stroke = NULL;
+ pen_down = FALSE;
- return TRUE;
+ return TRUE;
}
- return FALSE;
+ return FALSE;
}
static void
-draw_overlay (GeglGtkView *view, cairo_t *cr, GdkRectangle *rect)
+draw_overlay(GeglGtkView *view, cairo_t *cr, GdkRectangle *rect)
{
- cairo_translate (cr, 200.0, 200.0);
+ cairo_translate(cr, 200.0, 200.0);
- cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.3);
- cairo_rectangle (cr, 0.0, 0.0, 200.0, 50.0);
- cairo_fill (cr);
+ cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.3);
+ cairo_rectangle(cr, 0.0, 0.0, 200.0, 50.0);
+ cairo_fill(cr);
- cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 0.9);
- cairo_translate (cr, 20.0, 20.0);
- cairo_show_text (cr, "canvas overlay");
- cairo_fill (cr);
+ cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.9);
+ cairo_translate(cr, 20.0, 20.0);
+ cairo_show_text(cr, "canvas overlay");
+ cairo_fill(cr);
}
static void
-draw_background (GeglGtkView *view, cairo_t *cr, GdkRectangle *rect)
+draw_background(GeglGtkView *view, cairo_t *cr, GdkRectangle *rect)
{
- cairo_set_source_rgba (cr, 0.9, 0.9, 1.0, 1.0);
- cairo_rectangle (cr, 0.0, 0.0, rect->width, rect->height);
- cairo_fill (cr);
+ cairo_set_source_rgba(cr, 0.9, 0.9, 1.0, 1.0);
+ cairo_rectangle(cr, 0.0, 0.0, rect->width, rect->height);
+ cairo_fill(cr);
}
gint
-main (gint argc,
- gchar **argv)
+main(gint argc,
+ gchar **argv)
{
- g_thread_init (NULL);
- gtk_init (&argc, &argv);
- gegl_init (&argc, &argv);
-
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "GEGL-GTK paint example");
-
- if (argv[1] == NULL)
- {
- GeglRectangle rect = {0, 0, 512, 512};
- gpointer buf;
-
- /* XXX: for best overall performance, this format should probably
- * be RaGaBaA float, overeager in-place processing code makes that fail though.
- */
- buffer = gegl_buffer_new (&rect, babl_format("R'G'B' u8"));
- /* it would be useful to have a programmatic way of doing this, filling
- * with a given pixel value
- */
- buf = gegl_buffer_linear_open (buffer, NULL, NULL, babl_format ("Y' u8"));
- memset (buf, 255, 512 * 512);
- gegl_buffer_linear_close (buffer, buf);
- }
- else
- {
- buffer = gegl_buffer_open (argv[1]);
+ g_thread_init(NULL);
+ gtk_init(&argc, &argv);
+ gegl_init(&argc, &argv);
+
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(window), "GEGL-GTK paint example");
+
+ if (argv[1] == NULL) {
+ GeglRectangle rect = {0, 0, 512, 512};
+ gpointer buf;
+
+ /* XXX: for best overall performance, this format should probably
+ * be RaGaBaA float, overeager in-place processing code makes that fail though.
+ */
+ buffer = gegl_buffer_new(&rect, babl_format("R'G'B' u8"));
+ /* it would be useful to have a programmatic way of doing this, filling
+ * with a given pixel value
+ */
+ buf = gegl_buffer_linear_open(buffer, NULL, NULL, babl_format("Y' u8"));
+ memset(buf, 255, 512 * 512);
+ gegl_buffer_linear_close(buffer, buf);
+ } else {
+ buffer = gegl_buffer_open(argv[1]);
}
- gegl = gegl_node_new ();
- {
- GeglNode *loadbuf = gegl_node_new_child (gegl, "operation", "gegl:buffer-source", "buffer", buffer, NULL);
- out = gegl_node_new_child (gegl, "operation", "gegl:nop", NULL);
+ gegl = gegl_node_new();
+ {
+ GeglNode *loadbuf = gegl_node_new_child(gegl, "operation", "gegl:buffer-source", "buffer", buffer, NULL);
+ out = gegl_node_new_child(gegl, "operation", "gegl:nop", NULL);
- gegl_node_link_many (loadbuf, out, NULL);
+ gegl_node_link_many(loadbuf, out, NULL);
- view = GTK_WIDGET(gegl_gtk_view_new_for_node(out));
- gegl_gtk_view_set_x(GEGL_GTK_VIEW(view), -50.0);
- gegl_gtk_view_set_y(GEGL_GTK_VIEW(view), -50.0);
- gegl_gtk_view_set_autoscale_policy(GEGL_GTK_VIEW(view), GEGL_GTK_VIEW_AUTOSCALE_DISABLED);
- top = loadbuf;
- }
+ view = GTK_WIDGET(gegl_gtk_view_new_for_node(out));
+ gegl_gtk_view_set_x(GEGL_GTK_VIEW(view), -50.0);
+ gegl_gtk_view_set_y(GEGL_GTK_VIEW(view), -50.0);
+ gegl_gtk_view_set_autoscale_policy(GEGL_GTK_VIEW(view), GEGL_GTK_VIEW_AUTOSCALE_DISABLED);
+ top = loadbuf;
+ }
- g_signal_connect (G_OBJECT (view), "draw-overlay",
- (GCallback) draw_overlay, NULL);
- g_signal_connect (G_OBJECT (view), "draw-background",
- (GCallback) draw_background, NULL);
+ g_signal_connect(G_OBJECT(view), "draw-overlay",
+ (GCallback) draw_overlay, NULL);
+ g_signal_connect(G_OBJECT(view), "draw-background",
+ (GCallback) draw_background, NULL);
- eventbox = gtk_event_box_new ();
+ eventbox = gtk_event_box_new();
- g_signal_connect (G_OBJECT (eventbox), "motion-notify-event",
- (GCallback) paint_motion, NULL);
- g_signal_connect (G_OBJECT (eventbox), "button-press-event",
- (GCallback) paint_press, NULL);
- g_signal_connect (G_OBJECT (eventbox), "button-release-event",
- (GCallback) paint_release, NULL);
- gtk_widget_add_events (eventbox, GDK_BUTTON_RELEASE_MASK);
+ g_signal_connect(G_OBJECT(eventbox), "motion-notify-event",
+ (GCallback) paint_motion, NULL);
+ g_signal_connect(G_OBJECT(eventbox), "button-press-event",
+ (GCallback) paint_press, NULL);
+ g_signal_connect(G_OBJECT(eventbox), "button-release-event",
+ (GCallback) paint_release, NULL);
+ gtk_widget_add_events(eventbox, GDK_BUTTON_RELEASE_MASK);
- gtk_container_add (GTK_CONTAINER (eventbox), view);
- gtk_container_add (GTK_CONTAINER (window), eventbox);
- gtk_widget_set_size_request (view, 512, 512);
+ gtk_container_add(GTK_CONTAINER(eventbox), view);
+ gtk_container_add(GTK_CONTAINER(window), eventbox);
+ gtk_widget_set_size_request(view, 512, 512);
- g_signal_connect (G_OBJECT (window), "delete-event",
- G_CALLBACK (gtk_main_quit), window);
- gtk_widget_show_all (window);
+ g_signal_connect(G_OBJECT(window), "delete-event",
+ G_CALLBACK(gtk_main_quit), window);
+ gtk_widget_show_all(window);
- gtk_main ();
- g_object_unref (gegl);
- gegl_buffer_destroy (buffer);
+ gtk_main();
+ g_object_unref(gegl);
+ gegl_buffer_destroy(buffer);
- gegl_exit ();
- return 0;
+ gegl_exit();
+ return 0;
}
diff --git a/examples/c/gegl-gtk-scroll.c b/examples/c/gegl-gtk-scroll.c
index 6fd85a4..367dd56 100644
--- a/examples/c/gegl-gtk-scroll.c
+++ b/examples/c/gegl-gtk-scroll.c
@@ -24,55 +24,55 @@
#include <gegl-gtk.h>
gint
-main (gint argc,
- gchar **argv)
+main(gint argc,
+ gchar **argv)
{
- GtkWidget *window = NULL;
- GtkWidget *view = NULL;
- GtkWidget *scrolled = NULL;
- GeglNode *graph = NULL;
- GeglNode *node = NULL;
+ GtkWidget *window = NULL;
+ GtkWidget *view = NULL;
+ GtkWidget *scrolled = NULL;
+ GeglNode *graph = NULL;
+ GeglNode *node = NULL;
- g_thread_init (NULL);
- gtk_init (&argc, &argv);
- gegl_init (&argc, &argv);
+ g_thread_init(NULL);
+ gtk_init(&argc, &argv);
+ gegl_init(&argc, &argv);
- if (argc != 2) {
- g_print ("Usage: %s <FILENAME>\n", argv[0]);
- exit(1);
- }
+ if (argc != 2) {
+ g_print("Usage: %s <FILENAME>\n", argv[0]);
+ exit(1);
+ }
- /* Build graph that loads an image */
- graph = gegl_node_new ();
- node = gegl_node_new_child (graph,
- "operation", "gegl:load",
- "path", argv[1], NULL);
+ /* Build graph that loads an image */
+ graph = gegl_node_new();
+ node = gegl_node_new_child(graph,
+ "operation", "gegl:load",
+ "path", argv[1], NULL);
- gegl_node_process (node);
+ gegl_node_process(node);
- /* Setup */
- window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title (GTK_WINDOW (window), "GEGL-GTK scrolled example");
+ /* Setup */
+ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(window), "GEGL-GTK scrolled example");
- scrolled = gtk_scrolled_window_new(NULL, NULL);
+ scrolled = gtk_scrolled_window_new(NULL, NULL);
- view = GTK_WIDGET(gegl_gtk_view_new_for_node(node));
- gegl_gtk_view_set_autoscale_policy(GEGL_GTK_VIEW(view), GEGL_GTK_VIEW_AUTOSCALE_WIDGET);
+ view = GTK_WIDGET(gegl_gtk_view_new_for_node(node));
+ gegl_gtk_view_set_autoscale_policy(GEGL_GTK_VIEW(view), GEGL_GTK_VIEW_AUTOSCALE_WIDGET);
- gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), view);
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), view);
- gtk_container_add (GTK_CONTAINER (window), scrolled);
+ gtk_container_add(GTK_CONTAINER(window), scrolled);
- g_signal_connect (window, "destroy",
- G_CALLBACK (gtk_main_quit), NULL);
- gtk_widget_show_all (window);
+ g_signal_connect(window, "destroy",
+ G_CALLBACK(gtk_main_quit), NULL);
+ gtk_widget_show_all(window);
- /* Run */
- gtk_main ();
+ /* Run */
+ gtk_main();
- /* Cleanup */
- g_object_unref (graph);
- gegl_exit ();
- return 0;
+ /* Cleanup */
+ g_object_unref(graph);
+ gegl_exit();
+ return 0;
}
diff --git a/gegl-gtk/gegl-gtk-enums.h b/gegl-gtk/gegl-gtk-enums.h
index 63f9385..641152d 100644
--- a/gegl-gtk/gegl-gtk-enums.h
+++ b/gegl-gtk/gegl-gtk-enums.h
@@ -22,12 +22,12 @@
G_BEGIN_DECLS
typedef enum {
- GEGL_GTK_VIEW_AUTOSCALE_DISABLED = 0,
- GEGL_GTK_VIEW_AUTOSCALE_WIDGET,
- GEGL_GTK_VIEW_AUTOSCALE_CONTENT
+ GEGL_GTK_VIEW_AUTOSCALE_DISABLED = 0,
+ GEGL_GTK_VIEW_AUTOSCALE_WIDGET,
+ GEGL_GTK_VIEW_AUTOSCALE_CONTENT
} GeglGtkViewAutoscale;
-GType gegl_gtk_view_autoscale_get_type (void) G_GNUC_CONST;
+GType gegl_gtk_view_autoscale_get_type(void) G_GNUC_CONST;
#define GEGL_GTK_TYPE_VIEW_AUTOSCALE (gegl_gtk_view_autoscale_get_type())
G_END_DECLS
diff --git a/gegl-gtk/gegl-gtk-view.c b/gegl-gtk/gegl-gtk-view.c
index f0c3790..0462494 100644
--- a/gegl-gtk/gegl-gtk-view.c
+++ b/gegl-gtk/gegl-gtk-view.c
@@ -41,25 +41,23 @@
* a widget and rely on the presence and behaviour of a windowing system.
*/
-G_DEFINE_TYPE (GeglGtkView, gegl_gtk_view, GTK_TYPE_DRAWING_AREA)
-
-enum
-{
- PROP_0,
- PROP_NODE,
- PROP_X,
- PROP_Y,
- PROP_SCALE,
- PROP_BLOCK,
- PROP_AUTOSCALE_POLICY
+G_DEFINE_TYPE(GeglGtkView, gegl_gtk_view, GTK_TYPE_DRAWING_AREA)
+
+enum {
+ PROP_0,
+ PROP_NODE,
+ PROP_X,
+ PROP_Y,
+ PROP_SCALE,
+ PROP_BLOCK,
+ PROP_AUTOSCALE_POLICY
};
#ifdef HAVE_CAIRO_GOBJECT
-enum
-{
- SIGNAL_DRAW_BACKGROUND,
- SIGNAL_DRAW_OVERLAY,
- N_SIGNALS
+enum {
+ SIGNAL_DRAW_BACKGROUND,
+ SIGNAL_DRAW_OVERLAY,
+ N_SIGNALS
};
static guint gegl_view_signals[N_SIGNALS];
@@ -74,227 +72,225 @@ get_private(GeglGtkView *self)
#define GET_PRIVATE(self) (get_private(self))
-static void gegl_gtk_view_class_init (GeglGtkViewClass *klass);
-static void gegl_gtk_view_init (GeglGtkView *self);
-static void finalize (GObject *gobject);
-static void set_property (GObject *gobject,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec);
-static void get_property (GObject *gobject,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec);
+static void gegl_gtk_view_class_init(GeglGtkViewClass *klass);
+static void gegl_gtk_view_init(GeglGtkView *self);
+static void finalize(GObject *gobject);
+static void set_property(GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void get_property(GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec);
#ifdef HAVE_GTK2
-static gboolean expose_event (GtkWidget *widget,
- GdkEventExpose *event);
+static gboolean expose_event(GtkWidget *widget,
+ GdkEventExpose *event);
#endif
#ifdef HAVE_GTK3
-static gboolean draw (GtkWidget * widget,
- cairo_t *cr);
+static gboolean draw(GtkWidget *widget,
+ cairo_t *cr);
#endif
static void
-trigger_redraw(ViewHelper* priv, GeglRectangle *rect, GeglGtkView *view);
+trigger_redraw(ViewHelper *priv, GeglRectangle *rect, GeglGtkView *view);
static void
size_allocate(GtkWidget *widget, GdkRectangle *allocation, gpointer user_data);
static void
-view_size_changed(ViewHelper* priv, GeglRectangle *rect, GeglGtkView *view);
+view_size_changed(ViewHelper *priv, GeglRectangle *rect, GeglGtkView *view);
static void
-gegl_gtk_view_class_init (GeglGtkViewClass * klass)
+gegl_gtk_view_class_init(GeglGtkViewClass *klass)
{
- GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
- GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
+ GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
- gobject_class->finalize = finalize;
- gobject_class->set_property = set_property;
- gobject_class->get_property = get_property;
+ gobject_class->finalize = finalize;
+ gobject_class->set_property = set_property;
+ gobject_class->get_property = get_property;
#ifdef HAVE_GTK2
- widget_class->expose_event = expose_event;
+ widget_class->expose_event = expose_event;
#endif
#ifdef HAVE_GTK3
- widget_class->draw = draw;
+ widget_class->draw = draw;
#endif
- g_object_class_install_property (gobject_class, PROP_X,
- g_param_spec_float ("x",
- "X",
- "X origin",
- -G_MAXFLOAT, G_MAXFLOAT, 0.0,
- G_PARAM_CONSTRUCT |
- G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_Y,
- g_param_spec_float ("y",
- "Y",
- "Y origin",
- -G_MAXFLOAT, G_MAXFLOAT, 0.0,
- G_PARAM_CONSTRUCT |
- G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_SCALE,
- g_param_spec_double ("scale",
- "Scale",
- "Zoom factor",
- 0.0, 100.0, 1.00,
- G_PARAM_CONSTRUCT |
- G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_NODE,
- g_param_spec_object ("node",
- "Node",
- "The node to render",
- G_TYPE_OBJECT,
- G_PARAM_CONSTRUCT |
- G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_BLOCK,
- g_param_spec_boolean ("block",
- "Blocking render",
- "Make sure all data requested to blit is generated.",
- FALSE,
- G_PARAM_READWRITE));
- g_object_class_install_property (gobject_class, PROP_AUTOSCALE_POLICY,
- g_param_spec_enum ("autoscale-policy", NULL, NULL,
- GEGL_GTK_TYPE_VIEW_AUTOSCALE,
- GEGL_GTK_VIEW_AUTOSCALE_CONTENT,
- G_PARAM_READWRITE |
- G_PARAM_CONSTRUCT));
+ g_object_class_install_property(gobject_class, PROP_X,
+ g_param_spec_float("x",
+ "X",
+ "X origin",
+ -G_MAXFLOAT, G_MAXFLOAT, 0.0,
+ G_PARAM_CONSTRUCT |
+ G_PARAM_READWRITE));
+ g_object_class_install_property(gobject_class, PROP_Y,
+ g_param_spec_float("y",
+ "Y",
+ "Y origin",
+ -G_MAXFLOAT, G_MAXFLOAT, 0.0,
+ G_PARAM_CONSTRUCT |
+ G_PARAM_READWRITE));
+ g_object_class_install_property(gobject_class, PROP_SCALE,
+ g_param_spec_double("scale",
+ "Scale",
+ "Zoom factor",
+ 0.0, 100.0, 1.00,
+ G_PARAM_CONSTRUCT |
+ G_PARAM_READWRITE));
+ g_object_class_install_property(gobject_class, PROP_NODE,
+ g_param_spec_object("node",
+ "Node",
+ "The node to render",
+ G_TYPE_OBJECT,
+ G_PARAM_CONSTRUCT |
+ G_PARAM_READWRITE));
+ g_object_class_install_property(gobject_class, PROP_BLOCK,
+ g_param_spec_boolean("block",
+ "Blocking render",
+ "Make sure all data requested to blit is generated.",
+ FALSE,
+ G_PARAM_READWRITE));
+ g_object_class_install_property(gobject_class, PROP_AUTOSCALE_POLICY,
+ g_param_spec_enum("autoscale-policy", NULL, NULL,
+ GEGL_GTK_TYPE_VIEW_AUTOSCALE,
+ GEGL_GTK_VIEW_AUTOSCALE_CONTENT,
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT));
#ifdef HAVE_CAIRO_GOBJECT
- gegl_view_signals[SIGNAL_DRAW_BACKGROUND] =
- g_signal_new ("draw-background",
- G_TYPE_FROM_CLASS (klass),
- 0,
- 0,
- NULL,
- NULL,
- gegl_gtk_marshal_VOID__BOXED_BOXED,
- G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
-
- gegl_view_signals[SIGNAL_DRAW_OVERLAY] =
- g_signal_new ("draw-overlay",
- G_TYPE_FROM_CLASS (klass),
- 0,
- 0,
- NULL,
- NULL,
- gegl_gtk_marshal_VOID__BOXED_BOXED,
- G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
+ gegl_view_signals[SIGNAL_DRAW_BACKGROUND] =
+ g_signal_new("draw-background",
+ G_TYPE_FROM_CLASS(klass),
+ 0,
+ 0,
+ NULL,
+ NULL,
+ gegl_gtk_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
+
+ gegl_view_signals[SIGNAL_DRAW_OVERLAY] =
+ g_signal_new("draw-overlay",
+ G_TYPE_FROM_CLASS(klass),
+ 0,
+ 0,
+ NULL,
+ NULL,
+ gegl_gtk_marshal_VOID__BOXED_BOXED,
+ G_TYPE_NONE, 2, CAIRO_GOBJECT_TYPE_CONTEXT, GDK_TYPE_RECTANGLE);
#endif
}
static void
-gegl_gtk_view_init (GeglGtkView *self)
+gegl_gtk_view_init(GeglGtkView *self)
{
- self->priv = (GeglGtkViewPrivate *)view_helper_new();
+ self->priv = (GeglGtkViewPrivate *)view_helper_new();
- g_signal_connect(self->priv, "redraw-needed", G_CALLBACK (trigger_redraw), (gpointer)self);
- g_signal_connect(self->priv, "size-changed", G_CALLBACK (view_size_changed), (gpointer)self);
+ g_signal_connect(self->priv, "redraw-needed", G_CALLBACK(trigger_redraw), (gpointer)self);
+ g_signal_connect(self->priv, "size-changed", G_CALLBACK(view_size_changed), (gpointer)self);
- g_signal_connect(self, "size-allocate", G_CALLBACK (size_allocate), NULL);
+ g_signal_connect(self, "size-allocate", G_CALLBACK(size_allocate), NULL);
}
static void
-finalize (GObject *gobject)
+finalize(GObject *gobject)
{
- GeglGtkView *self = GEGL_GTK_VIEW (gobject);
+ GeglGtkView *self = GEGL_GTK_VIEW(gobject);
- g_object_unref(G_OBJECT(self->priv));
+ g_object_unref(G_OBJECT(self->priv));
- G_OBJECT_CLASS(gegl_gtk_view_parent_class)->finalize(gobject);
+ G_OBJECT_CLASS(gegl_gtk_view_parent_class)->finalize(gobject);
}
static void
-set_property (GObject *gobject,
- guint property_id,
- const GValue *value,
- GParamSpec *pspec)
+set_property(GObject *gobject,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GeglGtkView *self = GEGL_GTK_VIEW (gobject);
- ViewHelper *priv = GET_PRIVATE (self);
+ GeglGtkView *self = GEGL_GTK_VIEW(gobject);
+ ViewHelper *priv = GET_PRIVATE(self);
- switch (property_id)
- {
+ switch (property_id) {
case PROP_NODE:
- gegl_gtk_view_set_node(self, GEGL_NODE(g_value_get_object(value)));
- break;
+ gegl_gtk_view_set_node(self, GEGL_NODE(g_value_get_object(value)));
+ break;
case PROP_X:
- gegl_gtk_view_set_x(self, g_value_get_float(value));
- break;
+ gegl_gtk_view_set_x(self, g_value_get_float(value));
+ break;
case PROP_BLOCK:
- priv->block = g_value_get_boolean (value);
- break;
+ priv->block = g_value_get_boolean(value);
+ break;
case PROP_Y:
- gegl_gtk_view_set_y(self, g_value_get_float(value));
- break;
+ gegl_gtk_view_set_y(self, g_value_get_float(value));
+ break;
case PROP_SCALE:
- gegl_gtk_view_set_scale(self, g_value_get_double(value));
- break;
+ gegl_gtk_view_set_scale(self, g_value_get_double(value));
+ break;
case PROP_AUTOSCALE_POLICY:
- gegl_gtk_view_set_autoscale_policy(self, g_value_get_enum(value));
- break;
+ gegl_gtk_view_set_autoscale_policy(self, g_value_get_enum(value));
+ break;
default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, pspec);
- break;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
+ break;
}
}
static void
-get_property (GObject *gobject,
- guint property_id,
- GValue *value,
- GParamSpec *pspec)
+get_property(GObject *gobject,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GeglGtkView *self = GEGL_GTK_VIEW (gobject);
- ViewHelper *priv = GET_PRIVATE (self);
+ GeglGtkView *self = GEGL_GTK_VIEW(gobject);
+ ViewHelper *priv = GET_PRIVATE(self);
- switch (property_id)
- {
+ switch (property_id) {
case PROP_NODE:
- g_value_set_object (value, gegl_gtk_view_get_node(self));
- break;
+ g_value_set_object(value, gegl_gtk_view_get_node(self));
+ break;
case PROP_X:
- g_value_set_float (value, gegl_gtk_view_get_x(self));
- break;
+ g_value_set_float(value, gegl_gtk_view_get_x(self));
+ break;
case PROP_BLOCK:
- g_value_set_boolean (value, priv->block);
- break;
+ g_value_set_boolean(value, priv->block);
+ break;
case PROP_Y:
- g_value_set_float (value, gegl_gtk_view_get_y(self));
- break;
+ g_value_set_float(value, gegl_gtk_view_get_y(self));
+ break;
case PROP_SCALE:
- g_value_set_double (value, gegl_gtk_view_get_scale(self));
- break;
+ g_value_set_double(value, gegl_gtk_view_get_scale(self));
+ break;
case PROP_AUTOSCALE_POLICY:
- g_value_set_enum (value, gegl_gtk_view_get_autoscale_policy(self));
- break;
+ g_value_set_enum(value, gegl_gtk_view_get_autoscale_policy(self));
+ break;
default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, property_id, pspec);
- break;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, property_id, pspec);
+ break;
}
}
/* Trigger a redraw */
static void
-trigger_redraw (ViewHelper *priv,
- GeglRectangle *rect,
- GeglGtkView *view)
+trigger_redraw(ViewHelper *priv,
+ GeglRectangle *rect,
+ GeglGtkView *view)
{
if (rect->width < 0 || rect->height < 0)
gtk_widget_queue_draw(GTK_WIDGET(view));
else
gtk_widget_queue_draw_area(GTK_WIDGET(view),
- rect->x, rect->y, rect->width, rect->height);
+ rect->x, rect->y, rect->width, rect->height);
}
/* Bounding box of the node view changed */
static void
-view_size_changed(ViewHelper* priv, GeglRectangle *rect, GeglGtkView *view)
+view_size_changed(ViewHelper *priv, GeglRectangle *rect, GeglGtkView *view)
{
/* Resize the widget to fit the entire view bounding box
* TODO: implement a policy for this
@@ -306,79 +302,79 @@ view_size_changed(ViewHelper* priv, GeglRectangle *rect, GeglGtkView *view)
static void
size_allocate(GtkWidget *widget, GdkRectangle *allocation, gpointer user_data)
{
- GeglGtkView *self = GEGL_GTK_VIEW (widget);
+ GeglGtkView *self = GEGL_GTK_VIEW(widget);
view_helper_set_allocation(GET_PRIVATE(self), allocation);
}
static void
draw_implementation(GeglGtkView *self, cairo_t *cr, GdkRectangle *rect)
{
- ViewHelper *priv = GET_PRIVATE (self);
+ ViewHelper *priv = GET_PRIVATE(self);
#ifdef HAVE_CAIRO_GOBJECT
- /* Draw background */
- cairo_save(cr);
- g_signal_emit(G_OBJECT(self), gegl_view_signals[SIGNAL_DRAW_BACKGROUND],
- 0, cr, rect, NULL);
- cairo_restore(cr);
+ /* Draw background */
+ cairo_save(cr);
+ g_signal_emit(G_OBJECT(self), gegl_view_signals[SIGNAL_DRAW_BACKGROUND],
+ 0, cr, rect, NULL);
+ cairo_restore(cr);
#endif
- /* Draw the gegl node */
- cairo_save(cr);
- view_helper_draw(priv, cr, rect);
- cairo_restore(cr);
+ /* Draw the gegl node */
+ cairo_save(cr);
+ view_helper_draw(priv, cr, rect);
+ cairo_restore(cr);
#ifdef HAVE_CAIRO_GOBJECT
- /* Draw overlay */
- cairo_save(cr);
- g_signal_emit(G_OBJECT(self), gegl_view_signals[SIGNAL_DRAW_OVERLAY],
- 0, cr, rect, NULL);
- cairo_restore(cr);
+ /* Draw overlay */
+ cairo_save(cr);
+ g_signal_emit(G_OBJECT(self), gegl_view_signals[SIGNAL_DRAW_OVERLAY],
+ 0, cr, rect, NULL);
+ cairo_restore(cr);
#endif
}
#ifdef HAVE_GTK3
static gboolean
-draw (GtkWidget * widget, cairo_t *cr)
+draw(GtkWidget *widget, cairo_t *cr)
{
- GeglGtkView *self = GEGL_GTK_VIEW (widget);
- ViewHelper *priv = GET_PRIVATE (view);
- GdkRectangle rect;
+ GeglGtkView *self = GEGL_GTK_VIEW(widget);
+ ViewHelper *priv = GET_PRIVATE(view);
+ GdkRectangle rect;
- if (!priv->node)
- return FALSE;
+ if (!priv->node)
+ return FALSE;
- gdk_cairo_get_clip_rectangle (cr, &rect);
-
- draw_implementation(self, cr, &rect);
+ gdk_cairo_get_clip_rectangle(cr, &rect);
- return FALSE;
+ draw_implementation(self, cr, &rect);
+
+ return FALSE;
}
#endif
#ifdef HAVE_GTK2
static gboolean
-expose_event (GtkWidget *widget,
- GdkEventExpose *event)
+expose_event(GtkWidget *widget,
+ GdkEventExpose *event)
{
- GeglGtkView *self = GEGL_GTK_VIEW (widget);
- ViewHelper *priv = GET_PRIVATE (self);
- cairo_t *cr;
- GdkRectangle rect;
+ GeglGtkView *self = GEGL_GTK_VIEW(widget);
+ ViewHelper *priv = GET_PRIVATE(self);
+ cairo_t *cr;
+ GdkRectangle rect;
- if (!priv->node)
- return FALSE;
+ if (!priv->node)
+ return FALSE;
- cr = gdk_cairo_create (widget->window);
- gdk_cairo_region (cr, event->region);
- cairo_clip (cr);
- gdk_region_get_clipbox (event->region, &rect);
+ cr = gdk_cairo_create(widget->window);
+ gdk_cairo_region(cr, event->region);
+ cairo_clip(cr);
+ gdk_region_get_clipbox(event->region, &rect);
- draw_implementation(self, cr, &rect);
+ draw_implementation(self, cr, &rect);
- cairo_destroy (cr);
+ cairo_destroy(cr);
- return FALSE;
+ return FALSE;
}
#endif
@@ -386,7 +382,7 @@ expose_event (GtkWidget *widget,
GeglGtkView *
gegl_gtk_view_new()
{
- return GEGL_GTK_VIEW(g_object_new (GEGL_GTK_TYPE_VIEW, NULL));
+ return GEGL_GTK_VIEW(g_object_new(GEGL_GTK_TYPE_VIEW, NULL));
}
GeglGtkView *
@@ -401,7 +397,7 @@ gegl_gtk_view_new_for_node(GeglNode *node)
void
gegl_gtk_view_set_node(GeglGtkView *self, GeglNode *node)
{
- view_helper_set_node(GET_PRIVATE (self), node);
+ view_helper_set_node(GET_PRIVATE(self), node);
}
/**
diff --git a/gegl-gtk/gegl-gtk-view.h b/gegl-gtk/gegl-gtk-view.h
index 1d21cc1..41cecfd 100644
--- a/gegl-gtk/gegl-gtk-view.h
+++ b/gegl-gtk/gegl-gtk-view.h
@@ -38,20 +38,18 @@ typedef struct _GeglGtkViewClass GeglGtkViewClass;
typedef struct _ViewHelper GeglGtkViewPrivate;
-struct _GeglGtkView
-{
- /*< private >*/
- GtkDrawingArea parent_instance;
- GeglGtkViewPrivate *priv; /* Can't use the GType private mechanism for GObjects */
+struct _GeglGtkView {
+ /*< private >*/
+ GtkDrawingArea parent_instance;
+ GeglGtkViewPrivate *priv; /* Can't use the GType private mechanism for GObjects */
};
-struct _GeglGtkViewClass
-{
- /*< private >*/
- GtkDrawingAreaClass parent_class;
+struct _GeglGtkViewClass {
+ /*< private >*/
+ GtkDrawingAreaClass parent_class;
};
-GType gegl_gtk_view_get_type (void) G_GNUC_CONST;
+GType gegl_gtk_view_get_type(void) G_GNUC_CONST;
GeglGtkView *gegl_gtk_view_new(void);
diff --git a/gegl-gtk/internal/view-helper.c b/gegl-gtk/internal/view-helper.c
index ddbedc7..b71bc4c 100644
--- a/gegl-gtk/internal/view-helper.c
+++ b/gegl-gtk/internal/view-helper.c
@@ -22,97 +22,95 @@
#include <babl/babl.h>
-G_DEFINE_TYPE (ViewHelper, view_helper, G_TYPE_OBJECT)
+G_DEFINE_TYPE(ViewHelper, view_helper, G_TYPE_OBJECT)
-enum
-{
- SIGNAL_REDRAW_NEEDED,
- SIGNAL_SIZE_CHANGED,
- N_SIGNALS
+enum {
+ SIGNAL_REDRAW_NEEDED,
+ SIGNAL_SIZE_CHANGED,
+ N_SIGNALS
};
static guint view_helper_signals[N_SIGNALS] = { 0 };
static void
-finalize (GObject *gobject);
+finalize(GObject *gobject);
static void
-view_helper_class_init (ViewHelperClass * klass)
+view_helper_class_init(ViewHelperClass *klass)
{
- GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
-
- gobject_class->finalize = finalize;
-
- /* Emitted when a redraw is needed, with the area that needs redrawing. */
- view_helper_signals[SIGNAL_REDRAW_NEEDED] = g_signal_new ("redraw-needed",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- 0,
- NULL, NULL,
- g_cclosure_marshal_VOID__BOXED,
- G_TYPE_NONE, 1,
- GEGL_TYPE_RECTANGLE);
-
- /* Emitted when the size of the view changes, with the new size. */
- view_helper_signals[SIGNAL_SIZE_CHANGED] = g_signal_new ("size-changed",
- G_TYPE_FROM_CLASS (klass),
- G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- 0,
- NULL, NULL,
- g_cclosure_marshal_VOID__BOXED,
- G_TYPE_NONE, 1,
- GEGL_TYPE_RECTANGLE);
+ GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
+
+ gobject_class->finalize = finalize;
+
+ /* Emitted when a redraw is needed, with the area that needs redrawing. */
+ view_helper_signals[SIGNAL_REDRAW_NEEDED] = g_signal_new("redraw-needed",
+ G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ 0,
+ NULL, NULL,
+ g_cclosure_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GEGL_TYPE_RECTANGLE);
+
+ /* Emitted when the size of the view changes, with the new size. */
+ view_helper_signals[SIGNAL_SIZE_CHANGED] = g_signal_new("size-changed",
+ G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ 0,
+ NULL, NULL,
+ g_cclosure_marshal_VOID__BOXED,
+ G_TYPE_NONE, 1,
+ GEGL_TYPE_RECTANGLE);
}
static void
-view_helper_init (ViewHelper *self)
+view_helper_init(ViewHelper *self)
{
- GeglRectangle invalid_rect = {0, 0, -1, -1};
- GdkRectangle invalid_gdkrect = {0, 0, -1, -1};
+ GeglRectangle invalid_rect = {0, 0, -1, -1};
+ GdkRectangle invalid_gdkrect = {0, 0, -1, -1};
- self->node = NULL;
- self->x = 0;
- self->y = 0;
- self->scale = 1.0;
- self->autoscale_policy = GEGL_GTK_VIEW_AUTOSCALE_CONTENT;
+ self->node = NULL;
+ self->x = 0;
+ self->y = 0;
+ self->scale = 1.0;
+ self->autoscale_policy = GEGL_GTK_VIEW_AUTOSCALE_CONTENT;
- self->monitor_id = 0;
- self->processor = NULL;
+ self->monitor_id = 0;
+ self->processor = NULL;
- self->widget_allocation = invalid_gdkrect;
+ self->widget_allocation = invalid_gdkrect;
}
static void
-finalize (GObject *gobject)
+finalize(GObject *gobject)
{
- ViewHelper *self = VIEW_HELPER(gobject);
+ ViewHelper *self = VIEW_HELPER(gobject);
- if (self->monitor_id)
- {
- g_source_remove (self->monitor_id);
- self->monitor_id = 0;
+ if (self->monitor_id) {
+ g_source_remove(self->monitor_id);
+ self->monitor_id = 0;
}
- if (self->node)
- g_object_unref (self->node);
+ if (self->node)
+ g_object_unref(self->node);
- if (self->processor)
- g_object_unref (self->processor);
+ if (self->processor)
+ g_object_unref(self->processor);
}
/* Transform a rectangle from model to view coordinates. */
static void
model_rect_to_view_rect(ViewHelper *self, GeglRectangle *rect)
{
- GeglRectangle temp;
+ GeglRectangle temp;
- temp.x = self->scale * (rect->x) - rect->x;
- temp.y = self->scale * (rect->y) - rect->y;
- temp.width = ceil (self->scale * rect->width);
- temp.height = ceil (self->scale * rect->height);
+ temp.x = self->scale * (rect->x) - rect->x;
+ temp.y = self->scale * (rect->y) - rect->y;
+ temp.width = ceil(self->scale * rect->width);
+ temp.height = ceil(self->scale * rect->height);
- *rect = temp;
+ *rect = temp;
}
static void
@@ -123,14 +121,14 @@ update_autoscale(ViewHelper *self)
model_rect_to_view_rect(self, &bbox);
if (!self->node || viewport.width < 0 || viewport.height < 0
- || bbox.width < 0 || bbox.height < 0)
+ || bbox.width < 0 || bbox.height < 0)
return;
if (self->autoscale_policy == GEGL_GTK_VIEW_AUTOSCALE_WIDGET) {
/* Request widget size change */
/* XXX: Should we reset scale/x/y here? */
- g_signal_emit (self, view_helper_signals[SIGNAL_SIZE_CHANGED],
- 0, &bbox, NULL);
+ g_signal_emit(self, view_helper_signals[SIGNAL_SIZE_CHANGED],
+ 0, &bbox, NULL);
} else if (self->autoscale_policy == GEGL_GTK_VIEW_AUTOSCALE_CONTENT) {
/* Calculate and set scaling factor to make the content fit inside */
@@ -139,31 +137,31 @@ update_autoscale(ViewHelper *self)
float max_ratio = width_ratio >= height_ratio ? width_ratio : height_ratio;
float current_scale = view_helper_get_scale(self);
- view_helper_set_scale(self, current_scale*(1.0/max_ratio));
+ view_helper_set_scale(self, current_scale * (1.0 / max_ratio));
}
}
static void
-invalidated_event (GeglNode *node,
- GeglRectangle *rect,
- ViewHelper *self)
+invalidated_event(GeglNode *node,
+ GeglRectangle *rect,
+ ViewHelper *self)
{
- view_helper_repaint (self);
+ view_helper_repaint(self);
}
static gboolean
-task_monitor (ViewHelper *self)
+task_monitor(ViewHelper *self)
{
- if (self->processor==NULL)
- return FALSE;
+ if (self->processor == NULL)
+ return FALSE;
- if (gegl_processor_work (self->processor, NULL))
- return TRUE;
+ if (gegl_processor_work(self->processor, NULL))
+ return TRUE;
- self->monitor_id = 0;
+ self->monitor_id = 0;
- return FALSE;
+ return FALSE;
}
@@ -173,9 +171,9 @@ task_monitor (ViewHelper *self)
* find out which area in the view was computed and emit the
* "redraw-needed" signal to notify it that a redraw is needed */
static void
-computed_event (GeglNode *node,
- GeglRectangle *rect,
- ViewHelper *self)
+computed_event(GeglNode *node,
+ GeglRectangle *rect,
+ ViewHelper *self)
{
update_autoscale(self);
@@ -183,8 +181,8 @@ computed_event (GeglNode *node,
GeglRectangle redraw_rect = *rect;
model_rect_to_view_rect(self, &redraw_rect);
- g_signal_emit (self, view_helper_signals[SIGNAL_REDRAW_NEEDED],
- 0, &redraw_rect, NULL);
+ g_signal_emit(self, view_helper_signals[SIGNAL_REDRAW_NEEDED],
+ 0, &redraw_rect, NULL);
}
ViewHelper *
@@ -199,36 +197,36 @@ view_helper_new(void)
*
* For instance called by widget during the draw/expose */
void
-view_helper_draw (ViewHelper *self, cairo_t *cr, GdkRectangle *rect)
+view_helper_draw(ViewHelper *self, cairo_t *cr, GdkRectangle *rect)
{
- cairo_surface_t *surface = NULL;
- guchar *buf = NULL;
- GeglRectangle roi;
-
- roi.x = self->x + rect->x;
- roi.y = self->y + rect->y;
- roi.width = rect->width;
- roi.height = rect->height;
-
- buf = g_malloc ((roi.width) * (roi.height) * 4);
-
- gegl_node_blit (self->node,
- self->scale,
- &roi,
- babl_format ("B'aG'aR'aA u8"),
- (gpointer)buf,
- GEGL_AUTO_ROWSTRIDE,
- GEGL_BLIT_CACHE | (self->block ? 0 : GEGL_BLIT_DIRTY));
-
- surface = cairo_image_surface_create_for_data (buf,
- CAIRO_FORMAT_ARGB32,
- roi.width, roi.height,
- roi.width*4);
- cairo_set_source_surface (cr, surface, rect->x, rect->y);
- cairo_paint (cr);
-
- cairo_surface_destroy (surface);
- g_free (buf);
+ cairo_surface_t *surface = NULL;
+ guchar *buf = NULL;
+ GeglRectangle roi;
+
+ roi.x = self->x + rect->x;
+ roi.y = self->y + rect->y;
+ roi.width = rect->width;
+ roi.height = rect->height;
+
+ buf = g_malloc((roi.width) * (roi.height) * 4);
+
+ gegl_node_blit(self->node,
+ self->scale,
+ &roi,
+ babl_format("B'aG'aR'aA u8"),
+ (gpointer)buf,
+ GEGL_AUTO_ROWSTRIDE,
+ GEGL_BLIT_CACHE | (self->block ? 0 : GEGL_BLIT_DIRTY));
+
+ surface = cairo_image_surface_create_for_data(buf,
+ CAIRO_FORMAT_ARGB32,
+ roi.width, roi.height,
+ roi.width * 4);
+ cairo_set_source_surface(cr, surface, rect->x, rect->y);
+ cairo_paint(cr);
+
+ cairo_surface_destroy(surface);
+ g_free(buf);
}
@@ -241,37 +239,37 @@ view_helper_set_allocation(ViewHelper *self, GdkRectangle *allocation)
/* Trigger processing of the GeglNode */
void
-view_helper_repaint (ViewHelper *self)
+view_helper_repaint(ViewHelper *self)
{
- GeglRectangle roi;
+ GeglRectangle roi;
- if (!self->node)
- return;
+ if (!self->node)
+ return;
- roi.x = self->x / self->scale;
- roi.y = self->y / self->scale;
+ roi.x = self->x / self->scale;
+ roi.y = self->y / self->scale;
- roi.width = ceil(self->widget_allocation.width / self->scale+1);
- roi.height = ceil(self->widget_allocation.height / self->scale+1);
+ roi.width = ceil(self->widget_allocation.width / self->scale + 1);
+ roi.height = ceil(self->widget_allocation.height / self->scale + 1);
- if (self->monitor_id == 0) {
- self->monitor_id = g_idle_add_full (G_PRIORITY_LOW,
- (GSourceFunc) task_monitor, self,
- NULL);
- }
+ if (self->monitor_id == 0) {
+ self->monitor_id = g_idle_add_full(G_PRIORITY_LOW,
+ (GSourceFunc) task_monitor, self,
+ NULL);
+ }
- if (self->processor)
- gegl_processor_set_rectangle (self->processor, &roi);
- else
- self->processor = gegl_node_new_processor (self->node, &roi);
+ if (self->processor)
+ gegl_processor_set_rectangle(self->processor, &roi);
+ else
+ self->processor = gegl_node_new_processor(self->node, &roi);
}
void
invalidate(ViewHelper *self)
{
GeglRectangle redraw_rect = {0, 0, -1, -1}; /* Indicates full redraw */
- g_signal_emit (self, view_helper_signals[SIGNAL_REDRAW_NEEDED],
- 0, &redraw_rect, NULL);
+ g_signal_emit(self, view_helper_signals[SIGNAL_REDRAW_NEEDED],
+ 0, &redraw_rect, NULL);
}
void
@@ -281,18 +279,18 @@ view_helper_set_node(ViewHelper *self, GeglNode *node)
return;
if (self->node)
- g_object_unref (self->node);
+ g_object_unref(self->node);
if (node) {
- g_object_ref (node);
+ g_object_ref(node);
self->node = node;
- g_signal_connect_object (self->node, "computed",
- G_CALLBACK (computed_event),
- self, 0);
- g_signal_connect_object (self->node, "invalidated",
- G_CALLBACK (invalidated_event),
- self, 0);
+ g_signal_connect_object(self->node, "computed",
+ G_CALLBACK(computed_event),
+ self, 0);
+ g_signal_connect_object(self->node, "invalidated",
+ G_CALLBACK(invalidated_event),
+ self, 0);
invalidate(self);
diff --git a/gegl-gtk/internal/view-helper.h b/gegl-gtk/internal/view-helper.h
index 0c3f95e..4fbb9b4 100644
--- a/gegl-gtk/internal/view-helper.h
+++ b/gegl-gtk/internal/view-helper.h
@@ -37,29 +37,27 @@ G_BEGIN_DECLS
typedef struct _ViewHelper ViewHelper;
typedef struct _ViewHelperClass ViewHelperClass;
-struct _ViewHelper
-{
- GObject parent_instance;
-
- GeglNode *node;
- gfloat x;
- gfloat y;
- gdouble scale;
- gboolean block; /* blocking render */
- GeglGtkViewAutoscale autoscale_policy;
-
- guint monitor_id;
- GeglProcessor *processor;
- GdkRectangle widget_allocation; /* The allocated size of the widget */
+struct _ViewHelper {
+ GObject parent_instance;
+
+ GeglNode *node;
+ gfloat x;
+ gfloat y;
+ gdouble scale;
+ gboolean block; /* blocking render */
+ GeglGtkViewAutoscale autoscale_policy;
+
+ guint monitor_id;
+ GeglProcessor *processor;
+ GdkRectangle widget_allocation; /* The allocated size of the widget */
};
-struct _ViewHelperClass
-{
- GObjectClass parent_class;
+struct _ViewHelperClass {
+ GObjectClass parent_class;
};
-GType view_helper_get_type (void) G_GNUC_CONST;
+GType view_helper_get_type(void) G_GNUC_CONST;
ViewHelper *view_helper_new(void);
void view_helper_node_changed(ViewHelper *self);
diff --git a/operations/gegl-gtk-display.c b/operations/gegl-gtk-display.c
index 3bc41ca..4f2697d 100644
--- a/operations/gegl-gtk-display.c
+++ b/operations/gegl-gtk-display.c
@@ -22,8 +22,8 @@
#ifdef GEGL_CHANT_PROPERTIES
-gegl_chant_string (window_title, _("Window Title"), "",
- _("Title to give window, if no title given inherits name of the pad providing input."))
+gegl_chant_string(window_title, _("Window Title"), "",
+ _("Title to give window, if no title given inherits name of the pad providing input."))
#else
@@ -36,128 +36,120 @@ gegl_chant_string (window_title, _("Window Title"), "",
#include <gtk/gtk.h>
#include <gegl-gtk.h>
-typedef struct
-{
- GtkWidget *window;
- GtkWidget *view_widget;
- GeglNode *node;
- GeglNode *input;
- gint width;
- gint height;
+typedef struct {
+ GtkWidget *window;
+ GtkWidget *view_widget;
+ GeglNode *node;
+ GeglNode *input;
+ gint width;
+ gint height;
} Priv;
static Priv *
-init_priv (GeglOperation *operation)
+init_priv(GeglOperation *operation)
{
- GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
+ GeglChantO *o = GEGL_CHANT_PROPERTIES(operation);
- if (!o->chant_data)
- {
- Priv *priv = g_new0 (Priv, 1);
- o->chant_data = (void*) priv;
+ if (!o->chant_data) {
+ Priv *priv = g_new0(Priv, 1);
+ o->chant_data = (void *) priv;
- gtk_init (0, 0);
+ gtk_init(0, 0);
- priv->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- priv->view_widget = g_object_new (GEGL_GTK_TYPE_VIEW, NULL);
- gtk_container_add (GTK_CONTAINER (priv->window), priv->view_widget);
- priv->width = -1;
- priv->height = -1;
- gtk_widget_set_size_request (priv->view_widget, priv->width, priv->height);
- gtk_window_set_title (GTK_WINDOW (priv->window), o->window_title);
+ priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ priv->view_widget = g_object_new(GEGL_GTK_TYPE_VIEW, NULL);
+ gtk_container_add(GTK_CONTAINER(priv->window), priv->view_widget);
+ priv->width = -1;
+ priv->height = -1;
+ gtk_widget_set_size_request(priv->view_widget, priv->width, priv->height);
+ gtk_window_set_title(GTK_WINDOW(priv->window), o->window_title);
- priv->node = NULL;
- priv->input = NULL;
+ priv->node = NULL;
+ priv->input = NULL;
- gtk_widget_show_all (priv->window);
+ gtk_widget_show_all(priv->window);
}
- return (Priv*)(o->chant_data);
+ return (Priv *)(o->chant_data);
}
static void
-set_window_attributes (GeglOperation *operation, const GeglRectangle *result)
+set_window_attributes(GeglOperation *operation, const GeglRectangle *result)
{
- GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
- Priv *priv = init_priv (operation);
-
- if (priv->width != result->width ||
- priv->height != result->height)
- {
- priv->width = result->width ;
- priv->height = result->height;
- gtk_widget_set_size_request (priv->view_widget, priv->width, priv->height);
+ GeglChantO *o = GEGL_CHANT_PROPERTIES(operation);
+ Priv *priv = init_priv(operation);
+
+ if (priv->width != result->width ||
+ priv->height != result->height) {
+ priv->width = result->width ;
+ priv->height = result->height;
+ gtk_widget_set_size_request(priv->view_widget, priv->width, priv->height);
}
-
-
- if (priv->window)
- {
- gtk_window_resize (GTK_WINDOW (priv->window), priv->width, priv->height);
- if (o->window_title && o->window_title[0]!='\0')
- {
- gtk_window_set_title (GTK_WINDOW (priv->window), o->window_title);
- }
- else
- {
- const gchar *gegl_node_get_debug_name (GeglNode *node);
- gtk_window_set_title (GTK_WINDOW (priv->window),
- gegl_node_get_debug_name (gegl_node_get_producer(operation->node, "input", NULL))
- );
+
+
+ if (priv->window) {
+ gtk_window_resize(GTK_WINDOW(priv->window), priv->width, priv->height);
+ if (o->window_title && o->window_title[0] != '\0') {
+ gtk_window_set_title(GTK_WINDOW(priv->window), o->window_title);
+ } else {
+ const gchar *gegl_node_get_debug_name(GeglNode * node);
+ gtk_window_set_title(GTK_WINDOW(priv->window),
+ gegl_node_get_debug_name(gegl_node_get_producer(operation->node, "input", NULL))
+ );
}
- }
+ }
}
/* Create an input proxy, and initial display operation, and link together.
* These will be passed control when process is called later. */
static void
-attach (GeglOperation *operation)
+attach(GeglOperation *operation)
{
- Priv *priv = init_priv (operation);
+ Priv *priv = init_priv(operation);
- g_assert (!priv->input);
- g_assert (!priv->node);
+ g_assert(!priv->input);
+ g_assert(!priv->node);
- priv->input = gegl_node_get_input_proxy (operation->node, "input");
- priv->node = gegl_node_new_child (operation->node,
- "operation", "gegl:nop",
- NULL);
+ priv->input = gegl_node_get_input_proxy(operation->node, "input");
+ priv->node = gegl_node_new_child(operation->node,
+ "operation", "gegl:nop",
+ NULL);
- gegl_node_link (priv->input, priv->node);
- g_object_set (G_OBJECT (priv->view_widget), "node", priv->node, NULL);
+ gegl_node_link(priv->input, priv->node);
+ g_object_set(G_OBJECT(priv->view_widget), "node", priv->node, NULL);
}
static void
-dispose (GObject *object)
+dispose(GObject *object)
{
- GeglChantO *o = GEGL_CHANT_PROPERTIES (object);
- Priv *priv = (Priv*)o->chant_data;
-
- if (priv)
- {
- gtk_widget_destroy (priv->window);
- g_free (priv);
- o->chant_data = NULL;
+ GeglChantO *o = GEGL_CHANT_PROPERTIES(object);
+ Priv *priv = (Priv *)o->chant_data;
+
+ if (priv) {
+ gtk_widget_destroy(priv->window);
+ g_free(priv);
+ o->chant_data = NULL;
}
- G_OBJECT_CLASS (g_type_class_peek_parent (G_OBJECT_GET_CLASS (object)))->dispose (object);
+ G_OBJECT_CLASS(g_type_class_peek_parent(G_OBJECT_GET_CLASS(object)))->dispose(object);
}
static void
-gegl_chant_class_init (GeglChantClass *klass)
+gegl_chant_class_init(GeglChantClass *klass)
{
- GeglOperationClass *operation_class = GEGL_OPERATION_CLASS (klass);
- GeglOperationSinkClass *sink_class = GEGL_OPERATION_SINK_CLASS (klass);
+ GeglOperationClass *operation_class = GEGL_OPERATION_CLASS(klass);
+ GeglOperationSinkClass *sink_class = GEGL_OPERATION_SINK_CLASS(klass);
- operation_class->attach = attach;
- G_OBJECT_CLASS (klass)->dispose = dispose;
+ operation_class->attach = attach;
+ G_OBJECT_CLASS(klass)->dispose = dispose;
#ifdef HAVE_GTK2
- operation_class->name = "gegl-gtk2:display";
+ operation_class->name = "gegl-gtk2:display";
#else
- operation_class->name = "gegl-gtk3:display";
+ operation_class->name = "gegl-gtk3:display";
#endif
- operation_class->categories = "output";
- operation_class->description =
+ operation_class->categories = "output";
+ operation_class->description =
_("Displays the input buffer in an GTK window .");
}
diff --git a/tests/test-view-helper.c b/tests/test-view-helper.c
index f9792db..8906037 100644
--- a/tests/test-view-helper.c
+++ b/tests/test-view-helper.c
@@ -16,24 +16,24 @@ typedef struct {
static void
-setup_helper_test (ViewHelperTest *test)
+setup_helper_test(ViewHelperTest *test)
{
gpointer buf;
GeglRectangle rect = {0, 0, 512, 512};
/* Create a buffer, fill it with white */
- test->buffer = gegl_buffer_new (&rect, babl_format("R'G'B' u8"));
- buf = gegl_buffer_linear_open (test->buffer, NULL, NULL, babl_format ("Y' u8"));
- memset (buf, 255, rect.width * rect.height);
- gegl_buffer_linear_close (test->buffer, buf);
+ test->buffer = gegl_buffer_new(&rect, babl_format("R'G'B' u8"));
+ buf = gegl_buffer_linear_open(test->buffer, NULL, NULL, babl_format("Y' u8"));
+ memset(buf, 255, rect.width * rect.height);
+ gegl_buffer_linear_close(test->buffer, buf);
/* Setup a graph with two nodes, one sourcing the buffer and a no-op */
- test->graph = gegl_node_new ();
- test->loadbuf = gegl_node_new_child (test->graph,
- "operation", "gegl:buffer-source",
- "buffer", test->buffer, NULL);
- test->out = gegl_node_new_child (test->graph, "operation", "gegl:nop", NULL);
- gegl_node_link_many (test->loadbuf, test->out, NULL);
+ test->graph = gegl_node_new();
+ test->loadbuf = gegl_node_new_child(test->graph,
+ "operation", "gegl:buffer-source",
+ "buffer", test->buffer, NULL);
+ test->out = gegl_node_new_child(test->graph, "operation", "gegl:nop", NULL);
+ gegl_node_link_many(test->loadbuf, test->out, NULL);
/* Setup the GeglView helper, hook up the output node to it */
test->helper = view_helper_new();
@@ -41,11 +41,11 @@ setup_helper_test (ViewHelperTest *test)
}
static void
-teardown_helper_test (ViewHelperTest *test)
+teardown_helper_test(ViewHelperTest *test)
{
- g_object_unref (test->graph);
- gegl_buffer_destroy (test->buffer);
- g_object_unref (test->helper);
+ g_object_unref(test->graph);
+ gegl_buffer_destroy(test->buffer);
+ g_object_unref(test->helper);
}
@@ -55,13 +55,13 @@ typedef struct {
} RedrawTestState;
static void
-needs_redraw_event (ViewHelper *helper,
- GeglRectangle *rect,
- RedrawTestState *data)
+needs_redraw_event(ViewHelper *helper,
+ GeglRectangle *rect,
+ RedrawTestState *data)
{
data->needs_redraw_called = TRUE;
- g_assert (test_utils_compare_rect (rect, data->expected_result));
+ g_assert(test_utils_compare_rect(rect, data->expected_result));
}
/* Test that the redraw signal is emitted when the GeglNode has been computed.
@@ -71,7 +71,7 @@ needs_redraw_event (ViewHelper *helper,
* Redraws can be triggered by other things, and the exposed events
* can be coalesced. */
static void
-test_redraw_on_computed (void)
+test_redraw_on_computed(void)
{
ViewHelperTest test;
GeglRectangle computed_rect = {0, 0, 128, 128};
@@ -81,25 +81,25 @@ test_redraw_on_computed (void)
setup_helper_test(&test);
/* Setup will invalidate the node, make sure those events are processed. */
- while (gtk_events_pending ()) {
- gtk_main_iteration ();
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
}
- gegl_node_process (test.out);
+ gegl_node_process(test.out);
- g_assert (IS_VIEW_HELPER (test.helper));
+ g_assert(IS_VIEW_HELPER(test.helper));
/* TODO: when adding tests for transformed cases,
* split out a function for testing the redrawn area, given
* the input area and the transformation (translation, scaling, rotation) */
- g_signal_connect (G_OBJECT (test.helper), "redraw-needed",
- G_CALLBACK (needs_redraw_event),
- &test_data);
+ g_signal_connect(G_OBJECT(test.helper), "redraw-needed",
+ G_CALLBACK(needs_redraw_event),
+ &test_data);
- g_signal_emit_by_name (test.out, "computed", &computed_rect, NULL);
+ g_signal_emit_by_name(test.out, "computed", &computed_rect, NULL);
- g_timeout_add (300, test_utils_quit_gtk_main, NULL);
- gtk_main ();
+ g_timeout_add(300, test_utils_quit_gtk_main, NULL);
+ gtk_main();
g_assert(test_data.needs_redraw_called);
@@ -107,7 +107,8 @@ test_redraw_on_computed (void)
}
int
-main (int argc, char **argv) {
+main(int argc, char **argv)
+{
int retval = -1;
diff --git a/tests/test-view.c b/tests/test-view.c
index e996589..fdbd01c 100644
--- a/tests/test-view.c
+++ b/tests/test-view.c
@@ -15,45 +15,45 @@ typedef struct {
} ViewWidgetTest;
static void
-setup_widget_test (ViewWidgetTest *test)
+setup_widget_test(ViewWidgetTest *test)
{
gpointer buf;
GeglRectangle rect = {0, 0, 512, 512};
/* Create a buffer, fill it with white */
- test->buffer = gegl_buffer_new (&rect, babl_format("R'G'B' u8"));
- buf = gegl_buffer_linear_open (test->buffer, NULL, NULL, babl_format ("Y' u8"));
- memset (buf, 255, rect.width * rect.height);
- gegl_buffer_linear_close (test->buffer, buf);
+ test->buffer = gegl_buffer_new(&rect, babl_format("R'G'B' u8"));
+ buf = gegl_buffer_linear_open(test->buffer, NULL, NULL, babl_format("Y' u8"));
+ memset(buf, 255, rect.width * rect.height);
+ gegl_buffer_linear_close(test->buffer, buf);
/* Setup a graph with two nodes, one sourcing the buffer and a no-op */
- test->graph = gegl_node_new ();
- test->loadbuf = gegl_node_new_child (test->graph,
- "operation", "gegl:buffer-source",
- "buffer", test->buffer, NULL);
- test->out = gegl_node_new_child (test->graph, "operation", "gegl:nop", NULL);
- gegl_node_link_many (test->loadbuf, test->out, NULL);
+ test->graph = gegl_node_new();
+ test->loadbuf = gegl_node_new_child(test->graph,
+ "operation", "gegl:buffer-source",
+ "buffer", test->buffer, NULL);
+ test->out = gegl_node_new_child(test->graph, "operation", "gegl:nop", NULL);
+ gegl_node_link_many(test->loadbuf, test->out, NULL);
/* Setup the GeglView widget, and a window for it */
- test->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
- test->view = GTK_WIDGET (g_object_new (GEGL_GTK_TYPE_VIEW, "node", test->out, NULL));
- gtk_container_add (GTK_CONTAINER (test->window), test->view);
- gtk_widget_set_size_request (test->view, rect.width, rect.height);
- gtk_widget_show_all (test->window);
+ test->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ test->view = GTK_WIDGET(g_object_new(GEGL_GTK_TYPE_VIEW, "node", test->out, NULL));
+ gtk_container_add(GTK_CONTAINER(test->window), test->view);
+ gtk_widget_set_size_request(test->view, rect.width, rect.height);
+ gtk_widget_show_all(test->window);
}
static void
-teardown_widget_test (ViewWidgetTest *test)
+teardown_widget_test(ViewWidgetTest *test)
{
- g_object_unref (test->graph);
- gegl_buffer_destroy (test->buffer);
- gtk_widget_destroy (test->window);
+ g_object_unref(test->graph);
+ gegl_buffer_destroy(test->buffer);
+ gtk_widget_destroy(test->window);
}
-/* Test that instantiating the widget and hooking up a gegl graph
+/* Test that instantiating the widget and hooking up a gegl graph
* does not cause any crashes, criticals or warnings. */
static void
-test_sanity (void)
+test_sanity(void)
{
ViewWidgetTest test;
@@ -61,16 +61,16 @@ test_sanity (void)
// XXX: Better to do on/after expose event instead?
g_timeout_add(300, test_utils_quit_gtk_main, NULL);
- gtk_main ();
+ gtk_main();
teardown_widget_test(&test);
}
static void
-computed_event (GeglNode *node,
- GeglRectangle *rect,
- gpointer data)
+computed_event(GeglNode *node,
+ GeglRectangle *rect,
+ gpointer data)
{
gboolean *got_computed = (gboolean *)data;
*got_computed = TRUE;
@@ -78,7 +78,7 @@ computed_event (GeglNode *node,
/* Test that the GeglNode is processed when invalidated. */
static void
-test_processing (void)
+test_processing(void)
{
ViewWidgetTest test;
gboolean got_computed_event = FALSE;
@@ -86,22 +86,22 @@ test_processing (void)
setup_widget_test(&test);
/* Setup will invalidate the node, make sure those events are processed. */
- while (gtk_events_pending ()) {
- gtk_main_iteration ();
+ while (gtk_events_pending()) {
+ gtk_main_iteration();
}
- gegl_node_process (test.out);
+ gegl_node_process(test.out);
- g_signal_connect (test.out, "computed",
- G_CALLBACK (computed_event),
- &got_computed_event);
+ g_signal_connect(test.out, "computed",
+ G_CALLBACK(computed_event),
+ &got_computed_event);
- g_signal_emit_by_name (test.out, "invalidated", &invalidated_rect, NULL);
+ g_signal_emit_by_name(test.out, "invalidated", &invalidated_rect, NULL);
- g_timeout_add (300, test_utils_quit_gtk_main, NULL);
- gtk_main ();
+ g_timeout_add(300, test_utils_quit_gtk_main, NULL);
+ gtk_main();
/* FIXME: test that the computed events span the invalidated area */
- g_assert (got_computed_event);
+ g_assert(got_computed_event);
teardown_widget_test(&test);
}
@@ -122,7 +122,8 @@ test_processing (void)
having a real widget backend present. */
int
-main (int argc, char **argv) {
+main(int argc, char **argv)
+{
int retval = -1;
diff --git a/tests/utils.c b/tests/utils.c
index b3b5e57..3c2eefb 100644
--- a/tests/utils.c
+++ b/tests/utils.c
@@ -1,29 +1,31 @@
gboolean
-test_utils_display_is_set () {
- return g_getenv ("DISPLAY") != NULL;
+test_utils_display_is_set()
+{
+ return g_getenv("DISPLAY") != NULL;
}
void
-test_utils_print_rect (GeglRectangle *rect) {
+test_utils_print_rect(GeglRectangle *rect)
+{
- g_print ("GeglRectangle: %d,%d %dx%d", rect->x, rect->y, rect->width, rect->height);
+ g_print("GeglRectangle: %d,%d %dx%d", rect->x, rect->y, rect->width, rect->height);
}
static gboolean
-test_utils_quit_gtk_main (gpointer data)
+test_utils_quit_gtk_main(gpointer data)
{
gtk_main_quit();
}
/* Compare two rectangles, output */
gboolean
-test_utils_compare_rect (GeglRectangle *r, GeglRectangle *s)
+test_utils_compare_rect(GeglRectangle *r, GeglRectangle *s)
{
- gboolean equal = gegl_rectangle_equal (r, s);
+ gboolean equal = gegl_rectangle_equal(r, s);
if (!equal) {
- test_utils_print_rect (r);
- g_printf ("%s", " != ");
- test_utils_print_rect (s);
+ test_utils_print_rect(r);
+ g_printf("%s", " != ");
+ test_utils_print_rect(s);
}
return equal;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
