vcs.maemo.org Git - hildon/blob - hildon-widgets/hildon-scroll-area.c

   1 /*
   2  * This file is part of hildon-libs
   3  *
   4  * Copyright (C) 2005 Nokia Corporation.
   5  *
   6  * Contact: Luc Pionchon <luc.pionchon@nokia.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  21  * 02110-1301 USA
  22  *
  23  */
  24
  25 /* hildon-scroll-area.c
  26  *
  27  */
  28
  29 #include "hildon-scroll-area.h"
  30 #include <gtk/gtkscrolledwindow.h>
  31 #include <gtk/gtkfixed.h>
  32 #include <gtk/gtkadjustment.h>
  33 #include <gtk/gtkwidget.h>
  34 #include <string.h>
  35
  36 typedef struct
  37   {
  38     GtkWidget *fixed;
  39     GtkWidget *swinner;
  40     GtkWidget *child;
  41
  42     GtkAdjustment *outadj;
  43     GtkAdjustment *inadj;
  44
  45   } HildonScrollArea;
  46
  47
  48 static void hildon_scroll_area_outer_value_changed (GtkAdjustment *adjustment,
  49                                                     HildonScrollArea *sc);
  50 static void hildon_scroll_area_inner_value_changed (GtkAdjustment *adjustment,
  51                                                     HildonScrollArea *sc);
  52 static void hildon_scroll_area_size_allocate (GtkWidget *widget,
  53                                               GtkAllocation *allocation,
  54                                               HildonScrollArea *sc);
  55 static void hildon_scroll_area_child_requisition (GtkWidget *widget,
  56                                                   GtkRequisition *req,
  57                                                   HildonScrollArea *sc);
  58 static void hildon_scroll_area_fixed_allocate (GtkWidget *widget,
  59                                                GtkAllocation *allocation,
  60                                                HildonScrollArea *sc);
  61 static void hildon_scroll_area_destroy (GtkObject *object,
  62                                         HildonScrollArea *sc);
  63 /**
  64  * hildon_scroll_area_new:
  65  * @sw: #GtkWidget - #GtkScrolledWindow
  66  * @child: #GtkWidget - Child to be place inside the sw
  67  *
  68  * This is not a widget. It's a helper function to provide
  69  * hildon specified scrolling for applications.
  70  * Puts and connects the @child to the @sw.
  71  * A common situation where the scroll area should be used
  72  * might be following.  A view containing @GtkTreeView based widget,
  73  * (or any similar widget which has built-in @GtkScrolledWindow support)
  74  * and eg. couple buttons.  Normaly @GtkScrolledWindow can not handle
  75  * the situation so that the @GtkTreeView built-in support
  76  * would work.  The scroll area is connecting this built-in system to
  77  * the scrolled window and also noticing the buttons.  To use, one should
  78  * create a box to which pack the buttons and the scroll area.
  79  * The scroll area then contains the problematic widget eg. the @GtkTreeView.
  80  * Then the box should be placed in the @GtkScrolledWindow.
  81  * The function is currently assuming that the newly created scroll area
  82  * hierarchy is not modified in anyway.  Or if it is, it may lead to
  83  * unwanted problems.  Also assumed, that the @child will be packed
  84  * to the @sw.
  85  *
  86  * Returns: a @GtkFixed
  87  */
  88 GtkWidget *hildon_scroll_area_new (GtkWidget *sw, GtkWidget *child)
  89 {
  90   GtkWidget *swi;
  91   GtkWidget *fixed;
  92   HildonScrollArea *sc;
  93
  94   g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (sw)
  95                         && GTK_IS_WIDGET (child), NULL);
  96
  97   swi = gtk_scrolled_window_new (NULL, NULL);
  98   fixed = gtk_fixed_new ();
  99   sc = g_malloc (sizeof (HildonScrollArea));
 100   memset (sc, 0, sizeof (HildonScrollArea));
 101
 102   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swi),
 103                                   GTK_POLICY_NEVER, GTK_POLICY_NEVER);
 104
 105   gtk_container_add (GTK_CONTAINER (swi), child);
 106   gtk_fixed_put (GTK_FIXED (fixed), swi, 0, 0);
 107
 108   sc->fixed = fixed;
 109   sc->swinner = swi;
 110   sc->child = child;
 111   sc->outadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw));
 112   sc->inadj = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (swi));
 113
 114   g_signal_connect_after (G_OBJECT (child), "size-request",
 115                           G_CALLBACK (hildon_scroll_area_child_requisition), sc);
 116
 117   g_signal_connect_after (G_OBJECT (sc->outadj), "value_changed",
 118                           G_CALLBACK (hildon_scroll_area_outer_value_changed), sc);
 119   g_signal_connect_after (G_OBJECT (sc->inadj), "value_changed",
 120                           G_CALLBACK (hildon_scroll_area_inner_value_changed), sc);
 121
 122   g_signal_connect_after (G_OBJECT (sw), "size-allocate",
 123                           G_CALLBACK (hildon_scroll_area_size_allocate), sc);
 124   g_signal_connect (G_OBJECT (sc->fixed), "size-allocate",
 125                     G_CALLBACK (hildon_scroll_area_fixed_allocate), sc);
 126   g_signal_connect (G_OBJECT (sw), "destroy",
 127                     G_CALLBACK (hildon_scroll_area_destroy), sc);
 128
 129   gtk_widget_show_all (sw);
 130   return fixed;
 131 }
 132
 133 static void hildon_scroll_area_destroy (GtkObject *object,
 134                                         HildonScrollArea *sc)
 135 {
 136   g_free (sc);
 137 }
 138
 139 static void hildon_scroll_area_fixed_allocate (GtkWidget *widget,
 140                                                GtkAllocation *allocation,
 141                                                HildonScrollArea *sc)
 142 {
 143   gtk_widget_set_size_request (sc->swinner, -1,
 144                                MIN (sc->outadj->page_size, allocation->height));
 145 }
 146
 147 static void hildon_scroll_area_child_requisition (GtkWidget *widget,
 148                                                   GtkRequisition *req,
 149                                                   HildonScrollArea *sc)
 150 {
 151   gint new_req = MAX (req->height, sc->fixed->allocation.height);
 152   gtk_widget_set_size_request (sc->fixed, -1, req->height);
 153   gtk_widget_set_size_request (sc->swinner, -1,
 154                                MIN (sc->outadj->page_size, new_req));
 155 }
 156
 157 static void hildon_scroll_area_outer_value_changed (GtkAdjustment *adjustment,
 158                                                     HildonScrollArea *sc)
 159 {
 160   GtkRequisition req;
 161   gtk_widget_size_request (sc->child, &req);
 162
 163   if ((sc->outadj->value + sc->outadj->page_size) > sc->fixed->allocation.y
 164       && sc->outadj->value <
 165       (sc->fixed->allocation.y + req.height))
 166     {
 167       gdouble new_pos = 0;
 168
 169       new_pos = MAX (sc->outadj->value - sc->fixed->allocation.y, 0);
 170       new_pos = MIN (new_pos,
 171                      req.height - sc->inadj->page_size);
 172       new_pos = MAX (new_pos, 0);
 173
 174       gtk_fixed_move (GTK_FIXED (sc->fixed), sc->swinner, 0, new_pos);
 175       gtk_adjustment_set_value (sc->inadj, new_pos);
 176     }
 177 }
 178
 179 static void hildon_scroll_area_inner_value_changed (GtkAdjustment *adjustment,
 180                                                     HildonScrollArea *sc)
 181 {
 182   if (sc->outadj->value != sc->fixed->allocation.y + adjustment->value)
 183     gtk_adjustment_set_value (sc->outadj,
 184                               sc->fixed->allocation.y + adjustment->value);
 185 }
 186
 187 static void hildon_scroll_area_size_allocate (GtkWidget *widget,
 188                                               GtkAllocation *allocation,
 189                                               HildonScrollArea *sc)
 190 {
 191   g_signal_handlers_disconnect_by_func (widget,
 192                                         (void*)hildon_scroll_area_size_allocate,
 193                                         sc);
 194   gtk_widget_set_size_request (sc->child, sc->fixed->allocation.width, -1);
 195 }