← Back to branch summary

~cairo-dock-team/ubuntu/precise/cairo-dock/3.0.0.0beta1

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Julien Lavergne
  • Date: 2008-09-14 16:26:12 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080914162612-t6aa8pr2o0qry48o
Tags: 1.6.2.3-0ubuntu1
* New upstream release.
* debian/control
 - Update to 3.8.0 (no change needed).
 - Add libxtst-dev as Build-Depends.
* debian/cairo-dock-data.install
 - Add usr/share/cairo-dock/emblems directory.
* debian/watch
 - Update location.
* debian/rules
 - Add a get-orig-source rule.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cairo-dock-dock-manager.c
39
39
#include "cairo-dock-log.h"
40
40
#include "cairo-dock-keyfile-utilities.h"
41
41
#include "cairo-dock-dock-factory.h"
 
42
#include "cairo-dock-draw.h"
 
43
#include "cairo-dock-animations.h"
42
44
#include "cairo-dock-dock-manager.h"
43
45
 
44
46
extern CairoDock *g_pMainDock;
45
47
extern gchar *g_cConfFile;
46
48
extern gchar *g_cCurrentThemePath;
 
49
extern gboolean g_bSameHorizontality;
 
50
extern gboolean g_bPopUp;
 
51
extern gboolean g_bAutoHideOnMaximized, g_bAutoHideOnFullScreen;
47
52
 
48
53
static GHashTable *s_hDocksTable = NULL;  // table des docks existant.
 
54
static int s_iSidPollScreenEdge = 0;
49
55
 
50
56
 
51
57
void cairo_dock_initialize_dock_manager (void)
80
86
 
81
87
void cairo_dock_unregister_dock (const gchar *cDockName)
82
88
{
83
 
        g_return_if_fail (cDockName != NULL);
84
 
        g_hash_table_remove (s_hDocksTable, cDockName);
 
89
        if (cDockName != NULL)
 
90
                g_hash_table_remove (s_hDocksTable, cDockName);
85
91
}
86
92
 
87
93
static gboolean _cairo_dock_free_one_dock (gchar *cDockName, CairoDock *pDock, gpointer data)
142
148
}
143
149
Icon *cairo_dock_search_icon_pointing_on_dock (CairoDock *pDock, CairoDock **pParentDock)  // pParentDock peut etre NULL.
144
150
{
145
 
        if (pDock->bIsMainDock)  // par definition. On n'utilise pas iRefCount, car si on est en train de detruire un dock, sa reference est deja decrementee. note pour moi-meme : pas terrible ca...
 
151
        if (pDock->bIsMainDock)  // par definition. On n'utilise pas iRefCount, car si on est en train de detruire un dock, sa reference est deja decrementee. C'est dommage mais c'est comme ca.
146
152
                return NULL;
147
153
        Icon *pPointingIcon = NULL;
148
154
        gpointer data[3] = {pDock, &pPointingIcon, pParentDock};
158
164
{
159
165
        g_return_val_if_fail (icon != NULL, NULL);
160
166
        if (CAIRO_DOCK_IS_APPLET (icon))
161
 
                return icon->pModule->pContainer;
 
167
                return icon->pModuleInstance->pContainer;
162
168
        
163
169
        if (icon->cParentDockName != NULL)
164
170
                return g_hash_table_lookup (s_hDocksTable, icon->cParentDockName);
193
199
{
194
200
        if (pDock->bInside)
195
201
                return FALSE;
196
 
 
197
 
        Icon *pPointedIcon = cairo_dock_get_pointed_icon (pDock->icons);
198
 
        if (pPointedIcon == NULL || pPointedIcon->pSubDock != pChildDock)
 
202
                
 
203
        Icon *pPointedIcon;
 
204
        ///pPointedIcon = cairo_dock_get_pointed_icon (pDock->icons);
 
205
        ///if (pPointedIcon == NULL || pPointedIcon->pSubDock != pChildDock)
199
206
                pPointedIcon = cairo_dock_get_icon_with_subdock (pDock->icons, pChildDock);
200
207
 
201
208
        if (pPointedIcon != NULL)
213
220
                                pDock->iMouseX = pDock->iCurrentWidth / 2;  // utile ?
214
221
                                pDock->iMouseY = 0;
215
222
                                pDock->calculate_icons (pDock);
216
 
                                pDock->render (pDock);  // peut-etre qu'il faudrait faire un redraw.
 
223
                                ///pDock->render (pDock);  // peut-etre qu'il faudrait faire un redraw...
217
224
                        }
218
225
 
219
226
                        cd_message ("on cache %s par parente", cDockName);
226
233
}
227
234
void cairo_dock_hide_parent_dock (CairoDock *pDock)
228
235
{
229
 
         g_hash_table_find (s_hDocksTable, (GHRFunc)_cairo_dock_hide_dock_if_parent, pDock);
 
236
        g_hash_table_find (s_hDocksTable, (GHRFunc)_cairo_dock_hide_dock_if_parent, pDock);
230
237
}
231
238
 
232
239
gboolean cairo_dock_hide_child_docks (CairoDock *pDock)
260
267
 
261
268
void cairo_dock_reload_buffers_in_all_docks (void)
262
269
{
263
 
        g_hash_table_foreach (s_hDocksTable, (GHFunc) cairo_dock_reload_buffers_in_dock, NULL);
 
270
        g_hash_table_foreach (s_hDocksTable, (GHFunc) cairo_dock_reload_buffers_in_dock, GINT_TO_POINTER (FALSE));
 
271
}
 
272
 
 
273
 
 
274
CairoDock *cairo_dock_alter_dock_name (const gchar *cDockName, CairoDock *pDock, const gchar *cNewName)
 
275
{
 
276
        //g_return_val_if_fail (cDockName != NULL && cNewName != NULL, NULL);
 
277
        if (pDock == NULL)
 
278
        {
 
279
                if (cDockName != NULL)
 
280
                        pDock = g_hash_table_lookup (s_hDocksTable, cDockName);
 
281
                g_return_val_if_fail (pDock != NULL, NULL);
 
282
        }
 
283
        
 
284
        if (cDockName != NULL)
 
285
                g_hash_table_remove (s_hDocksTable, cDockName);  // libere la cle, mais pas la valeur puisque la GDestroyFunc est a NULL.
 
286
        if (cNewName != NULL)
 
287
                g_hash_table_insert (s_hDocksTable, g_strdup (cNewName), pDock);
 
288
        
 
289
        return pDock;
264
290
}
265
291
 
266
292
void cairo_dock_rename_dock (const gchar *cDockName, CairoDock *pDock, const gchar *cNewName)
267
293
{
268
 
        g_return_if_fail (cDockName != NULL && cNewName != NULL);
269
 
        if (pDock == NULL)
270
 
                pDock = g_hash_table_lookup (s_hDocksTable, cDockName);
271
 
        
272
 
        g_hash_table_remove (s_hDocksTable, cDockName);  // libere la cle, mais pas la valeur puisque la GDestroyFunc est a NULL.
273
 
        g_hash_table_insert (s_hDocksTable, g_strdup (cNewName), pDock);
 
294
        pDock = cairo_dock_alter_dock_name (cDockName, pDock, cNewName);
 
295
        g_return_if_fail (pDock != NULL);
274
296
        
275
297
        GList* ic;
276
298
        Icon *icon;
279
301
                icon = ic->data;
280
302
                g_free (icon->cParentDockName);
281
303
                icon->cParentDockName = g_strdup (cNewName);
 
304
                if (CAIRO_DOCK_IS_NORMAL_LAUNCHER (icon))
 
305
                {
 
306
                        cairo_dock_update_conf_file (icon->acDesktopFileName,
 
307
                                G_TYPE_STRING, "Desktop Entry", "Container", cNewName,
 
308
                                G_TYPE_INVALID);
 
309
                }
 
310
                else if (CAIRO_DOCK_IS_APPLET (icon))
 
311
                {
 
312
                        cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
 
313
                                G_TYPE_STRING, "Icon", "dock name", cNewName,
 
314
                                G_TYPE_INVALID);
 
315
                }
282
316
        }
283
317
}
284
318
 
306
340
 
307
341
 
308
342
 
309
 
void cairo_dock_write_main_dock_gaps (CairoDock *pDock)
 
343
void cairo_dock_write_root_dock_gaps (CairoDock *pDock)
310
344
{
311
345
        if (pDock->iRefCount > 0)
312
346
                return;
319
353
        {
320
354
                const gchar *cDockName = cairo_dock_search_dock_name (pDock);
321
355
                gchar *cConfFilePath = g_strdup_printf ("%s/%s.conf", g_cCurrentThemePath, cDockName);
 
356
                if (! g_file_test (cConfFilePath, G_FILE_TEST_EXISTS))
 
357
                {
 
358
                        gchar *cCommand = g_strdup_printf ("cp %s/%s %s", CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_MAIN_DOCK_CONF_FILE, cConfFilePath);
 
359
                        system (cCommand);
 
360
                        g_free (cCommand);
 
361
                }
 
362
                
322
363
                cairo_dock_update_conf_file_with_position (cConfFilePath, pDock->iGapX, pDock->iGapY);
323
364
                g_free (cConfFilePath);
324
365
        }
325
366
}
326
367
 
327
 
void cairo_dock_get_main_dock_position (const gchar *cDockName, CairoDock *pDock)
 
368
gboolean cairo_dock_get_root_dock_position (const gchar *cDockName, CairoDock *pDock)
328
369
{
329
 
        g_return_if_fail (cDockName != NULL && pDock != NULL);
330
 
        if (pDock->iRefCount > 0 || pDock->bIsMainDock)
331
 
                return;
 
370
        g_return_val_if_fail (cDockName != NULL && pDock != NULL, FALSE);
 
371
        if (pDock->iRefCount > 0)
 
372
                return FALSE;
332
373
        
 
374
        //g_print ("%s (%s)\n", __func__, cDockName);
333
375
        gchar *cConfFilePath = (pDock->bIsMainDock ? g_cConfFile : g_strdup_printf ("%s/%s.conf", g_cCurrentThemePath, cDockName));
334
376
        if (! g_file_test (cConfFilePath, G_FILE_TEST_EXISTS))
335
377
        {
 
378
                pDock->bHorizontalDock = g_pMainDock->bHorizontalDock;
 
379
                pDock->bDirectionUp = g_pMainDock->bDirectionUp;
 
380
                pDock->fAlign = g_pMainDock->fAlign;
 
381
                
336
382
                if (! pDock->bIsMainDock)
337
383
                        g_free (cConfFilePath);
338
 
                return ;
 
384
                return FALSE;
339
385
        }
340
386
        
341
387
        GKeyFile *pKeyFile = g_key_file_new ();
345
391
        {
346
392
                cd_warning ("Attention : %s", erreur->message);
347
393
                g_error_free (erreur);
348
 
                return ;
 
394
                return FALSE;
349
395
        }
350
396
        else
351
397
        {
352
398
                gboolean bFlushConfFileNeeded = FALSE;
353
399
                pDock->iGapX = cairo_dock_get_integer_key_value (pKeyFile, "Position", "x gap", &bFlushConfFileNeeded, 0, NULL, NULL);
354
400
                pDock->iGapY = cairo_dock_get_integer_key_value (pKeyFile, "Position", "y gap", &bFlushConfFileNeeded, 0, NULL, NULL);
355
 
        
 
401
                
356
402
                CairoDockPositionType iScreenBorder = cairo_dock_get_integer_key_value (pKeyFile, "Position", "screen border", &bFlushConfFileNeeded, 0, NULL, NULL);
357
403
                if (iScreenBorder < 0 || iScreenBorder >= CAIRO_DOCK_NB_POSITIONS)
358
404
                        iScreenBorder = 0;
359
 
        
360
 
                pDock->fAlign = cairo_dock_get_double_key_value (pKeyFile, "Position", "alignment", &bFlushConfFileNeeded, 0.5, NULL, NULL);
361
405
                
362
406
                switch (iScreenBorder)
363
407
                {
369
413
                                pDock->bHorizontalDock = CAIRO_DOCK_HORIZONTAL;
370
414
                                pDock->bDirectionUp = FALSE;
371
415
                        break;
 
416
                        case CAIRO_DOCK_RIGHT :
 
417
                                pDock->bHorizontalDock = CAIRO_DOCK_VERTICAL;
 
418
                                pDock->bDirectionUp = TRUE;
 
419
                        break;
372
420
                        case CAIRO_DOCK_LEFT :
373
421
                                pDock->bHorizontalDock = CAIRO_DOCK_VERTICAL;
374
422
                                pDock->bDirectionUp = FALSE;
375
423
                        break;
376
 
                        case CAIRO_DOCK_RIGHT :
377
 
                                pDock->bHorizontalDock = CAIRO_DOCK_VERTICAL;
378
 
                                pDock->bDirectionUp = TRUE;
379
 
                        break;
380
424
                }
381
425
                
 
426
                pDock->fAlign = cairo_dock_get_double_key_value (pKeyFile, "Position", "alignment", &bFlushConfFileNeeded, 0.5, NULL, NULL);
 
427
                
 
428
                pDock->bAutoHide = cairo_dock_get_boolean_key_value (pKeyFile, "Position", "auto-hide", &bFlushConfFileNeeded, FALSE, "Auto-Hide", "auto-hide");
 
429
                
382
430
                g_key_file_free (pKeyFile);
383
431
        }
384
432
        
385
433
        if (! pDock->bIsMainDock)
386
434
                g_free (cConfFilePath);
 
435
        return TRUE;
387
436
}
388
437
 
389
 
void cairo_dock_remove_main_dock_config (const gchar *cDockName)
 
438
void cairo_dock_remove_root_dock_config (const gchar *cDockName)
390
439
{
391
440
        gchar *cConfFilePath = g_strdup_printf ("%s/%s.conf", g_cCurrentThemePath, cDockName);
392
441
        if (g_file_test (cConfFilePath, G_FILE_TEST_EXISTS))
395
444
        }
396
445
        g_free (cConfFilePath);
397
446
}
 
447
 
 
448
 
 
449
static gboolean s_bTemporaryAutoHide = FALSE;
 
450
static gboolean s_bQuickHide = FALSE;
 
451
 
 
452
static void _cairo_dock_quick_hide_one_root_dock (const gchar *cDockName, CairoDock *pDock, gpointer data)
 
453
{
 
454
        if (pDock->iRefCount == 0)
 
455
        {
 
456
                pDock->bAtBottom = FALSE;  // car on a deja quitte le dock lors de la fermeture du menu, donc le "leave-notify" serait ignore.
 
457
                pDock->bAutoHideInitialValue = pDock->bAutoHide;
 
458
                pDock->bAutoHide = TRUE;
 
459
                pDock->bEntranceDisabled = TRUE;
 
460
                cairo_dock_emit_leave_signal (pDock);
 
461
        }
 
462
}
 
463
void cairo_dock_activate_temporary_auto_hide (void)
 
464
{
 
465
        if (! s_bTemporaryAutoHide)
 
466
        {
 
467
                s_bTemporaryAutoHide = TRUE;
 
468
                g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_quick_hide_one_root_dock, NULL);
 
469
        }
 
470
}
 
471
void cairo_dock_quick_hide_all_docks (void)
 
472
{
 
473
        if (! s_bTemporaryAutoHide)
 
474
        {
 
475
                s_bTemporaryAutoHide = TRUE;
 
476
                s_bQuickHide = TRUE;
 
477
                g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_quick_hide_one_root_dock, NULL);
 
478
        }
 
479
}
 
480
 
 
481
static void _cairo_dock_stop_quick_hide_one_root_dock (const gchar *cDockName, CairoDock *pDock, gpointer data)
 
482
{
 
483
        if (pDock->iRefCount == 0)
 
484
        {
 
485
                pDock->bAutoHide = pDock->bAutoHideInitialValue;
 
486
                pDock->bAtBottom = TRUE;
 
487
                
 
488
                if (! pDock->bInside && ! pDock->bAutoHide)  // on le fait re-apparaitre.
 
489
                {
 
490
                        pDock->fFoldingFactor = 0;
 
491
                        
 
492
                        int iNewWidth, iNewHeight;
 
493
                        cairo_dock_get_window_position_and_geometry_at_balance (pDock, CAIRO_DOCK_NORMAL_SIZE, &iNewWidth, &iNewHeight);
 
494
                        
 
495
                        if (pDock->bHorizontalDock)
 
496
                                gdk_window_move_resize (pDock->pWidget->window,
 
497
                                        pDock->iWindowPositionX,
 
498
                                        pDock->iWindowPositionY,
 
499
                                        iNewWidth,
 
500
                                        iNewHeight);
 
501
                        else
 
502
                                gdk_window_move_resize (pDock->pWidget->window,
 
503
                                        pDock->iWindowPositionY,
 
504
                                        pDock->iWindowPositionX,
 
505
                                        iNewHeight,
 
506
                                        iNewWidth);
 
507
                }
 
508
        }
 
509
}
 
510
void cairo_dock_deactivate_temporary_auto_hide (void)
 
511
{
 
512
        cd_message ("");
 
513
        if (s_bTemporaryAutoHide)
 
514
        {
 
515
                s_bTemporaryAutoHide = FALSE;
 
516
                g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_stop_quick_hide_one_root_dock, NULL);
 
517
        }
 
518
}
 
519
void cairo_dock_stop_quick_hide (void)
 
520
{
 
521
        cd_message ("");
 
522
        if (s_bTemporaryAutoHide && s_bQuickHide && cairo_dock_search_window_on_our_way (g_bAutoHideOnMaximized, g_bAutoHideOnFullScreen) == NULL)
 
523
        {
 
524
                s_bTemporaryAutoHide = FALSE;
 
525
                g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_stop_quick_hide_one_root_dock, NULL);
 
526
        }
 
527
        s_bQuickHide = FALSE;
 
528
}
 
529
 
 
530
void cairo_dock_allow_entrance (CairoDock *pDock)
 
531
{
 
532
        pDock->bEntranceDisabled = FALSE;
 
533
}
 
534
 
 
535
void cairo_dock_disable_entrance (CairoDock *pDock)
 
536
{
 
537
        pDock->bEntranceDisabled = TRUE;
 
538
}
 
539
 
 
540
gboolean cairo_dock_entrance_is_allowed (CairoDock *pDock)
 
541
{
 
542
        return (! pDock->bEntranceDisabled);
 
543
}
 
544
 
 
545
gboolean cairo_dock_quick_hide_is_activated (void)
 
546
{
 
547
        return s_bTemporaryAutoHide;
 
548
}
 
549
 
 
550
 
 
551
gboolean cairo_dock_window_hovers_dock (GtkAllocation *pWindowGeometry, CairoDock *pDock)
 
552
{
 
553
        if (pWindowGeometry->width != 0 && pWindowGeometry->height != 0)
 
554
        {
 
555
                int iDockX = pDock->iWindowPositionX, iDockY = pDock->iWindowPositionY;
 
556
                int iDockWidth = pDock->iCurrentWidth, iDockHeight = pDock->iCurrentHeight;
 
557
                cd_message ("dock : (%d;%d) %dx%d", iDockX, iDockY, iDockWidth, iDockHeight);
 
558
                if ((pWindowGeometry->x < iDockX + iDockWidth && pWindowGeometry->x + pWindowGeometry->width > iDockX) || (pWindowGeometry->y > iDockY + iDockHeight && pWindowGeometry->y + pWindowGeometry->height > iDockY))
 
559
                {
 
560
                        cd_message (" empiete sur le dock");
 
561
                        return TRUE;
 
562
                }
 
563
        }
 
564
        else
 
565
        {
 
566
                cd_warning (" on ne peut pas dire ou elle est sur l'ecran, on va supposer qu'elle recouvre le dock");
 
567
                return TRUE;
 
568
        }
 
569
        return FALSE;
 
570
}
 
571
 
 
572
 
 
573
void cairo_dock_synchronize_one_sub_dock_position (Icon *icon, CairoDock *pDock, gboolean bReloadBuffersIfNecessary)
 
574
{
 
575
        if (icon->pSubDock != NULL)
 
576
        {
 
577
                cd_message ("%s (%s)", __func__, icon->acName);
 
578
                if (icon->pSubDock->bDirectionUp != pDock->bDirectionUp || (icon->pSubDock->bDirectionUp != ((!g_bSameHorizontality) ^ pDock->bHorizontalDock)))
 
579
                {
 
580
                        icon->pSubDock->bDirectionUp = pDock->bDirectionUp;
 
581
                        icon->pSubDock->bHorizontalDock = (!g_bSameHorizontality) ^ pDock->bHorizontalDock;
 
582
                        if (bReloadBuffersIfNecessary)
 
583
                                cairo_dock_reload_reflects_in_dock (icon->pSubDock);
 
584
                        cairo_dock_synchronize_sub_docks_position (icon->pSubDock, bReloadBuffersIfNecessary);
 
585
                }
 
586
        }
 
587
}
 
588
 
 
589
void cairo_dock_synchronize_sub_docks_position (CairoDock *pDock, gboolean bReloadBuffersIfNecessary)
 
590
{
 
591
        GList* ic;
 
592
        Icon *icon;
 
593
        for (ic = pDock->icons; ic != NULL; ic = ic->next)
 
594
        {
 
595
                icon = ic->data;
 
596
                cairo_dock_synchronize_one_sub_dock_position (icon, pDock, bReloadBuffersIfNecessary);
 
597
        }
 
598
}
 
599
 
 
600
 
 
601
 
 
602
void cairo_dock_start_polling_screen_edge (CairoDock *pMainDock)
 
603
{
 
604
        if (s_iSidPollScreenEdge == 0)
 
605
                s_iSidPollScreenEdge = g_timeout_add (500, (GSourceFunc) cairo_dock_poll_screen_edge, (gpointer) pMainDock);
 
606
}
 
607
void cairo_dock_stop_polling_screen_edge (void)
 
608
{
 
609
        if (s_iSidPollScreenEdge != 0)
 
610
        {
 
611
                g_source_remove (s_iSidPollScreenEdge);
 
612
                s_iSidPollScreenEdge = 0;
 
613
        }
 
614
}
 
615
 
 
616
static void _cairo_dock_pop_up_one_root_dock (gchar *cDockName, CairoDock *pDock, gpointer data)
 
617
{
 
618
        if (pDock->iRefCount > 0)
 
619
                return ;
 
620
        CairoDockPositionType iScreenBorder = GPOINTER_TO_INT (data);
 
621
        
 
622
        CairoDockPositionType iDockScreenBorder = (((! pDock->bHorizontalDock) << 1) | (! pDock->bDirectionUp));
 
623
        if (iDockScreenBorder == iScreenBorder)
 
624
        {
 
625
                cd_message ("%s passe en avant-plan", cDockName);
 
626
                cairo_dock_pop_up (pDock);
 
627
                if (pDock->iSidPopDown == 0)
 
628
                        pDock->iSidPopDown = g_timeout_add (2000, (GSourceFunc) cairo_dock_pop_down, (gpointer) pDock);  // au cas ou on serait pas dedans.
 
629
        }
 
630
}
 
631
void cairo_dock_pop_up_root_docks_on_screen_edge (CairoDockPositionType iScreenBorder)
 
632
{
 
633
        g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_pop_up_one_root_dock, GINT_TO_POINTER (iScreenBorder));
 
634
}
 
635
 
 
636
static void _cairo_dock_set_one_root_dock_on_top_layer (gchar *cDockName, CairoDock *pDock, gpointer data)
 
637
{
 
638
        if (pDock->iRefCount > 0)
 
639
                return ;
 
640
        gtk_window_set_keep_below (GTK_WINDOW (pDock->pWidget), FALSE);
 
641
}
 
642
void cairo_dock_set_root_docks_on_top_layer (void)
 
643
{
 
644
        g_hash_table_foreach (s_hDocksTable, (GHFunc) _cairo_dock_set_one_root_dock_on_top_layer, NULL);
 
645
}
 
646
 
 
647
 
 
648
gchar *cairo_dock_get_unique_dock_name (const gchar *cPrefix)
 
649
{
 
650
        const gchar *cNamepattern = (cPrefix != NULL && *cPrefix != '\0' ? cPrefix : "dock");
 
651
        GString *sNameString = g_string_new (cNamepattern);
 
652
        
 
653
        int i = 1;
 
654
        while (g_hash_table_lookup (s_hDocksTable, sNameString->str) != NULL)
 
655
        {
 
656
                g_string_printf (sNameString, "%s-%d", cNamepattern, i);
 
657
                i ++;
 
658
        }
 
659
        
 
660
        gchar *cUniqueName = sNameString->str;
 
661
        g_string_free (sNameString, FALSE);
 
662
        return cUniqueName;
 
663
}
 
664
 
 
665
 
 
666
void cairo_dock_show_hide_container (CairoContainer *pContainer)
 
667
{
 
668
        if (pContainer == NULL)
 
669
                return;
 
670
        if (! GTK_WIDGET_VISIBLE (pContainer->pWidget))
 
671
                gtk_window_present (GTK_WINDOW (pContainer->pWidget));
 
672
        else
 
673
                gtk_widget_hide (pContainer->pWidget);
 
674
}