#include "atimer.h"
#include "gtkutil.h"
#include "termhooks.h"
+#include "keyboard.h"
+#include "charset.h"
+#include "coding.h"
#include <gdk/gdkkeysyms.h>
#define FRAME_TOTAL_PIXEL_HEIGHT(f) \
- (PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
-
-
-/* Key to save a struct xg_last_sb_pos in the scroll bars. */
-#define XG_LAST_SB_POS "emacs_last_sb_pos"
-
-
-/* Use this in scroll bars to keep track of when redraw is really needed. */
-struct xg_last_sb_pos
-{
- int portion, position, whole;
-};
+ (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
\f
/* Start the xg_timer with an interval of 0.1 seconds, if not already started.
xg_process_timeouts is called when the timer expires. The timer
- stared is continuous, i.e. runs until xg_stop_timer is called. */
+ started is continuous, i.e. runs until xg_stop_timer is called. */
static void
xg_start_timer ()
{
xg_set_geometry (f)
FRAME_PTR f;
{
- if (f->output_data.x->size_hint_flags & USPosition)
+ if (f->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;
+ int left = f->left_pos;
+ int xneg = f->size_hint_flags & XNegative;
+ int top = f->top_pos;
+ int yneg = f->size_hint_flags & YNegative;
char geom_str[32];
if (xneg)
top = -top;
sprintf (geom_str, "=%dx%d%c%d%c%d",
- PIXEL_WIDTH (f),
+ FRAME_PIXEL_WIDTH (f),
FRAME_TOTAL_PIXEL_HEIGHT (f),
(xneg ? '-' : '+'), left,
(yneg ? '-' : '+'), top);
int rows;
{
gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
- PIXEL_WIDTH (f), FRAME_TOTAL_PIXEL_HEIGHT (f));
+ FRAME_PIXEL_WIDTH (f), FRAME_TOTAL_PIXEL_HEIGHT (f));
/* base_height is now changed. */
x_wm_set_size_hint (f, 0, 0);
gdk_window_process_all_updates ();
}
-/* When the Emacs frame is resized, we must call this function for each
- child of our GtkFixed widget. The children are scroll bars and
- we invalidate the last position data here so it will be properly
- redrawn later when xg_update_scrollbar_pos is called.
- W is the child widget.
- CLIENT_DATA is not used. */
-static handle_fixed_child (w, client_data)
- GtkWidget *w;
- gpointer client_data;
-{
- struct xg_last_sb_pos *last_pos
- = g_object_get_data (G_OBJECT (w), XG_LAST_SB_POS);
- if (last_pos)
- {
- last_pos->portion = last_pos->position = last_pos->whole = .1;
- }
-}
-
/* This gets called after the frame F has been cleared. Since that is
done with X calls, we need to redraw GTK widget (scroll bars). */
void
xg_frame_cleared (f)
FRAME_PTR f;
{
- GtkWidget *wfixed = f->output_data.x->edit_widget;
+ GtkWidget *w = f->output_data.x->widget;
- if (wfixed)
+ if (w)
{
- gtk_container_foreach (GTK_CONTAINER (wfixed),
- (GtkCallback) handle_fixed_child,
- NULL);
- gtk_container_set_reallocate_redraws (GTK_CONTAINER (wfixed), TRUE);
+ gtk_container_set_reallocate_redraws (GTK_CONTAINER (w), TRUE);
+ gtk_container_foreach (GTK_CONTAINER (w),
+ (GtkCallback) gtk_widget_queue_draw,
+ 0);
gdk_window_process_all_updates ();
}
}
{
int mbheight = FRAME_MENUBAR_HEIGHT (f);
int tbheight = FRAME_TOOLBAR_HEIGHT (f);
- int rows = PIXEL_TO_CHAR_HEIGHT (f, pixelheight - mbheight - tbheight);
- int columns = PIXEL_TO_CHAR_WIDTH (f, pixelwidth);
+ int rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, (pixelheight
+ - mbheight - tbheight));
+ int columns = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixelwidth);
if (FRAME_GTK_WIDGET (f)
- && (columns != FRAME_WIDTH (f) || rows != FRAME_HEIGHT (f)
- || pixelwidth != PIXEL_WIDTH (f) || pixelheight != PIXEL_HEIGHT (f)))
+ && (columns != FRAME_COLS (f) || rows != FRAME_LINES (f)
+ || pixelwidth != FRAME_PIXEL_WIDTH (f) || pixelheight != FRAME_PIXEL_HEIGHT (f)))
{
struct x_output *x = f->output_data.x;
GtkAllocation all;
gtk_widget_size_allocate (x->edit_widget, &all);
- xg_frame_cleared (f);
-
change_frame_size (f, rows, columns, 0, 1, 0);
SET_FRAME_GARBAGED (f);
cancel_mouse_face (f);
int cols;
int rows;
{
- int pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows)
+ int pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows)
+ FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
- int pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
+ int pixelwidth;
/* Take into account the size of the scroll bar. 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)));
+ f->scroll_bar_actual_width
+ = FRAME_SCROLL_BAR_COLS (f) * FRAME_COLUMN_WIDTH (f);
compute_fringe_widths (f, 0);
+ /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
+ after calculating that value. */
+ pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, cols);
+
/* 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);
+
+ SET_FRAME_GARBAGED (f);
+ cancel_mouse_face (f);
}
/* Convert an X Window WSESC to its corresponding GtkWidget.
gdk_colormap_query_color (map, pixel, c);
}
+/* Turning off double buffering for our GtkFixed widget has the side
+ effect of turning it off also for its children (scroll bars).
+ But we want those to be double buffered to not flicker so handle
+ expose manually here.
+ WIDGET is the GtkFixed widget that gets exposed.
+ EVENT is the expose event.
+ USER_DATA is unused.
+
+ Return TRUE to tell GTK that this expose event has been fully handeled
+ and that GTK shall do nothing more with it. */
+static gboolean
+xg_fixed_handle_expose(GtkWidget *widget,
+ GdkEventExpose *event,
+ gpointer user_data)
+{
+ GList *iter;
+
+ for (iter = GTK_FIXED (widget)->children; iter; iter = g_list_next (iter))
+ {
+ GtkFixedChild *child_data = (GtkFixedChild *) iter->data;
+ GtkWidget *child = child_data->widget;
+ GdkWindow *window = child->window;
+ GdkRegion *region = gtk_widget_region_intersect (child, event->region);
+
+ if (! gdk_region_empty (region))
+ {
+ GdkEvent child_event;
+ child_event.expose = *event;
+ child_event.expose.region = region;
+
+ /* Turn on double buffering, i.e. draw to an off screen area. */
+ gdk_window_begin_paint_region (window, region);
+
+ /* Tell child to redraw itself. */
+ gdk_region_get_clipbox (region, &child_event.expose.area);
+ gtk_widget_send_expose (child, &child_event);
+ gdk_window_process_updates (window, TRUE);
+
+ /* Copy off screen area to the window. */
+ gdk_window_end_paint (window);
+ }
+
+ gdk_region_destroy (region);
+ }
+
+ return TRUE;
+}
+
/* Create and set up the GTK widgets for frame F.
Return 0 if creation failed, non-zero otherwise. */
int
gtk_widget_set_name (wfixed, SDATA (Vx_resource_name));
/* If this frame has a title or name, set it in the title bar. */
- if (! NILP (f->title)) title = SDATA (f->title);
- else if (! NILP (f->name)) title = SDATA (f->name);
+ if (! NILP (f->title)) title = SDATA (ENCODE_UTF_8 (f->title));
+ else if (! NILP (f->name)) title = SDATA (ENCODE_UTF_8 (f->name));
if (title) gtk_window_set_title (GTK_WINDOW (wtop), title);
gtk_fixed_set_has_window (GTK_FIXED (wfixed), TRUE);
- gtk_widget_set_size_request (wfixed,
- PIXEL_WIDTH (f),
- PIXEL_HEIGHT (f));
+ gtk_widget_set_size_request (wfixed, FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f));
gtk_container_add (GTK_CONTAINER (wtop), wvbox);
gtk_box_pack_end (GTK_BOX (wvbox), wfixed, TRUE, TRUE, 0);
if (FRAME_EXTERNAL_TOOL_BAR (f) && FRAME_TOOLBAR_HEIGHT (f) == 0)
FRAME_TOOLBAR_HEIGHT (f) = 34;
- gtk_widget_set_double_buffered (wvbox, FALSE);
+
+ /* We don't want this widget double buffered, because we draw on it
+ with regular X drawing primitives, so from a GTK/GDK point of
+ view, the widget is totally blank. When an expose comes, this
+ will make the widget blank, and then Emacs redraws it. This flickers
+ a lot, so we turn off double buffering. */
gtk_widget_set_double_buffered (wfixed, FALSE);
- gtk_widget_set_double_buffered (wtop, FALSE);
+
+ /* Turning off double buffering above has the side effect of turning
+ it off also for its children (scroll bars). But we want those
+ to be double buffered to not flicker so handle expose manually. */
+ g_signal_connect (G_OBJECT (wfixed), "expose-event",
+ G_CALLBACK (xg_fixed_handle_expose), 0);
/* GTK documents says use gtk_window_set_resizable. But then a user
can't shrink the window from its starting size. */
gtk_widget_modify_style (wfixed, style);
/* 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;
+ f->border_width = 0;
+ f->internal_border_width = 0;
UNBLOCK_INPUT;
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;
+ int win_gravity = f->win_gravity;
if (flags)
{
f->output_data.x->hint_flags = hint_flags;
}
else
- flags = f->output_data.x->size_hint_flags;
+ flags = f->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;
+ size_hints.width_inc = FRAME_COLUMN_WIDTH (f);
+ size_hints.height_inc = FRAME_LINE_HEIGHT (f);
hint_flags |= GDK_HINT_BASE_SIZE;
- base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
- base_height = CHAR_TO_PIXEL_HEIGHT (f, 0)
+ base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0);
+ base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 0)
+ FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
check_frame_size (f, &min_rows, &min_cols);
else
{
/* This is one button to add to the dialog. */
- w = gtk_button_new_with_mnemonic (utf8_label);
+ w = gtk_button_new_with_label (utf8_label);
if (! item->enabled)
gtk_widget_set_sensitive (w, FALSE);
if (select_cb)
GtkWidget *wbox;
wbox = gtk_hbox_new (FALSE, 0);
- wlbl = gtk_label_new_with_mnemonic (utf8_label);
+ wlbl = gtk_label_new (utf8_label);
wkey = gtk_label_new (utf8_key);
gtk_misc_set_alignment (GTK_MISC (wlbl), 0.0, 0.5);
gtk_widget_set_name (wlbl, MENU_ITEM_NAME);
gtk_widget_set_name (wkey, MENU_ITEM_NAME);
+ gtk_widget_set_name (wbox, MENU_ITEM_NAME);
return wbox;
}
GtkWidget *w;
GtkWidget *wtoadd = 0;
+ /* It has been observed that some menu items have a NULL name field.
+ This will lead to this function being called with a NULL utf8_label.
+ GTK crashes on that so we set a blank label. Why there is a NULL
+ name remains to be investigated. */
+ if (! utf8_label) utf8_label = " ";
+
if (utf8_key)
wtoadd = make_widget_for_menu_item (utf8_label, utf8_key);
{
*group = NULL;
if (utf8_key) w = gtk_check_menu_item_new ();
- else w = gtk_check_menu_item_new_with_mnemonic (utf8_label);
+ else w = gtk_check_menu_item_new_with_label (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);
+ else w = gtk_radio_menu_item_new_with_label (*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);
{
*group = NULL;
if (utf8_key) w = gtk_menu_item_new ();
- else w = gtk_menu_item_new_with_mnemonic (utf8_label);
+ else w = gtk_menu_item_new_with_label (utf8_label);
}
if (wtoadd) gtk_container_add (GTK_CONTAINER (w), wtoadd);
return w;
}
-/* Return non-zero if NAME specifies a separator (GTK only has one
+/* Return non-zero if LABEL specifies a separator (GTK only has one
separator type) */
static int
-xg_separator_p (char *name)
+xg_separator_p (char *label)
{
- if (! name) return 0;
+ if (! label) return 0;
+ else if (strlen (label) > 3
+ && strncmp (label, "--", 2) == 0
+ && label[2] != '-')
+ {
+ static char* separator_names[] = {
+ "space",
+ "no-line",
+ "single-line",
+ "double-line",
+ "single-dashed-line",
+ "double-dashed-line",
+ "shadow-etched-in",
+ "shadow-etched-out",
+ "shadow-etched-in-dash",
+ "shadow-etched-out-dash",
+ "shadow-double-etched-in",
+ "shadow-double-etched-out",
+ "shadow-double-etched-in-dash",
+ "shadow-double-etched-out-dash",
+ 0,
+ };
+
+ int i;
+
+ label += 2;
+ for (i = 0; separator_names[i]; ++i)
+ if (strcmp (label, separator_names[i]) == 0)
+ return 1;
+ }
+ else
+ {
+ /* Old-style separator, maybe. It's a separator if it contains
+ only dashes. */
+ while (*label == '-')
+ ++label;
+ if (*label == 0) return 1;
+ }
- return strcmp (name, "--") == 0
- || strncmp (name, "--:", 3) == 0
- || strcmp (name, "---") == 0;
+ return 0;
}
GtkWidget *xg_did_tearoff;
G_CALLBACK (tearoff_remove), menu);
}
-int xg_debug = 0;
-
/* Create a menu item widget, and connect the callbacks.
ITEM decribes the menu item.
F is the frame the created menu belongs to.
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);
+ w = gtk_menu_item_new_with_label (utf8_label);
gtk_widget_set_sensitive (w, FALSE);
if (utf8_label && utf8_label != item->name) g_free (utf8_label);
}
GtkLabel *wlabel = GTK_LABEL (gtk_bin_get_child (GTK_BIN (witem)));
char *utf8_label = get_utf8_string (val->name);
- gtk_label_set_text_with_mnemonic (wlabel, utf8_label);
+ gtk_label_set_text (wlabel, utf8_label);
iter = g_list_next (iter);
val = val->next;
gtk_label_set_text (wkey, utf8_key);
if (! old_label || strcmp (utf8_label, old_label) != 0)
- gtk_label_set_text_with_mnemonic (wlbl, utf8_label);
+ gtk_label_set_text (wlbl, utf8_label);
if (utf8_key && utf8_key != val->key) g_free (utf8_key);
if (utf8_label && utf8_label != val->name) g_free (utf8_label);
/* The height has changed, resize outer widget and set columns
rows to what we had before adding the menu bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
SET_FRAME_GARBAGED (f);
UNBLOCK_INPUT;
/* The height has changed, resize outer widget and set columns
rows to what we had before removing the menu bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
SET_FRAME_GARBAGED (f);
UNBLOCK_INPUT;
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
p = g_object_get_data (G_OBJECT (widget), XG_LAST_SB_DATA);
if (p) xfree (p);
- p = g_object_get_data (G_OBJECT (widget), XG_LAST_SB_POS);
- if (p) xfree (p);
xg_remove_widget_from_map (id);
}
/* Callback for button press/release events. Used to start timer so that
the scroll bar repetition timer in GTK gets handeled.
+ Also, sets bar->dragging to Qnil when dragging (button release) is done.
WIDGET is the scroll bar widget the event is for (not used).
EVENT contains the event.
- USER_DATA is 0 (not used).
+ USER_DATA points to the struct scrollbar structure.
Returns FALSE to tell GTK that it shall continue propagate the event
to widgets. */
{
if (event->type == GDK_BUTTON_PRESS && ! xg_timer)
xg_start_timer ();
- else if (event->type == GDK_BUTTON_RELEASE && xg_timer)
- xg_stop_timer ();
-
+ else if (event->type == GDK_BUTTON_RELEASE)
+ {
+ struct scroll_bar *bar = (struct scroll_bar *) user_data;
+ if (xg_timer) xg_stop_timer ();
+ bar->dragging = Qnil;
+ }
+
return FALSE;
}
scroll_id = xg_store_widget_in_map (wscroll);
- g_signal_connect (G_OBJECT (vadj),
+ g_signal_connect (G_OBJECT (wscroll),
"value-changed",
scroll_callback,
- (gpointer)bar);
+ (gpointer) bar);
g_signal_connect (G_OBJECT (wscroll),
"destroy",
G_CALLBACK (xg_gtk_scroll_destroy),
- (gpointer)scroll_id);
+ (gpointer) scroll_id);
/* Connect to button press and button release to detect if any scroll bar
has the pointer. */
g_signal_connect (G_OBJECT (wscroll),
"button-press-event",
G_CALLBACK (scroll_bar_button_cb),
- 0);
+ (gpointer) bar);
g_signal_connect (G_OBJECT (wscroll),
"button-release-event",
G_CALLBACK (scroll_bar_button_cb),
- 0);
+ (gpointer) bar);
gtk_fixed_put (GTK_FIXED (f->output_data.x->edit_widget),
- wscroll, 0, 0);
+ wscroll, -1, -1);
/* Set the cursor to an arrow. */
xg_set_cursor (wscroll, &xg_left_ptr_cursor);
- /* Allocate a place to hold the last scollbar size. GTK redraw for
- scroll bars is basically clear all, and then redraw. This flickers
- a lot since xg_update_scrollbar_pos gets called on every cursor move
- and a lot more places. So we have this to check if a redraw really
- is needed. */
- struct xg_last_sb_pos *last_pos
- = (struct xg_last_sb_pos *) xmalloc (sizeof (struct xg_last_sb_pos));
- last_pos->portion = last_pos->position = last_pos->whole = -1;
- g_object_set_data (G_OBJECT (wscroll), XG_LAST_SB_POS, last_pos);
-
SET_SCROLL_BAR_X_WINDOW (bar, scroll_id);
}
}
}
+/* Find left/top for widget W in GtkFixed widget WFIXED. */
+static void
+xg_find_top_left_in_fixed (w, wfixed, left, top)
+ GtkWidget *w, *wfixed;
+ int *left, *top;
+{
+ GList *iter;
+
+ for (iter = GTK_FIXED (wfixed)->children; iter; iter = g_list_next (iter))
+ {
+ GtkFixedChild *child = (GtkFixedChild *) iter->data;
+
+ if (child->widget == w)
+ {
+ *left = child->x;
+ *top = child->y;
+ return;
+ }
+ }
+
+ /* Shall never end up here. */
+ abort ();
+}
/* Update the position of the vertical scroll bar 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)
+xg_update_scrollbar_pos (f, scrollbar_id, top, left, width, height,
+ real_left, canon_width)
FRAME_PTR f;
int scrollbar_id;
int top;
if (wscroll)
{
- int gheight = max (height, 1);
- struct xg_last_sb_pos *last_pos
- = g_object_get_data (G_OBJECT (wscroll), XG_LAST_SB_POS);
GtkWidget *wfixed = f->output_data.x->edit_widget;
+ int winextra = canon_width > width ? (canon_width - width) / 2 : 0;
+ int bottom = top + height;
- last_pos->portion = last_pos->position = last_pos->whole = -1;
- xg_ignore_next_thumb = 0;
-
- gtk_fixed_move (GTK_FIXED (wfixed), wscroll, left, top);
- gtk_widget_set_size_request (wscroll, width, gheight);
+ gint slider_width;
+ int oldtop, oldleft, oldbottom;
+ GtkRequisition req;
- gtk_container_set_reallocate_redraws (GTK_CONTAINER (wfixed), TRUE);
+ /* Get old values. */
+ xg_find_top_left_in_fixed (wscroll, wfixed, &oldleft, &oldtop);
+ gtk_widget_size_request (wscroll, &req);
+ oldbottom = oldtop + req.height;
+
+ /* Scroll bars in GTK has a fixed width, so if we say width 16, it
+ will only be its fixed width (14 is default) anyway, the rest is
+ blank. We are drawing the mode line across scroll bars when
+ the frame is split:
+ |bar| |fringe|
+ ----------------
+ mode line
+ ----------------
+ |bar| |fringe|
+
+ When we "unsplit" the frame:
+
+ |bar| |fringe|
+ -| |-| |
+ m¦ |i| |
+ -| |-| |
+ | | | |
+
+
+ the remains of the mode line can be seen in these blank spaces.
+ So we must clear them explicitly.
+ GTK scroll bars should do that, but they don't.
+ Also, the canonical width may be wider than the width for the
+ scroll bar so that there is some space (typically 1 pixel) between
+ the scroll bar and the edge of the window and between the scroll
+ bar and the fringe. */
+
+ if (oldtop != -1 && oldleft != -1)
+ {
+ int gtkextral, gtkextrah;
+ int xl, xr, wbl, wbr;
+ int bottomdiff, topdiff;
+
+ gtk_widget_style_get (wscroll, "slider_width", &slider_width, NULL);
+ gtkextral = width > slider_width ? (width - slider_width) / 2 : 0;
+ gtkextrah = gtkextral ? (width - slider_width - gtkextral) : 0;
+
+ xl = real_left;
+ wbl = gtkextral + winextra;
+ wbr = gtkextrah + winextra;
+ xr = left + gtkextral + slider_width;
+ bottomdiff = abs (oldbottom - bottom);
+ topdiff = abs (oldtop - top);
+
+ if (oldleft != left)
+ {
+ gdk_window_clear_area (wfixed->window, xl, top, wbl, height);
+ gdk_window_clear_area (wfixed->window, xr, top, wbr, height);
+ }
- /* Must force out update so wscroll gets the resize.
- Otherwise, the gdk_window_clear clears the old window size. */
- gdk_window_process_all_updates ();
+ if (oldtop > top)
+ {
+ gdk_window_clear_area (wfixed->window, xl, top, wbl, topdiff);
+ gdk_window_clear_area (wfixed->window, xr, top, wbr, topdiff);
+ }
+ else if (oldtop < top)
+ {
+ gdk_window_clear_area (wfixed->window, xl, oldtop, wbl, topdiff);
+ gdk_window_clear_area (wfixed->window, xr, oldtop, wbr, topdiff);
+ }
- /* The scroll bar doesn't explicitly redraw the whole window
- when a resize occurs. Since the scroll bar seems to be fixed
- in width it doesn't fill the space reserved, so we must clear
- the whole window. */
- gdk_window_clear (wscroll->window);
+ if (oldbottom > bottom)
+ {
+ gdk_window_clear_area (wfixed->window, xl, bottom, wbl,
+ bottomdiff);
+ gdk_window_clear_area (wfixed->window, xr, bottom, wbr,
+ bottomdiff);
+ }
+ else if (oldbottom < bottom)
+ {
+ gdk_window_clear_area (wfixed->window, xl, oldbottom, wbl,
+ bottomdiff);
+ gdk_window_clear_area (wfixed->window, xr, oldbottom, wbr,
+ bottomdiff);
+ }
+ }
- /* Since we are not using a pure gtk event loop, we must force out
- pending update events with this call. */
+ /* Move and resize to new values. */
+ gtk_fixed_move (GTK_FIXED (wfixed), wscroll, left, top);
+ gtk_widget_set_size_request (wscroll, width, height);
+
+ /* Must force out update so changed scroll bars gets redrawn. */
gdk_window_process_all_updates ();
SET_FRAME_GARBAGED (f);
GtkWidget *wscroll = xg_get_widget_from_map (SCROLL_BAR_X_WINDOW (bar));
FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
- struct xg_last_sb_pos *last_pos
- = (wscroll ? g_object_get_data (G_OBJECT (wscroll), XG_LAST_SB_POS) : 0);
- BLOCK_INPUT;
- if (wscroll
- && ! xg_ignore_next_thumb
- && last_pos
- && (last_pos->portion != portion
- || last_pos->position != position
- || last_pos->whole != whole))
+ if (wscroll && NILP (bar->dragging))
{
GtkAdjustment *adj;
gdouble shown;
gdouble top;
int size, value;
+ int new_step;
+ int changed = 0;
adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
+ /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
+ rather than the real portion value. This makes the thumb less likely
+ to resize and that looks better. */
+ portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
+ /* When the thumb is at the bottom, position == whole.
+ So we need to increase `whole' to make space for the thumb. */
+ whole += portion;
+
if (whole <= 0)
top = 0, shown = 1;
else
{
- shown = (gdouble) portion / whole;
top = (gdouble) position / whole;
+ shown = (gdouble) portion / whole;
}
- size = shown * whole;
- size = min (size, whole);
+ size = shown * XG_SB_RANGE;
+ size = min (size, XG_SB_RANGE);
size = max (size, 1);
- value = top * whole;
- value = min (value, whole - size);
+ value = top * XG_SB_RANGE;
+ value = min (value, XG_SB_MAX - size);
value = max (value, XG_SB_MIN);
- adj->upper = max (whole, size);
- 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));
+ /* Assume all lines are of equal size. */
+ new_step = size / max (1, FRAME_LINES (f));
- if (last_pos)
+ if ((int) adj->page_size != size
+ || (int) adj->step_increment != new_step)
{
- last_pos->portion = portion;
- last_pos->position = position;
- last_pos->whole = whole;
+ adj->page_size = size;
+ adj->step_increment = new_step;
+ /* Assume a page increment is about 95% of the page size */
+ adj->page_increment = (int) (0.95*adj->page_size);
+ changed = 1;
}
- /* 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;
+ if (changed || (int) gtk_range_get_value (GTK_RANGE (wscroll)) != value)
+ {
+ GtkWidget *wfixed = f->output_data.x->edit_widget;
- /* Make sure the scroll bar is redrawn with new thumb */
- gtk_widget_queue_draw (wscroll);
- }
+ BLOCK_INPUT;
- gdk_window_process_all_updates ();
- xg_ignore_next_thumb = 0;
- UNBLOCK_INPUT;
+ /* gtk_range_set_value invokes the callback. Set
+ ignore_gtk_scrollbar to make the callback do nothing */
+ xg_ignore_gtk_scrollbar = 1;
+
+ if ((int) gtk_range_get_value (GTK_RANGE (wscroll)) != value)
+ gtk_range_set_value (GTK_RANGE (wscroll), (gdouble)value);
+ else if (changed)
+ gtk_adjustment_changed (adj);
+
+ xg_ignore_gtk_scrollbar = 0;
+
+ UNBLOCK_INPUT;
+ }
+ }
}
\f
FRAME_PTR f = (FRAME_PTR) g_object_get_data (G_OBJECT (w), XG_FRAME_DATA);
Lisp_Object key, frame;
struct input_event event;
+ EVENT_INIT (event);
if (! f || ! f->n_tool_bar_items || NILP (f->tool_bar_items))
return;
/* The height has changed, resize outer widget and set columns
rows to what we had before detaching the tool bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
}
}
/* The height has changed, resize outer widget and set columns
rows to what we had before detaching the tool bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
}
}
GdkEventExpose *event;
gpointer client_data;
{
- event->area.x = event->area.y = 0;
- event->area.width = event->area.height = 1000;
+ gint width, height;
+
+ gdk_drawable_get_size (event->window, &width, &height);
+
+ event->area.x -= width > event->area.width ? width-event->area.width : 0;
+ event->area.y -= height > event->area.height ? height-event->area.height : 0;
+
+ event->area.x = max(0, event->area.x);
+ event->area.y = max(0, event->area.y);
+
+ event->area.width = max (width, event->area.width);
+ event->area.height = max (height, event->area.height);
+
return FALSE;
}
/* The height has changed, resize outer widget and set columns
rows to what we had before adding the tool bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
SET_FRAME_GARBAGED (f);
}
if (old_req.height != new_req.height)
{
FRAME_TOOLBAR_HEIGHT (f) = new_req.height;
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
}
- /* Must force out update so changed images gets redrawn. */
- gdk_window_process_all_updates ();
-
if (icon_list) g_list_free (icon_list);
UNBLOCK_INPUT;
/* The height has changed, resize outer widget and set columns
rows to what we had before removing the tool bar. */
- xg_resize_outer_widget (f, FRAME_WIDTH (f), FRAME_HEIGHT (f));
+ xg_resize_outer_widget (f, FRAME_COLS (f), FRAME_LINES (f));
SET_FRAME_GARBAGED (f);
UNBLOCK_INPUT;
xg_initialize ()
{
xg_ignore_gtk_scrollbar = 0;
- xg_ignore_next_thumb = 0;
xg_left_ptr_cursor = 0;
xg_did_tearoff = 0;