Mercurial > hg > xemacs-beta
annotate src/scrollbar-gtk.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 |
|---|---|
| 2168 | 1 /* scrollbar implementation -- GTK interface. |
| 462 | 2 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois. |
| 3 Copyright (C) 1994 Amdhal Corporation. | |
| 4 Copyright (C) 1995 Sun Microsystems, Inc. | |
| 5 Copyright (C) 1995 Darrell Kindred <dkindred+@cmu.edu>. | |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
6 Copyright (C) 2010 Ben Wing. |
| 462 | 7 |
| 8 This file is part of XEmacs. | |
| 9 | |
|
5402
308d34e9f07d
Changed bulk of GPLv2 or later files identified by script
Mats Lidell <matsl@xemacs.org>
parents:
5170
diff
changeset
|
10 XEmacs is free software: you can redistribute it and/or modify it |
| 462 | 11 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:
5170
diff
changeset
|
12 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:
5170
diff
changeset
|
13 option) any later version. |
| 462 | 14 |
| 15 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 18 for more details. | |
| 19 | |
| 20 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:
5170
diff
changeset
|
21 along with XEmacs. If not, see <http://www.gnu.org/licenses/>. */ |
| 462 | 22 |
| 23 /* Synched up with: Not in FSF. */ | |
| 24 /* Gtk version by William M. Perry */ | |
| 25 | |
| 26 #include <config.h> | |
| 27 #include "lisp.h" | |
| 28 | |
| 872 | 29 #include "frame-impl.h" |
| 30 #include "window.h" | |
| 31 | |
| 32 #include "console-gtk-impl.h" | |
| 462 | 33 #include "glyphs-gtk.h" |
| 34 #include "scrollbar-gtk.h" | |
| 35 | |
| 36 static gboolean scrollbar_cb (GtkAdjustment *adj, gpointer user_data); | |
| 37 | |
| 38 /* Used to prevent changing the size of the slider while drag | |
| 39 scrolling, under Motif. This is necessary because the Motif | |
| 40 scrollbar is incredibly stupid about updating the slider and causes | |
| 41 lots of flicker if it is done too often. */ | |
| 42 static int inhibit_slider_size_change; | |
| 43 | |
| 44 static int vertical_drag_in_progress; | |
| 45 | |
| 46 | |
| 47 /* A device method. */ | |
| 48 static int | |
| 49 gtk_inhibit_scrollbar_slider_size_change (void) | |
| 50 { | |
| 51 return inhibit_slider_size_change; | |
| 52 } | |
| 53 | |
| 54 /* A device method. */ | |
| 55 static void | |
| 56 gtk_free_scrollbar_instance (struct scrollbar_instance *instance) | |
| 57 { | |
| 3482 | 58 if (instance->scrollbar_data) |
| 462 | 59 { |
| 3482 | 60 if (SCROLLBAR_GTK_WIDGET (instance)) |
| 61 { | |
| 62 gtk_widget_hide_all (SCROLLBAR_GTK_WIDGET (instance)); | |
| 63 gtk_widget_destroy (SCROLLBAR_GTK_WIDGET (instance)); | |
| 64 } | |
| 65 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
3482
diff
changeset
|
66 xfree (instance->scrollbar_data); |
|
5169
6c6d78781d59
cleanup of code related to xfree(), better KKCC backtrace capabilities, document XD_INLINE_LISP_OBJECT_BLOCK_PTR, fix some memory leaks, other code cleanup
Ben Wing <ben@xemacs.org>
parents:
5157
diff
changeset
|
67 instance->scrollbar_data = 0; |
| 462 | 68 } |
| 69 } | |
| 70 | |
| 71 /* A device method. */ | |
| 72 static void | |
| 73 gtk_release_scrollbar_instance (struct scrollbar_instance *instance) | |
| 74 { | |
| 75 /* It won't hurt to hide it all the time, will it? */ | |
| 76 gtk_widget_hide_all (SCROLLBAR_GTK_WIDGET (instance)); | |
| 77 } | |
| 78 | |
| 79 static gboolean | |
| 2286 | 80 scrollbar_drag_hack_cb (GtkWidget *UNUSED (w), GdkEventButton *UNUSED (ev), |
| 81 gpointer v) | |
| 462 | 82 { |
| 83 vertical_drag_in_progress = (int) v; | |
| 84 inhibit_slider_size_change = (int) v; | |
| 85 return (FALSE); | |
| 86 } | |
| 87 | |
| 88 /* A device method. */ | |
| 89 static void | |
| 90 gtk_create_scrollbar_instance (struct frame *f, int vertical, | |
| 91 struct scrollbar_instance *instance) | |
| 92 { | |
| 93 GtkAdjustment *adj = GTK_ADJUSTMENT (gtk_adjustment_new (0,0,0,0,0,0)); | |
| 94 GtkScrollbar *sb = NULL; | |
| 95 | |
| 96 /* initialize the X specific data section. */ | |
| 97 instance->scrollbar_data = xnew_and_zero (struct gtk_scrollbar_data); | |
| 98 | |
| 99 SCROLLBAR_GTK_ID (instance) = new_gui_id (); | |
| 100 SCROLLBAR_GTK_VDRAG_ORIG_VALUE (instance) = -1; | |
| 101 SCROLLBAR_GTK_LAST_VALUE (instance) = adj->value; | |
| 102 | |
| 2168 | 103 gtk_object_set_data (GTK_OBJECT (adj), GTK_DATA_GUI_IDENTIFIER, (void *) SCROLLBAR_GTK_ID (instance)); |
| 104 gtk_object_set_data (GTK_OBJECT (adj), GTK_DATA_FRAME_IDENTIFIER, f); | |
| 462 | 105 |
| 106 sb = GTK_SCROLLBAR (vertical ? gtk_vscrollbar_new (adj) : gtk_hscrollbar_new (adj)); | |
| 107 SCROLLBAR_GTK_WIDGET (instance) = GTK_WIDGET (sb); | |
| 108 | |
| 109 gtk_signal_connect (GTK_OBJECT (adj),"value-changed", | |
| 110 GTK_SIGNAL_FUNC (scrollbar_cb), (gpointer) vertical); | |
| 111 | |
| 112 gtk_signal_connect (GTK_OBJECT (sb), "button-press-event", | |
| 113 GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 1); | |
| 114 gtk_signal_connect (GTK_OBJECT (sb), "button-release-event", | |
| 115 GTK_SIGNAL_FUNC (scrollbar_drag_hack_cb), (gpointer) 0); | |
| 116 | |
| 117 gtk_fixed_put (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)), SCROLLBAR_GTK_WIDGET (instance), 0, 0); | |
| 525 | 118 |
| 119 /* | |
| 120 ** With gtk version > 1.2.8 the scrollbars in gtk-xemacs and xemacs | |
| 121 ** from CVS are invisible. In fact they are not invisible but very | |
| 122 ** thin (0 pixels wide). This is so, because the new gtk code does | |
| 123 ** not call gtk_widget_request_size() on the newly created | |
| 124 ** scrollbars anymore. this change was done to allow the theme | |
| 125 ** engines to manipulate the scrollbar width. This patch calls | |
| 126 ** gtk_widget_request_size with the newly created scollbars. Maybe | |
| 127 ** it is better to postpone this call just before the | |
| 128 ** gtk_widget_show() call is done on the scrolbar. | |
| 129 */ | |
| 130 gtk_widget_size_request(GTK_WIDGET(sb), &(GTK_WIDGET(sb)->requisition)); | |
| 131 | |
| 462 | 132 gtk_widget_hide (SCROLLBAR_GTK_WIDGET (instance)); |
| 133 } | |
| 134 | |
| 135 #define UPDATE_DATA_FIELD(field) \ | |
| 136 if (new_##field >= 0 && \ | |
| 137 SCROLLBAR_GTK_POS_DATA (inst).field != new_##field) { \ | |
| 138 SCROLLBAR_GTK_POS_DATA (inst).field = new_##field; \ | |
| 139 inst->scrollbar_instance_changed = 1; \ | |
| 140 } | |
| 141 | |
| 142 /* A device method. */ | |
| 143 /* #### The -1 check is such a hack. */ | |
| 144 static void | |
| 145 gtk_update_scrollbar_instance_values (struct window *w, | |
| 146 struct scrollbar_instance *inst, | |
| 147 int new_line_increment, | |
| 148 int new_page_increment, | |
| 149 int new_minimum, int new_maximum, | |
| 150 int new_slider_size, | |
| 151 int new_slider_position, | |
| 152 int new_scrollbar_width, | |
| 153 int new_scrollbar_height, | |
| 154 int new_scrollbar_x, int new_scrollbar_y) | |
| 155 { | |
| 156 UPDATE_DATA_FIELD (line_increment); | |
| 157 UPDATE_DATA_FIELD (page_increment); | |
| 158 UPDATE_DATA_FIELD (minimum); | |
| 159 UPDATE_DATA_FIELD (maximum); | |
| 160 UPDATE_DATA_FIELD (slider_size); | |
| 161 UPDATE_DATA_FIELD (slider_position); | |
| 162 UPDATE_DATA_FIELD (scrollbar_width); | |
| 163 UPDATE_DATA_FIELD (scrollbar_height); | |
| 164 UPDATE_DATA_FIELD (scrollbar_x); | |
| 165 UPDATE_DATA_FIELD (scrollbar_y); | |
| 166 | |
| 167 if (w && !vertical_drag_in_progress) | |
| 168 { | |
| 169 int new_vov = SCROLLBAR_GTK_POS_DATA (inst).slider_position; | |
| 170 int new_vows = marker_position (w->start[CURRENT_DISP]); | |
| 171 | |
| 172 if (SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) != new_vov) | |
| 173 { | |
| 174 SCROLLBAR_GTK_VDRAG_ORIG_VALUE (inst) = new_vov; | |
| 175 inst->scrollbar_instance_changed = 1; | |
| 176 } | |
| 177 if (SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) != new_vows) | |
| 178 { | |
| 179 SCROLLBAR_GTK_VDRAG_ORIG_WINDOW_START (inst) = new_vows; | |
| 180 inst->scrollbar_instance_changed = 1; | |
| 181 } | |
| 182 } | |
| 183 } | |
| 184 | |
| 185 /* Used by gtk_update_scrollbar_instance_status. */ | |
| 186 static void | |
| 187 update_one_widget_scrollbar_pointer (struct window *w, GtkWidget *wid) | |
| 188 { | |
| 189 if (!wid->window) | |
| 190 gtk_widget_realize (wid); | |
| 191 | |
| 192 if (POINTER_IMAGE_INSTANCEP (w->scrollbar_pointer)) | |
| 193 { | |
| 194 gdk_window_set_cursor (GET_GTK_WIDGET_WINDOW (wid), | |
| 195 XIMAGE_INSTANCE_GTK_CURSOR (w->scrollbar_pointer)); | |
| 196 gdk_flush (); | |
| 197 } | |
| 198 } | |
| 199 | |
| 200 /* A device method. */ | |
| 201 static void | |
| 202 gtk_update_scrollbar_instance_status (struct window *w, int active, int size, | |
| 203 struct scrollbar_instance *instance) | |
| 204 { | |
| 205 struct frame *f = XFRAME (w->frame); | |
| 206 GtkWidget *wid = SCROLLBAR_GTK_WIDGET (instance); | |
| 207 gboolean managed = GTK_WIDGET_MAPPED (wid); | |
| 208 | |
| 209 if (active && size) | |
| 210 { | |
| 211 if (instance->scrollbar_instance_changed) | |
| 212 { | |
| 213 /* Need to set the height, width, and position of the widget */ | |
| 214 GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (wid)); | |
| 215 scrollbar_values *pos_data = & SCROLLBAR_GTK_POS_DATA (instance); | |
| 216 int modified_p = 0; | |
| 217 | |
| 218 /* We do not want to update the size all the time if we can | |
| 219 help it. This cuts down on annoying flicker. | |
| 220 */ | |
| 221 if ((wid->allocation.width != pos_data->scrollbar_width) || | |
| 222 (wid->allocation.height != pos_data->scrollbar_height)) | |
| 223 { | |
| 224 gtk_widget_set_usize (wid, | |
| 225 pos_data->scrollbar_width, | |
| 226 pos_data->scrollbar_height); | |
| 2195 | 227 |
| 228 /* | |
| 229 UGLY! UGLY! UGLY! Changes to wid->allocation are queued and | |
| 230 not performed until the GTK event loop. However, when the | |
| 231 fontlock progress bar is run, the vertical scrollbar's height | |
| 232 is change and then changed back before events are again | |
| 233 processed. This means that the change back is not seen and | |
| 234 the scrollbar is left too short. Fix this by making the | |
| 235 change manually so the test above sees the change. This does | |
| 236 not seem to cause problems in other cases. | |
| 237 */ | |
| 238 | |
| 239 wid->allocation.width = pos_data->scrollbar_width; | |
| 240 wid->allocation.height = pos_data->scrollbar_height; | |
| 241 | |
| 462 | 242 modified_p = 1; |
| 243 } | |
| 244 | |
| 245 /* Ditto for the x/y position. */ | |
| 246 if ((wid->allocation.x != pos_data->scrollbar_x) || | |
| 247 (wid->allocation.y != pos_data->scrollbar_y)) | |
| 248 { | |
| 249 gtk_fixed_move (GTK_FIXED (FRAME_GTK_TEXT_WIDGET (f)), | |
| 250 wid, | |
| 251 pos_data->scrollbar_x, | |
| 252 pos_data->scrollbar_y); | |
| 2195 | 253 |
| 254 /* | |
| 255 UGLY! UGLY! UGLY! Changes to wid->allocation are queued and | |
| 256 not performed until the GTK event loop. However, when the | |
| 257 fontlock progress bar is run, the horizontal scrollbar's | |
| 258 position is change and then changed back before events are | |
| 259 again processed. This means that the change back is not seen | |
| 260 and the scrollbar is left in the wrong position. Fix this by | |
| 261 making the change manually so the test above sees the change. | |
| 262 This does not seem to cause problems in other cases. | |
| 263 */ | |
| 264 | |
| 265 wid->allocation.x = pos_data->scrollbar_x; | |
| 266 wid->allocation.y = pos_data->scrollbar_y; | |
| 267 | |
| 462 | 268 modified_p = 1; |
| 269 } | |
| 270 | |
| 271 adj->lower = pos_data->minimum; | |
| 272 adj->upper = pos_data->maximum; | |
| 273 adj->page_increment = pos_data->slider_size + 1; | |
| 274 adj->step_increment = w->max_line_len - 1; | |
| 275 adj->page_size = pos_data->slider_size + 1; | |
| 276 adj->value = pos_data->slider_position; | |
| 277 | |
| 278 /* But, if we didn't resize or move the scrollbar, the | |
| 279 widget will not get redrawn correctly when the user | |
| 280 scrolls around in the XEmacs frame manually. So we | |
| 281 update the slider manually here. | |
| 282 */ | |
| 283 if (!modified_p) | |
| 284 gtk_range_slider_update (GTK_RANGE (wid)); | |
| 285 | |
| 286 instance->scrollbar_instance_changed = 0; | |
| 287 } | |
| 288 | |
| 289 if (!managed) | |
| 290 { | |
| 291 gtk_widget_show (wid); | |
| 292 update_one_widget_scrollbar_pointer (w, wid); | |
| 293 } | |
| 294 } | |
| 295 else if (managed) | |
| 296 { | |
| 297 gtk_widget_hide (wid); | |
| 298 } | |
| 299 } | |
| 300 | |
| 301 enum gtk_scrollbar_loop | |
| 302 { | |
| 303 GTK_FIND_SCROLLBAR_WINDOW_MIRROR, | |
| 304 GTK_SET_SCROLLBAR_POINTER, | |
| 305 GTK_WINDOW_IS_SCROLLBAR, | |
| 306 GTK_UPDATE_FRAME_SCROLLBARS | |
| 307 }; | |
| 308 | |
| 309 static struct window_mirror * | |
| 310 gtk_scrollbar_loop (enum gtk_scrollbar_loop type, Lisp_Object window, | |
| 311 struct window_mirror *mir, | |
| 312 GUI_ID id, GdkWindow *x_win) | |
| 313 { | |
| 314 struct window_mirror *retval = NULL; | |
| 315 | |
| 316 while (mir) | |
| 317 { | |
| 318 struct scrollbar_instance *vinstance = mir->scrollbar_vertical_instance; | |
| 319 struct scrollbar_instance *hinstance = mir->scrollbar_horizontal_instance; | |
| 320 struct window *w = XWINDOW (window); | |
| 321 | |
| 322 if (mir->vchild) | |
| 323 retval = gtk_scrollbar_loop (type, w->vchild, mir->vchild, id, x_win); | |
| 324 else if (mir->hchild) | |
| 325 retval = gtk_scrollbar_loop (type, w->hchild, mir->hchild, id, x_win); | |
| 326 if (retval) | |
| 327 return retval; | |
| 328 | |
| 329 if (hinstance || vinstance) | |
| 330 { | |
| 331 switch (type) | |
| 332 { | |
| 333 case GTK_FIND_SCROLLBAR_WINDOW_MIRROR: | |
| 334 if ((vinstance && SCROLLBAR_GTK_ID (vinstance) == id) || | |
| 335 (hinstance && SCROLLBAR_GTK_ID (hinstance) == id)) | |
| 336 return mir; | |
| 337 break; | |
| 338 case GTK_UPDATE_FRAME_SCROLLBARS: | |
| 339 if (!mir->vchild && !mir->hchild) | |
| 340 update_window_scrollbars (w, mir, 1, 0); | |
| 341 break; | |
| 342 case GTK_SET_SCROLLBAR_POINTER: | |
| 343 if (!mir->vchild && !mir->hchild) | |
| 344 { | |
| 345 GtkWidget *widget; | |
| 346 | |
| 347 widget = SCROLLBAR_GTK_WIDGET (hinstance); | |
| 348 if (widget && GTK_WIDGET_MAPPED (widget)) | |
| 349 update_one_widget_scrollbar_pointer (w, widget); | |
| 350 | |
| 351 widget = SCROLLBAR_GTK_WIDGET (vinstance); | |
| 352 if (widget && GTK_WIDGET_MAPPED (widget)) | |
| 353 update_one_widget_scrollbar_pointer (w, widget); | |
| 354 } | |
| 355 break; | |
| 356 case GTK_WINDOW_IS_SCROLLBAR: | |
| 357 if (!mir->vchild && !mir->hchild) | |
| 358 { | |
| 359 GtkWidget *widget; | |
| 360 | |
| 361 widget = SCROLLBAR_GTK_WIDGET (hinstance); | |
| 362 if (widget && GTK_WIDGET_MAPPED (widget) && | |
| 363 GET_GTK_WIDGET_WINDOW (widget) == x_win) | |
| 364 return (struct window_mirror *) 1; | |
| 365 | |
| 366 widget = SCROLLBAR_GTK_WIDGET (vinstance); | |
| 367 if (widget && GTK_WIDGET_MAPPED (widget) && | |
| 368 GET_GTK_WIDGET_WINDOW (widget) == x_win) | |
| 369 return (struct window_mirror *) 1; | |
| 370 } | |
| 371 break; | |
| 372 default: | |
| 2500 | 373 ABORT (); |
| 462 | 374 } |
| 375 } | |
| 376 | |
| 377 mir = mir->next; | |
| 378 window = w->next; | |
| 379 } | |
| 380 | |
| 381 return NULL; | |
| 382 } | |
| 383 | |
| 384 /* Used by callbacks. */ | |
| 385 static struct window_mirror * | |
| 386 find_scrollbar_window_mirror (struct frame *f, GUI_ID id) | |
| 387 { | |
| 388 if (f->mirror_dirty) | |
| 389 update_frame_window_mirror (f); | |
| 390 return gtk_scrollbar_loop (GTK_FIND_SCROLLBAR_WINDOW_MIRROR, f->root_window, | |
| 617 | 391 XWINDOW_MIRROR (f->root_mirror), id, |
| 392 (GdkWindow *) NULL); | |
| 462 | 393 } |
| 394 | |
| 395 static gboolean | |
| 396 scrollbar_cb (GtkAdjustment *adj, gpointer user_data) | |
| 397 { | |
| 398 /* This function can GC */ | |
| 399 int vertical = (int) user_data; | |
| 2168 | 400 struct frame *f = (struct frame*) gtk_object_get_data (GTK_OBJECT (adj), GTK_DATA_FRAME_IDENTIFIER); |
| 617 | 401 struct scrollbar_instance *instance; |
| 2168 | 402 GUI_ID id = (GUI_ID) gtk_object_get_data (GTK_OBJECT (adj), GTK_DATA_GUI_IDENTIFIER); |
| 462 | 403 Lisp_Object win, frame; |
| 404 struct window_mirror *mirror; | |
| 405 Lisp_Object event_type = Qnil; | |
| 406 Lisp_Object event_data = Qnil; | |
| 407 | |
| 408 if (!f) | |
| 409 return(FALSE); | |
| 410 | |
| 411 mirror = find_scrollbar_window_mirror (f, id); | |
| 412 if (!mirror) | |
| 413 return(FALSE); | |
| 414 | |
| 415 win = real_window (mirror, 1); | |
| 416 | |
| 417 if (NILP (win)) | |
| 418 return(FALSE); | |
| 419 instance = vertical ? mirror->scrollbar_vertical_instance : mirror->scrollbar_horizontal_instance; | |
| 420 frame = WINDOW_FRAME (XWINDOW (win)); | |
| 421 | |
| 422 inhibit_slider_size_change = 0; | |
| 423 switch (GTK_RANGE (SCROLLBAR_GTK_WIDGET (instance))->scroll_type) | |
| 424 { | |
| 425 case GTK_SCROLL_PAGE_BACKWARD: | |
| 426 event_type = vertical ? Qscrollbar_page_up : Qscrollbar_page_left; | |
| 427 event_data = Fcons (win, Qnil); | |
| 428 break; | |
| 429 case GTK_SCROLL_PAGE_FORWARD: | |
| 430 event_type = vertical ? Qscrollbar_page_down : Qscrollbar_page_right; | |
| 431 event_data = Fcons (win, Qnil); | |
| 432 break; | |
| 433 case GTK_SCROLL_STEP_FORWARD: | |
| 434 event_type = vertical ? Qscrollbar_line_down : Qscrollbar_char_right; | |
| 435 event_data = win; | |
| 436 break; | |
| 437 case GTK_SCROLL_STEP_BACKWARD: | |
| 438 event_type = vertical ? Qscrollbar_line_up : Qscrollbar_char_left; | |
| 439 event_data = win; | |
| 440 break; | |
| 441 case GTK_SCROLL_NONE: | |
| 442 case GTK_SCROLL_JUMP: | |
| 443 inhibit_slider_size_change = 1; | |
| 444 event_type = vertical ? Qscrollbar_vertical_drag : Qscrollbar_horizontal_drag; | |
| 445 event_data = Fcons (win, make_int ((int)adj->value)); | |
| 446 break; | |
| 447 default: | |
| 2500 | 448 ABORT(); |
| 462 | 449 } |
| 450 | |
| 451 signal_special_gtk_user_event (frame, event_type, event_data); | |
| 452 | |
| 453 return (TRUE); | |
| 454 } | |
| 455 | |
| 456 static void | |
| 457 gtk_scrollbar_pointer_changed_in_window (struct window *w) | |
| 458 { | |
| 793 | 459 Lisp_Object window = wrap_window (w); |
| 462 | 460 |
| 617 | 461 gtk_scrollbar_loop (GTK_SET_SCROLLBAR_POINTER, window, |
| 462 find_window_mirror (w), 0, (GdkWindow *) NULL); | |
| 462 | 463 } |
| 464 | |
| 465 /* #### BILL!!! This comment is not true for Gtk - should it be? */ | |
| 466 /* Make sure that all scrollbars on frame are up-to-date. Called | |
| 467 directly from gtk_set_frame_properties in frame-gtk.c*/ | |
| 468 void | |
| 469 gtk_update_frame_scrollbars (struct frame *f) | |
| 470 { | |
| 617 | 471 gtk_scrollbar_loop (GTK_UPDATE_FRAME_SCROLLBARS, f->root_window, |
| 472 XWINDOW_MIRROR (f->root_mirror), | |
| 462 | 473 0, (GdkWindow *) NULL); |
| 474 } | |
| 475 | |
| 476 #ifdef MEMORY_USAGE_STATS | |
|
5170
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
477 static Bytecount |
| 2286 | 478 gtk_compute_scrollbar_instance_usage (struct device *UNUSED (d), |
| 462 | 479 struct scrollbar_instance *inst, |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
480 struct usage_stats *ustats) |
| 462 | 481 { |
|
5170
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
482 struct gtk_scrollbar_data *data = |
|
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
483 (struct gtk_scrollbar_data *) inst->scrollbar_data; |
| 462 | 484 |
|
5170
5ddbab03b0e6
various fixes to memory-usage stats
Ben Wing <ben@xemacs.org>
parents:
5169
diff
changeset
|
485 return malloced_storage_size (data, sizeof (*data), ustats); |
| 462 | 486 } |
| 487 | |
| 488 #endif /* MEMORY_USAGE_STATS */ | |
| 489 | |
| 490 | |
| 491 /************************************************************************/ | |
| 492 /* initialization */ | |
| 493 /************************************************************************/ | |
| 494 | |
| 495 void | |
| 496 console_type_create_scrollbar_gtk (void) | |
| 497 { | |
| 498 CONSOLE_HAS_METHOD (gtk, inhibit_scrollbar_slider_size_change); | |
| 499 CONSOLE_HAS_METHOD (gtk, free_scrollbar_instance); | |
| 500 CONSOLE_HAS_METHOD (gtk, release_scrollbar_instance); | |
| 501 CONSOLE_HAS_METHOD (gtk, create_scrollbar_instance); | |
| 502 CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_values); | |
| 503 CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_status); | |
| 504 CONSOLE_HAS_METHOD (gtk, scrollbar_pointer_changed_in_window); | |
| 505 #ifdef MEMORY_USAGE_STATS | |
| 506 CONSOLE_HAS_METHOD (gtk, compute_scrollbar_instance_usage); | |
| 507 #endif /* MEMORY_USAGE_STATS */ | |
| 508 } | |
| 509 | |
| 510 void | |
| 511 vars_of_scrollbar_gtk (void) | |
| 512 { | |
| 513 Fprovide (intern ("gtk-scrollbars")); | |
| 514 } |