/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */ /* * gtk.c: GTK front end for my puzzle collection. */ /* * Modified by Iain Holmes * Changes (C) 2006-2007 Openedhand, Ltd. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "puzzles.h" /* ---------------------------------------------------------------------- * GTK front end to puzzles. */ struct font { PangoFontDescription *desc; int type; int size; }; /* * This structure holds all the data relevant to a single window. * In principle this would allow us to open multiple independent * puzzle windows, although I can't currently see any real point in * doing so. I'm just coding cleanly because there's no * particularly good reason not to. */ struct frontend { GtkWidget *window; GtkAccelGroup *accelgroup; GtkWidget *area; GtkWidget *statusbar; guint statusctx; GdkPixmap *pixmap; GdkColor *colours; int ncolours; GdkColormap *colmap; int w, h; midend *me; GdkGC *gc; int bbox_l, bbox_r, bbox_u, bbox_d; int timer_active, timer_id; struct timeval last_time; struct font *fonts; int nfonts, fontsize; config_item *cfg; int cfg_which, cfgret; GtkWidget *cfgbox; int pw, ph; /* pixmap size (w, h are area size) */ int ox, oy; /* offset of pixmap in drawing area */ GdkPixbuf **pixbufs; int npixbufs; }; void get_random_seed(void **randseed, int *randseedsize) { struct timeval *tvp = snew(struct timeval); gettimeofday(tvp, NULL); *randseed = (void *)tvp; *randseedsize = sizeof(struct timeval); } void frontend_default_colour(frontend *fe, float *output) { GdkColor col = fe->window->style->bg[GTK_STATE_NORMAL]; output[0] = col.red / 65535.0; output[1] = col.green / 65535.0; output[2] = col.blue / 65535.0; } void gtk_status_bar(void *handle, char *text) { frontend *fe = (frontend *)handle; assert(fe->statusbar); gtk_statusbar_pop(GTK_STATUSBAR(fe->statusbar), fe->statusctx); gtk_statusbar_push(GTK_STATUSBAR(fe->statusbar), fe->statusctx, text); } void gtk_start_draw(void *handle) { frontend *fe = (frontend *)handle; fe->gc = gdk_gc_new(fe->area->window); fe->bbox_l = fe->w; fe->bbox_r = 0; fe->bbox_u = fe->h; fe->bbox_d = 0; } void gtk_clip(void *handle, int x, int y, int w, int h) { frontend *fe = (frontend *)handle; GdkRectangle rect; rect.x = x; rect.y = y; rect.width = w; rect.height = h; gdk_gc_set_clip_rectangle(fe->gc, &rect); } void gtk_unclip(void *handle) { frontend *fe = (frontend *)handle; GdkRectangle rect; rect.x = 0; rect.y = 0; rect.width = fe->w; rect.height = fe->h; gdk_gc_set_clip_rectangle(fe->gc, &rect); } void gtk_draw_text(void *handle, int x, int y, int fonttype, int fontsize, int align, int colour, char *text) { frontend *fe = (frontend *)handle; int i; /* * Find or create the font. */ for (i = 0; i < fe->nfonts; i++) if (fe->fonts[i].type == fonttype && fe->fonts[i].size == fontsize) break; if (i == fe->nfonts) { if (fe->fontsize <= fe->nfonts) { fe->fontsize = fe->nfonts + 10; fe->fonts = sresize(fe->fonts, fe->fontsize, struct font); } fe->nfonts++; fe->fonts[i].type = fonttype; fe->fonts[i].size = fontsize; /* * Use Pango to find the closest match to the requested * font. */ { PangoFontDescription *fd; fd = pango_font_description_new(); /* `Monospace' and `Sans' are meta-families guaranteed to exist */ pango_font_description_set_family(fd, fonttype == FONT_FIXED ? "Monospace" : "Sans"); pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD); pango_font_description_set_absolute_size(fd, PANGO_SCALE*fontsize); fe->fonts[i].desc = fd; } } /* * Set the colour. */ gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); { PangoLayout *layout; PangoRectangle rect; /* * Create a layout. */ layout = pango_layout_new(gtk_widget_get_pango_context(fe->area)); pango_layout_set_font_description(layout, fe->fonts[i].desc); pango_layout_set_text(layout, text, strlen(text)); pango_layout_get_pixel_extents(layout, NULL, &rect); if (align & ALIGN_VCENTRE) rect.y -= rect.height / 2; else rect.y -= rect.height; if (align & ALIGN_HCENTRE) rect.x -= rect.width / 2; else if (align & ALIGN_HRIGHT) rect.x -= rect.width; gdk_draw_layout(fe->pixmap, fe->gc, rect.x + x, rect.y + y, layout); g_object_unref(layout); } } void gtk_draw_rect(void *handle, int x, int y, int w, int h, int colour) { frontend *fe = (frontend *)handle; gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); gdk_draw_rectangle(fe->pixmap, fe->gc, 1, x, y, w, h); } void gtk_draw_line(void *handle, int x1, int y1, int x2, int y2, int colour) { frontend *fe = (frontend *)handle; gdk_gc_set_foreground(fe->gc, &fe->colours[colour]); gdk_draw_line(fe->pixmap, fe->gc, x1, y1, x2, y2); } void gtk_draw_poly(void *handle, int *coords, int npoints, int fillcolour, int outlinecolour) { frontend *fe = (frontend *)handle; GdkPoint *points = snewn(npoints, GdkPoint); int i; for (i = 0; i < npoints; i++) { points[i].x = coords[i*2]; points[i].y = coords[i*2+1]; } if (fillcolour >= 0) { gdk_gc_set_foreground(fe->gc, &fe->colours[fillcolour]); gdk_draw_polygon(fe->pixmap, fe->gc, TRUE, points, npoints); } assert(outlinecolour >= 0); gdk_gc_set_foreground(fe->gc, &fe->colours[outlinecolour]); /* * In principle we ought to be able to use gdk_draw_polygon for * the outline as well. In fact, it turns out to interact badly * with a clipping region, for no terribly obvious reason, so I * draw the outline as a sequence of lines instead. */ for (i = 0; i < npoints; i++) gdk_draw_line(fe->pixmap, fe->gc, points[i].x, points[i].y, points[(i+1)%npoints].x, points[(i+1)%npoints].y); sfree(points); } void gtk_draw_circle(void *handle, int cx, int cy, int radius, int fillcolour, int outlinecolour) { frontend *fe = (frontend *)handle; /* cairo_t *cr; */ if (fillcolour >= 0) { gdk_gc_set_foreground(fe->gc, &fe->colours[fillcolour]); gdk_draw_arc(fe->pixmap, fe->gc, TRUE, cx - radius, cy - radius, 2 * radius, 2 * radius, 0, 360 * 64); } assert(outlinecolour >= 0); gdk_gc_set_foreground(fe->gc, &fe->colours[outlinecolour]); gdk_draw_arc(fe->pixmap, fe->gc, FALSE, cx - radius, cy - radius, 2 * radius, 2 * radius, 0, 360 * 64); #if 0 cr = gdk_cairo_create (fe->pixmap); cairo_new_path (cr); cairo_arc (cr, cx, cy, radius, 0.0, 2 * G_PI); if (fillcolour >= 0) { gdk_cairo_set_source_color (cr, &fe->colours[fillcolour]); cairo_fill_preserve (cr); } gdk_cairo_set_source_color (cr, &fe->colours[outlinecolour]); cairo_stroke (cr); cairo_destroy (cr); #endif } static void gtk_draw_pixbuf (void *handle, int x, int y, int pixbuf) { frontend *fe = (frontend *) handle; g_return_if_fail (pixbuf < fe->npixbufs); gdk_draw_pixbuf (fe->pixmap, fe->gc, fe->pixbufs[pixbuf], 0, 0, x, y, -1, -1, GDK_RGB_DITHER_NONE, 0, 0); } struct blitter { GdkPixmap *pixmap; int w, h, x, y; }; blitter *gtk_blitter_new(void *handle, int w, int h) { /* * We can't create the pixmap right now, because fe->window * might not yet exist. So we just cache w and h and create it * during the firs call to blitter_save. */ blitter *bl = g_new (blitter, 1); bl->pixmap = NULL; bl->w = w; bl->h = h; return bl; } void gtk_blitter_free(void *handle, blitter *bl) { if (bl->pixmap) { gdk_pixmap_unref(bl->pixmap); } g_free (bl); } void gtk_blitter_save(void *handle, blitter *bl, int x, int y) { frontend *fe = (frontend *)handle; if (!bl->pixmap) bl->pixmap = gdk_pixmap_new(fe->area->window, bl->w, bl->h, -1); bl->x = x; bl->y = y; gdk_draw_pixmap(bl->pixmap, fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], fe->pixmap, x, y, 0, 0, bl->w, bl->h); } void gtk_blitter_load(void *handle, blitter *bl, int x, int y) { frontend *fe = (frontend *)handle; assert(bl->pixmap); if (x == BLITTER_FROMSAVED && y == BLITTER_FROMSAVED) { x = bl->x; y = bl->y; } gdk_draw_pixmap(fe->pixmap, fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], bl->pixmap, 0, 0, x, y, bl->w, bl->h); } void gtk_draw_update(void *handle, int x, int y, int w, int h) { frontend *fe = (frontend *)handle; if (fe->bbox_l > x ) fe->bbox_l = x ; if (fe->bbox_r < x+w) fe->bbox_r = x+w; if (fe->bbox_u > y ) fe->bbox_u = y ; if (fe->bbox_d < y+h) fe->bbox_d = y+h; } void gtk_end_draw(void *handle) { frontend *fe = (frontend *)handle; gdk_gc_unref(fe->gc); fe->gc = NULL; if (fe->bbox_l < fe->bbox_r && fe->bbox_u < fe->bbox_d) { gdk_draw_pixmap(fe->area->window, fe->area->style->fg_gc[GTK_WIDGET_STATE(fe->area)], fe->pixmap, fe->bbox_l, fe->bbox_u, fe->ox + fe->bbox_l, fe->oy + fe->bbox_u, fe->bbox_r - fe->bbox_l, fe->bbox_d - fe->bbox_u); } } const struct drawing_api gtk_drawing = { gtk_draw_text, gtk_draw_rect, gtk_draw_line, gtk_draw_poly, gtk_draw_circle, gtk_draw_update, gtk_clip, gtk_unclip, gtk_start_draw, gtk_end_draw, gtk_status_bar, gtk_blitter_new, gtk_blitter_free, gtk_blitter_save, gtk_blitter_load, NULL, NULL, NULL, NULL, NULL, NULL, /* {begin,end}_{doc,page,puzzle} */ NULL, /* line_width */ gtk_draw_pixbuf, }; static void destroy(GtkWidget *widget, gpointer data) { frontend *fe = (frontend *)data; deactivate_timer(fe); midend_free(fe->me); gtk_main_quit(); } static gint key_event(GtkWidget *widget, GdkEventKey *event, gpointer data) { frontend *fe = (frontend *)data; int keyval; int shift = (event->state & GDK_SHIFT_MASK) ? MOD_SHFT : 0; int ctrl = (event->state & GDK_CONTROL_MASK) ? MOD_CTRL : 0; if (!fe->pixmap) return TRUE; switch (event->keyval) { case GDK_Up: keyval = shift | ctrl | CURSOR_UP; break; case GDK_KP_Up: case GDK_KP_8: keyval = MOD_NUM_KEYPAD | '8'; break; case GDK_Down: keyval = shift | ctrl | CURSOR_DOWN; break; case GDK_KP_Down: case GDK_KP_2: keyval = MOD_NUM_KEYPAD | '2'; break; case GDK_Left: keyval = shift | ctrl | CURSOR_LEFT; break; case GDK_KP_Left: case GDK_KP_4: keyval = MOD_NUM_KEYPAD | '4'; break; case GDK_Right: keyval = shift | ctrl | CURSOR_RIGHT; break; case GDK_KP_Right: case GDK_KP_6: keyval = MOD_NUM_KEYPAD | '6'; break; case GDK_KP_Home: case GDK_KP_7: keyval = MOD_NUM_KEYPAD | '7'; break; case GDK_KP_End: case GDK_KP_1: keyval = MOD_NUM_KEYPAD | '1'; break; case GDK_KP_Page_Up: case GDK_KP_9: keyval = MOD_NUM_KEYPAD | '9'; break; case GDK_KP_Page_Down: case GDK_KP_3: keyval = MOD_NUM_KEYPAD | '3'; break; case GDK_KP_Insert: case GDK_KP_0: keyval = MOD_NUM_KEYPAD | '0'; break; case GDK_KP_Begin: case GDK_KP_5: keyval = MOD_NUM_KEYPAD | '5'; break; case GDK_BackSpace: case GDK_Delete: case GDK_KP_Delete: keyval = '\177'; break; default: return FALSE; } #if 0 else if (event->string[0] && !event->string[1]) keyval = (unsigned char)event->string[0]; else keyval = -1; #endif if (keyval >= 0 && !midend_process_key(fe->me, 0, 0, keyval)) gtk_widget_destroy(fe->window); return TRUE; } static gint button_event(GtkWidget *widget, GdkEventButton *event, gpointer data) { frontend *fe = (frontend *)data; int button; if (!fe->pixmap) return TRUE; if (event->type != GDK_BUTTON_PRESS && event->type != GDK_BUTTON_RELEASE) return TRUE; if (event->button == 2 || (event->state & GDK_SHIFT_MASK)) button = MIDDLE_BUTTON; else if (event->button == 3 || (event->state & GDK_MOD1_MASK)) button = RIGHT_BUTTON; else if (event->button == 1) button = LEFT_BUTTON; else return FALSE; /* don't even know what button! */ if (event->type == GDK_BUTTON_RELEASE) button += LEFT_RELEASE - LEFT_BUTTON; if (!midend_process_key(fe->me, event->x - fe->ox, event->y - fe->oy, button)) gtk_widget_destroy(fe->window); return TRUE; } static gint motion_event(GtkWidget *widget, GdkEventMotion *event, gpointer data) { frontend *fe = (frontend *)data; int button; if (!fe->pixmap) return TRUE; if (event->state & (GDK_BUTTON2_MASK | GDK_SHIFT_MASK)) button = MIDDLE_DRAG; else if (event->state & GDK_BUTTON1_MASK) button = LEFT_DRAG; else if (event->state & GDK_BUTTON3_MASK) button = RIGHT_DRAG; else return FALSE; /* don't even know what button! */ if (!midend_process_key(fe->me, event->x - fe->ox, event->y - fe->oy, button)) gtk_widget_destroy(fe->window); return TRUE; } static gint expose_area(GtkWidget *widget, GdkEventExpose *event, gpointer data) { frontend *fe = (frontend *)data; if (fe->pixmap) { gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], fe->pixmap, event->area.x - fe->ox, event->area.y - fe->oy, event->area.x, event->area.y, event->area.width, event->area.height); } return TRUE; } static gint map_window(GtkWidget *widget, GdkEvent *event, gpointer data) { frontend *fe = (frontend *)data; /* * Apparently we need to do this because otherwise the status * bar will fail to update immediately. Annoying, but there we * go. */ gtk_widget_queue_draw(fe->window); return TRUE; } static gint configure_area(GtkWidget *widget, GdkEventConfigure *event, gpointer data) { frontend *fe = (frontend *)data; GdkGC *gc; int x, y; if (fe->pixmap) gdk_pixmap_unref(fe->pixmap); x = fe->w = event->width; y = fe->h = event->height; midend_size(fe->me, &x, &y, TRUE); fe->pw = x; fe->ph = y; fe->ox = (fe->w - fe->pw) / 2; fe->oy = (fe->h - fe->ph) / 2; fe->pixmap = gdk_pixmap_new(widget->window, fe->pw, fe->ph, -1); gc = gdk_gc_new(fe->area->window); gdk_gc_set_foreground(gc, &fe->colours[0]); gdk_draw_rectangle(fe->pixmap, gc, 1, 0, 0, fe->pw, fe->ph); gdk_draw_rectangle(widget->window, gc, 1, 0, 0, event->width, event->height); gdk_gc_unref(gc); midend_force_redraw(fe->me); return TRUE; } static gint timer_func(gpointer data) { frontend *fe = (frontend *)data; if (fe->timer_active) { struct timeval now; float elapsed; gettimeofday(&now, NULL); elapsed = ((now.tv_usec - fe->last_time.tv_usec) * 0.000001F + (now.tv_sec - fe->last_time.tv_sec)); midend_timer(fe->me, elapsed); /* may clear timer_active */ fe->last_time = now; } return fe->timer_active; } void deactivate_timer(frontend *fe) { if (!fe) return; /* can happen due to --generate */ if (fe->timer_active) gtk_timeout_remove(fe->timer_id); fe->timer_active = FALSE; } void activate_timer(frontend *fe) { if (!fe) return; /* can happen due to --generate */ if (!fe->timer_active) { fe->timer_id = gtk_timeout_add(20, timer_func, fe); gettimeofday(&fe->last_time, NULL); } fe->timer_active = TRUE; } static void window_destroy(GtkWidget *widget, gpointer data) { gtk_main_quit(); } enum { MB_OK, MB_YESNO }; int message_box(GtkWidget *parent, char *title, char *msg, int centre, int type) { GtkWidget *window; int response; window = gtk_message_dialog_new (GTK_WINDOW (parent), GTK_DIALOG_MODAL, type == MB_OK ? GTK_MESSAGE_INFO : GTK_MESSAGE_QUESTION, type == MB_OK ? GTK_BUTTONS_OK : GTK_BUTTONS_YES_NO, msg); gtk_window_set_title (GTK_WINDOW (window), title); response = gtk_dialog_run (GTK_DIALOG (window)); gtk_widget_destroy (window); return (type == MB_YESNO ? response == GTK_RESPONSE_YES : TRUE); } void error_box(GtkWidget *parent, char *msg) { GtkWidget *window; int response; window = gtk_message_dialog_new (GTK_WINDOW (parent), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, msg); gtk_window_set_title (GTK_WINDOW (window), _("Error")); gtk_dialog_run (GTK_DIALOG (window)); gtk_widget_destroy (window); } static void editbox_changed(GtkEditable *ed, gpointer data) { config_item *i = (config_item *)data; g_free(i->sval); i->sval = g_strdup (gtk_entry_get_text (GTK_ENTRY (ed))); } static void button_toggled (GtkToggleButton *tb, gpointer data) { config_item *i = (config_item *)data; i->ival = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(tb)); } static void value_changed_cb (GtkSpinButton *w, gpointer data) { config_item *i = (config_item *) data; i->ival = gtk_spin_button_get_value_as_int (w); } static void droplist_sel (GtkComboBox *combo, gpointer data) { config_item *i = (config_item *)data; i->ival = gtk_combo_box_get_active (combo); } static int get_config(frontend *fe, int which) { GtkWidget *w, *table, *cancel; char *title, *text, *err; config_item *i; int y; fe->cfg = midend_get_config(fe->me, which, &title); fe->cfg_which = which; fe->cfgbox = gtk_dialog_new_with_buttons (title, GTK_WINDOW (fe->window), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_dialog_set_has_separator (GTK_DIALOG (fe->cfgbox), FALSE); gtk_dialog_set_default_response (GTK_DIALOG (fe->cfgbox), GTK_RESPONSE_OK); gtk_window_set_resizable (GTK_WINDOW (fe->cfgbox), FALSE); sfree(title); table = gtk_table_new(1, 2, FALSE); y = 0; gtk_box_pack_start(GTK_BOX(GTK_DIALOG(fe->cfgbox)->vbox), table, FALSE, FALSE, 0); gtk_widget_show(table); for (i = fe->cfg; i->type != C_END; i++) { gtk_table_resize(GTK_TABLE(table), y+1, 2); switch (i->type) { case C_STRING: /* * Edit box with a label beside it. */ text = g_strdup_printf ("%s:", _(i->name)); w = gtk_label_new(text); g_free (text); gtk_misc_set_alignment(GTK_MISC(w), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_widget_show(w); w = gtk_entry_new(); gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE); gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_entry_set_text(GTK_ENTRY(w), i->sval); g_signal_connect(GTK_OBJECT(w), "changed", G_CALLBACK (editbox_changed), i); gtk_widget_show(w); break; case C_INTEGER: /* * Spin button with a label beside it. */ text = g_strdup_printf ("%s:", _(i->name)); w = gtk_label_new (text); g_free (text); gtk_misc_set_alignment (GTK_MISC(w), 1.0, 0.5); gtk_table_attach (GTK_TABLE(table), w, 0, 1, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_widget_show (w); w = gtk_spin_button_new_with_range (0.0, 255.0, 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (w), 0); gtk_entry_set_activates_default (GTK_ENTRY (w), TRUE); gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_spin_button_set_value (GTK_SPIN_BUTTON (w), (double) i->ival); g_signal_connect (G_OBJECT (w), "value-changed", G_CALLBACK (value_changed_cb), i); gtk_widget_show (w); break; case C_BOOLEAN: /* * Simple checkbox. */ text = g_strdup_printf ("%s: ", _(i->name)); w = gtk_label_new (text); g_free (text); gtk_misc_set_alignment (GTK_MISC (w), 1.0, 0.5); gtk_table_attach (GTK_TABLE (table), w, 0, 1, y, y + 1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_widget_show (w); w = gtk_check_button_new (); g_signal_connect (G_OBJECT (w), "toggled", G_CALLBACK (button_toggled), i); gtk_table_attach (GTK_TABLE(table), w, 1, 2, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(w), i->ival); gtk_widget_show (w); break; case C_CHOICES: /* * Drop-down list (GtkOptionMenu). */ text = g_strdup_printf ("%s:", _(i->name)); w = gtk_label_new(text); g_free (text); gtk_misc_set_alignment(GTK_MISC(w), 1.0, 0.5); gtk_table_attach(GTK_TABLE(table), w, 0, 1, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_widget_show(w); w = gtk_combo_box_new_text (); gtk_table_attach(GTK_TABLE(table), w, 1, 2, y, y+1, GTK_EXPAND | GTK_SHRINK | GTK_FILL, GTK_EXPAND | GTK_SHRINK | GTK_FILL, 3, 3); gtk_widget_show(w); { int c; char *p, *q, *name; c = *i->sval; p = i->sval + 1; while (*p) { q = p; while (*q && *q != c) q++; name = g_strndup (p, q-p); name[q-p] = '\0'; if (*q) q++; /* eat delimiter */ gtk_combo_box_append_text (GTK_COMBO_BOX (w), name); g_free (name); g_signal_connect(w, "changed", G_CALLBACK (droplist_sel), i); p = q; } gtk_combo_box_set_active (GTK_COMBO_BOX (w), i->ival); } break; } y++; } switch (gtk_dialog_run (GTK_DIALOG (fe->cfgbox))) { case GTK_RESPONSE_OK: err = midend_set_config(fe->me, fe->cfg_which, fe->cfg); if (err) { error_box(fe->cfgbox, _(err)); } else { fe->cfgret = TRUE; } break; case GTK_RESPONSE_CANCEL: default: fe->cfgret = FALSE; break; } gtk_widget_destroy (fe->cfgbox); free_cfg(fe->cfg); return fe->cfgret; } static void get_size(frontend *fe, int *px, int *py) { int x, y; /* * Currently I don't want to make the GTK port scale large * puzzles to fit on the screen. This is because X does permit * extremely large windows and many window managers provide a * means of navigating round them, and the users I consulted * before deciding said that they'd rather have enormous puzzle * windows spanning multiple screen pages than have them * shrunk. I could change my mind later or introduce * configurability; this would be the place to do so, by * replacing the initial values of x and y with the screen * dimensions. */ x = INT_MAX; y = INT_MAX; midend_size(fe->me, &x, &y, FALSE); *px = x; *py = y; } #if !GTK_CHECK_VERSION(2,0,0) #define gtk_window_resize(win, x, y) \ gdk_window_resize(GTK_WIDGET(win)->window, x, y) #endif static void menu_preset_event(GtkAction *action, frontend *fe) { game_params *params = (game_params *)g_object_get_data(G_OBJECT(action), "game-params"); midend_set_params(fe->me, params); midend_new_game(fe->me); get_size(fe, &fe->w, &fe->h); gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), fe->w, fe->h); { GtkRequisition req; gtk_widget_size_request(GTK_WIDGET(fe->window), &req); gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height); } } static void savefile_write(void *wctx, void *buf, int len) { FILE *fp = (FILE *)wctx; fwrite(buf, 1, len, fp); } static int savefile_read(void *wctx, void *buf, int len) { FILE *fp = (FILE *)wctx; int ret; ret = fread(buf, 1, len, fp); return (ret == len); } static void menu_save_event(GtkAction *action, frontend *fe) { GtkWidget *fc; char *name; fc = gtk_file_chooser_dialog_new (_("Save Game"), GTK_WINDOW (fe->window), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_SAVE, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); #ifdef HAVE_OVERWRITE_CONFIRMATION gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (fc), TRUE); #endif gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), TRUE); switch (gtk_dialog_run (GTK_DIALOG (fc))) { case GTK_RESPONSE_OK: name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc)); gtk_widget_destroy (fc); if (name) { FILE *fp; fp = fopen(name, "w"); g_free(name); if (!fp) { error_box(fe->window, _("Unable to open save file")); return; } midend_serialise(fe->me, savefile_write, fp); fclose(fp); } break; case GTK_RESPONSE_CANCEL: default: gtk_widget_destroy (fc); break; } } static void menu_load_event(GtkAction *action, frontend *fe) { GtkWidget *fc; char *name; fc = gtk_file_chooser_dialog_new (_("Open Game"), GTK_WINDOW (fe->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_OPEN, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL); gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (fc), TRUE); switch (gtk_dialog_run (GTK_DIALOG (fc))) { case GTK_RESPONSE_OK: name = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (fc)); gtk_widget_destroy (fc); if (name) { FILE *fp = fopen(name, "r"); char *err; g_free(name); if (!fp) { error_box(fe->window, _("Unable to open saved game file")); return; } err = midend_deserialise(fe->me, savefile_read, fp); fclose(fp); if (err) { error_box(fe->window, err); return; } get_size(fe, &fe->w, &fe->h); gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), fe->w, fe->h); { GtkRequisition req; gtk_widget_size_request(GTK_WIDGET(fe->window), &req); gtk_window_resize(GTK_WINDOW(fe->window), req.width, req.height); } } break; case GTK_RESPONSE_CANCEL: default: gtk_widget_destroy (fc); break; } } static void menu_solve_event(GtkAction *action, frontend *fe) { char *msg; msg = midend_solve(fe->me); if (msg) error_box(fe->window, _(msg)); } static void menu_restart_event(GtkAction *action, frontend *fe) { midend_restart_game(fe->me); } static void start_game (frontend *fe, int type) { if (!get_config (fe, type)) return; midend_new_game (fe->me); get_size (fe, &fe->w, &fe->h); gtk_drawing_area_size (GTK_DRAWING_AREA (fe->area), fe->w, fe->h); { GtkRequisition req; gtk_widget_size_request (GTK_WIDGET (fe->window), &req); gtk_window_resize (GTK_WINDOW (fe->window), req.width, req.height); } } static void menu_new_event (GtkAction *action, frontend *fe) { midend_process_key(fe->me, 0, 0, 'n'); } static void menu_specific_event (GtkAction *action, frontend *fe) { start_game (fe, CFG_DESC); } static void menu_random_event (GtkAction *action, frontend *fe) { start_game (fe, CFG_SEED); } static void menu_custom_event (GtkAction *action, frontend *fe) { start_game (fe, CFG_SETTINGS); } static void menu_undo_event (GtkAction *action, frontend *fe) { midend_process_key(fe->me, 0, 0, 'u'); } static void menu_redo_event (GtkAction *action, frontend *fe) { midend_process_key(fe->me, 0, 0, 'r'); } static void menu_quit_event (GtkAction *action, frontend *fe) { gtk_widget_destroy (fe->window); } static void menu_about_event(GtkAction *action, frontend *fe) { static GtkWidget *about = NULL; const char *authors[2] = {"Simon Tatham", NULL}; if (about != NULL) { gtk_window_present (GTK_WINDOW (about)); } else { about = g_object_new (GTK_TYPE_ABOUT_DIALOG, "name", thegame.name, /* "version", VERSION, */ "copyright", "Copyright \xc2\xa9 2004-2006 Simon Tatham", "authors", authors, NULL); gtk_window_set_transient_for (GTK_WINDOW (about), GTK_WINDOW (fe->window)); gtk_window_set_destroy_with_parent (GTK_WINDOW (about), TRUE); g_signal_connect (about, "response", G_CALLBACK (gtk_widget_destroy), NULL); g_object_add_weak_pointer (G_OBJECT (about), (gpointer) &about); gtk_window_present (GTK_WINDOW (about)); } } static void add_widget (GtkUIManager *merge, GtkWidget *widget, GtkBox *box) { GtkWidget *toplevel; gtk_box_pack_start (box, widget, FALSE, FALSE, 0); toplevel = gtk_widget_get_toplevel (GTK_WIDGET (box)); gtk_widget_show_all (toplevel); } static GtkActionEntry toplevel_actions[] = { { "Game", NULL, N_("Game") }, { "Settings", NULL, N_("Settings") }, { "Help", NULL, N_("Help") }, }; static GtkActionEntry game_actions[] = { { "New", GTK_STOCK_NEW, N_("New"), "N", N_("Start a new game"), G_CALLBACK (menu_new_event) }, { "Restart", NULL, N_("Restart"), NULL, N_("Restart game"), G_CALLBACK (menu_restart_event) }, #if 0 { "Specific", NULL, N_("Specific..."), NULL, N_("Start a specific game"), G_CALLBACK (menu_specific_event) }, #endif { "Random", NULL, N_("Random Seed..."), NULL, N_("Start a random game"), G_CALLBACK (menu_random_event) }, { "Load", GTK_STOCK_OPEN, N_("Open Game"), NULL, N_("Load an old game"), G_CALLBACK (menu_load_event) }, { "Save", GTK_STOCK_SAVE, N_("Save Game"), NULL, N_("Save current game"), G_CALLBACK (menu_save_event) }, { "Undo", GTK_STOCK_UNDO, N_("Undo"), "Z", N_("Undo previous move"), G_CALLBACK (menu_undo_event) }, { "Redo", GTK_STOCK_REDO, N_("Redo"), "Z", N_("Redo previous move"), G_CALLBACK (menu_redo_event) }, { "Solve", NULL, N_("Solve Game"), NULL, N_("Solve the game"), G_CALLBACK (menu_solve_event) }, { "Quit", GTK_STOCK_QUIT, N_("Quit"), "Q", N_("Quit game"), G_CALLBACK (menu_quit_event) } }; static GtkActionEntry help_actions[] = { { "About", GTK_STOCK_ABOUT, N_("About"), NULL, N_("About"), G_CALLBACK (menu_about_event) }, }; static void generate_settings_menu (GtkUIManager *merge, GtkActionGroup *actions, frontend *fe) { GString *xml; gboolean presets = FALSE; GSList *radio_group = NULL; int i; xml = g_string_new ("" ""); for (i = 0; i < midend_num_presets(fe->me); i++) { GtkRadioAction *action; char *name, *action_name; game_params *params; char *menuitem; action_name = g_strdup_printf ("Game%d", i); midend_fetch_preset(fe->me, i, &name, ¶ms); action = gtk_radio_action_new (action_name, name, NULL, NULL, i); gtk_radio_action_set_group (action, radio_group); radio_group = gtk_radio_action_get_group (action); g_object_set_data (G_OBJECT (action), "game-params", params); g_signal_connect(G_OBJECT (action), "activate", G_CALLBACK (menu_preset_event), fe); gtk_action_group_add_action (actions, GTK_ACTION (action)); g_object_unref (action); menuitem = g_strdup_printf ("", action_name, action_name); g_free (action_name); g_string_append (xml, menuitem); g_free (menuitem); presets = TRUE; } if (thegame.can_configure) { GtkAction *action; action = gtk_action_new ("Custom", _("Custom Game..."), _("Create a custom game"), NULL); g_signal_connect (action, "activate", G_CALLBACK (menu_custom_event), fe); gtk_action_group_add_action (actions, action); g_object_unref (action); if (presets) { /* If we've added the presets then we want a separator here */ g_string_append (xml, ""); } g_string_append (xml, ""); } g_string_append (xml, ""); gtk_ui_manager_add_ui_from_string (merge, xml->str, -1, NULL); g_string_free (xml, TRUE); } static void setup_colours (frontend *fe) { int i, ncolours; float *colours; gboolean *success; fe->colmap = gdk_colormap_get_system(); colours = midend_colours(fe->me, &ncolours); fe->ncolours = ncolours; fe->colours = snewn(ncolours, GdkColor); for (i = 0; i < ncolours; i++) { fe->colours[i].red = colours[i*3] * 0xFFFF; fe->colours[i].green = colours[i*3+1] * 0xFFFF; fe->colours[i].blue = colours[i*3+2] * 0xFFFF; } g_free (colours); /* Make background white... */ fe->colours[0].red = 0xFFFF; fe->colours[0].green = 0xFFFF; fe->colours[0].blue = 0xFFFF; success = g_new (gboolean, ncolours); gdk_colormap_alloc_colors(fe->colmap, fe->colours, ncolours, FALSE, FALSE, success); for (i = 0; i < ncolours; i++) { if (!success[i]) g_error("couldn't allocate colour %d (#%02x%02x%02x)\n", i, fe->colours[i].red >> 8, fe->colours[i].green >> 8, fe->colours[i].blue >> 8); } g_free (success); } static void setup_pixbufs (frontend *fe) { char **names; int i, size; names = midend_pixbufs (fe->me, &fe->npixbufs, &size); if (names == NULL) { return; } fe->pixbufs = g_new (GdkPixbuf *, fe->npixbufs); for (i = 0; i < fe->npixbufs; i++) { GError *error = NULL; char *filename; filename = g_strdup_printf (DATADIR "/pixmaps/oh-puzzles/%s", names[i]); fe->pixbufs[i] = rsvg_pixbuf_from_file_at_size (filename, size, size, &error); if (error) { g_warning ("Error loading %s: %s", filename, error->message); g_error_free (error); } g_free (filename); } } static frontend * new_window(char *arg, char **error) { frontend *fe; GtkBox *vbox; GtkUIManager *merge; GtkActionGroup *actions; int x, y, n; fe = g_new (frontend, 1); fe->timer_active = FALSE; fe->timer_id = -1; fe->me = midend_new(fe, &thegame, >k_drawing, fe); if (arg) { char *err; /* * Try treating the argument as a game ID. */ err = midend_game_id(fe->me, arg); if (!err) { /* * It's a valid game ID. */ midend_new_game(fe->me); } else { FILE *fp = fopen(arg, "r"); if (!fp) { *error = g_strdup_printf ("Supplied argument is neither a game ID (%.400s)" " nor a save file (%.400s)", err, strerror(errno)); midend_free (fe->me); g_free (fe); return NULL; } else { err = midend_deserialise(fe->me, savefile_read, fp); if (err) { *error = g_strdup (err); fclose (fp); return NULL; } fclose(fp); } } } else { midend_new_game(fe->me); } fe->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(fe->window), thegame.name); gtk_window_set_resizable (GTK_WINDOW (fe->window), FALSE); vbox = GTK_BOX(gtk_vbox_new(FALSE, 0)); gtk_container_add(GTK_CONTAINER(fe->window), GTK_WIDGET(vbox)); gtk_widget_show(GTK_WIDGET(vbox)); fe->accelgroup = gtk_accel_group_new(); gtk_window_add_accel_group(GTK_WINDOW(fe->window), fe->accelgroup); merge = gtk_ui_manager_new (); g_signal_connect (G_OBJECT (merge), "add_widget", G_CALLBACK (add_widget), vbox); actions = gtk_action_group_new ("PuzzleActions"); gtk_action_group_add_actions (actions, toplevel_actions, G_N_ELEMENTS (toplevel_actions), fe); gtk_action_group_add_actions (actions, game_actions, G_N_ELEMENTS (game_actions), fe); gtk_action_group_add_actions (actions, help_actions, G_N_ELEMENTS (help_actions), fe); gtk_ui_manager_insert_action_group (merge, actions, 0); gtk_ui_manager_add_ui_from_file (merge, DATADIR "/oh-puzzles/ui/menu.xml", NULL); if (thegame.can_solve) { char *str = "" "" "" "" ""; gtk_ui_manager_add_ui_from_string (merge, str, -1, NULL); } if ((n = midend_num_presets(fe->me)) > 0 || thegame.can_configure) { generate_settings_menu (merge, actions, fe); } setup_colours (fe); setup_pixbufs (fe); if (midend_wants_statusbar(fe->me)) { fe->statusbar = gtk_statusbar_new (); gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (fe->statusbar), FALSE); gtk_box_pack_end (vbox, fe->statusbar, FALSE, FALSE, 0); gtk_widget_show (fe->statusbar); fe->statusctx = gtk_statusbar_get_context_id (GTK_STATUSBAR (fe->statusbar), "game"); } else fe->statusbar = NULL; fe->area = gtk_drawing_area_new(); get_size(fe, &x, &y); gtk_drawing_area_size(GTK_DRAWING_AREA(fe->area), x, y); fe->w = x; fe->h = y; gtk_box_pack_end(vbox, fe->area, TRUE, TRUE, 0); fe->pixmap = NULL; fe->fonts = NULL; fe->nfonts = fe->fontsize = 0; g_signal_connect(G_OBJECT(fe->window), "destroy", G_CALLBACK(destroy), fe); g_signal_connect(G_OBJECT(fe->window), "key_press_event", G_CALLBACK(key_event), fe); g_signal_connect(G_OBJECT(fe->area), "button_press_event", G_CALLBACK(button_event), fe); g_signal_connect(G_OBJECT(fe->area), "button_release_event", G_CALLBACK(button_event), fe); g_signal_connect(G_OBJECT(fe->area), "motion_notify_event", G_CALLBACK(motion_event), fe); g_signal_connect(G_OBJECT(fe->area), "expose_event", G_CALLBACK(expose_area), fe); g_signal_connect(G_OBJECT(fe->window), "map_event", G_CALLBACK(map_window), fe); g_signal_connect(G_OBJECT(fe->area), "configure_event", G_CALLBACK(configure_area), fe); gtk_widget_add_events(GTK_WIDGET(fe->area), GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK); /* The window is shown once the menubar has been added */ return fe; } int main(int argc, char **argv) { char *pname = argv[0]; char *error; bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); gtk_init(&argc, &argv); if (!new_window(argc > 1 ? argv[1] : NULL, &error)) { fprintf(stderr, "%s: %s\n", pname, error); return 1; } gtk_main(); return 0; }