← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne, Matthieu Baerts (matttbe), Julien Lavergne
  • Date: 2009-10-04 16:33:52 UTC
  • mfrom: (1.1.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20091004163352-ttbbjfmpb8uzl8j4
Tags: 2.0.9-0ubuntu1
https://launchpad.net/bugs/435587
[ Matthieu Baerts (matttbe) ]
* New Upstream Version. (LP: #435587)
* Added apport hook in debian/apport
 - Add debian/apport
 - debian/cairo-dock-core.install: Added debian/apport/cairo-dock.py
* Use .desktop provided by upstream
 - Removed debian/*.desktop
 - debian/cairo-dock-core.install: install upstream desktop files. 

[ Julien Lavergne ]
* Adjust debian/changelog with Daniel Holbach suggestions.
* debian/patches/01_rename_cairo-dock-package-theme.patch: drop, 
  merged upstream.
* debian/patches/01-desktop-file-category.patch:
 - Remove Encoding field and set category to Utility.
* debian/patches/02-merge-changelog.patch:
 - Merge ChangeLog and ChangeLog-2.0.9.
* debian/apport: Remove commands with grep, python doesn't like it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-dock-factory.c
1
1
/**
2
 
* Dock factory for Cairo-Dock
 
2
* This file is a part of the Cairo-Dock project
3
3
*
4
 
* Copyright : (C) 2009 by Fabrice Rey
5
 
* E-mail    : fabounet@users.berlios.de
 
4
* Copyright : (C) see the 'copyright' file.
 
5
* E-mail    : see the 'copyright' file.
6
6
*
7
7
* This program is free software; you can redistribute it and/or
8
8
* modify it under the terms of the GNU General Public License
13
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
15
* GNU General Public License for more details.
16
 
*   http://www.gnu.org/licenses/licenses.html#GPL
 
16
* You should have received a copy of the GNU General Public License
 
17
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18
*/
18
19
 
19
20
#include <math.h>
69
70
#include "cairo-dock-container.h"
70
71
#include "cairo-dock-desktop-file-factory.h"
71
72
#include "cairo-dock-themes-manager.h"
 
73
#include "cairo-dock-gui-manager.h"
72
74
#include "cairo-dock-dock-facility.h"
73
75
#include "cairo-dock-dock-factory.h"
74
76
 
139
141
        
140
142
        //\__________________ On enregistre un nouveau dock.
141
143
        CairoDock *pDock = g_new0 (CairoDock, 1);
142
 
        pDock->iType = CAIRO_DOCK_TYPE_DOCK;
 
144
        pDock->container.iType = CAIRO_DOCK_TYPE_DOCK;
143
145
        CairoDock *pInsertedDock = cairo_dock_register_dock (cDockName, pDock);  // determine au passage si c'est le MainDock.
144
146
        if (pInsertedDock != pDock)  // un autre dock de ce nom existe deja.
145
147
        {
149
151
        
150
152
        pDock->bAtBottom = TRUE;
151
153
        pDock->iRefCount = 0;  // c'est un dock racine par defaut.
152
 
        pDock->fRatio = 1.;
 
154
        pDock->container.fRatio = 1.;
153
155
        pDock->iAvoidingMouseIconType = -1;
154
156
        pDock->fFlatDockWidth = - myIcons.iIconGap;
155
 
        pDock->iMouseX = -1; // utile ?
156
 
        pDock->iMouseY = -1;
 
157
        pDock->container.iMouseX = -1; // utile ?
 
158
        pDock->container.iMouseY = -1;
157
159
        pDock->fMagnitudeMax = 1.;
158
160
 
159
161
        //\__________________ On cree la fenetre GTK.
160
162
        GtkWidget *pWindow = cairo_dock_create_container_window ();
161
163
        gtk_container_set_border_width(GTK_CONTAINER(pWindow), 0);
162
 
        pDock->pWidget = pWindow;
 
164
        pDock->container.pWidget = pWindow;
163
165
 
164
166
        if (g_bKeepAbove)
165
167
                gtk_window_set_keep_above (GTK_WINDOW (pWindow), g_bKeepAbove);
170
172
        gtk_window_set_gravity (GTK_WINDOW (pWindow), GDK_GRAVITY_STATIC);
171
173
        gtk_window_set_type_hint (GTK_WINDOW (pWindow), g_iWmHint);
172
174
 
173
 
        gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock");  // GTK renseigne la classe avec la meme valeur.
 
175
        gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock");
174
176
        
175
177
        cairo_dock_set_renderer (pDock, cRendererName);
176
178
 
228
230
                G_CALLBACK (cairo_dock_on_drag_data_received),
229
231
                pDock);
230
232
        g_signal_connect (G_OBJECT (pWindow),
231
 
                "drag_motion",
 
233
                "drag-motion",
232
234
                G_CALLBACK (cairo_dock_on_drag_motion),
233
235
                pDock);
234
236
        g_signal_connect (G_OBJECT (pWindow),
235
 
                "drag_leave",
 
237
                "drag-leave",
236
238
                G_CALLBACK (cairo_dock_on_drag_leave),
237
239
                pDock);
 
240
        /*g_signal_connect (G_OBJECT (pWindow),
 
241
                "drag-drop",
 
242
                G_CALLBACK (cairo_dock_on_drag_drop),
 
243
                pDock);*/
238
244
 
239
 
        gtk_window_get_size (GTK_WINDOW (pWindow), &pDock->iCurrentWidth, &pDock->iCurrentHeight);  // ca n'est que la taille initiale allouee par GTK.
 
245
        gtk_window_get_size (GTK_WINDOW (pWindow), &pDock->container.iWidth, &pDock->container.iHeight);  // ca n'est que la taille initiale allouee par GTK.
240
246
        gtk_widget_show_all (pWindow);
241
247
        gdk_window_set_back_pixmap (pWindow->window, NULL, FALSE);  // vraiment plus rapide ?
242
248
        
243
249
 
244
250
#ifdef HAVE_GLITZ
245
 
        if (g_bUseGlitz && pDock->pDrawFormat != NULL)
 
251
        if (g_bUseGlitz && pDock->container.pDrawFormat != NULL)
246
252
        {
247
253
                glitz_format_t templ;
248
254
                GdkDisplay         *gdkdisplay;
252
258
                gdkdisplay = gdk_display_get_default ();
253
259
                XDisplay   = gdk_x11_display_get_xdisplay (gdkdisplay);
254
260
                xid = gdk_x11_drawable_get_xid (GDK_DRAWABLE (pWindow->window));
255
 
                pDock->pGlitzDrawable = glitz_glx_create_drawable_for_window (XDisplay,
 
261
                pDock->container.pGlitzDrawable = glitz_glx_create_drawable_for_window (XDisplay,
256
262
                        0,
257
 
                        pDock->pDrawFormat,
 
263
                        pDock->container.pDrawFormat,
258
264
                        xid,
259
 
                        pDock->iCurrentWidth,
260
 
                        pDock->iCurrentHeight);
261
 
                if (! pDock->pGlitzDrawable)
 
265
                        pDock->container.iWidth,
 
266
                        pDock->container.iHeight);
 
267
                if (! pDock->container.pGlitzDrawable)
262
268
                {
263
269
                        cd_warning ("failed to create glitz drawable");
264
270
                }
265
271
                else
266
272
                {
267
 
                        templ.color        = pDock->pDrawFormat->color;
 
273
                        templ.color        = pDock->container.pDrawFormat->color;
268
274
                        templ.color.fourcc = GLITZ_FOURCC_RGB;
269
 
                        pDock->pGlitzFormat = glitz_find_format (pDock->pGlitzDrawable,
 
275
                        pDock->container.pGlitzFormat = glitz_find_format (pDock->container.pGlitzDrawable,
270
276
                                GLITZ_FORMAT_RED_SIZE_MASK   |
271
277
                                GLITZ_FORMAT_GREEN_SIZE_MASK |
272
278
                                GLITZ_FORMAT_BLUE_SIZE_MASK  |
274
280
                                GLITZ_FORMAT_FOURCC_MASK,
275
281
                                &templ,
276
282
                                0);
277
 
                        if (! pDock->pGlitzFormat)
 
283
                        if (! pDock->container.pGlitzFormat)
278
284
                        {
279
285
                                cd_warning ("couldn't find glitz surface format");
280
286
                        }
312
318
                g_source_remove (pDock->iSidPopUp);
313
319
        if (pDock->iSidLeaveDemand != 0)
314
320
                g_source_remove (pDock->iSidLeaveDemand);
315
 
        if (pDock->iSidIconGlide != 0)
316
 
                g_source_remove (pDock->iSidIconGlide);
317
321
        if (pDock->bIsMainDock && cairo_dock_application_manager_is_running ())
318
322
        {
319
323
                cairo_dock_pause_application_manager ();  // precaution au cas ou.
320
324
        }
321
325
        cairo_dock_notify (CAIRO_DOCK_STOP_DOCK, pDock);
322
 
        if (pDock->iSidGLAnimation != 0)
323
 
                g_source_remove (pDock->iSidGLAnimation);
 
326
        if (pDock->container.iSidGLAnimation != 0)
 
327
                g_source_remove (pDock->container.iSidGLAnimation);
324
328
 
325
329
        g_list_foreach (pDock->icons, (GFunc) _cairo_dock_fm_remove_monitor_on_one_icon, NULL);
326
330
 
332
336
                g_object_unref ((gpointer) pDock->pShapeBitmap);
333
337
        pDock->pShapeBitmap = NULL;
334
338
        
335
 
        gtk_widget_destroy (pDock->pWidget);
336
 
        pDock->pWidget = NULL;
 
339
        gtk_widget_destroy (pDock->container.pWidget);
 
340
        pDock->container.pWidget = NULL;
337
341
 
338
342
        g_free (pDock->cRendererName);
339
343
        pDock->cRendererName = NULL;
340
344
}
341
345
 
342
 
void cairo_dock_destroy_dock (CairoDock *pDock, const gchar *cDockName, CairoDock *pReceivingDock, const gchar *cpReceivingDockName)
 
346
void cairo_dock_destroy_dock (CairoDock *pDock, const gchar *cDockName, CairoDock *pReceivingDock, const gchar *cReceivingDockName)
343
347
{
344
 
        cd_debug ("%s (%s, %d)", __func__, cDockName, pDock->iRefCount);
345
 
        g_return_if_fail (pDock != NULL);  // && cDockName != NULL
 
348
        g_return_if_fail (pDock != NULL);
 
349
        g_print ("%s (%s, %d)\n", __func__, cDockName, pDock->iRefCount);
346
350
        if (pDock->bIsMainDock)  // utiliser cairo_dock_free_all_docks ().
347
351
                return;
348
352
        pDock->iRefCount --;
349
353
        if (pDock->iRefCount > 0)
350
354
                return ;
351
 
 
 
355
        if (cairo_dock_search_dock_from_name (cDockName) != pDock)
 
356
        {
 
357
                cDockName = cairo_dock_search_dock_name (pDock);
 
358
                cd_warning ("dock's name mismatch !\nThe real name is %s", cDockName);
 
359
        }
 
360
        
352
361
        cairo_dock_deactivate_one_dock (pDock);
353
362
 
354
363
        gboolean bModuleWasRemoved = FALSE;
363
372
 
364
373
                if (icon->pSubDock != NULL && pReceivingDock == NULL)
365
374
                {
366
 
                        cairo_dock_destroy_dock (icon->pSubDock, icon->acName, NULL, NULL);
 
375
                        cairo_dock_destroy_dock (icon->pSubDock, icon->cClass != NULL ? icon->cClass : icon->cName, NULL, NULL);
367
376
                        icon->pSubDock = NULL;
368
377
                }
369
378
 
370
 
                if (pReceivingDock == NULL || cpReceivingDockName == NULL)  // alors on les jete.
 
379
                if (pReceivingDock == NULL || cReceivingDockName == NULL)  // alors on les jete.
371
380
                {
372
 
                        if (CAIRO_DOCK_IS_NORMAL_LAUNCHER (icon))  // icon->acDesktopFileName != NULL
 
381
                        if (CAIRO_DOCK_IS_STORED_LAUNCHER (icon))
373
382
                        {
374
 
                                cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon->acDesktopFileName);
 
383
                                cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon->cDesktopFileName);
375
384
                                g_remove (cDesktopFilePath);
376
385
                                g_free (cDesktopFilePath);
377
386
                        }
380
389
                                cairo_dock_update_icon_s_container_name (icon, CAIRO_DOCK_MAIN_DOCK_NAME);
381
390
                                bModuleWasRemoved = TRUE;
382
391
                        }
383
 
                        cairo_dock_free_icon (icon);
 
392
                        cairo_dock_free_icon (icon);  // de-instancie l'applet.
384
393
                }
385
394
                else  // on les re-attribue au dock receveur.
386
395
                {
387
 
                        cairo_dock_update_icon_s_container_name (icon, cpReceivingDockName);
 
396
                        cairo_dock_update_icon_s_container_name (icon, cReceivingDockName);
388
397
 
389
 
                        icon->fWidth /= pDock->fRatio;
390
 
                        icon->fHeight /= pDock->fRatio;
 
398
                        icon->fWidth /= pDock->container.fRatio;
 
399
                        icon->fHeight /= pDock->container.fRatio;
391
400
                        
392
 
                        cd_debug (" on re-attribue %s au dock %s", icon->acName, icon->cParentDockName);
 
401
                        cd_debug (" on re-attribue %s au dock %s", icon->cName, icon->cParentDockName);
393
402
                        cairo_dock_insert_icon_in_dock (icon, pReceivingDock, ! CAIRO_DOCK_UPDATE_DOCK_SIZE, CAIRO_DOCK_ANIMATE_ICON);
394
403
                        
395
404
                        if (CAIRO_DOCK_IS_APPLET (icon))
415
424
                cairo_dock_remove_root_dock_config (cDockName);
416
425
        
417
426
        g_free (pDock);
 
427
        cairo_dock_refresh_launcher_gui ();
418
428
}
419
429
 
420
430
 
425
435
        {
426
436
                if (pParentDock == NULL)
427
437
                        pParentDock = g_pMainDock;
428
 
                CairoDockPositionType iScreenBorder = ((! pDock->bHorizontalDock) << 1) | (! pDock->bDirectionUp);
429
 
                cd_message ("position : %d/%d", pDock->bHorizontalDock, pDock->bDirectionUp);
430
 
                pDock->bHorizontalDock = (myViews.bSameHorizontality ? pParentDock->bHorizontalDock : ! pParentDock->bHorizontalDock);
431
 
                pDock->bDirectionUp = pParentDock->bDirectionUp;
432
 
                if (iScreenBorder != (((! pDock->bHorizontalDock) << 1) | (! pDock->bDirectionUp)))
 
438
                CairoDockPositionType iScreenBorder = ((! pDock->container.bIsHorizontal) << 1) | (! pDock->container.bDirectionUp);
 
439
                cd_message ("position : %d/%d", pDock->container.bIsHorizontal, pDock->container.bDirectionUp);
 
440
                pDock->container.bIsHorizontal = (myViews.bSameHorizontality ? pParentDock->container.bIsHorizontal : ! pParentDock->container.bIsHorizontal);
 
441
                pDock->container.bDirectionUp = pParentDock->container.bDirectionUp;
 
442
                if (iScreenBorder != (((! pDock->container.bIsHorizontal) << 1) | (! pDock->container.bDirectionUp)))
433
443
                {
434
 
                        cd_message ("changement de position -> %d/%d", pDock->bHorizontalDock, pDock->bDirectionUp);
 
444
                        cd_message ("changement de position -> %d/%d", pDock->container.bIsHorizontal, pDock->container.bDirectionUp);
435
445
                        cairo_dock_reload_reflects_in_dock (pDock);
436
446
                }
437
447
                if (g_bKeepAbove)
438
 
                        gtk_window_set_keep_above (GTK_WINDOW (pDock->pWidget), FALSE);
 
448
                        gtk_window_set_keep_above (GTK_WINDOW (pDock->container.pWidget), FALSE);
439
449
                if (myAccessibility.bPopUp)
440
 
                        gtk_window_set_keep_below (GTK_WINDOW (pDock->pWidget), FALSE);
 
450
                        gtk_window_set_keep_below (GTK_WINDOW (pDock->container.pWidget), FALSE);
 
451
                gtk_window_set_title (GTK_WINDOW (pDock->container.pWidget), "cairo-dock-sub");
441
452
                
442
453
                pDock->bAutoHide = FALSE;
443
 
                double fPrevRatio = pDock->fRatio;
444
 
                pDock->fRatio = MIN (pDock->fRatio, myViews.fSubDockSizeRatio);
 
454
                double fPrevRatio = pDock->container.fRatio;
 
455
                pDock->container.fRatio = MIN (pDock->container.fRatio, myViews.fSubDockSizeRatio);
445
456
 
446
457
                Icon *icon;
447
458
                GList *ic;
449
460
                for (ic = pDock->icons; ic != NULL; ic = ic->next)
450
461
                {
451
462
                        icon = ic->data;
452
 
                        icon->fWidth *= pDock->fRatio / fPrevRatio;
453
 
                        icon->fHeight *= pDock->fRatio / fPrevRatio;
 
463
                        icon->fWidth *= pDock->container.fRatio / fPrevRatio;
 
464
                        icon->fHeight *= pDock->container.fRatio / fPrevRatio;
454
465
                        pDock->fFlatDockWidth += icon->fWidth + myIcons.iIconGap;
455
466
                }
456
 
                pDock->iMaxIconHeight *= pDock->fRatio / fPrevRatio;
 
467
                pDock->iMaxIconHeight *= pDock->container.fRatio / fPrevRatio;
457
468
 
458
469
                cairo_dock_set_default_renderer (pDock);
459
470
 
460
 
                gtk_widget_hide (pDock->pWidget);
 
471
                gtk_widget_hide (pDock->container.pWidget);
461
472
                cairo_dock_update_dock_size (pDock);
462
473
                
463
474
                const gchar *cDockName = cairo_dock_search_dock_name (pDock);
577
588
                icon,
578
589
                pCompareFunc);
579
590
 
580
 
        icon->fWidth *= pDock->fRatio;
581
 
        icon->fHeight *= pDock->fRatio;
 
591
        icon->fWidth *= pDock->container.fRatio;
 
592
        icon->fHeight *= pDock->container.fRatio;
582
593
 
583
594
        pDock->fFlatDockWidth += myIcons.iIconGap + icon->fWidth;
584
595
        pDock->iMaxIconHeight = MAX (pDock->iMaxIconHeight, icon->fHeight);
593
604
                        if (pNextIcon != NULL && ((cairo_dock_get_icon_order (pNextIcon) - cairo_dock_get_icon_order (icon)) % 2 == 0) && (cairo_dock_get_icon_order (pNextIcon) != cairo_dock_get_icon_order (icon)))
594
605
                        {
595
606
                                int iSeparatorType = iOrder + 1;
596
 
                                //g_print (" insertion de %s avant %s -> iSeparatorType : %d\n", icon->acName, pNextIcon->acName, iSeparatorType);
 
607
                                //g_print (" insertion de %s avant %s -> iSeparatorType : %d\n", icon->cName, pNextIcon->cName, iSeparatorType);
597
608
 
598
609
                                cairo_t *pSourceContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pDock));
599
610
                                Icon *pSeparatorIcon = cairo_dock_create_separator_icon (pSourceContext, iSeparatorType, pDock);
615
626
                        if (pPrevIcon != NULL && ((cairo_dock_get_icon_order (pPrevIcon) - cairo_dock_get_icon_order (icon)) % 2 == 0) && (cairo_dock_get_icon_order (pPrevIcon) != cairo_dock_get_icon_order (icon)))
616
627
                        {
617
628
                                int iSeparatorType = iOrder - 1;
618
 
                                //g_print (" insertion de %s (%d) apres %s -> iSeparatorType : %d\n", icon->acName, icon->pModuleInstance != NULL, pPrevIcon->acName, iSeparatorType);
 
629
                                //g_print (" insertion de %s (%d) apres %s -> iSeparatorType : %d\n", icon->cName, icon->pModuleInstance != NULL, pPrevIcon->cName, iSeparatorType);
619
630
 
620
631
                                cairo_t *pSourceContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pDock));
621
632
                                Icon *pSeparatorIcon = cairo_dock_create_separator_icon (pSourceContext, iSeparatorType, pDock);
636
647
        //\______________ On effectue les actions demandees.
637
648
        if (bAnimated)
638
649
        {
639
 
                icon->fPersonnalScale = - 0.95;
 
650
                if (cairo_dock_animation_will_be_visible (pDock))
 
651
                        icon->fPersonnalScale = - 0.95;
 
652
                else
 
653
                        icon->fPersonnalScale = - 0.05;
640
654
                cairo_dock_notify (CAIRO_DOCK_INSERT_ICON, icon, pDock);
641
655
        }
642
656
        if (bUpdateSize)
644
658
 
645
659
        if (pDock->iRefCount == 0 && myAccessibility.bReserveSpace && bUpdateSize && ! pDock->bAutoHide && (pDock->fFlatDockWidth != iPreviousMinWidth || pDock->iMaxIconHeight != iPreviousMaxIconHeight))
646
660
                cairo_dock_reserve_space_for_dock (pDock, TRUE);
 
661
        
 
662
        if (CAIRO_DOCK_IS_STORED_LAUNCHER (icon) || CAIRO_DOCK_IS_USER_SEPARATOR (icon) || CAIRO_DOCK_IS_APPLET (icon))
 
663
                cairo_dock_refresh_launcher_gui ();
647
664
}
648
665
 
649
666
 
652
669
        if (pDock == NULL || g_list_find (pDock->icons, icon) == NULL)  // elle est deja detachee.
653
670
                return FALSE;
654
671
 
655
 
        cd_message ("%s (%s)", __func__, icon->acName);
 
672
        cd_message ("%s (%s)", __func__, icon->cName);
656
673
        g_free (icon->cParentDockName);
657
674
        icon->cParentDockName = NULL;
658
675
        
661
678
        //\___________________ On desactive sa miniature.
662
679
        if (icon->Xid != 0)
663
680
        {
664
 
                cd_debug ("on desactive la miniature de %s (Xid : %lx)", icon->acName, icon->Xid);
 
681
                cd_debug ("on desactive la miniature de %s (Xid : %lx)", icon->cName, icon->Xid);
665
682
                cairo_dock_set_xicon_geometry (icon->Xid, 0, 0, 0, 0);
666
683
        }
667
684
        //\___________________ On l'enleve de la liste.
694
711
        }
695
712
 
696
713
        //\___________________ On la remet a la taille normale en vue d'une reinsertion quelque part.
697
 
        icon->fWidth /= pDock->fRatio;
698
 
        icon->fHeight /= pDock->fRatio;
 
714
        icon->fWidth /= pDock->container.fRatio;
 
715
        icon->fHeight /= pDock->container.fRatio;
699
716
 
700
717
        //\___________________ On enleve le separateur si c'est la derniere icone de son type.
701
718
        if (bCheckUnusedSeparator && ! CAIRO_DOCK_IS_AUTOMATIC_SEPARATOR (icon))
705
722
                {
706
723
                        Icon * pSeparatorIcon = NULL;
707
724
                        int iOrder = cairo_dock_get_icon_order (icon);
708
 
                        //g_print ("iOrder : %d\n", iOrder);
709
 
                        if (iOrder > 1)  // attention : iType - 1 > 0 si iType = 0, car c'est un unsigned int (enum) !
 
725
                        g_print ("plus d'icone de cet ordre : %d\n", iOrder);
 
726
                        if (iOrder > 1)
710
727
                                pSeparatorIcon = cairo_dock_get_first_icon_of_order (pDock->icons, iOrder - 1);
711
728
                        if (iOrder + 1 < CAIRO_DOCK_NB_TYPES && pSeparatorIcon == NULL)
712
729
                                pSeparatorIcon = cairo_dock_get_first_icon_of_order (pDock->icons, iOrder + 1);
713
730
 
714
731
                        if (pSeparatorIcon != NULL)
715
732
                        {
716
 
                                //g_print ("  on enleve un separateur\n");
 
733
                                g_print (" -> on enleve un separateur\n");
717
734
                                cairo_dock_detach_icon_from_dock (pSeparatorIcon, pDock, FALSE);
718
735
                                cairo_dock_free_icon (pSeparatorIcon);
719
736
                        }
720
737
                }
721
738
        }
 
739
        
 
740
        if (CAIRO_DOCK_IS_STORED_LAUNCHER (icon) || CAIRO_DOCK_IS_USER_SEPARATOR (icon) || CAIRO_DOCK_IS_APPLET (icon))
 
741
                cairo_dock_refresh_launcher_gui ();
722
742
        return TRUE;
723
743
}
724
744
void cairo_dock_remove_icon_from_dock_full (CairoDock *pDock, Icon *icon, gboolean bCheckUnusedSeparator)
725
745
{
726
 
        g_return_if_fail (icon != NULL && pDock != NULL);
 
746
        g_return_if_fail (icon != NULL);
727
747
        //\___________________ On effectue les taches de fermeture de l'icone suivant son type.
728
 
        if (icon->acDesktopFileName != NULL)
 
748
        if (icon->cDesktopFileName != NULL)
729
749
        {
730
 
                gchar *icon_path = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon->acDesktopFileName);
731
 
                g_remove (icon_path);
732
 
                g_free (icon_path);
 
750
                gchar *cDesktopFilePath = g_strdup_printf ("%s/%s", g_cCurrentLaunchersPath, icon->cDesktopFileName);
 
751
                g_remove (cDesktopFilePath);
 
752
                g_free (cDesktopFilePath);
 
753
                cairo_dock_mark_theme_as_modified (TRUE);
733
754
 
734
755
                if (CAIRO_DOCK_IS_URI_LAUNCHER (icon))
735
756
                {
736
757
                        cairo_dock_fm_remove_monitor (icon);
737
758
                }
 
759
                
 
760
                if (icon->pSubDock != NULL && icon->cClass == NULL)
 
761
                {
 
762
                        cairo_dock_destroy_dock (icon->pSubDock, icon->cName, NULL, NULL);
 
763
                        icon->pSubDock = NULL;
 
764
                }
738
765
        }
739
 
        if (CAIRO_DOCK_IS_APPLET (icon))
 
766
        else if (CAIRO_DOCK_IS_APPLET (icon))
740
767
        {
741
768
                cairo_dock_deinstanciate_module (icon->pModuleInstance);  // desactive l'instance du module.
742
 
                icon->pModuleInstance = NULL;  // l'instance n'est plus valide apres ca.
 
769
                cairo_dock_update_conf_file_with_active_modules ();
 
770
                cairo_dock_mark_theme_as_modified (TRUE);
743
771
        }  // rien a faire pour les separateurs automatiques.
744
772
 
745
773
        //\___________________ On detache l'icone du dock.
746
 
        cairo_dock_detach_icon_from_dock (icon, pDock, bCheckUnusedSeparator);
 
774
        if (pDock != NULL)
 
775
                cairo_dock_detach_icon_from_dock (icon, pDock, bCheckUnusedSeparator);
747
776
        
748
777
        if (CAIRO_DOCK_IS_NORMAL_APPLI (icon))
749
778
        {
750
779
                cairo_dock_unregister_appli (icon);
751
780
        }
752
 
        
753
 
        if (pDock->iRefCount == 0 && myAccessibility.bReserveSpace)  // bIsMainDock
754
 
                cairo_dock_reserve_space_for_dock (pDock, TRUE);  // l'espace est reserve sur la taille min, qui a deja ete mise a jour.
755
781
}
756
782
 
757
783
 
766
792
                next_ic = ic->next;  // si l'icone se fait enlever, on perdrait le fil.
767
793
                if (CAIRO_DOCK_IS_AUTOMATIC_SEPARATOR (icon))
768
794
                {
769
 
                        //g_print ("un separateur en moins (apres %s)\n", ((Icon*)ic->data)->acName);
 
795
                        //g_print ("un separateur en moins (apres %s)\n", ((Icon*)ic->data)->cName);
770
796
                        cairo_dock_remove_one_icon_from_dock (pDock, icon);
771
797
                        cairo_dock_free_icon (icon);
772
798
                }
790
816
                                if (! CAIRO_DOCK_IS_AUTOMATIC_SEPARATOR (next_icon) && abs (cairo_dock_get_icon_order (icon) - cairo_dock_get_icon_order (next_icon)) > 1)  // icon->iType != next_icon->iType
791
817
                                {
792
818
                                        int iSeparatorType = myIcons.tIconTypeOrder[next_icon->iType] - 1;
793
 
                                        //g_print ("un separateur entre %s et %s, dans le groupe %d (=%d)\n", icon->acName, next_icon->acName, iSeparatorType, myIcons.tIconTypeOrder[iSeparatorType]);
 
819
                                        //g_print ("un separateur entre %s et %s, dans le groupe %d (=%d)\n", icon->cName, next_icon->cName, iSeparatorType, myIcons.tIconTypeOrder[iSeparatorType]);
794
820
                                        cairo_t *pCairoContext = cairo_dock_create_context_from_window (CAIRO_CONTAINER (pDock));
795
821
                                        Icon *pSeparator = cairo_dock_create_separator_icon (pCairoContext, iSeparatorType, pDock);
796
822
                                        cairo_destroy (pCairoContext);
797
823
                                        if (pSeparator != NULL)
798
824
                                        {
799
 
                                                pSeparator->fWidth /= pDock->fRatio;
800
 
                                                pSeparator->fHeight /= pDock->fRatio;
 
825
                                                pSeparator->fWidth /= pDock->container.fRatio;
 
826
                                                pSeparator->fHeight /= pDock->container.fRatio;
801
827
                                                cairo_dock_insert_icon_in_dock_full (pSeparator, pDock, !CAIRO_DOCK_UPDATE_DOCK_SIZE, ! CAIRO_DOCK_ANIMATE_ICON, ! CAIRO_DOCK_INSERT_SEPARATOR, NULL);
802
828
                                                pSeparator->cParentDockName = g_strdup (next_icon->cParentDockName);
803
829
                                        }