X-Git-Url: https://asedeno.scripts.mit.edu/gitweb/?a=blobdiff_plain;f=unix%2Fgtkdlg.c;h=966164ac025e4ecf3a04bcc44802b5c907e70cfb;hb=12e019bafc75cb441e965c63e15dfceeaf71ca1e;hp=b7947b52acaf65ff7fe4e50bf794b2f1e0c0a949;hpb=cd94e3bc3c65e6205867549708c82bec40f55e79;p=PuTTY.git diff --git a/unix/gtkdlg.c b/unix/gtkdlg.c index b7947b52..966164ac 100644 --- a/unix/gtkdlg.c +++ b/unix/gtkdlg.c @@ -2,15 +2,6 @@ * gtkdlg.c - GTK implementation of the PuTTY configuration box. */ -/* - * TODO when porting to GTK 2.0: - * - * - GtkTree is apparently deprecated and we should switch to - * GtkTreeView instead. - * - GtkLabel has a built-in mnemonic scheme, so we should at - * least consider switching to that from the current adhockery. - */ - #include #include #include @@ -56,6 +47,7 @@ struct uctrl { GtkWidget *text; /* for text */ GtkWidget *label; /* for dlg_label_change */ GtkAdjustment *adj; /* for the scrollbar in a list box */ + guint entrysig; guint textsig; }; @@ -67,9 +59,12 @@ struct dlgparam { * due to automatic processing and should not flag a user event. */ int flags; struct Shortcuts *shortcuts; - GtkWidget *window, *cancelbutton, *currtreeitem, **treeitems; + GtkWidget *window, *cancelbutton; union control *currfocus, *lastfocus; +#if !GTK_CHECK_VERSION(2,0,0) + GtkWidget *currtreeitem, **treeitems; int ntreeitems; +#endif int retval; }; #define FLAG_UPDATING_COMBO_LIST 1 @@ -83,6 +78,14 @@ enum { /* values for Shortcut.action */ SHORTCUT_UCTRL_DOWN, /* uctrl is a draglist, move Down */ }; +#if GTK_CHECK_VERSION(2,0,0) +enum { + TREESTORE_PATH, + TREESTORE_PARAMS, + TREESTORE_NUM +}; +#endif + /* * Forward references. */ @@ -91,12 +94,12 @@ static gboolean widget_focus(GtkWidget *widget, GdkEventFocus *event, static void shortcut_add(struct Shortcuts *scs, GtkWidget *labelw, int chr, int action, void *ptr); static void shortcut_highlight(GtkWidget *label, int chr); -static int listitem_single_key(GtkWidget *item, GdkEventKey *event, - gpointer data); -static int listitem_multi_key(GtkWidget *item, GdkEventKey *event, - gpointer data); -static int listitem_button(GtkWidget *item, GdkEventButton *event, - gpointer data); +static gboolean listitem_single_key(GtkWidget *item, GdkEventKey *event, + gpointer data); +static gboolean listitem_multi_key(GtkWidget *item, GdkEventKey *event, + gpointer data); +static gboolean listitem_button(GtkWidget *item, GdkEventButton *event, + gpointer data); static void menuitem_activate(GtkMenuItem *item, gpointer data); static void coloursel_ok(GtkButton *button, gpointer data); static void coloursel_cancel(GtkButton *button, gpointer data); @@ -151,8 +154,11 @@ static void dlg_init(struct dlgparam *dp) dp->byctrl = newtree234(uctrl_cmp_byctrl); dp->bywidget = newtree234(uctrl_cmp_bywidget); dp->coloursel_result.ok = FALSE; + dp->window = dp->cancelbutton = NULL; +#if !GTK_CHECK_VERSION(2,0,0) dp->treeitems = NULL; - dp->window = dp->cancelbutton = dp->currtreeitem = NULL; + dp->currtreeitem = NULL; +#endif dp->flags = 0; dp->currfocus = NULL; } @@ -172,7 +178,9 @@ static void dlg_cleanup(struct dlgparam *dp) } freetree234(dp->bywidget); dp->bywidget = NULL; +#if !GTK_CHECK_VERSION(2,0,0) sfree(dp->treeitems); +#endif } static void dlg_add_uctrl(struct dlgparam *dp, struct uctrl *uc) @@ -284,7 +292,27 @@ void dlg_editbox_set(union control *ctrl, void *dlg, char const *text) struct uctrl *uc = dlg_find_byctrl(dp, ctrl); assert(uc->ctrl->generic.type == CTRL_EDITBOX); assert(uc->entry != NULL); + /* + * GTK 2 implements gtk_entry_set_text by means of two separate + * operations: first delete the previous text leaving the empty + * string, then insert the new text. This causes two calls to + * the "changed" signal. + * + * The first call to "changed", if allowed to proceed normally, + * will cause an EVENT_VALCHANGE event on the edit box, causing + * a call to dlg_editbox_get() which will read the empty string + * out of the GtkEntry - and promptly write it straight into + * the Config structure, which is precisely where our `text' + * pointer is probably pointing, so the second editing + * operation will insert that instead of the string we + * originally asked for. + * + * Hence, we must block our "changed" signal handler for the + * duration of this call to gtk_entry_set_text. + */ + g_signal_handler_block(uc->entry, uc->entrysig); gtk_entry_set_text(GTK_ENTRY(uc->entry), text); + g_signal_handler_unblock(uc->entry, uc->entrysig); } void dlg_editbox_get(union control *ctrl, void *dlg, char *buffer, int length) @@ -735,7 +763,11 @@ void dlg_set_focus(union control *ctrl, void *dlg) gtk_widget_grab_focus(uc->optmenu); } else { assert(uc->list != NULL); +#if GTK_CHECK_VERSION(2,0,0) + gtk_widget_grab_focus(uc->list); +#else gtk_container_focus(GTK_CONTAINER(uc->list), GTK_DIR_TAB_FORWARD); +#endif } break; } @@ -863,7 +895,11 @@ void dlg_coloursel_start(union control *ctrl, void *dlg, int r, int g, int b) dp->coloursel_result.ok = FALSE; gtk_window_set_modal(GTK_WINDOW(coloursel), TRUE); +#if GTK_CHECK_VERSION(2,0,0) + gtk_color_selection_set_has_opacity_control(GTK_COLOR_SELECTION(ccs->colorsel), FALSE); +#else gtk_color_selection_set_opacity(GTK_COLOR_SELECTION(ccs->colorsel), FALSE); +#endif cvals[0] = r / 255.0; cvals[1] = g / 255.0; cvals[2] = b / 255.0; @@ -939,7 +975,8 @@ static void button_toggled(GtkToggleButton *tb, gpointer data) uc->ctrl->generic.handler(uc->ctrl, dp, dp->data, EVENT_VALCHANGE); } -static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data) +static gboolean editbox_key(GtkWidget *widget, GdkEventKey *event, + gpointer data) { /* * GtkEntry has a nasty habit of eating the Return key, which @@ -951,7 +988,7 @@ static int editbox_key(GtkWidget *widget, GdkEventKey *event, gpointer data) * in the dialog just like it will everywhere else. */ if (event->keyval == GDK_Return && widget->parent != NULL) { - gint return_val; + gboolean return_val; gtk_signal_emit_stop_by_name(GTK_OBJECT(widget), "key_press_event"); gtk_signal_emit_by_name(GTK_OBJECT(widget->parent), "key_press_event", event, &return_val); @@ -969,16 +1006,17 @@ static void editbox_changed(GtkEditable *ed, gpointer data) } } -static void editbox_lostfocus(GtkWidget *ed, GdkEventFocus *event, - gpointer data) +static gboolean editbox_lostfocus(GtkWidget *ed, GdkEventFocus *event, + gpointer data) { struct dlgparam *dp = (struct dlgparam *)data; struct uctrl *uc = dlg_find_bywidget(dp, GTK_WIDGET(ed)); uc->ctrl->generic.handler(uc->ctrl, dp, dp->data, EVENT_REFRESH); + return FALSE; } -static int listitem_key(GtkWidget *item, GdkEventKey *event, gpointer data, - int multiple) +static gboolean listitem_key(GtkWidget *item, GdkEventKey *event, + gpointer data, int multiple) { GtkAdjustment *adj = GTK_ADJUSTMENT(data); @@ -1071,20 +1109,20 @@ static int listitem_key(GtkWidget *item, GdkEventKey *event, gpointer data, return FALSE; } -static int listitem_single_key(GtkWidget *item, GdkEventKey *event, - gpointer data) +static gboolean listitem_single_key(GtkWidget *item, GdkEventKey *event, + gpointer data) { return listitem_key(item, event, data, FALSE); } -static int listitem_multi_key(GtkWidget *item, GdkEventKey *event, - gpointer data) +static gboolean listitem_multi_key(GtkWidget *item, GdkEventKey *event, + gpointer data) { return listitem_key(item, event, data, TRUE); } -static int listitem_button(GtkWidget *item, GdkEventButton *event, - gpointer data) +static gboolean listitem_button(GtkWidget *item, GdkEventButton *event, + gpointer data) { struct dlgparam *dp = (struct dlgparam *)data; if (event->type == GDK_2BUTTON_PRESS || @@ -1157,7 +1195,8 @@ static void filesel_ok(GtkButton *button, gpointer data) /* struct dlgparam *dp = (struct dlgparam *)data; */ gpointer filesel = gtk_object_get_data(GTK_OBJECT(button), "user-data"); struct uctrl *uc = gtk_object_get_data(GTK_OBJECT(filesel), "user-data"); - char *name = gtk_file_selection_get_filename(GTK_FILE_SELECTION(filesel)); + const char *name = gtk_file_selection_get_filename + (GTK_FILE_SELECTION(filesel)); gtk_entry_set_text(GTK_ENTRY(uc->entry), name); } @@ -1166,7 +1205,7 @@ static void fontsel_ok(GtkButton *button, gpointer data) /* struct dlgparam *dp = (struct dlgparam *)data; */ gpointer fontsel = gtk_object_get_data(GTK_OBJECT(button), "user-data"); struct uctrl *uc = gtk_object_get_data(GTK_OBJECT(fontsel), "user-data"); - char *name = gtk_font_selection_dialog_get_font_name + const char *name = gtk_font_selection_dialog_get_font_name (GTK_FONT_SELECTION_DIALOG(fontsel)); gtk_entry_set_text(GTK_ENTRY(uc->entry), name); } @@ -1222,15 +1261,20 @@ static void filefont_clicked(GtkButton *button, gpointer data) } if (uc->ctrl->generic.type == CTRL_FONTSELECT) { +#if !GTK_CHECK_VERSION(2,0,0) gchar *spacings[] = { "c", "m", NULL }; - gchar *fontname = gtk_entry_get_text(GTK_ENTRY(uc->entry)); +#endif + const gchar *fontname = gtk_entry_get_text(GTK_ENTRY(uc->entry)); + /* TODO: In GTK 2, this only seems to offer client-side fonts. */ GtkWidget *fontsel = gtk_font_selection_dialog_new("Select a font"); gtk_window_set_modal(GTK_WINDOW(fontsel), TRUE); +#if !GTK_CHECK_VERSION(2,0,0) gtk_font_selection_dialog_set_filter (GTK_FONT_SELECTION_DIALOG(fontsel), GTK_FONT_FILTER_BASE, GTK_FONT_ALL, NULL, NULL, NULL, NULL, spacings, NULL); +#endif if (!gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG(fontsel), fontname)) { /* @@ -1245,6 +1289,7 @@ static void filefont_clicked(GtkButton *button, gpointer data) Display *disp = GDK_FONT_XDISPLAY(font); Atom fontprop = XInternAtom(disp, "FONT", False); unsigned long ret; + gdk_font_ref(font); if (XGetFontProperty(xfs, fontprop, &ret)) { char *name = XGetAtomName(disp, (Atom)ret); if (name) @@ -1469,8 +1514,9 @@ GtkWidget *layout_ctrls(struct dlgparam *dp, struct Shortcuts *scs, gtk_entry_set_visibility(GTK_ENTRY(w), FALSE); uc->entry = w; } - gtk_signal_connect(GTK_OBJECT(uc->entry), "changed", - GTK_SIGNAL_FUNC(editbox_changed), dp); + uc->entrysig = + gtk_signal_connect(GTK_OBJECT(uc->entry), "changed", + GTK_SIGNAL_FUNC(editbox_changed), dp); gtk_signal_connect(GTK_OBJECT(uc->entry), "key_press_event", GTK_SIGNAL_FUNC(editbox_key), dp); gtk_signal_connect(GTK_OBJECT(uc->entry), "focus_in_event", @@ -1561,8 +1607,9 @@ GtkWidget *layout_ctrls(struct dlgparam *dp, struct Shortcuts *scs, gtk_signal_connect(GTK_OBJECT(uc->entry), "key_press_event", GTK_SIGNAL_FUNC(editbox_key), dp); - gtk_signal_connect(GTK_OBJECT(uc->entry), "changed", - GTK_SIGNAL_FUNC(editbox_changed), dp); + uc->entrysig = + gtk_signal_connect(GTK_OBJECT(uc->entry), "changed", + GTK_SIGNAL_FUNC(editbox_changed), dp); gtk_signal_connect(GTK_OBJECT(uc->entry), "focus_in_event", GTK_SIGNAL_FUNC(widget_focus), dp); gtk_signal_connect(GTK_OBJECT(uc->button), "focus_in_event", @@ -1620,7 +1667,12 @@ GtkWidget *layout_ctrls(struct dlgparam *dp, struct Shortcuts *scs, * upgrades, I'd be grateful. */ { - int edge = GTK_WIDGET(uc->list)->style->klass->ythickness; + int edge; +#if GTK_CHECK_VERSION(2,0,0) + edge = GTK_WIDGET(uc->list)->style->ythickness; +#else + edge = GTK_WIDGET(uc->list)->style->klass->ythickness; +#endif gtk_widget_set_usize(w, 10, 2*edge + (ctrl->listbox.height * listitemheight)); @@ -1741,10 +1793,37 @@ GtkWidget *layout_ctrls(struct dlgparam *dp, struct Shortcuts *scs, struct selparam { struct dlgparam *dp; GtkNotebook *panels; - GtkWidget *panel, *treeitem; + GtkWidget *panel; +#if !GTK_CHECK_VERSION(2,0,0) + GtkWidget *treeitem; +#endif struct Shortcuts shortcuts; }; +#if GTK_CHECK_VERSION(2,0,0) +static void treeselection_changed(GtkTreeSelection *treeselection, + gpointer data) +{ + struct selparam *sps = (struct selparam *)data, *sp; + GtkTreeModel *treemodel; + GtkTreeIter treeiter; + gint spindex; + gint page_num; + + if (!gtk_tree_selection_get_selected(treeselection, &treemodel, &treeiter)) + return; + + gtk_tree_model_get(treemodel, &treeiter, TREESTORE_PARAMS, &spindex, -1); + sp = &sps[spindex]; + + page_num = gtk_notebook_page_num(sp->panels, sp->panel); + gtk_notebook_set_page(sp->panels, page_num); + + dlg_refresh(NULL, sp->dp); + + sp->dp->shortcuts = &sp->shortcuts; +} +#else static void treeitem_sel(GtkItem *item, gpointer data) { struct selparam *sp = (struct selparam *)data; @@ -1758,12 +1837,14 @@ static void treeitem_sel(GtkItem *item, gpointer data) sp->dp->shortcuts = &sp->shortcuts; sp->dp->currtreeitem = sp->treeitem; } +#endif static void window_destroy(GtkWidget *widget, gpointer data) { gtk_main_quit(); } +#if !GTK_CHECK_VERSION(2,0,0) static int tree_grab_focus(struct dlgparam *dp) { int i, f; @@ -1799,6 +1880,7 @@ gint tree_focus(GtkContainer *container, GtkDirectionType direction, */ return tree_grab_focus(dp); } +#endif int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) { @@ -1817,7 +1899,11 @@ int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) switch (sc->action) { case SHORTCUT_TREE: +#if GTK_CHECK_VERSION(2,0,0) + gtk_widget_grab_focus(sc->widget); +#else tree_grab_focus(dp); +#endif break; case SHORTCUT_FOCUS: gtk_widget_grab_focus(sc->widget); @@ -1893,8 +1979,12 @@ int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) } else { assert(sc->uc->list != NULL); +#if GTK_CHECK_VERSION(2,0,0) + gtk_widget_grab_focus(sc->uc->list); +#else gtk_container_focus(GTK_CONTAINER(sc->uc->list), GTK_DIR_TAB_FORWARD); +#endif } break; } @@ -1905,6 +1995,7 @@ int win_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) return FALSE; } +#if !GTK_CHECK_VERSION(2,0,0) int tree_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) { struct dlgparam *dp = (struct dlgparam *)data; @@ -1973,6 +2064,7 @@ int tree_key_press(GtkWidget *widget, GdkEventKey *event, gpointer data) return FALSE; } +#endif static void shortcut_highlight(GtkWidget *labelw, int chr) { @@ -2024,10 +2116,76 @@ int get_listitemheight(void) GtkWidget *listitem = gtk_list_item_new_with_label("foo"); GtkRequisition req; gtk_widget_size_request(listitem, &req); - gtk_widget_unref(listitem); + gtk_object_sink(GTK_OBJECT(listitem)); return req.height; } +void set_dialog_action_area(GtkDialog *dlg, GtkWidget *w) +{ +#if !GTK_CHECK_VERSION(2,0,0) + + /* + * In GTK 1, laying out the buttons at the bottom of the + * configuration box is nice and easy, because a GtkDialog's + * action_area is a GtkHBox which stretches to cover the full + * width of the dialog. So we just put our Columns widget + * straight into that hbox, and it ends up just where we want + * it. + */ + gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), + w, TRUE, TRUE, 0); + +#else + /* + * In GTK 2, the action area is now a GtkHButtonBox and its + * layout behaviour seems to be different: it doesn't stretch + * to cover the full width of the window, but instead finds its + * own preferred width and right-aligns that within the window. + * This isn't what we want, because we have both left-aligned + * and right-aligned buttons coming out of the above call to + * layout_ctrls(), and right-aligning the whole thing will + * result in the former being centred and looking weird. + * + * So instead we abandon the dialog's action area completely: + * we gtk_widget_hide() it in the below code, and we also call + * gtk_dialog_set_has_separator() to remove the separator above + * it. We then insert our own action area into the end of the + * dialog's main vbox, and add our own separator above that. + * + * (Ideally, if we were a native GTK app, we would use the + * GtkHButtonBox's _own_ innate ability to support one set of + * buttons being right-aligned and one left-aligned. But to do + * that here, we would have to either (a) pick apart our cross- + * platform layout structures and treat them specially for this + * particular set of controls, which would be painful, or else + * (b) develop a special and simpler cross-platform + * representation for these particular controls, and introduce + * special-case code into all the _other_ platforms to handle + * it. Neither appeals. Therefore, I regretfully discard the + * GTKHButtonBox and go it alone.) + */ + + GtkWidget *align; + align = gtk_alignment_new(0, 0, 1, 1); + gtk_container_add(GTK_CONTAINER(align), w); + /* + * The purpose of this GtkAlignment is to provide padding + * around the buttons. The padding we use is twice the padding + * used in our GtkColumns, because we nest two GtkColumns most + * of the time (one separating the tree view from the main + * controls, and another for the main controls themselves). + */ + gtk_alignment_set_padding(GTK_ALIGNMENT(align), 8, 8, 8, 8); + gtk_widget_show(align); + gtk_box_pack_end(GTK_BOX(dlg->vbox), align, FALSE, TRUE, 0); + w = gtk_hseparator_new(); + gtk_box_pack_end(GTK_BOX(dlg->vbox), w, FALSE, TRUE, 0); + gtk_widget_show(w); + gtk_widget_hide(dlg->action_area); + gtk_dialog_set_has_separator(dlg, FALSE); +#endif +} + int do_config_box(const char *title, Config *cfg, int midsession, int protcfginfo) { @@ -2036,8 +2194,16 @@ int do_config_box(const char *title, Config *cfg, int midsession, int index, level, listitemheight; struct controlbox *ctrlbox; char *path; +#if GTK_CHECK_VERSION(2,0,0) + GtkTreeStore *treestore; + GtkCellRenderer *treerenderer; + GtkTreeViewColumn *treecolumn; + GtkTreeSelection *treeselection; + GtkTreeIter treeiterlevels[8]; +#else GtkTreeItem *treeitemlevels[8]; GtkTree *treelevels[8]; +#endif struct dlgparam dp; struct Shortcuts scs; @@ -2075,20 +2241,28 @@ int do_config_box(const char *title, Config *cfg, int midsession, columns_force_left_align(COLUMNS(cols), label); gtk_widget_show(label); treescroll = gtk_scrolled_window_new(NULL, NULL); +#if GTK_CHECK_VERSION(2,0,0) + treestore = gtk_tree_store_new + (TREESTORE_NUM, G_TYPE_STRING, G_TYPE_INT); + tree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(treestore)); + gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(tree), FALSE); + treerenderer = gtk_cell_renderer_text_new(); + treecolumn = gtk_tree_view_column_new_with_attributes + ("Label", treerenderer, "text", 0, NULL); + gtk_tree_view_append_column(GTK_TREE_VIEW(tree), treecolumn); + treeselection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)); + gtk_tree_selection_set_mode(treeselection, GTK_SELECTION_BROWSE); + gtk_container_add(GTK_CONTAINER(treescroll), tree); +#else tree = gtk_tree_new(); - gtk_signal_connect(GTK_OBJECT(tree), "focus_in_event", - GTK_SIGNAL_FUNC(widget_focus), &dp); - shortcut_add(&scs, label, 'g', SHORTCUT_TREE, tree); gtk_tree_set_view_mode(GTK_TREE(tree), GTK_TREE_VIEW_ITEM); gtk_tree_set_selection_mode(GTK_TREE(tree), GTK_SELECTION_BROWSE); - gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(treescroll), - tree); - gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(treescroll), - GTK_POLICY_NEVER, - GTK_POLICY_AUTOMATIC); gtk_signal_connect(GTK_OBJECT(tree), "focus", GTK_SIGNAL_FUNC(tree_focus), &dp); - gtk_widget_show(tree); +#endif + gtk_signal_connect(GTK_OBJECT(tree), "focus_in_event", + GTK_SIGNAL_FUNC(widget_focus), &dp); + shortcut_add(&scs, label, 'g', SHORTCUT_TREE, tree); gtk_widget_show(treescroll); gtk_box_pack_start(GTK_BOX(vbox), treescroll, TRUE, TRUE, 0); panels = gtk_notebook_new(); @@ -2106,13 +2280,17 @@ int do_config_box(const char *title, Config *cfg, int midsession, if (!*s->pathname) { w = layout_ctrls(&dp, &scs, s, listitemheight, GTK_WINDOW(window)); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), - w, TRUE, TRUE, 0); + + set_dialog_action_area(GTK_DIALOG(window), w); } else { int j = path ? ctrl_path_compare(s->pathname, path) : 0; if (j != INT_MAX) { /* add to treeview, start new panel */ char *c; +#if GTK_CHECK_VERSION(2,0,0) + GtkTreeIter treeiter; +#else GtkWidget *treeitem; +#endif int first; /* @@ -2133,31 +2311,6 @@ int do_config_box(const char *title, Config *cfg, int midsession, else c++; - treeitem = gtk_tree_item_new_with_label(c); - assert(j-1 < level); - if (j > 0) { - if (!treelevels[j-1]) { - treelevels[j-1] = GTK_TREE(gtk_tree_new()); - gtk_tree_item_set_subtree - (treeitemlevels[j-1], - GTK_WIDGET(treelevels[j-1])); - gtk_tree_item_expand(treeitemlevels[j-1]); - } - gtk_tree_append(treelevels[j-1], treeitem); - } else { - gtk_tree_append(GTK_TREE(tree), treeitem); - } - treeitemlevels[j] = GTK_TREE_ITEM(treeitem); - treelevels[j] = NULL; - level = j+1; - - gtk_signal_connect(GTK_OBJECT(treeitem), "key_press_event", - GTK_SIGNAL_FUNC(tree_key_press), &dp); - gtk_signal_connect(GTK_OBJECT(treeitem), "focus_in_event", - GTK_SIGNAL_FUNC(widget_focus), &dp); - - gtk_widget_show(treeitem); - path = s->pathname; first = (panelvbox == NULL); @@ -2172,7 +2325,6 @@ int do_config_box(const char *title, Config *cfg, int midsession, page_num = gtk_notebook_page_num(GTK_NOTEBOOK(panels), panelvbox); gtk_notebook_set_page(GTK_NOTEBOOK(panels), page_num); - gtk_tree_select_child(GTK_TREE(tree), treeitem); } if (nselparams >= selparamsize) { @@ -2184,9 +2336,70 @@ int do_config_box(const char *title, Config *cfg, int midsession, selparams[nselparams].panels = GTK_NOTEBOOK(panels); selparams[nselparams].panel = panelvbox; selparams[nselparams].shortcuts = scs; /* structure copy */ + + assert(j-1 < level); + +#if GTK_CHECK_VERSION(2,0,0) + if (j > 0) + /* treeiterlevels[j-1] will always be valid because we + * don't allow implicit path components; see above. + */ + gtk_tree_store_append(treestore, &treeiter, + &treeiterlevels[j-1]); + else + gtk_tree_store_append(treestore, &treeiter, NULL); + gtk_tree_store_set(treestore, &treeiter, + TREESTORE_PATH, c, + TREESTORE_PARAMS, nselparams, + -1); + treeiterlevels[j] = treeiter; + + if (j > 0) { + GtkTreePath *path; + + path = gtk_tree_model_get_path(GTK_TREE_MODEL(treestore), + &treeiterlevels[j-1]); + if (j < 2) + gtk_tree_view_expand_row(GTK_TREE_VIEW(tree), path, + FALSE); + else + gtk_tree_view_collapse_row(GTK_TREE_VIEW(tree), path); + gtk_tree_path_free(path); + } +#else + treeitem = gtk_tree_item_new_with_label(c); + if (j > 0) { + if (!treelevels[j-1]) { + treelevels[j-1] = GTK_TREE(gtk_tree_new()); + gtk_tree_item_set_subtree + (treeitemlevels[j-1], + GTK_WIDGET(treelevels[j-1])); + if (j < 2) + gtk_tree_item_expand(treeitemlevels[j-1]); + else + gtk_tree_item_collapse(treeitemlevels[j-1]); + } + gtk_tree_append(treelevels[j-1], treeitem); + } else { + gtk_tree_append(GTK_TREE(tree), treeitem); + } + treeitemlevels[j] = GTK_TREE_ITEM(treeitem); + treelevels[j] = NULL; + + gtk_signal_connect(GTK_OBJECT(treeitem), "key_press_event", + GTK_SIGNAL_FUNC(tree_key_press), &dp); + gtk_signal_connect(GTK_OBJECT(treeitem), "focus_in_event", + GTK_SIGNAL_FUNC(widget_focus), &dp); + + gtk_widget_show(treeitem); + + if (first) + gtk_tree_select_child(GTK_TREE(tree), treeitem); selparams[nselparams].treeitem = treeitem; - nselparams++; +#endif + level = j+1; + nselparams++; } w = layout_ctrls(&dp, @@ -2197,6 +2410,10 @@ int do_config_box(const char *title, Config *cfg, int midsession, } } +#if GTK_CHECK_VERSION(2,0,0) + g_signal_connect(G_OBJECT(treeselection), "changed", + G_CALLBACK(treeselection_changed), selparams); +#else dp.ntreeitems = nselparams; dp.treeitems = snewn(dp.ntreeitems, GtkWidget *); @@ -2206,16 +2423,38 @@ int do_config_box(const char *title, Config *cfg, int midsession, &selparams[index]); dp.treeitems[index] = selparams[index].treeitem; } +#endif dp.data = cfg; dlg_refresh(NULL, &dp); dp.shortcuts = &selparams[0].shortcuts; +#if !GTK_CHECK_VERSION(2,0,0) dp.currtreeitem = dp.treeitems[0]; +#endif dp.lastfocus = NULL; dp.retval = 0; dp.window = window; + { + /* in gtkwin.c */ + extern void set_window_icon(GtkWidget *window, + const char *const *const *icon, + int n_icon); + extern const char *const *const cfg_icon[]; + extern const int n_cfg_icon; + set_window_icon(window, cfg_icon, n_cfg_icon); + } + +#if !GTK_CHECK_VERSION(2,0,0) + gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(treescroll), + tree); +#endif + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(treescroll), + GTK_POLICY_NEVER, + GTK_POLICY_AUTOMATIC); + gtk_widget_show(tree); + gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_widget_show(window); @@ -2322,8 +2561,7 @@ int messagebox(GtkWidget *parentwin, char *title, char *msg, int minwid, ...) window = gtk_dialog_new(); gtk_window_set_title(GTK_WINDOW(window), title); w0 = layout_ctrls(&dp, &scs, s0, 0, GTK_WINDOW(window)); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), - w0, TRUE, TRUE, 0); + set_dialog_action_area(GTK_DIALOG(window), w0); gtk_widget_show(w0); w1 = layout_ctrls(&dp, &scs, s1, 0, GTK_WINDOW(window)); gtk_container_set_border_width(GTK_CONTAINER(w1), 10); @@ -2364,7 +2602,7 @@ static int string_width(char *text) GtkWidget *label = gtk_label_new(text); GtkRequisition req; gtk_widget_size_request(label, &req); - gtk_widget_unref(label); + gtk_object_sink(GTK_OBJECT(label)); return req.width; } @@ -2511,12 +2749,12 @@ static void licence_clicked(GtkButton *button, gpointer data) char *title; char *licence = - "Copyright 1997-2006 Simon Tatham.\n\n" + "Copyright 1997-2007 Simon Tatham.\n\n" "Portions copyright Robert de Bath, Joris van Rantwijk, Delian " "Delchev, Andreas Schultz, Jeroen Massar, Wez Furlong, Nicolas " "Barry, Justin Bradford, Ben Harris, Malcolm Smith, Ahmad Khalifa, " - "Markus Kuhn, and CORE SDI S.A.\n\n" + "Markus Kuhn, Colin Watson, and CORE SDI S.A.\n\n" "Permission is hereby granted, free of charge, to any person " "obtaining a copy of this software and associated documentation " @@ -2592,7 +2830,7 @@ void about_box(void *window) w, FALSE, FALSE, 5); gtk_widget_show(w); - w = gtk_label_new("Copyright 1997-2006 Simon Tatham. All rights reserved"); + w = gtk_label_new("Copyright 1997-2007 Simon Tatham. All rights reserved"); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(aboutbox)->vbox), w, FALSE, FALSE, 5); gtk_widget_show(w); @@ -2768,8 +3006,7 @@ void showeventlog(void *estuff, void *parentwin) sfree(title); w0 = layout_ctrls(&es->dp, &es->scs, s0, listitemheight, GTK_WINDOW(window)); - gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area), - w0, TRUE, TRUE, 0); + set_dialog_action_area(GTK_DIALOG(window), w0); gtk_widget_show(w0); w1 = layout_ctrls(&es->dp, &es->scs, s1, listitemheight, GTK_WINDOW(window));