nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-10 18:07:59 +00:00
Code Issues Projects Releases Wiki Activity
097fbefa82
putty-source/unix/gtkdlg.c
Simon Tatham fca92a5b43 Continuing work on the GTK config box. Created uxcfg.c for the 
Unix-specific config items; moved a stray Windows-specific config
item (scrollbar-in-fullscreen) out into wincfg.c to stop it
appearing on Unix; continued updates to gtkdlg.c. I now believe the
GTK config box looks basically correct (modulo minor cosmetic issues
and keyboard accelerators). Next step, add the event handling so
it's actually functional.

[originally from svn r2933]
2003-03-14 18:35:01 +00:00

803 lines
23 KiB
C
Raw Blame History

/*
* gtkdlg.c - GTK implementation of the PuTTY configuration box.
*/
/*
* TODO:
*
* - event handling, in general!
*
* - keyboard stuff
* + accelerators
* + tab order
* + default button
*
* - cosmetics:
* + can't we _somehow_ have less leading between radio buttons?
* + wrapping text widgets, the horror, the horror
* + labels and their associated edit boxes don't line up
* properly
*/
#include <assert.h>
#include <gtk/gtk.h>
#include "gtkcols.h"
#include "gtkpanel.h"
#ifdef TESTMODE
#define PUTTY_DO_GLOBALS /* actually _define_ globals */
#endif
#include "putty.h"
#include "dialog.h"
void *dlg_get_privdata(union control *ctrl, void *dlg)
{
return NULL; /* FIXME */
}
void dlg_set_privdata(union control *ctrl, void *dlg, void *ptr)
{
/* FIXME */
}
void *dlg_alloc_privdata(union control *ctrl, void *dlg, size_t size)
{
return NULL; /* FIXME */
}
union control *dlg_last_focused(void *dlg)
{
return NULL; /* FIXME */
}
void dlg_radiobutton_set(union control *ctrl, void *dlg, int whichbutton)
{
/* FIXME */
}
int dlg_radiobutton_get(union control *ctrl, void *dlg)
{
return 0; /* FIXME */
}
void dlg_checkbox_set(union control *ctrl, void *dlg, int checked)
{
/* FIXME */
}
int dlg_checkbox_get(union control *ctrl, void *dlg)
{
return 0; /* FIXME */
}
void dlg_editbox_set(union control *ctrl, void *dlg, char const *text)
{
/* FIXME */
}
void dlg_editbox_get(union control *ctrl, void *dlg, char *buffer, int length)
{
/* FIXME */
}
/* The `listbox' functions can also apply to combo boxes. */
void dlg_listbox_clear(union control *ctrl, void *dlg)
{
/* FIXME */
}
void dlg_listbox_del(union control *ctrl, void *dlg, int index)
{
/* FIXME */
}
void dlg_listbox_add(union control *ctrl, void *dlg, char const *text)
{
/* FIXME */
}
/*
* Each listbox entry may have a numeric id associated with it.
* Note that some front ends only permit a string to be stored at
* each position, which means that _if_ you put two identical
* strings in any listbox then you MUST not assign them different
* IDs and expect to get meaningful results back.
*/
void dlg_listbox_addwithindex(union control *ctrl, void *dlg,
char const *text, int id)
{
/* FIXME */
}
int dlg_listbox_getid(union control *ctrl, void *dlg, int index)
{
return -1; /* FIXME */
}
/* dlg_listbox_index returns <0 if no single element is selected. */
int dlg_listbox_index(union control *ctrl, void *dlg)
{
return -1; /* FIXME */
}
int dlg_listbox_issel(union control *ctrl, void *dlg, int index)
{
return 0; /* FIXME */
}
void dlg_listbox_select(union control *ctrl, void *dlg, int index)
{
/* FIXME */
}
void dlg_text_set(union control *ctrl, void *dlg, char const *text)
{
/* FIXME */
}
void dlg_filesel_set(union control *ctrl, void *dlg, Filename fn)
{
/* FIXME */
}
void dlg_filesel_get(union control *ctrl, void *dlg, Filename *fn)
{
/* FIXME */
}
void dlg_fontsel_set(union control *ctrl, void *dlg, FontSpec fs)
{
/* FIXME */
}
void dlg_fontsel_get(union control *ctrl, void *dlg, FontSpec *fs)
{
/* FIXME */
}
/*
* Bracketing a large set of updates in these two functions will
* cause the front end (if possible) to delay updating the screen
* until it's all complete, thus avoiding flicker.
*/
void dlg_update_start(union control *ctrl, void *dlg)
{
/* FIXME */
}
void dlg_update_done(union control *ctrl, void *dlg)
{
/* FIXME */
}
void dlg_set_focus(union control *ctrl, void *dlg)
{
/* FIXME */
}
/*
* During event processing, you might well want to give an error
* indication to the user. dlg_beep() is a quick and easy generic
* error; dlg_error() puts up a message-box or equivalent.
*/
void dlg_beep(void *dlg)
{
/* FIXME */
}
void dlg_error_msg(void *dlg, char *msg)
{
/* FIXME */
}
/*
* This function signals to the front end that the dialog's
* processing is completed, and passes an integer value (typically
* a success status).
*/
void dlg_end(void *dlg, int value)
{
/* FIXME */
}
void dlg_refresh(union control *ctrl, void *dlg)
{
/* FIXME */
}
void dlg_coloursel_start(union control *ctrl, void *dlg, int r, int g, int b)
{
/* FIXME */
}
int dlg_coloursel_results(union control *ctrl, void *dlg,
int *r, int *g, int *b)
{
return 0; /* FIXME */
}
/*
* This function does the main layout work: it reads a controlset,
* it creates the relevant GTK controls, and returns a GtkWidget
* containing the result. (This widget might be a title of some
* sort, it might be a Columns containing many controls, or it
* might be a GtkFrame containing a Columns; whatever it is, it's
* definitely a GtkWidget and should probably be added to a
* GtkVbox.)
*/
GtkWidget *layout_ctrls(struct controlset *s, int listitemheight)
{
Columns *cols;
GtkWidget *ret;
int i;
if (!s->boxname && s->boxtitle) {
/* This controlset is a panel title. */
return gtk_label_new(s->boxtitle);
}
/*
* Otherwise, we expect to be laying out actual controls, so
* we'll start by creating a Columns for the purpose.
*/
cols = COLUMNS(columns_new(4));
ret = GTK_WIDGET(cols);
gtk_widget_show(ret);
/*
* Create a containing frame if we have a box name.
*/
if (*s->boxname) {
ret = gtk_frame_new(s->boxtitle); /* NULL is valid here */
gtk_container_set_border_width(GTK_CONTAINER(cols), 4);
gtk_container_add(GTK_CONTAINER(ret), GTK_WIDGET(cols));
gtk_widget_show(ret);
}
/*
* Now iterate through the controls themselves, create them,
* and add them to the Columns.
*/
for (i = 0; i < s->ncontrols; i++) {
union control *ctrl = s->ctrls[i];
GtkWidget *w = NULL;
switch (ctrl->generic.type) {
case CTRL_COLUMNS:
{
static const int simplecols[1] = { 100 };
columns_set_cols(cols, ctrl->columns.ncols,
(ctrl->columns.percentages ?
ctrl->columns.percentages : simplecols));
}
continue; /* no actual control created */
case CTRL_TABDELAY:
/* FIXME: we can do columns_taborder_last easily enough, but
* we need to be able to remember which GtkWidget(s) correspond
* to ctrl->tabdelay.ctrl. */
continue; /* no actual control created */
case CTRL_BUTTON:
w = gtk_button_new_with_label(ctrl->generic.label);
break;
case CTRL_CHECKBOX:
w = gtk_check_button_new_with_label(ctrl->generic.label);
break;
case CTRL_RADIO:
/*
* Radio buttons get to go inside their own Columns, no
* matter what.
*/
{
gint i, *percentages;
GSList *group;
w = columns_new(1);
if (ctrl->generic.label) {
GtkWidget *label = gtk_label_new(ctrl->generic.label);
columns_add(COLUMNS(w), label, 0, 1);
columns_force_left_align(COLUMNS(w), label);
gtk_widget_show(label);
}
percentages = g_new(gint, ctrl->radio.ncolumns);
for (i = 0; i < ctrl->radio.ncolumns; i++) {
percentages[i] =
((100 * (i+1) / ctrl->radio.ncolumns) -
100 * i / ctrl->radio.ncolumns);
}
columns_set_cols(COLUMNS(w), ctrl->radio.ncolumns,
percentages);
g_free(percentages);
group = NULL;
for (i = 0; i < ctrl->radio.nbuttons; i++) {
GtkWidget *b;
gint colstart;
b = (gtk_radio_button_new_with_label
(group, ctrl->radio.buttons[i]));
group = gtk_radio_button_group(GTK_RADIO_BUTTON(b));
colstart = i % ctrl->radio.ncolumns;
columns_add(COLUMNS(w), b, colstart,
(i == ctrl->radio.nbuttons-1 ?
ctrl->radio.ncolumns - colstart : 1));
gtk_widget_show(b);
}
}
break;
case CTRL_EDITBOX:
if (ctrl->editbox.has_list) {
w = gtk_combo_new();
} else {
w = gtk_entry_new();
if (ctrl->editbox.password)
gtk_entry_set_visibility(GTK_ENTRY(w), FALSE);
}
/*
* Edit boxes, for some strange reason, have a minimum
* width of 150 in GTK 1.2. We don't want this - we'd
* rather the edit boxes acquired their natural width
* from the column layout of the rest of the box.
*/
{
GtkRequisition req;
gtk_widget_size_request(w, &req);
gtk_widget_set_usize(w, 10, req.height);
}
if (ctrl->generic.label) {
GtkWidget *label, *container;
label = gtk_label_new(ctrl->generic.label);
container = columns_new(4);
if (ctrl->editbox.percentwidth == 100) {
columns_add(COLUMNS(container), label, 0, 1);
columns_force_left_align(COLUMNS(container), label);
columns_add(COLUMNS(container), w, 0, 1);
} else {
gint percentages[2];
percentages[1] = ctrl->editbox.percentwidth;
percentages[0] = 100 - ctrl->editbox.percentwidth;
columns_set_cols(COLUMNS(container), 2, percentages);
columns_add(COLUMNS(container), label, 0, 1);
columns_force_left_align(COLUMNS(container), label);
columns_add(COLUMNS(container), w, 1, 1);
}
gtk_widget_show(label);
gtk_widget_show(w);
w = container;
}
break;
case CTRL_FILESELECT:
case CTRL_FONTSELECT:
{
GtkWidget *ww;
GtkRequisition req;
char *browsebtn =
(ctrl->generic.type == CTRL_FILESELECT ?
"Browse..." : "Change...");
gint percentages[] = { 75, 25 };
w = columns_new(4);
columns_set_cols(COLUMNS(w), 2, percentages);
if (ctrl->generic.label) {
ww = gtk_label_new(ctrl->generic.label);
columns_add(COLUMNS(w), ww, 0, 2);
columns_force_left_align(COLUMNS(w), ww);
gtk_widget_show(ww);
}
ww = gtk_entry_new();
gtk_widget_size_request(ww, &req);
gtk_widget_set_usize(ww, 10, req.height);
columns_add(COLUMNS(w), ww, 0, 1);
gtk_widget_show(ww);
ww = gtk_button_new_with_label(browsebtn);
columns_add(COLUMNS(w), ww, 1, 1);
gtk_widget_show(ww);
}
break;
case CTRL_LISTBOX:
if (ctrl->listbox.height == 0) {
w = gtk_option_menu_new();
} else {
GtkWidget *list;
list = gtk_list_new();
gtk_list_set_selection_mode(GTK_LIST(list),
(ctrl->listbox.multisel ?
GTK_SELECTION_MULTIPLE :
GTK_SELECTION_SINGLE));
w = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(w),
list);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(w),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(list);
/*
* Adjust the height of the scrolled window to the
* minimum given by the height parameter.
*
* This piece of guesswork is a horrid hack based
* on looking inside the GTK 1.2 sources
* (specifically gtkviewport.c, which appears to be
* the widget which provides the border around the
* scrolling area). Anyone lets me know how I can
* do this in a way which isn't at risk from GTK
* upgrades, I'd be grateful.
*/
{
int edge = GTK_WIDGET(list)->style->klass->ythickness;
gtk_widget_set_usize(w, 10,
2*edge + (ctrl->listbox.height *
listitemheight));
}
#if 1
/* here is an example of a percentage-based tabbed list item */
{ int i; for (i=0; i<10; i++) {
GtkWidget *listitem = gtk_list_item_new();
GtkWidget *cols = columns_new(4);
GtkWidget *label1 = gtk_label_new("left");
GtkWidget *label2 = gtk_label_new("right");
GList *itemlist;
static const gint percents[] = { 50, 50 };
columns_set_cols(COLUMNS(cols), 2, percents);
columns_add(COLUMNS(cols), label1, 0, 1);
columns_force_left_align(COLUMNS(cols), label1);
columns_add(COLUMNS(cols), label2, 1, 1);
columns_force_left_align(COLUMNS(cols), label2);
gtk_widget_show(label1);
gtk_widget_show(label2);
gtk_widget_show(cols);
gtk_container_add(GTK_CONTAINER(listitem), cols);
itemlist = g_list_append(NULL, listitem);
gtk_list_append_items(GTK_LIST(list), itemlist);
gtk_widget_show(listitem);
} }
#endif
if (ctrl->listbox.draglist) {
/*
* GTK doesn't appear to make it easy to
* implement a proper draggable list; so
* instead I'm just going to have to put an Up
* and a Down button to the right of the actual
* list box. Ah well.
*/
GtkWidget *cols, *button;
static const gint percentages[2] = { 80, 20 };
cols = columns_new(4);
columns_set_cols(COLUMNS(cols), 2, percentages);
columns_add(COLUMNS(cols), w, 0, 1);
gtk_widget_show(w);
button = gtk_button_new_with_label("Up");
columns_add(COLUMNS(cols), button, 1, 1);
gtk_widget_show(button);
button = gtk_button_new_with_label("Down");
columns_add(COLUMNS(cols), button, 1, 1);
gtk_widget_show(button);
w = cols;
}
}
if (ctrl->generic.label) {
GtkWidget *label, *container;
label = gtk_label_new(ctrl->generic.label);
container = columns_new(4);
if (ctrl->listbox.percentwidth == 100) {
columns_add(COLUMNS(container), label, 0, 1);
columns_force_left_align(COLUMNS(container), label);
columns_add(COLUMNS(container), w, 0, 1);
} else {
gint percentages[2];
percentages[1] = ctrl->listbox.percentwidth;
percentages[0] = 100 - ctrl->listbox.percentwidth;
columns_set_cols(COLUMNS(container), 2, percentages);
columns_add(COLUMNS(container), label, 0, 1);
columns_force_left_align(COLUMNS(container), label);
columns_add(COLUMNS(container), w, 1, 1);
}
gtk_widget_show(label);
gtk_widget_show(w);
w = container;
}
break;
case CTRL_TEXT:
w = gtk_label_new(ctrl->generic.label);
gtk_label_set_line_wrap(GTK_LABEL(w), TRUE);
/* FIXME: deal with wrapping! */
break;
}
if (w) {
columns_add(cols, w,
COLUMN_START(ctrl->generic.column),
COLUMN_SPAN(ctrl->generic.column));
gtk_widget_show(w);
}
}
return ret;
}
struct selparam {
Panels *panels;
GtkWidget *panel, *treeitem;
};
static void treeitem_sel(GtkItem *item, gpointer data)
{
struct selparam *sp = (struct selparam *)data;
panels_switch_to(sp->panels, sp->panel);
}
void destroy(GtkWidget *widget, gpointer data)
{
gtk_main_quit();
}
void do_config_box(void)
{
GtkWidget *window, *hbox, *vbox, *cols, *label,
*tree, *treescroll, *panels, *panelvbox;
int index, level, listitemheight;
struct controlbox *ctrlbox;
char *path;
GtkTreeItem *treeitemlevels[8];
GtkTree *treelevels[8];
Config cfg;
struct selparam *selparams = NULL;
int nselparams = 0, selparamsize = 0;
do_defaults(NULL, &cfg);
{
GtkWidget *listitem = gtk_list_item_new_with_label("foo");
GtkRequisition req;
gtk_widget_size_request(listitem, &req);
listitemheight = req.height;
gtk_widget_unref(listitem);
}
ctrlbox = ctrl_new_box();
setup_config_box(ctrlbox, NULL, FALSE, 0);
unix_setup_config_box(ctrlbox, FALSE);
window = gtk_dialog_new();
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->vbox), hbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
gtk_widget_show(hbox);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
gtk_widget_show(vbox);
cols = columns_new(4);
gtk_box_pack_start(GTK_BOX(vbox), cols, FALSE, FALSE, 0);
gtk_widget_show(cols);
label = gtk_label_new("Category:");
columns_add(COLUMNS(cols), label, 0, 1);
columns_force_left_align(COLUMNS(cols), label);
gtk_widget_show(label);
treescroll = gtk_scrolled_window_new(NULL, NULL);
tree = gtk_tree_new();
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_widget_show(tree);
gtk_widget_show(treescroll);
gtk_box_pack_start(GTK_BOX(vbox), treescroll, TRUE, TRUE, 0);
panels = panels_new();
gtk_box_pack_start(GTK_BOX(hbox), panels, TRUE, TRUE, 0);
gtk_widget_show(panels);
panelvbox = NULL;
path = NULL;
level = 0;
for (index = 0; index < ctrlbox->nctrlsets; index++) {
struct controlset *s = ctrlbox->ctrlsets[index];
GtkWidget *w = layout_ctrls(s, listitemheight);
if (!*s->pathname) {
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(window)->action_area),
w, TRUE, TRUE, 0);
} else {
int j = path ? ctrl_path_compare(s->pathname, path) : 0;
if (j != INT_MAX) { /* add to treeview, start new panel */
char *c;
GtkWidget *treeitem;
int first;
/*
* We expect never to find an implicit path
* component. For example, we expect never to see
* A/B/C followed by A/D/E, because that would
* _implicitly_ create A/D. All our path prefixes
* are expected to contain actual controls and be
* selectable in the treeview; so we would expect
* to see A/D _explicitly_ before encountering
* A/D/E.
*/
assert(j == ctrl_path_elements(s->pathname) - 1);
c = strrchr(s->pathname, '/');
if (!c)
c = s->pathname;
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_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);
gtk_tree_select_child(GTK_TREE(tree), treeitem);
}
if (nselparams >= selparamsize) {
selparamsize += 16;
selparams = srealloc(selparams,
selparamsize * sizeof(*selparams));
}
selparams[nselparams].panels = PANELS(panels);
selparams[nselparams].panel = panelvbox;
selparams[nselparams].treeitem = treeitem;
nselparams++;
}
gtk_box_pack_start(GTK_BOX(panelvbox), w, FALSE, FALSE, 0);
gtk_widget_show(w);
}
}
for (index = 0; index < nselparams; index++) {
gtk_signal_connect(GTK_OBJECT(selparams[index].treeitem), "select",
GTK_SIGNAL_FUNC(treeitem_sel),
&selparams[index]);
}
gtk_widget_show(window);
gtk_signal_connect(GTK_OBJECT(window), "destroy",
GTK_SIGNAL_FUNC(destroy), NULL);
gtk_main();
sfree(selparams);
}
/* ======================================================================
* Below here is a stub main program which allows the dialog box
* code to be compiled and tested with a minimal amount of the rest
* of PuTTY.
*/
#ifdef TESTMODE
/* Compile command for testing:
gcc -g -o gtkdlg gtk{dlg,cols,panel}.c ../{config,dialog,settings}.c \
../{misc,tree234,be_none}.c ux{store,misc,print,cfg}.c \
-I. -I.. -I../charset -DTESTMODE `gtk-config --cflags --libs`
*/
void modalfatalbox(char *p, ...)
{
va_list ap;
fprintf(stderr, "FATAL ERROR: ");
va_start(ap, p);
vfprintf(stderr, p, ap);
va_end(ap);
fputc('\n', stderr);
exit(1);
}
char *cp_name(int codepage)
{
return (codepage == 123 ? "testing123" :
codepage == 234 ? "testing234" :
codepage == 345 ? "testing345" :
"unknown");
}
char *cp_enumerate(int index)
{
return (index == 0 ? "testing123" :
index == 1 ? "testing234" :
NULL);
}
int decode_codepage(char *cp_name)
{
return (!strcmp(cp_name, "testing123") ? 123 :
!strcmp(cp_name, "testing234") ? 234 :
!strcmp(cp_name, "testing345") ? 345 :
-2);
}
struct printer_enum_tag { int dummy; } printer_test;
printer_enum *printer_start_enum(int *nprinters_ptr) {
*nprinters_ptr = 2;
return &printer_test;
}
char *printer_get_name(printer_enum *pe, int i) {
return (i==0 ? "lpr" : i==1 ? "lpr -Pfoobar" : NULL);
}
void printer_finish_enum(printer_enum *pe) { }
char *platform_default_s(const char *name)
{
return NULL;
}
int platform_default_i(const char *name, int def)
{
return def;
}
FontSpec platform_default_fontspec(const char *name)
{
FontSpec ret;
*ret.name = '\0';
return ret;
}
Filename platform_default_filename(const char *name)
{
Filename ret;
*ret.path = '\0';
return ret;
}
char *x_get_default(const char *key)
{
return NULL;
}
int main(int argc, char **argv)
{
gtk_init(&argc, &argv);
do_config_box();
return 0;
}
#endif
Reference in New Issue View Git Blame Copy Permalink