← Back to branch summary

~ubuntu-branches/ubuntu/utopic/cairo-dock/utopic

« back to all changes in this revision

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

Tags: upstream-2.3.0~1
Import upstream version 2.3.0~1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gldit/cairo-dock-class-manager.c
24
24
 
25
25
#include <cairo.h>
26
26
 
27
 
#include "cairo-dock-icons.h"
 
27
#include "cairo-dock-icon-factory.h"
 
28
#include "cairo-dock-icon-facility.h"
28
29
#include "cairo-dock-surface-factory.h"
29
30
#include "cairo-dock-log.h"
30
31
#include "cairo-dock-dock-manager.h"
33
34
#include "cairo-dock-config.h"
34
35
#include "cairo-dock-applications-manager.h"
35
36
#include "cairo-dock-draw.h"
36
 
#include "cairo-dock-load.h"
37
 
#include "cairo-dock-icon-loader.h"
38
 
#include "cairo-dock-internal-taskbar.h"
39
 
#include "cairo-dock-internal-icons.h"
40
 
#include "cairo-dock-internal-indicators.h"
 
37
#include "cairo-dock-image-buffer.h"
 
38
#include "cairo-dock-icon-manager.h"
 
39
#include "cairo-dock-indicator-manager.h"
41
40
#include "cairo-dock-container.h"
42
41
#include "cairo-dock-animations.h"
43
42
#include "cairo-dock-application-facility.h"
 
43
#include "cairo-dock-keyfile-utilities.h"
 
44
#include "cairo-dock-file-manager.h"
44
45
#include "cairo-dock-class-manager.h"
45
46
 
46
47
extern CairoDock *g_pMainDock;
 
48
extern CairoDockDesktopEnv g_iDesktopEnv;
47
49
 
48
50
static GHashTable *s_hClassTable = NULL;
49
51
 
 
52
static void cairo_dock_free_class_appli (CairoDockClassAppli *pClassAppli);
 
53
 
50
54
 
51
55
void cairo_dock_initialize_class_manager (void)
52
56
{
58
62
}
59
63
 
60
64
 
61
 
static CairoDockClassAppli *cairo_dock_find_class_appli (const gchar *cClass)
 
65
static CairoDockClassAppli *_cairo_dock_lookup_class_appli (const gchar *cClass)
62
66
{
63
67
        return (cClass != NULL ? g_hash_table_lookup (s_hClassTable, cClass) : NULL);
64
68
}
67
71
{
68
72
        g_return_val_if_fail (cClass != NULL, NULL);
69
73
        
70
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
74
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
71
75
        return (pClassAppli != NULL ? pClassAppli->pAppliOfClass : NULL);
72
76
}
73
77
 
74
78
 
75
 
static void _cairo_dock_set_same_indicator_on_sub_dock (Icon *pInhibhatorIcon)
76
 
{
77
 
        CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibhatorIcon->cParentDockName);
78
 
        if (pInhibhatorDock != NULL && pInhibhatorDock->iRefCount > 0)  // l'inhibiteur est dans un sous-dock.
79
 
        {
80
 
                gboolean bSubDockHasIndicator = FALSE;
81
 
                if (pInhibhatorIcon->bHasIndicator)
82
 
                {
83
 
                        bSubDockHasIndicator = TRUE;
84
 
                }
85
 
                else
86
 
                {
87
 
                        GList* ic;
88
 
                        Icon *icon;
89
 
                        for (ic =pInhibhatorDock->icons ; ic != NULL; ic = ic->next)
90
 
                        {
91
 
                                icon = ic->data;
92
 
                                if (icon->bHasIndicator)
93
 
                                {
94
 
                                        bSubDockHasIndicator = TRUE;
95
 
                                        break;
96
 
                                }
97
 
                        }
98
 
                }
99
 
                CairoDock *pParentDock = NULL;
100
 
                Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pInhibhatorDock, &pParentDock);
101
 
                if (pPointingIcon != NULL && pPointingIcon->bHasIndicator != bSubDockHasIndicator)
102
 
                {
103
 
                        cd_message ("  pour le sous-dock %s : indicateur <- %d", pPointingIcon->cName, bSubDockHasIndicator);
104
 
                        pPointingIcon->bHasIndicator = bSubDockHasIndicator;
105
 
                        if (pParentDock != NULL)
106
 
                                cairo_dock_redraw_icon (pPointingIcon, CAIRO_CONTAINER (pParentDock));
107
 
                }
108
 
        }
109
 
}
110
 
 
111
 
void cairo_dock_free_class_appli (CairoDockClassAppli *pClassAppli)
112
 
{
113
 
        GList *pElement;
114
 
        Icon *pInhibatorIcon;
115
 
        for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
116
 
        {
117
 
                pInhibatorIcon = pElement->data;
118
 
                cd_message ("%s perd sa mana", pInhibatorIcon->cName);
119
 
                pInhibatorIcon->Xid = 0;
120
 
                pInhibatorIcon->bHasIndicator = FALSE;
121
 
                _cairo_dock_set_same_indicator_on_sub_dock (pInhibatorIcon);
122
 
        }
 
79
static void cairo_dock_free_class_appli (CairoDockClassAppli *pClassAppli)
 
80
{
123
81
        g_list_free (pClassAppli->pIconsOfClass);
124
82
        g_list_free (pClassAppli->pAppliOfClass);
 
83
        g_free (pClassAppli->cDesktopFile);
 
84
        if (pClassAppli->pMimeTypes)
 
85
                g_strfreev (pClassAppli->pMimeTypes);
125
86
        g_free (pClassAppli);
126
87
}
127
88
 
129
90
{
130
91
        g_return_val_if_fail (cClass != NULL, NULL);
131
92
        
132
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
93
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
133
94
        if (pClassAppli == NULL)
134
95
        {
135
96
                pClassAppli = g_new0 (CairoDockClassAppli, 1);
138
99
        return pClassAppli;
139
100
}
140
101
 
141
 
gboolean cairo_dock_add_inhibator_to_class (const gchar *cClass, Icon *pIcon)
 
102
static gboolean _cairo_dock_add_inhibitor_to_class (const gchar *cClass, Icon *pIcon)
142
103
{
143
104
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
144
105
        g_return_val_if_fail (pClassAppli!= NULL, FALSE);
212
173
}
213
174
 
214
175
 
 
176
static void _cairo_dock_set_same_indicator_on_sub_dock (Icon *pInhibhatorIcon)
 
177
{
 
178
        CairoDock *pInhibatorDock = cairo_dock_search_dock_from_name (pInhibhatorIcon->cParentDockName);
 
179
        if (pInhibatorDock != NULL && pInhibatorDock->iRefCount > 0)  // l'inhibiteur est dans un sous-dock.
 
180
        {
 
181
                gboolean bSubDockHasIndicator = FALSE;
 
182
                if (pInhibhatorIcon->bHasIndicator)
 
183
                {
 
184
                        bSubDockHasIndicator = TRUE;
 
185
                }
 
186
                else
 
187
                {
 
188
                        GList* ic;
 
189
                        Icon *icon;
 
190
                        for (ic =pInhibatorDock->icons ; ic != NULL; ic = ic->next)
 
191
                        {
 
192
                                icon = ic->data;
 
193
                                if (icon->bHasIndicator)
 
194
                                {
 
195
                                        bSubDockHasIndicator = TRUE;
 
196
                                        break;
 
197
                                }
 
198
                        }
 
199
                }
 
200
                CairoDock *pParentDock = NULL;
 
201
                Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pInhibatorDock, &pParentDock);
 
202
                if (pPointingIcon != NULL && pPointingIcon->bHasIndicator != bSubDockHasIndicator)
 
203
                {
 
204
                        cd_message ("  pour le sous-dock %s : indicateur <- %d", pPointingIcon->cName, bSubDockHasIndicator);
 
205
                        pPointingIcon->bHasIndicator = bSubDockHasIndicator;
 
206
                        if (pParentDock != NULL)
 
207
                                cairo_dock_redraw_icon (pPointingIcon, CAIRO_CONTAINER (pParentDock));
 
208
                }
 
209
        }
 
210
}
 
211
 
215
212
static Window _cairo_dock_detach_appli_of_class (const gchar *cClass, gboolean bDetachAll)
216
213
{
217
214
        g_return_val_if_fail (cClass != NULL, 0);
232
229
                cd_debug ("detachement de l'icone %s (%d;%d)", pIcon->cName, bDetachAll, XFirstFoundId);
233
230
                gchar *cParentDockName = pIcon->cParentDockName;
234
231
                pIcon->cParentDockName = NULL;  // astuce.
235
 
                bDetached = cairo_dock_detach_icon_from_dock (pIcon, pParentDock, myIcons.iSeparateIcons);
 
232
                bDetached = cairo_dock_detach_icon_from_dock (pIcon, pParentDock, myIconsParam.iSeparateIcons);
236
233
                if (bDetached)  // detachee => on met a jour son dock.
237
234
                {
238
235
                        if (! pParentDock->bIsMainDock)  // sous-dock de classe => on le met a jour / detruit.
275
272
        }
276
273
        return XFirstFoundId;
277
274
}
278
 
gboolean cairo_dock_inhibate_class (const gchar *cClass, Icon *pInhibatorIcon)
 
275
gboolean cairo_dock_inhibite_class (const gchar *cClass, Icon *pInhibitorIcon)
279
276
{
280
277
        g_return_val_if_fail (cClass != NULL, FALSE);
281
278
        cd_message ("%s (%s)", __func__, cClass);
282
279
        
283
 
        if (! cairo_dock_add_inhibator_to_class (cClass, pInhibatorIcon))  // on l'insere avant pour que les icones des applis puissent le trouver et prendre sa surface si necessaire.
 
280
        // add inhibitor to class (first, so that applis can find it and take its surface if neccessary)
 
281
        if (! _cairo_dock_add_inhibitor_to_class (cClass, pInhibitorIcon))
284
282
                return FALSE;
285
283
        
286
 
        Window XFirstFoundId = _cairo_dock_detach_appli_of_class (cClass, (TRUE));
287
 
        if (pInhibatorIcon != NULL)
288
 
        {
289
 
                pInhibatorIcon->Xid = XFirstFoundId;
290
 
                pInhibatorIcon->bHasIndicator = (XFirstFoundId > 0);
291
 
                _cairo_dock_set_same_indicator_on_sub_dock (pInhibatorIcon);
292
 
                if (pInhibatorIcon->cClass != cClass)
293
 
                {
294
 
                        g_free (pInhibatorIcon->cClass);
295
 
                        pInhibatorIcon->cClass = g_strdup (cClass);
296
 
                }
 
284
        // set class name on the inhibitor if not already done.
 
285
        if (pInhibitorIcon && pInhibitorIcon->cClass != cClass)
 
286
        {
 
287
                g_free (pInhibitorIcon->cClass);
 
288
                pInhibitorIcon->cClass = g_strdup (cClass);
 
289
        }
 
290
 
 
291
        // if launchers are mixed with applis, steal applis icons.
 
292
        if (!myTaskbarParam.bMixLauncherAppli)
 
293
                return TRUE;
 
294
        Window XFirstFoundId = _cairo_dock_detach_appli_of_class (cClass, TRUE);  // detach existing applis, and then retach them to the inhibitor.
 
295
        if (pInhibitorIcon != NULL)
 
296
        {
 
297
                // inhibitor takes control of the first existing appli of the class.
 
298
                pInhibitorIcon->Xid = XFirstFoundId;
 
299
                pInhibitorIcon->bHasIndicator = (XFirstFoundId > 0);
 
300
                _cairo_dock_set_same_indicator_on_sub_dock (pInhibitorIcon);
297
301
                
 
302
                // other applis icons are retached to the inhibitor.
298
303
                const GList *pList = cairo_dock_list_existing_appli_with_class (cClass);
299
304
                Icon *pIcon;
300
305
                const GList *pElement;
302
307
                {
303
308
                        pIcon = pElement->data;
304
309
                        cd_debug ("une appli detachee (%s)", pIcon->cParentDockName);
305
 
                        if (pIcon->Xid != XFirstFoundId && pIcon->cParentDockName == NULL)  // s'est faite detacher et doit etre rattacher.
 
310
                        if (pIcon->Xid != XFirstFoundId && pIcon->cParentDockName == NULL)  // s'est faite detacher et doit etre rattachee.
306
311
                                cairo_dock_insert_appli_in_dock (pIcon, g_pMainDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
307
312
                }
308
313
        }
310
315
        return TRUE;
311
316
}
312
317
 
313
 
gboolean cairo_dock_class_is_inhibated (const gchar *cClass)
 
318
gboolean cairo_dock_class_is_inhibited (const gchar *cClass)
314
319
{
315
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
320
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
316
321
        return (pClassAppli != NULL && pClassAppli->pIconsOfClass != NULL);
317
322
}
318
323
 
319
324
gboolean cairo_dock_class_is_using_xicon (const gchar *cClass)
320
325
{
321
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
326
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
322
327
        return (pClassAppli != NULL && pClassAppli->bUseXIcon);  // si pClassAppli == NULL, il n'y a pas de lanceur pouvant lui filer son icone, mais on peut en trouver une dans le theme d'icones systeme.
323
328
}
324
329
 
325
330
gboolean cairo_dock_class_is_expanded (const gchar *cClass)
326
331
{
327
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
332
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
328
333
        return (pClassAppli != NULL && pClassAppli->bExpand);
329
334
}
330
335
 
331
 
gboolean cairo_dock_prevent_inhibated_class (Icon *pIcon)
 
336
gboolean cairo_dock_prevent_inhibited_class (Icon *pIcon)
332
337
{
333
338
        g_return_val_if_fail (pIcon != NULL, FALSE);
334
339
        //g_print ("%s (%s)\n", __func__, pIcon->cClass);
335
340
        
336
341
        gboolean bToBeInhibited = FALSE;
337
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (pIcon->cClass);
 
342
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (pIcon->cClass);
338
343
        if (pClassAppli != NULL)
339
344
        {
340
 
                Icon *pInhibatorIcon;
 
345
                Icon *pInhibitorIcon;
341
346
                GList *pElement;
342
347
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
343
348
                {
344
 
                        pInhibatorIcon = pElement->data;
345
 
                        if (pInhibatorIcon != NULL)  // un inhibiteur est present.
 
349
                        pInhibitorIcon = pElement->data;
 
350
                        if (pInhibitorIcon != NULL)  // un inhibiteur est present.
346
351
                        {
347
 
                                if (pInhibatorIcon->Xid == 0 && pInhibatorIcon->pSubDock == NULL)  // cette icone inhibe cette classe mais ne controle encore aucune appli, on s'y asservit.
 
352
                                if (pInhibitorIcon->Xid == 0 && pInhibitorIcon->pSubDock == NULL)  // cette icone inhibe cette classe mais ne controle encore aucune appli, on s'y asservit.
348
353
                                {
349
 
                                        pInhibatorIcon->Xid = pIcon->Xid;
350
 
                                        pInhibatorIcon->bIsHidden = pIcon->bIsHidden;
351
 
                                        cd_message (">>> %s prendra un indicateur au prochain redraw ! (Xid : %d)", pInhibatorIcon->cName, pInhibatorIcon->Xid);
352
 
                                        pInhibatorIcon->bHasIndicator = TRUE;
353
 
                                        _cairo_dock_set_same_indicator_on_sub_dock (pInhibatorIcon);
 
354
                                        pInhibitorIcon->Xid = pIcon->Xid;
 
355
                                        pInhibitorIcon->bIsHidden = pIcon->bIsHidden;
 
356
                                        cd_message (">>> %s prendra un indicateur au prochain redraw ! (Xid : %d)", pInhibitorIcon->cName, pInhibitorIcon->Xid);
 
357
                                        pInhibitorIcon->bHasIndicator = TRUE;
 
358
                                        _cairo_dock_set_same_indicator_on_sub_dock (pInhibitorIcon);
354
359
                                }
355
360
                                
356
 
                                if (pInhibatorIcon->Xid == pIcon->Xid)  // cette icone nous controle.
 
361
                                if (pInhibitorIcon->Xid == pIcon->Xid)  // cette icone nous controle.
357
362
                                {
358
 
                                        CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
363
                                        CairoDock *pInhibatorDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
359
364
                                        //\______________ On place l'icone pour X.
360
365
                                        if (! bToBeInhibited)  // on ne met le thumbnail que sur la 1ere.
361
366
                                        {
362
 
                                                if (pInhibhatorDock != NULL)
 
367
                                                if (pInhibatorDock != NULL)
363
368
                                                {
364
 
                                                        //g_print ("on positionne la miniature sur l'inhibiteur %s\n", pInhibatorIcon->cName);
365
 
                                                        cairo_dock_set_one_icon_geometry_for_window_manager (pInhibatorIcon, pInhibhatorDock);
 
369
                                                        //g_print ("on positionne la miniature sur l'inhibiteur %s\n", pInhibitorIcon->cName);
 
370
                                                        cairo_dock_set_one_icon_geometry_for_window_manager (pInhibitorIcon, pInhibatorDock);
366
371
                                                }
367
372
                                                bToBeInhibited = TRUE;
368
373
                                        }
369
374
                                        //\______________ On met a jour l'etiquette de l'inhibiteur.
370
 
                                        if (pInhibhatorDock != NULL && pIcon->cName != NULL)
 
375
                                        if (pInhibatorDock != NULL && pIcon->cName != NULL)
371
376
                                        {
372
 
                                                if (pInhibatorIcon->cInitialName == NULL)
373
 
                                                        pInhibatorIcon->cInitialName = pInhibatorIcon->cName;
 
377
                                                if (pInhibitorIcon->cInitialName == NULL)
 
378
                                                        pInhibitorIcon->cInitialName = pInhibitorIcon->cName;
374
379
                                                else
375
 
                                                        g_free (pInhibatorIcon->cName);
376
 
                                                pInhibatorIcon->cName = NULL;
377
 
                                                cairo_dock_set_icon_name (pIcon->cName, pInhibatorIcon, CAIRO_CONTAINER (pInhibhatorDock));
 
380
                                                        g_free (pInhibitorIcon->cName);
 
381
                                                pInhibitorIcon->cName = NULL;
 
382
                                                cairo_dock_set_icon_name (pIcon->cName, pInhibitorIcon, CAIRO_CONTAINER (pInhibatorDock));
378
383
                                        }
379
384
                                }
380
385
                        }
384
389
}
385
390
 
386
391
 
387
 
gboolean cairo_dock_remove_icon_from_class (Icon *pInhibatorIcon)
 
392
static gboolean _cairo_dock_remove_icon_from_class (Icon *pInhibitorIcon)
388
393
{
389
 
        g_return_val_if_fail (pInhibatorIcon != NULL, FALSE);
390
 
        cd_message ("%s (%s)", __func__, pInhibatorIcon->cClass);
 
394
        g_return_val_if_fail (pInhibitorIcon != NULL, FALSE);
 
395
        cd_message ("%s (%s)", __func__, pInhibitorIcon->cClass);
391
396
        
392
 
        gboolean bStillInhibated = FALSE;
393
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (pInhibatorIcon->cClass);
 
397
        gboolean bStillInhibited = FALSE;
 
398
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (pInhibitorIcon->cClass);
394
399
        if (pClassAppli != NULL)
395
400
        {
396
 
                pClassAppli->pIconsOfClass = g_list_remove (pClassAppli->pIconsOfClass, pInhibatorIcon);
 
401
                pClassAppli->pIconsOfClass = g_list_remove (pClassAppli->pIconsOfClass, pInhibitorIcon);
397
402
                if (pClassAppli->pIconsOfClass == NULL && pClassAppli->pAppliOfClass == NULL && ! pClassAppli->bUseXIcon)  // cette classe ne sert plus a rien.
398
403
                {
399
404
                        cd_message ("  cette classe n'a plus d'interet");
400
 
                        g_hash_table_remove (s_hClassTable, pInhibatorIcon->cClass);  // detruit pClassAppli.
401
 
                        bStillInhibated = FALSE;
 
405
                        g_hash_table_remove (s_hClassTable, pInhibitorIcon->cClass);  // detruit pClassAppli.
 
406
                        bStillInhibited = FALSE;
402
407
                }
403
408
                else
404
 
                        bStillInhibated = (pClassAppli->pIconsOfClass != NULL);
 
409
                        bStillInhibited = (pClassAppli->pIconsOfClass != NULL);
405
410
        }
406
 
        return bStillInhibated;
 
411
        return bStillInhibited;
407
412
}
408
413
 
409
 
void cairo_dock_deinhibate_class (const gchar *cClass, Icon *pInhibatorIcon)
 
414
void cairo_dock_deinhibite_class (const gchar *cClass, Icon *pInhibitorIcon)
410
415
{
411
416
        cd_message ("%s (%s)", __func__, cClass);
412
 
        gboolean bStillInhibated = cairo_dock_remove_icon_from_class (pInhibatorIcon);
413
 
        cd_debug (" bStillInhibated : %d", bStillInhibated);
414
 
        ///if (! bStillInhibated)  // il n'y a plus personne dans cette classe.
 
417
        gboolean bStillInhibited = _cairo_dock_remove_icon_from_class (pInhibitorIcon);
 
418
        cd_debug (" bStillInhibited : %d", bStillInhibited);
 
419
        ///if (! bStillInhibited)  // il n'y a plus personne dans cette classe.
415
420
        ///     return ;
416
421
        
417
 
        if (pInhibatorIcon == NULL || pInhibatorIcon->Xid != 0)
 
422
        if (pInhibitorIcon == NULL || pInhibitorIcon->Xid != 0)
418
423
        {
419
424
                const GList *pList = cairo_dock_list_existing_appli_with_class (cClass);
420
425
                Icon *pIcon;
424
429
                for (pElement = pList; pElement != NULL; pElement = pElement->next)
425
430
                {
426
431
                        pIcon = pElement->data;
427
 
                        if (pInhibatorIcon == NULL || pIcon->Xid == pInhibatorIcon->Xid)
 
432
                        if (pInhibitorIcon == NULL || pIcon->Xid == pInhibitorIcon->Xid)
428
433
                        {
429
434
                                cd_message ("rajout de l'icone precedemment inhibee (Xid:%d)", pIcon->Xid);
430
435
                                pIcon->fInsertRemoveFactor = 0;
431
436
                                pIcon->fScale = 1.;
432
437
                                pParentDock = cairo_dock_insert_appli_in_dock (pIcon, g_pMainDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
433
438
                                bNeedsRedraw = (pParentDock != NULL && pParentDock->bIsMainDock);
434
 
                                //if (pInhibatorIcon != NULL)
 
439
                                //if (pInhibitorIcon != NULL)
435
440
                                //      break ;
436
441
                        }
437
442
                        pParentDock = cairo_dock_search_dock_from_name (pIcon->cParentDockName);
440
445
                if (bNeedsRedraw)
441
446
                        gtk_widget_queue_draw (g_pMainDock->container.pWidget);  /// pDock->pRenderer->calculate_icons (pDock); ?...
442
447
        }
443
 
        if (pInhibatorIcon != NULL)
 
448
        if (pInhibitorIcon != NULL)
444
449
        {
445
450
                cd_message (" l'inhibiteur a perdu toute sa mana");
446
 
                pInhibatorIcon->Xid = 0;
447
 
                pInhibatorIcon->bHasIndicator = FALSE;
448
 
                g_free (pInhibatorIcon->cClass);
449
 
                pInhibatorIcon->cClass = NULL;
 
451
                pInhibitorIcon->Xid = 0;
 
452
                pInhibitorIcon->bHasIndicator = FALSE;
 
453
                g_free (pInhibitorIcon->cClass);
 
454
                pInhibitorIcon->cClass = NULL;
450
455
                cd_debug ("  plus de classe");
451
456
        }
452
457
}
453
458
 
454
459
 
455
 
void cairo_dock_update_Xid_on_inhibators (Window Xid, const gchar *cClass)
 
460
void cairo_dock_update_Xid_on_inhibitors (Window Xid, const gchar *cClass)
456
461
{
457
462
        cd_message ("%s (%s)", __func__, cClass);
458
 
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
463
        CairoDockClassAppli *pClassAppli = _cairo_dock_lookup_class_appli (cClass);
459
464
        if (pClassAppli != NULL)
460
465
        {
461
466
                int iNextXid = -1;
488
493
                                                CairoDock *pClassSubDock = cairo_dock_search_dock_from_name (pSameClassIcon->cParentDockName);
489
494
                                                if (pClassSubDock != NULL)
490
495
                                                {
491
 
                                                        cairo_dock_detach_icon_from_dock (pSameClassIcon, pClassSubDock, myIcons.iSeparateIcons);
 
496
                                                        cairo_dock_detach_icon_from_dock (pSameClassIcon, pClassSubDock, myIconsParam.iSeparateIcons);
492
497
                                                        if (pClassSubDock->icons == NULL && pClassSubDock == cairo_dock_search_dock_from_name (cClass))  // le sous-dock de la classe devient vide.
493
498
                                                                cairo_dock_destroy_dock (pClassSubDock, cClass);
494
499
                                                        else
510
515
        g_list_free (pClassAppli->pAppliOfClass);
511
516
        pClassAppli->pAppliOfClass = NULL;
512
517
        
513
 
        Icon *pInhibatorIcon;
 
518
        Icon *pInhibitorIcon;
514
519
        GList *pElement;
515
520
        for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
516
521
        {
517
 
                pInhibatorIcon = pElement->data;
518
 
                pInhibatorIcon->bHasIndicator = FALSE;
519
 
                pInhibatorIcon->Xid = 0;
520
 
                _cairo_dock_set_same_indicator_on_sub_dock (pInhibatorIcon);
 
522
                pInhibitorIcon = pElement->data;
 
523
                pInhibitorIcon->bHasIndicator = FALSE;
 
524
                pInhibitorIcon->Xid = 0;
 
525
                _cairo_dock_set_same_indicator_on_sub_dock (pInhibitorIcon);
521
526
        }
522
527
}
523
 
void cairo_dock_remove_all_applis_from_class_table (void)
 
528
void cairo_dock_remove_all_applis_from_class_table (void)  // pour le stop_application_manager
524
529
{
525
530
        g_hash_table_foreach (s_hClassTable, (GHFunc) _cairo_dock_remove_all_applis_from_class, NULL);
526
531
}
532
537
 
533
538
 
534
539
 
535
 
cairo_surface_t *cairo_dock_duplicate_inhibator_surface_for_appli (Icon *pInhibatorIcon, int iWidth, int iHeight)
 
540
cairo_surface_t *cairo_dock_duplicate_inhibitor_surface_for_appli (Icon *pInhibitorIcon, int iWidth, int iHeight)
536
541
{
537
 
        CairoContainer *pInhibhatorContainer = cairo_dock_search_container_from_icon (pInhibatorIcon);
 
542
        CairoContainer *pInhibhatorContainer = cairo_dock_search_container_from_icon (pInhibitorIcon);
538
543
        int w, h;
539
 
        cairo_dock_get_icon_extent (pInhibatorIcon, pInhibhatorContainer, &w, &h);
 
544
        cairo_dock_get_icon_extent (pInhibitorIcon, pInhibhatorContainer, &w, &h);
540
545
        
541
 
        return cairo_dock_duplicate_surface (pInhibatorIcon->pIconBuffer,
 
546
        return cairo_dock_duplicate_surface (pInhibitorIcon->pIconBuffer,
542
547
                w,
543
548
                h,
544
549
                iWidth,
555
560
                        return NULL;
556
561
                
557
562
                GList *pElement;
558
 
                Icon *pInhibatorIcon;
 
563
                Icon *pInhibitorIcon;
559
564
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
560
565
                {
561
 
                        pInhibatorIcon = pElement->data;
562
 
                        cd_debug ("  %s", pInhibatorIcon->cName);
563
 
                        if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibatorIcon))
 
566
                        pInhibitorIcon = pElement->data;
 
567
                        cd_debug ("  %s", pInhibitorIcon->cName);
 
568
                        if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibitorIcon))
564
569
                        {
565
 
                                if (pInhibatorIcon->pSubDock == NULL || myIndicators.bUseClassIndic)  // dans le cas d'un lanceur qui aurait deja plusieurs instances de sa classe, et qui les representerait en pile, on ne prend pas son icone.
566
 
                                {
567
 
                                        cd_debug ("%s va fournir genereusement sa surface", pInhibatorIcon->cName);
568
 
                                        return cairo_dock_duplicate_inhibator_surface_for_appli (pInhibatorIcon, iWidth, iHeight);
 
570
                                if (pInhibitorIcon->pSubDock == NULL || myIndicatorsParam.bUseClassIndic)  // dans le cas d'un lanceur qui aurait deja plusieurs instances de sa classe, et qui les representerait en pile, on ne prend pas son icone.
 
571
                                {
 
572
                                        cd_debug ("%s va fournir genereusement sa surface", pInhibitorIcon->cName);
 
573
                                        return cairo_dock_duplicate_inhibitor_surface_for_appli (pInhibitorIcon, iWidth, iHeight);
 
574
                                }
 
575
                                else if (pInhibitorIcon->cFileName != NULL)
 
576
                                {
 
577
                                        gchar *cIconFilePath = cairo_dock_search_icon_s_path (pInhibitorIcon->cFileName);
 
578
                                        if (cIconFilePath != NULL)
 
579
                                        {
 
580
                                                cd_debug ("on remplace l'icone X par %s", cIconFilePath);
 
581
                                                cairo_surface_t *pSurface = cairo_dock_create_surface_from_image_simple (cIconFilePath,
 
582
                                                        iWidth,
 
583
                                                        iHeight);
 
584
                                                g_free (cIconFilePath);
 
585
                                                return pSurface;
 
586
                                        }
569
587
                                }
570
588
                        }
571
589
                }
587
605
}
588
606
 
589
607
 
590
 
void cairo_dock_update_visibility_on_inhibators (const gchar *cClass, Window Xid, gboolean bIsHidden)
 
608
void cairo_dock_update_visibility_on_inhibitors (const gchar *cClass, Window Xid, gboolean bIsHidden)
591
609
{
592
610
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
593
611
        if (pClassAppli != NULL)
594
612
        {
595
613
                GList *pElement;
596
 
                Icon *pInhibatorIcon;
 
614
                Icon *pInhibitorIcon;
597
615
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
598
616
                {
599
 
                        pInhibatorIcon = pElement->data;
 
617
                        pInhibitorIcon = pElement->data;
600
618
                        
601
 
                        if (pInhibatorIcon->Xid == Xid)
 
619
                        if (pInhibitorIcon->Xid == Xid)
602
620
                        {
603
 
                                cd_debug (" %s aussi se %s", pInhibatorIcon->cName, (bIsHidden ? "cache" : "montre"));
604
 
                                pInhibatorIcon->bIsHidden = bIsHidden;
605
 
                                if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibatorIcon) && myTaskBar.fVisibleAppliAlpha != 0)
 
621
                                cd_debug (" %s aussi se %s", pInhibitorIcon->cName, (bIsHidden ? "cache" : "montre"));
 
622
                                pInhibitorIcon->bIsHidden = bIsHidden;
 
623
                                if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibitorIcon) && myTaskbarParam.fVisibleAppliAlpha != 0)
606
624
                                {
607
 
                                        CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
608
 
                                        pInhibatorIcon->fAlpha = 1;  // on triche un peu.
609
 
                                        cairo_dock_redraw_icon (pInhibatorIcon, CAIRO_CONTAINER (pInhibhatorDock));
 
625
                                        CairoDock *pInhibatorDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
 
626
                                        pInhibitorIcon->fAlpha = 1;  // on triche un peu.
 
627
                                        cairo_dock_redraw_icon (pInhibitorIcon, CAIRO_CONTAINER (pInhibatorDock));
610
628
                                }
611
629
                        }
612
630
                }
613
631
        }
614
632
}
615
633
 
616
 
void cairo_dock_update_activity_on_inhibators (const gchar *cClass, Window Xid)
 
634
void cairo_dock_update_activity_on_inhibitors (const gchar *cClass, Window Xid)
617
635
{
618
636
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
619
637
        if (pClassAppli != NULL)
620
638
        {
621
639
                GList *pElement;
622
 
                Icon *pInhibatorIcon;
 
640
                Icon *pInhibitorIcon;
623
641
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
624
642
                {
625
 
                        pInhibatorIcon = pElement->data;
 
643
                        pInhibitorIcon = pElement->data;
626
644
                        
627
 
                        if (pInhibatorIcon->Xid == Xid)
 
645
                        if (pInhibitorIcon->Xid == Xid)
628
646
                        {
629
 
                                cd_debug (" %s aussi devient active", pInhibatorIcon->cName);
630
 
                                ///pInhibatorIcon->bIsActive = TRUE;
631
 
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
647
                                cd_debug (" %s aussi devient active", pInhibitorIcon->cName);
 
648
                                ///pInhibitorIcon->bIsActive = TRUE;
 
649
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
632
650
                                if (pParentDock != NULL)
633
 
                                        cairo_dock_animate_icon_on_active (pInhibatorIcon, pParentDock);
 
651
                                        cairo_dock_animate_icon_on_active (pInhibitorIcon, pParentDock);
634
652
                        }
635
653
                }
636
654
        }
637
655
}
638
656
 
639
 
void cairo_dock_update_inactivity_on_inhibators (const gchar *cClass, Window Xid)
 
657
void cairo_dock_update_inactivity_on_inhibitors (const gchar *cClass, Window Xid)
640
658
{
641
659
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
642
660
        if (pClassAppli != NULL)
643
661
        {
644
662
                GList *pElement;
645
 
                Icon *pInhibatorIcon;
 
663
                Icon *pInhibitorIcon;
646
664
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
647
665
                {
648
 
                        pInhibatorIcon = pElement->data;
 
666
                        pInhibitorIcon = pElement->data;
649
667
                        
650
 
                        if (pInhibatorIcon->Xid == Xid)
 
668
                        if (pInhibitorIcon->Xid == Xid)
651
669
                        {
652
 
                                cd_debug (" %s aussi devient inactive", pInhibatorIcon->cName);
653
 
                                ///pInhibatorIcon->bIsActive = FALSE;
654
 
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
670
                                cd_debug (" %s aussi devient inactive", pInhibitorIcon->cName);
 
671
                                ///pInhibitorIcon->bIsActive = FALSE;
 
672
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
655
673
                                if (pParentDock != NULL && ! pParentDock->bIsShrinkingDown)
656
 
                                        cairo_dock_redraw_icon (pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
 
674
                                        cairo_dock_redraw_icon (pInhibitorIcon, CAIRO_CONTAINER (pParentDock));
657
675
                        }
658
676
                }
659
677
        }
660
678
}
661
679
 
662
 
void cairo_dock_update_name_on_inhibators (const gchar *cClass, Window Xid, gchar *cNewName)
 
680
void cairo_dock_update_name_on_inhibitors (const gchar *cClass, Window Xid, gchar *cNewName)
663
681
{
664
682
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
665
683
        if (pClassAppli != NULL)
666
684
        {
667
685
                GList *pElement;
668
 
                Icon *pInhibatorIcon;
 
686
                Icon *pInhibitorIcon;
669
687
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
670
688
                {
671
 
                        pInhibatorIcon = pElement->data;
 
689
                        pInhibitorIcon = pElement->data;
672
690
                        
673
 
                        if (pInhibatorIcon->Xid == Xid)
 
691
                        if (pInhibitorIcon->Xid == Xid)
674
692
                        {
675
 
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
693
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
676
694
                                if (pParentDock != NULL)
677
695
                                {
678
 
                                        if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibatorIcon))
 
696
                                        if (! CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibitorIcon))
679
697
                                        {
680
 
                                                cd_debug (" %s change son nom en %s", pInhibatorIcon->cName, cNewName);
681
 
                                                if (pInhibatorIcon->cInitialName == NULL)
 
698
                                                cd_debug (" %s change son nom en %s", pInhibitorIcon->cName, cNewName);
 
699
                                                if (pInhibitorIcon->cInitialName == NULL)
682
700
                                                {
683
 
                                                        pInhibatorIcon->cInitialName = pInhibatorIcon->cName;
684
 
                                                        cd_debug ("pInhibatorIcon->cInitialName <- %s", pInhibatorIcon->cInitialName);
 
701
                                                        pInhibitorIcon->cInitialName = pInhibitorIcon->cName;
 
702
                                                        cd_debug ("pInhibitorIcon->cInitialName <- %s", pInhibitorIcon->cInitialName);
685
703
                                                }
686
704
                                                else
687
 
                                                        g_free (pInhibatorIcon->cName);
688
 
                                                pInhibatorIcon->cName = NULL;
 
705
                                                        g_free (pInhibitorIcon->cName);
 
706
                                                pInhibitorIcon->cName = NULL;
689
707
                                                
690
 
                                                cairo_dock_set_icon_name ((cNewName != NULL ? cNewName : pInhibatorIcon->cInitialName), pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
 
708
                                                cairo_dock_set_icon_name ((cNewName != NULL ? cNewName : pInhibitorIcon->cInitialName), pInhibitorIcon, CAIRO_CONTAINER (pParentDock));
691
709
                                        }
692
710
                                        if (! pParentDock->bIsShrinkingDown)
693
 
                                                cairo_dock_redraw_icon (pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
 
711
                                                cairo_dock_redraw_icon (pInhibitorIcon, CAIRO_CONTAINER (pParentDock));
694
712
                                }
695
713
                        }
696
714
                }
755
773
                CairoDock *pFakeParentDock = NULL;
756
774
                Icon *pFakeClassIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pFakeParentDock);
757
775
                g_return_val_if_fail (pFakeClassIcon != NULL, TRUE);
758
 
                if (CAIRO_DOCK_IS_FAKE_LAUNCHER (pFakeClassIcon))  // le sous-dock est pointe par une icone de paille.
 
776
                if (CAIRO_DOCK_ICON_TYPE_IS_CLASS_CONTAINER (pFakeClassIcon))  // le sous-dock est pointe par une icone de paille.
759
777
                {
760
778
                        cd_debug ("trouve l'icone en papier (%x;%x)", pFakeClassIcon, pFakeParentDock);
 
779
                        gboolean bLastIconIsRemoving = cairo_dock_icon_is_being_removed (pLastClassIcon);  // keep the removing state because when we detach the icon, it returns to normal state.
761
780
                        cairo_dock_detach_icon_from_dock (pLastClassIcon, pDock, FALSE);
762
781
                        g_free (pLastClassIcon->cParentDockName);
763
782
                        pLastClassIcon->cParentDockName = g_strdup (pFakeClassIcon->cParentDockName);
774
793
                        cairo_dock_free_icon (pFakeClassIcon);
775
794
                        
776
795
                        cd_debug (" puis on re-insere l'appli restante");
777
 
                        if (! cairo_dock_icon_is_being_removed (pLastClassIcon))
 
796
                        if (! bLastIconIsRemoving)
778
797
                        {
779
798
                                cairo_dock_insert_icon_in_dock (pLastClassIcon, pFakeParentDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
780
799
                                cairo_dock_calculate_dock_icons (pFakeParentDock);
791
810
                }
792
811
                else  // le sous-dock est pointe par un inhibiteur (normal launcher ou applet).
793
812
                {
 
813
                        gboolean bLastIconIsRemoving = cairo_dock_icon_is_being_removed (pLastClassIcon);  // keep the removing state because when we detach the icon, it returns to normal state.
794
814
                        cairo_dock_detach_icon_from_dock (pLastClassIcon, pDock, FALSE);
795
815
                        g_free (pLastClassIcon->cParentDockName);
796
816
                        pLastClassIcon->cParentDockName = NULL;
798
818
                        cairo_dock_destroy_dock (pDock, cClass);
799
819
                        pFakeClassIcon->pSubDock = NULL;
800
820
                        cd_debug ("sanity check : pFakeClassIcon->Xid : %d", pFakeClassIcon->Xid);
801
 
                        if (! cairo_dock_icon_is_being_removed (pLastClassIcon))
 
821
                        if (! bLastIconIsRemoving)
802
822
                        {
803
823
                                cairo_dock_insert_appli_in_dock (pLastClassIcon, g_pMainDock, ! CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);  // a priori inutile.
804
 
                                cairo_dock_update_name_on_inhibators (cClass, pLastClassIcon->Xid, pLastClassIcon->cName);
 
824
                                cairo_dock_update_name_on_inhibitors (cClass, pLastClassIcon->Xid, pLastClassIcon->cName);
805
825
                        }
806
826
                        else  // la derniere icone est en cours de suppression, inutile de la re-inserer
807
827
                        {
946
966
 
947
967
 
948
968
 
949
 
Icon *cairo_dock_get_inhibator (Icon *pIcon, gboolean bOnlyInDock)
 
969
Icon *cairo_dock_get_inhibitor (Icon *pIcon, gboolean bOnlyInDock)
950
970
{
951
971
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (pIcon->cClass);
952
972
        if (pClassAppli != NULL)
953
973
        {
954
974
                GList *pElement;
955
 
                Icon *pInhibatorIcon;
 
975
                Icon *pInhibitorIcon;
956
976
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
957
977
                {
958
 
                        pInhibatorIcon = pElement->data;
 
978
                        pInhibitorIcon = pElement->data;
959
979
                        
960
 
                        if (pInhibatorIcon->Xid == pIcon->Xid)
 
980
                        if (pInhibitorIcon->Xid == pIcon->Xid)
961
981
                        {
962
 
                                if (! bOnlyInDock || pInhibatorIcon->cParentDockName != NULL)
963
 
                                        return pInhibatorIcon;
 
982
                                if (! bOnlyInDock || pInhibitorIcon->cParentDockName != NULL)
 
983
                                        return pInhibitorIcon;
964
984
                        }
965
985
                }
966
986
        }
976
996
                // on cherche un inhibiteur de cette classe, de preference un lanceur.
977
997
                Icon *pSameClassIcon = NULL;
978
998
                CairoDock *pDock;
979
 
                Icon *pInhibatorIcon;
 
999
                Icon *pInhibitorIcon;
980
1000
                GList *ic;
981
1001
                for (ic = pClassAppli->pIconsOfClass; ic != NULL; ic = ic->next)
982
1002
                {
983
 
                        pInhibatorIcon = ic->data;
984
 
                        if (CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibatorIcon) && myIcons.iSeparateIcons)
 
1003
                        pInhibitorIcon = ic->data;
 
1004
                        if (CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibitorIcon) && myIconsParam.iSeparateIcons)
985
1005
                                continue;
986
 
                        pDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
1006
                        pDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
987
1007
                        if (!pDock || !pDock->bIsMainDock)
988
 
                                pInhibatorIcon = cairo_dock_search_icon_pointing_on_dock (pDock, NULL);
989
 
                        pSameClassIcon = pInhibatorIcon;
990
 
                        if (CAIRO_DOCK_IS_LAUNCHER (pSameClassIcon))  // on prend les lanceurs de preference.
 
1008
                                pInhibitorIcon = cairo_dock_search_icon_pointing_on_dock (pDock, NULL);
 
1009
                        pSameClassIcon = pInhibitorIcon;
 
1010
                        if (CAIRO_DOCK_ICON_TYPE_IS_LAUNCHER (pSameClassIcon))  // on prend les lanceurs de preference.
991
1011
                                break ;
992
1012
                }
993
1013
                
1041
1061
                for (ic = g_list_last (g_pMainDock->icons); ic != NULL; ic = ic->prev)
1042
1062
                {
1043
1063
                        icon = ic->data;
1044
 
                        if (CAIRO_DOCK_ICON_TYPE_IS_APPLI (icon) && ! cairo_dock_class_is_inhibated (icon->cClass))  // on verifie qu'elle n'est pas placé a cote de son lanceur, sinon cela cree des incoherences suivants que l'appli est lancee 2 fois ou pas.
 
1064
                        if (CAIRO_DOCK_ICON_TYPE_IS_APPLI (icon) && ! cairo_dock_class_is_inhibited (icon->cClass))  // on verifie qu'elle n'est pas placé a cote de son lanceur, sinon cela cree des incoherences suivants que l'appli est lancee 2 fois ou pas.
1045
1065
                        {
1046
1066
                                break ;
1047
1067
                        }
1056
1076
                        else
1057
1077
                                fOrder = icon->fOrder + 1;
1058
1078
                }
1059
 
                else if (myTaskBar.bMixLauncherAppli)  // on decide de la placer apres le dernier lanceur dans le cas ou les lanceurs peuvent faire appli.
 
1079
                else if (myTaskbarParam.bMixLauncherAppli)  // on decide de la placer apres le dernier lanceur dans le cas ou les lanceurs peuvent faire appli.
1060
1080
                {
1061
1081
                        for (ic = g_list_last (g_pMainDock->icons); ic != NULL; ic = ic->prev)
1062
1082
                        {
1063
1083
                                icon = ic->data;
1064
1084
                                if (CAIRO_DOCK_ICON_TYPE_IS_LAUNCHER (icon) || CAIRO_DOCK_ICON_TYPE_IS_CONTAINER (icon))
1065
 
                                ///if (icon->iType == CAIRO_DOCK_LAUNCHER && ! CAIRO_DOCK_IS_SEPARATOR (icon))
 
1085
                                ///if (icon->iType == CAIRO_DOCK_LAUNCHER && ! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (icon))
1066
1086
                                        break;
1067
1087
                        }
1068
1088
                        if (ic != NULL)  // on a trouve une icone de lanceur.
1084
1104
{
1085
1105
        // on touve un inhibiteur par rapport auquel se placer.
1086
1106
        Icon *pSameClassIcon = NULL;
1087
 
        Icon *pInhibatorIcon;
 
1107
        Icon *pInhibitorIcon;
1088
1108
        CairoDock *pParentDock;
1089
1109
        GList *ic;
1090
1110
        for (ic = pClassAppli->pIconsOfClass; ic != NULL; ic = ic->next)
1091
1111
        {
1092
 
                pInhibatorIcon = ic->data;
1093
 
                if (CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibatorIcon) && myIcons.iSeparateIcons)
 
1112
                pInhibitorIcon = ic->data;
 
1113
                if (CAIRO_DOCK_ICON_TYPE_IS_APPLET (pInhibitorIcon) && myIconsParam.iSeparateIcons)
1094
1114
                        continue;
1095
1115
                
1096
 
                pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
1116
                pParentDock = cairo_dock_search_dock_from_name (pInhibitorIcon->cParentDockName);
1097
1117
                CairoDock *pDock;
1098
1118
                while (pParentDock && pParentDock->iRefCount != 0)
1099
1119
                {
1100
1120
                        pDock = pParentDock;
1101
 
                        pInhibatorIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
 
1121
                        pInhibitorIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
1102
1122
                }
1103
1123
                if (!pParentDock || !pParentDock->bIsMainDock)  // on place les icones d'applis dans le main dock.
1104
1124
                        continue;
1105
 
                pSameClassIcon = pInhibatorIcon;
1106
 
                if (CAIRO_DOCK_IS_LAUNCHER (pSameClassIcon))  // on prend les lanceurs de preference aux applets.
 
1125
                pSameClassIcon = pInhibitorIcon;
 
1126
                if (CAIRO_DOCK_ICON_TYPE_IS_LAUNCHER (pSameClassIcon))  // on prend les lanceurs de preference aux applets.
1107
1127
                        break ;
1108
1128
        }
1109
1129
        
1162
1182
        int iMaxOrder = (pLastIcon ? pLastIcon->fOrder + 1 : 1);
1163
1183
        g_hash_table_foreach (s_hClassTable, (GHFunc) _cairo_dock_reorder_one_class, &iMaxOrder);
1164
1184
}
 
1185
 
 
1186
static gchar *_search_class_desktop_file (const gchar *cClass)
 
1187
{
 
1188
        gboolean bFound = TRUE;
 
1189
        GString *sDesktopFilePath = g_string_new ("");
 
1190
        g_string_printf (sDesktopFilePath, "/usr/share/applications/%s.desktop", cClass);
 
1191
        if (! g_file_test (sDesktopFilePath->str, G_FILE_TEST_EXISTS))
 
1192
        {
 
1193
                g_string_printf (sDesktopFilePath, "/usr/share/applications/xfce4/%s.desktop", cClass);
 
1194
                if (! g_file_test (sDesktopFilePath->str, G_FILE_TEST_EXISTS))
 
1195
                {
 
1196
                        g_string_printf (sDesktopFilePath, "/usr/share/applications/kde4/%s.desktop", cClass);
 
1197
                        if (! g_file_test (sDesktopFilePath->str, G_FILE_TEST_EXISTS))
 
1198
                        {
 
1199
                                bFound = FALSE;
 
1200
                        }
 
1201
                }
 
1202
        }
 
1203
        
 
1204
        gchar *cDesktopFile;
 
1205
        if (bFound)
 
1206
        {
 
1207
                cDesktopFile = sDesktopFilePath->str;
 
1208
                g_string_free (sDesktopFilePath, FALSE);
 
1209
        }
 
1210
        else
 
1211
        {
 
1212
                cDesktopFile = NULL;
 
1213
                g_string_free (sDesktopFilePath, TRUE);
 
1214
                cd_debug ("couldn't find the .desktop for %s", cClass);
 
1215
        }
 
1216
        return cDesktopFile;
 
1217
}
 
1218
 
 
1219
static void _cairo_dock_find_class_attributes (const gchar *cClass)
 
1220
{
 
1221
        g_return_if_fail (cClass != NULL);
 
1222
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
 
1223
        
 
1224
        // if we already searched the attributes beforehand, quit.
 
1225
        if (pClassAppli->bSearchedAttributes)
 
1226
                return;
 
1227
        pClassAppli->bSearchedAttributes = TRUE;
 
1228
        
 
1229
        // look for the .desktop file in the common locations.
 
1230
        pClassAppli->cDesktopFile = _search_class_desktop_file (cClass);
 
1231
        
 
1232
        // if found, get the attributes.
 
1233
        if (pClassAppli->cDesktopFile != NULL)
 
1234
        {
 
1235
                GKeyFile *pKeyFile = cairo_dock_open_key_file (pClassAppli->cDesktopFile);
 
1236
                if (pKeyFile)
 
1237
                {
 
1238
                        gsize length = 0;
 
1239
                        pClassAppli->pMimeTypes = g_key_file_get_string_list (pKeyFile, "Desktop Entry", "MimeType", &length, NULL);
 
1240
                        pClassAppli->cCommand = g_key_file_get_string (pKeyFile, "Desktop Entry", "Exec", NULL);
 
1241
                        if (pClassAppli->cCommand != NULL)
 
1242
                        {
 
1243
                                gchar *str = strchr (pClassAppli->cCommand, '%');
 
1244
                                if (str != NULL)
 
1245
                                        *str = '\0';  // il peut rester un espace en fin de chaine, ce n'est pas grave.
 
1246
                        }
 
1247
                        cd_debug ("check: set command '%s' to class %s", pClassAppli->cCommand, cClass);
 
1248
                        g_key_file_free (pKeyFile);
 
1249
                }
 
1250
        }
 
1251
}
 
1252
 
 
1253
 
 
1254
static inline CairoDockClassAppli *_get_class_appli_with_attributes (const gchar *cClass)
 
1255
{
 
1256
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
 
1257
        if (! pClassAppli->bSearchedAttributes)
 
1258
        {
 
1259
                _cairo_dock_find_class_attributes (cClass);
 
1260
        }
 
1261
        return pClassAppli;
 
1262
}
 
1263
const gchar *cairo_dock_get_class_command (const gchar *cClass)
 
1264
{
 
1265
        g_return_val_if_fail (cClass != NULL, NULL);
 
1266
        CairoDockClassAppli *pClassAppli = _get_class_appli_with_attributes (cClass);
 
1267
        return pClassAppli->cCommand;
 
1268
}
 
1269
 
 
1270
const gchar **cairo_dock_get_class_mimetypes (const gchar *cClass)
 
1271
{
 
1272
        g_return_val_if_fail (cClass != NULL, NULL);
 
1273
        CairoDockClassAppli *pClassAppli = _get_class_appli_with_attributes (cClass);
 
1274
        return (const gchar **)pClassAppli->pMimeTypes;
 
1275
}
 
1276
 
 
1277
const gchar *cairo_dock_get_class_desktop_file (const gchar *cClass)
 
1278
{
 
1279
        g_return_val_if_fail (cClass != NULL, NULL);
 
1280
        CairoDockClassAppli *pClassAppli = _get_class_appli_with_attributes (cClass);
 
1281
        return pClassAppli->cDesktopFile;
 
1282
}
 
1283
 
 
1284
 
 
1285
void cairo_dock_get_class_attributes (const gchar *cClass, GKeyFile *pKeyFile)
 
1286
{
 
1287
        g_return_if_fail (cClass != NULL && pKeyFile != NULL);
 
1288
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
 
1289
        
 
1290
        // get mime types
 
1291
        gsize length = 0;
 
1292
        pClassAppli->pMimeTypes = g_key_file_get_string_list (pKeyFile, "Desktop Entry", "MimeType", &length, NULL);
 
1293
        
 
1294
        // get command
 
1295
        gchar *cCommand = g_key_file_get_string (pKeyFile, "Desktop Entry", "Exec", NULL);
 
1296
        if (cCommand != NULL)
 
1297
        {
 
1298
                gchar *str = strchr (cCommand, '%');
 
1299
                if (str != NULL)
 
1300
                        *str = '\0';  // il peut rester un espace en fin de chaine, ce n'est pas grave.
 
1301
        }
 
1302
        cd_debug ("check: set command '%s' to class %s", pClassAppli->cCommand, cClass);
 
1303
        
 
1304
        // modify the command if it should be launched in a terminal.
 
1305
        gchar *cCommandFull = NULL;
 
1306
        gboolean bExecInTerminal = g_key_file_get_boolean (pKeyFile, "Desktop Entry", "Terminal", NULL);
 
1307
        if (bExecInTerminal)
 
1308
        {
 
1309
                const gchar *cTerm = g_getenv ("COLORTERM");
 
1310
                if (cTerm != NULL && strlen (cTerm) > 1)  // on filtre les cas COLORTERM=1 ou COLORTERM=y. ce qu'on veut c'est le nom d'un terminal.
 
1311
                        cCommandFull = g_strdup_printf ("%s -e \"%s\"", cTerm, cCommand);
 
1312
                else if (g_iDesktopEnv == CAIRO_DOCK_GNOME)
 
1313
                        cCommandFull = g_strdup_printf ("gnome-terminal -e \"%s\"", cCommand);
 
1314
                else if (g_iDesktopEnv == CAIRO_DOCK_XFCE)
 
1315
                        cCommandFull = g_strdup_printf ("xfce4-terminal -e \"%s\"", cCommand);
 
1316
                else if (g_iDesktopEnv == CAIRO_DOCK_KDE)
 
1317
                        cCommandFull = g_strdup_printf ("konsole -e \"%s\"", cCommand);
 
1318
                else if (g_getenv ("TERM") != NULL)
 
1319
                        cCommandFull = g_strdup_printf ("%s -e \"%s\"", g_getenv ("TERM"), cCommand);
 
1320
                else
 
1321
                        cCommandFull = g_strdup_printf ("xterm -e \"%s\"", cCommand);
 
1322
        }
 
1323
        
 
1324
        // get the working directory.
 
1325
        gchar *cWorkingDirectory = g_key_file_get_string (pKeyFile, "Desktop Entry", "Path", NULL);
 
1326
        if (cWorkingDirectory != NULL && *cWorkingDirectory == '\0')
 
1327
        {
 
1328
                g_free (cWorkingDirectory);
 
1329
                cWorkingDirectory = NULL;
 
1330
        }
 
1331
        
 
1332
        pClassAppli->cCommand = cCommand;
 
1333
}