/* Functions for creating and updating GTK widgets.
-Copyright (C) 2003-2011 Free Software Foundation, Inc.
+Copyright (C) 2003-2012 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
#endif
+#if GTK_MAJOR_VERSION < 3 || \
+ (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION < 2)
+#define gtk_font_chooser_dialog_new(x, y) \
+ gtk_font_selection_dialog_new (x)
+#undef GTK_FONT_CHOOSER
+#define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
+#define gtk_font_chooser_set_font(x, y) \
+ gtk_font_selection_dialog_set_font_name (x, y)
+#define gtk_font_chooser_get_font(x) \
+ gtk_font_selection_dialog_get_font_name (x)
+#endif
+
#ifndef HAVE_GTK3
#ifdef USE_GTK_TOOLTIP
#define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
gdk_window_get_geometry (w, a, b, c, d, 0)
#define gdk_x11_window_lookup_for_display(d, w) \
gdk_xid_table_lookup_for_display (d, w)
+#define gtk_box_new(ori, spacing) \
+ ((ori) == GTK_ORIENTATION_HORIZONTAL \
+ ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
+#define gtk_scrollbar_new(ori, spacing) \
+ ((ori) == GTK_ORIENTATION_HORIZONTAL \
+ ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
#ifndef GDK_KEY_g
#define GDK_KEY_g GDK_g
#endif
-#endif
+#endif /* HAVE_GTK3 */
#define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
Returns non-zero if display could be opened, zero if display could not
be opened, and less than zero if the GTK version doesn't support
- multipe displays. */
+ multiple displays. */
void
xg_display_open (char *display_name, Display **dpy)
}
else
{
- wv = (widget_value *) xmalloc (sizeof (widget_value));
+ wv = xmalloc (sizeof *wv);
malloc_cpt++;
}
memset (wv, 0, sizeof (widget_value));
/* For the image defined in IMG, make and return a GtkImage. For displays with
8 planes or less we must make a GdkPixbuf and apply the mask manually.
- Otherwise the highlightning and dimming the tool bar code in GTK does
+ Otherwise the highlighting and dimming the tool bar code in GTK does
will look bad. For display with more than 8 planes we just use the
pixmap and mask directly. For monochrome displays, GTK doesn't seem
able to use external pixmaps, it looks bad whatever we do.
&bytes_written, &err))
&& err->code == G_CONVERT_ERROR_ILLEGAL_SEQUENCE)
{
- strncpy (up, (char *)p, bytes_written);
+ memcpy (up, p, bytes_written);
sprintf (up + bytes_written, "\\%03o", p[bytes_written]);
- up[bytes_written+4] = '\0';
up += bytes_written+4;
p += bytes_written+1;
g_error_free (err);
}
}
-/* Resize the outer window of frame F after chainging the height.
+/* Resize the outer window of frame F after changing the height.
COLUMNS/ROWS is the size the edit area shall have after the resize. */
void
{
GdkEvent event;
event.any.window = gdkwin;
+ event.any.type = GDK_NOTHING;
gwdesc = gtk_get_event_widget (&event);
}
GtkWidget *wtop;
GtkWidget *wvbox, *whbox;
GtkWidget *wfixed;
+#ifndef HAVE_GTK3
GtkRcStyle *style;
+#endif
char *title = 0;
BLOCK_INPUT;
if (FRAME_X_EMBEDDED_P (f))
- wtop = gtk_plug_new (f->output_data.x->parent_desc);
+ {
+ GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
+ wtop = gtk_plug_new_for_display (gdpy, f->output_data.x->parent_desc);
+ }
else
wtop = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+ /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
+ has backported it to Gtk+ 2.0 and they add the resize grip for
+ Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
+ forever, so disable the grip. */
+#if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
+ gtk_window_set_has_resize_grip (GTK_WINDOW (wtop), FALSE);
+#endif
+
xg_set_screen (wtop, f);
- wvbox = gtk_vbox_new (FALSE, 0);
- whbox = gtk_hbox_new (FALSE, 0);
+ wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ whbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (wvbox), FALSE);
+ gtk_box_set_homogeneous (GTK_BOX (whbox), FALSE);
#ifdef HAVE_GTK3
wfixed = emacs_fixed_new (f);
gtk_widget_set_name (wfixed, SSDATA (Vx_resource_name));
/* If this frame has a title or name, set it in the title bar. */
- if (! NILP (f->title)) title = SSDATA (ENCODE_UTF_8 (f->title));
- else if (! NILP (f->name)) title = SSDATA (ENCODE_UTF_8 (f->name));
+ if (! NILP (f->title))
+ title = SSDATA (ENCODE_UTF_8 (f->title));
+ else if (! NILP (f->name))
+ title = SSDATA (ENCODE_UTF_8 (f->name));
if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
hint_flags |= GDK_HINT_BASE_SIZE;
base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0) + FRAME_TOOLBAR_WIDTH (f);
- base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0)
+ /* Use one row here so base_height does not become zero.
+ Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
+ base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
+ FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
check_frame_size (f, &min_rows, &min_cols);
+ if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
size_hints.base_width = base_width;
size_hints.base_height = base_height;
/* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
the dialog, but return TRUE so the event does not propagate further
in GTK. This prevents GTK from destroying the dialog widget automatically
- and we can always destrou the widget manually, regardles of how
+ and we can always destroy the widget manually, regardless of how
it was popped down (button press or WM_DELETE_WINDOW).
W is the dialog widget.
EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
if (make_two_rows)
{
- GtkWidget *wvbox = gtk_vbox_new (TRUE, button_spacing);
- GtkWidget *whbox_up = gtk_hbox_new (FALSE, 0);
- whbox_down = gtk_hbox_new (FALSE, 0);
+ GtkWidget *wvbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, button_spacing);
+ GtkWidget *whbox_up = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (wvbox), TRUE);
+ gtk_box_set_homogeneous (GTK_BOX (whbox_up), FALSE);
+ whbox_down = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (whbox_down), FALSE);
gtk_box_pack_start (cur_box, wvbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (wvbox), whbox_up, FALSE, FALSE, 0);
{
struct xg_dialog_data *dd = (struct xg_dialog_data *) data;
EMACS_TIME next_time = timer_check ();
- long secs = EMACS_SECS (next_time);
- long usecs = EMACS_USECS (next_time);
dd->timerid = 0;
- if (secs >= 0 && usecs >= 0 && secs < ((guint)-1)/1000)
+ if (EMACS_TIME_VALID_P (next_time))
{
- dd->timerid = g_timeout_add (secs * 1000 + usecs/1000,
- xg_maybe_add_timer,
- dd);
+ time_t s = EMACS_SECS (next_time);
+ int per_ms = EMACS_TIME_RESOLUTION / 1000;
+ int ms = (EMACS_NSECS (next_time) + per_ms - 1) / per_ms;
+ if (s <= ((guint) -1 - ms) / 1000)
+ dd->timerid = g_timeout_add (s * 1000 + ms, xg_maybe_add_timer, dd);
}
return FALSE;
}
PROMPT is a prompt to show to the user. May not be NULL.
DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
If MUSTMATCH_P is non-zero, the returned file name must be an existing
- file. *FUNC is set to a function that can be used to retrieve the
- selected file name from the returned widget.
+ file. (Actually, this only has cosmetic effects, the user can
+ still enter a non-existing file.) *FUNC is set to a function that
+ can be used to retrieve the selected file name from the returned widget.
Returns the created widget. */
NULL);
gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin), TRUE);
- wbox = gtk_vbox_new (FALSE, 0);
+ wbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
gtk_widget_show (wbox);
wtoggle = gtk_check_button_new_with_label ("Show hidden files.");
sigblock (sigmask (__SIGRTMIN));
#endif /* HAVE_PTHREAD */
- w = gtk_font_selection_dialog_new ("Pick a font");
+ w = gtk_font_chooser_dialog_new
+ ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
+
if (!default_name)
default_name = "Monospace 10";
- gtk_font_selection_dialog_set_font_name (GTK_FONT_SELECTION_DIALOG (w),
- default_name);
+ gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w), default_name);
gtk_widget_set_name (w, "emacs-fontdialog");
done = xg_dialog_run (f, w);
#endif
if (done == GTK_RESPONSE_OK)
- fontname = gtk_font_selection_dialog_get_font_name
- (GTK_FONT_SELECTION_DIALOG (w));
+ fontname = gtk_font_chooser_get_font (GTK_FONT_CHOOSER (w));
gtk_widget_destroy (w);
return fontname;
{
if (! cl_data)
{
- cl_data = (xg_menu_cb_data*) xmalloc (sizeof (*cl_data));
+ cl_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;
GtkWidget *wkey;
GtkWidget *wbox;
- wbox = gtk_hbox_new (FALSE, 0);
+ wbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+ gtk_box_set_homogeneous (GTK_BOX (wbox), FALSE);
wlbl = gtk_label_new (utf8_label);
wkey = gtk_label_new (utf8_key);
/* Create a menu item widget, and connect the callbacks.
- ITEM decribes the menu item.
+ ITEM describes the menu item.
F is the frame the created menu belongs to.
SELECT_CB is the callback to use when a menu item is selected.
HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
if (utf8_label) g_free (utf8_label);
if (utf8_key) g_free (utf8_key);
- cb_data = xmalloc (sizeof (xg_menu_item_cb_data));
+ cb_data = xmalloc (sizeof *cb_data);
xg_list_insert (&xg_menu_item_cb_list, &cb_data->ptrs);
HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
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.
- ADD_TEAROFF_P is non-zero if we shall add a teroff menu item. Ignored
+ ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
if MENU_BAR_P is non-zero.
TOPMENU is the topmost GtkWidget that others shall be placed under.
It may be NULL, in that case we create the appropriate widget
utf8_key = get_utf8_string (val->key);
/* See if W is a menu item with a key. See make_menu_item above. */
- if (GTK_IS_HBOX (wchild))
+ if (GTK_IS_BOX (wchild))
{
GList *list = gtk_container_get_children (GTK_CONTAINER (wchild));
}
}
- /* Remove widgets from first structual change. */
+ /* Remove widgets from first structural change. */
if (iter)
{
/* If we are adding new menu items below, we must remove from
gw = gdk_x11_window_lookup_for_display (gdpy, event->xbutton.window);
if (! gw) return 0;
gevent.any.window = gw;
+ gevent.any.type = GDK_NOTHING;
gwdesc = gtk_get_event_widget (&gevent);
if (! gwdesc) return 0;
if (! GTK_IS_MENU_BAR (gwdesc)
int w = 0, b = 0;
vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX, 0.1, 0.1, 0.1);
- wscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj));
+ wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
g_object_ref_sink (G_OBJECT (wscroll));
gtk_widget_style_get (wscroll, "slider-width", &w, "trough-border", &b, NULL);
gtk_widget_destroy (wscroll);
vadj = gtk_adjustment_new (XG_SB_MIN, XG_SB_MIN, XG_SB_MAX,
0.1, 0.1, 0.1);
- wscroll = gtk_vscrollbar_new (GTK_ADJUSTMENT (vadj));
+ wscroll = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, GTK_ADJUSTMENT (vadj));
webox = gtk_event_box_new ();
gtk_widget_set_name (wscroll, scroll_bar_name);
#ifndef HAVE_GTK3
{
/* Check if press occurred outside the edit widget. */
GdkDisplay *gdpy = gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f));
- retval = gdk_display_get_window_at_pointer (gdpy, NULL, NULL)
- != gtk_widget_get_window (f->output_data.x->edit_widget);
+ GdkWindow *gwin;
+#ifdef HAVE_GTK3
+ GdkDevice *gdev = gdk_device_manager_get_client_pointer
+ (gdk_display_get_device_manager (gdpy));
+ gwin = gdk_device_get_window_at_position (gdev, NULL, NULL);
+#else
+ gwin = gdk_display_get_window_at_pointer (gdpy, NULL, NULL);
+#endif
+ retval = gwin != gtk_widget_get_window (f->output_data.x->edit_widget);
}
else if (f
&& ((event->type == ButtonRelease && event->xbutton.button < 4)
xg_create_tool_bar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
+#if GTK_CHECK_VERSION (3, 3, 6)
+ GtkStyleContext *gsty;
+#endif
x->toolbar_widget = gtk_toolbar_new ();
x->toolbar_detached = 0;
gtk_toolbar_set_style (GTK_TOOLBAR (x->toolbar_widget), GTK_TOOLBAR_ICONS);
toolbar_set_orientation (x->toolbar_widget, GTK_ORIENTATION_HORIZONTAL);
+#if GTK_CHECK_VERSION (3, 3, 6)
+ gsty = gtk_widget_get_style_context (x->toolbar_widget);
+ gtk_style_context_add_class (gsty, "primary-toolbar");
+#endif
}
int i, int horiz, int text_image)
{
GtkToolItem *ti = gtk_tool_item_new ();
- GtkWidget *vb = horiz ? gtk_hbox_new (FALSE, 0) : gtk_vbox_new (FALSE, 0);
+ GtkWidget *vb = gtk_box_new (horiz
+ ? GTK_ORIENTATION_HORIZONTAL
+ : GTK_ORIENTATION_VERTICAL,
+ 0);
GtkWidget *wb = gtk_button_new ();
/* The eventbox is here so we can have tooltips on disabled items. */
GtkWidget *weventbox = gtk_event_box_new ();
+#if GTK_CHECK_VERSION (3, 3, 6)
+ GtkCssProvider *css_prov = gtk_css_provider_new ();
+ GtkStyleContext *gsty;
+
+ gtk_css_provider_load_from_data (css_prov,
+ "GtkEventBox {"
+ " background-color: transparent;"
+ "}",
+ -1, NULL);
+
+ gsty = gtk_widget_get_style_context (weventbox);
+ gtk_style_context_add_provider (gsty,
+ GTK_STYLE_PROVIDER (css_prov),
+ GTK_STYLE_PROVIDER_PRIORITY_USER);
+ g_object_unref (css_prov);
+#endif
+
+ gtk_box_set_homogeneous (GTK_BOX (vb), FALSE);
if (wimage && !text_image)
gtk_box_pack_start (GTK_BOX (vb), wimage, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (weventbox), wb);
gtk_container_add (GTK_CONTAINER (ti), weventbox);
- if (wimage)
+ if (wimage || label)
{
intptr_t ii = i;
gpointer gi = (gpointer) ii;
#endif
gtk_tool_item_set_homogeneous (ti, FALSE);
- /* Callback to save modifyer mask (Shift/Control, etc). GTK makes
+ /* Callback to save modifier mask (Shift/Control, etc). GTK makes
no distinction based on modifiers in the activate callback,
so we have to do it ourselves. */
g_signal_connect (wb, "button-release-event",
return ti;
}
+static int
+is_box_type (GtkWidget *vb, int is_horizontal)
+{
+#ifdef HAVE_GTK3
+ int ret = 0;
+ if (GTK_IS_BOX (vb))
+ {
+ GtkOrientation ori = gtk_orientable_get_orientation (GTK_ORIENTABLE (vb));
+ ret = (ori == GTK_ORIENTATION_HORIZONTAL && is_horizontal)
+ || (ori == GTK_ORIENTATION_VERTICAL && ! is_horizontal);
+ }
+ return ret;
+#else
+ return is_horizontal ? GTK_IS_VBOX (vb) : GTK_IS_HBOX (vb);
+#endif
+}
+
+
static int
xg_tool_item_stale_p (GtkWidget *wbutton, const char *stock_name,
const char *icon_name, const struct image *img,
GtkWidget *wlbl = xg_get_tool_bar_widgets (vb, &wimage);
/* Check if the tool icon matches. */
- if (stock_name)
+ if (stock_name && wimage)
{
old = g_object_get_data (G_OBJECT (wimage),
XG_TOOL_BAR_STOCK_NAME);
if (!old || strcmp (old, stock_name))
return 1;
}
- else if (icon_name)
+ else if (icon_name && wimage)
{
old = g_object_get_data (G_OBJECT (wimage),
XG_TOOL_BAR_ICON_NAME);
if (!old || strcmp (old, icon_name))
return 1;
}
- else
+ else if (wimage)
{
gpointer gold_img = g_object_get_data (G_OBJECT (wimage),
- XG_TOOL_BAR_IMAGE_DATA);
+ XG_TOOL_BAR_IMAGE_DATA);
Pixmap old_img = (Pixmap) gold_img;
if (old_img != img->pixmap)
return 1;
}
/* Check button configuration and label. */
- if ((horiz ? GTK_IS_VBOX (vb) : GTK_IS_HBOX (vb))
+ if (is_box_type (vb, horiz)
|| (label ? (wlbl == NULL) : (wlbl != NULL)))
return 1;
/* Ensure label is correct. */
- if (label)
+ if (label && wlbl)
gtk_label_set_text (GTK_LABEL (wlbl), label);
return 0;
}
? TOOL_BAR_IMAGE_DISABLED_SELECTED
: TOOL_BAR_IMAGE_DISABLED_DESELECTED);
- xassert (ASIZE (image) >= idx);
+ eassert (ASIZE (image) >= idx);
image = AREF (image, idx);
}
else
xg_initialize (void)
{
GtkBindingSet *binding_set;
+ GtkSettings *settings;
#if HAVE_XFT
/* Work around a bug with corrupted data if libXft gets unloaded. This way
id_to_widget.max_size = id_to_widget.used = 0;
id_to_widget.widgets = 0;
+ settings = gtk_settings_get_for_screen (gdk_display_get_default_screen
+ (gdk_display_get_default ()));
/* Remove F10 as a menu accelerator, it does not mix well with Emacs key
bindings. It doesn't seem to be any way to remove properties,
so we set it to VoidSymbol which in X means "no key". */
- gtk_settings_set_string_property (gtk_settings_get_default (),
+ gtk_settings_set_string_property (settings,
"gtk-menu-bar-accel",
"VoidSymbol",
EMACS_CLASS);
/* Make GTK text input widgets use Emacs style keybindings. This is
Emacs after all. */
- gtk_settings_set_string_property (gtk_settings_get_default (),
+ gtk_settings_set_string_property (settings,
"gtk-key-theme-name",
"Emacs",
EMACS_CLASS);
HCoop / bpt / emacs.git / blobdiff