Mercurial > hg > xemacs-beta
annotate src/scrollbar-gtk.c @ 5167:e374ea766cc1
clean up, rearrange allocation statistics code
-------------------- ChangeLog entries follow: --------------------
src/ChangeLog addition:
2010-03-21 Ben Wing <ben@xemacs.org>
* alloc.c:
* alloc.c (assert_proper_sizing):
* alloc.c (c_readonly):
* alloc.c (malloced_storage_size):
* alloc.c (fixed_type_block_overhead):
* alloc.c (lisp_object_storage_size):
* alloc.c (inc_lrecord_stats):
* alloc.c (dec_lrecord_stats):
* alloc.c (pluralize_word):
* alloc.c (object_memory_usage_stats):
* alloc.c (Fobject_memory_usage):
* alloc.c (compute_memusage_stats_length):
* alloc.c (disksave_object_finalization_1):
* alloc.c (Fgarbage_collect):
* mc-alloc.c:
* mc-alloc.c (mc_alloced_storage_size):
* mc-alloc.h:
No functionality change here. Collect the allocations-statistics
code that was scattered throughout alloc.c into one place. Add
remaining section headings so that all sections have headings
clearly identifying the start of the section and its purpose.
Expose mc_alloced_storage_size() even when not MEMORY_USAGE_STATS;
this fixes build problems and is related to the export of
lisp_object_storage_size() and malloced_storage_size() when
non-MEMORY_USAGE_STATS in the previous change set.
| author | Ben Wing <ben@xemacs.org> |
|---|---|
| date | Sun, 21 Mar 2010 04:41:49 -0500 |
| parents | 1fae11d56ad2 |
| children | 6c6d78781d59 |
| 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>. | |
| 6 | |
| 7 This file is part of XEmacs. | |
| 8 | |
| 9 XEmacs is free software; you can redistribute it and/or modify it | |
| 10 under the terms of the GNU General Public License as published by the | |
| 11 Free Software Foundation; either version 2, or (at your option) any | |
| 12 later version. | |
| 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 | |
| 20 along with XEmacs; see the file COPYING. If not, write to | |
| 21 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 22 Boston, MA 02111-1307, USA. */ | |
| 23 | |
| 24 /* Synched up with: Not in FSF. */ | |
| 25 /* Gtk version by William M. Perry */ | |
| 26 | |
| 27 #include <config.h> | |
| 28 #include "lisp.h" | |
| 29 | |
| 872 | 30 #include "frame-impl.h" |
| 31 #include "window.h" | |
| 32 | |
| 33 #include "console-gtk-impl.h" | |
| 462 | 34 #include "glyphs-gtk.h" |
| 35 #include "scrollbar-gtk.h" | |
| 36 | |
| 37 static gboolean scrollbar_cb (GtkAdjustment *adj, gpointer user_data); | |
| 38 | |
| 39 /* Used to prevent changing the size of the slider while drag | |
| 40 scrolling, under Motif. This is necessary because the Motif | |
| 41 scrollbar is incredibly stupid about updating the slider and causes | |
| 42 lots of flicker if it is done too often. */ | |
| 43 static int inhibit_slider_size_change; | |
| 44 | |
| 45 static int vertical_drag_in_progress; | |
| 46 | |
| 47 | |
| 48 /* A device method. */ | |
| 49 static int | |
| 50 gtk_inhibit_scrollbar_slider_size_change (void) | |
| 51 { | |
| 52 return inhibit_slider_size_change; | |
| 53 } | |
| 54 | |
| 55 /* A device method. */ | |
| 56 static void | |
| 57 gtk_free_scrollbar_instance (struct scrollbar_instance *instance) | |
| 58 { | |
| 3482 | 59 if (instance->scrollbar_data) |
| 462 | 60 { |
| 3482 | 61 if (SCROLLBAR_GTK_WIDGET (instance)) |
| 62 { | |
| 63 gtk_widget_hide_all (SCROLLBAR_GTK_WIDGET (instance)); | |
| 64 gtk_widget_destroy (SCROLLBAR_GTK_WIDGET (instance)); | |
| 65 } | |
| 66 | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
3482
diff
changeset
|
67 xfree (instance->scrollbar_data); |
| 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 | |
| 477 static int | |
| 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 { |
| 482 int total = 0; | |
| 483 | |
| 484 while (inst) | |
| 485 { | |
| 486 struct gtk_scrollbar_data *data = | |
| 487 (struct gtk_scrollbar_data *) inst->scrollbar_data; | |
| 488 | |
|
5157
1fae11d56ad2
redo memory-usage mechanism, add way of dynamically initializing Lisp objects
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
489 total += malloced_storage_size (data, sizeof (*data), ustats); |
| 462 | 490 inst = inst->next; |
| 491 } | |
| 492 | |
| 493 return total; | |
| 494 } | |
| 495 | |
| 496 #endif /* MEMORY_USAGE_STATS */ | |
| 497 | |
| 498 | |
| 499 /************************************************************************/ | |
| 500 /* initialization */ | |
| 501 /************************************************************************/ | |
| 502 | |
| 503 void | |
| 504 console_type_create_scrollbar_gtk (void) | |
| 505 { | |
| 506 CONSOLE_HAS_METHOD (gtk, inhibit_scrollbar_slider_size_change); | |
| 507 CONSOLE_HAS_METHOD (gtk, free_scrollbar_instance); | |
| 508 CONSOLE_HAS_METHOD (gtk, release_scrollbar_instance); | |
| 509 CONSOLE_HAS_METHOD (gtk, create_scrollbar_instance); | |
| 510 CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_values); | |
| 511 CONSOLE_HAS_METHOD (gtk, update_scrollbar_instance_status); | |
| 512 CONSOLE_HAS_METHOD (gtk, scrollbar_pointer_changed_in_window); | |
| 513 #ifdef MEMORY_USAGE_STATS | |
| 514 CONSOLE_HAS_METHOD (gtk, compute_scrollbar_instance_usage); | |
| 515 #endif /* MEMORY_USAGE_STATS */ | |
| 516 } | |
| 517 | |
| 518 void | |
| 519 vars_of_scrollbar_gtk (void) | |
| 520 { | |
| 521 Fprovide (intern ("gtk-scrollbars")); | |
| 522 } |