Here's the vertical divider shadow thickness specifier. When you drag the divider, it will get a "pressed" look. The following set of patches must be applied on top of Kirill's and my former ones. *** WARNING: *** I've patched redisplay-msw.c to make it compile, but the feature is not functional. I don't know msw, so I'll let someone else hack it. There is one thing I would have liked to discuss with Ben, but I'm not allowed to give international phone calls :-( The thing is that currently, `redisplay_output_window' checks for several flags in order to decide when to redraw the dividers, including the windows_structure_changed flag. I've decided to activate this flag when the shadow thickness is changed. I'm not sure if it's really kludgy. I'm not sure it's worth adding a new flag either. 1998-05-13 Didier Verna <verna(a)inf.enst.fr&gt; * mouse.el (drag-window-divider): give the vertical divider a pressed look when dragging it. 1998-05-12 Didier Verna <verna(a)inf.enst.fr&gt; * console.h (struct console_methods): the divider_width console method now requires a struct window * argument. * redisplay-x.c (x_divider_width): ditto. Plus remove X_DIVIDER_WIDTH, X_DIVIDER_SHADOW_THICKNESS. (x_output_vertical_divider): give a depressed look when the shadow thickness is negative. * console-stream.c (stream_divider_width): pass a struct window * argument. * redisplay-tty.c (tty_divider_width): ditto. * window.c (window_right_gutter_width): totdi. * redisplay.c (generate_modeline): ittod. * scrollbar.c (update_scrollbar_instance): ttido. * redisplay-msw.c (mswindows_divider_width): ottid. WARNING: this enables to compile, but the feature is not functional. * window.h (struct window): new field vertical_divider_shadow_thickness. * window.c (specifier_vars_of_window): new specifier vertical-divider-shadow-thickness. (vertical_divider_shadow_thickness_changed): new function to inform redisplay that the window has changed. (mark_window): handle new field vertical_divider_shadow_thickness from struct window. (allocate_window): ditto. (saved_window_equal): toddi. (Fset_window_configuration): totid. (save_window_save): ttdio. (struct saved_window): new field vertical_divider_shadow_thickness. --- lisp/mouse.el.orig Tue May 12 20:25:05 1998 +++ lisp/mouse.el Wed May 13 09:36:47 1998 ＠＠ -1412,11 +1412,12 ＠＠ window-divider-map. You would not call it, but you may bind it to other mouse buttons." (interactive "e") - (let ((window (event-window event)) - (frame (event-channel event)) - (last-timestamp (event-timestamp event)) - (doit t)) - + (letf* ((window (event-window event)) + (frame (event-channel event)) + (last-timestamp (event-timestamp event)) + (doit t) + ((specifier-instance vertical-divider-shadow-thickness window) + (- (specifier-instance vertical-divider-shadow-thickness window)))) (while doit (let ((old-right (caddr (window-pixel-edges window))) (old-left (car (window-pixel-edges window))) --- src/console.h.orig Tue May 12 18:38:10 1998 +++ src/console.h Tue May 12 18:40:09 1998 ＠＠ -133,7 +133,7 ＠＠ CONST Emchar *str, Charcount len); void (*output_display_block_method) (struct window *, struct display_line *, int, int, int, int, int, int, int); - int (*divider_width_method) (void); + int (*divider_width_method) (struct window *); int (*divider_height_method) (void); int (*eol_cursor_width_method) (void); void (*output_vertical_divider_method) (struct window *, int); --- src/redisplay-x.c.orig Tue May 12 18:45:31 1998 +++ src/redisplay-x.c Tue May 12 20:18:30 1998 ＠＠ -54,23 +54,16 ＠＠ /* X_DIVIDER_LINE_WIDTH is the width of the line drawn in the gutter. X_DIVIDER_SPACING is the amount of blank space on each side of the line. - X_DIVIDER_SHADOW_THICKNESS is the size of shadows - X_DIVIDER_WIDTH = - X_DIVIDER_LINE_WIDTH + 2*X_DIVIDER_SPACING + 2*X_DIVIDER_SHADOW_THICKNESS + the shadow thickness is now a specifier. */ +#define X_DIVIDER_LINE_WIDTH 3 +#define X_DIVIDER_SPACING 2 + /* Number of pixels below each line. */ /* #### implement me */ int x_interline_space; -#define X_DIVIDER_LINE_WIDTH 3 -#define X_DIVIDER_SPACING 2 -#define X_DIVIDER_SHADOW_THICKNESS 2 -#define X_DIVIDER_WIDTH \ - (X_DIVIDER_LINE_WIDTH + \ - 2 * X_DIVIDER_SPACING + \ - 2 * X_DIVIDER_SHADOW_THICKNESS) - #define EOL_CURSOR_WIDTH 5 static void x_output_pixmap (struct window *w, struct display_line *dl, ＠＠ -290,9 +283,16 ＠＠ divider_width is a device method. ****************************************************************************/ static int -x_divider_width (void) +x_divider_width (struct window *w) { - return X_DIVIDER_WIDTH; + int shadow_thickness = XINT (w->vertical_divider_shadow_thickness); + + /* the shadow thickness can be negative !! This means that the divider will + have a depressed look */ + if (shadow_thickness < 0) + shadow_thickness = - shadow_thickness; + + return X_DIVIDER_LINE_WIDTH + 2 * X_DIVIDER_SPACING + 2 * shadow_thickness; } /***************************************************************************** ＠＠ -1414,11 +1414,14 ＠＠ int use_pixmap = 0; int flip_gcs = 0; unsigned long mask; + int x, y1, y2, width, shadow_thickness; + + width = x_divider_width (w); + shadow_thickness = XINT (w->vertical_divider_shadow_thickness); + x = WINDOW_RIGHT (w) - width; + y1 = WINDOW_TOP (w); + y2 = WINDOW_BOTTOM (w); - int x = WINDOW_RIGHT (w) - X_DIVIDER_WIDTH; - int y1 = WINDOW_TOP (w); - int y2 = WINDOW_BOTTOM (w); - memset (&gcv, ~0, sizeof (XGCValues)); tmp_pixel = WINDOW_FACE_CACHEL_BACKGROUND (w, MODELINE_INDEX); ＠＠ -1488,21 +1491,35 ＠＠ gcv.foreground = background_pixel; background_gc = gc_cache_lookup (DEVICE_X_GC_CACHE (d), &gcv, mask); + /* possibly revert the GC's in case the shadow thickness is < 0. + This will give a depressed look to the divider */ + if (shadow_thickness < 0) + { + GC temp; + + temp = top_shadow_gc; + top_shadow_gc = bottom_shadow_gc; + bottom_shadow_gc = temp; + + /* better avoid a Bad Adress XLib error ;-) */ + shadow_thickness = - shadow_thickness; + } + /* Clear the divider area first. This needs to be done when a window split occurs. */ if (clear) - XClearArea (dpy, x_win, x, y1, X_DIVIDER_WIDTH, y2 - y1, False); + XClearArea (dpy, x_win, x, y1, width, y2 - y1, False); /* Draw the divider line. */ XFillRectangle (dpy, x_win, background_gc, - x + X_DIVIDER_SPACING + X_DIVIDER_SHADOW_THICKNESS, y1, + x + X_DIVIDER_SPACING + shadow_thickness, y1, X_DIVIDER_LINE_WIDTH, y2 - y1); - + /* Draw the shadows around the divider line */ x_output_shadows (f, x + X_DIVIDER_SPACING, y1, - X_DIVIDER_WIDTH - 2 * X_DIVIDER_SPACING, y2 - y1, + width - 2 * X_DIVIDER_SPACING, y2 - y1, top_shadow_gc, bottom_shadow_gc, - background_gc, X_DIVIDER_SHADOW_THICKNESS); + background_gc, shadow_thickness); } /***************************************************************************** --- src/console-stream.c.orig Tue May 12 18:55:41 1998 +++ src/console-stream.c Tue May 12 18:56:05 1998 ＠＠ -201,7 +201,7 ＠＠ } static int -stream_divider_width (void) +stream_divider_width (struct window *w) { return 1; } --- src/redisplay-tty.c.orig Tue May 12 18:56:31 1998 +++ src/redisplay-tty.c Tue May 12 18:56:45 1998 ＠＠ -120,7 +120,7 ＠＠ divider_width is a console method. ****************************************************************************/ static int -tty_divider_width (void) +tty_divider_width (struct window *w) { return 1; } --- src/redisplay-msw.c.orig Tue May 12 18:57:07 1998 +++ src/redisplay-msw.c Tue May 12 18:57:35 1998 ＠＠ -884,7 +884,7 ＠＠ Return the width of the vertical divider. ****************************************************************************/ static int -mswindows_divider_width (void) +mswindows_divider_width (struct window *w) { if (divider_width == 0) divider_width = (GetSystemMetrics (SM_CXSIZEFRAME) --- src/redisplay.c.orig Tue May 12 19:30:36 1998 +++ src/redisplay.c Tue May 12 19:30:44 1998 ＠＠ -8133,7 +8133,7 ＠＠ if (window_needs_vertical_divider (*w)) { int div_x_high = WINDOW_RIGHT (*w); - int div_x_low = div_x_high - FRAMEMETH (f, divider_width, ()); + int div_x_low = div_x_high - FRAMEMETH (f, divider_width, (*w)); int div_y_high = WINDOW_BOTTOM (*w); #ifdef HAVE_SCROLLBARS int div_y_low = (!NILP ((*w)->scrollbar_on_top_p) --- src/scrollbar.c.orig Tue May 12 19:31:31 1998 +++ src/scrollbar.c Tue May 12 19:31:50 1998 ＠＠ -470,7 +470,7 ＠＠ ? WINDOW_LEFT (w) : (WINDOW_RIGHT (w) - scrollbar_width - (window_needs_vertical_divider (w) - ? FRAMEMETH (f, divider_width, ()) : 0))); + ? FRAMEMETH (f, divider_width, (w)) : 0))); y_offset = WINDOW_TEXT_TOP (w) + f->scrollbar_y_offset; } else --- src/window.c.orig Tue May 12 19:06:30 1998 +++ src/window.c Wed May 13 10:06:57 1998 ＠＠ -71,6 +71,9 ＠＠ /* Whether a modeline should be displayed. */ Lisp_Object Vhas_modeline_p; +/* Thickness of shadow border around vertical dividers. */ +Lisp_Object Vvertical_divider_shadow_thickness; + /* Scroll if point lands on the bottom line and that line is partially clipped. */ int scroll_on_clipped_lines; ＠＠ -154,6 +157,7 ＠＠ ((markobj) (window->display_table)); ((markobj) (window->has_modeline_p)); ((markobj) (window->modeline_shadow_thickness)); + ((markobj) (window->vertical_divider_shadow_thickness)); #ifdef HAVE_SCROLLBARS ((markobj) (window->scrollbar_width)); ((markobj) (window->scrollbar_height)); ＠＠ -311,6 +315,7 ＠＠ p->display_table = Qnil; p->has_modeline_p = Qnil; p->modeline_shadow_thickness = Qnil; + p->vertical_divider_shadow_thickness = Qnil; #ifdef HAVE_SCROLLBARS p->scrollbar_width = Qnil; p->scrollbar_height = Qnil; ＠＠ -1057,7 +1062,7 ＠＠ #endif if (window_needs_vertical_divider (w)) - gutter += FRAMEMETH (XFRAME (WINDOW_FRAME (w)), divider_width, ()); + gutter += FRAMEMETH (XFRAME (WINDOW_FRAME (w)), divider_width, (w)); return gutter; } ＠＠ -4368,6 +4373,19 ＠＠ MARK_WINDOWS_CHANGED (w); } +static void +vertical_divider_shadow_thickness_changed (Lisp_Object specifier, + struct window *w, + Lisp_Object oldval) +{ + struct frame *f = XFRAME (w->frame); + + MARK_WINDOWS_CHANGED (w); + /* This is to indicate to redisplay_output_window that it should redraw the + vertical divider. I'm not sure of the kludge-ness level of this ... */ + MARK_FRAME_WINDOWS_STRUCTURE_CHANGED (f); +} + /* also used in scrollbar.c */ void some_window_value_changed (Lisp_Object specifier, struct window *w, ＠＠ -4508,6 +4526,7 ＠＠ char start_at_line_beg; /* boolean */ Lisp_Object display_table; Lisp_Object modeline_shadow_thickness; + Lisp_Object vertical_divider_shadow_thickness; Lisp_Object has_modeline_p; #ifdef HAVE_SCROLLBARS Lisp_Object scrollbar_width; ＠＠ -4651,6 +4670,8 ＠＠ win1->start_at_line_beg == win2->start_at_line_beg && internal_equal(win1->display_table, win2->display_table, 0) && EQ(win1->modeline_shadow_thickness, win2->modeline_shadow_thickness) && + EQ(win1->vertical_divider_shadow_thickness, + win2->vertical_divider_shadow_thickness) && EQ(win1->has_modeline_p, win2->has_modeline_p) && #ifdef HAVE_SCROLLBARS EQ(win1->scrollbar_width, win2->scrollbar_width) && ＠＠ -4974,6 +4995,8 ＠＠ w->modeline_hscroll = p->modeline_hscroll; w->display_table = p->display_table; w->modeline_shadow_thickness = p->modeline_shadow_thickness; + w->vertical_divider_shadow_thickness = + p->vertical_divider_shadow_thickness; w->has_modeline_p = p->has_modeline_p; #ifdef HAVE_SCROLLBARS w->scrollbar_width = p->scrollbar_width; ＠＠ -5240,6 +5263,8 ＠＠ p->modeline_hscroll = w->modeline_hscroll; p->display_table = w->display_table; p->modeline_shadow_thickness = w->modeline_shadow_thickness; + p->vertical_divider_shadow_thickness = + w->vertical_divider_shadow_thickness; p->has_modeline_p = w->has_modeline_p; #ifdef HAVE_SCROLLBARS p->scrollbar_width = w->scrollbar_width; ＠＠ -5635,6 +5660,21 ＠＠ modeline_shadow_thickness), modeline_shadow_thickness_changed, 0, 0); + + DEFVAR_SPECIFIER ("vertical-divider-shadow-thickness", &Vvertical_divider_shadow_thickness /* +*How thick to draw shadows around the vertical dividers. +This is a specifier; use `set-specifier' to change it. +*/ ); + Vvertical_divider_shadow_thickness = Fmake_specifier (Qinteger); + set_specifier_fallback (Vvertical_divider_shadow_thickness, + list1 (Fcons (Qnil, Qzero))); + Fadd_spec_to_specifier (Vvertical_divider_shadow_thickness, make_int (2), + Qnil, Qnil, Qnil); + set_specifier_caching (Vvertical_divider_shadow_thickness, + slot_offset (struct window, + vertical_divider_shadow_thickness), + vertical_divider_shadow_thickness_changed, + 0, 0); DEFVAR_SPECIFIER ("has-modeline-p", &Vhas_modeline_p /* *Whether the modeline should be displayed. --- src/window.h.orig Tue May 12 19:00:04 1998 +++ src/window.h Tue May 12 19:04:39 1998 ＠＠ -189,6 +189,9 ＠＠ Lisp_Object modeline_shadow_thickness; /* Non-nil means to display a modeline for the buffer. */ Lisp_Object has_modeline_p; + /* Thickness of vertical divider shadow, in pixels. If negative, draw as + recessed. */ + Lisp_Object vertical_divider_shadow_thickness; #ifdef HAVE_SCROLLBARS /* Width of vertical scrollbars. */ Lisp_Object scrollbar_width;