Mercurial > hg > xemacs-beta
annotate src/toolbar-xlike.c @ 5518:3cc7470ea71c
gnuclient: if TMPDIR was set and connect failed, try again with /tmp
2011-06-03 Aidan Kehoe <kehoea@parhasard.net>
* gnuslib.c (connect_to_unix_server):
Retry with /tmp as a directory in which to search for Unix sockets
if an attempt to connect with some other directory failed (which
may be because gnuclient and gnuserv don't share an environment
value for TMPDIR, or because gnuserv was compiled with USE_TMPDIR
turned off).
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Fri, 03 Jun 2011 18:40:57 +0100 |
| parents | 308d34e9f07d |
| children | 56144c8593a8 |
| rev | line source |
|---|---|
| 771 | 1 /* toolbar implementation -- "Generic" (X or GTK) redisplay interface. |
| 713 | 2 Copyright (C) 1995 Board of Trustees, University of Illinois. |
| 3 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 4917 | 4 Copyright (C) 1995, 1996, 2002, 2010 Ben Wing. |
| 713 | 5 Copyright (C) 1996 Chuck Thompson. |
| 6 | |
| 7 This file is part of XEmacs. | |
| 8 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5077
diff
changeset
|
9 XEmacs is free software: you can redistribute it and/or modify it |
| 713 | 10 under the terms of the GNU General Public License as published by the |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5077
diff
changeset
|
11 Free Software Foundation, either version 3 of the License, or (at your |
|
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5077
diff
changeset
|
12 option) any later version. |
| 713 | 13 |
| 14 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 15 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 17 for more details. | |
| 18 | |
| 19 You should have received a copy of the GNU General Public License | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5077
diff
changeset
|
20 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 713 | 21 |
| 22 /* Synched up with: Not in FSF. */ | |
| 23 | |
| 24 #include <config.h> | |
| 25 #include "lisp.h" | |
| 26 | |
| 872 | 27 #include "device-impl.h" |
| 713 | 28 #include "faces.h" |
| 872 | 29 #include "frame-impl.h" |
| 800 | 30 #include "glyphs.h" |
| 713 | 31 #include "toolbar.h" |
| 32 #include "window.h" | |
| 33 | |
| 771 | 34 /* This is used when we need to draw the toolbars ourselves -- on X or GTK. |
| 35 On MS Windows, we use the built-in toolbar controls. */ | |
| 36 | |
| 713 | 37 /* Only a very few things need to differ based on the toolkit used. |
| 38 ** | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
39 ** Some of the routines used assert (FRAME_yyy_P(f)) checks, this is |
| 713 | 40 ** now abstracted into __INTERNAL_APPROPRIATENESS_CHECK(). When we |
| 41 ** add new window systems that use this code, we should either add a | |
| 42 ** new case here, or just remove the checks completely. | |
| 43 ** | |
| 44 ** At least for X & GTK redraw_frame_toolbars() might end up getting | |
| 45 ** called before we are completely initialized. To avoid this, we use | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
46 ** the __INTERNAL_MAPPED_P (f) macro, that should return 0 if we should |
| 713 | 47 ** not draw the toolbars yet. When we add new window systems that use |
| 48 ** this code, we should add a new case here, if they need it. | |
| 49 ** | |
| 50 ** When clearing the toolbar, it is nice to flush the drawing queue. | |
| 51 ** Use __INTERNAL_FLUSH to do this. It is passed a device. | |
| 52 */ | |
| 53 #if defined(HAVE_GTK) | |
| 872 | 54 #include "console-gtk-impl.h" |
| 713 | 55 #define __INTERNAL_MAPPED_P(f) GTK_WIDGET_REALIZED (FRAME_GTK_TEXT_WIDGET (f)) |
| 56 #define __INTERNAL_FLUSH(d) gdk_flush() | |
| 57 #define __INTERNAL_APPROPRIATENESS_CHECK(f) assert(FRAME_GTK_P (f)) | |
| 58 #elif defined(HAVE_X_WINDOWS) | |
| 872 | 59 #include "console-x-impl.h" |
| 713 | 60 #define __INTERNAL_MAPPED_P(f) XtIsRealized (FRAME_X_SHELL_WIDGET (f)) |
| 61 #define __INTERNAL_APPROPRIATENESS_CHECK(f) assert(FRAME_X_P (f)) | |
| 62 #define __INTERNAL_FLUSH(d) XFlush (DEVICE_X_DISPLAY (d)) | |
| 63 #else | |
| 2500 | 64 #define __INTERNAL_MAPPED_P(f) ABORT() |
| 65 #define __INTERNAL_APPROPRIATENESS_CHECK(f) ABORT() | |
| 66 #define __INTERNAL_FLUSH(f) ABORT() | |
| 713 | 67 #endif |
| 68 | |
| 4917 | 69 #include "toolbar-xlike.h" |
| 713 | 70 |
| 744 | 71 extern Lisp_Object Vtoolbar_shadow_thickness; |
| 72 | |
| 713 | 73 static void __prepare_button_area (struct frame *f, |
| 74 struct toolbar_button *tb) | |
| 75 { | |
| 76 int sx = tb->x; | |
| 77 int sy = tb->y; | |
| 78 int swidth = tb->width; | |
| 79 int sheight = tb->height; | |
| 80 int border_width = tb->border_width; | |
| 81 int x_adj, width_adj, y_adj, height_adj; | |
| 82 struct device *d = XDEVICE (f->device); | |
| 83 Lisp_Object window = FRAME_LAST_NONMINIBUF_WINDOW (f); | |
| 84 struct window *w = XWINDOW (window); | |
| 744 | 85 int shadow_thickness; |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
86 int def_shadow_thickness = XINT (Fspecifier_instance (Vtoolbar_shadow_thickness, window, Qnil, Qnil)); |
| 713 | 87 face_index toolbar_findex; |
| 88 | |
| 89 if (tb->vertical) | |
| 90 { | |
| 91 x_adj = border_width; | |
| 92 width_adj = - 2 * border_width; | |
| 93 y_adj = height_adj = 0; | |
| 94 } | |
| 95 else | |
| 96 { | |
| 97 x_adj = width_adj = 0; | |
| 98 y_adj = border_width; | |
| 99 height_adj = - 2 * border_width; | |
| 100 } | |
| 101 | |
| 102 toolbar_findex = get_builtin_face_cache_index (w, Vtoolbar_face); | |
| 103 | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
104 /* Blank toolbar buttons that should be 3d will have EQ (tb->up_glyph, Qt) |
| 713 | 105 ** Blank toolbar buttons that should be flat will have NILP (tb->up_glyph) |
| 106 ** | |
| 107 ** Real toolbar buttons will check tb->enabled && tb->down | |
| 108 */ | |
| 109 if (EQ (Qt, tb->up_glyph)) | |
| 110 { | |
| 744 | 111 shadow_thickness = def_shadow_thickness; |
| 713 | 112 } |
| 113 else if (NILP (tb->up_glyph)) | |
| 114 { | |
| 115 shadow_thickness = 0; | |
| 116 } | |
| 117 else | |
| 118 { | |
| 119 if (tb->enabled) | |
| 120 { | |
| 121 if (tb->down) | |
| 744 | 122 shadow_thickness = -def_shadow_thickness; |
| 713 | 123 else |
| 744 | 124 shadow_thickness = def_shadow_thickness; |
| 713 | 125 } |
| 126 else | |
| 127 { | |
| 128 shadow_thickness = 0; | |
| 129 } | |
| 130 } | |
| 131 | |
| 132 /* Blank the entire area. */ | |
| 133 redisplay_clear_region (window, toolbar_findex, | |
| 134 sx + x_adj, sy + y_adj, | |
| 135 swidth + width_adj, | |
| 136 sheight + height_adj); | |
| 137 | |
| 138 /* Draw the outline. */ | |
| 139 if (shadow_thickness) | |
| 140 { | |
| 141 MAYBE_DEVMETH (d, bevel_area, | |
| 142 (w, toolbar_findex, sx + x_adj, | |
| 143 sy + y_adj, swidth + width_adj, | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
144 sheight + height_adj, abs (shadow_thickness), |
| 3094 | 145 EDGE_ALL, (shadow_thickness < 0) ? EDGE_BEVEL_IN |
| 146 : EDGE_BEVEL_OUT)); | |
| 713 | 147 } |
| 148 | |
| 149 /* Handle the borders... */ | |
| 150 redisplay_clear_region (window, toolbar_findex, | |
| 151 sx, sy, | |
| 152 (tb->vertical ? border_width : swidth), | |
| 153 (tb->vertical ? sheight : border_width)); | |
| 154 redisplay_clear_region (window, toolbar_findex, | |
| 155 (tb->vertical ? sx + swidth : sx), | |
| 156 (tb->vertical ? sy : sy + sheight), | |
| 157 (tb->vertical ? border_width : swidth), | |
| 158 (tb->vertical ? sheight : border_width)); | |
| 159 } | |
| 160 | |
| 4917 | 161 #define xlike_draw_blank_toolbar_button(f,tb) __prepare_button_area (f,tb) |
| 713 | 162 |
| 163 void | |
| 4917 | 164 xlike_output_toolbar_button (struct frame *f, Lisp_Object button) |
| 713 | 165 { |
| 166 int shadow_thickness = 2; | |
| 167 int x_adj, y_adj, width_adj, height_adj; | |
| 168 struct device *d = XDEVICE (f->device); | |
| 2212 | 169 Lisp_Object instance, window, glyph; |
| 713 | 170 struct toolbar_button *tb = XTOOLBAR_BUTTON (button); |
| 171 struct Lisp_Image_Instance *p; | |
| 172 struct window *w; | |
| 173 int vertical = tb->vertical; | |
| 174 int border_width = tb->border_width; | |
| 3094 | 175 face_index button_findex; |
| 713 | 176 |
| 177 if (vertical) | |
| 178 { | |
| 179 x_adj = border_width; | |
| 180 width_adj = - 2 * border_width; | |
| 181 y_adj = 0; | |
| 182 height_adj = 0; | |
| 183 } | |
| 184 else | |
| 185 { | |
| 186 x_adj = 0; | |
| 187 width_adj = 0; | |
| 188 y_adj = border_width; | |
| 189 height_adj = - 2 * border_width; | |
| 190 } | |
| 191 | |
| 192 window = FRAME_LAST_NONMINIBUF_WINDOW (f); | |
| 193 w = XWINDOW (window); | |
| 194 | |
| 195 glyph = get_toolbar_button_glyph (w, tb); | |
| 196 | |
| 197 if (tb->enabled) | |
| 198 { | |
| 199 if (tb->down) | |
| 200 { | |
| 201 shadow_thickness = -2; | |
| 202 } | |
| 203 else | |
| 204 { | |
| 205 shadow_thickness = 2; | |
| 206 } | |
| 207 } | |
| 208 else | |
| 209 { | |
| 210 shadow_thickness = 0; | |
| 211 } | |
| 212 | |
| 213 /* #### It is currently possible for users to trash us by directly | |
| 214 changing the toolbar glyphs. Avoid crashing in that case. */ | |
| 215 if (GLYPHP (glyph)) | |
| 3094 | 216 { |
| 217 /* WARNING: this interface may change */ | |
| 218 Lisp_Object face_list[2] = { XGLYPH_FACE (glyph), Vtoolbar_face }; | |
| 219 | |
| 220 button_findex = merge_face_list_to_cache_index (w, face_list, 2); | |
| 221 instance = glyph_image_instance (glyph, window, ERROR_ME_DEBUG_WARN, 1); | |
| 222 } | |
| 713 | 223 else |
| 3094 | 224 { |
| 225 button_findex = get_builtin_face_cache_index (w, Vtoolbar_face); | |
| 226 instance = Qnil; | |
| 227 } | |
| 228 | |
| 229 __prepare_button_area (f, tb); | |
| 713 | 230 |
| 231 if (IMAGE_INSTANCEP (instance)) | |
| 232 { | |
| 233 int width = tb->width + width_adj - shadow_thickness * 2; | |
| 234 int height = tb->height + height_adj - shadow_thickness * 2; | |
| 235 int x_offset = x_adj + shadow_thickness; | |
| 236 int y_offset = y_adj + shadow_thickness; | |
| 237 | |
| 238 p = XIMAGE_INSTANCE (instance); | |
| 239 | |
| 240 if (IMAGE_INSTANCE_PIXMAP_TYPE_P (p)) | |
| 241 { | |
| 242 struct display_box db; | |
| 243 struct display_glyph_area dga; | |
| 244 | |
| 245 if (width > (int) IMAGE_INSTANCE_PIXMAP_WIDTH (p)) | |
| 246 { | |
| 247 x_offset += ((int) (width - IMAGE_INSTANCE_PIXMAP_WIDTH (p)) | |
| 248 / 2); | |
| 249 width = IMAGE_INSTANCE_PIXMAP_WIDTH (p); | |
| 250 } | |
| 251 if (height > (int) IMAGE_INSTANCE_PIXMAP_HEIGHT (p)) | |
| 252 { | |
| 253 y_offset += ((int) (height - IMAGE_INSTANCE_PIXMAP_HEIGHT (p)) | |
| 254 / 2); | |
| 255 height = IMAGE_INSTANCE_PIXMAP_HEIGHT (p); | |
| 256 } | |
| 257 | |
| 258 /* Draw exactly in the area specified... */ | |
| 259 db.xpos = tb->x + x_offset; | |
| 260 db.ypos = tb->y + y_offset; | |
| 261 db.width = width; | |
| 262 db.height = height; | |
| 263 | |
| 264 /* Display the whole glyph */ | |
| 265 dga.xoffset = 0; | |
| 266 dga.yoffset = 0; | |
| 267 dga.width = width; | |
| 268 dga.height = height; | |
| 269 | |
| 270 redisplay_output_pixmap (w, instance, | |
| 271 &db, &dga, | |
| 3094 | 272 button_findex, 0, 0, 0, 0); |
| 713 | 273 } |
| 274 else if (IMAGE_INSTANCE_TYPE (p) == IMAGE_TEXT) | |
| 275 { | |
| 276 /* #### We need to make the face used configurable. */ | |
| 277 struct face_cachel *cachel = | |
| 278 WINDOW_FACE_CACHEL (w, DEFAULT_INDEX); | |
| 279 struct display_line dl; | |
| 280 Lisp_Object string = IMAGE_INSTANCE_TEXT_STRING (p); | |
| 281 unsigned char charsets[NUM_LEADING_BYTES]; | |
| 867 | 282 Ichar_dynarr *buf; |
| 713 | 283 struct font_metric_info fm; |
| 284 | |
| 285 /* This could be true if we were called via the Expose event | |
| 286 handler. Mark the button as dirty and return | |
| 287 immediately. */ | |
| 288 if (f->window_face_cache_reset) | |
| 289 { | |
| 290 tb->dirty = 1; | |
| 291 MARK_TOOLBAR_CHANGED; | |
| 292 return; | |
| 293 } | |
| 867 | 294 buf = Dynarr_new (Ichar); |
| 295 convert_ibyte_string_into_ichar_dynarr | |
| 713 | 296 (XSTRING_DATA (string), XSTRING_LENGTH (string), buf); |
| 4967 | 297 find_charsets_in_ichar_string (charsets, Dynarr_begin (buf), |
| 713 | 298 Dynarr_length (buf)); |
| 299 ensure_face_cachel_complete (cachel, window, charsets); | |
| 300 face_cachel_charset_font_metric_info (cachel, charsets, &fm); | |
| 301 | |
| 302 dl.ascent = fm.ascent; | |
| 303 dl.descent = fm.descent; | |
| 304 dl.ypos = tb->y + y_offset + fm.ascent; | |
| 305 | |
| 306 if (fm.ascent + fm.descent <= height) | |
| 307 { | |
| 308 dl.ypos += (height - fm.ascent - fm.descent) / 2; | |
| 309 dl.clip = 0; | |
| 310 } | |
| 311 else | |
| 312 { | |
| 313 dl.clip = fm.ascent + fm.descent - height; | |
| 314 } | |
| 315 | |
| 316 MAYBE_DEVMETH (d, output_string, | |
| 317 (w, &dl, buf, tb->x + x_offset, 0, 0, width, | |
| 3094 | 318 button_findex, 0, 0, 0, 0)); |
| 713 | 319 Dynarr_free (buf); |
| 320 } | |
| 321 | |
| 322 /* We silently ignore the image if it isn't a pixmap or text. */ | |
| 323 } | |
| 324 | |
| 325 tb->dirty = 0; | |
| 326 } | |
| 327 | |
| 328 static int | |
| 4917 | 329 xlike_get_button_size (struct frame *f, Lisp_Object window, |
| 713 | 330 struct toolbar_button *tb, int vert, int pos) |
| 331 { | |
| 332 int shadow_thickness = 2; | |
| 333 int size; | |
| 334 | |
| 335 if (tb->blank) | |
| 336 { | |
| 337 if (!NILP (tb->down_glyph)) | |
| 338 size = XINT (tb->down_glyph); | |
| 339 else | |
| 340 size = DEFAULT_TOOLBAR_BLANK_SIZE; | |
| 341 } | |
| 342 else | |
| 343 { | |
| 344 struct window *w = XWINDOW (window); | |
| 345 Lisp_Object glyph = get_toolbar_button_glyph (w, tb); | |
| 346 | |
| 347 /* Unless, of course, the user has done something stupid like | |
| 348 change the glyph out from under us. Use a blank placeholder | |
| 349 in that case. */ | |
| 350 if (NILP (glyph)) | |
| 351 return XINT (f->toolbar_size[pos]); | |
| 352 | |
| 353 if (vert) | |
| 354 size = glyph_height (glyph, window); | |
| 355 else | |
| 356 size = glyph_width (glyph, window); | |
| 357 } | |
| 358 | |
| 359 if (!size) | |
| 360 { | |
| 361 /* If the glyph doesn't have a size we'll insert a blank | |
| 362 placeholder instead. */ | |
| 363 return XINT (f->toolbar_size[pos]); | |
| 364 } | |
| 365 | |
| 366 size += shadow_thickness * 2; | |
| 367 | |
| 368 return (size); | |
| 369 } | |
| 370 | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
371 #define XLIKE_OUTPUT_BUTTONS_LOOP(left) \ |
| 713 | 372 do { \ |
| 373 while (!NILP (button)) \ | |
| 374 { \ | |
| 375 struct toolbar_button *tb = XTOOLBAR_BUTTON (button); \ | |
| 376 int size, height, width; \ | |
| 377 \ | |
| 378 if (left && tb->pushright) \ | |
| 379 break; \ | |
| 380 \ | |
| 4917 | 381 size = xlike_get_button_size (f, window, tb, vert, pos); \ |
| 713 | 382 \ |
| 383 if (vert) \ | |
| 384 { \ | |
| 385 width = bar_width; \ | |
| 386 if (y + size > max_pixpos) \ | |
| 387 height = max_pixpos - y; \ | |
| 388 else \ | |
| 389 height = size; \ | |
| 390 } \ | |
| 391 else \ | |
| 392 { \ | |
| 393 if (x + size > max_pixpos) \ | |
| 394 width = max_pixpos - x; \ | |
| 395 else \ | |
| 396 width = size; \ | |
| 397 height = bar_height; \ | |
| 398 } \ | |
| 399 \ | |
| 400 if (tb->x != x \ | |
| 401 || tb->y != y \ | |
| 402 || tb->width != width \ | |
| 403 || tb->height != height \ | |
| 905 | 404 || tb->dirty \ |
| 405 || f->clear) /* This is clearly necessary. */ \ | |
| 713 | 406 { \ |
| 407 if (width && height) \ | |
| 408 { \ | |
| 409 tb->x = x; \ | |
| 410 tb->y = y; \ | |
| 411 tb->width = width; \ | |
| 412 tb->height = height; \ | |
| 413 tb->border_width = border_width; \ | |
| 414 tb->vertical = vert; \ | |
| 415 \ | |
| 416 if (tb->blank || NILP (tb->up_glyph)) \ | |
| 417 { \ | |
| 4917 | 418 xlike_draw_blank_toolbar_button (f, tb); \ |
| 713 | 419 } \ |
| 420 else \ | |
| 4917 | 421 xlike_output_toolbar_button (f, button); \ |
| 713 | 422 } \ |
| 423 } \ | |
| 424 \ | |
| 425 if (vert) \ | |
| 426 y += height; \ | |
| 427 else \ | |
| 428 x += width; \ | |
| 429 \ | |
| 430 if ((vert && y == max_pixpos) || (!vert && x == max_pixpos)) \ | |
| 431 button = Qnil; \ | |
| 432 else \ | |
| 433 button = tb->next; \ | |
| 434 } \ | |
| 435 } while (0) | |
| 436 | |
| 437 static void | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
438 xlike_output_toolbar (struct frame *f, enum edge_pos pos) |
| 713 | 439 { |
| 440 int x, y, bar_width, bar_height, vert; | |
| 441 int max_pixpos, right_size, right_start, blank_size; | |
| 442 int border_width = FRAME_REAL_TOOLBAR_BORDER_WIDTH (f, pos); | |
| 443 Lisp_Object button, window; | |
| 444 face_index toolbar_findex; | |
| 445 | |
| 446 get_toolbar_coords (f, pos, &x, &y, &bar_width, &bar_height, &vert, 1); | |
| 447 window = FRAME_LAST_NONMINIBUF_WINDOW (f); | |
| 448 toolbar_findex = get_builtin_face_cache_index (XWINDOW (window), Vtoolbar_face); | |
| 449 | |
| 450 /* Do the border */ | |
| 451 redisplay_clear_region (window, toolbar_findex, | |
| 452 x, y, | |
| 453 (vert ? bar_width : border_width), | |
| 454 (vert ? border_width : bar_height)); | |
| 455 redisplay_clear_region (window, toolbar_findex, | |
| 456 (vert ? x : x + bar_width - border_width), | |
| 457 (vert ? y + bar_height - border_width : y), | |
| 458 (vert ? bar_width : border_width), | |
| 459 (vert ? border_width : bar_height)); | |
| 460 | |
| 461 if (vert) | |
| 462 { | |
| 463 max_pixpos = y + bar_height - border_width; | |
| 464 y += border_width; | |
| 465 } | |
| 466 else | |
| 467 { | |
| 468 max_pixpos = x + bar_width - border_width; | |
| 469 x += border_width; | |
| 470 } | |
| 471 | |
| 472 button = FRAME_TOOLBAR_BUTTONS (f, pos); | |
| 473 right_size = 0; | |
| 474 | |
| 475 /* First loop over all of the buttons to determine how much room we | |
| 476 need for left hand and right hand buttons. This loop will also | |
| 477 make sure that all instances are instantiated so when we actually | |
| 478 output them they will come up immediately. */ | |
| 479 while (!NILP (button)) | |
| 480 { | |
| 481 struct toolbar_button *tb = XTOOLBAR_BUTTON (button); | |
| 4917 | 482 int size = xlike_get_button_size (f, window, tb, vert, pos); |
| 713 | 483 |
| 484 if (tb->pushright) | |
| 485 right_size += size; | |
| 486 | |
| 487 button = tb->next; | |
| 488 } | |
| 489 | |
| 490 button = FRAME_TOOLBAR_BUTTONS (f, pos); | |
| 491 | |
| 492 /* Loop over the left buttons, updating and outputting them. */ | |
| 4917 | 493 XLIKE_OUTPUT_BUTTONS_LOOP (1); |
| 713 | 494 |
| 495 /* Now determine where the right buttons start. */ | |
| 496 right_start = max_pixpos - right_size; | |
| 497 if (right_start < (vert ? y : x)) | |
| 498 right_start = (vert ? y : x); | |
| 499 | |
| 500 /* Output the blank which goes from the end of the left buttons to | |
| 501 the start of the right. */ | |
| 502 blank_size = right_start - (vert ? y : x); | |
| 503 if (blank_size) | |
| 504 { | |
| 505 int height, width; | |
| 506 | |
| 507 if (vert) | |
| 508 { | |
| 509 width = bar_width; | |
| 510 height = blank_size; | |
| 511 } | |
| 512 else | |
| 513 { | |
| 514 width = blank_size; | |
| 515 height = bar_height; | |
| 516 } | |
| 517 | |
| 518 /* | |
| 519 * Use a 3D pushright separator only if there isn't a toolbar | |
| 520 * border. A flat separator meshes with the border and looks | |
| 521 * better. | |
| 522 */ | |
| 523 if (1) | |
| 524 { | |
| 525 struct toolbar_button tb; | |
| 526 | |
| 527 tb.x = x; | |
| 528 tb.y = y; | |
| 529 tb.width = width; | |
| 530 tb.height = height; | |
| 531 tb.border_width = border_width; | |
| 532 tb.vertical = vert; | |
| 533 tb.enabled = 1; | |
| 534 tb.up_glyph = border_width ? Qt : Qnil; | |
| 535 | |
| 536 __prepare_button_area (f, &tb); | |
| 537 } | |
| 538 | |
| 539 if (vert) | |
| 540 y += height; | |
| 541 else | |
| 542 x += width; | |
| 543 } | |
| 544 | |
| 545 /* Loop over the right buttons, updating and outputting them. */ | |
| 4917 | 546 XLIKE_OUTPUT_BUTTONS_LOOP (0); |
| 713 | 547 |
| 548 if (!vert) | |
| 549 { | |
| 793 | 550 Lisp_Object frame = wrap_frame (f); |
| 713 | 551 |
| 552 redisplay_clear_region (frame, | |
| 553 DEFAULT_INDEX, FRAME_PIXWIDTH (f) - 1, y, 1, | |
| 554 bar_height); | |
| 555 } | |
| 556 | |
| 557 SET_TOOLBAR_WAS_VISIBLE_FLAG (f, pos, 1); | |
| 558 __INTERNAL_FLUSH (XDEVICE (f->device)); | |
| 559 } | |
| 560 | |
| 561 static void | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
562 xlike_clear_toolbar (struct frame *f, enum edge_pos pos, int thickness_change) |
| 713 | 563 { |
| 564 Lisp_Object frame; | |
| 565 int x, y, width, height, vert; | |
| 566 | |
| 567 get_toolbar_coords (f, pos, &x, &y, &width, &height, &vert, 1); | |
| 793 | 568 frame = wrap_frame (f); |
| 713 | 569 |
| 570 /* The thickness_change parameter is used by the toolbar resize routines | |
| 571 to clear any excess toolbar if the size shrinks. */ | |
| 572 if (thickness_change < 0) | |
| 573 { | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
574 if (pos == LEFT_EDGE || pos == RIGHT_EDGE) |
| 713 | 575 { |
| 576 x = x + width + thickness_change; | |
| 577 width = -thickness_change; | |
| 578 } | |
| 579 else | |
| 580 { | |
| 581 y = y + height + thickness_change; | |
| 582 height = -thickness_change; | |
| 583 } | |
| 584 } | |
| 585 | |
| 586 SET_TOOLBAR_WAS_VISIBLE_FLAG (f, pos, 0); | |
| 587 | |
| 588 redisplay_clear_region (frame, DEFAULT_INDEX, x, y, width, height); | |
| 589 | |
| 590 __INTERNAL_FLUSH (XDEVICE (f->device)); | |
| 591 } | |
| 592 | |
| 593 void | |
| 4917 | 594 xlike_output_frame_toolbars (struct frame *f) |
| 713 | 595 { |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
596 enum edge_pos pos; |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
597 __INTERNAL_APPROPRIATENESS_CHECK (f); |
| 713 | 598 |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
599 EDGE_POS_LOOP (pos) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
600 { |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
601 if (FRAME_REAL_TOOLBAR_VISIBLE (f, pos)) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
602 xlike_output_toolbar (f, pos); |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
603 } |
| 905 | 604 } |
| 605 | |
| 606 void | |
| 4917 | 607 xlike_clear_frame_toolbars (struct frame *f) |
| 905 | 608 { |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
609 enum edge_pos pos; |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
610 __INTERNAL_APPROPRIATENESS_CHECK (f); |
| 905 | 611 |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
612 EDGE_POS_LOOP (pos) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
613 { |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
614 if (f->toolbar_was_visible[pos] |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
615 && !FRAME_REAL_TOOLBAR_VISIBLE (f, pos)) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
616 xlike_clear_toolbar (f, pos, 0); |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
617 } |
| 713 | 618 } |
| 619 | |
| 620 static void | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
621 xlike_redraw_exposed_toolbar (struct frame *f, enum edge_pos pos, int x, int y, |
| 713 | 622 int width, int height) |
| 623 { | |
| 624 int bar_x, bar_y, bar_width, bar_height, vert; | |
| 625 Lisp_Object button = FRAME_TOOLBAR_BUTTONS (f, pos); | |
| 626 | |
| 627 get_toolbar_coords (f, pos, &bar_x, &bar_y, &bar_width, &bar_height, | |
| 628 &vert, 1); | |
| 629 | |
| 630 if (((y + height) < bar_y) || (y > (bar_y + bar_height))) | |
| 631 return; | |
| 632 if (((x + width) < bar_x) || (x > (bar_x + bar_width))) | |
| 633 return; | |
| 634 | |
| 635 while (!NILP (button)) | |
| 636 { | |
| 637 struct toolbar_button *tb = XTOOLBAR_BUTTON (button); | |
| 638 | |
| 639 if (vert) | |
| 640 { | |
| 641 if (((tb->y + tb->height) > y) && (tb->y < (y + height))) | |
| 642 tb->dirty = 1; | |
| 643 | |
| 644 /* If this is true we have gone past the exposed region. */ | |
| 645 if (tb->y > (y + height)) | |
| 646 break; | |
| 647 } | |
| 648 else | |
| 649 { | |
| 650 if (((tb->x + tb->width) > x) && (tb->x < (x + width))) | |
| 651 tb->dirty = 1; | |
| 652 | |
| 653 /* If this is true we have gone past the exposed region. */ | |
| 654 if (tb->x > (x + width)) | |
| 655 break; | |
| 656 } | |
| 657 | |
| 658 button = tb->next; | |
| 659 } | |
| 660 | |
| 661 /* Even if none of the buttons is in the area, the blank region at | |
| 662 the very least must be because the first thing we did is verify | |
| 663 that some portion of the toolbar is in the exposed region. */ | |
| 4917 | 664 xlike_output_toolbar (f, pos); |
| 713 | 665 } |
| 666 | |
| 667 void | |
| 4917 | 668 xlike_redraw_exposed_toolbars (struct frame *f, int x, int y, int width, |
| 713 | 669 int height) |
| 670 { | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
671 enum edge_pos pos; |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
672 __INTERNAL_APPROPRIATENESS_CHECK (f); |
| 713 | 673 |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
674 EDGE_POS_LOOP (pos) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
675 { |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
676 if (FRAME_REAL_TOOLBAR_VISIBLE (f, pos)) |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
677 xlike_redraw_exposed_toolbar (f, pos, x, y, width, height); |
|
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
678 } |
| 713 | 679 } |
| 680 | |
| 681 void | |
| 4917 | 682 xlike_redraw_frame_toolbars (struct frame *f) |
| 713 | 683 { |
| 684 /* There are certain startup paths that lead to update_EmacsFrame in | |
| 685 faces.c being called before a new frame is fully initialized. In | |
| 686 particular before we have actually mapped it. That routine can | |
| 687 call this one. So, we need to make sure that the frame is | |
| 688 actually ready before we try and draw all over it. */ | |
|
5077
d372b17f63ce
clean up toolbar/gutter edge geometry
Ben Wing <ben@xemacs.org>
parents:
4969
diff
changeset
|
689 if (__INTERNAL_MAPPED_P (f)) |
| 4917 | 690 xlike_redraw_exposed_toolbars (f, 0, 0, FRAME_PIXWIDTH (f), |
| 713 | 691 FRAME_PIXHEIGHT (f)); |
| 692 } |