/* Functions for creating and updating GTK widgets. Copyright (C) 2002 Free Software Foundation, Inc. This file is part of GNU Emacs. GNU Emacs is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. GNU Emacs is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GNU Emacs; see the file COPYING. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "config.h" #ifdef USE_GTK #include "lisp.h" #include "xterm.h" #include "blockinput.h" #include "window.h" #include "atimer.h" #include "gtkutil.h" #include #include /*********************************************************************** Menus and dialog functions. ***********************************************************************/ /* Linked list of all allocated struct menu_gtk_data. Used for marking during GC. */ static struct menu_gtk_data *menu_gtk_data_list; /* The next two variables and functions are taken from lwlib. */ static widget_value *widget_value_free_list; static int malloc_cpt; widget_value * malloc_widget_value () { widget_value *wv; if (widget_value_free_list) { wv = widget_value_free_list; widget_value_free_list = wv->free_list; wv->free_list = 0; } else { wv = (widget_value *) malloc (sizeof (widget_value)); malloc_cpt++; } memset (wv, 0, sizeof (widget_value)); return wv; } /* this is analogous to free(). It frees only what was allocated by malloc_widget_value(), and no substructures. */ void free_widget_value (wv) widget_value *wv; { if (wv->free_list) abort (); if (malloc_cpt > 25) { /* When the number of already allocated cells is too big, We free it. */ free (wv); malloc_cpt--; } else { wv->free_list = widget_value_free_list; widget_value_free_list = wv; } } /* Allocate and return a utf8 version of STR. If STR is already utf8 or NULL, just return STR. If not, a new string is allocated and the caller must free the result with g_free(). */ static char* get_utf8_string (str) char *str; { char *utf8_str = str; /* If not UTF-8, try current locale. */ if (str && !g_utf8_validate (str, -1, NULL)) utf8_str = g_locale_to_utf8 (str, -1, 0, 0, 0); return utf8_str; } /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count. F is the frame CL_DATA will be initialized for. Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly allocated menu_gtk_data if CL_DATA is NULL. */ struct menu_gtk_data* make_cl_data (cl_data, f) struct menu_gtk_data *cl_data; FRAME_PTR f; { if (! cl_data) { cl_data = (struct menu_gtk_data*) xmalloc (sizeof (*cl_data)); cl_data->f = f; cl_data->menu_bar_vector = f->menu_bar_vector; cl_data->menu_bar_items_used = f->menu_bar_items_used; cl_data->ref_count = 0; cl_data->next = menu_gtk_data_list; if (menu_gtk_data_list) menu_gtk_data_list->prev = cl_data; cl_data->prev = 0; menu_gtk_data_list = cl_data; } cl_data->ref_count++; return cl_data; } /* Function that marks all lisp data during GC. */ void xg_mark_data () { struct menu_gtk_data *iter = menu_gtk_data_list; while (iter) { mark_object (&iter->menu_bar_vector); iter = iter->next; } } /* Callback called when a menu item is destroyed. Used to free data. W is the widget that is being destroyed. DATA points to the struct menu_gtk_data associated with the WIDGET. */ static void menuitem_destroy_callback (w, client_data) GtkWidget *w; gpointer client_data; { struct menu_gtk_data *data = (struct menu_gtk_data*) client_data; if (data && data->ref_count > 0) { data->ref_count--; if (data->ref_count == 0) { if (data == menu_gtk_data_list) { menu_gtk_data_list = data->next; if (menu_gtk_data_list) menu_gtk_data_list->prev = 0; } else { data->prev->next = data->next; if (data->next) data->next->prev = data->prev; } xfree (data); } } } /* Make and return a menu item widget with the key to the right. UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally). UTF8_KEY is the text representing the key binding. ITEM is the widget_value describing the menu item. GROUP is an in/out parameter. If the menu item to be created is not part of any radio menu group, *GROUP contains NULL on entry and exit. If the menu item to be created is part of a radio menu group, on entry *GROUP contains the group to use, or NULL if this is the first item in the group. On exit, *GROUP contains the radio item group. Unfortunately, keys don't line up as nicely as in Motif, but the MacOS X version doesn't either, so I guess that is OK. */ static GtkWidget* make_menu_item (utf8_label, utf8_key, item, group) char *utf8_label; char *utf8_key; widget_value* item; GSList **group; { GtkWidget *w; GtkWidget *wtoadd = 0; if (utf8_key) { GtkWidget *wlbl; GtkWidget *wkey; wtoadd = gtk_hbox_new (FALSE, 0); wlbl = gtk_label_new_with_mnemonic (utf8_label); wkey = gtk_label_new (utf8_key); gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5); gtk_misc_set_alignment (GTK_MISC (wkey), 0.0, 0.5); gtk_box_pack_start (GTK_BOX (wtoadd), wlbl, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (wtoadd), wkey, FALSE, FALSE, 0); gtk_widget_show (wlbl); gtk_widget_show (wkey); gtk_widget_show (wtoadd); } if (item->button_type == BUTTON_TYPE_TOGGLE) { *group = NULL; if (utf8_key) w = gtk_check_menu_item_new (); else w = gtk_check_menu_item_new_with_mnemonic (utf8_label); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), item->selected); } else if (item->button_type == BUTTON_TYPE_RADIO) { if (utf8_key) w = gtk_radio_menu_item_new (*group); else w = gtk_radio_menu_item_new_with_mnemonic (*group, utf8_label); *group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w)); if (item->selected) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w), TRUE); } else { *group = NULL; if (utf8_key) w = gtk_menu_item_new (); else w = gtk_menu_item_new_with_mnemonic (utf8_label); } if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd); if (! item->enabled) gtk_widget_set_sensitive (w, FALSE); return w; } /* Return non-zero if NAME specifies a separator (GTK only has one separator type) */ static int xg_separator_p (char *name) { return strcmp (name, "--") == 0 || strcmp (name, "--:") == 0 || strcmp (name, "---") == 0; } /* Create a full menu tree specified by DATA. F is the frame the created menu belongs to. ACTIVATE_CB is the callback to use when a sub menu is shown. SELECT_CB is the callback to use when a menu item is selected. DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore. HELP_CB is the callback to use to display help text. POP_UP_P is non-zero if we shall create a popup menu. MENU_BAR_P is non-zero if we shall create a menu bar. TOPMENU is the topmost GtkWidget that others shall be placed under. It may be NULL, in that case we create the appropriate widget (menu bar or menu item depending on POP_UP_P and MENU_BAR_P) CL_DATA is the callback data we shall use for this menu, or NULL if we haven't set the first callback yet. Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is not NULL. This function calls itself to create submenus. */ static GtkWidget* create_menus (data, f, activate_cb, select_cb, deactivate_cb, help_cb, pop_up_p, menu_bar_p, topmenu, cl_data) widget_value* data; FRAME_PTR f; GCallback activate_cb; GCallback select_cb; GCallback deactivate_cb; int menu_bar_p; GtkWidget *topmenu; struct menu_gtk_data *cl_data; { widget_value* item; GtkWidget* wmenu = topmenu; GSList* group = NULL; if (! topmenu) { if (! menu_bar_p) wmenu = gtk_menu_new (); else wmenu = gtk_menu_bar_new (); if (deactivate_cb) g_signal_connect(wmenu, "deactivate", deactivate_cb, 0); } if (! menu_bar_p) { GtkWidget *tearoff = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), tearoff); gtk_widget_show (tearoff); } for (item = data; item; item = item->next) { GtkWidget *w; if (pop_up_p && !item->contents && !item->call_data && !xg_separator_p (item->name)) { char *utf8_label; /* A title for a popup. We do the same as GTK does when creating titles, but it is very ugly looking. */ group = NULL; utf8_label = get_utf8_string (item->name); gtk_menu_set_title(GTK_MENU(wmenu), utf8_label); w = gtk_menu_item_new_with_mnemonic (utf8_label); gtk_widget_set_sensitive (w, FALSE); if (utf8_label && utf8_label != item->name) g_free (utf8_label); } else if (xg_separator_p (item->name)) { group = NULL; /* GTK only have one separator type. */ w = gtk_separator_menu_item_new (); } else { char *utf8_label; char *utf8_key; utf8_label = get_utf8_string (item->name); utf8_key = get_utf8_string (item->key); w = make_menu_item (utf8_label, utf8_key, item, &group); if (utf8_label && utf8_label != item->name) g_free (utf8_label); if (utf8_key && utf8_key != item->key) g_free (utf8_key); /* Assume "Help" is the last menu in the menubar. */ if (menu_bar_p && ! item->next) gtk_menu_item_right_justify (GTK_MENU_ITEM (w)); /* final item, not a submenu */ if (item->call_data && ! item->contents) { if (select_cb) { cl_data = make_cl_data (cl_data, f); g_signal_connect(w, "activate", select_cb, item->call_data); g_signal_connect(w, "destroy", menuitem_destroy_callback, cl_data); /* Put cl_data in widget, so select_cb can get it */ g_object_set_data (G_OBJECT (w), G_FRAME_DATA, (gpointer)cl_data); } /* help_cb NYI */ } if (item->contents) { GtkWidget *submenu = create_menus (item->contents, f, activate_cb, select_cb, deactivate_cb, help_cb, 0, 0, 0, cl_data); gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), submenu); if (activate_cb) g_signal_connect(w, "activate", activate_cb, 0); gtk_widget_show (submenu); } } gtk_menu_shell_append (GTK_MENU_SHELL (wmenu), w); gtk_widget_show (w); } return wmenu; } /* Return the dialog title to use for a dialog of type KEY. This is the encoding used by lwlib. We use the same for GTK. */ static char* get_dialog_title (char key) { char *title = ""; switch (key) { case 'E': case 'e': title = "Error"; break; case 'I': case 'i': title = "Information"; break; case 'L': case 'l': title = "Prompt"; break; case 'P': case 'p': title = "Prompt"; break; case 'Q': case 'q': title = "Question"; break; } return title; } /* Create a popup dialog window. WV is a widget_value describing the dialog. SELECT_CB is the callback to use when a button has been pressed. DEACTIVATE_CB is the callback to use when the dialog pops down. Returns the GTK dialog widget. */ static GtkWidget* create_dialog (wv, select_cb, deactivate_cb) widget_value* wv; GCallback select_cb; GCallback deactivate_cb; { char *title = get_dialog_title (wv->name[0]); int total_buttons = wv->name[1] - '0'; int right_buttons = wv->name[4] - '0'; int left_buttons; int button_nr = 0; int button_spacing = 10; GtkWidget *wdialog = gtk_dialog_new (); widget_value* item; if (right_buttons == 0) right_buttons = total_buttons/2; left_buttons = total_buttons - right_buttons; gtk_window_set_title (GTK_WINDOW (wdialog), title); if (deactivate_cb) { g_signal_connect(wdialog, "close", deactivate_cb, 0); g_signal_connect(wdialog, "response", deactivate_cb, 0); } for (item = wv->contents; item; item = item->next) { char *utf8_label = get_utf8_string (item->value); GtkWidget *w; GtkRequisition req; if (strcmp (item->name, "message") == 0) { /* This is the text part of the dialog. */ w = gtk_label_new (utf8_label); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->vbox), gtk_label_new (""), FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->vbox), w, TRUE, TRUE, 0); gtk_misc_set_alignment (GTK_MISC (w), 0.1, 0.5); gtk_widget_realize (w); /* Try to make dialog look better. */ gtk_widget_size_request (w, &req); gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (wdialog)->vbox), req.height); if (strlen(item->value) > 0) button_spacing = 2*req.width/strlen(item->value); } else { /* This is one button to add to the dialog. */ w = gtk_button_new_with_mnemonic (utf8_label); if (! item->enabled) gtk_widget_set_sensitive (w, FALSE); if (select_cb) g_signal_connect(w, "clicked", select_cb, item->call_data); gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->action_area), w, TRUE, TRUE, button_spacing); if (++button_nr == left_buttons) gtk_box_pack_start (GTK_BOX (GTK_DIALOG (wdialog)->action_area), gtk_label_new (""), TRUE, TRUE, button_spacing); } if (utf8_label && utf8_label != item->value) g_free (utf8_label); gtk_widget_show (w); } return wdialog; } /* Create a menubar, popup menu or dialog, depending on the TYPE argument. TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog with some text and buttons. F is the frame the created item belongs to. NAME is the name to use for the top widget. VAL is a widget_value structure describing items to be created. ACTIVATE_CB is the callback to use when an item is activated. For a menu, when a sub menu is shown, not used for dialogs. SELECT_CB is the callback to use when a menu item is selected or a dialog button is pressed. DEACTIVATE_CB is the callback to use when an item is deactivated. For a menu, when a sub menu is not shown anymore, for a dialog it is called when the dialog is popped down. HELP_CB is the callback to use to display help text. Returns the widget created. */ GtkWidget* xg_create_widget (type, name, f, val, activate_cb, select_cb, deactivate_cb, help_cb) char* type; char* name; FRAME_PTR f; widget_value* val; GCallback activate_cb; GCallback select_cb; GCallback deactivate_cb; GCallback help_cb; { GtkWidget *w = 0; if (strcmp (type, "dialog") == 0) { w = create_dialog (val, select_cb, deactivate_cb); gtk_window_set_transient_for (GTK_WINDOW (w), GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f))); } else if (strcmp (type, "menubar") == 0 || strcmp (type, "popup") == 0) { w = create_menus (val->contents, f, activate_cb, select_cb, deactivate_cb, help_cb, strcmp (type, "popup") == 0, strcmp (type, "menubar") == 0, 0, 0); } else { fprintf (stderr, "bad type in xg_create_widget: %s, doing nothing\n", type); } if (w) gtk_widget_set_name (w, name); return w; } /* Remove all children in the GTK container W. */ static void remove_all_children (w) GtkWidget *w; { GList *list = gtk_container_get_children (GTK_CONTAINER (w)); GList *iter; if (! list) return; for (iter = g_list_copy (list); iter; iter = g_list_next (iter)) { GtkWidget *witem = GTK_WIDGET (iter->data); gtk_container_remove (GTK_CONTAINER (w), witem); } g_list_free (iter); } /* Update the MENUBAR. F is the frame the menu bar belongs to. VAL describes the contents of the menu bar. If DEEP_P is non-zero, rebuild all but the top level menu names in the MENUBAR. If DEEP_P is zero, just rebuild everything. ACTIVATE_CB is the callback to use when a sub menu is shown. SELECT_CB is the callback to use when a menu item is selected. DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore. HELP_CB is the callback to use to display help text. */ void xg_modify_menubar_widgets (menubar, f, val, deep_p, activate_cb, select_cb, deactivate_cb, help_cb) GtkWidget *menubar; FRAME_PTR f; widget_value* val; int deep_p; GCallback activate_cb; GCallback select_cb; GCallback deactivate_cb; GCallback help_cb; { GList *list = gtk_container_get_children (GTK_CONTAINER (menubar)); GList *iter; if (! list) return; if (! deep_p) { widget_value* cur = val->contents; int is_changed = 0; /* Check if the change is actually no change. */ for (iter = g_list_first (list); iter && cur && ! is_changed; cur = cur->next, iter = g_list_next (iter)) { GtkMenuItem *witem = GTK_MENU_ITEM (iter->data); GtkLabel *wlabel = GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem))); char *utf8_label = get_utf8_string (cur->name); is_changed = strcmp (utf8_label, gtk_label_get_label (wlabel)); } is_changed = ! (cur == 0 && iter == 0); if (! is_changed) { return; } /* Keep menubar, but change everything else. This is simple, but not efficient. Ok for now. */ remove_all_children (menubar); (void)create_menus (val->contents, f, activate_cb, select_cb, deactivate_cb, help_cb, 0, 1, menubar, 0); } else { /* Keep the top level submenu names intact, but change everything else. This is simple, but not efficient. We must keep the submenu names (GTK menu item widgets) since the X Window in the XEvent that activates the menu are those widgets. */ widget_value* cur; for (cur = val->contents; cur; cur = cur->next) { for (iter = list ; iter; iter = g_list_next (iter)) { GtkMenuItem *witem = GTK_MENU_ITEM (iter->data); GtkWidget *wlbl = gtk_bin_get_child (GTK_BIN (witem)); const char *text = gtk_label_get_text (GTK_LABEL (wlbl)); GtkWidget *sub = gtk_menu_item_get_submenu (witem); GtkWidget *newsub; if (strcmp (text, cur->name)) continue; if (sub) gtk_menu_item_remove_submenu (witem); newsub = create_menus (cur->contents, f, activate_cb, select_cb, deactivate_cb, help_cb, 0, 0, 0, 0); gtk_menu_item_set_submenu (witem, newsub); break; } } } } /* Recompute all the widgets of frame F, when the menu bar has been changed. Value is non-zero if widgets were updated. */ int xg_update_frame_menubar (f) FRAME_PTR f; { struct x_output *x = f->output_data.x; GtkRequisition req; if (!x->menubar_widget || GTK_WIDGET_MAPPED (x->menubar_widget)) return 0; BLOCK_INPUT; gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (x->vbox_widget), x->menubar_widget, 0); gtk_widget_show (x->menubar_widget); gtk_widget_size_request (x->menubar_widget, &req); FRAME_MENUBAR_HEIGHT (f) = req.height; gtk_window_resize (GTK_WINDOW (x->widget), PIXEL_WIDTH (f), req.height + PIXEL_HEIGHT (f)); gdk_window_process_all_updates (); x_wm_set_size_hint (f, 0, 0); SET_FRAME_GARBAGED (f); UNBLOCK_INPUT; } /* Get rid of the menu bar of frame F, and free its storage. This is used when deleting a frame, and when turning off the menu bar. */ void free_frame_menubar (f) FRAME_PTR f; { struct x_output *x = f->output_data.x; if (x->menubar_widget) { int rows = f->height; int columns = f->width; int menubar_height = FRAME_MENUBAR_HEIGHT (f); BLOCK_INPUT; gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget); /* The menubar and its children shall be deleted when removed from the container. */ x->menubar_widget = 0; FRAME_MENUBAR_HEIGHT (f) = 0; /* base_height is now changed. */ x_wm_set_size_hint (f, 0, 0); SET_FRAME_GARBAGED (f); UNBLOCK_INPUT; } } /*********************************************************************** Scrollbar functions ***********************************************************************/ /* Setting scrollbar values invokes the callback. Use this variable to indicate that callback should do nothing. */ int xg_ignore_gtk_scrollbar; /* After we send a scroll bar event, x_set_toolkit_scroll_bar_thumb will be called. For some reason that needs to be debugged, it gets called with bad values. Thus, we set this variable to ignore those calls. */ int xg_ignore_next_thumb; /* SET_SCROLL_BAR_X_WINDOW assumes the second argument fits in 32 bits. But we want to store pointers, and they may be larger than 32 bits. Keep a mapping from integer index to widget pointers to get around the 32 bit limitation. */ static struct { GtkWidget **widgets; int max_size; int used; } id_to_widget = { 0, 0, 0 }; /* Grow this much every time we need to allocate more */ #define ID_TO_WIDGET_INCR 32 /* Store the widget pointer W in id_to_widget and return the integer index. */ static int xg_store_widget_in_map (w) GtkWidget *w; { int i; if (id_to_widget.max_size == id_to_widget.used) { int new_size = id_to_widget.max_size + ID_TO_WIDGET_INCR; id_to_widget.widgets = xrealloc (id_to_widget.widgets, sizeof (GtkWidget *)*new_size); for (i = id_to_widget.max_size; i < new_size; ++i) id_to_widget.widgets[i] = 0; id_to_widget.max_size = new_size; } /* Just loop over the array and find a free place. After all, how many scrollbars are we creating? Should be a small number. The check above guarantees we will find a free place. */ for (i = 0; i < id_to_widget.max_size; ++i) { if (! id_to_widget.widgets[i]) { id_to_widget.widgets[i] = w; ++id_to_widget.used; return i; } } /* Should never end up here */ abort (); } /* Remove pointer at IDX from id_to_widget. Called when scrollbar is destroyed. */ static void xg_remove_widget_from_map (idx) int idx; { if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0) { id_to_widget.widgets[idx] = 0; --id_to_widget.used; } } /* Get the widget pointer at IDX from id_to_widget. */ static GtkWidget* xg_get_widget_from_map (idx) int idx; { if (idx < id_to_widget.max_size && id_to_widget.widgets[idx] != 0) return id_to_widget.widgets[idx]; return 0; } /* Callback invoked when scrollbar WIDGET is destroyed. DATA is the index into id_to_widget for WIDGET. We free pointer to last scrollbar value here and remove the index. */ static void xg_gtk_scroll_destroy (widget, data) GtkWidget *widget; gpointer data; { gpointer p; int id = (int)data; p = g_object_get_data (G_OBJECT (widget), G_LAST_SB_DATA); if (p) xfree (p); xg_remove_widget_from_map (id); } /* The timer for scroll bar repetition. NULL if no timer is started. */ static struct atimer *scroll_timer; /* Timer function called when a timeout occurs for the scroll bar timer. This function processes all GTK events in a recursive event loop. This is done because GTK timer events are not seen by Emacs event detection, Emacs only looks for X events. When a scroll bar has the pointer (detected by button press/release events below) an Emacs timer is started, and this function can then check if the GTK timer has expired by calling the GTK event loop. */ static void xg_process_timeouts (timer) struct atimer *timer; { BLOCK_INPUT; /* Ideally we would like to just handle timer events, like the Xt version of this does in xterm.c, but there is no such feature in GTK. */ while (gtk_events_pending ()) gtk_main_iteration (); UNBLOCK_INPUT; } /* Callback for button press/release events. Used to start timer so that the scroll bar repetition timer in GTK gets handeled. WIDGET is the scroll bar widget the event is for (not used). EVENT contains the event. USER_DATA is 0 (not used). Returns FALSE to tell GTK that it shall continue propagate the event to widgets. */ static gboolean scroll_bar_button_cb (widget, event, user_data) GtkWidget *widget; GdkEventButton *event; gpointer user_data; { if (event->type == GDK_BUTTON_PRESS && !scroll_timer) { EMACS_TIME interval; EMACS_SET_SECS_USECS (interval, 0, 100000); scroll_timer = start_atimer (ATIMER_CONTINUOUS, interval, xg_process_timeouts, 0); } else if (event->type == GDK_BUTTON_RELEASE && scroll_timer) { cancel_atimer (scroll_timer); scroll_timer = 0; } return FALSE; } /* Create a scrollbar widget for frame F. Store the scrollbar in BAR. SCROLL_CALLBACK is the callback to invoke when the value of the bar changes. SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used to set resources for the widget. */ void xg_create_scroll_bar (f, bar, scroll_callback, scroll_bar_name) FRAME_PTR f; struct scroll_bar *bar; GCallback scroll_callback; char *scroll_bar_name; { GtkWidget *wscroll; GtkObject *vadj; int scroll_id; /* Page, step increment values are not so important here, they will be corrected in x_set_toolkit_scroll_bar_thumb. */ vadj = gtk_adjustment_new (GTK_SB_MIN, GTK_SB_MIN, GTK_SB_MAX, 0.1, 0.1, 0.1); /* KOKO, set fg & bg, cursor? */ wscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj)); gtk_widget_set_name (wscroll, scroll_bar_name); gtk_range_set_update_policy (GTK_RANGE (wscroll), GTK_UPDATE_CONTINUOUS); scroll_id = xg_store_widget_in_map (wscroll); g_signal_connect (vadj, "value-changed", scroll_callback, (gpointer)bar); g_signal_connect (wscroll, "destroy", G_CALLBACK(xg_gtk_scroll_destroy), (gpointer)scroll_id); /* Connect to button press and button release to detect if any scroll bar has the pointer. */ g_signal_connect (wscroll, "button-press-event", G_CALLBACK(scroll_bar_button_cb), (gpointer)1); g_signal_connect (wscroll, "button-release-event", G_CALLBACK(scroll_bar_button_cb), 0); gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget), wscroll, 0, 0); SET_SCROLL_BAR_X_WINDOW (bar, scroll_id); } /* Make the scrollbar represented by SCROLLBAR_ID visible. */ void xg_show_scroll_bar (scrollbar_id) int scrollbar_id; { GtkWidget *w = xg_get_widget_from_map (scrollbar_id); if (w) gtk_widget_show (w); } /* Remove the scrollbar represented by SCROLLBAR_ID from the frame F. */ void xg_remove_scroll_bar (f, scrollbar_id) FRAME_PTR f; int scrollbar_id; { GtkWidget *w = xg_get_widget_from_map (scrollbar_id); if (w) { gtk_widget_destroy (w); SET_FRAME_GARBAGED (f); } } /* Update the position of the vertical scrollbar represented by SCROLLBAR_ID in frame F. TOP/LEFT are the new pixel positions where the bar shall appear. WIDTH, HEIGHT is the size in pixels the bar shall have. */ void xg_update_scrollbar_pos (f, scrollbar_id, top, left, width, height) FRAME_PTR f; int scrollbar_id; int top; int left; int width; int height; { int gheight = max (height, 1); GtkWidget *wscroll = xg_get_widget_from_map (scrollbar_id); if (wscroll) { gtk_fixed_move (GTK_FIXED (f->output_data.x->edit_widget), wscroll, left, top); gtk_widget_set_size_request (wscroll, width, gheight); gtk_widget_queue_draw (wscroll); /* Since we are not using a pure gtk event loop, we must force out pending update events with this call. */ gdk_window_process_all_updates (); } } /* Set the thumb size and position of scroll bar BAR. We are currently displaying PORTION out of a whole WHOLE, and our position POSITION. */ void xg_set_toolkit_scroll_bar_thumb (bar, portion, position, whole) struct scroll_bar *bar; int portion, position, whole; { GtkWidget *wscroll = xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar)); FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window))); BLOCK_INPUT; if (wscroll && ! xg_ignore_next_thumb) { GtkAdjustment* adj; gdouble shown; gdouble top; int size, value; adj = gtk_range_get_adjustment (GTK_RANGE (wscroll)); if (whole <= 0) top = 0, shown = 1; else { shown = (gdouble) portion / whole; top = (gdouble) position / whole; } size = shown * whole; size = min (size, whole); size = max (size, 1); value = top * whole; value = min (value, whole - size); value = max (value, GTK_SB_MIN); adj->upper = whole; adj->page_size = (int)size; /* Assume a page increment is about 95% of the page size */ adj->page_increment = (int) (0.95*adj->page_size); /* Assume all lines are equal. */ adj->step_increment = portion / max (1, FRAME_HEIGHT (f)); /* gtk_range_set_value invokes the callback. Set ignore_gtk_scrollbar to make the callback do nothing */ xg_ignore_gtk_scrollbar = 1; gtk_range_set_value (GTK_RANGE (wscroll), (gdouble)value); xg_ignore_gtk_scrollbar = 0; } /* Make sure the scrollbar is redrawn with new thumb */ gtk_widget_queue_draw (wscroll); gdk_window_process_all_updates (); xg_ignore_next_thumb = 0; UNBLOCK_INPUT; } /*********************************************************************** General functions for creating widgets, resizing, events, e.t.c. ***********************************************************************/ /* Set this to non-zero to skip Emacs event processing. For dialogs and popups. */ int xg_pass_through_events; /* Function to handle resize of our widgets. Since Emacs has some layouts that does not fit well with GTK standard containers, we do most layout manually. F is the frame to resize. PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */ void xg_resize_widgets (f, pixelwidth, pixelheight) FRAME_PTR f; int pixelwidth, pixelheight; { int mbheight = FRAME_MENUBAR_HEIGHT (f); int rows = PIXEL_TO_CHAR_HEIGHT (f, pixelheight - mbheight); int columns = PIXEL_TO_CHAR_WIDTH (f, pixelwidth); if (FRAME_GTK_WIDGET (f) && (columns != FRAME_WIDTH (f) || rows != FRAME_HEIGHT (f) || pixelwidth != PIXEL_WIDTH (f) || pixelheight != PIXEL_HEIGHT (f))) { struct x_output *x = f->output_data.x; GtkAllocation all; all.y = mbheight; all.x = 0; all.width = pixelwidth; all.height = pixelheight - mbheight; gtk_widget_size_allocate (x->edit_widget, &all); gdk_window_process_all_updates (); change_frame_size (f, rows, columns, 0, 1, 0); SET_FRAME_GARBAGED (f); cancel_mouse_face (f); } } /* Update our widget size to be COLS/ROWS characters for frame F. */ void xg_frame_set_char_size (f, cols, rows) FRAME_PTR f; int cols; int rows; { int pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows) + FRAME_MENUBAR_HEIGHT (f); int pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols); /* Take into account the size of the scrollbar. Always use the number of columns occupied by the scroll bar here otherwise we might end up with a frame width that is not a multiple of the frame's character width which is bad for vertically split windows. */ f->output_data.x->vertical_scroll_bar_extra = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f) ? 0 : (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.x->font))); x_compute_fringe_widths (f, 0); /* Must resize our top level widget. Font size may have changed, but not rows/cols. */ gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixelwidth, pixelheight); xg_resize_widgets (f, pixelwidth, pixelheight); } /* Convert an X Window WSESC to its corresponding GtkWidget. Must be done like this, because GtkWidget:s can have "hidden" X Window that aren't accessible. Return 0 if no widget match WDESC. */ GtkWidget* xg_win_to_widget (wdesc) Window wdesc; { gpointer gdkwin; GtkWidget *gwdesc = 0; BLOCK_INPUT; gdkwin = gdk_xid_table_lookup (wdesc); if (gdkwin) { GdkEvent event; event.any.window = gdkwin; gwdesc = gtk_get_event_widget (&event); } UNBLOCK_INPUT; return gwdesc; } /* Fill in the GdkColor C so that it represents PIXEL. */ static void xg_pix2Gcolor (c, pixel) GdkColor *c; unsigned long pixel; { c->red = c->green = c->blue = 0; c->pixel = pixel; /* I've looked at the Gdk source, this works for X */ } /* Create and set up the GTK widgets for frame F. Return 0 if creation failed, non-zero otherwise. */ int xg_create_frame_widgets (f) FRAME_PTR f; { GtkWidget *wtop; GtkWidget *wvbox; GtkWidget *wfixed; GdkColor bg; int i; BLOCK_INPUT; wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL); wvbox = gtk_vbox_new (FALSE, 0); wfixed = gtk_fixed_new (); /* Must have this to place scrollbars */ if (! wtop || ! wvbox || ! wfixed) { if (wtop) gtk_widget_destroy (wtop); if (wvbox) gtk_widget_destroy (wvbox); if (wfixed) gtk_widget_destroy (wfixed); return 0; } FRAME_GTK_OUTER_WIDGET (f) = wtop; FRAME_GTK_WIDGET (f) = wfixed; f->output_data.x->vbox_widget = wvbox; gtk_fixed_set_has_window (GTK_FIXED (wfixed), TRUE); gtk_widget_set_size_request (wfixed, PIXEL_WIDTH (f), PIXEL_HEIGHT (f)); gtk_container_add (GTK_CONTAINER (wtop), wvbox); gtk_box_pack_end (GTK_BOX (wvbox), wfixed, TRUE, TRUE, 0); gtk_widget_set_double_buffered (wvbox, FALSE); gtk_widget_set_double_buffered (wfixed, FALSE); gtk_widget_set_double_buffered (wtop, FALSE); /* GTK documents says use gtk_window_set_resizable. But then a user can't shrink the window from its starting size. */ gtk_window_set_policy (GTK_WINDOW (wtop), TRUE, TRUE, TRUE); gtk_window_set_wmclass (GTK_WINDOW (wtop), SDATA (Vx_resource_name), SDATA (Vx_resource_class)); /* Convert our geometry parameters into a geometry string and specify it. GTK will itself handle calculating the real position this way. */ if (f->output_data.x->size_hint_flags & USPosition) { int left = f->output_data.x->left_pos; int xneg = f->output_data.x->size_hint_flags & XNegative; int top = f->output_data.x->top_pos; int yneg = f->output_data.x->size_hint_flags & YNegative; char geom_str[32]; if (xneg) left = -left; if (yneg) top = -top; sprintf (geom_str, "=%dx%d%c%d%c%d", PIXEL_WIDTH (f), PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f), (xneg ? '-' : '+'), left, (yneg ? '-' : '+'), top); if (!gtk_window_parse_geometry (GTK_WINDOW (wtop), geom_str)) fprintf (stderr, "Failed to parse: '%s'\n", geom_str); } gtk_widget_add_events (wfixed, GDK_POINTER_MOTION_MASK | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_KEY_PRESS_MASK | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_FOCUS_CHANGE_MASK | GDK_STRUCTURE_MASK | GDK_VISIBILITY_NOTIFY_MASK); /* Must realize the windows so the X window gets created. It is used by callers of this function. */ gtk_widget_realize (wfixed); FRAME_X_WINDOW (f) = GTK_WIDGET_TO_X_WIN (wfixed); /* Since GTK clears its window by filling with the background color, we must keep X and GTK background in sync. */ xg_pix2Gcolor (&bg, (f)->output_data.x->background_pixel); gdk_window_set_background (wfixed->window, &bg); /* GTK does not set any border, and they look bad with GTK. */ f->output_data.x->border_width = 0; f->output_data.x->internal_border_width = 0; UNBLOCK_INPUT; return 1; } /* Set the normal size hints for the window manager, for frame F. FLAGS is the flags word to use--or 0 meaning preserve the flags that the window now has. If USER_POSITION is nonzero, we set the User Position flag (this is useful when FLAGS is 0). */ void x_wm_set_size_hint (f, flags, user_position) FRAME_PTR f; long flags; int user_position; { if (FRAME_GTK_OUTER_WIDGET (f)) { /* Must use GTK routines here, otherwise GTK resets the size hints to its own defaults. */ GdkGeometry size_hints; gint hint_flags = 0; int base_width, base_height; int min_rows = 0, min_cols = 0; int win_gravity = f->output_data.x->win_gravity; if (flags) { memset (&size_hints, 0, sizeof (size_hints)); f->output_data.x->size_hints = size_hints; f->output_data.x->hint_flags = hint_flags; } else flags = f->output_data.x->size_hint_flags; size_hints = f->output_data.x->size_hints; hint_flags = f->output_data.x->hint_flags; hint_flags |= GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE; size_hints.width_inc = FONT_WIDTH (f->output_data.x->font); size_hints.height_inc = f->output_data.x->line_height; hint_flags |= GDK_HINT_BASE_SIZE; base_width = CHAR_TO_PIXEL_WIDTH (f, 0); base_height = CHAR_TO_PIXEL_HEIGHT (f, 0) + FRAME_MENUBAR_HEIGHT (f); check_frame_size (f, &min_rows, &min_cols); size_hints.base_width = base_width; size_hints.base_height = base_height; size_hints.min_width = base_width + min_cols * size_hints.width_inc; size_hints.min_height = base_height + min_rows * size_hints.height_inc; /* These currently have a one to one mapping with the X values, but I don't think we should rely on that. */ hint_flags |= GDK_HINT_WIN_GRAVITY; size_hints.win_gravity = 0; if (win_gravity == NorthWestGravity) size_hints.win_gravity = GDK_GRAVITY_NORTH_WEST; else if (win_gravity == NorthGravity) size_hints.win_gravity = GDK_GRAVITY_NORTH; else if (win_gravity == NorthEastGravity) size_hints.win_gravity = GDK_GRAVITY_NORTH_EAST; else if (win_gravity == WestGravity) size_hints.win_gravity = GDK_GRAVITY_WEST; else if (win_gravity == CenterGravity) size_hints.win_gravity = GDK_GRAVITY_CENTER; else if (win_gravity == EastGravity) size_hints.win_gravity = GDK_GRAVITY_EAST; else if (win_gravity == SouthWestGravity) size_hints.win_gravity = GDK_GRAVITY_SOUTH_WEST; else if (win_gravity == SouthGravity) size_hints.win_gravity = GDK_GRAVITY_SOUTH; else if (win_gravity == SouthEastGravity) size_hints.win_gravity = GDK_GRAVITY_SOUTH_EAST; else if (win_gravity == StaticGravity) size_hints.win_gravity = GDK_GRAVITY_STATIC; if (flags & PPosition) hint_flags |= GDK_HINT_POS; if (flags & USPosition) hint_flags |= GDK_HINT_USER_POS; if (flags & USSize) hint_flags |= GDK_HINT_USER_SIZE; if (user_position) { hint_flags &= ~GDK_HINT_POS; hint_flags |= GDK_HINT_USER_POS; } BLOCK_INPUT; gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), FRAME_GTK_OUTER_WIDGET (f), &size_hints, hint_flags); f->output_data.x->size_hints = size_hints; f->output_data.x->hint_flags = hint_flags; UNBLOCK_INPUT; } } /*********************************************************************** Initializing ***********************************************************************/ void xg_initialize () { xg_pass_through_events = FALSE; xg_ignore_gtk_scrollbar = 0; xg_ignore_next_thumb = 0; } #endif /* USE_GTK */