← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/cairo-dock/oneiric-201106091216

« back to all changes in this revision

Viewing changes to src/cairo-dock-surface-factory.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthieu Baerts (matttbe), Matthieu Baerts (matttbe), Didier Roche
  • Date: 2010-03-01 21:24:00 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20100301212400-3a3csog6eonse3in
Tags: 2.1.3-6-0ubuntu1
https://launchpad.net/bugs/521534
[ Matthieu Baerts (matttbe) ]
* New Upstream Version. (LP: #521534)
* Updated debian/watch and debian/copyright with LP account.
* Removed debian/patches/02-merge-changelog.patch'
 - data/ChangeLog.txt has to respect a syntax and is used by CD.
* debian/cairo-dock.1:
 - Updated with the latest release.
 - The domain name 'cairo-dock.org' has changed to 'glx-dock.org'
* debian/control:
 - Changed the homepage and other links (glx-dock.org)
 - Updated cairo-dock-dev architecture to 'all' (it no longer contains compiled files)
* debian/cairo-dock-dev.install
 - libcairo-dock.a and libcairo-dock.so no longer exist
* debian/rules
 - removed uneeded changelog file
* Updated debian/patches/01-desktop-file-category.patch

[ Didier Roche ]
* Fix debian/watch
* Fix some issue in versionning
* debian/control: clean the packaging and add right -plugins depends

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-surface-factory.c
25
25
 
26
26
#include "cairo-dock-log.h"
27
27
#include "cairo-dock-draw.h"
28
 
#include "cairo-dock-draw.h"
29
28
#include "cairo-dock-launcher-factory.h"
30
29
#include "cairo-dock-load.h"
31
 
#include "cairo-dock-internal-icons.h"
32
30
#include "cairo-dock-surface-factory.h"
33
31
 
34
32
extern gboolean g_bUseOpenGL;
136
134
{
137
135
        int iOrientation = iLoadingModifier & CAIRO_DOCK_ORIENTATION_MASK;
138
136
        
139
 
        //if (iOrientation != 0)
 
137
        cairo_translate (pCairoContext,
 
138
                fImageWidth/2,
 
139
                fImageHeight/2);
 
140
        cairo_scale (pCairoContext,
 
141
                fZoomX,
 
142
                fZoomY);
 
143
        switch (iOrientation)
140
144
        {
141
 
                cairo_translate (pCairoContext,
142
 
                        fImageWidth/2,
143
 
                        fImageHeight/2);
144
 
                cairo_scale (pCairoContext,
145
 
                        fZoomX,
146
 
                        fZoomY);
147
 
                switch (iOrientation)
148
 
                {
149
 
                        case CAIRO_DOCK_ORIENTATION_HFLIP :
150
 
                                g_print ("orientation : HFLIP\n");
151
 
                                cairo_scale (pCairoContext, -1., 1.);
152
 
                        break ;
153
 
                        case CAIRO_DOCK_ORIENTATION_ROT_180 :
154
 
                                g_print ("orientation : ROT_180\n");
155
 
                                cairo_rotate (pCairoContext, G_PI);
156
 
                        break ;
157
 
                        case CAIRO_DOCK_ORIENTATION_VFLIP :
158
 
                                g_print ("orientation : VFLIP\n");
159
 
                                cairo_scale (pCairoContext, 1., -1.);
160
 
                        break ;
161
 
                        case CAIRO_DOCK_ORIENTATION_ROT_90_HFLIP :
162
 
                                g_print ("orientation : ROT_90_HFLIP\n");
163
 
                                cairo_scale (pCairoContext, -1., 1.);
164
 
                                cairo_rotate (pCairoContext, + G_PI/2);
165
 
                        break ;
166
 
                        case CAIRO_DOCK_ORIENTATION_ROT_90 :
167
 
                                g_print ("orientation : ROT_90\n");
168
 
                                cairo_rotate (pCairoContext, + G_PI/2);
169
 
                        break ;
170
 
                        case CAIRO_DOCK_ORIENTATION_ROT_90_VFLIP :
171
 
                                g_print ("orientation : ROT_90_VFLIP\n");
172
 
                                cairo_scale (pCairoContext, 1., -1.);
173
 
                                cairo_rotate (pCairoContext, + G_PI/2);
174
 
                        break ;
175
 
                        case CAIRO_DOCK_ORIENTATION_ROT_270 :
176
 
                                g_print ("orientation : ROT_270\n");
177
 
                                cairo_rotate (pCairoContext, - G_PI/2);
178
 
                        break ;
179
 
                        default :
180
 
                        break ;
181
 
                }
182
 
                if (iOrientation < CAIRO_DOCK_ORIENTATION_ROT_90_HFLIP)
183
 
                        cairo_translate (pCairoContext,
184
 
                                - fUsefulWidth/2/fZoomX,
185
 
                                - fUsefulheight/2/fZoomY);
186
 
                else
187
 
                        cairo_translate (pCairoContext,
188
 
                                - fUsefulheight/2/fZoomY,
189
 
                                - fUsefulWidth/2/fZoomX);
 
145
                case CAIRO_DOCK_ORIENTATION_HFLIP :
 
146
                        g_print ("orientation : HFLIP\n");
 
147
                        cairo_scale (pCairoContext, -1., 1.);
 
148
                break ;
 
149
                case CAIRO_DOCK_ORIENTATION_ROT_180 :
 
150
                        g_print ("orientation : ROT_180\n");
 
151
                        cairo_rotate (pCairoContext, G_PI);
 
152
                break ;
 
153
                case CAIRO_DOCK_ORIENTATION_VFLIP :
 
154
                        g_print ("orientation : VFLIP\n");
 
155
                        cairo_scale (pCairoContext, 1., -1.);
 
156
                break ;
 
157
                case CAIRO_DOCK_ORIENTATION_ROT_90_HFLIP :
 
158
                        g_print ("orientation : ROT_90_HFLIP\n");
 
159
                        cairo_scale (pCairoContext, -1., 1.);
 
160
                        cairo_rotate (pCairoContext, + G_PI/2);
 
161
                break ;
 
162
                case CAIRO_DOCK_ORIENTATION_ROT_90 :
 
163
                        g_print ("orientation : ROT_90\n");
 
164
                        cairo_rotate (pCairoContext, + G_PI/2);
 
165
                break ;
 
166
                case CAIRO_DOCK_ORIENTATION_ROT_90_VFLIP :
 
167
                        g_print ("orientation : ROT_90_VFLIP\n");
 
168
                        cairo_scale (pCairoContext, 1., -1.);
 
169
                        cairo_rotate (pCairoContext, + G_PI/2);
 
170
                break ;
 
171
                case CAIRO_DOCK_ORIENTATION_ROT_270 :
 
172
                        g_print ("orientation : ROT_270\n");
 
173
                        cairo_rotate (pCairoContext, - G_PI/2);
 
174
                break ;
 
175
                default :
 
176
                break ;
190
177
        }
191
 
        /*else
192
 
        {
193
 
                cairo_scale (pCairoContext,
194
 
                        fZoomX,
195
 
                        fZoomY);
196
 
        }*/
 
178
        if (iOrientation < CAIRO_DOCK_ORIENTATION_ROT_90_HFLIP)
 
179
                cairo_translate (pCairoContext,
 
180
                        - fUsefulWidth/2/fZoomX,
 
181
                        - fUsefulheight/2/fZoomY);
 
182
        else
 
183
                cairo_translate (pCairoContext,
 
184
                        - fUsefulheight/2/fZoomY,
 
185
                        - fUsefulWidth/2/fZoomX);
197
186
}
198
187
 
199
188
 
200
 
cairo_surface_t *cairo_dock_create_surface_from_xicon_buffer (gulong *pXIconBuffer, int iBufferNbElements, cairo_t *pSourceContext, double fMaxScale, double *fWidth, double *fHeight)
 
189
cairo_surface_t *cairo_dock_create_surface_from_xicon_buffer (gulong *pXIconBuffer, int iBufferNbElements, cairo_t *pSourceContext, double fConstraintWidth, double fConstraintHeight, double fMaxScale, double *fWidth, double *fHeight)
201
190
{
202
191
        g_return_val_if_fail (cairo_status (pSourceContext) == CAIRO_STATUS_SUCCESS, NULL);
203
192
 
213
202
        //\____________________ On pre-multiplie chaque composante par le alpha (necessaire pour libcairo).
214
203
        int w = pXIconBuffer[iBestIndex];
215
204
        int h = pXIconBuffer[iBestIndex+1];
 
205
        iBestIndex += 2;
 
206
        //g_print ("%s (%dx%d)\n", __func__, w, h);
216
207
        
217
 
        int i;
 
208
        int i, n = w * h;
 
209
        if (iBestIndex + n > iBufferNbElements)  // precaution au cas ou le nombre d'elements dans le buffer serait incorrect.
 
210
        {
 
211
                cd_warning ("This icon is broken !\nThis means that one of the current applications has sent a buggy icon to X.");
 
212
                return NULL;
 
213
        }
218
214
        gint pixel, alpha, red, green, blue;
219
215
        float fAlphaFactor;
220
 
        gint *pPixelBuffer = (gint *) &pXIconBuffer[iBestIndex+2];  // on va ecrire le resultat du filtre directement dans le tableau fourni en entree. C'est ok car sizeof(gulong) >= sizeof(gint), donc le tableau de pixels est plus petit que le buffer fourni en entree. merci a Hannemann pour ses tests et ses screenshots ! :-)
221
 
        for (i = 0; i < w * h; i ++)
 
216
        gint *pPixelBuffer = (gint *) &pXIconBuffer[iBestIndex];  // on va ecrire le resultat du filtre directement dans le tableau fourni en entree. C'est ok car sizeof(gulong) >= sizeof(gint), donc le tableau de pixels est plus petit que le buffer fourni en entree. merci a Hannemann pour ses tests et ses screenshots ! :-)
 
217
        for (i = 0; i < n; i ++)
222
218
        {
223
 
                pixel = (gint) pXIconBuffer[iBestIndex+2+i];
 
219
                pixel = (gint) pXIconBuffer[iBestIndex+i];
224
220
                alpha = (pixel & 0xFF000000) >> 24;
225
221
                red   = (pixel & 0x00FF0000) >> 16;
226
222
                green = (pixel & 0x0000FF00) >> 8;
245
241
        double fIconWidthSaturationFactor = 1., fIconHeightSaturationFactor = 1.;
246
242
        cairo_dock_calculate_constrainted_size (fWidth,
247
243
                fHeight,
248
 
                myIcons.tIconAuthorizedWidth[CAIRO_DOCK_APPLI],
249
 
                myIcons.tIconAuthorizedHeight[CAIRO_DOCK_APPLI],
 
244
                fConstraintWidth,
 
245
                fConstraintHeight,
250
246
                CAIRO_DOCK_KEEP_RATIO | CAIRO_DOCK_FILL_SPACE,
251
247
                &fIconWidthSaturationFactor,
252
248
                &fIconHeightSaturationFactor);
253
 
 
 
249
        
254
250
        cairo_surface_t *pNewSurface = _cairo_dock_create_blank_surface (pSourceContext,
255
251
                ceil (*fWidth * fMaxScale),
256
252
                ceil (*fHeight * fMaxScale));
257
253
        cairo_t *pCairoContext = cairo_create (pNewSurface);
258
254
        
259
 
        
260
 
        
261
255
        double fUsefulWidth = w * fIconWidthSaturationFactor;  // a part dans le cas fill && keep ratio, c'est la meme chose que fImageWidth et fImageHeight.
262
256
        double fUsefulHeight = h * fIconHeightSaturationFactor;
263
257
        _apply_orientation_and_scale (pCairoContext,
265
259
                ceil ((*fWidth) * fMaxScale), ceil ((*fHeight) * fMaxScale),
266
260
                fMaxScale * fIconWidthSaturationFactor, fMaxScale * fIconHeightSaturationFactor,
267
261
                fUsefulWidth * fMaxScale, fUsefulHeight * fMaxScale);
268
 
        /**cairo_scale (pCairoContext, fMaxScale * fIconWidthSaturationFactor, fMaxScale * fIconHeightSaturationFactor);*/
269
262
        cairo_set_source_surface (pCairoContext, surface_ini, 0, 0);
270
263
        cairo_paint (pCairoContext);
271
264
 
562
555
        return pSurface;
563
556
}
564
557
 
 
558
cairo_surface_t *cairo_dock_create_surface_from_pattern (const gchar *cImageFile, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fAlpha)
 
559
{
 
560
        g_return_val_if_fail (cairo_status (pSourceContext) == CAIRO_STATUS_SUCCESS, NULL);
 
561
        cairo_surface_t *pNewSurface = NULL;
 
562
 
 
563
        if (cImageFile != NULL)
 
564
        {
 
565
                gchar *cImagePath = cairo_dock_generate_file_path (cImageFile);
 
566
                double fImageWidth, fImageHeight;
 
567
                cairo_surface_t *pPatternSurface = cairo_dock_create_surface_from_image (cImagePath,
 
568
                        pSourceContext,
 
569
                        1.,
 
570
                        0,  // pas de contrainte sur
 
571
                        0,  // la taille du motif initialement.
 
572
                        CAIRO_DOCK_FILL_SPACE,
 
573
                        &fImageWidth,
 
574
                        &fImageHeight,
 
575
                        NULL, NULL);
 
576
                g_free (cImagePath);
 
577
                if (pPatternSurface == NULL)
 
578
                        return NULL;
 
579
                
 
580
                pNewSurface = _cairo_dock_create_blank_surface (pSourceContext,
 
581
                        fImageWidth,
 
582
                        fImageHeight);
 
583
                cairo_t *pCairoContext = cairo_create (pNewSurface);
 
584
 
 
585
                cairo_pattern_t* pPattern = cairo_pattern_create_for_surface (pPatternSurface);
 
586
                g_return_val_if_fail (cairo_pattern_status (pPattern) == CAIRO_STATUS_SUCCESS, NULL);
 
587
                cairo_pattern_set_extend (pPattern, CAIRO_EXTEND_REPEAT);
 
588
 
 
589
                cairo_set_source (pCairoContext, pPattern);
 
590
                cairo_paint_with_alpha (pCairoContext, fAlpha);
 
591
                cairo_destroy (pCairoContext);
 
592
                cairo_pattern_destroy (pPattern);
 
593
                
 
594
                cairo_surface_destroy (pPatternSurface);
 
595
        }
 
596
        
 
597
        return pNewSurface;
 
598
}
 
599
 
565
600
 
566
601
 
567
602
cairo_surface_t * cairo_dock_rotate_surface (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fRotationAngle)
614
649
}
615
650
 
616
651
 
617
 
static cairo_surface_t * cairo_dock_create_reflection_surface_horizontal (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fMaxScale, gboolean bDirectionUp)
 
652
static cairo_surface_t * cairo_dock_create_reflection_surface_horizontal (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fReflectSize, double fAlbedo, gboolean bDirectionUp)
618
653
{
619
654
        g_return_val_if_fail (pSourceContext != NULL && cairo_status (pSourceContext) == CAIRO_STATUS_SUCCESS, NULL);
620
655
        //g_print ("%s (%d)\n", __func__, bDirectionUp);
621
656
 
622
657
        //\_______________ On cree la surface d'une fraction hauteur de l'image originale.
623
 
        double fReflectHeight = myIcons.fReflectSize * fMaxScale;
624
 
        if (pSurface == NULL || fReflectHeight == 0 || myIcons.fAlbedo == 0)
 
658
        if (pSurface == NULL || fReflectSize == 0 || fAlbedo == 0)
625
659
                return NULL;
626
660
        cairo_surface_t *pNewSurface = _cairo_dock_create_blank_surface (pSourceContext,
627
661
                fImageWidth,
628
 
                fReflectHeight);
 
662
                fReflectSize);
629
663
        cairo_t *pCairoContext = cairo_create (pNewSurface);
630
664
        
631
665
        cairo_set_operator (pCairoContext, CAIRO_OPERATOR_OVER);
634
668
        //\_______________ On dessine l'image originale inversee.
635
669
        cairo_translate (pCairoContext, 0, fImageHeight);
636
670
        cairo_scale (pCairoContext, 1., -1.);
637
 
        cairo_set_source_surface (pCairoContext, pSurface, 0, (bDirectionUp ? 0 : fImageHeight - fReflectHeight));
 
671
        cairo_set_source_surface (pCairoContext, pSurface, 0, (bDirectionUp ? 0 : fImageHeight - fReflectSize));
638
672
        
639
673
        //\_______________ On applique un degrade en transparence.
640
674
        /**cairo_pattern_t *pGradationPattern = cairo_pattern_create_linear (0.,
644
678
        cairo_pattern_t *pGradationPattern = cairo_pattern_create_linear (0.,
645
679
                fImageHeight,
646
680
                0.,
647
 
                fImageHeight-fReflectHeight);  // de haut en bas.
 
681
                fImageHeight - fReflectSize);  // de haut en bas.
648
682
        g_return_val_if_fail (cairo_pattern_status (pGradationPattern) == CAIRO_STATUS_SUCCESS, NULL);
649
683
 
650
684
        cairo_pattern_set_extend (pGradationPattern, CAIRO_EXTEND_NONE);
653
687
                0.,
654
688
                0.,
655
689
                0.,
656
 
                (bDirectionUp ? myIcons.fAlbedo : 0.));
 
690
                (bDirectionUp ? fAlbedo : 0.));
657
691
        cairo_pattern_add_color_stop_rgba (pGradationPattern,
658
692
                1.,
659
693
                0.,
660
694
                0.,
661
695
                0.,
662
 
                (bDirectionUp ? 0 : myIcons.fAlbedo));
 
696
                (bDirectionUp ? 0 : fAlbedo));
663
697
 
664
698
        cairo_mask (pCairoContext, pGradationPattern);
665
699
 
668
702
        return pNewSurface;
669
703
}
670
704
 
671
 
static cairo_surface_t * cairo_dock_create_reflection_surface_vertical (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fMaxScale, gboolean bDirectionUp)
 
705
static cairo_surface_t * cairo_dock_create_reflection_surface_vertical (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fReflectSize, double fAlbedo, gboolean bDirectionUp)
672
706
{
673
707
        g_return_val_if_fail (pSurface != NULL && pSourceContext != NULL && cairo_status (pSourceContext) == CAIRO_STATUS_SUCCESS, NULL);
674
708
 
675
709
        //\_______________ On cree la surface d'une fraction hauteur de l'image originale.
676
 
        double fReflectWidth = myIcons.fReflectSize * fMaxScale;
677
 
        if (fReflectWidth == 0 || myIcons.fAlbedo == 0)
 
710
        if (fReflectSize == 0 || fAlbedo == 0)
678
711
                return NULL;
679
712
        cairo_surface_t *pNewSurface = _cairo_dock_create_blank_surface (pSourceContext,
680
 
                fReflectWidth,
 
713
                fReflectSize,
681
714
                fImageHeight);
682
715
        cairo_t *pCairoContext = cairo_create (pNewSurface);
683
716
 
687
720
        //\_______________ On dessine l'image originale inversee.
688
721
        cairo_translate (pCairoContext, fImageWidth, 0);
689
722
        cairo_scale (pCairoContext, -1., 1.);
690
 
        cairo_set_source_surface (pCairoContext, pSurface, (bDirectionUp ? 0. : fImageHeight - fReflectWidth), 0.);
 
723
        cairo_set_source_surface (pCairoContext, pSurface, (bDirectionUp ? 0. : fImageHeight - fReflectSize), 0.);
691
724
        
692
725
        //\_______________ On applique un degrade en transparence.
693
726
        cairo_pattern_t *pGradationPattern = cairo_pattern_create_linear (0,
694
727
                0.,
695
 
                fImageHeight-fReflectWidth,
 
728
                fImageHeight - fReflectSize,
696
729
                0.);  // de gauche a droite.
697
730
        g_return_val_if_fail (cairo_pattern_status (pGradationPattern) == CAIRO_STATUS_SUCCESS, NULL);
698
731
 
702
735
                0.,
703
736
                0.,
704
737
                0.,
705
 
                (bDirectionUp ? myIcons.fAlbedo : 0.));
 
738
                (bDirectionUp ? fAlbedo : 0.));
706
739
        cairo_pattern_add_color_stop_rgba (pGradationPattern,
707
740
                1.,
708
741
                0.,
709
742
                0.,
710
743
                0.,
711
 
                (bDirectionUp ? 0. : myIcons.fAlbedo));
 
744
                (bDirectionUp ? 0. : fAlbedo));
712
745
 
713
746
        cairo_mask (pCairoContext, pGradationPattern);
714
747
 
717
750
        return pNewSurface;
718
751
}
719
752
 
720
 
cairo_surface_t * cairo_dock_create_reflection_surface (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, gboolean bIsHorizontal, double fMaxScale, gboolean bDirectionUp)
 
753
cairo_surface_t * cairo_dock_create_reflection_surface (cairo_surface_t *pSurface, cairo_t *pSourceContext, double fImageWidth, double fImageHeight, double fReflectSize, double fAlbedo, gboolean bIsHorizontal, gboolean bDirectionUp)
721
754
{
722
755
        if (bIsHorizontal)
723
 
                return cairo_dock_create_reflection_surface_horizontal (pSurface, pSourceContext, fImageWidth, fImageHeight, fMaxScale, bDirectionUp);
 
756
                return cairo_dock_create_reflection_surface_horizontal (pSurface, pSourceContext, fImageWidth, fImageHeight, fReflectSize, fAlbedo, bDirectionUp);
724
757
        else
725
 
                return cairo_dock_create_reflection_surface_vertical (pSurface, pSourceContext, fImageWidth, fImageHeight, fMaxScale, bDirectionUp);
 
758
                return cairo_dock_create_reflection_surface_vertical (pSurface, pSourceContext, fImageWidth, fImageHeight, fReflectSize, fAlbedo, bDirectionUp);
726
759
}
727
760
 
728
761
 
785
818
                cairo_push_group (pCairoContext);
786
819
                cairo_set_source_rgb (pCairoContext, 0.2, 0.2, 0.2);
787
820
                int i;
788
 
                for (i = 0; i < 4; i++)
789
 
                {
790
 
                        cairo_move_to (pCairoContext, i&2-1, 2*(i&1)-1);
 
821
                for (i = 0; i < 2; i++)
 
822
                {
 
823
                        cairo_move_to (pCairoContext, 0, 2*i-1);
 
824
                        pango_cairo_show_layout (pCairoContext, pLayout);
 
825
                }
 
826
                for (i = 0; i < 2; i++)
 
827
                {
 
828
                        cairo_move_to (pCairoContext, 2*i-1, 0);
791
829
                        pango_cairo_show_layout (pCairoContext, pLayout);
792
830
                }
793
831
                cairo_pop_group_to_source (pCairoContext);