* 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 <assert.h>
#include <stdarg.h>
#include <ctype.h>
#include <X11/Xutil.h>
#include "gtkcols.h"
-#include "gtkpanel.h"
#ifdef TESTMODE
#define PUTTY_DO_GLOBALS /* actually _define_ globals */
GtkWidget *menu; /* for optionmenu (==droplist) */
GtkWidget *optmenu; /* also for optionmenu */
GtkWidget *text; /* for text */
+ GtkWidget *label; /* for dlg_label_change */
GtkAdjustment *adj; /* for the scrollbar in a list box */
+ guint entrysig;
guint textsig;
};
* 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
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.
*/
gpointer data);
static void shortcut_add(struct Shortcuts *scs, GtkWidget *labelw,
int chr, int action, void *ptr);
-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 void shortcut_highlight(GtkWidget *label, int chr);
+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);
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;
}
}
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)
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)
if (uc->optmenu) {
gtk_option_menu_set_history(GTK_OPTION_MENU(uc->optmenu), index);
} else {
+ int nitems;
+ GList *items;
+ gdouble newtop, newbot;
+
gtk_list_select_item(GTK_LIST(uc->list), index);
+
+ /*
+ * Scroll the list box if necessary to ensure the newly
+ * selected item is visible.
+ */
+ items = gtk_container_children(GTK_CONTAINER(uc->list));
+ nitems = g_list_length(items);
+ if (nitems > 0) {
+ int modified = FALSE;
+ g_list_free(items);
+ newtop = uc->adj->lower +
+ (uc->adj->upper - uc->adj->lower) * index / nitems;
+ newbot = uc->adj->lower +
+ (uc->adj->upper - uc->adj->lower) * (index+1) / nitems;
+ if (uc->adj->value > newtop) {
+ modified = TRUE;
+ uc->adj->value = newtop;
+ } else if (uc->adj->value < newbot - uc->adj->page_size) {
+ modified = TRUE;
+ uc->adj->value = newbot - uc->adj->page_size;
+ }
+ if (modified)
+ gtk_adjustment_value_changed(uc->adj);
+ }
}
}
gtk_label_set_text(GTK_LABEL(uc->text), text);
}
+void dlg_label_change(union control *ctrl, void *dlg, char const *text)
+{
+ struct dlgparam *dp = (struct dlgparam *)dlg;
+ struct uctrl *uc = dlg_find_byctrl(dp, ctrl);
+
+ switch (uc->ctrl->generic.type) {
+ case CTRL_BUTTON:
+ gtk_label_set_text(GTK_LABEL(uc->toplevel), text);
+ shortcut_highlight(uc->toplevel, ctrl->button.shortcut);
+ break;
+ case CTRL_CHECKBOX:
+ gtk_label_set_text(GTK_LABEL(uc->toplevel), text);
+ shortcut_highlight(uc->toplevel, ctrl->checkbox.shortcut);
+ break;
+ case CTRL_RADIO:
+ gtk_label_set_text(GTK_LABEL(uc->label), text);
+ shortcut_highlight(uc->label, ctrl->radio.shortcut);
+ break;
+ case CTRL_EDITBOX:
+ gtk_label_set_text(GTK_LABEL(uc->label), text);
+ shortcut_highlight(uc->label, ctrl->editbox.shortcut);
+ break;
+ case CTRL_FILESELECT:
+ gtk_label_set_text(GTK_LABEL(uc->label), text);
+ shortcut_highlight(uc->label, ctrl->fileselect.shortcut);
+ break;
+ case CTRL_FONTSELECT:
+ gtk_label_set_text(GTK_LABEL(uc->label), text);
+ shortcut_highlight(uc->label, ctrl->fontselect.shortcut);
+ break;
+ case CTRL_LISTBOX:
+ gtk_label_set_text(GTK_LABEL(uc->label), text);
+ shortcut_highlight(uc->label, ctrl->listbox.shortcut);
+ break;
+ default:
+ assert(!"This shouldn't happen");
+ break;
+ }
+}
+
void dlg_filesel_set(union control *ctrl, void *dlg, Filename fn)
{
struct dlgparam *dp = (struct dlgparam *)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;
}
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;
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
* 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);
}
}
-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);
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 ||
/* 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);
}
/* 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);
}
}
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)) {
/*
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)
uc->buttons = NULL;
uc->entry = uc->list = uc->menu = NULL;
uc->button = uc->optmenu = uc->text = NULL;
+ uc->label = NULL;
switch (ctrl->generic.type) {
case CTRL_BUTTON:
gtk_widget_show(label);
shortcut_add(scs, label, ctrl->radio.shortcut,
SHORTCUT_UCTRL, uc);
+ uc->label = label;
}
percentages = g_new(gint, ctrl->radio.ncolumns);
for (i = 0; i < ctrl->radio.ncolumns; i++) {
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",
gtk_widget_show(w);
w = container;
+ uc->label = label;
}
gtk_signal_connect(GTK_OBJECT(uc->entry), "focus_out_event",
GTK_SIGNAL_FUNC(editbox_lostfocus), dp);
ctrl->fileselect.shortcut :
ctrl->fontselect.shortcut),
SHORTCUT_UCTRL, uc);
+ uc->label = ww;
}
uc->entry = ww = gtk_entry_new();
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",
* 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));
shortcut_add(scs, label, ctrl->listbox.shortcut,
SHORTCUT_UCTRL, uc);
w = container;
+ uc->label = label;
}
break;
case CTRL_TEXT:
struct selparam {
struct dlgparam *dp;
- Panels *panels;
- GtkWidget *panel, *treeitem;
+ GtkNotebook *panels;
+ 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;
+ gint page_num;
+
+ page_num = gtk_notebook_page_num(sp->panels, sp->panel);
+ gtk_notebook_set_page(sp->panels, page_num);
- panels_switch_to(sp->panels, sp->panel);
+ dlg_refresh(NULL, sp->dp);
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;
*/
return tree_grab_focus(dp);
}
+#endif
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);
} 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;
}
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;
return FALSE;
}
+#endif
-void shortcut_add(struct Shortcuts *scs, GtkWidget *labelw,
- int chr, int action, void *ptr)
+static void shortcut_highlight(GtkWidget *labelw, int chr)
{
GtkLabel *label = GTK_LABEL(labelw);
gchar *currstr, *pattern;
int i;
+ gtk_label_get(label, &currstr);
+ for (i = 0; currstr[i]; i++)
+ if (tolower((unsigned char)currstr[i]) == chr) {
+ GtkRequisition req;
+
+ pattern = dupprintf("%*s_", i, "");
+
+ gtk_widget_size_request(GTK_WIDGET(label), &req);
+ gtk_label_set_pattern(label, pattern);
+ gtk_widget_set_usize(GTK_WIDGET(label), -1, req.height);
+
+ sfree(pattern);
+ break;
+ }
+}
+
+void shortcut_add(struct Shortcuts *scs, GtkWidget *labelw,
+ int chr, int action, void *ptr)
+{
if (chr == NO_SHORTCUT)
return;
scs->sc[chr].uc = (struct uctrl *)ptr;
}
- gtk_label_get(label, &currstr);
- for (i = 0; currstr[i]; i++)
- if (tolower((unsigned char)currstr[i]) == chr) {
- GtkRequisition req;
-
- pattern = dupprintf("%*s_", i, "");
-
- gtk_widget_size_request(GTK_WIDGET(label), &req);
- gtk_label_set_pattern(label, pattern);
- gtk_widget_set_usize(GTK_WIDGET(label), -1, req.height);
-
- sfree(pattern);
- break;
- }
+ shortcut_highlight(labelw, chr);
}
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)
{
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;
ctrlbox = ctrl_new_box();
setup_config_box(ctrlbox, midsession, cfg->protocol, protcfginfo);
- unix_setup_config_box(ctrlbox, midsession);
+ unix_setup_config_box(ctrlbox, midsession, cfg->protocol);
gtk_setup_config_box(ctrlbox, midsession, window);
gtk_window_set_title(GTK_WINDOW(window), title);
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 = panels_new();
+ panels = gtk_notebook_new();
+ gtk_notebook_set_show_tabs(GTK_NOTEBOOK(panels), FALSE);
+ gtk_notebook_set_show_border(GTK_NOTEBOOK(panels), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), panels, TRUE, TRUE, 0);
gtk_widget_show(panels);
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;
/*
else
c++;
- treeitem = gtk_tree_item_new_with_label(c);
+ path = s->pathname;
+
+ first = (panelvbox == NULL);
+
+ panelvbox = gtk_vbox_new(FALSE, 4);
+ gtk_widget_show(panelvbox);
+ gtk_notebook_append_page(GTK_NOTEBOOK(panels), panelvbox,
+ NULL);
+ if (first) {
+ gint page_num;
+
+ page_num = gtk_notebook_page_num(GTK_NOTEBOOK(panels),
+ panelvbox);
+ gtk_notebook_set_page(GTK_NOTEBOOK(panels), page_num);
+ }
+
+ if (nselparams >= selparamsize) {
+ selparamsize += 16;
+ selparams = sresize(selparams, selparamsize,
+ struct selparam);
+ }
+ selparams[nselparams].dp = &dp;
+ 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]));
- gtk_tree_item_expand(treeitemlevels[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 {
}
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_widget_show(treeitem);
- path = s->pathname;
-
- first = (panelvbox == NULL);
-
- panelvbox = gtk_vbox_new(FALSE, 4);
- gtk_container_add(GTK_CONTAINER(panels), panelvbox);
- if (first) {
- panels_switch_to(PANELS(panels), panelvbox);
+ if (first)
gtk_tree_select_child(GTK_TREE(tree), treeitem);
- }
-
- if (nselparams >= selparamsize) {
- selparamsize += 16;
- selparams = sresize(selparams, selparamsize,
- struct selparam);
- }
- selparams[nselparams].dp = &dp;
- selparams[nselparams].panels = PANELS(panels);
- selparams[nselparams].panel = panelvbox;
- selparams[nselparams].shortcuts = scs; /* structure copy */
selparams[nselparams].treeitem = treeitem;
- nselparams++;
+#endif
+ level = j+1;
+ nselparams++;
}
w = layout_ctrls(&dp,
}
}
+#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 *);
&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);
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);
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;
}
char *title;
char *licence =
- "Copyright 1997-2005 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 "
w, FALSE, FALSE, 5);
gtk_widget_show(w);
- w = gtk_label_new("Copyright 1997-2005 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);
struct eventlog_stuff *es = (struct eventlog_stuff *)data;
gtk_selection_data_set(seldata, seldata->target, 8,
- es->seldata, es->sellen);
+ (unsigned char *)es->seldata, es->sellen);
}
gint eventlog_selection_clear(GtkWidget *widget, GdkEventSelection *seldata,
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));
projects / PuTTY.git / blobdiff