summaryrefslogtreecommitdiff
path: root/app/cornu/ppedit_gtk1.c
diff options
context:
space:
mode:
Diffstat (limited to 'app/cornu/ppedit_gtk1.c')
-rw-r--r--app/cornu/ppedit_gtk1.c930
1 files changed, 930 insertions, 0 deletions
diff --git a/app/cornu/ppedit_gtk1.c b/app/cornu/ppedit_gtk1.c
new file mode 100644
index 0000000..b81299e
--- /dev/null
+++ b/app/cornu/ppedit_gtk1.c
@@ -0,0 +1,930 @@
+/*
+ppedit - A pattern plate editor for Spiro splines.
+Copyright (C) 2007 Raph Levien
+
+This program is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+as published by the Free Software Foundation; either version 2
+of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301, USA.
+
+*/
+#include <gdk/gdkkeysyms.h>
+#include <gtk/gtk.h>
+#include <libart_lgpl/libart.h>
+#include <string.h>
+#include <stdio.h>
+#include <math.h>
+
+#include "zmisc.h"
+#include "bezctx.h"
+#include "bezctx_libart.h"
+#include "bezctx_ps.h"
+#include "cornu.h"
+#include "spiro.h"
+#include "plate.h"
+#include "image.h"
+
+int n_iter = 10;
+
+typedef struct {
+ const char *description;
+ plate *p;
+} undo_record;
+
+typedef struct {
+ GtkWidget *da;
+ const char *description;
+ plate *p;
+ int undo_n;
+ int undo_i;
+ undo_record undo_buf[16];
+ int undo_xn_state;
+
+ GtkWidget *undo_me;
+ GtkWidget *redo_me;
+
+ GtkWidget *show_knots_me;
+ GtkWidget *show_bg_me;
+ int show_knots;
+ int show_bg;
+
+ image *bg_image;
+} plate_edit;
+
+int
+quit_func(GtkWidget *widget, gpointer dummy)
+{
+ gtk_main_quit();
+ return TRUE;
+}
+
+#define C1 0.55228
+static void
+draw_dot(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ double x, double y, double r, guint32 rgba)
+{
+ ArtBpath bp[6];
+ ArtVpath *vp;
+ ArtSVP *svp;
+
+ bp[0].code = ART_MOVETO;
+ bp[0].x3 = x + r;
+ bp[0].y3 = y;
+ bp[1].code = ART_CURVETO;
+ bp[1].x1 = x + r;
+ bp[1].y1 = y - C1 * r;
+ bp[1].x2 = x + C1 * r;
+ bp[1].y2 = y - r;
+ bp[1].x3 = x;
+ bp[1].y3 = y - r;
+ bp[2].code = ART_CURVETO;
+ bp[2].x1 = x - C1 * r;
+ bp[2].y1 = y - r;
+ bp[2].x2 = x - r;
+ bp[2].y2 = y - C1 * r;
+ bp[2].x3 = x - r;
+ bp[2].y3 = y;
+ bp[3].code = ART_CURVETO;
+ bp[3].x1 = x - r;
+ bp[3].y1 = y + C1 * r;
+ bp[3].x2 = x - C1 * r;
+ bp[3].y2 = y + r;
+ bp[3].x3 = x;
+ bp[3].y3 = y + r;
+ bp[4].code = ART_CURVETO;
+ bp[4].x1 = x + C1 * r;
+ bp[4].y1 = y + r;
+ bp[4].x2 = x + r;
+ bp[4].y2 = y + C1 * r;
+ bp[4].x3 = x + r;
+ bp[4].y3 = y;
+ bp[5].code = ART_END;
+
+ vp = art_bez_path_to_vec(bp, 0.25);
+ svp = art_svp_from_vpath(vp);
+ art_free(vp);
+
+ art_rgb_svp_alpha(svp, x0, y0, x1, y1, rgba, buf, rowstride, NULL);
+ art_svp_free(svp);
+}
+
+static void
+draw_raw_rect(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ double rx0, double ry0, double rx1, double ry1, guint32 rgba)
+{
+ ArtVpath vp[6];
+ ArtSVP *svp;
+
+ vp[0].code = ART_MOVETO;
+ vp[0].x = rx0;
+ vp[0].y = ry1;
+ vp[1].code = ART_LINETO;
+ vp[1].x = rx1;
+ vp[1].y = ry1;
+ vp[2].code = ART_LINETO;
+ vp[2].x = rx1;
+ vp[2].y = ry0;
+ vp[3].code = ART_LINETO;
+ vp[3].x = rx0;
+ vp[3].y = ry0;
+ vp[4].code = ART_LINETO;
+ vp[4].x = rx0;
+ vp[4].y = ry1;
+ vp[5].code = ART_END;
+
+ svp = art_svp_from_vpath(vp);
+
+ art_rgb_svp_alpha(svp, x0, y0, x1, y1, rgba, buf, rowstride, NULL);
+ art_svp_free(svp);
+}
+
+static void
+draw_rect(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ double x, double y, double r, guint32 rgba)
+{
+ draw_raw_rect(buf, x0, y0, x1, y1, rowstride,
+ x - r, y - r, x + r, y + r, rgba);
+}
+
+static void
+draw_half(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ double x, double y, double r, double th, guint32 rgba)
+{
+ ArtBpath bp[6];
+ ArtVpath *vp;
+ ArtSVP *svp;
+ double c = cos(th);
+ double s = sin(th);
+
+ bp[0].code = ART_MOVETO;
+ bp[0].x3 = x + c * r;
+ bp[0].y3 = y + s * r;
+ bp[1].code = ART_CURVETO;
+ bp[1].x1 = x + c * r + C1 * s * r;
+ bp[1].y1 = y + s * r - C1 * c * r;
+ bp[1].x2 = x + s * r + C1 * c * r;
+ bp[1].y2 = y - c * r + C1 * s * r;
+ bp[1].x3 = x + s * r;
+ bp[1].y3 = y - c * r;
+ bp[2].code = ART_CURVETO;
+ bp[2].x1 = x + s * r - C1 * c * r;
+ bp[2].y1 = y - c * r - C1 * s * r;
+ bp[2].x2 = x - c * r + C1 * s * r;
+ bp[2].y2 = y - s * r - C1 * c * r;
+ bp[2].x3 = x - c * r;
+ bp[2].y3 = y - s * r;
+ bp[3].code = ART_LINETO;
+ bp[3].x3 = x + c * r;
+ bp[3].y3 = y + s * r;
+ bp[4].code = ART_END;
+
+ vp = art_bez_path_to_vec(bp, 0.25);
+ svp = art_svp_from_vpath(vp);
+ art_free(vp);
+
+ art_rgb_svp_alpha(svp, x0, y0, x1, y1, rgba, buf, rowstride, NULL);
+ art_svp_free(svp);
+}
+
+static ArtVpath *
+bezctx_to_vpath(bezctx *bc)
+{
+ ArtBpath *bp = bezctx_to_bpath(bc);
+ ArtVpath *vp = art_bez_path_to_vec(bp, .25);
+
+ g_free(bp);
+ if (vp[0].code == ART_END || vp[1].code == ART_END) {
+ g_free(vp);
+ vp = NULL;
+ }
+ return vp;
+}
+
+static void
+draw_plate(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ plate_edit *pe)
+{
+ plate *p = pe->p;
+ int i, j;
+
+ /* find an existing point to select, if any */
+ for (i = 0; i < p->n_sp; i++) {
+ bezctx *bc = new_bezctx_libart();
+ subpath *sp = &p->sp[i];
+ spiro_seg *s = draw_subpath(sp, bc);
+ ArtVpath *vp = bezctx_to_vpath(bc);
+
+ if (vp != NULL) {
+ ArtSVP *svp = art_svp_vpath_stroke(vp, ART_PATH_STROKE_JOIN_MITER,
+ ART_PATH_STROKE_CAP_BUTT,
+ 1.5, 4.0, 0.25);
+
+ art_free(vp);
+ art_rgb_svp_alpha(svp, x0, y0, x1, y1, 0x000000ff, buf, rowstride,
+ NULL);
+ art_svp_free(svp);
+ }
+
+ for (j = 0; j < sp->n_kt; j++) {
+ if (pe->show_knots) {
+ knot *kt = &sp->kt[j];
+ kt_flags kf = kt->flags;
+ if ((kf & KT_SELECTED) && (kf & KT_OPEN)) {
+ draw_dot(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 3, 0x000000ff);
+ draw_dot(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 1.5, 0xffffffff);
+ } else if ((kf & KT_SELECTED) && (kf & KT_CORNER)) {
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 3, 0x000000ff);
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 1.5, 0xffffffff);
+ } else if (!(kf & KT_SELECTED) && (kf & KT_CORNER)) {
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 2.5, 0x000080ff);
+ } else if ((kf & KT_SELECTED) && (kf & KT_CORNU)) {
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 3, 0xc000c0ff);
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 1.5, 0xffffffff);
+ } else if (!(kf & KT_SELECTED) && (kf & KT_CORNU)) {
+ draw_rect(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 2.5, 0x800080ff);
+ } else if ((kf & KT_LEFT) || (kf & KT_RIGHT)) {
+ double th = 1.5708 + (s ? get_knot_th(s, j) : 0);
+ if (kf & KT_LEFT)
+ th += 3.1415926;
+ if (kf & KT_SELECTED) {
+ draw_half(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 4, th, 0x000000ff);
+ draw_half(buf, x0, y0, x1, y1, rowstride,
+ kt->x + sin(th), kt->y - cos(th),
+ 2, th, 0xffffffff);
+ } else {
+ draw_half(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 3, th, 0x000080ff);
+ }
+ } else {
+ draw_dot(buf, x0, y0, x1, y1, rowstride, kt->x, kt->y,
+ 2, 0x000080ff);
+ }
+ }
+ }
+ free_spiro(s);
+ }
+}
+
+static void
+draw_selection(art_u8 *buf, int x0, int y0, int x1, int y1, int rowstride,
+ plate_edit *pe)
+{
+ plate *p = pe->p;
+
+ if (p->motmode == MOTION_MODE_SELECT) {
+ double rx0 = p->sel_x0;
+ double ry0 = p->sel_y0;
+ double rx1 = p->x0;
+ double ry1 = p->y0;
+ if (rx0 > rx1) {
+ double tmp = rx1;
+ rx1 = rx0;
+ rx0 = tmp;
+ }
+ if (ry0 > ry1) {
+ double tmp = ry1;
+ ry1 = ry0;
+ ry0 = tmp;
+ }
+ if (rx1 > rx0 && ry1 > ry0)
+ draw_raw_rect(buf, x0, y0, x1, y1, rowstride,
+ rx0, ry0, rx1, ry1, 0x0000ff20);
+ }
+}
+
+static void
+render_bg_layer(guchar *buf, int rowstride, int x0, int y0, int x1, int y1,
+ plate_edit *pe)
+{
+ const double affine[6] = { 1, 0, 0, 1, 0, 0 };
+
+ if (pe->show_bg && pe->bg_image)
+ render_image(pe->bg_image, affine,
+ buf, rowstride, x0, y0, x1, y1);
+ else
+ memset(buf, 255, (y1 - y0) * rowstride);
+}
+
+static gint
+data_expose (GtkWidget *widget, GdkEventExpose *event, void *data)
+{
+ plate_edit *pe = (plate_edit *)data;
+ int x0 = event->area.x;
+ int y0 = event->area.y;
+ int width = event->area.width;
+ int height = event->area.height;
+ guchar *rgb;
+ int rowstride = (width * 3 + 3) & -4;
+
+ rgb = g_new (guchar, event->area.height * rowstride);
+
+ render_bg_layer(rgb, rowstride, x0, y0, x0 + width, y0 + height, pe);
+
+ draw_plate(rgb, x0, y0, x0 + width, y0 + height, rowstride, pe);
+
+ draw_selection(rgb, x0, y0, x0 + width, y0 + height, rowstride, pe);
+
+ gdk_draw_rgb_image(widget->window,
+ widget->style->black_gc,
+ x0, y0, width, height,
+ GDK_RGB_DITHER_NONE, rgb,
+ rowstride);
+ g_free(rgb);
+ return FALSE;
+}
+
+/* Make sure there's room for at least one more undo record. */
+static void
+makeroom_undo(plate_edit *pe)
+{
+ const int undo_max = sizeof(pe->undo_buf) / sizeof(undo_record);
+
+ if (pe->undo_n == undo_max) {
+ free_plate(pe->undo_buf[0].p);
+ memmove(pe->undo_buf, pe->undo_buf + 1, (undo_max - 1) * sizeof(undo_record));
+ pe->undo_i--;
+ pe->undo_n--;
+ }
+}
+
+static void
+set_undo_menuitem(GtkWidget *me, const char *name, const char *desc)
+{
+ char str[256];
+
+ if (desc) {
+ sprintf(str, "%s %s", name, desc);
+ } else {
+ strcpy(str, name);
+ }
+ gtk_container_foreach(GTK_CONTAINER(me),
+ (GtkCallback)gtk_label_set_text,
+ str);
+ gtk_widget_set_sensitive(me, desc != NULL);
+}
+
+static void
+set_undo_state(plate_edit *pe, const char *undo_desc, const char *redo_desc)
+{
+ set_undo_menuitem(pe->undo_me, "Undo", undo_desc);
+ set_undo_menuitem(pe->redo_me, "Redo", redo_desc);
+}
+
+static void
+begin_undo_xn(plate_edit *pe)
+{
+ int i;
+
+ if (pe->undo_xn_state != 1) {
+ for (i = pe->undo_i; i < pe->undo_n; i++)
+ free_plate(pe->undo_buf[i].p);
+ pe->undo_n = pe->undo_i;
+ makeroom_undo(pe);
+ i = pe->undo_i;
+ pe->undo_buf[i].description = pe->description;
+ pe->undo_buf[i].p = copy_plate(pe->p);
+ pe->undo_n = i + 1;
+ pe->undo_xn_state = 1;
+ }
+}
+
+static void
+dirty_undo_xn(plate_edit *pe, const char *description)
+{
+ if (pe->undo_xn_state == 0) {
+ g_warning("dirty_undo_xn: not in begin_undo_xn state");
+ begin_undo_xn(pe);
+ }
+ if (description == NULL)
+ description = pe->p->description;
+ if (pe->undo_xn_state == 1) {
+ pe->undo_i++;
+ pe->undo_xn_state = 2;
+ set_undo_state(pe, description, NULL);
+ }
+ pe->description = description;
+}
+
+static void
+begindirty_undo_xn(plate_edit *pe, const char *description)
+{
+ begin_undo_xn(pe);
+ dirty_undo_xn(pe, description);
+}
+
+static void
+end_undo_xn(plate_edit *pe)
+{
+ if (pe->undo_xn_state == 0) {
+ g_warning("end_undo_xn: not in undo xn");
+ }
+ pe->undo_xn_state = 0;
+}
+
+static int
+undo(plate_edit *pe)
+{
+ if (pe->undo_i == 0)
+ return 0;
+
+ if (pe->undo_i == pe->undo_n) {
+ makeroom_undo(pe);
+ pe->undo_buf[pe->undo_i].description = pe->description;
+ pe->undo_buf[pe->undo_i].p = pe->p;
+ pe->undo_n++;
+ } else {
+ free_plate(pe->p);
+ }
+ pe->undo_i--;
+ pe->description = pe->undo_buf[pe->undo_i].description;
+ set_undo_state(pe,
+ pe->undo_i > 0 ? pe->description : NULL,
+ pe->undo_buf[pe->undo_i + 1].description);
+ g_print("undo: %d of %d\n", pe->undo_i, pe->undo_n);
+ pe->p = copy_plate(pe->undo_buf[pe->undo_i].p);
+ return 1;
+}
+
+static int
+redo(plate_edit *pe)
+{
+ if (pe->undo_i >= pe->undo_n - 1)
+ return 0;
+ free_plate(pe->p);
+ pe->undo_i++;
+ set_undo_state(pe,
+ pe->undo_buf[pe->undo_i].description,
+ pe->undo_i < pe->undo_n - 1 ?
+ pe->undo_buf[pe->undo_i + 1].description : NULL);
+ pe->description = pe->undo_buf[pe->undo_i].description;
+ pe->p = copy_plate(pe->undo_buf[pe->undo_i].p);
+ g_print("redo: %d of %d\n", pe->undo_i, pe->undo_n);
+ return 1;
+}
+
+static gint
+data_button_press (GtkWidget *widget, GdkEventButton *event, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+ plate *p = pe->p;
+ double x, y;
+ press_mod mods = 0;
+
+#define noVERBOSE
+#ifdef VERBOSE
+ g_print ("button press %f %f %f %d\n",
+ event->x, event->y, event->pressure, event->type);
+
+#endif
+ x = event->x;
+ y = event->y;
+ if (event->state & GDK_SHIFT_MASK) mods |= PRESS_MOD_SHIFT;
+ if (event->state & GDK_CONTROL_MASK) mods |= PRESS_MOD_CTRL;
+ if (event->type == GDK_2BUTTON_PRESS) mods |= PRESS_MOD_DOUBLE;
+ if (event->type == GDK_3BUTTON_PRESS) mods |= PRESS_MOD_TRIPLE;
+
+ begin_undo_xn(pe);
+ p->description = NULL;
+ plate_press(p, x, y, mods);
+ if (p->description) dirty_undo_xn(pe, NULL);
+ gtk_widget_queue_draw(widget);
+
+ return TRUE;
+}
+
+static gint
+data_motion_move (GtkWidget *widget, GdkEventMotion *event, plate_edit *pe)
+{
+ double x, y;
+ x = event->x;
+ y = event->y;
+
+ plate_motion_move(pe->p, x, y);
+ dirty_undo_xn(pe, NULL);
+
+ gtk_widget_queue_draw(widget);
+
+ return TRUE;
+}
+
+static gint
+data_motion_select (GtkWidget *widget, GdkEventMotion *event, plate_edit *pe)
+{
+ double x, y;
+
+ x = event->x;
+ y = event->y;
+
+ plate_motion_select(pe->p, x, y);
+ gtk_widget_queue_draw(widget);
+
+ return TRUE;
+}
+
+static gint
+data_motion (GtkWidget *widget, GdkEventMotion *event, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+#ifdef VERBOSE
+ g_print ("motion %f %f %f\n", event->x, event->y, event->pressure);
+
+#endif
+ if (pe->p->motmode == MOTION_MODE_MOVE)
+ return data_motion_move(widget, event, pe);
+ else if (pe->p->motmode == MOTION_MODE_SELECT)
+ return data_motion_select(widget, event, pe);
+ return TRUE;
+}
+
+static gint
+data_button_release (GtkWidget *widget, GdkEventMotion *event, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+ int need_redraw;
+
+ need_redraw = (pe->p->motmode == MOTION_MODE_SELECT);
+
+ plate_unpress(pe->p);
+
+ gtk_widget_queue_draw(widget);
+
+ return TRUE;
+}
+
+static gboolean
+key_press(GtkWidget *widget, GdkEventKey *event, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+ int delta = event->state & 4 ? 10 : 1;
+ int old_n_iter = n_iter;
+ double dx = 0, dy = 0;
+ gboolean did_something = FALSE;
+
+ g_print("key press %d %s %d\n", event->keyval, event->string, event->state);
+
+ if (event->keyval == '<') {
+ did_something = TRUE;
+ n_iter -= delta;
+ } else if (event->keyval == '>') {
+ n_iter += delta;
+ }
+ if (n_iter < 0) n_iter = 0;
+ if (n_iter != old_n_iter)
+ g_print("n_iter = %d\n", n_iter);
+
+ if (event->keyval == GDK_Left)
+ dx = -1;
+ else if (event->keyval == GDK_Right)
+ dx = 1;
+ else if (event->keyval == GDK_Up)
+ dy = -1;
+ else if (event->keyval == GDK_Down)
+ dy = 1;
+ if (event->state & GDK_SHIFT_MASK) {
+ dx *= 10;
+ dy *= 10;
+ } else if (event->state & GDK_CONTROL_MASK) {
+ dx *= .1;
+ dy *= .1;
+ }
+ if (dx != 0 || dy != 0) {
+ begindirty_undo_xn(pe, "Keyboard move");
+ plate_motion_move(pe->p, pe->p->x0 + dx, pe->p->y0 + dy);
+ end_undo_xn(pe);
+ did_something = TRUE;
+ }
+
+ if (did_something) {
+ gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key-press-event");
+ gtk_widget_queue_draw(widget);
+ }
+
+ return did_something;
+}
+
+static gint
+toggle_corner_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ begindirty_undo_xn(pe, "Toggle Corner");
+ plate_toggle_corner(pe->p);
+ end_undo_xn(pe);
+ gtk_widget_queue_draw(pe->da);
+
+ return TRUE;
+}
+
+static gint
+delete_pt_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ begindirty_undo_xn(pe, "Delete Point");
+ plate_delete_pt(pe->p);
+ end_undo_xn(pe);
+ gtk_widget_queue_draw(pe->da);
+
+ return TRUE;
+}
+
+static gint
+set_select_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_SELECT;
+ return TRUE;
+}
+
+static gint
+set_curve_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_ADD_CURVE;
+ pe->p->last_curve_mmode = pe->p->mmode;
+ return TRUE;
+}
+
+static gint
+set_corner_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_ADD_CORNER;
+ return TRUE;
+}
+
+static gint
+set_left_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_ADD_LEFT;
+ return TRUE;
+}
+
+static gint
+set_right_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_ADD_RIGHT;
+ return TRUE;
+}
+
+static gint
+set_cornu_mode_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->p->mmode = MOUSE_MODE_ADD_CORNU;
+ pe->p->last_curve_mmode = pe->p->mmode;
+ return TRUE;
+}
+
+static gint
+undo_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ undo(pe);
+ gtk_widget_queue_draw(pe->da);
+
+ return TRUE;
+}
+
+static gint
+redo_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ redo(pe);
+ gtk_widget_queue_draw(pe->da);
+
+ return TRUE;
+}
+
+static gint
+save_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ file_write_plate("plate", pe->p);
+
+ return TRUE;
+}
+
+static gint
+toggle_show_knots_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->show_knots = !pe->show_knots;
+ gtk_container_foreach(GTK_CONTAINER(pe->show_knots_me),
+ (GtkCallback)gtk_label_set_text,
+ pe->show_knots ? "Hide Knots" : "Show Knots");
+ gtk_widget_queue_draw(pe->da);
+ return TRUE;
+}
+
+static gint
+toggle_show_bg_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+
+ pe->show_bg = !pe->show_bg;
+ gtk_container_foreach(GTK_CONTAINER(pe->show_bg_me),
+ (GtkCallback)gtk_label_set_text,
+ pe->show_bg ? "Hide BG" : "Show BG");
+ gtk_widget_queue_draw(pe->da);
+ return TRUE;
+}
+
+static gint
+print_func(GtkWidget *widget, gpointer data)
+{
+ plate_edit *pe = (plate_edit *)data;
+ plate *p = pe->p;
+ int i;
+ FILE *f = fopen("/tmp/foo.ps", "w");
+ bezctx *bc = new_bezctx_ps(f);
+
+ fputs(ps_prolog, f);
+ for (i = 0; i < p->n_sp; i++) {
+ subpath *sp = &p->sp[i];
+ free_spiro(draw_subpath(sp, bc));
+ }
+ bezctx_ps_close(bc);
+ fputs(ps_postlog, f);
+ fclose(f);
+ return TRUE;
+}
+
+static GtkWidget *
+add_menuitem(GtkWidget *menu, const char *name, GtkSignalFunc callback,
+ gpointer callback_data, GtkAccelGroup *ag, const char *accel)
+{
+ GtkWidget *menuitem;
+
+ menuitem = gtk_menu_item_new_with_label(name);
+ gtk_menu_append(GTK_MENU(menu), menuitem);
+ gtk_widget_show(menuitem);
+ if (accel != NULL) {
+ guint accel_key, accel_mods;
+
+ gtk_accelerator_parse(accel, &accel_key, &accel_mods);
+ gtk_widget_add_accelerator(menuitem, "activate", ag,
+ accel_key, accel_mods, GTK_ACCEL_VISIBLE);
+ }
+ gtk_signal_connect(GTK_OBJECT(menuitem), "activate",
+ (GtkSignalFunc)callback, callback_data);
+ return (menuitem);
+}
+
+static void
+create_mainwin(plate_edit *p)
+{
+ GtkWidget *mainwin;
+ GtkWidget *eb;
+ GtkWidget *da;
+ GtkWidget *vbox;
+ GtkWidget *menubar;
+ GtkWidget *menu;
+ GtkWidget *menuitem;
+ GtkAccelGroup *ag;
+ void *data = p;
+
+ mainwin = gtk_widget_new(gtk_window_get_type(),
+ "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
+ "GtkWindow::title", "pattern plate editor",
+ NULL);
+ gtk_signal_connect(GTK_OBJECT(mainwin), "destroy",
+ (GtkSignalFunc)quit_func, NULL);
+
+ vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(mainwin), vbox);
+
+ menubar = gtk_menu_bar_new();
+ ag = gtk_accel_group_new();
+ gtk_window_add_accel_group(GTK_WINDOW(mainwin), ag);
+ gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
+
+ menu = gtk_menu_new();
+ menuitem = gtk_menu_item_new_with_label("File");
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
+ gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
+ gtk_widget_show(menuitem);
+ gtk_menu_set_accel_group(GTK_MENU(menu), ag);
+ add_menuitem(menu, "Save", (GtkSignalFunc)save_func, data, ag, "<ctrl>S");
+ add_menuitem(menu, "Quit", (GtkSignalFunc)quit_func, data, ag, "<ctrl>Q");
+ add_menuitem(menu, "Print", (GtkSignalFunc)print_func, data, ag, "<ctrl>P");
+
+ menu = gtk_menu_new();
+ menuitem = gtk_menu_item_new_with_label("Edit");
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
+ gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
+ gtk_widget_show(menuitem);
+ gtk_menu_set_accel_group(GTK_MENU(menu), ag);
+ p->undo_me = add_menuitem(menu, "Undo", (GtkSignalFunc)undo_func, data, ag, "<ctrl>Z");
+ p->redo_me = add_menuitem(menu, "Redo", (GtkSignalFunc)redo_func, data, ag, "<ctrl>Y");
+ set_undo_state(p, NULL, NULL);
+ add_menuitem(menu, "Toggle Corner", (GtkSignalFunc)toggle_corner_func, data, ag, "<ctrl>T");
+ add_menuitem(menu, "Delete Point", (GtkSignalFunc)delete_pt_func, data, ag, "<ctrl>D");
+ add_menuitem(menu, "Selection Mode", (GtkSignalFunc)set_select_mode_func, data, ag, "1");
+ add_menuitem(menu, "Add Curve Mode", (GtkSignalFunc)set_curve_mode_func, data, ag, "2");
+ add_menuitem(menu, "Add Corner Mode", (GtkSignalFunc)set_corner_mode_func, data, ag, "3");
+ add_menuitem(menu, "Add Left Mode", (GtkSignalFunc)set_left_mode_func, data, ag, "4");
+ add_menuitem(menu, "Add Right Mode", (GtkSignalFunc)set_right_mode_func, data, ag, "5");
+ add_menuitem(menu, "Add Cornu Mode", (GtkSignalFunc)set_cornu_mode_func, data, ag, "6");
+
+
+ menu = gtk_menu_new();
+ menuitem = gtk_menu_item_new_with_label("View");
+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
+ gtk_menu_bar_append(GTK_MENU_BAR(menubar), menuitem);
+ gtk_widget_show(menuitem);
+ gtk_menu_set_accel_group(GTK_MENU(menu), ag);
+ p->show_knots_me = add_menuitem(menu, "Hide Knots",
+ (GtkSignalFunc)toggle_show_knots_func,
+ data, ag, "<ctrl>K");
+ p->show_bg_me = add_menuitem(menu, "Hide BG",
+ (GtkSignalFunc)toggle_show_bg_func,
+ data, ag, "<ctrl>B");
+
+ eb = gtk_event_box_new ();
+ GTK_WIDGET_SET_FLAGS(eb, GTK_CAN_FOCUS);
+ gtk_box_pack_start(GTK_BOX(vbox), eb, TRUE, TRUE, 0);
+ gtk_widget_set_extension_events (eb, GDK_EXTENSION_EVENTS_ALL);
+ gtk_signal_connect(GTK_OBJECT (eb), "button-press-event",
+ (GtkSignalFunc) data_button_press, data);
+ gtk_signal_connect(GTK_OBJECT (eb), "motion-notify-event",
+ (GtkSignalFunc) data_motion, data);
+ gtk_signal_connect(GTK_OBJECT (eb), "button-release-event",
+ (GtkSignalFunc) data_button_release, data);
+ gtk_signal_connect(GTK_OBJECT(eb), "key-press-event",
+ (GtkSignalFunc)key_press, data);
+
+ da = gtk_drawing_area_new();
+ p->da = da;
+ gtk_window_set_default_size(GTK_WINDOW(mainwin), 512, 512);
+ gtk_container_add(GTK_CONTAINER(eb), da);
+ gtk_signal_connect(GTK_OBJECT (da), "expose-event",
+ (GtkSignalFunc) data_expose, data);
+#if 0
+ gtk_widget_set_double_buffered(da, FALSE);
+#endif
+
+ gtk_widget_grab_focus(eb);
+ gtk_widget_show(da);
+ gtk_widget_show(eb);
+ gtk_widget_show(menubar);
+ gtk_widget_show(vbox);
+ gtk_widget_show(mainwin);
+}
+
+int main(int argc, char **argv)
+{
+ plate_edit pe;
+ plate *p = NULL;
+ gtk_init(&argc, &argv);
+ gtk_widget_set_default_colormap(gdk_rgb_get_cmap());
+ gtk_widget_set_default_visual(gdk_rgb_get_visual());
+ char *reason;
+
+ if (argc > 1)
+ p = file_read_plate(argv[1]);
+ if (p == NULL)
+ p = new_plate();
+ pe.p = p;
+ pe.undo_n = 0;
+ pe.undo_i = 0;
+ pe.undo_xn_state = 0;
+ pe.show_knots = 1;
+ pe.show_bg = 1;
+ pe.bg_image = load_image_file("/tmp/foo.ppm", &reason);
+ create_mainwin(&pe);
+ gtk_main();
+ return 0;
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-11 03:33:22 +0000