← Back to branch summary

~ubuntu-branches/ubuntu/maverick/cairo-dock/maverick

« back to all changes in this revision

Viewing changes to src/gldit/cairo-dock-gui-manager.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2010-08-09 23:26:12 UTC
  • mfrom: (1.1.10 upstream)
  • Revision ID: james.westby@ubuntu.com-20100809232612-yp4c6ig3jt1bzpdv
Tags: 2.2.0~0beta4-0ubuntu1
https://launchpad.net/bugs/614624
https://launchpad.net/bugs/518453
https://launchpad.net/bugs/521369
https://launchpad.net/bugs/521762
https://launchpad.net/bugs/526466
https://launchpad.net/bugs/535083
* New Upstream Version (LP: #614624)
* Fixed a few bugs on LP:
 - LP: #518453: Dock appears under all windows
                 (Compiz - fullscreen window)
 - LP: #521369: Separator are not removed when closing
                 grouped windows
 - LP: #521762: Some sentences are not correct
 - LP: #526466: Icons of apps with same class shouldn't
                 be stacked by default
 - LP: #535083: Dialogues looks ugly when a lot of them
                 appears at the same time
 - More details on the 'ChangeLog' file
* debian/rules:
 - Autotools has been replaced by CMake
 - Man pages are now included in the source code
* debian/copyright:
 - Updated with the new pathes and new files
* debian/control:
 - Autotools has been replaced by CMake
 - Added libcurl4-gnutls-dev as Build-deps
 - Bump Standard-Version to 3.9.1
* debian/cairo-dock-core.install:
 - Man pages are now included in the source code
 - All sonames are now installed into lib32 or lib64
* debian/cairo-dock-dev.install:
 - pkgconfig is now installed into lib32 or lib64

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gldit/cairo-dock-gui-manager.c
 
1
/**
 
2
* This file is a part of the Cairo-Dock project
 
3
*
 
4
* Copyright : (C) see the 'copyright' file.
 
5
* E-mail    : see the 'copyright' file.
 
6
*
 
7
* This program is free software; you can redistribute it and/or
 
8
* modify it under the terms of the GNU General Public License
 
9
* as published by the Free Software Foundation; either version 3
 
10
* of the License, or (at your option) any later version.
 
11
*
 
12
* This program is distributed in the hope that it will be useful,
 
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
* GNU General Public License for more details.
 
16
* You should have received a copy of the GNU General Public License
 
17
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
18
*/
 
19
 
 
20
#include <string.h>
 
21
#include <unistd.h>
 
22
#define __USE_XOPEN_EXTENDED
 
23
#include <stdlib.h>
 
24
#include <glib/gstdio.h>
 
25
#include <glib/gi18n.h>
 
26
 
 
27
#include "../config.h"
 
28
#include "cairo-dock-struct.h"
 
29
#include "cairo-dock-modules.h"
 
30
#include "cairo-dock-log.h"
 
31
#include "cairo-dock-gui-factory.h"
 
32
#include "cairo-dock-keyfile-utilities.h"
 
33
#include "cairo-dock-animations.h"
 
34
#include "cairo-dock-draw.h"
 
35
#include "cairo-dock-dialog-manager.h"
 
36
#include "cairo-dock-dock-manager.h"
 
37
#include "cairo-dock-container.h"
 
38
#include "cairo-dock-applications-manager.h"
 
39
#include "cairo-dock-launcher-factory.h"
 
40
#include "cairo-dock-load.h"
 
41
#include "cairo-dock-internal-accessibility.h"
 
42
#include "cairo-dock-desktop-file-factory.h"
 
43
#include "cairo-dock-gui-manager.h"
 
44
 
 
45
#define CAIRO_DOCK_FRAME_MARGIN 6
 
46
 
 
47
extern CairoDock *g_pMainDock;
 
48
extern gchar *g_cCairoDockDataDir;
 
49
 
 
50
static CairoDockGuiBackend *s_pGuiBackend = NULL;
 
51
static CairoDockLauncherGuiBackend *s_pLauncherGuiBackend = NULL;
 
52
 
 
53
  //////////////////////////
 
54
 // MAIN DOCK VISIBILITY //
 
55
//////////////////////////
 
56
 
 
57
static int iNbConfigDialogs = 0;
 
58
int cairo_dock_get_nb_dialog_windows (void)
 
59
{
 
60
        return iNbConfigDialogs;
 
61
}
 
62
 
 
63
void cairo_dock_dialog_window_destroyed (void)
 
64
{
 
65
        /**iNbConfigDialogs --;
 
66
        if (iNbConfigDialogs <= 0)
 
67
        {
 
68
                iNbConfigDialogs = 0;
 
69
                if (g_pMainDock != NULL)  // peut arriver au 1er lancement.
 
70
                        cairo_dock_pop_down (g_pMainDock);
 
71
        }*/
 
72
        //g_print ("iNbConfigDialogs <- %d\n", iNbConfigDialogs);
 
73
}
 
74
 
 
75
void cairo_dock_dialog_window_created (void)
 
76
{
 
77
        /**iNbConfigDialogs ++;
 
78
        //g_print ("iNbConfigDialogs <- %d\n", iNbConfigDialogs);
 
79
        if (g_pMainDock != NULL && cairo_dock_search_window_covering_dock (g_pMainDock, FALSE, TRUE) == NULL)  // peut etre NULL au 1er lancement.
 
80
                cairo_dock_pop_up (g_pMainDock);*/
 
81
}
 
82
 
 
83
 
 
84
  //////////////////////////
 
85
 // DYNAMIC CONFIG PANEL //
 
86
//////////////////////////
 
87
 
 
88
CairoDockGroupKeyWidget *cairo_dock_get_group_key_widget_from_name (const gchar *cGroupName, const gchar *cKeyName)
 
89
{
 
90
        if (s_pGuiBackend && s_pGuiBackend->get_widget_from_name)
 
91
        {
 
92
                return s_pGuiBackend->get_widget_from_name (cGroupName, cKeyName);
 
93
        }
 
94
        return NULL;
 
95
}
 
96
 
 
97
GtkWidget *cairo_dock_get_widget_from_name (const gchar *cGroupName, const gchar *cKeyName)
 
98
{
 
99
        CairoDockGroupKeyWidget *pGroupKeyWidget = cairo_dock_get_group_key_widget_from_name (cGroupName, cKeyName);
 
100
        if (pGroupKeyWidget != NULL && pGroupKeyWidget->pSubWidgetList != NULL)
 
101
                return pGroupKeyWidget->pSubWidgetList->data;
 
102
        return NULL;
 
103
}
 
104
 
 
105
void cairo_dock_reload_current_module_widget_full (CairoDockModuleInstance *pInstance, int iShowPage)
 
106
{
 
107
        g_return_if_fail (pInstance != NULL);
 
108
        if (pInstance->pModule->pVisitCard->cInternalModule != NULL)
 
109
        {
 
110
                cairo_dock_show_module_gui (pInstance->pModule->pVisitCard->cInternalModule);
 
111
        }
 
112
        else
 
113
        {
 
114
                cairo_dock_show_module_instance_gui (pInstance, iShowPage);
 
115
        }
 
116
        /**g_return_if_fail (s_pCurrentGroupWidget != NULL && s_pCurrentGroup != NULL && cairo_dock_get_current_widget_list () != NULL);
 
117
        
 
118
        int iNotebookPage = (GTK_IS_NOTEBOOK (s_pCurrentGroupWidget) ? 
 
119
                (iShowPage >= 0 ?
 
120
                        iShowPage :
 
121
                        gtk_notebook_get_current_page (GTK_NOTEBOOK (s_pCurrentGroupWidget))) :
 
122
                -1);
 
123
        
 
124
        gtk_widget_destroy (s_pCurrentGroupWidget);
 
125
        s_pCurrentGroupWidget = NULL;
 
126
        
 
127
        cairo_dock_reset_current_widget_list ();
 
128
        
 
129
        CairoDockModule *pModule = cairo_dock_find_module_from_name (s_pCurrentGroup->cGroupName);
 
130
        GtkWidget *pWidget;
 
131
        if (pModule != NULL)
 
132
        {
 
133
                pWidget = cairo_dock_present_group_widget (pModule->cConfFilePath, s_pCurrentGroup, FALSE, pInstance);
 
134
        }
 
135
        else
 
136
        {
 
137
                pWidget = cairo_dock_present_group_widget (g_cConfFile, s_pCurrentGroup, TRUE, NULL);
 
138
        }
 
139
        if (iNotebookPage != -1)
 
140
        {
 
141
                gtk_notebook_set_current_page (GTK_NOTEBOOK (s_pCurrentGroupWidget), iNotebookPage);
 
142
        }*/
 
143
}
 
144
 
 
145
 
 
146
void cairo_dock_deactivate_module_in_gui (const gchar *cModuleName)
 
147
{
 
148
        if (s_pGuiBackend && s_pGuiBackend->deactivate_module_in_gui)
 
149
                s_pGuiBackend->deactivate_module_in_gui (cModuleName);
 
150
}
 
151
 
 
152
static gboolean _cairo_dock_module_is_opened (CairoDockModuleInstance *pModuleInstance)
 
153
{
 
154
        if (s_pGuiBackend && s_pGuiBackend->module_is_opened)
 
155
                return s_pGuiBackend->module_is_opened (pModuleInstance);
 
156
        else
 
157
                return FALSE;
 
158
}
 
159
 
 
160
void cairo_dock_update_desklet_size_in_gui (CairoDockModuleInstance *pModuleInstance, int iWidth, int iHeight)
 
161
{
 
162
        if (_cairo_dock_module_is_opened (pModuleInstance))  // on est en train d'editer ce module dans le panneau de conf.
 
163
        {
 
164
                CairoDockGroupKeyWidget *pGroupKeyWidget = cairo_dock_get_group_key_widget_from_name ("Desklet", "size");
 
165
                GtkWidget *pOneWidget;
 
166
                
 
167
                if (pGroupKeyWidget != NULL && pGroupKeyWidget->pSubWidgetList)
 
168
                {
 
169
                        pOneWidget = pGroupKeyWidget->pSubWidgetList->data;
 
170
                        g_signal_handlers_block_matched (pOneWidget,
 
171
                                (GSignalMatchType) G_SIGNAL_MATCH_FUNC,
 
172
                                0, 0, NULL, _cairo_dock_set_value_in_pair, NULL);
 
173
                        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pOneWidget), iWidth);
 
174
                        g_signal_handlers_unblock_matched (pOneWidget,
 
175
                                (GSignalMatchType) G_SIGNAL_MATCH_FUNC,
 
176
                                0, 0, NULL, _cairo_dock_set_value_in_pair, NULL);
 
177
                        
 
178
                        if (pGroupKeyWidget->pSubWidgetList->next != NULL)
 
179
                        {
 
180
                                pOneWidget = pGroupKeyWidget->pSubWidgetList->next->data;
 
181
                                g_signal_handlers_block_matched (pOneWidget,
 
182
                                        (GSignalMatchType) G_SIGNAL_MATCH_FUNC,
 
183
                                        0, 0, NULL, _cairo_dock_set_value_in_pair, NULL);
 
184
                                gtk_spin_button_set_value (GTK_SPIN_BUTTON (pOneWidget), iHeight);
 
185
                                g_signal_handlers_unblock_matched (pOneWidget,
 
186
                                        (GSignalMatchType) G_SIGNAL_MATCH_FUNC,
 
187
                                        0, 0, NULL, _cairo_dock_set_value_in_pair, NULL);
 
188
                        }
 
189
                }
 
190
                
 
191
        }
 
192
}
 
193
 
 
194
void cairo_dock_update_desklet_position_in_gui (CairoDockModuleInstance *pModuleInstance, int x, int y)
 
195
{
 
196
        if (_cairo_dock_module_is_opened (pModuleInstance))  // on est en train d'editer ce module dans le panneau de conf.
 
197
        {
 
198
                GtkWidget *pOneWidget;
 
199
                pOneWidget = cairo_dock_get_widget_from_name ("Desklet", "x position");
 
200
                if (pOneWidget != NULL)
 
201
                        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pOneWidget), x);
 
202
                pOneWidget = cairo_dock_get_widget_from_name ("Desklet", "y position");
 
203
                if (pOneWidget != NULL)
 
204
                        gtk_spin_button_set_value (GTK_SPIN_BUTTON (pOneWidget), y);
 
205
        }
 
206
}
 
207
 
 
208
void cairo_dock_update_desklet_detached_state_in_gui (CairoDockModuleInstance *pModuleInstance, gboolean bIsDetached)
 
209
{
 
210
        if (_cairo_dock_module_is_opened (pModuleInstance))  // on est en train d'editer ce module dans le panneau de conf.
 
211
        {
 
212
                GtkWidget *pOneWidget = cairo_dock_get_widget_from_name ("Desklet", "initially detached");
 
213
                if (pOneWidget != NULL)
 
214
                        gtk_toggle_button_set_active  (GTK_TOGGLE_BUTTON (pOneWidget), bIsDetached);
 
215
        }
 
216
}
 
217
 
 
218
 
 
219
void cairo_dock_set_status_message (GtkWidget *pWindow, const gchar *cMessage)
 
220
{
 
221
        g_print ("%s (%s)\n", __func__, cMessage);
 
222
        GtkWidget *pStatusBar;
 
223
        if (pWindow != NULL)
 
224
        {
 
225
                pStatusBar = g_object_get_data (G_OBJECT (pWindow), "status-bar");
 
226
                if (pStatusBar == NULL)
 
227
                        return ;
 
228
                //g_print ("%s (%s sur %x/%x)\n", __func__, cMessage, pWindow, pStatusBar);
 
229
                gtk_statusbar_pop (GTK_STATUSBAR (pStatusBar), 0);  // clear any previous message, underflow is allowed.
 
230
                gtk_statusbar_push (GTK_STATUSBAR (pStatusBar), 0, cMessage);
 
231
        }
 
232
        else
 
233
        {
 
234
                if (s_pGuiBackend && s_pGuiBackend->set_status_message_on_gui)
 
235
                        s_pGuiBackend->set_status_message_on_gui (cMessage);
 
236
        }
 
237
}
 
238
 
 
239
void cairo_dock_set_status_message_printf (GtkWidget *pWindow, const gchar *cFormat, ...)
 
240
{
 
241
        g_return_if_fail (cFormat != NULL);
 
242
        va_list args;
 
243
        va_start (args, cFormat);
 
244
        gchar *cMessage = g_strdup_vprintf (cFormat, args);
 
245
        cairo_dock_set_status_message (pWindow, cMessage);
 
246
        g_free (cMessage);
 
247
        va_end (args);
 
248
}
 
249
 
 
250
 
 
251
  /////////////////
 
252
 // GUI BACKEND //
 
253
/////////////////
 
254
 
 
255
void cairo_dock_register_gui_backend (CairoDockGuiBackend *pBackend)
 
256
{
 
257
        g_free (s_pGuiBackend);
 
258
        s_pGuiBackend = pBackend;
 
259
}
 
260
 
 
261
GtkWidget *cairo_dock_show_main_gui (void)
 
262
{
 
263
        GtkWidget *pWindow = NULL;
 
264
        if (s_pGuiBackend && s_pGuiBackend->show_main_gui)
 
265
                pWindow = s_pGuiBackend->show_main_gui ();
 
266
        if (pWindow && g_pMainDock != NULL)  // evitons d'empieter sur le main dock.
 
267
        {
 
268
                if (g_pMainDock->container.bIsHorizontal)
 
269
                {
 
270
                        if (g_pMainDock->container.bDirectionUp)
 
271
                                gtk_window_move (GTK_WINDOW (pWindow), 0, 0);
 
272
                        else
 
273
                                gtk_window_move (GTK_WINDOW (pWindow), 0, g_pMainDock->iMinDockHeight+10);
 
274
                }
 
275
                else
 
276
                {
 
277
                        if (g_pMainDock->container.bDirectionUp)
 
278
                                gtk_window_move (GTK_WINDOW (pWindow), 0, 0);
 
279
                        else
 
280
                                gtk_window_move (GTK_WINDOW (pWindow), g_pMainDock->iMinDockHeight+10, 0);
 
281
                }
 
282
        }
 
283
        
 
284
        return pWindow;
 
285
}
 
286
 
 
287
void cairo_dock_show_module_instance_gui (CairoDockModuleInstance *pModuleInstance, int iShowPage)
 
288
{
 
289
        if (s_pGuiBackend && s_pGuiBackend->show_module_instance_gui)
 
290
                s_pGuiBackend->show_module_instance_gui (pModuleInstance, iShowPage);
 
291
}
 
292
 
 
293
void cairo_dock_show_module_gui (const gchar *cModuleName)
 
294
{
 
295
        if (s_pGuiBackend && s_pGuiBackend->show_module_gui)
 
296
                s_pGuiBackend->show_module_gui (cModuleName);
 
297
}
 
298
 
 
299
void cairo_dock_close_gui (void)
 
300
{
 
301
        if (s_pGuiBackend && s_pGuiBackend->close_gui)
 
302
                s_pGuiBackend->close_gui ();
 
303
}
 
304
 
 
305
 
 
306
  ////////////////
 
307
 // NORMAL GUI //
 
308
////////////////
 
309
 
 
310
static gboolean on_delete_generic_gui (GtkWidget *pWidget, GdkEvent *event, GMainLoop *pBlockingLoop)
 
311
{
 
312
        cd_debug ("%s ()\n", __func__);
 
313
        if (pBlockingLoop != NULL && g_main_loop_is_running (pBlockingLoop))
 
314
        {
 
315
                g_main_loop_quit (pBlockingLoop);
 
316
        }
 
317
        
 
318
        gpointer pUserData = g_object_get_data (G_OBJECT (pWidget), "action-data");
 
319
        GFreeFunc pFreeUserData = g_object_get_data (G_OBJECT (pWidget), "free-data");
 
320
        if (pFreeUserData != NULL)
 
321
                pFreeUserData (pUserData);
 
322
        
 
323
        GSList *pWidgetList = g_object_get_data (G_OBJECT (pWidget), "widget-list");
 
324
        cairo_dock_free_generated_widget_list (pWidgetList);
 
325
        
 
326
        GPtrArray *pDataGarbage = g_object_get_data (G_OBJECT (pWidget), "garbage");
 
327
        /// nettoyer.
 
328
        
 
329
        gchar *cConfFilePath = g_object_get_data (G_OBJECT (pWidget), "conf-file");
 
330
        g_free (cConfFilePath);
 
331
        
 
332
        cairo_dock_dialog_window_destroyed ();
 
333
        
 
334
        return (pBlockingLoop != NULL);  // TRUE <=> ne pas detruire la fenetre.
 
335
}
 
336
 
 
337
static void on_click_generic_apply (GtkButton *button, GtkWidget *pWindow)
 
338
{
 
339
        //g_print ("%s ()\n", __func__);
 
340
        GSList *pWidgetList = g_object_get_data (G_OBJECT (pWindow), "widget-list");
 
341
        gchar *cConfFilePath = g_object_get_data (G_OBJECT (pWindow), "conf-file");
 
342
        GKeyFile *pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
343
        g_return_if_fail (pKeyFile != NULL);
 
344
        
 
345
        gchar *cConfModuleName = g_object_get_data (G_OBJECT (pWindow), "module");
 
346
        if (cConfModuleName != NULL)
 
347
        {
 
348
                CairoDockModule *pModule = cairo_dock_find_module_from_name (cConfModuleName);
 
349
                if (pModule != NULL)
 
350
                {
 
351
                        CairoDockModuleInstance *pModuleInstance;
 
352
                        GList *i;
 
353
                        for (i = pModule->pInstancesList; i != NULL; i = i->next)
 
354
                        {
 
355
                                pModuleInstance = i->data;
 
356
                                if (strcmp (cConfFilePath, pModuleInstance->cConfFilePath) == 0)
 
357
                                        break;
 
358
                        }
 
359
                        if (i != NULL)
 
360
                        {
 
361
                                if (pModule->pInterface->save_custom_widget != NULL)
 
362
                                        pModule->pInterface->save_custom_widget (pModuleInstance, pKeyFile);
 
363
                        }
 
364
                }
 
365
        }
 
366
        else
 
367
        {
 
368
                CairoDockSaveCustomWidgetFunc save_custom_widgets = g_object_get_data (G_OBJECT (pWindow), "save-widget");
 
369
                if (save_custom_widgets)
 
370
                        save_custom_widgets (pWindow, pKeyFile);
 
371
        }
 
372
        
 
373
        cairo_dock_update_keyfile_from_widget_list (pKeyFile, pWidgetList);
 
374
        cairo_dock_write_keys_to_file (pKeyFile, cConfFilePath);
 
375
        g_key_file_free (pKeyFile);
 
376
        
 
377
        CairoDockApplyConfigFunc pAction = g_object_get_data (G_OBJECT (pWindow), "action");
 
378
        gpointer pUserData = g_object_get_data (G_OBJECT (pWindow), "action-data");
 
379
        
 
380
        if (pAction != NULL)
 
381
        {
 
382
                gboolean bKeepWindow = pAction (pUserData);
 
383
                if (!bKeepWindow)  // on recharge la fenetre.
 
384
                {
 
385
                        cairo_dock_reload_generic_gui (pWindow);
 
386
                }
 
387
        }
 
388
        else
 
389
                g_object_set_data (G_OBJECT (pWindow), "result", GINT_TO_POINTER (1));
 
390
}
 
391
 
 
392
static void on_click_generic_quit (GtkButton *button, GtkWidget *pWindow)
 
393
{
 
394
        cd_debug ("%s ()\n", __func__);
 
395
        GMainLoop *pBlockingLoop = g_object_get_data (G_OBJECT (pWindow), "loop");
 
396
        
 
397
        gboolean bReturn;
 
398
        g_signal_emit_by_name (pWindow, "delete-event", NULL, &bReturn);
 
399
        ///on_delete_generic_gui (pWindow, NULL, pBlockingLoop);
 
400
        
 
401
        if (pBlockingLoop == NULL)
 
402
                gtk_widget_destroy (pWindow);
 
403
}
 
404
 
 
405
static void on_click_generic_ok (GtkButton *button, GtkWidget *pWindow)
 
406
{
 
407
        //g_print ("%s ()\n", __func__);
 
408
        
 
409
        on_click_generic_apply (button, pWindow);
 
410
        on_click_generic_quit (button, pWindow);
 
411
}
 
412
 
 
413
GtkWidget *cairo_dock_build_generic_gui_window (const gchar *cTitle, int iWidth, int iHeight, CairoDockApplyConfigFunc pAction, gpointer pUserData, GFreeFunc pFreeUserData)
 
414
{
 
415
        //\_____________ On construit la fenetre.
 
416
        GtkWidget *pMainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 
417
        gtk_window_set_icon_from_file (GTK_WINDOW (pMainWindow), CAIRO_DOCK_SHARE_DATA_DIR"/"CAIRO_DOCK_ICON, NULL);
 
418
        if (cTitle != NULL)
 
419
                gtk_window_set_title (GTK_WINDOW (pMainWindow), cTitle);
 
420
        
 
421
        GtkWidget *pMainVBox = gtk_vbox_new (FALSE, CAIRO_DOCK_FRAME_MARGIN);
 
422
        gtk_container_add (GTK_CONTAINER (pMainWindow), pMainVBox);
 
423
        
 
424
        //\_____________ On ajoute les boutons.
 
425
        GtkWidget *pButtonsHBox = gtk_hbox_new (FALSE, CAIRO_DOCK_FRAME_MARGIN*2);
 
426
        gtk_box_pack_end (GTK_BOX (pMainVBox),
 
427
                pButtonsHBox,
 
428
                FALSE,
 
429
                FALSE,
 
430
                0);
 
431
        
 
432
        GtkWidget *pQuitButton = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 
433
        g_signal_connect (G_OBJECT (pQuitButton), "clicked", G_CALLBACK(on_click_generic_quit), pMainWindow);
 
434
        gtk_box_pack_end (GTK_BOX (pButtonsHBox),
 
435
                pQuitButton,
 
436
                FALSE,
 
437
                FALSE,
 
438
                0);
 
439
        
 
440
        if (pAction != NULL)
 
441
        {
 
442
                GtkWidget *pApplyButton = gtk_button_new_from_stock (GTK_STOCK_APPLY);
 
443
                g_signal_connect (G_OBJECT (pApplyButton), "clicked", G_CALLBACK(on_click_generic_apply), pMainWindow);
 
444
                gtk_box_pack_end (GTK_BOX (pButtonsHBox),
 
445
                        pApplyButton,
 
446
                        FALSE,
 
447
                        FALSE,
 
448
                        0);
 
449
        }
 
450
        else
 
451
        {
 
452
                GtkWidget *pApplyButton = gtk_button_new_from_stock (GTK_STOCK_OK);
 
453
                g_signal_connect (G_OBJECT (pApplyButton), "clicked", G_CALLBACK(on_click_generic_ok), pMainWindow);
 
454
                gtk_box_pack_end (GTK_BOX (pButtonsHBox),
 
455
                        pApplyButton,
 
456
                        FALSE,
 
457
                        FALSE,
 
458
                        0);
 
459
        }
 
460
        
 
461
        //\_____________ On ajoute la barre d'etat a la fin.
 
462
        GtkWidget *pStatusBar = gtk_statusbar_new ();
 
463
        gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (pStatusBar), FALSE);
 
464
        gtk_box_pack_start (GTK_BOX (pButtonsHBox),  // pMainVBox
 
465
                pStatusBar,
 
466
                FALSE,
 
467
                FALSE,
 
468
                0);
 
469
        g_object_set_data (G_OBJECT (pMainWindow), "status-bar", pStatusBar);
 
470
        
 
471
        gtk_window_resize (GTK_WINDOW (pMainWindow), iWidth, iHeight);
 
472
        
 
473
        gtk_widget_show_all (pMainWindow);
 
474
        cairo_dock_dialog_window_created ();
 
475
        
 
476
        int iResult = 0;
 
477
        if (pAction != NULL)
 
478
        {
 
479
                g_object_set_data (G_OBJECT (pMainWindow), "action", pAction);
 
480
                g_object_set_data (G_OBJECT (pMainWindow), "action-data", pUserData);
 
481
                g_object_set_data (G_OBJECT (pMainWindow), "free-data", pFreeUserData);
 
482
                g_signal_connect (G_OBJECT (pMainWindow),
 
483
                        "delete-event",
 
484
                        G_CALLBACK (on_delete_generic_gui),
 
485
                        NULL);
 
486
        }
 
487
        return pMainWindow;
 
488
}
 
489
 
 
490
GtkWidget *cairo_dock_build_generic_gui_full (const gchar *cConfFilePath, const gchar *cGettextDomain, const gchar *cTitle, int iWidth, int iHeight, CairoDockApplyConfigFunc pAction, gpointer pUserData, GFreeFunc pFreeUserData, CairoDockLoadCustomWidgetFunc load_custom_widgets, CairoDockSaveCustomWidgetFunc save_custom_widgets)
 
491
{
 
492
        //\_____________ On construit la fenetre.
 
493
        GtkWidget *pMainWindow = cairo_dock_build_generic_gui_window (cTitle, iWidth, iHeight, pAction, pUserData, pFreeUserData);
 
494
        
 
495
        //\_____________ On construit l'IHM du fichier de conf.
 
496
        GKeyFile* pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
497
        
 
498
        GtkWidget *pNoteBook = NULL;
 
499
        GSList *pWidgetList = NULL;
 
500
        GPtrArray *pDataGarbage = g_ptr_array_new ();
 
501
        if (pKeyFile != NULL)
 
502
        {
 
503
                pNoteBook = cairo_dock_build_key_file_widget (pKeyFile,
 
504
                        cGettextDomain,
 
505
                        pMainWindow,
 
506
                        &pWidgetList,
 
507
                        pDataGarbage,
 
508
                        NULL);
 
509
        }
 
510
        
 
511
        g_object_set_data (G_OBJECT (pMainWindow), "conf-file", g_strdup (cConfFilePath));
 
512
        g_object_set_data (G_OBJECT (pMainWindow), "widget-list", pWidgetList);
 
513
        g_object_set_data (G_OBJECT (pMainWindow), "garbage", pDataGarbage);
 
514
        g_object_set_data (G_OBJECT (pMainWindow), "save-widget", save_custom_widgets);
 
515
        g_object_set_data (G_OBJECT (pMainWindow), "load-widget", load_custom_widgets);
 
516
        
 
517
        if (load_custom_widgets)  // a faire apres avoir mis "widget-list".
 
518
                load_custom_widgets (pMainWindow, pKeyFile);
 
519
        
 
520
        g_key_file_free (pKeyFile);
 
521
        
 
522
        //\_____________ On l'insere dans la fenetre.
 
523
        GtkWidget *pMainVBox = gtk_bin_get_child (GTK_BIN (pMainWindow));
 
524
        gtk_box_pack_start (GTK_BOX (pMainVBox),
 
525
                pNoteBook,
 
526
                TRUE,
 
527
                TRUE,
 
528
                0);
 
529
        gtk_widget_show_all (pMainWindow);
 
530
        
 
531
        int iResult = 0;
 
532
        if (pAction == NULL)  // on bloque.
 
533
        {
 
534
                GList *children = gtk_container_get_children (GTK_CONTAINER (pMainVBox));
 
535
                GList *w = g_list_last (children);
 
536
                g_return_val_if_fail (w != NULL, FALSE);
 
537
                GtkWidget *pButtonsHBox = w->data;
 
538
                
 
539
                GtkWidget *pOkButton = gtk_button_new_from_stock (GTK_STOCK_OK);
 
540
                g_signal_connect (G_OBJECT (pOkButton), "clicked", G_CALLBACK(on_click_generic_ok), pMainWindow);
 
541
                gtk_box_pack_end (GTK_BOX (pButtonsHBox),
 
542
                        pOkButton,
 
543
                        FALSE,
 
544
                        FALSE,
 
545
                        0);
 
546
                
 
547
                gtk_window_set_modal (GTK_WINDOW (pMainWindow), TRUE);
 
548
                GMainLoop *pBlockingLoop = g_main_loop_new (NULL, FALSE);
 
549
                g_object_set_data (G_OBJECT (pMainWindow), "loop", pBlockingLoop);
 
550
                g_signal_connect (G_OBJECT (pMainWindow),
 
551
                        "delete-event",
 
552
                        G_CALLBACK (on_delete_generic_gui),
 
553
                        pBlockingLoop);
 
554
 
 
555
                cd_debug ("debut de boucle bloquante ...\n");
 
556
                GDK_THREADS_LEAVE ();
 
557
                g_main_loop_run (pBlockingLoop);
 
558
                GDK_THREADS_ENTER ();
 
559
                cd_debug ("fin de boucle bloquante\n");
 
560
                
 
561
                g_main_loop_unref (pBlockingLoop);
 
562
                g_object_set_data (G_OBJECT (pMainWindow), "loop", NULL);
 
563
                
 
564
                iResult = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (pMainWindow), "result"));
 
565
                cd_debug ("iResult : %d", iResult);
 
566
                gtk_widget_destroy (pMainWindow);
 
567
                pMainWindow = NULL;
 
568
        }
 
569
        
 
570
        return pMainWindow;
 
571
}
 
572
 
 
573
void cairo_dock_reload_generic_gui (GtkWidget *pWindow)
 
574
{
 
575
        //g_print ("%s ()", __func__);
 
576
        GSList *pWidgetList = g_object_get_data (G_OBJECT (pWindow), "widget-list");
 
577
        cairo_dock_free_generated_widget_list (pWidgetList);
 
578
        pWidgetList = NULL;
 
579
        g_object_set_data (G_OBJECT (pWindow), "widget-list", NULL);
 
580
        
 
581
        GPtrArray *pDataGarbage = g_object_get_data (G_OBJECT (pWindow), "garbage");
 
582
        /// nettoyer...
 
583
        g_object_set_data (G_OBJECT (pWindow), "garbage", NULL);
 
584
        
 
585
        GtkWidget *pMainVBox = gtk_bin_get_child (GTK_BIN (pWindow));
 
586
        GList *children = gtk_container_get_children (GTK_CONTAINER (pMainVBox));
 
587
        g_return_if_fail (children != NULL);
 
588
        GtkWidget *pNoteBook = children->data;
 
589
        gtk_widget_destroy (pNoteBook);
 
590
        
 
591
        gchar *cConfFilePath = g_object_get_data (G_OBJECT (pWindow), "conf-file");
 
592
        GKeyFile* pKeyFile = cairo_dock_open_key_file (cConfFilePath);
 
593
        if (pKeyFile != NULL)
 
594
        {
 
595
                pNoteBook = cairo_dock_build_key_file_widget (pKeyFile,
 
596
                        NULL,
 
597
                        pWindow,
 
598
                        &pWidgetList,
 
599
                        pDataGarbage,
 
600
                        NULL);
 
601
        }
 
602
        
 
603
        g_object_set_data (G_OBJECT (pWindow), "widget-list", pWidgetList);
 
604
        g_object_set_data (G_OBJECT (pWindow), "garbage", pDataGarbage);
 
605
        
 
606
        CairoDockLoadCustomWidgetFunc load_custom_widgets = g_object_get_data (G_OBJECT (pWindow), "load-widget");
 
607
        if (load_custom_widgets)  // a faire apres avoir mis "widget-list".
 
608
                load_custom_widgets (pWindow, pKeyFile);
 
609
        
 
610
        g_key_file_free (pKeyFile);
 
611
        
 
612
        gtk_box_pack_start (GTK_BOX (pMainVBox),
 
613
                pNoteBook,
 
614
                TRUE,
 
615
                TRUE,
 
616
                0);
 
617
        gtk_widget_show_all (pNoteBook);
 
618
}
 
619
 
 
620
 
 
621
  //////////////////////////
 
622
 // LAUNCHER GUI BACKEND //
 
623
//////////////////////////
 
624
 
 
625
void cairo_dock_register_launcher_gui_backend (CairoDockLauncherGuiBackend *pBackend)
 
626
{
 
627
        g_free (s_pLauncherGuiBackend);
 
628
        s_pLauncherGuiBackend = pBackend;
 
629
}
 
630
 
 
631
GtkWidget *cairo_dock_build_launcher_gui (Icon *pIcon)
 
632
{
 
633
        if (s_pLauncherGuiBackend && s_pLauncherGuiBackend->show_gui)
 
634
                s_pLauncherGuiBackend->show_gui (pIcon);
 
635
}
 
636
 
 
637
static guint s_iSidRefreshGUI = 0;
 
638
static gboolean _refresh_launcher_gui (gpointer data)
 
639
{
 
640
        if (s_pLauncherGuiBackend && s_pLauncherGuiBackend->refresh_gui)
 
641
                s_pLauncherGuiBackend->refresh_gui ();
 
642
        
 
643
        s_iSidRefreshGUI = 0;
 
644
        return FALSE;
 
645
}
 
646
void cairo_dock_trigger_refresh_launcher_gui (void)
 
647
{
 
648
        if (s_iSidRefreshGUI != 0)
 
649
                return;
 
650
        
 
651
        s_iSidRefreshGUI = g_idle_add ((GSourceFunc) _refresh_launcher_gui, NULL);
 
652
}