src/gtk/gtkvscrollbutton.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 3 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * Modified by the GTK+ Team and others 1997-1999.  See the AUTHORS
  20  * file for a list of people on the GTK+ Team.  See the ChangeLog
  21  * files for a list of changes.  These files are distributed with
  22  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  23  */
  24
  25  /*
  26   * Simple composite widget to provide vertical scrolling, based
  27   * on GtkRange widget code.
  28   * Modified by the Sylpheed Team and others 2003
  29   */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #  include "config.h"
  33 #endif
  34
  35 #include <glib.h>
  36 #include <gtk/gtksignal.h>
  37 #include <gtk/gtkbutton.h>
  38 #include <gtk/gtkmisc.h>
  39 #include <gtk/gtk.h>
  40 #include <gtk/gtkbox.h>
  41 #include <gtk/gtkmain.h>
  42
  43 #include "gtkvscrollbutton.h"
  44
  45 #define SCROLL_TIMER_LENGTH  20
  46 #define SCROLL_INITIAL_DELAY 100        /* must hold button this long before ... */
  47 #define SCROLL_LATER_DELAY   20 /* ... it starts repeating at this rate  */
  48 #define SCROLL_DELAY_LENGTH  300
  49
  50
  51 enum {
  52     ARG_0,
  53     ARG_ADJUSTMENT
  54 };
  55
  56 static void gtk_vscrollbutton_class_init(GtkVScrollbuttonClass * klass);
  57 static void gtk_vscrollbutton_init(GtkVScrollbutton * vscrollbutton);
  58
  59 GtkType gtk_vscrollbutton_get_type              (void);
  60 GtkWidget *gtk_vscrollbutton_new                (GtkAdjustment    *adjustment);
  61
  62 static gint gtk_vscrollbutton_button_release    (GtkWidget        *widget,
  63                                                  GdkEventButton   *event,
  64                                                  GtkVScrollbutton *scrollbutton);
  65
  66 static void gtk_vscrollbutton_set_adjustment    (GtkVScrollbutton *scrollbutton,
  67                                                  GtkAdjustment    *adjustment);
  68
  69 static gint gtk_vscrollbutton_button_press      (GtkWidget        *widget,
  70                                                  GdkEventButton   *event,
  71                                                  GtkVScrollbutton *scrollbutton);
  72
  73 static gint gtk_vscrollbutton_button_release    (GtkWidget        *widget,
  74                                                  GdkEventButton   *event,
  75                                                  GtkVScrollbutton *scrollbutton);
  76
  77 gint gtk_vscrollbutton_scroll           (GtkVScrollbutton *scrollbutton);
  78
  79 static gboolean gtk_vscrollbutton_timer_1st_time(GtkVScrollbutton *scrollbutton);
  80
  81 static void gtk_vscrollbutton_add_timer         (GtkVScrollbutton *scrollbutton);
  82
  83 static void gtk_vscrollbutton_remove_timer      (GtkVScrollbutton *scrollbutton);
  84
  85 static gint gtk_real_vscrollbutton_timer        (GtkVScrollbutton *scrollbutton);
  86
  87 static void gtk_vscrollbutton_set_sensitivity   (GtkAdjustment    *adjustment,
  88                                                  GtkVScrollbutton *scrollbutton);
  89
  90 GtkType gtk_vscrollbutton_get_type(void)
  91 {
  92     static GtkType vscrollbutton_type = 0;
  93
  94     if (!vscrollbutton_type) {
  95         static const GtkTypeInfo vscrollbutton_info = {
  96             "GtkVScrollbutton",
  97             sizeof(GtkVScrollbutton),
  98             sizeof(GtkVScrollbuttonClass),
  99             (GtkClassInitFunc) gtk_vscrollbutton_class_init,
 100             (GtkObjectInitFunc) gtk_vscrollbutton_init,
 101             /* reserved_1 */ NULL,
 102             /* reserved_2 */ NULL,
 103             (GtkClassInitFunc) NULL,
 104         };
 105
 106         vscrollbutton_type =
 107             gtk_type_unique(GTK_TYPE_VBOX, &vscrollbutton_info);
 108     }
 109
 110     return vscrollbutton_type;
 111 }
 112
 113 static void gtk_vscrollbutton_class_init(GtkVScrollbuttonClass *class)
 114 {
 115 }
 116
 117 static GdkCursor *hand_cursor = NULL;
 118
 119 static gboolean vscroll_visi_notify(GtkWidget *widget,
 120                                        GdkEventVisibility *event,
 121                                        gpointer data)
 122 {
 123         gdk_window_set_cursor(widget->window, hand_cursor);
 124         return FALSE;
 125 }
 126
 127 static gboolean vscroll_leave_notify(GtkWidget *widget,
 128                                       GdkEventCrossing *event,
 129                                        gpointer data)
 130 {
 131         gdk_window_set_cursor(widget->window, NULL);
 132         return FALSE;
 133 }
 134
 135 static gboolean vscroll_enter_notify(GtkWidget *widget,
 136                                       GdkEventCrossing *event,
 137                                        gpointer data)
 138 {
 139         gdk_window_set_cursor(widget->window, hand_cursor);
 140         return FALSE;
 141 }
 142
 143
 144 static void gtk_vscrollbutton_init(GtkVScrollbutton *scrollbutton)
 145 {
 146     GtkWidget *arrow;
 147
 148     if (!hand_cursor)
 149             hand_cursor = gdk_cursor_new(GDK_HAND2);
 150
 151     scrollbutton->upbutton = gtk_event_box_new();
 152     scrollbutton->downbutton = gtk_event_box_new();
 153     arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE);
 154     gtk_widget_show(arrow);
 155     gtk_container_add(GTK_CONTAINER(scrollbutton->upbutton), arrow);
 156     gtk_widget_set_size_request(scrollbutton->upbutton, -1, 16);
 157     arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE);
 158     gtk_widget_show(arrow);
 159     gtk_container_add(GTK_CONTAINER(scrollbutton->downbutton), arrow);
 160     gtk_widget_set_size_request(scrollbutton->downbutton, -1, 16);
 161     GTK_WIDGET_UNSET_FLAGS(scrollbutton->upbutton, GTK_CAN_FOCUS);
 162     GTK_WIDGET_UNSET_FLAGS(scrollbutton->downbutton, GTK_CAN_FOCUS);
 163     gtk_widget_show(scrollbutton->downbutton);
 164     gtk_widget_show(scrollbutton->upbutton);
 165
 166     g_signal_connect(G_OBJECT(scrollbutton->upbutton), "visibility-notify-event",
 167                      G_CALLBACK(vscroll_visi_notify), NULL);
 168     g_signal_connect(G_OBJECT(scrollbutton->upbutton), "motion-notify-event",
 169                      G_CALLBACK(vscroll_visi_notify), NULL);
 170     g_signal_connect(G_OBJECT(scrollbutton->upbutton), "leave-notify-event",
 171                      G_CALLBACK(vscroll_leave_notify), NULL);
 172     g_signal_connect(G_OBJECT(scrollbutton->upbutton), "enter-notify-event",
 173                      G_CALLBACK(vscroll_enter_notify), NULL);
 174     g_signal_connect(G_OBJECT(scrollbutton->downbutton), "visibility-notify-event",
 175                      G_CALLBACK(vscroll_visi_notify), NULL);
 176     g_signal_connect(G_OBJECT(scrollbutton->downbutton), "motion-notify-event",
 177                      G_CALLBACK(vscroll_visi_notify), NULL);
 178     g_signal_connect(G_OBJECT(scrollbutton->downbutton), "leave-notify-event",
 179                      G_CALLBACK(vscroll_leave_notify), NULL);
 180     g_signal_connect(G_OBJECT(scrollbutton->downbutton), "enter-notify-event",
 181                      G_CALLBACK(vscroll_enter_notify), NULL);
 182
 183     g_signal_connect(G_OBJECT(scrollbutton->upbutton),
 184                        "button_press_event",
 185                        G_CALLBACK(gtk_vscrollbutton_button_press),
 186                        scrollbutton);
 187     g_signal_connect(G_OBJECT(scrollbutton->downbutton),
 188                        "button_press_event",
 189                        G_CALLBACK(gtk_vscrollbutton_button_press),
 190                        scrollbutton);
 191     g_signal_connect(G_OBJECT(scrollbutton->upbutton),
 192                      "button_release_event",
 193                      G_CALLBACK
 194                      (gtk_vscrollbutton_button_release), scrollbutton);
 195     g_signal_connect(G_OBJECT(scrollbutton->downbutton),
 196                      "button_release_event",
 197                      G_CALLBACK
 198                      (gtk_vscrollbutton_button_release), scrollbutton);
 199     gtk_box_pack_start(GTK_BOX(&scrollbutton->vbox),
 200                        scrollbutton->upbutton, TRUE, TRUE, 0);
 201     gtk_box_pack_end(GTK_BOX(&scrollbutton->vbox),
 202                      scrollbutton->downbutton, TRUE, TRUE, 0);
 203     scrollbutton->timer = 0;
 204 }
 205
 206 GtkWidget *gtk_vscrollbutton_new(GtkAdjustment *adjustment)
 207 {
 208     GtkWidget *vscrollbutton;
 209     vscrollbutton = GTK_WIDGET(gtk_type_new(gtk_vscrollbutton_get_type()));
 210     gtk_vscrollbutton_set_adjustment(GTK_VSCROLLBUTTON(vscrollbutton),
 211                                      adjustment);
 212     g_signal_connect(G_OBJECT(GTK_VSCROLLBUTTON(vscrollbutton)->adjustment),
 213                        "value_changed",
 214                        G_CALLBACK
 215                        (gtk_vscrollbutton_set_sensitivity), vscrollbutton);
 216     g_signal_connect(G_OBJECT(GTK_VSCROLLBUTTON(vscrollbutton)->adjustment),
 217                        "changed",
 218                        G_CALLBACK
 219                        (gtk_vscrollbutton_set_sensitivity), vscrollbutton);
 220     return vscrollbutton;
 221 }
 222
 223
 224 void gtk_vscrollbutton_set_adjustment(GtkVScrollbutton *scrollbutton,
 225                                       GtkAdjustment *adjustment)
 226 {
 227     g_return_if_fail(scrollbutton != NULL);
 228     g_return_if_fail(GTK_IS_VSCROLLBUTTON(scrollbutton));
 229
 230     if (!adjustment)
 231             adjustment =
 232             GTK_ADJUSTMENT(gtk_adjustment_new(0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
 233     else
 234         g_return_if_fail(GTK_IS_ADJUSTMENT(adjustment));
 235
 236     if (scrollbutton->adjustment != adjustment) {
 237         if (scrollbutton->adjustment) {
 238             g_signal_handlers_disconnect_matched(scrollbutton->adjustment,
 239                                                  G_SIGNAL_MATCH_DATA,
 240                                                  0, 0, NULL, NULL,
 241                                                  (gpointer) scrollbutton);
 242             g_object_unref(G_OBJECT(scrollbutton->adjustment));
 243         }
 244
 245         scrollbutton->adjustment = adjustment;
 246         g_object_ref(G_OBJECT(adjustment));
 247         gtk_object_sink(GTK_OBJECT(adjustment));
 248     }
 249 }
 250
 251 static gint gtk_vscrollbutton_button_press(GtkWidget *widget,
 252                                            GdkEventButton *event,
 253                                            GtkVScrollbutton *scrollbutton)
 254 {
 255     if (!GTK_WIDGET_HAS_FOCUS(widget))
 256         gtk_widget_grab_focus(widget);
 257
 258     if (scrollbutton->button == 0) {
 259         gtk_grab_add(widget);
 260         scrollbutton->button = event->button;
 261
 262         if (widget == scrollbutton->downbutton)
 263             scrollbutton->scroll_type = GTK_SCROLL_STEP_FORWARD;
 264         else
 265             scrollbutton->scroll_type = GTK_SCROLL_STEP_BACKWARD;
 266         gtk_vscrollbutton_scroll(scrollbutton);
 267         gtk_vscrollbutton_add_timer(scrollbutton);
 268     }
 269     return TRUE;
 270 }
 271
 272
 273 static gint gtk_vscrollbutton_button_release(GtkWidget *widget,
 274                                              GdkEventButton *event,
 275                                              GtkVScrollbutton *scrollbutton)
 276 {
 277     if (!GTK_WIDGET_HAS_FOCUS(widget))
 278         gtk_widget_grab_focus(widget);
 279
 280     if (scrollbutton->button == event->button) {
 281         gtk_grab_remove(widget);
 282
 283         scrollbutton->button = 0;
 284         gtk_vscrollbutton_remove_timer(scrollbutton);
 285         gtk_vscrollbutton_set_sensitivity(scrollbutton->adjustment, scrollbutton);
 286     }
 287     return TRUE;
 288 }
 289
 290 gint gtk_vscrollbutton_scroll(GtkVScrollbutton *scrollbutton)
 291 {
 292     gfloat new_value;
 293     gint return_val;
 294
 295     g_return_val_if_fail(scrollbutton != NULL, FALSE);
 296     g_return_val_if_fail(GTK_IS_VSCROLLBUTTON(scrollbutton), FALSE);
 297
 298     new_value = scrollbutton->adjustment->value;
 299     return_val = TRUE;
 300
 301     switch (scrollbutton->scroll_type) {
 302
 303     case GTK_SCROLL_STEP_BACKWARD:
 304         new_value -= scrollbutton->adjustment->step_increment;
 305         if (new_value <= scrollbutton->adjustment->lower) {
 306             new_value = scrollbutton->adjustment->lower;
 307             return_val = FALSE;
 308             scrollbutton->timer = 0;
 309         }
 310         break;
 311
 312     case GTK_SCROLL_STEP_FORWARD:
 313         new_value += scrollbutton->adjustment->step_increment;
 314         if (new_value >=
 315             (scrollbutton->adjustment->upper -
 316              scrollbutton->adjustment->page_size)) {
 317             new_value =
 318                 scrollbutton->adjustment->upper -
 319                 scrollbutton->adjustment->page_size;
 320             return_val = FALSE;
 321             scrollbutton->timer = 0;
 322         }
 323         break;
 324
 325     default:
 326         break;
 327
 328     }
 329
 330     if (new_value != scrollbutton->adjustment->value) {
 331         scrollbutton->adjustment->value = new_value;
 332         g_signal_emit_by_name(G_OBJECT
 333                                 (scrollbutton->adjustment),
 334                                 "value_changed");
 335         gtk_widget_queue_resize(GTK_WIDGET(scrollbutton)); /* ensure resize */
 336     }
 337
 338     return return_val;
 339 }
 340
 341 static gboolean
 342 gtk_vscrollbutton_timer_1st_time(GtkVScrollbutton *scrollbutton)
 343 {
 344     /*
 345      * If the real timeout function succeeds and the timeout is still set,
 346      * replace it with a quicker one so successive scrolling goes faster.
 347      */
 348     g_object_ref(G_OBJECT(scrollbutton));
 349     if (scrollbutton->timer) {
 350         /* We explicitely remove ourselves here in the paranoia
 351          * that due to things happening above in the callback
 352          * above, we might have been removed, and another added.
 353          */
 354         g_source_remove(scrollbutton->timer);
 355         scrollbutton->timer = g_timeout_add(SCROLL_LATER_DELAY,
 356                                             (GtkFunction)
 357                                             gtk_real_vscrollbutton_timer,
 358                                             scrollbutton);
 359     }
 360     g_object_unref(G_OBJECT(scrollbutton));
 361     return FALSE;               /* don't keep calling this function */
 362 }
 363
 364
 365 static void gtk_vscrollbutton_add_timer(GtkVScrollbutton *scrollbutton)
 366 {
 367     g_return_if_fail(scrollbutton != NULL);
 368     g_return_if_fail(GTK_IS_VSCROLLBUTTON(scrollbutton));
 369
 370     if (!scrollbutton->timer) {
 371         scrollbutton->need_timer = TRUE;
 372         scrollbutton->timer = g_timeout_add(SCROLL_INITIAL_DELAY,
 373                                             (GtkFunction)
 374                                             gtk_vscrollbutton_timer_1st_time,
 375                                             scrollbutton);
 376     }
 377 }
 378
 379 static void gtk_vscrollbutton_remove_timer(GtkVScrollbutton *scrollbutton)
 380 {
 381     g_return_if_fail(scrollbutton != NULL);
 382     g_return_if_fail(GTK_IS_VSCROLLBUTTON(scrollbutton));
 383
 384     if (scrollbutton->timer) {
 385         g_source_remove(scrollbutton->timer);
 386         scrollbutton->timer = 0;
 387     }
 388     scrollbutton->need_timer = FALSE;
 389 }
 390
 391 static gint gtk_real_vscrollbutton_timer(GtkVScrollbutton *scrollbutton)
 392 {
 393     gint return_val;
 394
 395     GDK_THREADS_ENTER();
 396
 397     return_val = TRUE;
 398     if (!scrollbutton->timer) {
 399         return_val = FALSE;
 400         if (scrollbutton->need_timer)
 401             scrollbutton->timer =
 402                 g_timeout_add(SCROLL_TIMER_LENGTH,
 403                               (GtkFunction) gtk_real_vscrollbutton_timer,
 404                               (gpointer) scrollbutton);
 405         else {
 406             GDK_THREADS_LEAVE();
 407             return FALSE;
 408         }
 409         scrollbutton->need_timer = FALSE;
 410     }
 411     GDK_THREADS_LEAVE();
 412     return_val = gtk_vscrollbutton_scroll(scrollbutton);
 413     return return_val;
 414 }
 415
 416 static void gtk_vscrollbutton_set_sensitivity   (GtkAdjustment    *adjustment,
 417                                                  GtkVScrollbutton *scrollbutton)
 418 {
 419         if (!GTK_WIDGET_REALIZED(GTK_WIDGET(scrollbutton))) return;
 420         if (scrollbutton->button != 0) return; /* not while something is pressed */
 421
 422         gtk_widget_set_sensitive(scrollbutton->upbutton,
 423                                  (adjustment->value > adjustment->lower));
 424         gtk_widget_set_sensitive(scrollbutton->downbutton,
 425                                  (adjustment->value <  (adjustment->upper - adjustment->page_size)));
 426 }