← Back to branch summary

~ubuntu-branches/ubuntu/precise/cairo-dock/precise-updates

« back to all changes in this revision

Viewing changes to src/gldit/cairo-dock-dock-facility.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe)
  • Date: 2011-03-17 14:08:48 UTC
  • mfrom: (1.1.14 upstream)
  • Revision ID: james.westby@ubuntu.com-20110317140848-b8efysl4ynhjm87k
Tags: 2.3.0~1-0ubuntu1
https://launchpad.net/bugs/723994
* New Upstream Version (LP: #723994)
* Upstream short ChangeLog:
 - Updated translations
 - Updated the integration of the new versions of kwin and compiz
 - Updated default theme
 - Fixed a few bugs
 - Updated the man
* debian/control:
 - Added suggests apps for cairo-dock-core (needed by the default theme)
 - Updated the description (from launchpad.net/cairo-dock)
 - Added cairo-dock-plug-ins as a new suggestion for cairo-dock-core
* debian/patches:
 - Updated the default theme to use default apps of Ubuntu Natty 
* Switch to dpkg-source 3.0 (quilt) format
* Removed the desktop-file-category patch (sync with debian packages)
* debian/rules:
 - Added a CMake flag to disable the gtk grip
 - No longer used simple-patchsys
* Updated the debian/watch

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gldit/cairo-dock-dock-facility.c
46
46
 
47
47
#include "cairo-dock-draw.h"
48
48
#include "cairo-dock-applications-manager.h"
49
 
#include "cairo-dock-load.h"
 
49
#include "cairo-dock-image-buffer.h"
50
50
#include "cairo-dock-config.h"
51
 
#include "cairo-dock-modules.h"
 
51
#include "cairo-dock-module-factory.h"
52
52
#include "cairo-dock-callbacks.h"
53
 
#include "cairo-dock-icons.h"
 
53
#include "cairo-dock-icon-factory.h"
 
54
#include "cairo-dock-icon-facility.h"
54
55
#include "cairo-dock-separator-factory.h"
55
56
#include "cairo-dock-launcher-factory.h"
56
 
#include "cairo-dock-backends-manager.h"
 
57
#include "cairo-dock-backends-manager.h"  // myBackendsParam.fSubDockSizeRatio
57
58
#include "cairo-dock-X-utilities.h"
58
59
#include "cairo-dock-log.h"
59
60
#include "cairo-dock-keyfile-utilities.h"
60
61
#include "cairo-dock-dock-manager.h"
61
62
#include "cairo-dock-dialog-manager.h"
62
63
#include "cairo-dock-notifications.h"
 
64
#include "cairo-dock-indicator-manager.h"  // myIndicators.bUseClassIndic
63
65
#include "cairo-dock-class-manager.h"
64
 
#include "cairo-dock-internal-accessibility.h"
65
 
#include "cairo-dock-internal-icons.h"
66
 
#include "cairo-dock-internal-indicators.h"
67
 
#include "cairo-dock-internal-system.h"
68
 
#include "cairo-dock-internal-views.h"
69
 
#include "cairo-dock-internal-background.h"
70
66
#include "cairo-dock-animations.h"
71
67
#include "cairo-dock-emblem.h"
72
68
#include "cairo-dock-X-manager.h"
93
89
 
94
90
void cairo_dock_update_dock_size (CairoDock *pDock)  // iMaxIconHeight et fFlatDockWidth doivent avoir ete mis a jour au prealable.
95
91
{
 
92
        //g_print ("%s ()\n", __func__);
96
93
        g_return_if_fail (pDock != NULL);
97
94
        int iPrevMaxDockHeight = pDock->iMaxDockHeight;
98
95
        int iPrevMaxDockWidth = pDock->iMaxDockWidth;
101
98
        {
102
99
                GList *ic;
103
100
                Icon *icon;
104
 
                pDock->fFlatDockWidth = -myIcons.iIconGap;
 
101
                pDock->fFlatDockWidth = -myIconsParam.iIconGap;
105
102
                pDock->iMaxIconHeight = 0;
106
103
                for (ic = pDock->icons; ic != NULL; ic = ic->next)
107
104
                {
108
105
                        icon = ic->data;
109
106
                        icon->fWidth /= pDock->container.fRatio;
110
107
                        icon->fHeight /= pDock->container.fRatio;
111
 
                        pDock->fFlatDockWidth += icon->fWidth + myIcons.iIconGap;
 
108
                        pDock->fFlatDockWidth += icon->fWidth + myIconsParam.iIconGap;
112
109
                        if (! CAIRO_DOCK_ICON_TYPE_IS_SEPARATOR (icon))
113
110
                                pDock->iMaxIconHeight = MAX (pDock->iMaxIconHeight, icon->fHeight);
114
111
                }
131
128
                }
132
129
                else
133
130
                {
134
 
                        double fMaxRatio = (pDock->iRefCount == 0 ? 1 : myViews.fSubDockSizeRatio);
 
131
                        double fMaxRatio = (pDock->iRefCount == 0 ? 1 : myBackendsParam.fSubDockSizeRatio);
135
132
                        if (pDock->container.fRatio < fMaxRatio)
136
133
                        {
137
134
                                pDock->container.fRatio *= 1. * iMaxAuthorizedWidth / pDock->iMaxDockWidth;
151
148
                        //g_print ("  -> changement du ratio : %.3f -> %.3f (%d, %d try)\n", fPrevRatio, pDock->container.fRatio, pDock->iRefCount, n);
152
149
                        Icon *icon;
153
150
                        GList *ic;
154
 
                        pDock->fFlatDockWidth = -myIcons.iIconGap;
 
151
                        pDock->fFlatDockWidth = -myIconsParam.iIconGap;
155
152
                        for (ic = pDock->icons; ic != NULL; ic = ic->next)
156
153
                        {
157
154
                                icon = ic->data;
158
155
                                icon->fWidth *= pDock->container.fRatio / fPrevRatio;
159
156
                                icon->fHeight *= pDock->container.fRatio / fPrevRatio;
160
 
                                pDock->fFlatDockWidth += icon->fWidth + myIcons.iIconGap;
 
157
                                pDock->fFlatDockWidth += icon->fWidth + myIconsParam.iIconGap;
161
158
                        }
162
159
                        hmax *= pDock->container.fRatio / fPrevRatio;
163
160
                        
183
180
                cairo_dock_move_resize_dock (pDock);
184
181
        }
185
182
        
186
 
        ///cairo_dock_update_background_decorations_if_necessary (pDock, pDock->iDecorationsWidth, pDock->iDecorationsHeight);
187
183
        cairo_dock_trigger_load_dock_background (pDock);
188
184
        
189
185
        if (pDock->iRefCount == 0 && pDock->iVisibility == CAIRO_DOCK_VISI_RESERVE && iPrevMaxDockHeight != pDock->iMaxDockHeight)
426
422
        int H = pDock->iMaxDockHeight;
427
423
        int w = pDock->iMinDockWidth;
428
424
        int h = pDock->iMinDockHeight;
429
 
        ///int w_ = MIN (myAccessibility.iVisibleZoneWidth, pDock->iMaxDockWidth);
430
 
        ///int h_ = MIN (myAccessibility.iVisibleZoneHeight, pDock->iMaxDockHeight);
 
425
        ///int w_ = MIN (myDocksParam.iVisibleZoneWidth, pDock->iMaxDockWidth);
 
426
        ///int h_ = MIN (myDocksParam.iVisibleZoneHeight, pDock->iMaxDockHeight);
431
427
        int w_ = 1;
432
428
        int h_ = 1;
433
429
        
480
476
                }
481
477
                //g_print ("%s : fXAtRest = %.2f\n", icon->cName, icon->fXAtRest);
482
478
 
483
 
                x_cumulated += icon->fWidth + myIcons.iIconGap;
 
479
                x_cumulated += icon->fWidth + myIconsParam.iIconGap;
484
480
        }
485
481
 
486
482
        return pFirstDrawnElement;
489
485
double cairo_dock_calculate_max_dock_width (CairoDock *pDock, GList *pFirstDrawnElementGiven, double fFlatDockWidth, double fWidthConstraintFactor, double fExtraWidth)
490
486
{
491
487
        double fMaxDockWidth = 0.;
492
 
        //g_print ("%s (%d)\n", __func__, fFlatDockWidth);
 
488
        //g_print ("%s (%d)\n", __func__, (int)fFlatDockWidth);
493
489
        GList *pIconList = pDock->icons;
494
490
        if (pIconList == NULL)
495
 
                return 2 * myBackground.iDockRadius + myBackground.iDockLineWidth + 2 * myBackground.iFrameMargin;
 
491
                return 2 * myDocksParam.iDockRadius + myDocksParam.iDockLineWidth + 2 * myDocksParam.iFrameMargin;
496
492
 
497
493
        //\_______________ On remet a zero les positions extremales des icones.
498
494
        GList* ic;
585
581
                fXMiddle = icon->fXAtRest + icon->fWidth / 2;
586
582
 
587
583
                //\_______________ On calcule sa phase (pi/2 au niveau du curseur).
588
 
                icon->fPhase = (fXMiddle - x_abs) / myIcons.iSinusoidWidth * G_PI + G_PI / 2;
 
584
                icon->fPhase = (fXMiddle - x_abs) / myIconsParam.iSinusoidWidth * G_PI + G_PI / 2;
589
585
                if (icon->fPhase < 0)
590
586
                {
591
587
                        icon->fPhase = 0;
596
592
                }
597
593
                
598
594
                //\_______________ On en deduit l'amplitude de la sinusoide au niveau de cette icone, et donc son echelle.
599
 
                icon->fScale = 1 + fMagnitude * myIcons.fAmplitude * sin (icon->fPhase);
 
595
                icon->fScale = 1 + fMagnitude * myIconsParam.fAmplitude * sin (icon->fPhase);
600
596
                if (iWidth > 0 && icon->fInsertRemoveFactor != 0)
601
597
                {
602
598
                        fScale = icon->fScale;
608
604
                        ///offset -= (icon->fWidth * icon->fScale) * (pointed_ic == NULL ? 1 : -1);
609
605
                }
610
606
                
611
 
                icon->fY = (bDirectionUp ? iHeight - myBackground.iDockLineWidth - myBackground.iFrameMargin - icon->fScale * icon->fHeight : myBackground.iDockLineWidth + myBackground.iFrameMargin);
 
607
                icon->fY = (bDirectionUp ? iHeight - myDocksParam.iDockLineWidth - myDocksParam.iFrameMargin - icon->fScale * icon->fHeight : myDocksParam.iDockLineWidth + myDocksParam.iFrameMargin);
612
608
                //g_print ("%s fY : %d; %.2f\n", icon->cName, iHeight, icon->fHeight);
613
609
                
614
610
                //\_______________ Si on avait deja defini l'icone pointee, on peut placer l'icone courante par rapport a la precedente.
622
618
                        else
623
619
                        {
624
620
                                prev_icon = (ic->prev != NULL ? ic->prev->data : cairo_dock_get_last_icon (pIconList));
625
 
                                icon->fX = prev_icon->fX + (prev_icon->fWidth + myIcons.iIconGap) * prev_icon->fScale;
 
621
                                icon->fX = prev_icon->fX + (prev_icon->fWidth + myIconsParam.iIconGap) * prev_icon->fScale;
626
622
 
627
 
                                if (icon->fX + icon->fWidth * icon->fScale > icon->fXMax - myIcons.fAmplitude * fMagnitude * (icon->fWidth + 1.5*myIcons.iIconGap) / 8 && iWidth != 0)
 
623
                                if (icon->fX + icon->fWidth * icon->fScale > icon->fXMax - myIconsParam.fAmplitude * fMagnitude * (icon->fWidth + 1.5*myIconsParam.iIconGap) / 8 && iWidth != 0)
628
624
                                {
629
625
                                        //g_print ("  on contraint %s (fXMax=%.2f , fX=%.2f\n", prev_icon->cName, prev_icon->fXMax, prev_icon->fX);
630
 
                                        fDeltaExtremum = icon->fX + icon->fWidth * icon->fScale - (icon->fXMax - myIcons.fAmplitude * fMagnitude * (icon->fWidth + 1.5*myIcons.iIconGap) / 16);
631
 
                                        if (myIcons.fAmplitude != 0)
632
 
                                                icon->fX -= fDeltaExtremum * (1 - (icon->fScale - 1) / myIcons.fAmplitude) * fMagnitude;
 
626
                                        fDeltaExtremum = icon->fX + icon->fWidth * icon->fScale - (icon->fXMax - myIconsParam.fAmplitude * fMagnitude * (icon->fWidth + 1.5*myIconsParam.iIconGap) / 16);
 
627
                                        if (myIconsParam.fAmplitude != 0)
 
628
                                                icon->fX -= fDeltaExtremum * (1 - (icon->fScale - 1) / myIconsParam.fAmplitude) * fMagnitude;
633
629
                                }
634
630
                        }
635
631
                        icon->fX = fAlign * iWidth + (icon->fX - fAlign * iWidth) * (1. - fFoldingFactor);
637
633
                }
638
634
                
639
635
                //\_______________ On regarde si on pointe sur cette icone.
640
 
                if (x_cumulated + icon->fWidth + .5*myIcons.iIconGap >= x_abs && x_cumulated - .5*myIcons.iIconGap <= x_abs && pointed_ic == NULL)  // on a trouve l'icone sur laquelle on pointe.
 
636
                if (x_cumulated + icon->fWidth + .5*myIconsParam.iIconGap >= x_abs && x_cumulated - .5*myIconsParam.iIconGap <= x_abs && pointed_ic == NULL)  // on a trouve l'icone sur laquelle on pointe.
641
637
                {
642
638
                        pointed_ic = ic;
643
639
                        ///icon->bPointed = TRUE;
644
640
                        icon->bPointed = (x_abs != (int) fFlatDockWidth && x_abs != 0);
645
 
                        icon->fX = x_cumulated - (fFlatDockWidth - iWidth) / 2 + (1 - icon->fScale) * (x_abs - x_cumulated + .5*myIcons.iIconGap);
 
641
                        icon->fX = x_cumulated - (fFlatDockWidth - iWidth) / 2 + (1 - icon->fScale) * (x_abs - x_cumulated + .5*myIconsParam.iIconGap);
646
642
                        icon->fX = fAlign * iWidth + (icon->fX - fAlign * iWidth) * (1. - fFoldingFactor);
647
643
                        //g_print ("  icone pointee : fX = %.2f (%.2f, %d)\n", icon->fX, x_cumulated, icon->bPointed);
648
644
                }
665
661
        {
666
662
                pointed_ic = (pFirstDrawnElement->prev == NULL ? g_list_last (pIconList) : pFirstDrawnElement->prev);
667
663
                icon = pointed_ic->data;
668
 
                icon->fX = x_cumulated - (fFlatDockWidth - iWidth) / 2 + (1 - icon->fScale) * (icon->fWidth + .5*myIcons.iIconGap);
 
664
                icon->fX = x_cumulated - (fFlatDockWidth - iWidth) / 2 + (1 - icon->fScale) * (icon->fWidth + .5*myIconsParam.iIconGap);
669
665
                icon->fX = fAlign * iWidth + (icon->fX - fAlign * iWidth) * (1 - fFoldingFactor);
670
666
                //g_print ("  en dehors a droite : icon->fX = %.2f (%.2f)\n", icon->fX, x_cumulated);
671
667
        }
681
677
                        
682
678
                prev_icon = ic->data;
683
679
                
684
 
                prev_icon->fX = icon->fX - (prev_icon->fWidth + myIcons.iIconGap) * prev_icon->fScale;
 
680
                prev_icon->fX = icon->fX - (prev_icon->fWidth + myIconsParam.iIconGap) * prev_icon->fScale;
685
681
                //g_print ("fX <- %.2f; fXMin : %.2f\n", prev_icon->fX, prev_icon->fXMin);
686
 
                if (prev_icon->fX < prev_icon->fXMin + myIcons.fAmplitude * fMagnitude * (prev_icon->fWidth + 1.5*myIcons.iIconGap) / 8 && iWidth != 0 && x_abs < iWidth && fMagnitude > 0)  /// && prev_icon->fPhase == 0   // on rajoute 'fMagnitude > 0' sinon il y'a un leger "saut" du aux contraintes a gauche de l'icone pointee.
 
682
                if (prev_icon->fX < prev_icon->fXMin + myIconsParam.fAmplitude * fMagnitude * (prev_icon->fWidth + 1.5*myIconsParam.iIconGap) / 8 && iWidth != 0 && x_abs < iWidth && fMagnitude > 0)  /// && prev_icon->fPhase == 0   // on rajoute 'fMagnitude > 0' sinon il y'a un leger "saut" du aux contraintes a gauche de l'icone pointee.
687
683
                {
688
684
                        //g_print ("  on contraint %s (fXMin=%.2f , fX=%.2f\n", prev_icon->cName, prev_icon->fXMin, prev_icon->fX);
689
 
                        fDeltaExtremum = prev_icon->fX - (prev_icon->fXMin + myIcons.fAmplitude * fMagnitude * (prev_icon->fWidth + 1.5*myIcons.iIconGap) / 16);
690
 
                        if (myIcons.fAmplitude != 0)
691
 
                                prev_icon->fX -= fDeltaExtremum * (1 - (prev_icon->fScale - 1) / myIcons.fAmplitude) * fMagnitude;
 
685
                        fDeltaExtremum = prev_icon->fX - (prev_icon->fXMin + myIconsParam.fAmplitude * fMagnitude * (prev_icon->fWidth + 1.5*myIconsParam.iIconGap) / 16);
 
686
                        if (myIconsParam.fAmplitude != 0)
 
687
                                prev_icon->fX -= fDeltaExtremum * (1 - (prev_icon->fScale - 1) / myIconsParam.fAmplitude) * fMagnitude;
692
688
                }
693
689
                prev_icon->fX = fAlign * iWidth + (prev_icon->fX - fAlign * iWidth) * (1. - fFoldingFactor);
694
690
                //g_print ("  prev_icon->fX : %.2f\n", prev_icon->fX);
707
703
                }
708
704
        }
709
705
        
710
 
        return pointed_ic->data;
 
706
        icon = pointed_ic->data;
 
707
        return (icon->bPointed ? icon : NULL);
711
708
}
712
709
 
713
710
Icon *cairo_dock_apply_wave_effect_linear (CairoDock *pDock)
725
722
double cairo_dock_get_current_dock_width_linear (CairoDock *pDock)
726
723
{
727
724
        if (pDock->icons == NULL)
728
 
                //return 2 * myBackground.iDockRadius + myBackground.iDockLineWidth + 2 * myBackground.iFrameMargin;
729
 
                return 1 + 2 * myBackground.iFrameMargin;
 
725
                //return 2 * myDocksParam.iDockRadius + myDocksParam.iDockLineWidth + 2 * myDocksParam.iFrameMargin;
 
726
                return 1 + 2 * myDocksParam.iFrameMargin;
730
727
 
731
728
        Icon *pLastIcon = cairo_dock_get_last_drawn_icon (pDock);
732
729
        Icon *pFirstIcon = cairo_dock_get_first_drawn_icon (pDock);
733
 
        double fWidth = pLastIcon->fX - pFirstIcon->fX + pLastIcon->fWidth * pLastIcon->fScale + 2 * myBackground.iFrameMargin;  //  + 2 * myBackground.iDockRadius + myBackground.iDockLineWidth + 2 * myBackground.iFrameMargin
 
730
        double fWidth = pLastIcon->fX - pFirstIcon->fX + pLastIcon->fWidth * pLastIcon->fScale + 2 * myDocksParam.iFrameMargin;  //  + 2 * myDocksParam.iDockRadius + myDocksParam.iDockLineWidth + 2 * myDocksParam.iFrameMargin
734
731
 
735
732
        return fWidth;
736
733
}
741
738
        CairoDockMousePositionType iMousePositionType;
742
739
        int iWidth = pDock->container.iWidth;
743
740
        int iHeight = (pDock->fMagnitudeMax != 0 ? pDock->container.iHeight : pDock->iMinDockHeight);
744
 
        ///int iExtraHeight = (pDock->bAtBottom ? 0 : myLabels.iLabelSize);
 
741
        ///int iExtraHeight = (pDock->bAtBottom ? 0 : myIconsParam.iLabelSize);
745
742
        int iExtraHeight = 0;  /// il faudrait voir si on a un sous-dock ou un dialogue au dessus :-/
746
743
        int iMouseX = pDock->container.iMouseX;
747
744
        int iMouseY = (pDock->container.bDirectionUp ? pDock->container.iHeight - pDock->container.iMouseY : pDock->container.iMouseY);
787
784
        switch (pDock->iMousePositionType)
788
785
        {
789
786
                case CAIRO_DOCK_MOUSE_INSIDE :
790
 
                        //g_print ("INSIDE (%d;%d;%d;%d;%.2f)\n", cairo_dock_entrance_is_allowed (pDock), pDock->iMagnitudeIndex, pDock->bIsGrowingUp, pDock->bIsShrinkingDown, pDock->fFoldingFactor);
 
787
                        //g_print ("INSIDE (%d;%d;%d;%d;%d)\n", cairo_dock_entrance_is_allowed (pDock), pDock->iMagnitudeIndex, pDock->bIsGrowingUp, pDock->bIsShrinkingDown, pDock->iInputState);
791
788
                        if (cairo_dock_entrance_is_allowed (pDock) && ((pDock->iMagnitudeIndex < CAIRO_DOCK_NB_MAX_ITERATIONS && ! pDock->bIsGrowingUp) || pDock->bIsShrinkingDown) && pDock->iInputState != CAIRO_DOCK_INPUT_HIDDEN && (pDock->iInputState != CAIRO_DOCK_INPUT_AT_REST || pDock->bIsDragging))  // on est dedans et la taille des icones est non maximale bien que le dock ne soit pas en train de grossir, cependant on respecte l'etat 'cache', et l'etat repos.
792
789
                        {
793
790
                                //g_print ("on est dedans en x et en y et la taille des icones est non maximale bien qu'aucune icone  ne soit animee (%d;%d)\n", pDock->iMagnitudeIndex, pDock->container.bInside);
828
825
                                        if (pPointingIcon && pPointingIcon->bPointed)  // sous-dock pointe, n le laisse en position haute.
829
826
                                                return;
830
827
                                }
831
 
                                cd_debug ("on force a quitter (iRefCount:%d; bIsGrowingUp:%d; iMagnitudeIndex:%d)", pDock->iRefCount, pDock->bIsGrowingUp, pDock->iMagnitudeIndex);
832
 
                                if (pDock->iRefCount > 0 && myAccessibility.iLeaveSubDockDelay > 0)
833
 
                                        pDock->iSidLeaveDemand = g_timeout_add (myAccessibility.iLeaveSubDockDelay, (GSourceFunc) cairo_dock_emit_leave_signal, (gpointer) pDock);
834
 
                                else
835
 
                                        cairo_dock_emit_leave_signal (CAIRO_CONTAINER (pDock));
 
828
                                //g_print ("on force a quitter (iRefCount:%d; bIsGrowingUp:%d; iMagnitudeIndex:%d)\n", pDock->iRefCount, pDock->bIsGrowingUp, pDock->iMagnitudeIndex);
 
829
                                pDock->iSidLeaveDemand = g_timeout_add (MAX (myDocksParam.iLeaveSubDockDelay, 330), (GSourceFunc) cairo_dock_emit_leave_signal, (gpointer) pDock);
836
830
                        }
837
831
                break ;
838
832
        }
841
835
#define make_icon_avoid_mouse(icon) \
842
836
        cairo_dock_mark_icon_as_avoiding_mouse (icon);\
843
837
        icon->fAlpha = 0.75;\
844
 
        if (myIcons.fAmplitude != 0)\
845
 
                icon->fDrawX += icon->fWidth / 2 * (icon->fScale - 1) / myIcons.fAmplitude * (icon->fPhase < G_PI/2 ? -1 : 1);
 
838
        if (myIconsParam.fAmplitude != 0)\
 
839
                icon->fDrawX += icon->fWidth / 2 * (icon->fScale - 1) / myIconsParam.fAmplitude * (icon->fPhase < G_PI/2 ? -1 : 1);
846
840
 
847
 
static gboolean _cairo_dock_check_can_drop_linear (CairoDock *pDock, CairoDockIconType iType, double fMargin)
 
841
static gboolean _cairo_dock_check_can_drop_linear (CairoDock *pDock, CairoDockIconGroup iGroup, double fMargin)
848
842
{
849
843
        gboolean bCanDrop = FALSE;
850
844
        Icon *icon;
858
852
                        if (pDock->container.iMouseX < icon->fDrawX + icon->fWidth * icon->fScale * fMargin)  // on est a gauche.  // fDrawXAtRest
859
853
                        {
860
854
                                Icon *prev_icon = cairo_dock_get_previous_element (ic, pDock->icons) -> data;
861
 
                                if ((cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (iType) || cairo_dock_get_icon_order (prev_icon) == cairo_dock_get_group_order (iType)))  // && prev_icon->iAnimationType != CAIRO_DOCK_FOLLOW_MOUSE
 
855
                                if ((cairo_dock_get_icon_order (icon) == cairo_dock_get_group_order (iGroup) || cairo_dock_get_icon_order (prev_icon) == cairo_dock_get_group_order (iGroup)))  // && prev_icon->iAnimationType != CAIRO_DOCK_FOLLOW_MOUSE
862
856
                                {
863
857
                                        make_icon_avoid_mouse (icon);
864
858
                                        make_icon_avoid_mouse (prev_icon);
869
863
                        else if (pDock->container.iMouseX > icon->fDrawX + icon->fWidth * icon->fScale * (1 - fMargin))  // on est a droite.  // fDrawXAtRest
870
864
                        {
871
865
                                Icon *next_icon = cairo_dock_get_next_element (ic, pDock->icons) -> data;
872
 
                                if ((icon->iType == iType || next_icon->iType == iType))  // && next_icon->iAnimationType != CAIRO_DOCK_FOLLOW_MOUSE
 
866
                                if ((icon->iGroup == iGroup || next_icon->iGroup == iGroup))  // && next_icon->iAnimationType != CAIRO_DOCK_FOLLOW_MOUSE
873
867
                                {
874
868
                                        make_icon_avoid_mouse (icon);
875
869
                                        make_icon_avoid_mouse (next_icon);
981
975
        
982
976
        if (pSubDock->icons != NULL)
983
977
        {
984
 
                pSubDock->fFoldingFactor = (mySystem.bAnimateSubDock ? .99 : 0.);
985
 
                cairo_dock_notify_on_icon (pPointedIcon, CAIRO_DOCK_UNFOLD_SUBDOCK, pPointedIcon);
 
978
                pSubDock->fFoldingFactor = (myDocksParam.bAnimateSubDock ? .99 : 0.);
 
979
                cairo_dock_notify_on_object (&myIconsMgr, NOTIFICATION_UNFOLD_SUBDOCK, pPointedIcon);
 
980
                cairo_dock_notify_on_object (pPointedIcon, NOTIFICATION_UNFOLD_SUBDOCK, pPointedIcon);
986
981
        }
 
982
        else
 
983
                pSubDock->fFoldingFactor = 0.;
987
984
        
988
985
        int iNewWidth = pSubDock->iMaxDockWidth;
989
986
        int iNewHeight = pSubDock->iMaxDockHeight;
993
990
        gtk_window_present (GTK_WINDOW (pSubDock->container.pWidget));
994
991
        
995
992
        if (pSubDock->container.bIsHorizontal)
996
 
                        gdk_window_move_resize (pSubDock->container.pWidget->window,
 
993
                gdk_window_move_resize (pSubDock->container.pWidget->window,
997
994
                        iNewPositionX,
998
995
                        iNewPositionY,
999
996
                        iNewWidth,
1008
1005
        if (pSubDock->fFoldingFactor == 0.)
1009
1006
        {
1010
1007
                cd_debug ("  on montre le sous-dock sans animation");
 
1008
                gtk_widget_queue_draw (pSubDock->container.pWidget);
1011
1009
        }
1012
1010
        else
1013
1011
        {
1017
1015
        }
1018
1016
        //g_print ("  -> Gap %d;%d -> W(%d;%d) (%d)\n", pSubDock->iGapX, pSubDock->iGapY, pSubDock->container.iWindowPositionX, pSubDock->container.iWindowPositionY, pSubDock->container.bIsHorizontal);
1019
1017
        
1020
 
        ///gtk_window_set_keep_above (GTK_WINDOW (pSubDock->container.pWidget), myAccessibility.bPopUp);
 
1018
        ///gtk_window_set_keep_above (GTK_WINDOW (pSubDock->container.pWidget), myDocksParam.bPopUp);
1021
1019
        
1022
1020
        cairo_dock_replace_all_dialogs ();
1023
1021
}
1026
1024
 
1027
1025
static gboolean _redraw_subdock_content_idle (Icon *pIcon)
1028
1026
{
 
1027
        cd_debug ("%s()", __func__);
 
1028
        cd_debug (" %s", pIcon->cName);
1029
1029
        CairoDock *pDock = cairo_dock_search_dock_from_name (pIcon->cParentDockName);
1030
1030
        if (pDock != NULL)
1031
1031
        {
1045
1045
void cairo_dock_trigger_redraw_subdock_content (CairoDock *pDock)
1046
1046
{
1047
1047
        Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, NULL);
1048
 
        if (pPointingIcon != NULL && (pPointingIcon->iSubdockViewType != 0 || (pPointingIcon->cClass != NULL && ! myIndicators.bUseClassIndic && (CAIRO_DOCK_ICON_TYPE_IS_CLASS_CONTAINER (pPointingIcon) || CAIRO_DOCK_ICON_TYPE_IS_LAUNCHER (pPointingIcon)))))
 
1048
        if (pPointingIcon != NULL && (pPointingIcon->iSubdockViewType != 0 || (pPointingIcon->cClass != NULL && ! myIndicatorsParam.bUseClassIndic && (CAIRO_DOCK_ICON_TYPE_IS_CLASS_CONTAINER (pPointingIcon) || CAIRO_DOCK_ICON_TYPE_IS_LAUNCHER (pPointingIcon)))))
1049
1049
        {
1050
1050
                if (pPointingIcon->iSidRedrawSubdockContent != 0)  // s'il y'a deja un redessin de prevu, on le passe a la fin de facon a ce qu'il ne se fasse  pas avant le redessin de l'icone responsable de ce trigger.
1051
1051
                        g_source_remove (pPointingIcon->iSidRedrawSubdockContent);
1083
1083
                pDock->iSidUpdateWMIcons = g_idle_add ((GSourceFunc) _update_WM_icons, pDock);
1084
1084
        }
1085
1085
}
 
1086
 
 
1087
 
 
1088
  ///////////////////////
 
1089
 /// DOCK BACKGROUND ///
 
1090
///////////////////////
 
1091
 
 
1092
static cairo_surface_t *_cairo_dock_make_stripes_background (int iWidth, int iHeight, double *fStripesColorBright, double *fStripesColorDark, int iNbStripes, double fStripesWidth, double fStripesAngle)
 
1093
{
 
1094
        cairo_pattern_t *pStripesPattern;
 
1095
        double fWidth = iWidth;
 
1096
        if (fabs (fStripesAngle) != 90)
 
1097
                pStripesPattern = cairo_pattern_create_linear (0.0f,
 
1098
                        0.0f,
 
1099
                        iWidth,
 
1100
                        iWidth * tan (fStripesAngle * G_PI/180.));
 
1101
        else
 
1102
                pStripesPattern = cairo_pattern_create_linear (0.0f,
 
1103
                        0.0f,
 
1104
                        0.,
 
1105
                        (fStripesAngle == 90) ? iHeight : - iHeight);
 
1106
        g_return_val_if_fail (cairo_pattern_status (pStripesPattern) == CAIRO_STATUS_SUCCESS, NULL);
 
1107
 
 
1108
        cairo_pattern_set_extend (pStripesPattern, CAIRO_EXTEND_REPEAT);
 
1109
 
 
1110
        if (iNbStripes > 0)
 
1111
        {
 
1112
                gdouble fStep;
 
1113
                int i;
 
1114
                for (i = 0; i < iNbStripes+1; i ++)
 
1115
                {
 
1116
                        fStep = (double)i / iNbStripes;
 
1117
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
1118
                                fStep - fStripesWidth / 2.,
 
1119
                                fStripesColorBright[0],
 
1120
                                fStripesColorBright[1],
 
1121
                                fStripesColorBright[2],
 
1122
                                fStripesColorBright[3]);
 
1123
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
1124
                                fStep,
 
1125
                                fStripesColorDark[0],
 
1126
                                fStripesColorDark[1],
 
1127
                                fStripesColorDark[2],
 
1128
                                fStripesColorDark[3]);
 
1129
                        cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
1130
                                fStep + fStripesWidth / 2.,
 
1131
                                fStripesColorBright[0],
 
1132
                                fStripesColorBright[1],
 
1133
                                fStripesColorBright[2],
 
1134
                                fStripesColorBright[3]);
 
1135
                }
 
1136
        }
 
1137
        else
 
1138
        {
 
1139
                cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
1140
                        0.,
 
1141
                        fStripesColorDark[0],
 
1142
                        fStripesColorDark[1],
 
1143
                        fStripesColorDark[2],
 
1144
                        fStripesColorDark[3]);
 
1145
                cairo_pattern_add_color_stop_rgba (pStripesPattern,
 
1146
                        1.,
 
1147
                        fStripesColorBright[0],
 
1148
                        fStripesColorBright[1],
 
1149
                        fStripesColorBright[2],
 
1150
                        fStripesColorBright[3]);
 
1151
        }
 
1152
 
 
1153
        cairo_surface_t *pNewSurface = cairo_dock_create_blank_surface (
 
1154
                        iWidth,
 
1155
                        iHeight);
 
1156
        cairo_t *pImageContext = cairo_create (pNewSurface);
 
1157
        cairo_set_source (pImageContext, pStripesPattern);
 
1158
        cairo_paint (pImageContext);
 
1159
 
 
1160
        cairo_pattern_destroy (pStripesPattern);
 
1161
        cairo_destroy (pImageContext);
 
1162
        
 
1163
        return pNewSurface;
 
1164
}
 
1165
static void _cairo_dock_load_default_background (CairoDockImageBuffer *pImage, int iWidth, int iHeight)
 
1166
{
 
1167
        //g_print ("%s (%s, %d)\n", __func__, myDocksParam.cBackgroundImageFile, myDocksParam.bBackgroundImageRepeat);
 
1168
        if (myDocksParam.cBackgroundImageFile != NULL)
 
1169
        {
 
1170
                if (myDocksParam.bBackgroundImageRepeat)
 
1171
                {
 
1172
                        cairo_surface_t *pBgSurface = cairo_dock_create_surface_from_pattern (myDocksParam.cBackgroundImageFile,
 
1173
                                iWidth,
 
1174
                                iHeight,
 
1175
                                myDocksParam.fBackgroundImageAlpha);
 
1176
                        cairo_dock_load_image_buffer_from_surface (pImage,
 
1177
                                pBgSurface,
 
1178
                                iWidth,
 
1179
                                iHeight);
 
1180
                }
 
1181
                else
 
1182
                {
 
1183
                        cairo_dock_load_image_buffer_full (pImage,
 
1184
                                myDocksParam.cBackgroundImageFile,
 
1185
                                iWidth,
 
1186
                                iHeight,
 
1187
                                CAIRO_DOCK_FILL_SPACE,
 
1188
                                myDocksParam.fBackgroundImageAlpha);
 
1189
                }
 
1190
        }
 
1191
        if (pImage->pSurface == NULL)
 
1192
        {
 
1193
                cairo_surface_t *pBgSurface = _cairo_dock_make_stripes_background (
 
1194
                        iWidth,
 
1195
                        iHeight,
 
1196
                        myDocksParam.fStripesColorBright,
 
1197
                        myDocksParam.fStripesColorDark,
 
1198
                        myDocksParam.iNbStripes,
 
1199
                        myDocksParam.fStripesWidth,
 
1200
                        myDocksParam.fStripesAngle);
 
1201
                cairo_dock_load_image_buffer_from_surface (pImage,
 
1202
                        pBgSurface,
 
1203
                        iWidth,
 
1204
                        iHeight);
 
1205
        }
 
1206
}
 
1207
 
 
1208
void cairo_dock_load_dock_background (CairoDock *pDock)
 
1209
{
 
1210
        cairo_dock_unload_image_buffer (&pDock->backgroundBuffer);
 
1211
        
 
1212
        int iWidth = pDock->iDecorationsWidth;
 
1213
        int iHeight = pDock->iDecorationsHeight;
 
1214
        
 
1215
        if (pDock->bGlobalBg || pDock->iRefCount > 0)
 
1216
        {
 
1217
                _cairo_dock_load_default_background (&pDock->backgroundBuffer, iWidth, iHeight);
 
1218
        }
 
1219
        else if (pDock->cBgImagePath != NULL)
 
1220
        {
 
1221
                cairo_dock_load_image_buffer (&pDock->backgroundBuffer, pDock->cBgImagePath, iWidth, iHeight, CAIRO_DOCK_FILL_SPACE);
 
1222
        }
 
1223
        if (pDock->backgroundBuffer.pSurface == NULL)
 
1224
        {
 
1225
                cairo_surface_t *pSurface = _cairo_dock_make_stripes_background (iWidth, iHeight, pDock->fBgColorBright, pDock->fBgColorDark, 0, 0., 90);
 
1226
                cairo_dock_load_image_buffer_from_surface (&pDock->backgroundBuffer, pSurface, iWidth, iHeight);
 
1227
        }
 
1228
}
 
1229
 
 
1230
static gboolean _load_background_idle (CairoDock *pDock)
 
1231
{
 
1232
        cairo_dock_load_dock_background (pDock);
 
1233
        
 
1234
        pDock->iSidLoadBg = 0;
 
1235
        return FALSE;
 
1236
}
 
1237
void cairo_dock_trigger_load_dock_background (CairoDock *pDock)
 
1238
{
 
1239
        if (pDock->iDecorationsWidth == pDock->backgroundBuffer.iWidth && pDock->iDecorationsHeight == pDock->backgroundBuffer.iHeight)  // mise a jour inutile.
 
1240
                return;
 
1241
        if (pDock->iSidLoadBg == 0)
 
1242
                pDock->iSidLoadBg = g_idle_add ((GSourceFunc)_load_background_idle, pDock);
 
1243
}