← Back to branch summary

~cairo-dock-team/ubuntu/precise/cairo-dock/988102

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Starr-Bochicchio, Andrew Starr-Bochicchio, Julien Lavergne
  • Date: 2009-06-03 20:39:11 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20090603203911-zstn9v1sf654mba4
Tags: 2.0.3-0ubuntu1
https://launchpad.net/bugs/375125
[ Andrew Starr-Bochicchio ]
* New upstream release. (LP: #375125)
* debian/control: Bump Standards-Version
* debian/rules: Call autoreconf
 - config.status should create po/stamp-it but does not,
   causing an infinite loop in the build, probably due to 
   upstream using an older version of intltool. Hopefully
   this can be dropped with next release.

[ Julien Lavergne ]
* debian/control :
 - Replace libglitz build-depends by libxrender-dev, libxcomposite-dev,
   libgtkglext1-dev and libxinerama-dev.
 - Add missing ${misc:Depends} for cairo-dock-dev.
* debian/cairo-dock-cairo.desktop
 - New desktop file to launch the non-OpenGL version.
* debian/cairo-dock-data.install :
 - Add new directorie usr/share/pixmaps
 - update to install both desktop files. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-class-manager.c
23
23
#include "cairo-dock-draw.h"
24
24
#include "cairo-dock-load.h"
25
25
#include "cairo-dock-launcher-factory.h"
 
26
#include "cairo-dock-internal-taskbar.h"
 
27
#include "cairo-dock-internal-icons.h"
 
28
#include "cairo-dock-container.h"
26
29
#include "cairo-dock-class-manager.h"
27
30
 
28
 
extern gboolean g_bUseSeparator;
29
31
extern CairoDock *g_pMainDock;
30
 
extern int g_tIconAuthorizedWidth[CAIRO_DOCK_NB_TYPES];
31
 
extern int g_tIconAuthorizedHeight[CAIRO_DOCK_NB_TYPES];
32
 
extern double g_fAmplitude;
33
 
extern double g_fVisibleAppliAlpha;
34
32
extern gboolean g_bEasterEggs;
35
33
 
36
34
static GHashTable *s_hClassTable = NULL;
82
80
                        {
83
81
                                gchar *cParentDockName = pIcon->cParentDockName;
84
82
                                pIcon->cParentDockName = NULL;  // astuce.
85
 
                                bDetached = cairo_dock_detach_icon_from_dock (pIcon, pParentDock, g_bUseSeparator);  // on la garde, elle pourra servir car elle contient l'Xid.
 
83
                                bDetached = cairo_dock_detach_icon_from_dock (pIcon, pParentDock, myIcons.bUseSeparator);  // on la garde, elle pourra servir car elle contient l'Xid.
86
84
                                if (! pParentDock->bIsMainDock)
87
85
                                {
88
86
                                        if (pParentDock->icons == NULL)
100
98
                        {
101
99
                                /**cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pContainer));
102
100
                                cd_messge ("  on recharge l'icone de l'appli detachee %s", pIcon->acName);
103
 
                                cairo_dock_fill_one_icon_buffer (pIcon, pCairoContext, 1 + g_fAmplitude, pParentDock->bHorizontalDock, TRUE, pParentDock->bDirectionUp);
 
101
                                cairo_dock_fill_one_icon_buffer (pIcon, pCairoContext, 1 + myIcons.fAmplitude, pParentDock->bHorizontalDock, TRUE, pParentDock->bDirectionUp);
104
102
                                cairo_destroy (pCairoContext);*/
105
103
                                bNeedsRedraw |= pParentDock->bIsMainDock;
106
104
                        }
109
107
        if (! cairo_dock_is_loading () && bNeedsRedraw)
110
108
        {
111
109
                cairo_dock_update_dock_size (g_pMainDock);
112
 
                gtk_widget_queue_draw (g_pMainDock->pWidget);  /// pDock->calculate_icons (pDock); ?...
 
110
                cairo_dock_calculate_dock_icons (g_pMainDock);
 
111
                gtk_widget_queue_draw (g_pMainDock->pWidget);
113
112
        }
114
113
        return XFirstFoundId;
115
114
}
138
137
                                }
139
138
                        }
140
139
                }
141
 
                Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pInhibhatorDock, NULL);
142
 
                if (pPointingIcon != NULL)
 
140
                CairoDock *pParentDock = NULL;
 
141
                Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pInhibhatorDock, &pParentDock);
 
142
                if (pPointingIcon != NULL && pPointingIcon->bHasIndicator != bSubDockHasIndicator)
143
143
                {
144
144
                        cd_message ("  pour le sous-dock %s : indicateur <- %d", pPointingIcon->acName, bSubDockHasIndicator);
145
145
                        pPointingIcon->bHasIndicator = bSubDockHasIndicator;
 
146
                        if (pParentDock != NULL)
 
147
                                cairo_dock_redraw_icon (pPointingIcon, pParentDock);
146
148
                }
147
149
        }
148
150
}
228
230
        if (pClassAppli->bUseXIcon == bUseXIcon)  // rien a faire.
229
231
                return FALSE;
230
232
        
 
233
        CairoDock *pDock;
231
234
        GList *pElement;
232
235
        Icon *pAppliIcon;
233
236
        cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (g_pMainDock));
242
245
                {
243
246
                        cd_message ("%s n'utilise plus l'icone de X", pAppliIcon->acName);
244
247
                }
245
 
                cairo_dock_fill_one_icon_buffer (pAppliIcon, pCairoContext, (1 + g_fAmplitude), g_pMainDock->bHorizontalDock, TRUE, g_pMainDock->bDirectionUp);
 
248
                
 
249
                pDock = cairo_dock_search_dock_from_name (pAppliIcon->cParentDockName);
 
250
                if (pDock != NULL)
 
251
                {
 
252
                        cairo_dock_reload_one_icon_buffer_in_dock_full (pAppliIcon, pDock, pCairoContext);
 
253
                }
 
254
                else
 
255
                {
 
256
                        cairo_dock_fill_one_icon_buffer (pAppliIcon, pCairoContext, (1 + myIcons.fAmplitude), g_pMainDock->bHorizontalDock, g_pMainDock->bDirectionUp);
 
257
                }
246
258
        }
247
259
        cairo_destroy (pCairoContext);
248
260
        
249
261
        return TRUE;
250
262
}
251
263
 
 
264
 
252
265
gboolean cairo_dock_inhibate_class (const gchar *cClass, Icon *pInhibatorIcon)
253
266
{
254
267
        g_return_val_if_fail (cClass != NULL, FALSE);
276
289
                for (pElement = pList; pElement != NULL; pElement = pElement->next)
277
290
                {
278
291
                        pIcon = pElement->data;
279
 
                        g_print ("une appli detachee (%s)\n", pIcon->cParentDockName);
 
292
                        cd_debug ("une appli detachee (%s)", pIcon->cParentDockName);
280
293
                        if (pIcon->Xid != XFirstFoundId && pIcon->cParentDockName == NULL)  // s'est faite detacher et doit etre rattacher.
281
294
                                cairo_dock_insert_appli_in_dock (pIcon, g_pMainDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
282
295
                }
298
311
        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.
299
312
}
300
313
 
 
314
gboolean cairo_dock_class_is_expanded (const gchar *cClass)
 
315
{
 
316
        CairoDockClassAppli *pClassAppli = cairo_dock_find_class_appli (cClass);
 
317
        return (pClassAppli != NULL && pClassAppli->bExpand);
 
318
}
 
319
 
301
320
gboolean cairo_dock_prevent_inhibated_class (Icon *pIcon)
302
321
{
303
322
        g_return_val_if_fail (pIcon != NULL, FALSE);
312
331
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
313
332
                {
314
333
                        pInhibatorIcon = pElement->data;
315
 
                        if (pInhibatorIcon == NULL)  // cette appli est inhibee par Dieu.
316
 
                        {
317
 
                                cd_debug ("cette appli est inhibee par Dieu");
318
 
                                bToBeInhibited = TRUE;
319
 
                        }
320
 
                        else
321
 
                        {
322
 
                                if (pInhibatorIcon->Xid == 0 && (! g_bEasterEggs || pInhibatorIcon->pSubDock == NULL || pInhibatorIcon->pSubDock != cairo_dock_search_dock_from_name (pIcon->cClass)))  // cette icone inhibe cette classe mais ne controle encore aucune appli, on s'y asservit.
 
334
                        if (pInhibatorIcon != NULL)  // un inhibiteur est present.
 
335
                        {
 
336
                                if (pInhibatorIcon->Xid == 0 && pInhibatorIcon->pSubDock == NULL)  // cette icone inhibe cette classe mais ne controle encore aucune appli, on s'y asservit.
323
337
                                {
324
338
                                        pInhibatorIcon->Xid = pIcon->Xid;
325
339
                                        pInhibatorIcon->bIsHidden = pIcon->bIsHidden;
331
345
                                        }
332
346
                                }
333
347
                                
334
 
                                if (pInhibatorIcon->Xid == pIcon->Xid)  // cette icone nous controle. Sinon c'est qu'elle controle deja une autre appli, auquel cas on n'est pas inhibe.
 
348
                                if (pInhibatorIcon->Xid == pIcon->Xid)  // cette icone nous controle.
335
349
                                {
336
350
                                        CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
351
                                        //\______________ On place l'icone pour X.
337
352
                                        if (! bToBeInhibited)  // on ne met le thumbnail que sur la 1ere.
338
353
                                        {
339
354
                                                if (pInhibhatorDock != NULL)
340
355
                                                        cairo_dock_set_one_icon_geometry_for_window_manager (pInhibatorIcon, pInhibhatorDock);
341
356
                                                bToBeInhibited = TRUE;
342
357
                                        }
 
358
                                        //\______________ On met a jour l'etiquette de l'inhibiteur.
 
359
                                        if (pInhibhatorDock != NULL && pIcon->acName != NULL)
 
360
                                        {
 
361
                                                if (pInhibatorIcon->cInitialName == NULL)
 
362
                                                        pInhibatorIcon->cInitialName = pInhibatorIcon->acName;
 
363
                                                else
 
364
                                                        g_free (pInhibatorIcon->acName);
 
365
                                                pInhibatorIcon->acName = NULL;
 
366
                                                cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pInhibhatorDock));
 
367
                                                cairo_dock_set_icon_name (pCairoContext, pIcon->acName, pInhibatorIcon, CAIRO_CONTAINER (pInhibhatorDock));
 
368
                                                cairo_destroy (pCairoContext);
 
369
                                        }
343
370
                                }
344
371
                        }
345
372
                }
403
430
                        if (pParentDock != NULL)
404
431
                        {
405
432
                                cd_message ("on recharge l'icone de l'appli %s", pIcon->acName);
406
 
                                cairo_dock_fill_one_icon_buffer (pIcon, pCairoContext, 1 + g_fAmplitude, pParentDock->bHorizontalDock, TRUE, pParentDock->bDirectionUp);
 
433
                                cairo_dock_reload_one_icon_buffer_in_dock_full (pIcon, pParentDock, pCairoContext);
 
434
                        }
 
435
                        else
 
436
                        {
 
437
                                cairo_dock_fill_one_icon_buffer (pIcon, pCairoContext, (1 + myIcons.fAmplitude), g_pMainDock->bHorizontalDock, g_pMainDock->bDirectionUp);
407
438
                        }
408
439
                }
409
440
                cairo_destroy (pCairoContext);
417
448
                pInhibatorIcon->bHasIndicator = FALSE;
418
449
                g_free (pInhibatorIcon->cClass);
419
450
                pInhibatorIcon->cClass = NULL;
 
451
                cd_debug ("  plus de classe");
420
452
        }
421
453
}
422
454
 
457
489
                                                CairoDock *pClassSubDock = cairo_dock_search_dock_from_name (pSameClassIcon->cParentDockName);
458
490
                                                if (pClassSubDock != NULL)
459
491
                                                {
460
 
                                                        cairo_dock_detach_icon_from_dock (pSameClassIcon, pClassSubDock, FALSE);
 
492
                                                        cairo_dock_detach_icon_from_dock (pSameClassIcon, pClassSubDock, myIcons.bUseSeparator);
461
493
                                                        if (pClassSubDock->icons == NULL && pClassSubDock == cairo_dock_search_dock_from_name (cClass))  // le sous-dock de la classe devient vide.
462
494
                                                                cairo_dock_destroy_dock (pClassSubDock, cClass, NULL, NULL);
463
495
                                                        else
501
533
 
502
534
 
503
535
 
504
 
static cairo_surface_t *cairo_dock_duplicate_inhibator_surface_for_appli (cairo_t *pSourceContext, Icon *pInhibatorIcon, double fMaxScale, double *fWidth, double *fHeight)
 
536
cairo_surface_t *cairo_dock_duplicate_inhibator_surface_for_appli (cairo_t *pSourceContext, Icon *pInhibatorIcon, double fMaxScale, double *fWidth, double *fHeight)
505
537
{
506
 
        double fIconWidthSaturationFactor, fIconHeightSaturationFactor;
507
 
        cairo_dock_calculate_size_fill (fWidth,
508
 
                fHeight,
509
 
                g_tIconAuthorizedWidth[CAIRO_DOCK_APPLI],
510
 
                g_tIconAuthorizedHeight[CAIRO_DOCK_APPLI],
511
 
                FALSE,
512
 
                &fIconWidthSaturationFactor,
513
 
                &fIconHeightSaturationFactor);
 
538
        *fWidth = myIcons.tIconAuthorizedWidth[CAIRO_DOCK_APPLI];
 
539
        *fHeight = myIcons.tIconAuthorizedHeight[CAIRO_DOCK_APPLI];
514
540
        
515
 
        CairoContainer *pInhibhatorContainer= cairo_dock_search_container_from_icon (pInhibatorIcon);
516
 
        double fInhibatorMaxScale = (CAIRO_DOCK_IS_DOCK (pInhibhatorContainer) ? (1 + g_fAmplitude) / CAIRO_DOCK (pInhibhatorContainer)->fRatio : 1);
 
541
        CairoContainer *pInhibhatorContainer = cairo_dock_search_container_from_icon (pInhibatorIcon);
 
542
        double fInhibatorMaxScale = (CAIRO_DOCK_IS_DOCK (pInhibhatorContainer) ? fMaxScale : 1);
517
543
        
518
544
        cairo_surface_t *pSurface = cairo_dock_duplicate_surface (pInhibatorIcon->pIconBuffer,
519
545
                pSourceContext,
520
 
                pInhibatorIcon->fWidth * fInhibatorMaxScale,
521
 
                pInhibatorIcon->fHeight * fInhibatorMaxScale,
 
546
                pInhibatorIcon->fWidth * fInhibatorMaxScale / pInhibhatorContainer->fRatio,
 
547
                pInhibatorIcon->fHeight * fInhibatorMaxScale / pInhibhatorContainer->fRatio,
522
548
                *fWidth * fMaxScale,
523
549
                *fHeight * fMaxScale);
524
550
        return pSurface;
553
579
                cd_debug ("on remplace l'icone X par %s", cIconFilePath);
554
580
                cairo_surface_t *pSurface = cairo_dock_create_surface_from_image (cIconFilePath,
555
581
                        pSourceContext,
556
 
                        1 + g_fAmplitude,
557
 
                        g_tIconAuthorizedWidth[CAIRO_DOCK_APPLI],
558
 
                        g_tIconAuthorizedHeight[CAIRO_DOCK_APPLI],
 
582
                        1 + myIcons.fAmplitude,
 
583
                        myIcons.tIconAuthorizedWidth[CAIRO_DOCK_APPLI],
 
584
                        myIcons.tIconAuthorizedHeight[CAIRO_DOCK_APPLI],
559
585
                        CAIRO_DOCK_FILL_SPACE,
560
586
                        fWidth, fHeight,
561
587
                        NULL, NULL);
584
610
                        {
585
611
                                cd_message (" %s aussi se %s", pInhibatorIcon->acName, (bIsHidden ? "cache" : "montre"));
586
612
                                pInhibatorIcon->bIsHidden = bIsHidden;
587
 
                                if (! CAIRO_DOCK_IS_APPLET (pInhibatorIcon) && g_fVisibleAppliAlpha != 0)
 
613
                                if (! CAIRO_DOCK_IS_APPLET (pInhibatorIcon) && myTaskBar.fVisibleAppliAlpha != 0)
588
614
                                {
589
615
                                        CairoDock *pInhibhatorDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
590
616
                                        pInhibatorIcon->fAlpha = 1;  // on triche un peu.
634
660
                                cd_message (" %s aussi devient inactive", pInhibatorIcon->acName);
635
661
                                ///pInhibatorIcon->bIsActive = FALSE;
636
662
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
637
 
                                if (pParentDock != NULL && pParentDock->iSidShrinkDown == 0)
 
663
                                if (pParentDock != NULL && ! pParentDock->bIsShrinkingDown)
 
664
                                        cairo_dock_redraw_my_icon (pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
 
665
                        }
 
666
                }
 
667
        }
 
668
}
 
669
 
 
670
void cairo_dock_update_name_on_inhibators (gchar *cClass, Window Xid, gchar *cNewName)
 
671
{
 
672
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClass);
 
673
        if (pClassAppli != NULL)
 
674
        {
 
675
                GList *pElement;
 
676
                Icon *pInhibatorIcon;
 
677
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
 
678
                {
 
679
                        pInhibatorIcon = pElement->data;
 
680
                        
 
681
                        if (pInhibatorIcon->Xid == Xid && ! CAIRO_DOCK_IS_APPLET (pInhibatorIcon))
 
682
                        {
 
683
                                CairoDock *pParentDock = cairo_dock_search_dock_from_name (pInhibatorIcon->cParentDockName);
 
684
                                if (pParentDock != NULL)
 
685
                                {
 
686
                                        cd_message (" %s change son nom en %s", pInhibatorIcon->acName, cNewName);
 
687
                                        if (pInhibatorIcon->cInitialName == NULL)
 
688
                                        {
 
689
                                                pInhibatorIcon->cInitialName = pInhibatorIcon->acName;
 
690
                                                cd_debug ("pInhibatorIcon->cInitialName <- %s", pInhibatorIcon->cInitialName);
 
691
                                        }
 
692
                                        else
 
693
                                                g_free (pInhibatorIcon->acName);
 
694
                                        pInhibatorIcon->acName = NULL;
 
695
                                        
 
696
                                        cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pParentDock));
 
697
                                        cairo_dock_set_icon_name (pCairoContext, (cNewName != NULL ? cNewName : pInhibatorIcon->cInitialName), pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
 
698
                                        cairo_destroy (pCairoContext);
 
699
                                }
 
700
                                if (pParentDock != NULL && ! pParentDock->bIsShrinkingDown)
638
701
                                        cairo_dock_redraw_my_icon (pInhibatorIcon, CAIRO_CONTAINER (pParentDock));
639
702
                        }
640
703
                }
644
707
Icon *cairo_dock_get_classmate (Icon *pIcon)
645
708
{
646
709
        cd_debug ("%s (%s)", __func__, pIcon->cClass);
647
 
        Icon *pClassMate = NULL;
648
710
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (pIcon->cClass);
649
 
        if (pClassAppli != NULL)
650
 
        {
651
 
                GList *pElement;
652
 
                Icon *pFriendIcon;
653
 
                for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
654
 
                {
655
 
                        pFriendIcon = pElement->data;
656
 
                        if (pFriendIcon != NULL) g_print (" friend : %s (%d)\n", pFriendIcon->acName, pFriendIcon->Xid);
657
 
                        if (pFriendIcon != NULL && pFriendIcon->Xid != 0)
658
 
                                return pFriendIcon;
659
 
                }
 
711
        if (pClassAppli == NULL)
 
712
                return NULL;
 
713
        
 
714
        Icon *pFriendIcon = NULL;
 
715
        GList *pElement;
 
716
        for (pElement = pClassAppli->pIconsOfClass; pElement != NULL; pElement = pElement->next)
 
717
        {
 
718
                pFriendIcon = pElement->data;
 
719
                if (pFriendIcon == NULL)
 
720
                        continue ;
 
721
                cd_debug (" friend : %s (%d)", pFriendIcon->acName, pFriendIcon->Xid);
 
722
                if (pFriendIcon->Xid != 0 || pFriendIcon->pSubDock != NULL)
 
723
                        return pFriendIcon;
 
724
        }
 
725
        
 
726
        for (pElement = pClassAppli->pAppliOfClass; pElement != NULL; pElement = pElement->next)
 
727
        {
 
728
                pFriendIcon = pElement->data;
 
729
                if (pFriendIcon != pIcon && pFriendIcon->cParentDockName != NULL && strcmp (pFriendIcon->cParentDockName, CAIRO_DOCK_MAIN_DOCK_NAME) == 0)
 
730
                        return pFriendIcon;
 
731
        }
 
732
        
 
733
        return NULL;
 
734
}
 
735
 
 
736
 
 
737
 
 
738
 
 
739
gboolean cairo_dock_check_class_subdock_is_empty (CairoDock *pDock, const gchar *cClass)
 
740
{
 
741
        cd_debug ("%s (%s, %d)", __func__, cClass, g_list_length (pDock->icons));
 
742
        if (pDock->iRefCount == 0)
 
743
                return FALSE;
 
744
        if (pDock->icons == NULL)  // ne devrait plus arriver.
 
745
        {
 
746
                cd_warning ("the %s class sub-dock has no element, which is probably an error !\nit will be destroyed.", cClass);
 
747
                CairoDock *pFakeParentDock = NULL;
 
748
                Icon *pFakeClassIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pFakeParentDock);
 
749
                cairo_dock_destroy_dock (pDock, cClass, NULL, NULL);
 
750
                pFakeClassIcon->pSubDock = NULL;
 
751
                cairo_dock_remove_icon_from_dock (pFakeParentDock, pFakeClassIcon);
 
752
                cairo_dock_free_icon (pFakeClassIcon);
 
753
                cairo_dock_update_dock_size (pFakeParentDock);
 
754
                return TRUE;
 
755
        }
 
756
        else if (pDock->icons->next == NULL)
 
757
        {
 
758
                cd_debug ("   le sous-dock de la classe %s n'a plus que 1 element et va etre vide puis detruit", cClass);
 
759
                Icon *pLastClassIcon = pDock->icons->data;
660
760
                
661
 
                for (pElement = pClassAppli->pAppliOfClass; pElement != NULL; pElement = pElement->next)
662
 
                {
663
 
                        pFriendIcon = pElement->data;
664
 
                        if (pFriendIcon != pIcon && pFriendIcon->cParentDockName != NULL && strcmp (pFriendIcon->cParentDockName, CAIRO_DOCK_MAIN_DOCK_NAME) == 0)
665
 
                                return pFriendIcon;
666
 
                }
667
 
        }
668
 
        return NULL;
 
761
                CairoDock *pFakeParentDock = NULL;
 
762
                Icon *pFakeClassIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pFakeParentDock);
 
763
                g_return_val_if_fail (pFakeClassIcon != NULL, TRUE);
 
764
                if (CAIRO_DOCK_IS_NORMAL_LAUNCHER (pFakeClassIcon) || CAIRO_DOCK_IS_APPLET (pFakeClassIcon))
 
765
                {
 
766
                        cairo_dock_detach_icon_from_dock (pLastClassIcon, pDock, FALSE);
 
767
                        g_free (pLastClassIcon->cParentDockName);
 
768
                        pLastClassIcon->cParentDockName = NULL;
 
769
                        
 
770
                        cairo_dock_destroy_dock (pDock, cClass, NULL, NULL);
 
771
                        pFakeClassIcon->pSubDock = NULL;
 
772
                        cd_debug ("sanity check : pFakeClassIcon->Xid : %d", pFakeClassIcon->Xid);
 
773
                        cairo_dock_insert_appli_in_dock (pLastClassIcon, g_pMainDock, ! CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON);
 
774
                }
 
775
                else  // le sous-dock est donc pointe par un inhibiteur.
 
776
                {
 
777
                        cd_debug ("trouve l'icone en papier (%x;%x)", pFakeClassIcon, pFakeParentDock);
 
778
                        cairo_dock_detach_icon_from_dock (pLastClassIcon, pDock, FALSE);
 
779
                        g_free (pLastClassIcon->cParentDockName);
 
780
                        pLastClassIcon->cParentDockName = g_strdup (pFakeClassIcon->cParentDockName);
 
781
                        pLastClassIcon->fOrder = pFakeClassIcon->fOrder;
 
782
                        
 
783
                        cd_debug (" on detruit le sous-dock...");
 
784
                        cairo_dock_destroy_dock (pDock, cClass, NULL, NULL);
 
785
                        pFakeClassIcon->pSubDock = NULL;
 
786
                        
 
787
                        cd_debug (" et l'icone de paille");
 
788
                        cairo_dock_remove_icon_from_dock (pFakeParentDock, pFakeClassIcon);
 
789
                        cairo_dock_free_icon (pFakeClassIcon);
 
790
                        
 
791
                        cd_debug (" puis on re-insere l'appli restante");
 
792
                        cairo_dock_insert_icon_in_dock_full (pLastClassIcon, pFakeParentDock, CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON, ! CAIRO_DOCK_INSERT_SEPARATOR, NULL);
 
793
                        cairo_dock_redraw_icon (pLastClassIcon, CAIRO_CONTAINER (pFakeParentDock));  // on suppose que les tailles des 2 icones sont identiques.
 
794
                }
 
795
                return TRUE;
 
796
        }
 
797
        return FALSE;
 
798
}
 
799
 
 
800
 
 
801
static void _cairo_dock_reset_overwrite_exceptions (gchar *cClass, CairoDockClassAppli *pClassAppli, gpointer data)
 
802
{
 
803
        pClassAppli->bUseXIcon = FALSE;
 
804
}
 
805
void cairo_dock_set_overwrite_exceptions (const gchar *cExceptions)
 
806
{
 
807
        g_hash_table_foreach (s_hClassTable, (GHFunc) _cairo_dock_reset_overwrite_exceptions, NULL);
 
808
        
 
809
        gchar **cClassList = g_strsplit (cExceptions, ";", -1);
 
810
        if (cClassList == NULL || cClassList[0] == NULL || *cClassList[0] == '\0')
 
811
        {
 
812
                g_strfreev (cClassList);
 
813
                return ;
 
814
        }
 
815
        CairoDockClassAppli *pClassAppli;
 
816
        int i;
 
817
        for (i = 0; cClassList[i] != NULL; i ++)
 
818
        {
 
819
                CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClassList[i]);
 
820
                pClassAppli->bUseXIcon = TRUE;
 
821
        }
 
822
        
 
823
        g_strfreev (cClassList);
 
824
}
 
825
 
 
826
static void _cairo_dock_reset_group_exceptions (gchar *cClass, CairoDockClassAppli *pClassAppli, gpointer data)
 
827
{
 
828
        pClassAppli->bExpand = FALSE;
 
829
}
 
830
void cairo_dock_set_group_exceptions (const gchar *cExceptions)
 
831
{
 
832
        g_hash_table_foreach (s_hClassTable, (GHFunc) _cairo_dock_reset_group_exceptions, NULL);
 
833
        
 
834
        gchar **cClassList = g_strsplit (cExceptions, ";", -1);
 
835
        if (cClassList == NULL || cClassList[0] == NULL || *cClassList[0] == '\0')
 
836
        {
 
837
                g_strfreev (cClassList);
 
838
                return ;
 
839
        }
 
840
        CairoDockClassAppli *pClassAppli;
 
841
        int i;
 
842
        for (i = 0; cClassList[i] != NULL; i ++)
 
843
        {
 
844
                CairoDockClassAppli *pClassAppli = cairo_dock_get_class (cClassList[i]);
 
845
                pClassAppli->bExpand = TRUE;
 
846
        }
 
847
        
 
848
        g_strfreev (cClassList);
 
849
}
 
850
 
 
851
 
 
852
Icon *cairo_dock_get_prev_next_classmate_icon (Icon *pIcon, gboolean bNext)
 
853
{
 
854
        cd_debug ("%s (%s, %s)", __func__, pIcon->cClass, pIcon->acName);
 
855
        g_return_val_if_fail (pIcon->cClass != NULL, NULL);
 
856
        
 
857
        Icon *pActiveIcon = cairo_dock_get_current_active_icon ();
 
858
        if (pActiveIcon == NULL || pActiveIcon->cClass == NULL || strcmp (pActiveIcon->cClass, pIcon->cClass) != 0)  // la fenetre active n'est pas de notre classe, on active l'icone fournies en entree.
 
859
        {
 
860
                cd_debug ("on active la classe %s", pIcon->cClass);
 
861
                return pIcon;
 
862
        }
 
863
        
 
864
        //\________________ on va chercher dans la classe la fenetre active, et prendre la suivante ou la precedente.
 
865
        Icon *pNextIcon = NULL;
 
866
        CairoDockClassAppli *pClassAppli = cairo_dock_get_class (pIcon->cClass);
 
867
        if (pClassAppli == NULL)
 
868
                return NULL;
 
869
        
 
870
        //\________________ On cherche dans les icones d'applis.
 
871
        Icon *pClassmateIcon;
 
872
        GList *pElement, *ic;
 
873
        for (pElement = pClassAppli->pAppliOfClass; pElement != NULL && pNextIcon == NULL; pElement = pElement->next)
 
874
        {
 
875
                pClassmateIcon = pElement->data;
 
876
                cd_debug (" %s est-elle active ?", pClassmateIcon->acName);
 
877
                if (pClassmateIcon->Xid == pActiveIcon->Xid)  // on a trouve la fenetre active.
 
878
                {
 
879
                        cd_debug ("  fenetre active trouvee (%s; %d)", pClassmateIcon->acName, pClassmateIcon->Xid);
 
880
                        if (bNext)  // on prend la 1ere non nulle qui suit.
 
881
                        {
 
882
                                ic = pElement;
 
883
                                do
 
884
                                {
 
885
                                        ic = cairo_dock_get_next_element (ic, pClassAppli->pAppliOfClass);
 
886
                                        if (ic == pElement)
 
887
                                        {
 
888
                                                cd_debug ("  on a fait le tour sans rien trouve");
 
889
                                                break ;
 
890
                                        }
 
891
                                        pClassmateIcon = ic->data;
 
892
                                        if (pClassmateIcon != NULL && pClassmateIcon->Xid != 0)
 
893
                                        {
 
894
                                                cd_debug ("  ok on prend celle-la (%s; %d)", pClassmateIcon->acName, pClassmateIcon->Xid);
 
895
                                                pNextIcon = pClassmateIcon;
 
896
                                                break ;
 
897
                                        }
 
898
                                        cd_debug ("un coup pour rien");
 
899
                                }
 
900
                                while (1);
 
901
                        }
 
902
                        else  // on prend la 1ere non nulle qui precede.
 
903
                        {
 
904
                                ic = pElement;
 
905
                                do
 
906
                                {
 
907
                                        ic = cairo_dock_get_previous_element (ic, pClassAppli->pAppliOfClass);
 
908
                                        if (ic == pElement)
 
909
                                                break ;
 
910
                                        pClassmateIcon = ic->data;
 
911
                                        if (pClassmateIcon != NULL && pClassmateIcon->Xid != 0)
 
912
                                        {
 
913
                                                pNextIcon = pClassmateIcon;
 
914
                                                break ;
 
915
                                        }
 
916
                                }
 
917
                                while (1);
 
918
                        }
 
919
                        break ;
 
920
                }
 
921
        }
 
922
        return pNextIcon;
669
923
}