Replace "usage" property with a "description" property
[pspp-builds.git] / src / ui / gui / psppire-window.c
1 /* PSPPIRE - a graphical user interface for PSPP.
2    Copyright (C) 2009  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 #include <config.h>
18
19 #include <gtk/gtksignal.h>
20 #include <gtk/gtkwindow.h>
21 #include <gtk/gtkcheckmenuitem.h>
22
23 #include <stdlib.h>
24
25 #include <gettext.h>
26 #define _(msgid) gettext (msgid)
27 #define N_(msgid) msgid
28
29 #include "psppire-window.h"
30 #include "psppire-window-register.h"
31
32 static void psppire_window_base_finalize (PsppireWindowClass *, gpointer);
33 static void psppire_window_base_init     (PsppireWindowClass *class);
34 static void psppire_window_class_init    (PsppireWindowClass *class);
35 static void psppire_window_init          (PsppireWindow      *window);
36
37
38 static PsppireWindowClass *the_class;
39 static GObjectClass *parent_class;
40
41 GType
42 psppire_window_get_type (void)
43 {
44   static GType psppire_window_type = 0;
45
46   if (!psppire_window_type)
47     {
48       static const GTypeInfo psppire_window_info =
49       {
50         sizeof (PsppireWindowClass),
51         (GBaseInitFunc) psppire_window_base_init,
52         (GBaseFinalizeFunc) psppire_window_base_finalize,
53         (GClassInitFunc) psppire_window_class_init,
54         (GClassFinalizeFunc) NULL,
55         NULL,
56         sizeof (PsppireWindow),
57         0,
58         (GInstanceInitFunc) psppire_window_init,
59       };
60
61       psppire_window_type =
62         g_type_register_static (GTK_TYPE_WINDOW, "PsppireWindow",
63                                 &psppire_window_info, 0);
64     }
65
66   return psppire_window_type;
67 }
68
69
70 /* Properties */
71 enum
72 {
73   PROP_0,
74   PROP_FILENAME,
75   PROP_DESCRIPTION
76 };
77
78
79 gchar *
80 uniquify (const gchar *str, int *x)
81 {
82   return g_strdup_printf ("%s%d", str, (*x)++);
83 }
84
85 static gchar mdash[6] = {0,0,0,0,0,0};
86
87 static void
88 psppire_window_set_title (PsppireWindow *window)
89 {
90   gchar *title =
91     g_strdup_printf ( _("%s %s PSPPIRE %s"),
92                       window->basename, mdash, window->description);
93
94   gtk_window_set_title (GTK_WINDOW (window), title);
95
96   free (title);
97 }
98
99 static void
100 psppire_window_set_property (GObject         *object,
101                              guint            prop_id,
102                              const GValue    *value,
103                              GParamSpec      *pspec)
104 {
105   PsppireWindow *window = PSPPIRE_WINDOW (object);
106
107   switch (prop_id)
108     {
109     case PROP_DESCRIPTION:
110       window->description = g_value_dup_string (value);
111       psppire_window_set_title (window);
112       break;
113     case PROP_FILENAME:
114       {
115         PsppireWindowRegister *reg = psppire_window_register_new ();
116
117         gchar *candidate_name ;
118
119         {
120           const gchar *name = g_value_get_string (value);
121           int x = 0;
122           GValue def = {0};
123           g_value_init (&def, pspec->value_type);
124
125           if ( NULL == name)
126             {
127               g_param_value_set_default (pspec, &def);
128               name = g_value_get_string (&def);
129             }
130
131           candidate_name = strdup (name);
132
133           while ( psppire_window_register_lookup (reg, candidate_name))
134             {
135               free (candidate_name);
136               candidate_name = uniquify (name, &x);
137             }
138
139           window->basename = g_path_get_basename (candidate_name);
140
141           g_value_unset (&def);
142         }
143
144         psppire_window_set_title (window);
145
146         if ( window->name)
147           psppire_window_register_remove (reg, window->name);
148
149         free (window->name);
150         window->name = candidate_name;
151
152         psppire_window_register_insert (reg, window, window->name);
153       }
154       break;
155     default:
156       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
157       break;
158     };
159 }
160
161
162 static void
163 psppire_window_get_property (GObject         *object,
164                              guint            prop_id,
165                              GValue          *value,
166                              GParamSpec      *pspec)
167 {
168   PsppireWindow *window = PSPPIRE_WINDOW (object);
169
170   switch (prop_id)
171     {
172     case PROP_FILENAME:
173       g_value_set_string (value, window->name);
174       break;
175     case PROP_DESCRIPTION:
176       g_value_set_string (value, window->description);
177       break;
178     default:
179       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
180       break;
181     };
182 }
183
184
185
186 static void
187 psppire_window_finalize (GObject *object)
188 {
189   PsppireWindow *window = PSPPIRE_WINDOW (object);
190
191   PsppireWindowRegister *reg = psppire_window_register_new ();
192
193   psppire_window_register_remove (reg, window->name);
194   free (window->name);
195   free (window->description);
196
197   g_signal_handler_disconnect (psppire_window_register_new (),
198                                window->remove_handler);
199
200   g_signal_handler_disconnect (psppire_window_register_new (),
201                                window->insert_handler);
202
203   g_hash_table_destroy (window->menuitem_table);
204
205   if (G_OBJECT_CLASS (parent_class)->finalize)
206     G_OBJECT_CLASS (parent_class)->finalize (object);
207 }
208
209
210 static void
211 psppire_window_class_init (PsppireWindowClass *class)
212 {
213   GObjectClass *object_class = G_OBJECT_CLASS (class);
214
215   GParamSpec *description_spec =
216     g_param_spec_string ("description",
217                        "Description",
218                        "A string describing the usage of the window",
219                          "??????", /*Should be overridden by derived classes */
220                        G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE);
221
222   GParamSpec *filename_spec =
223     g_param_spec_string ("filename",
224                        "File name",
225                        "The name of the file associated with this window, if any",
226                          "Untitled",
227                          G_PARAM_CONSTRUCT | G_PARAM_READWRITE);
228
229   g_unichar_to_utf8 (0x2014, mdash);
230
231   object_class->set_property = psppire_window_set_property;
232   object_class->get_property = psppire_window_get_property;
233
234   g_object_class_install_property (object_class,
235                                    PROP_DESCRIPTION,
236                                    description_spec);
237
238   g_object_class_install_property (object_class,
239                                    PROP_FILENAME,
240                                    filename_spec);
241
242   the_class = class;
243   parent_class = g_type_class_peek_parent (class);
244 }
245
246
247 static void
248 psppire_window_base_init (PsppireWindowClass *class)
249 {
250   GObjectClass *object_class = G_OBJECT_CLASS (class);
251
252   object_class->finalize = psppire_window_finalize;
253 }
254
255
256
257 static void
258 psppire_window_base_finalize (PsppireWindowClass *class,
259                                 gpointer class_data)
260 {
261 }
262
263 static void
264 menu_toggled (GtkCheckMenuItem *mi, gpointer data)
265 {
266   /* Prohibit changes to the state */
267   mi->active = !mi->active;
268 }
269
270
271 /* Look up the window associated with this menuitem and present it to the user */
272 static void
273 menu_activate (GtkMenuItem *mi, gpointer data)
274 {
275   const gchar *key = data;
276
277   PsppireWindowRegister *reg = psppire_window_register_new ();
278
279   PsppireWindow *window = psppire_window_register_lookup (reg, key);
280
281   gtk_window_present (GTK_WINDOW (window));
282 }
283
284 static void
285 insert_menuitem_into_menu (PsppireWindow *window, gpointer key)
286 {
287   GtkWidget *item = gtk_check_menu_item_new_with_label (key);
288
289   g_signal_connect (item, "toggled", G_CALLBACK (menu_toggled), NULL);
290   g_signal_connect (item, "activate", G_CALLBACK (menu_activate), key);
291
292   gtk_widget_show (item);
293   
294   gtk_menu_shell_append (window->menu, item);
295
296   /* Set the state without emitting a signal */
297   GTK_CHECK_MENU_ITEM (item)->active =
298    (psppire_window_register_lookup (psppire_window_register_new (), key) == window);
299
300   g_hash_table_insert (window->menuitem_table, key, item);
301 }
302
303 static void
304 insert_item (gpointer key, gpointer value, gpointer data)
305 {
306   PsppireWindow *window = PSPPIRE_WINDOW (data);
307
308   if ( NULL != g_hash_table_lookup (window->menuitem_table, key))
309     return;
310
311   insert_menuitem_into_menu (window, key);
312 }
313
314 /* Insert a new item into the window menu */
315 static void
316 insert_menuitem (GObject *reg, const gchar *key, gpointer data)
317 {
318   PsppireWindow *window = PSPPIRE_WINDOW (data);
319   
320   insert_menuitem_into_menu (window, (gpointer) key);
321 }
322
323
324 static void
325 remove_menuitem (PsppireWindowRegister *reg, const gchar *key, gpointer data)
326 {
327   PsppireWindow *window = PSPPIRE_WINDOW (data);
328   GtkWidget *item ;
329
330   item = g_hash_table_lookup (window->menuitem_table, key);
331
332   g_hash_table_remove (window->menuitem_table, key);
333
334   if (GTK_IS_CONTAINER (window->menu))
335     gtk_container_remove (GTK_CONTAINER (window->menu), item);
336 }
337
338 static void
339 insert_existing_items (PsppireWindow *window)
340 {
341   psppire_window_register_foreach (psppire_window_register_new (), insert_item, window);
342 }
343
344 static void
345 psppire_window_init (PsppireWindow *window)
346 {
347   window->name = NULL;
348   window->menu = NULL;
349
350   window->menuitem_table  = g_hash_table_new (g_str_hash, g_str_equal);
351
352
353   g_signal_connect (window,  "realize", G_CALLBACK (insert_existing_items), NULL);
354
355   window->insert_handler = g_signal_connect (psppire_window_register_new (),
356                                              "inserted",
357                                              G_CALLBACK (insert_menuitem),
358                                              window);
359
360   window->remove_handler = g_signal_connect (psppire_window_register_new (),
361                                              "removed",
362                                              G_CALLBACK (remove_menuitem),
363                                              window);
364 }
365
366
367 GtkWidget*
368 psppire_window_new (void)
369 {
370   return GTK_WIDGET (g_object_new (psppire_window_get_type (),
371                                    "type", GTK_WINDOW_TOPLEVEL,
372                                    NULL));
373 }
374
375
376 const gchar *
377 psppire_window_get_filename (PsppireWindow *w)
378 {
379   const gchar *name = NULL;
380   g_object_get (w, "filename", &name, NULL);
381   return name;
382 }
383
384
385 void
386 psppire_window_set_filename (PsppireWindow *w, const gchar *filename)
387 {
388   g_object_set (w, "filename", filename, NULL);
389 }
390
391 \f
392
393
394 static void
395 minimise_window (gpointer key, gpointer value, gpointer data)
396 {
397   gtk_window_iconify (GTK_WINDOW (value));
398 }
399
400
401 void
402 psppire_window_minimise_all (void)
403 {
404   PsppireWindowRegister *reg = psppire_window_register_new ();
405
406   g_hash_table_foreach (reg->name_table, minimise_window, NULL);
407 }