pspp-sheet-view: Rename GtkTreeSelectMode to PsppSheetSelectMode.
[pspp] / src / ui / gui / psppire-vbuttonbox.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2007, 2010, 2011  Free Software Foundation
3
4    This program is free software: you can redistribute it and/or modify
5    it under the terms of the GNU General Public License as published by
6    the Free Software Foundation, either version 3 of the License, or
7    (at your option) any later version.
8
9    This program 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
12    GNU General Public License for more details.
13
14    You should have received a copy of the GNU General Public License
15    along with this program.  If not, see <http://www.gnu.org/licenses/>. */
16
17
18 #include <config.h>
19
20 #include <glib.h>
21 #include <gtk/gtk.h>
22 #include "psppire-vbuttonbox.h"
23 #include "psppire-dialog.h"
24
25 #include <gettext.h>
26
27 #define _(msgid) gettext (msgid)
28 #define N_(msgid) msgid
29
30
31 static void psppire_vbuttonbox_class_init          (PsppireVButtonBoxClass *);
32 static void psppire_vbuttonbox_init                (PsppireVButtonBox      *);
33
34 static void gtk_vbutton_box_size_request  (GtkWidget      *widget,
35                                            GtkRequisition *requisition);
36 static void gtk_vbutton_box_size_allocate (GtkWidget      *widget,
37                                            GtkAllocation  *allocation);
38
39
40 static const GtkButtonBoxStyle default_layout_style = GTK_BUTTONBOX_EDGE;
41
42 GType
43 psppire_vbutton_box_get_type (void)
44 {
45   static GType vbuttonbox_type = 0;
46
47   if (!vbuttonbox_type)
48     {
49       static const GTypeInfo vbuttonbox_info =
50       {
51         sizeof (PsppireVButtonBoxClass),
52         NULL, /* base_init */
53         NULL, /* base_finalize */
54         (GClassInitFunc) psppire_vbuttonbox_class_init,
55         NULL, /* class_finalize */
56         NULL, /* class_data */
57         sizeof (PsppireVButtonBox),
58         0,
59         (GInstanceInitFunc) psppire_vbuttonbox_init,
60       };
61
62       vbuttonbox_type = g_type_register_static (PSPPIRE_BUTTONBOX_TYPE,
63                                             "PsppireVButtonBox", &vbuttonbox_info, 0);
64     }
65
66   return vbuttonbox_type;
67 }
68
69 static void
70 psppire_vbuttonbox_class_init (PsppireVButtonBoxClass *class)
71 {
72   GtkWidgetClass *widget_class;
73
74   widget_class = (GtkWidgetClass*) class;
75
76   widget_class->size_request = gtk_vbutton_box_size_request;
77   widget_class->size_allocate = gtk_vbutton_box_size_allocate;
78 }
79
80
81 static void
82 psppire_vbuttonbox_init (PsppireVButtonBox *vbuttonbox)
83 {
84 }
85
86
87 GtkWidget*
88 psppire_vbuttonbox_new (void)
89 {
90   PsppireVButtonBox *vbuttonbox ;
91
92   vbuttonbox = g_object_new (psppire_vbutton_box_get_type (), NULL);
93
94   return GTK_WIDGET (vbuttonbox) ;
95 }
96
97
98
99 /* The following two functions are lifted verbatim from
100    the Gtk2.10.6 library */
101
102 static void
103 gtk_vbutton_box_size_request (GtkWidget      *widget,
104                               GtkRequisition *requisition)
105 {
106   GtkBox *box;
107   GtkButtonBox *bbox;
108   gint nvis_children;
109   gint child_width;
110   gint child_height;
111   gint spacing;
112   GtkButtonBoxStyle layout;
113
114   box = GTK_BOX (widget);
115   bbox = GTK_BUTTON_BOX (widget);
116
117   spacing = box->spacing;
118   layout = bbox->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
119           ? bbox->layout_style : default_layout_style;
120
121   _psppire_button_box_child_requisition (widget,
122                                          &nvis_children,
123                                          NULL,
124                                          &child_width,
125                                          &child_height);
126
127   if (nvis_children == 0)
128     {
129       requisition->width = 0;
130       requisition->height = 0;
131     }
132   else
133     {
134       switch (layout)
135       {
136       case GTK_BUTTONBOX_SPREAD:
137         requisition->height =
138                 nvis_children*child_height + ((nvis_children+1)*spacing);
139         break;
140       case GTK_BUTTONBOX_EDGE:
141       case GTK_BUTTONBOX_START:
142       case GTK_BUTTONBOX_END:
143         requisition->height =
144                 nvis_children*child_height + ((nvis_children-1)*spacing);
145         break;
146       default:
147             g_assert_not_reached();
148             break;
149       }
150       requisition->width = child_width;
151     }
152
153   requisition->width += GTK_CONTAINER (box)->border_width * 2;
154   requisition->height += GTK_CONTAINER (box)->border_width * 2;
155 }
156
157
158
159 static void
160 gtk_vbutton_box_size_allocate (GtkWidget     *widget,
161                                GtkAllocation *allocation)
162 {
163   GtkBox *base_box;
164   GtkButtonBox *box;
165   GtkBoxChild *child;
166   GList *children;
167   GtkAllocation child_allocation;
168   gint nvis_children;
169   gint n_secondaries;
170   gint child_width;
171   gint child_height;
172   gint x = 0;
173   gint y = 0;
174   gint secondary_y = 0;
175   gint height;
176   gint childspace;
177   gint childspacing = 0;
178   GtkButtonBoxStyle layout;
179   gint spacing;
180
181   base_box = GTK_BOX (widget);
182   box = GTK_BUTTON_BOX (widget);
183   spacing = base_box->spacing;
184   layout = box->layout_style != GTK_BUTTONBOX_DEFAULT_STYLE
185           ? box->layout_style : default_layout_style;
186   _psppire_button_box_child_requisition (widget,
187                                      &nvis_children,
188                                      &n_secondaries,
189                                      &child_width,
190                                      &child_height);
191   widget->allocation = *allocation;
192   height = allocation->height - GTK_CONTAINER (box)->border_width*2;
193   switch (layout)
194   {
195   case GTK_BUTTONBOX_SPREAD:
196     childspacing = (height - (nvis_children * child_height)) / (nvis_children + 1);
197     y = allocation->y + GTK_CONTAINER (box)->border_width + childspacing;
198     secondary_y = y + ((nvis_children - n_secondaries) * (child_height + childspacing));
199     break;
200   case GTK_BUTTONBOX_EDGE:
201     if (nvis_children >= 2)
202       {
203         childspacing = (height - (nvis_children*child_height)) / (nvis_children-1);
204         y = allocation->y + GTK_CONTAINER (box)->border_width;
205         secondary_y = y + ((nvis_children - n_secondaries) * (child_height + childspacing));
206       }
207     else
208       {
209         /* one or zero children, just center */
210         childspacing = height;
211         y = secondary_y = allocation->y + (allocation->height - child_height) / 2;
212       }
213     break;
214   case GTK_BUTTONBOX_START:
215     childspacing = spacing;
216     y = allocation->y + GTK_CONTAINER (box)->border_width;
217     secondary_y = allocation->y + allocation->height
218       - child_height * n_secondaries
219       - spacing * (n_secondaries - 1)
220       - GTK_CONTAINER (box)->border_width;
221     break;
222   case GTK_BUTTONBOX_END:
223     childspacing = spacing;
224     y = allocation->y + allocation->height
225       - child_height * (nvis_children - n_secondaries)
226       - spacing * (nvis_children - n_secondaries - 1)
227       - GTK_CONTAINER (box)->border_width;
228     secondary_y = allocation->y + GTK_CONTAINER (box)->border_width;
229     break;
230   default:
231     g_assert_not_reached();
232     break;
233   }
234
235   x = allocation->x + (allocation->width - child_width) / 2;
236   childspace = child_height + childspacing;
237
238   children = GTK_BOX (box)->children;
239
240   while (children)
241     {
242       child = children->data;
243       children = children->next;
244
245       if (gtk_widget_get_visible (child->widget))
246         {
247           child_allocation.width = child_width;
248           child_allocation.height = child_height;
249           child_allocation.x = x;
250
251           if (child->is_secondary)
252             {
253               child_allocation.y = secondary_y;
254               secondary_y += childspace;
255             }
256           else
257             {
258               child_allocation.y = y;
259               y += childspace;
260             }
261
262           gtk_widget_size_allocate (child->widget, &child_allocation);
263         }
264     }
265 }
266