← 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-dialogs.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-dialogs.c
1
1
/**
2
 
* Dialogs 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 <stdlib.h>
22
23
#include <gdk/gdkkeysyms.h>
23
24
 
24
25
#include <gtk/gtkgl.h>
25
 
#include <GL/gl.h> 
26
 
#include <GL/glu.h> 
27
 
#include <GL/glx.h> 
 
26
#include <GL/gl.h>
 
27
#include <GL/glu.h>
 
28
#include <GL/glx.h>
28
29
#include <gdk/x11/gdkglx.h>
29
30
 
30
31
#include "cairo-dock-icons.h"
38
39
#include "cairo-dock-renderer-manager.h"
39
40
#include "cairo-dock-surface-factory.h"
40
41
#include "cairo-dock-internal-accessibility.h"
41
 
#include "cairo-dock-internal-hidden-dock.h"
42
42
#include "cairo-dock-internal-dialogs.h"
43
43
#include "cairo-dock-internal-icons.h"
44
44
#include "cairo-dock-internal-system.h"
47
47
#include "cairo-dock-notifications.h"
48
48
#include "cairo-dock-callbacks.h"
49
49
#include "cairo-dock-launcher-factory.h"
 
50
#include "cairo-dock-gui-manager.h"
50
51
#include "cairo-dock-dialogs.h"
51
52
 
52
53
extern CairoDock *g_pMainDock;
53
54
extern gint g_iXScreenWidth[2], g_iXScreenHeight[2];
54
55
extern gint g_iScreenWidth[2], g_iScreenHeight[2];
55
 
extern int g_iScreenOffsetX, g_iScreenOffsetY;
56
56
extern gboolean g_bSticky;
57
57
extern gboolean g_bKeepAbove;
58
58
extern gboolean g_bUseOpenGL;
76
76
        CairoDialog *pDialog)
77
77
{
78
78
        cd_debug ("inside");
79
 
        pDialog->bInside = TRUE;
 
79
        pDialog->container.bInside = TRUE;
80
80
        return FALSE;
81
81
}
82
82
 
87
87
        cd_debug ("debut d'attente...");
88
88
        while (gtk_events_pending ())
89
89
                gtk_main_iteration ();
90
 
        cd_debug ("fin d'attente, bInside : %d\n", pDialog->bInside);
 
90
        cd_debug ("fin d'attente, bInside : %d\n", pDialog->container.bInside);
91
91
        int iMouseX, iMouseY;
92
 
        gdk_window_get_pointer (pDialog->pWidget->window, &iMouseX, &iMouseY, NULL);
93
 
        if (iMouseX > 0 && iMouseX < pDialog->iWidth && iMouseY > 0 && iMouseY < pDialog->iHeight)
 
92
        gdk_window_get_pointer (pDialog->container.pWidget->window, &iMouseX, &iMouseY, NULL);
 
93
        if (iMouseX > 0 && iMouseX < pDialog->container.iWidth && iMouseY > 0 && iMouseY < pDialog->container.iHeight)
94
94
        {
95
95
                cd_debug ("en fait on est dedans");
96
96
                return FALSE;
97
97
        }
98
98
 
99
 
        //cd_debug ("outside (%d;%d / %dx%d)", iMouseX, iMouseY, pDialog->iWidth, pDialog->iHeight);
100
 
        pDialog->bInside = FALSE;
 
99
        //cd_debug ("outside (%d;%d / %dx%d)", iMouseX, iMouseY, pDialog->container.iWidth, pDialog->container.iHeight);
 
100
        pDialog->container.bInside = FALSE;
101
101
        Icon *pIcon = pDialog->pIcon;
102
102
        if (pIcon != NULL /*&& (pEvent->state & GDK_BUTTON1_MASK) == 0*/)
103
103
        {
104
 
                pDialog->iPositionX = pEvent->x_root;
105
 
                pDialog->iPositionY = pEvent->y_root;
 
104
                pDialog->container.iWindowPositionX = pEvent->x_root;
 
105
                pDialog->container.iWindowPositionY = pEvent->y_root;
106
106
                CairoContainer *pContainer = cairo_dock_search_container_from_icon (pIcon);
107
107
                cairo_dock_place_dialog (pDialog, pContainer);
108
 
                ///gtk_widget_queue_draw (pDialog->pWidget);
 
108
                ///gtk_widget_queue_draw (pDialog->container.pWidget);
109
109
        }
110
110
 
111
111
        return FALSE;
115
115
{
116
116
        int iButtonX, iButtonY;
117
117
        int i, n = pDialog->iNbButtons;
118
 
        iButtonY = (pDialog->bDirectionUp ?
 
118
        iButtonY = (pDialog->container.bDirectionUp ?
119
119
                pDialog->iTopMargin + pDialog->iMessageHeight + pDialog->iInteractiveHeight + CAIRO_DIALOG_VGAP :
120
 
                pDialog->iHeight - (pDialog->iTopMargin + pDialog->iButtonsHeight));
121
 
        int iMinButtonX = .5 * (pDialog->iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
 
120
                pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iButtonsHeight));
 
121
        int iMinButtonX = .5 * (pDialog->container.iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
122
122
        for (i = 0; i < pDialog->iNbButtons; i++)
123
123
        {
124
124
                iButtonX = iMinButtonX + i * (CAIRO_DIALOG_BUTTON_GAP + myDialogs.iDialogButtonWidth);
148
148
                                if (iButton >= 0 && iButton < pDialog->iNbButtons)
149
149
                                {
150
150
                                        pDialog->pButtons[iButton].iOffset = CAIRO_DIALOG_BUTTON_OFFSET;
151
 
                                        gtk_widget_queue_draw (pDialog->pWidget);
 
151
                                        gtk_widget_queue_draw (pDialog->container.pWidget);
152
152
                                }
153
153
                        }
154
154
                }
161
161
                                {
162
162
                                        pDialog->pButtons[iButton].iOffset = 0;
163
163
                                        pDialog->action_on_answer (iButton, pDialog->pInteractiveWidget, pDialog->pUserData, pDialog);
164
 
                                        gtk_widget_queue_draw (pDialog->pWidget);  // au cas ou le unref ci-dessous ne le detruirait pas.
 
164
                                        gtk_widget_queue_draw (pDialog->container.pWidget);  // au cas ou le unref ci-dessous ne le detruirait pas.
165
165
                                        cairo_dock_dialog_unreference (pDialog);
166
166
                                }
167
167
                                else
169
169
                                        int i;
170
170
                                        for (i = 0; i < pDialog->iNbButtons; i++)
171
171
                                                pDialog->pButtons[i].iOffset = 0;
172
 
                                        gtk_widget_queue_draw (pDialog->pWidget);
 
172
                                        gtk_widget_queue_draw (pDialog->container.pWidget);
173
173
                                }
174
174
                        }
175
175
                }
212
212
        if (pDialog->iIconTexture != 0)
213
213
        {
214
214
                x = pDialog->iLeftMargin;
215
 
                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
215
                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
216
216
                
217
217
                glBindTexture (GL_TEXTURE_2D, pDialog->iIconTexture);
218
218
                _cairo_dock_apply_current_texture_portion_at_size_with_offset (1.*pDialog->iCurrentFrame/pDialog->iNbFrames, 0.,
219
219
                        1. / pDialog->iNbFrames, 1.,
220
220
                        pDialog->iIconSize, pDialog->iIconSize,
221
 
                        x + pDialog->iIconSize/2, pDialog->iHeight - y - pDialog->iIconSize/2);
 
221
                        x + pDialog->iIconSize/2, pDialog->container.iHeight - y - pDialog->iIconSize/2);
222
222
        }
223
223
        
224
224
        if (pDialog->iTextTexture != 0)
225
225
        {
226
226
                x = pDialog->iLeftMargin + pDialog->iIconSize + CAIRO_DIALOG_TEXT_MARGIN;
227
 
                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
227
                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
228
228
                if (pDialog->iTextHeight < pDialog->iMessageHeight)  // on centre le texte.
229
229
                        y += (pDialog->iMessageHeight - pDialog->iTextHeight) / 2;
230
230
                
235
235
                        _cairo_dock_apply_current_texture_portion_at_size_with_offset (1.*pDialog->iCurrentTextOffset/pDialog->iTextWidth, 0.,
236
236
                                1.*(pDialog->iTextWidth - pDialog->iCurrentTextOffset) / pDialog->iTextWidth, 1.,
237
237
                                w, pDialog->iTextHeight,
238
 
                                x + w/2, pDialog->iHeight - y - pDialog->iTextHeight/2);
 
238
                                x + w/2, pDialog->container.iHeight - y - pDialog->iTextHeight/2);
239
239
                        
240
240
                        if (pDialog->iTextWidth - pDialog->iCurrentTextOffset < pDialog->iMaxTextWidth)
241
241
                        {
243
243
                                _cairo_dock_apply_current_texture_portion_at_size_with_offset (0., 0.,
244
244
                                        w / pDialog->iTextWidth, 1.,
245
245
                                        w, pDialog->iTextHeight,
246
 
                                        x + pDialog->iMaxTextWidth - w/2, pDialog->iHeight - y - pDialog->iTextHeight/2);
 
246
                                        x + pDialog->iMaxTextWidth - w/2, pDialog->container.iHeight - y - pDialog->iTextHeight/2);
247
247
                        }
248
248
                }
249
249
                else
250
250
                {
251
251
                        _cairo_dock_apply_current_texture_at_size_with_offset (pDialog->iTextWidth, pDialog->iTextHeight,
252
 
                                x + pDialog->iTextWidth/2, pDialog->iHeight - y - pDialog->iTextHeight/2);
 
252
                                x + pDialog->iTextWidth/2, pDialog->container.iHeight - y - pDialog->iTextHeight/2);
253
253
                }
254
254
        }
255
255
        
257
257
        {
258
258
                int iButtonX, iButtonY;
259
259
                int i, n = pDialog->iNbButtons;
260
 
                iButtonY = (pDialog->bDirectionUp ? pDialog->iTopMargin + pDialog->iMessageHeight + pDialog->iInteractiveHeight + CAIRO_DIALOG_VGAP : pDialog->iHeight - pDialog->iTopMargin - pDialog->iButtonsHeight - CAIRO_DIALOG_VGAP);
261
 
                int iMinButtonX = .5 * (pDialog->iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
 
260
                iButtonY = (pDialog->container.bDirectionUp ? pDialog->iTopMargin + pDialog->iMessageHeight + pDialog->iInteractiveHeight + CAIRO_DIALOG_VGAP : pDialog->container.iHeight - pDialog->iTopMargin - pDialog->iButtonsHeight - CAIRO_DIALOG_VGAP);
 
261
                int iMinButtonX = .5 * (pDialog->container.iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
262
262
                for (i = 0; i < pDialog->iNbButtons; i++)
263
263
                {
264
264
                        iButtonX = iMinButtonX + i * (CAIRO_DIALOG_BUTTON_GAP + myDialogs.iDialogButtonWidth);
266
266
                        _cairo_dock_apply_current_texture_at_size_with_offset (myDialogs.iDialogButtonWidth,
267
267
                                myDialogs.iDialogButtonWidth,
268
268
                                iButtonX + pDialog->pButtons[i].iOffset + myDialogs.iDialogButtonWidth/2,
269
 
                                pDialog->iHeight - (iButtonY + pDialog->pButtons[i].iOffset + myDialogs.iDialogButtonWidth/2));                 }
 
269
                                pDialog->container.iHeight - (iButtonY + pDialog->pButtons[i].iOffset + myDialogs.iDialogButtonWidth/2));                       }
270
270
        }
271
271
        
272
272
        if (pDialog->pRenderer != NULL && pDialog->pRenderer->render_opengl)
286
286
        if (pDialog->pIconBuffer != NULL)
287
287
        {
288
288
                x = pDialog->iLeftMargin;
289
 
                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
289
                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
290
290
                if (pDialog->iNbFrames > 1)
291
291
                {
292
292
                        cairo_save (pCairoContext);
310
310
        if (pDialog->pTextBuffer != NULL)
311
311
        {
312
312
                x = pDialog->iLeftMargin + pDialog->iIconSize + CAIRO_DIALOG_TEXT_MARGIN;
313
 
                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
313
                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
314
314
                if (pDialog->iTextHeight < pDialog->iMessageHeight)  // on centre le texte.
315
315
                        y += (pDialog->iMessageHeight - pDialog->iTextHeight) / 2;
316
316
                if (pDialog->iMaxTextWidth != 0 && pDialog->iTextWidth > pDialog->iMaxTextWidth)
335
335
                                pDialog->pTextBuffer,
336
336
                                x - pDialog->iCurrentTextOffset + pDialog->iTextWidth + 10,
337
337
                                y);
338
 
                        _paint_inside_dialog(pCairoContext, fAlpha);
 
338
                        _paint_inside_dialog (pCairoContext, fAlpha);
339
339
                        cairo_restore (pCairoContext);
340
340
                }
341
341
        }
344
344
        {
345
345
                int iButtonX, iButtonY;
346
346
                int i, n = pDialog->iNbButtons;
347
 
                iButtonY = (pDialog->bDirectionUp ? pDialog->iTopMargin + pDialog->iMessageHeight + pDialog->iInteractiveHeight + CAIRO_DIALOG_VGAP : pDialog->iHeight - pDialog->iTopMargin - pDialog->iButtonsHeight - CAIRO_DIALOG_VGAP);
348
 
                int iMinButtonX = .5 * (pDialog->iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
 
347
                iButtonY = (pDialog->container.bDirectionUp ? pDialog->iTopMargin + pDialog->iMessageHeight + pDialog->iInteractiveHeight + CAIRO_DIALOG_VGAP : pDialog->container.iHeight - pDialog->iTopMargin - pDialog->iButtonsHeight - CAIRO_DIALOG_VGAP);
 
348
                int iMinButtonX = .5 * (pDialog->container.iWidth - (n - 1) * CAIRO_DIALOG_BUTTON_GAP - n * myDialogs.iDialogButtonWidth);
349
349
                for (i = 0; i < pDialog->iNbButtons; i++)
350
350
                {
351
351
                        iButtonX = iMinButtonX + i * (CAIRO_DIALOG_BUTTON_GAP + myDialogs.iDialogButtonWidth);
364
364
        GdkEventExpose *pExpose,
365
365
        CairoDialog *pDialog)
366
366
{
367
 
        //cd_message ("%s (%dx%d)", __func__, pDialog->iWidth, pDialog->iHeight);
 
367
        //cd_message ("%s (%dx%d)", __func__, pDialog->container.iWidth, pDialog->container.iHeight);
368
368
        int x, y;
369
369
        if (0 && g_bUseOpenGL && (pDialog->pDecorator == NULL || pDialog->pDecorator->render_opengl != NULL) && (pDialog->pRenderer == NULL || pDialog->pRenderer->render_opengl != NULL))
370
370
        {
371
 
                GdkGLContext *pGlContext = gtk_widget_get_gl_context (pDialog->pWidget);
372
 
                GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pDialog->pWidget);
 
371
                GdkGLContext *pGlContext = gtk_widget_get_gl_context (pDialog->container.pWidget);
 
372
                GdkGLDrawable *pGlDrawable = gtk_widget_get_gl_drawable (pDialog->container.pWidget);
373
373
                if (!gdk_gl_drawable_gl_begin (pGlDrawable, pGlContext))
374
374
                        return FALSE;
375
375
                
386
386
                }
387
387
                
388
388
                cairo_dock_notify (CAIRO_DOCK_RENDER_DIALOG, pDialog, 1.);
389
 
                if (pDialog->fReflectAlpha != 0)
 
389
                if (pDialog->container.bUseReflect)
390
390
                {
391
391
                        glTranslatef (0.,
392
 
                                pDialog->iHeight - 2* (pDialog->iTopMargin + pDialog->iBubbleHeight),
 
392
                                pDialog->container.iHeight - 2* (pDialog->iTopMargin + pDialog->iBubbleHeight),
393
393
                                0.);
394
394
                        glScalef (1., -1., 1.);
395
 
                        cairo_dock_notify (CAIRO_DOCK_RENDER_DIALOG, pDialog, pDialog->fReflectAlpha);
 
395
                        cairo_dock_notify (CAIRO_DOCK_RENDER_DIALOG, pDialog, pDialog->container.fRatio);
396
396
                }
397
397
                
398
398
                if (gdk_gl_drawable_is_double_buffered (pGlDrawable))
405
405
        {
406
406
                cairo_t *pCairoContext;
407
407
                
408
 
                if ((pExpose->area.x != 0 || pExpose->area.y != 0) && pDialog->fReflectAlpha == 0)
 
408
                if ((pExpose->area.x != 0 || pExpose->area.y != 0) && !pDialog->container.bUseReflect)
409
409
                {
410
410
                        if (pDialog->pIconBuffer != NULL)
411
411
                        {
412
412
                                x = pDialog->iLeftMargin;
413
 
                                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
413
                                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
414
414
                                if (pExpose->area.x >= x &&
415
415
                                        pExpose->area.x + pExpose->area.width <= x + pDialog->iIconSize &&
416
416
                                        pExpose->area.y >= y &&
431
431
                        if (pDialog->pTextBuffer != NULL)
432
432
                        {
433
433
                                x = pDialog->iLeftMargin + pDialog->iIconSize + CAIRO_DIALOG_TEXT_MARGIN;
434
 
                                y = (pDialog->bDirectionUp ? pDialog->iTopMargin : pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
 
434
                                y = (pDialog->container.bDirectionUp ? pDialog->iTopMargin : pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight));
435
435
                                if (pExpose->area.x >= x &&
436
436
                                        pExpose->area.x + pExpose->area.width <= x + _drawn_text_width (pDialog) && 
437
437
                                        pExpose->area.y >=  y &&
474
474
                
475
475
                _cairo_dock_draw_inside_dialog (pCairoContext, pDialog, 0.);
476
476
 
477
 
                if (pDialog->fReflectAlpha != 0)
 
477
                if (pDialog->container.bUseReflect)
478
478
                {
479
479
                        cairo_save (pCairoContext);
480
480
                        cairo_rectangle (pCairoContext,
489
489
                                0.,
490
490
                                2* (pDialog->iTopMargin + pDialog->iBubbleHeight));
491
491
                        cairo_scale (pCairoContext, 1., -1.);
492
 
                        _cairo_dock_draw_inside_dialog (pCairoContext, pDialog, pDialog->fReflectAlpha);
 
492
                        _cairo_dock_draw_inside_dialog (pCairoContext, pDialog, pDialog->container.fRatio);
493
493
                }
494
494
 
495
495
                cairo_destroy (pCairoContext);
506
506
        if (pEvent->width == CAIRO_DIALOG_MIN_SIZE && pEvent->height == CAIRO_DIALOG_MIN_SIZE)
507
507
                return FALSE;
508
508
        
509
 
        int iWidth = pDialog->iWidth, iHeight = pDialog->iHeight;
 
509
        int iWidth = pDialog->container.iWidth, iHeight = pDialog->container.iHeight;
510
510
        //\____________ On recupere la taille du widget interactif qui a pu avoir change.
511
511
        if (pDialog->pInteractiveWidget != NULL)
512
512
        {
522
522
                cairo_dock_compute_dialog_sizes (pDialog);
523
523
        }
524
524
 
525
 
        if ((iWidth != pEvent->width || iHeight != pEvent->height))
 
525
        if (iWidth != pEvent->width || iHeight != pEvent->height)
526
526
        {
527
527
                if ((pEvent->width != CAIRO_DIALOG_MIN_SIZE || pEvent->height != CAIRO_DIALOG_MIN_SIZE) && (pEvent->width < iWidth || pEvent->height < iHeight))
528
528
                {
529
529
                        //g_print ("non, on a dit %dx%d !\n", pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin,
530
530
                        //      pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iDistanceToDock);
531
 
                        gtk_window_resize (GTK_WINDOW (pDialog->pWidget),
 
531
                        gtk_window_resize (GTK_WINDOW (pDialog->container.pWidget),
532
532
                                pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin,
533
533
                                pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iDistanceToDock);
534
534
                }
535
 
                pDialog->iWidth = pEvent->width;
536
 
                pDialog->iHeight = pEvent->height;
 
535
                pDialog->container.iWidth = pEvent->width;
 
536
                pDialog->container.iHeight = pEvent->height;
537
537
 
538
 
                if (pDialog->pIcon != NULL && ! pDialog->bInside)
 
538
                if (pDialog->pIcon != NULL && ! pDialog->container.bInside)
539
539
                {
540
540
                        CairoContainer *pContainer = cairo_dock_search_container_from_icon (pDialog->pIcon);
541
 
                        //g_print ("configure (%d) => place (%s, %s, %x)\n", pDialog->bInside, pDialog->pIcon->acName, pDialog->pIcon->cParentDockName, pContainer);
 
541
                        //g_print ("configure (%d) => place (%s, %s, %x)\n", pDialog->container.bInside, pDialog->pIcon->cName, pDialog->pIcon->cParentDockName, pContainer);
542
542
                        cairo_dock_place_dialog (pDialog, pContainer);
543
543
                }
544
544
        }
545
 
        gtk_widget_queue_draw (pDialog->pWidget);  // les widgets internes peuvent avoir changer de taille sans que le dialogue n'en ait change, il faut donc redessiner tout le temps.
 
545
        gtk_widget_queue_draw (pDialog->container.pWidget);  // les widgets internes peuvent avoir changer de taille sans que le dialogue n'en ait change, il faut donc redessiner tout le temps.
546
546
 
547
547
        return FALSE;
548
548
}
549
549
 
 
550
 
 
551
gboolean on_unmap_dialog (GtkWidget* pWidget,
 
552
        GdkEvent *pEvent,
 
553
        CairoDialog *pDialog)
 
554
{
 
555
        g_print ("unmap (bAllowMinimize:%d)\n", pDialog->bAllowMinimize);
 
556
        if (! pDialog->bAllowMinimize)
 
557
                gtk_window_present (GTK_WINDOW (pWidget));
 
558
        else
 
559
                pDialog->bAllowMinimize = FALSE;
 
560
        return TRUE;  // stops other handlers from being invoked for the event.
 
561
}
 
562
 
 
563
 
550
564
static cairo_surface_t *_cairo_dock_load_button_icon (cairo_t *pCairoContext, const gchar *cButtonImage, const gchar *cDefaultButtonImage)
551
565
{
552
566
        //g_print ("%s (%d ; %d)\n", __func__, myDialogs.iDialogButtonWidth, myDialogs.iDialogButtonHeight);
553
 
        cairo_surface_t *pButtonSurface = cairo_dock_load_image_for_icon (pCairoContext,
554
 
                cButtonImage,
 
567
        cairo_surface_t *pButtonSurface = cairo_dock_create_surface_from_image_simple (cButtonImage,
 
568
                pCairoContext,
555
569
                myDialogs.iDialogButtonWidth,
556
570
                myDialogs.iDialogButtonHeight);
557
571
 
559
573
        {
560
574
                gchar *cIconPath = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, cDefaultButtonImage);
561
575
                //g_print ("  on charge %s par defaut\n", cIconPath);
562
 
                pButtonSurface = cairo_dock_load_image_for_icon (pCairoContext,
563
 
                        cIconPath,
 
576
                pButtonSurface = cairo_dock_create_surface_from_image_simple (cIconPath,
 
577
                        pCairoContext,
564
578
                        myDialogs.iDialogButtonWidth,
565
579
                        myDialogs.iDialogButtonHeight);
566
580
                g_free (cIconPath);
631
645
        return FALSE;
632
646
}
633
647
 
634
 
static void _cairo_dock_isolate_dialog (CairoDialog *pDialog)
635
 
{
636
 
        cd_debug ("");
 
648
 
 
649
gboolean cairo_dock_dialog_unreference (CairoDialog *pDialog)
 
650
{
 
651
        //g_print ("%s (%d)\n", __func__, pDialog->iRefCount);
 
652
        if (pDialog != NULL && pDialog->iRefCount > 0)
 
653
        {
 
654
                pDialog->iRefCount --;
 
655
                if (pDialog->iRefCount == 0)  // devient nul.
 
656
                {
 
657
                        cairo_dock_free_dialog (pDialog);
 
658
                        return TRUE;
 
659
                }
 
660
                else
 
661
                        return FALSE;  // il n'est pas mort.
 
662
        }
 
663
        return TRUE;
 
664
}
 
665
 
 
666
 
 
667
void cairo_dock_free_dialog (CairoDialog *pDialog)
 
668
{
637
669
        if (pDialog == NULL)
638
670
                return ;
639
 
 
 
671
        
640
672
        if (pDialog->iSidTimer > 0)
641
673
        {
642
674
                g_source_remove (pDialog->iSidTimer);
652
684
                g_source_remove (pDialog->iSidAnimateText);
653
685
                pDialog->iSidAnimateText = 0;
654
686
        }
655
 
 
656
 
        g_signal_handlers_disconnect_by_func (pDialog->pWidget, on_expose_dialog, NULL);
657
 
        g_signal_handlers_disconnect_by_func (pDialog->pWidget, on_button_press_dialog, NULL);
658
 
        g_signal_handlers_disconnect_by_func (pDialog->pWidget, on_configure_dialog, NULL);
659
 
        g_signal_handlers_disconnect_by_func (pDialog->pWidget, on_enter_dialog, NULL);
660
 
        g_signal_handlers_disconnect_by_func (pDialog->pWidget, on_leave_dialog, NULL);
661
 
 
662
 
        pDialog->action_on_answer = NULL;
663
 
 
664
 
        pDialog->pIcon = NULL;
665
 
}
666
 
gboolean cairo_dock_dialog_unreference (CairoDialog *pDialog)
667
 
{
668
 
        //g_print ("%s (%d)\n", __func__, pDialog->iRefCount);
669
 
        if (pDialog != NULL && pDialog->iRefCount > 0)
670
 
        {
671
 
                pDialog->iRefCount --;
672
 
                if (pDialog->iRefCount == 0)  // devient nul.
673
 
                {
674
 
                        _cairo_dock_isolate_dialog (pDialog);
675
 
                        cairo_dock_free_dialog (pDialog);
676
 
                        return TRUE;
677
 
                }
678
 
                else
679
 
                        return FALSE;  // il n'est pas mort.
680
 
        }
681
 
        return TRUE;
682
 
}
683
 
 
684
 
 
685
 
void cairo_dock_free_dialog (CairoDialog *pDialog)
686
 
{
687
 
        if (pDialog == NULL)
688
 
                return ;
689
 
 
 
687
        
690
688
        cd_debug ("");
691
689
        s_pDialogList = g_slist_remove (s_pDialogList, pDialog);
692
690
 
716
714
                g_free (pDialog->pButtons);
717
715
        }
718
716
        
719
 
        gtk_widget_destroy (pDialog->pWidget);  // detruit aussi le widget interactif.
 
717
        gtk_widget_destroy (pDialog->container.pWidget);  // detruit aussi le widget interactif.
720
718
 
721
719
        if (pDialog->pUserData != NULL && pDialog->pFreeUserDataFunc != NULL)
722
720
                pDialog->pFreeUserDataFunc (pDialog->pUserData);
723
721
        
 
722
        if (pDialog->pIcon && pDialog->pIcon->cParentDockName != NULL)
 
723
                cairo_dock_dialog_window_destroyed ();
724
724
        g_free (pDialog);
725
725
}
726
726
 
727
727
gboolean cairo_dock_remove_dialog_if_any (Icon *icon)
728
728
{
729
729
        g_return_val_if_fail (icon != NULL, FALSE);
730
 
        cd_debug ("%s (%s)", __func__, (icon?icon->acName : "nobody"));
 
730
        cd_debug ("%s (%s)", __func__, (icon?icon->cName : "nobody"));
731
731
        CairoDialog *pDialog;
732
732
        GSList *ic;
733
733
        gboolean bDialogRemoved = FALSE;
803
803
{
804
804
        //\________________ On cree un dialogue qu'on insere immediatement dans la liste.
805
805
        CairoDialog *pDialog = g_new0 (CairoDialog, 1);
806
 
        pDialog->iType = CAIRO_DOCK_TYPE_DIALOG;
 
806
        pDialog->container.iType = CAIRO_DOCK_TYPE_DIALOG;
807
807
        pDialog->iRefCount = 1;
808
 
        pDialog->fRatio = 1.;
809
 
        pDialog->iAnimationDeltaT = mySystem.iCairoAnimationDeltaT;
 
808
        pDialog->container.fRatio = 1.;
 
809
        pDialog->container.iAnimationDeltaT = mySystem.iCairoAnimationDeltaT;
810
810
        s_pDialogList = g_slist_prepend (s_pDialogList, pDialog);
811
811
 
812
812
        //\________________ On construit la fenetre du dialogue.
813
813
        //GtkWidget* pWindow = gtk_window_new (bInteractiveWindow ? GTK_WINDOW_TOPLEVEL : GTK_WINDOW_POPUP);  // les popus ne prennent pas le focus. En fait, ils ne sont meme pas controles par le WM.
814
814
        GtkWidget* pWindow = cairo_dock_create_container_window_no_opengl ();
815
815
        
816
 
        pDialog->pWidget = pWindow;
 
816
        pDialog->container.pWidget = pWindow;
817
817
 
818
818
        //gtk_window_set_keep_above (GTK_WINDOW (pWindow), g_bKeepAbove || myAccessibility.bPopUp);
819
819
        gtk_window_set_gravity (GTK_WINDOW (pWindow), GDK_GRAVITY_STATIC);
820
820
 
821
821
        gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock-dialog");
822
822
        if (! bInteractive)
823
 
                gtk_window_set_type_hint (GTK_WINDOW (pDialog->pWidget), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);  // pour ne pas prendre le focus.
 
823
                gtk_window_set_type_hint (GTK_WINDOW (pDialog->container.pWidget), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);  // pour ne pas prendre le focus.
824
824
        
825
825
        gtk_widget_add_events (pWindow, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
826
826
        gtk_window_resize (GTK_WINDOW (pWindow), CAIRO_DIALOG_MIN_SIZE, CAIRO_DIALOG_MIN_SIZE);
842
842
                0,
843
843
                iTextWidth,
844
844
                iTextHeight,
845
 
                &fTextXOffset,
846
 
                &fTextYOffset);
 
845
                NULL,
 
846
                NULL);
847
847
        return pTextBuffer;
848
848
}
849
849
 
867
867
        else
868
868
        {
869
869
                double fImageWidth = iNbFrames * iDesiredSize, fImageHeight = iDesiredSize;
870
 
                pIconBuffer = cairo_dock_load_image (pSourceContext, cImageFilePath,
871
 
                        &fImageWidth, &fImageHeight,
872
 
                        0., 1., FALSE);
 
870
                pIconBuffer = cairo_dock_create_surface_from_image_simple (cImageFilePath,
 
871
                        pSourceContext,
 
872
                        fImageWidth,
 
873
                        fImageHeight);
873
874
        }
874
875
        if (pIconBuffer != NULL)
875
876
                *iIconSize = iDesiredSize;
952
953
        }
953
954
        
954
955
        //\________________ On prend en compte les boutons.
955
 
        if (pAttribute->cButtonsImage != NULL && pAttribute->pActionFunc != NULL)
956
 
        {
957
 
                pDialog->action_on_answer = pAttribute->pActionFunc;
 
956
        pDialog->action_on_answer = pAttribute->pActionFunc;
958
957
                pDialog->pUserData = pAttribute->pUserData;
959
958
                pDialog->pFreeUserDataFunc = pAttribute->pFreeDataFunc;
960
 
                
 
959
        if (pAttribute->cButtonsImage != NULL && pAttribute->pActionFunc != NULL)
 
960
        {
961
961
                if (s_pButtonOkSurface == NULL || s_pButtonCancelSurface == NULL)
962
962
                        cairo_dock_load_dialog_buttons (CAIRO_CONTAINER (pDialog), myDialogs.cButtonOkImage, myDialogs.cButtonCancelImage);
963
963
                
987
987
                                        cButtonPath = cairo_dock_search_icon_s_path (cButtonImage);
988
988
                                else
989
989
                                        cButtonPath = cButtonImage;
990
 
                                pDialog->pButtons[i].pSurface = cairo_dock_load_image_for_icon (pSourceContext,
991
 
                                        cButtonPath,
 
990
                                pDialog->pButtons[i].pSurface = cairo_dock_create_surface_from_image_simple (cButtonPath,
 
991
                                        pSourceContext,
992
992
                                        myDialogs.iDialogButtonWidth,
993
993
                                        myDialogs.iDialogButtonHeight);
994
994
                                if (cButtonPath != cButtonImage)
1006
1006
        //\________________ Maintenant qu'on connait tout, on calcule les tailles des divers elements.
1007
1007
        cairo_dock_compute_dialog_sizes (pDialog);
1008
1008
        
 
1009
        
 
1010
        cairo_dock_place_dialog (pDialog, pContainer);  // renseigne aussi bDirectionUp, bIsHorizontal, et iHeight.
 
1011
        
 
1012
        
1009
1013
        //\________________ On reserve l'espace pour les decorations.
1010
1014
        GtkWidget *pMainHBox = gtk_hbox_new (0, FALSE);
1011
 
        gtk_container_add (GTK_CONTAINER (pDialog->pWidget), pMainHBox);
 
1015
        gtk_container_add (GTK_CONTAINER (pDialog->container.pWidget), pMainHBox);
1012
1016
        pDialog->pLeftPaddingBox = gtk_vbox_new (0, FALSE);
1013
1017
        gtk_widget_set (pDialog->pLeftPaddingBox, "width-request", pDialog->iLeftMargin, NULL);
1014
1018
        gtk_box_pack_start (GTK_BOX (pMainHBox),
1033
1037
                0);
1034
1038
        
1035
1039
        //\________________ On reserve l'espace pour les elements.
 
1040
        if (! pDialog->container.bDirectionUp)
 
1041
                pDialog->pTipWidget = cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
1036
1042
        if (pDialog->iMessageWidth != 0 && pDialog->iMessageHeight != 0)
1037
1043
        {
1038
1044
                pDialog->pMessageWidget = cairo_dock_add_dialog_internal_box (pDialog, pDialog->iMessageWidth, pDialog->iMessageHeight, FALSE);
1052
1058
        {
1053
1059
                pDialog->pButtonsWidget = cairo_dock_add_dialog_internal_box (pDialog, pDialog->iButtonsWidth, pDialog->iButtonsHeight, FALSE);
1054
1060
        }
1055
 
        pDialog->pTipWidget = cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
 
1061
        if (pDialog->container.bDirectionUp)
 
1062
                pDialog->pTipWidget = cairo_dock_add_dialog_internal_box (pDialog, 0, pDialog->iMinBottomGap + pDialog->iBottomMargin, TRUE);
1056
1063
        
1057
 
        gtk_widget_show_all (pDialog->pWidget);
 
1064
        gtk_widget_show_all (pDialog->container.pWidget);
1058
1065
        
1059
1066
        //\________________ On connecte les signaux utiles.
1060
 
        g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1067
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1061
1068
                "expose-event",
1062
1069
                G_CALLBACK (on_expose_dialog),
1063
1070
                pDialog);
1064
 
        g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1071
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1065
1072
                "configure-event",
1066
1073
                G_CALLBACK (on_configure_dialog),
1067
1074
                pDialog);
1068
 
        g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1075
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1069
1076
                "button-press-event",
1070
1077
                G_CALLBACK (on_button_press_dialog),
1071
1078
                pDialog);
1072
 
        g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1079
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1073
1080
                "button-release-event",
1074
1081
                G_CALLBACK (on_button_press_dialog),
1075
1082
                pDialog);
1076
 
        g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1083
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1077
1084
                "key-press-event",
1078
1085
                G_CALLBACK (on_key_press_dialog),
1079
1086
                pDialog);
1080
1087
        if (pIcon != NULL)  // on inhibe le deplacement du dialogue lorsque l'utilisateur est dedans.
1081
1088
        {
1082
 
                g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1089
                g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1083
1090
                        "enter-notify-event",
1084
1091
                        G_CALLBACK (on_enter_dialog),
1085
1092
                        pDialog);
1086
 
                g_signal_connect (G_OBJECT (pDialog->pWidget),
 
1093
                g_signal_connect (G_OBJECT (pDialog->container.pWidget),
1087
1094
                        "leave-notify-event",
1088
1095
                        G_CALLBACK (on_leave_dialog),
1089
1096
                        pDialog);
1090
1097
        }
1091
 
 
1092
 
        cairo_dock_place_dialog (pDialog, pContainer);  // renseigne aussi bDirectionUp, bIsHorizontal, et iHeight.
 
1098
        g_signal_connect (G_OBJECT (pDialog->container.pWidget),
 
1099
                "unmap-event",
 
1100
                G_CALLBACK (on_unmap_dialog),
 
1101
                pDialog);
 
1102
        
 
1103
        ///cairo_dock_place_dialog (pDialog, pContainer);  // renseigne aussi bDirectionUp, bIsHorizontal, et iHeight.
1093
1104
        
1094
1105
        cairo_destroy (pSourceContext);
1095
1106
        
1096
1107
        if (pAttribute->iTimeLength != 0)
1097
1108
                pDialog->iSidTimer = g_timeout_add (pAttribute->iTimeLength, (GSourceFunc) _cairo_dock_dialog_auto_delete, (gpointer) pDialog);
1098
 
 
 
1109
        
 
1110
        if (pIcon->cParentDockName != NULL)
 
1111
                cairo_dock_dialog_window_created ();
1099
1112
        return pDialog;
1100
1113
}
1101
1114
 
1109
1122
                CairoDock *pDock = CAIRO_DOCK (pContainer);
1110
1123
                if (pDock->iRefCount == 0 && pDock->bAtBottom)  // un dock principal au repos.
1111
1124
                {
1112
 
                        *bIsHorizontal = (pDock->bHorizontalDock == CAIRO_DOCK_HORIZONTAL);
1113
 
                        if (pDock->bHorizontalDock)
 
1125
                        *bIsHorizontal = (pDock->container.bIsHorizontal == CAIRO_DOCK_HORIZONTAL);
 
1126
                        if (pDock->container.bIsHorizontal)
1114
1127
                        {
1115
1128
                                *bRight = (pIcon->fXAtRest > pDock->fFlatDockWidth / 2);
1116
 
                                *bDirectionUp = (pDock->iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
1117
 
                                *iY = (*bDirectionUp ? pDock->iWindowPositionY : pDock->iWindowPositionY + pDock->iCurrentHeight);
 
1129
                                *bDirectionUp = (pDock->container.iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
 
1130
                                *iY = (*bDirectionUp ? pDock->container.iWindowPositionY : pDock->container.iWindowPositionY + pDock->container.iHeight);
1118
1131
                        }
1119
1132
                        else
1120
1133
                        {
1121
 
                                *bRight = (pDock->iWindowPositionY < g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] / 2);
 
1134
                                *bRight = (pDock->container.iWindowPositionY < g_iScreenWidth[CAIRO_DOCK_HORIZONTAL] / 2);
1122
1135
                                *bDirectionUp = (pIcon->fXAtRest > pDock->fFlatDockWidth / 2);
1123
 
                                *iY = (! (*bRight) ? pDock->iWindowPositionY : pDock->iWindowPositionY + pDock->iCurrentHeight);
 
1136
                                *iY = (! (*bRight) ? pDock->container.iWindowPositionY : pDock->container.iWindowPositionY + pDock->container.iHeight);
1124
1137
                        }
1125
1138
        
1126
1139
                        if (pDock->bAutoHide)
1127
1140
                        {
1128
 
                                *iX = pDock->iWindowPositionX +
1129
 
                                        (pIcon->fXAtRest + pIcon->fWidth * (.5 + (*bRight ? .2 : -.2) * 2*(.5-fAlign))) / pDock->fFlatDockWidth * myHiddenDock.iVisibleZoneWidth;
 
1141
                                *iX = pDock->container.iWindowPositionX +
 
1142
                                        (pIcon->fXAtRest + pIcon->fWidth * (.5 + (*bRight ? .2 : -.2) * 2*(.5-fAlign))) / pDock->fFlatDockWidth * myAccessibility.iVisibleZoneWidth;
1130
1143
                                cd_debug ("placement sur un dock cache -> %d", *iX);
1131
1144
                        }
1132
1145
                        else
1133
1146
                        {
1134
 
                                *iX = pDock->iWindowPositionX +
 
1147
                                *iX = pDock->container.iWindowPositionX +
1135
1148
                                        pIcon->fDrawX + pIcon->fWidth * pIcon->fScale * (.5 + (*bRight ? .2 : -.2) * 2*(.5-fAlign));
1136
1149
                        }
1137
1150
                }
1138
 
                else if (pDock->iRefCount > 0 && ! GTK_WIDGET_VISIBLE (pDock->pWidget))  // sous-dock invisible.  // pDock->bAtBottom
 
1151
                else if (pDock->iRefCount > 0 && ! GTK_WIDGET_VISIBLE (pDock->container.pWidget))  // sous-dock invisible.  // pDock->bAtBottom
1139
1152
                {
1140
1153
                        CairoDock *pParentDock = NULL;
1141
1154
                        Icon *pPointingIcon = cairo_dock_search_icon_pointing_on_dock (pDock, &pParentDock);
1143
1156
                }
1144
1157
                else  // dock actif.
1145
1158
                {
1146
 
                        *bIsHorizontal = (pDock->bHorizontalDock == CAIRO_DOCK_HORIZONTAL);
1147
 
                        if (pDock->bHorizontalDock)
 
1159
                        *bIsHorizontal = (pDock->container.bIsHorizontal == CAIRO_DOCK_HORIZONTAL);
 
1160
                        if (pDock->container.bIsHorizontal)
1148
1161
                        {
1149
1162
                                *bRight = (pIcon->fXAtRest > pDock->fFlatDockWidth / 2);
1150
 
                                *bDirectionUp = (pDock->iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
1151
 
                                *iY = (*bDirectionUp ? pDock->iWindowPositionY : pDock->iWindowPositionY + pDock->iCurrentHeight);
 
1163
                                *bDirectionUp = (pDock->container.iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
 
1164
                                *iY = (*bDirectionUp ? pDock->container.iWindowPositionY : pDock->container.iWindowPositionY + pDock->container.iHeight);
1152
1165
                        }
1153
1166
                        else
1154
1167
                        {
1155
 
                                *bRight = (pDock->iWindowPositionY < g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] / 2);
 
1168
                                *bRight = (pDock->container.iWindowPositionY < g_iScreenWidth[CAIRO_DOCK_HORIZONTAL] / 2);
1156
1169
                                *bDirectionUp = (pIcon->fXAtRest > pDock->fFlatDockWidth / 2);
1157
 
                                *iY = (! (*bRight) ? pDock->iWindowPositionY : pDock->iWindowPositionY + pDock->iCurrentHeight);
 
1170
                                *iY = (! (*bRight) ? pDock->container.iWindowPositionY : pDock->container.iWindowPositionY + pDock->container.iHeight);
1158
1171
                        }
1159
 
                        *iX = pDock->iWindowPositionX + pIcon->fDrawX + pIcon->fWidth * pIcon->fScale * pIcon->fWidthFactor / 2 + pIcon->fWidth * (*bRight ? .2 : - .2);
 
1172
                        *iX = pDock->container.iWindowPositionX + pIcon->fDrawX + pIcon->fWidth * pIcon->fScale * pIcon->fWidthFactor / 2 + pIcon->fWidth * (*bRight ? .2 : - .2);
1160
1173
                }
1161
1174
        }
1162
1175
        else if (CAIRO_DOCK_IS_DESKLET (pContainer))
1163
1176
        {
1164
1177
                CairoDesklet *pDesklet = CAIRO_DESKLET (pContainer);
1165
 
                *bDirectionUp = (pDesklet->iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
1166
 
                *bIsHorizontal = (pDesklet->iWindowPositionX > 50 && pDesklet->iWindowPositionX + pDesklet->iHeight < g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] - 50);
 
1178
                *bDirectionUp = (pDesklet->container.iWindowPositionY > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
 
1179
                *bIsHorizontal = (pDesklet->container.iWindowPositionX > 50 && pDesklet->container.iWindowPositionX + pDesklet->container.iHeight < g_iXScreenWidth[CAIRO_DOCK_HORIZONTAL] - 50);
1167
1180
                
1168
1181
                if (*bIsHorizontal)
1169
1182
                {
1170
 
                        *bRight = (pDesklet->iWindowPositionX > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
1171
 
                        *iX = pDesklet->iWindowPositionX + pDesklet->iWidth * (*bRight ? .7 : .3);
1172
 
                        *iY = (*bDirectionUp ? pDesklet->iWindowPositionY : pDesklet->iWindowPositionY + pDesklet->iHeight);
 
1183
                        *bRight = (pDesklet->container.iWindowPositionX > g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
 
1184
                        *iX = pDesklet->container.iWindowPositionX + pDesklet->container.iWidth * (*bRight ? .7 : .3);
 
1185
                        *iY = (*bDirectionUp ? pDesklet->container.iWindowPositionY : pDesklet->container.iWindowPositionY + pDesklet->container.iHeight);
1173
1186
                }
1174
1187
                else
1175
1188
                {
1176
 
                        *bRight = (pDesklet->iWindowPositionX < g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
1177
 
                        *iY = pDesklet->iWindowPositionX + pDesklet->iWidth * (*bRight ? 1 : 0);
1178
 
                        *iX =pDesklet->iWindowPositionY + pDesklet->iHeight / 2;
 
1189
                        *bRight = (pDesklet->container.iWindowPositionX < g_iXScreenHeight[CAIRO_DOCK_HORIZONTAL] / 2);
 
1190
                        *iY = pDesklet->container.iWindowPositionX + pDesklet->container.iWidth * (*bRight ? 1 : 0);
 
1191
                        *iX =pDesklet->container.iWindowPositionY + pDesklet->container.iHeight / 2;
1179
1192
                }
1180
1193
        }
1181
1194
}
1183
1196
 
1184
1197
static void _cairo_dock_dialog_find_optimal_placement (CairoDialog *pDialog)
1185
1198
{
1186
 
        //g_print ("%s (Ybulle:%d; width:%d)\n", __func__, pDialog->iPositionY, pDialog->iWidth);
1187
 
        g_return_if_fail (pDialog->iPositionY > 0);
 
1199
        //g_print ("%s (Ybulle:%d; width:%d)\n", __func__, pDialog->container.iWindowPositionY, pDialog->container.iWidth);
 
1200
        g_return_if_fail (pDialog->container.iWindowPositionY > 0);
1188
1201
 
1189
1202
        Icon *icon;
1190
1203
        CairoDialog *pDialogOnOurWay;
1191
1204
 
1192
 
        double fXLeft = 0, fXRight = g_iXScreenWidth[pDialog->bIsHorizontal];
 
1205
        double fXLeft = 0, fXRight = g_iXScreenWidth[pDialog->container.bIsHorizontal];
1193
1206
        if (pDialog->bRight)
1194
1207
        {
1195
1208
                fXLeft = -1e4;
1196
 
                fXRight = MAX (g_iXScreenWidth[pDialog->bIsHorizontal], pDialog->iAimedX + pDialog->iMinFrameWidth + pDialog->iRightMargin + 1);  // 2*CAIRO_DIALOG_TIP_MARGIN + CAIRO_DIALOG_TIP_BASE
 
1209
                fXRight = MAX (g_iXScreenWidth[pDialog->container.bIsHorizontal], pDialog->iAimedX + pDialog->iMinFrameWidth + pDialog->iRightMargin + 1);  // 2*CAIRO_DIALOG_TIP_MARGIN + CAIRO_DIALOG_TIP_BASE
1197
1210
        }
1198
1211
        else
1199
1212
        {
1201
1214
                fXRight = 1e4;
1202
1215
        }
1203
1216
        gboolean bCollision = FALSE;
1204
 
        double fNextYStep = (pDialog->bDirectionUp ? -1e4 : 1e4);
 
1217
        double fNextYStep = (pDialog->container.bDirectionUp ? -1e4 : 1e4);
1205
1218
        int iYInf, iYSup;
1206
1219
        GSList *ic;
1207
1220
        for (ic = s_pDialogList; ic != NULL; ic = ic->next)
1211
1224
                        continue ;
1212
1225
                if (pDialogOnOurWay != pDialog)
1213
1226
                {
1214
 
                        if (GTK_WIDGET_VISIBLE (pDialogOnOurWay->pWidget) && pDialogOnOurWay->pIcon != NULL)
 
1227
                        if (GTK_WIDGET_VISIBLE (pDialogOnOurWay->container.pWidget) && pDialogOnOurWay->pIcon != NULL)
1215
1228
                        {
1216
 
                                iYInf = (pDialog->bDirectionUp ? pDialogOnOurWay->iPositionY : pDialogOnOurWay->iPositionY + pDialogOnOurWay->iHeight - (pDialogOnOurWay->iBubbleHeight + 0));
1217
 
                                iYSup = (pDialog->bDirectionUp ? pDialogOnOurWay->iPositionY + pDialogOnOurWay->iBubbleHeight + 0 : pDialogOnOurWay->iPositionY + pDialogOnOurWay->iHeight);
1218
 
                                if (iYInf < pDialog->iPositionY + pDialog->iBubbleHeight + 0 && iYSup > pDialog->iPositionY)
 
1229
                                iYInf = (pDialog->container.bDirectionUp ? pDialogOnOurWay->container.iWindowPositionY : pDialogOnOurWay->container.iWindowPositionY + pDialogOnOurWay->container.iHeight - (pDialogOnOurWay->iBubbleHeight + 0));
 
1230
                                iYSup = (pDialog->container.bDirectionUp ? pDialogOnOurWay->container.iWindowPositionY + pDialogOnOurWay->iBubbleHeight + 0 : pDialogOnOurWay->container.iWindowPositionY + pDialogOnOurWay->container.iHeight);
 
1231
                                if (iYInf < pDialog->container.iWindowPositionY + pDialog->iBubbleHeight + 0 && iYSup > pDialog->container.iWindowPositionY)
1219
1232
                                {
1220
 
                                        //g_print ("pDialogOnOurWay : %d - %d ; pDialog : %d - %d\n", iYInf, iYSup, pDialog->iPositionY, pDialog->iPositionY + (pDialog->iBubbleHeight + 2 * myBackground.iDockLineWidth));
 
1233
                                        //g_print ("pDialogOnOurWay : %d - %d ; pDialog : %d - %d\n", iYInf, iYSup, pDialog->container.iWindowPositionY, pDialog->container.iWindowPositionY + (pDialog->iBubbleHeight + 2 * myBackground.iDockLineWidth));
1221
1234
                                        if (pDialogOnOurWay->iAimedX < pDialog->iAimedX)
1222
 
                                                fXLeft = MAX (fXLeft, pDialogOnOurWay->iPositionX + pDialogOnOurWay->iWidth);
 
1235
                                                fXLeft = MAX (fXLeft, pDialogOnOurWay->container.iWindowPositionX + pDialogOnOurWay->container.iWidth);
1223
1236
                                        else
1224
 
                                                fXRight = MIN (fXRight, pDialogOnOurWay->iPositionX);
 
1237
                                                fXRight = MIN (fXRight, pDialogOnOurWay->container.iWindowPositionX);
1225
1238
                                        bCollision = TRUE;
1226
 
                                        fNextYStep = (pDialog->bDirectionUp ? MAX (fNextYStep, iYInf) : MIN (fNextYStep, iYSup));
 
1239
                                        fNextYStep = (pDialog->container.bDirectionUp ? MAX (fNextYStep, iYInf) : MIN (fNextYStep, iYSup));
1227
1240
                                }
1228
1241
                        }
1229
1242
                }
1230
1243
        }
1231
1244
        //g_print (" -> [%.2f ; %.2f]\n", fXLeft, fXRight);
1232
1245
 
1233
 
        if ((fXRight - fXLeft > pDialog->iWidth) && (
 
1246
        if ((fXRight - fXLeft > pDialog->container.iWidth) && (
1234
1247
                (pDialog->bRight && fXLeft + pDialog->iLeftMargin < pDialog->iAimedX && fXRight > pDialog->iAimedX + pDialog->iMinFrameWidth + pDialog->iRightMargin)
1235
1248
                ||
1236
1249
                (! pDialog->bRight && fXLeft < pDialog->iAimedX - pDialog->iMinFrameWidth - pDialog->iLeftMargin && fXRight > pDialog->iAimedX + pDialog->iRightMargin)
1237
1250
                ))
1238
1251
        {
1239
1252
                if (pDialog->bRight)
1240
 
                        pDialog->iPositionX = MIN (pDialog->iAimedX - pDialog->fAlign * pDialog->iBubbleWidth - pDialog->iLeftMargin, fXRight - pDialog->iWidth);
 
1253
                        pDialog->container.iWindowPositionX = MIN (pDialog->iAimedX - pDialog->fAlign * pDialog->iBubbleWidth - pDialog->iLeftMargin, fXRight - pDialog->container.iWidth);
1241
1254
                else
1242
 
                        pDialog->iPositionX = MAX (pDialog->iAimedX - pDialog->iRightMargin - pDialog->iWidth + pDialog->fAlign * pDialog->iBubbleWidth, fXLeft);  /// pDialog->iBubbleWidth (?)
 
1255
                        pDialog->container.iWindowPositionX = MAX (pDialog->iAimedX - pDialog->iRightMargin - pDialog->container.iWidth + pDialog->fAlign * pDialog->iBubbleWidth, fXLeft);  /// pDialog->iBubbleWidth (?)
1243
1256
        }
1244
1257
        else
1245
1258
        {
1246
 
                //g_print (" * Aim : (%d ; %d) ; Width : %d\n", pDialog->iAimedX, pDialog->iAimedY, pDialog->iWidth);
1247
 
                pDialog->iPositionY = fNextYStep - (pDialog->bDirectionUp ? pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin : 0);
 
1259
                //g_print (" * Aim : (%d ; %d) ; Width : %d\n", pDialog->iAimedX, pDialog->iAimedY, pDialog->container.iWidth);
 
1260
                pDialog->container.iWindowPositionY = fNextYStep - (pDialog->container.bDirectionUp ? pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin : 0);
1248
1261
                _cairo_dock_dialog_find_optimal_placement (pDialog);
1249
1262
        }
1250
1263
}
1252
1265
void cairo_dock_place_dialog (CairoDialog *pDialog, CairoContainer *pContainer)
1253
1266
{
1254
1267
        //g_print ("%s (%x;%d)\n", __func__, pDialog->pIcon, pContainer);
1255
 
        int iPrevPositionX = pDialog->iPositionX, iPrevPositionY = pDialog->iPositionY;
 
1268
        int iPrevPositionX = pDialog->container.iWindowPositionX, iPrevPositionY = pDialog->container.iWindowPositionY;
1256
1269
        if (pContainer != NULL && pDialog->pIcon != NULL)
1257
1270
        {
1258
 
                cairo_dock_dialog_calculate_aimed_point (pDialog->pIcon, pContainer, &pDialog->iAimedX, &pDialog->iAimedY, &pDialog->bRight, &pDialog->bIsHorizontal, &pDialog->bDirectionUp, pDialog->fAlign);
1259
 
                //g_print (" Aim (%d;%d) / %d,%d,%d\n", pDialog->iAimedX, pDialog->iAimedY, pDialog->bIsHorizontal, pDialog->bDirectionUp, pDialog->bInside);
 
1271
                cairo_dock_dialog_calculate_aimed_point (pDialog->pIcon, pContainer, &pDialog->iAimedX, &pDialog->iAimedY, &pDialog->bRight, &pDialog->container.bIsHorizontal, &pDialog->container.bDirectionUp, pDialog->fAlign);
 
1272
                //g_print (" Aim (%d;%d) / %d,%d,%d\n", pDialog->iAimedX, pDialog->iAimedY, pDialog->container.bIsHorizontal, pDialog->container.bDirectionUp, pDialog->container.bInside);
1260
1273
                
1261
 
                if (pDialog->bIsHorizontal)
 
1274
                if (pDialog->container.bIsHorizontal)
1262
1275
                {
1263
 
                        if (! pDialog->bInside)
 
1276
                        if (! pDialog->container.bInside)
1264
1277
                        {
1265
 
                                pDialog->iPositionY = (pDialog->bDirectionUp ? pDialog->iAimedY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap) : pDialog->iAimedY + pDialog->iMinBottomGap);  // on place la bulle d'abord sans prendre en compte la pointe.
 
1278
                                pDialog->container.iWindowPositionY = (pDialog->container.bDirectionUp ? pDialog->iAimedY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap) : pDialog->iAimedY + pDialog->iMinBottomGap);  // on place la bulle d'abord sans prendre en compte la pointe.
1266
1279
                                _cairo_dock_dialog_find_optimal_placement (pDialog);
1267
1280
                        }
1268
 
                        else if (! pDialog->bDirectionUp)
1269
 
                                pDialog->iPositionY += pDialog->iDistanceToDock;
 
1281
                        else if (! pDialog->container.bDirectionUp)
 
1282
                                pDialog->container.iWindowPositionY += pDialog->iDistanceToDock;
1270
1283
                }
1271
1284
                else
1272
1285
                {
1273
1286
                        int tmp = pDialog->iAimedX;
1274
1287
                        pDialog->iAimedX = pDialog->iAimedY;
1275
1288
                        pDialog->iAimedY = tmp;
1276
 
                        if (! pDialog->bInside)
 
1289
                        if (! pDialog->container.bInside)
1277
1290
                        {
1278
 
                                pDialog->iPositionX = (pDialog->bRight ? pDialog->iAimedX - pDialog->fAlign * pDialog->iBubbleWidth : pDialog->iAimedX - pDialog->iWidth + pDialog->fAlign * pDialog->iBubbleWidth);
1279
 
                                pDialog->iPositionY = (pDialog->bDirectionUp ? pDialog->iAimedY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap) : pDialog->iAimedY + pDialog->iMinBottomGap);  // on place la bulle (et non pas la fenetre) sans faire d'optimisation.
 
1291
                                pDialog->container.iWindowPositionX = (pDialog->bRight ? pDialog->iAimedX - pDialog->fAlign * pDialog->iBubbleWidth : pDialog->iAimedX - pDialog->container.iWidth + pDialog->fAlign * pDialog->iBubbleWidth);
 
1292
                                pDialog->container.iWindowPositionY = (pDialog->container.bDirectionUp ? pDialog->iAimedY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap) : pDialog->iAimedY + pDialog->iMinBottomGap);  // on place la bulle (et non pas la fenetre) sans faire d'optimisation.
1280
1293
                        }
1281
1294
                }
1282
 
                //g_print (" => position : (%d;%d)\n", pDialog->iPositionX, pDialog->iPositionY);
 
1295
                //g_print (" => position : (%d;%d)\n", pDialog->container.iWindowPositionX, pDialog->container.iWindowPositionY);
1283
1296
                int iOldDistance = pDialog->iDistanceToDock;
1284
 
                pDialog->iDistanceToDock = (pDialog->bDirectionUp ? pDialog->iAimedY - pDialog->iPositionY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin) : pDialog->iPositionY - pDialog->iAimedY);
1285
 
                if (! pDialog->bDirectionUp)  // iPositionY est encore la position du coin haut gauche de la bulle et non de la fenetre.
1286
 
                        pDialog->iPositionY = pDialog->iAimedY;
 
1297
                pDialog->iDistanceToDock = (pDialog->container.bDirectionUp ? pDialog->iAimedY - pDialog->container.iWindowPositionY - (pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin) : pDialog->container.iWindowPositionY - pDialog->iAimedY);
 
1298
                if (! pDialog->container.bDirectionUp)  // iPositionY est encore la position du coin haut gauche de la bulle et non de la fenetre.
 
1299
                        pDialog->container.iWindowPositionY = pDialog->iAimedY;
1287
1300
                
1288
1301
                if (pDialog->iDistanceToDock != iOldDistance)
1289
1302
                {
1293
1306
                        if ((iOldDistance == 0) || (pDialog->iDistanceToDock < iOldDistance))
1294
1307
                        {
1295
1308
                                //g_print ("    cela reduit la fenetre a %dx%d\n", pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin, pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iDistanceToDock);
1296
 
                                gtk_window_resize (GTK_WINDOW (pDialog->pWidget),
 
1309
                                gtk_window_resize (GTK_WINDOW (pDialog->container.pWidget),
1297
1310
                                        pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin,
1298
1311
                                        pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iDistanceToDock);
1299
1312
                        }
1301
1314
        }
1302
1315
        else  // au milieu de l'ecran courant.
1303
1316
        {
1304
 
                pDialog->bDirectionUp = TRUE;
1305
 
                pDialog->iPositionX = g_iScreenOffsetX + (g_iScreenWidth [CAIRO_DOCK_HORIZONTAL] - pDialog->iWidth) / 2;
1306
 
                pDialog->iPositionY = g_iScreenOffsetY + (g_iScreenHeight[CAIRO_DOCK_HORIZONTAL] - pDialog->iHeight) / 2;
1307
 
                pDialog->iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin;
1308
 
                //g_print (" au milieu de l'ecran (%d;%d) %dx%d\n", pDialog->iPositionX, pDialog->iPositionY, pDialog->iWidth, pDialog->iHeight);
 
1317
                pDialog->container.bDirectionUp = TRUE;
 
1318
                pDialog->container.iWindowPositionX = (g_pMainDock ? g_pMainDock->iScreenOffsetX : 0) + (g_iScreenWidth [CAIRO_DOCK_HORIZONTAL] - pDialog->container.iWidth) / 2;
 
1319
                pDialog->container.iWindowPositionY = (g_pMainDock ? g_pMainDock->iScreenOffsetY : 0) + (g_iScreenHeight[CAIRO_DOCK_HORIZONTAL] - pDialog->container.iHeight) / 2;
 
1320
                pDialog->container.iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin;
 
1321
                //g_print (" au milieu de l'ecran (%d;%d) %dx%d\n", pDialog->container.iWindowPositionX, pDialog->container.iWindowPositionY, pDialog->container.iWidth, pDialog->container.iHeight);
1309
1322
                
1310
 
                gtk_window_resize (GTK_WINDOW (pDialog->pWidget),
 
1323
                gtk_window_resize (GTK_WINDOW (pDialog->container.pWidget),
1311
1324
                        pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin,
1312
1325
                        pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin);
1313
1326
        }
1314
1327
 
1315
 
        if (iPrevPositionX != pDialog->iPositionX || iPrevPositionY != pDialog->iPositionY)
 
1328
        if (iPrevPositionX != pDialog->container.iWindowPositionX || iPrevPositionY != pDialog->container.iWindowPositionY)
1316
1329
        {
1317
 
                //g_print (" => move to (%d;%d) %dx%d\n", pDialog->iPositionX, pDialog->iPositionY, pDialog->iWidth, pDialog->iHeight);
1318
 
                gtk_window_move (GTK_WINDOW (pDialog->pWidget),
1319
 
                        pDialog->iPositionX,
1320
 
                        pDialog->iPositionY);
 
1330
                //g_print (" => move to (%d;%d) %dx%d\n", pDialog->container.iWindowPositionX, pDialog->container.iWindowPositionY, pDialog->container.iWidth, pDialog->container.iHeight);
 
1331
                gtk_window_move (GTK_WINDOW (pDialog->container.pWidget),
 
1332
                        pDialog->container.iWindowPositionX,
 
1333
                        pDialog->container.iWindowPositionY);
1321
1334
        }
1322
1335
}
1323
1336
 
1339
1352
        if (pDialog->iBubbleHeight == 0)
1340
1353
                pDialog->iBubbleHeight = 2 * myBackground.iDockRadius + myBackground.iDockLineWidth;
1341
1354
        
1342
 
        pDialog->iWidth = pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin;
1343
 
        pDialog->iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap;  // resultat temporaire, sans la pointe.
 
1355
        pDialog->container.iWidth = pDialog->iBubbleWidth + pDialog->iLeftMargin + pDialog->iRightMargin;
 
1356
        pDialog->container.iHeight = pDialog->iBubbleHeight + pDialog->iTopMargin + pDialog->iBottomMargin + pDialog->iMinBottomGap;  // resultat temporaire, sans la pointe.
1344
1357
}
1345
1358
 
1346
1359
 
1361
1374
                pDialog = ic->data;
1362
1375
                
1363
1376
                pIcon = pDialog->pIcon;
1364
 
                if (pIcon != NULL && GTK_WIDGET_VISIBLE (pDialog->pWidget)) // on ne replace pas les dialogues en cours de destruction ou caches.
 
1377
                if (pIcon != NULL && GTK_WIDGET_VISIBLE (pDialog->container.pWidget)) // on ne replace pas les dialogues en cours de destruction ou caches.
1365
1378
                {
1366
1379
                        pContainer = cairo_dock_search_container_from_icon (pIcon);
1367
1380
                        if (CAIRO_DOCK_IS_DOCK (pContainer))
1368
1381
                        {
1369
 
                                int iPositionX = pDialog->iPositionX;
1370
 
                                int iPositionY = pDialog->iPositionY;
 
1382
                                int iPositionX = pDialog->container.iWindowPositionX;
 
1383
                                int iPositionY = pDialog->container.iWindowPositionY;
1371
1384
                                int iAimedX = pDialog->iAimedX;
1372
1385
                                int iAimedY = pDialog->iAimedY;
1373
1386
                                cairo_dock_place_dialog (pDialog, pContainer);
1374
1387
                                
1375
 
                                if (iPositionX != pDialog->iPositionX || iPositionY != pDialog->iPositionY || iAimedX != pDialog->iAimedX || iAimedY != pDialog->iAimedY)
1376
 
                                        gtk_widget_queue_draw (pDialog->pWidget);  // on redessine meme si la position n'a pas changee, car la pointe, elle, change.
 
1388
                                if (iPositionX != pDialog->container.iWindowPositionX || iPositionY != pDialog->container.iWindowPositionY || iAimedX != pDialog->iAimedX || iAimedY != pDialog->iAimedY)
 
1389
                                        gtk_widget_queue_draw (pDialog->container.pWidget);  // on redessine meme si la position n'a pas changee, car la pointe, elle, change.
1377
1390
                        }
1378
1391
                }
1379
1392
        }
1380
1393
}
1381
1394
 
1382
1395
 
1383
 
CairoDialog *cairo_dock_show_dialog_full (const gchar *cText, Icon *pIcon, CairoContainer *pContainer, double fTimeLength, gchar *cIconPath, GtkWidget *pInteractiveWidget, CairoDockActionOnAnswerFunc pActionFunc, gpointer data, GFreeFunc pFreeDataFunc)
 
1396
CairoDialog *cairo_dock_show_dialog_full (const gchar *cText, Icon *pIcon, CairoContainer *pContainer, double fTimeLength, const gchar *cIconPath, GtkWidget *pInteractiveWidget, CairoDockActionOnAnswerFunc pActionFunc, gpointer data, GFreeFunc pFreeDataFunc)
1384
1397
{
1385
1398
        if (pIcon != NULL && pIcon->fPersonnalScale > 0)  // icone en cours de suppression.
1386
1399
        {
1387
 
                g_print ("dialog skipped\n");
 
1400
                g_print ("dialog skipped for %s (%.2f)\n", pIcon->cName, pIcon->fPersonnalScale);
1388
1401
                return NULL;
1389
1402
        }
1390
1403
        
1391
1404
        CairoDialogAttribute attr;
1392
1405
        memset (&attr, 0, sizeof (CairoDialogAttribute));
1393
 
        attr.cText = cText;
1394
 
        attr.cImageFilePath = cIconPath;
 
1406
        attr.cText = (gchar *)cText;
 
1407
        attr.cImageFilePath = (gchar *)cIconPath;
1395
1408
        attr.pInteractiveWidget = pInteractiveWidget;
1396
1409
        attr.pActionFunc = pActionFunc;
1397
1410
        attr.pUserData = data;
1399
1412
        attr.iTimeLength = (int) fTimeLength;
1400
1413
        if (pActionFunc != NULL)
1401
1414
        {
1402
 
                gchar *cButtons[3] = {"ok", "cancel", NULL};
1403
 
                attr.cButtonsImage = cButtons;
 
1415
                const gchar *cButtons[3] = {"ok", "cancel", NULL};
 
1416
                attr.cButtonsImage = (gchar **)cButtons;
1404
1417
        }
1405
1418
        
1406
1419
        CairoDialog *pDialog = cairo_dock_build_dialog (&attr, pIcon, pContainer);
1527
1540
 
1528
1541
        if (pDialog != NULL)
1529
1542
        {
1530
 
                gtk_window_set_modal (GTK_WINDOW (pDialog->pWidget), TRUE);
1531
 
                g_signal_connect (pDialog->pWidget,
 
1543
                gtk_window_set_modal (GTK_WINDOW (pDialog->container.pWidget), TRUE);
 
1544
                g_signal_connect (pDialog->container.pWidget,
1532
1545
                        "delete-event",
1533
1546
                        G_CALLBACK (_cairo_dock_dialog_destroyed),
1534
1547
                        pBlockingLoop);
1542
1555
                //g_print ("fin de boucle bloquante -> %d\n", iAnswer);
1543
1556
                if (myAccessibility.bPopUp && CAIRO_DOCK_IS_DOCK (pContainer))
1544
1557
                        cairo_dock_pop_down (CAIRO_DOCK (pContainer));
1545
 
                if (CAIRO_DOCK_IS_DOCK (pContainer)/* && ! pDock->bInside*/)
 
1558
                if (CAIRO_DOCK_IS_DOCK (pContainer)/* && ! pDock->container.bInside*/)
1546
1559
                {
1547
1560
                        cd_message ("on force a quitter");
1548
1561
                        CairoDock *pDock = CAIRO_DOCK (pContainer);
1549
 
                        pDock->bInside = TRUE;
 
1562
                        pDock->container.bInside = TRUE;
1550
1563
                        pDock->bAtBottom = FALSE;
1551
 
                        cairo_dock_on_leave_notify (pDock->pWidget,
 
1564
                        cairo_dock_on_leave_notify (pDock->container.pWidget,
1552
1565
                                NULL,
1553
1566
                                pDock);
1554
1567
                }
1563
1576
{
1564
1577
        //GtkWidget *pWidget = cairo_dock_build_common_interactive_widget_for_dialog ((cInitialAnswer != NULL ? cInitialAnswer : ""), -1, -1);
1565
1578
        GtkWidget *pWidget = _cairo_dock_make_entry_for_dialog (cInitialAnswer);
1566
 
        gchar *cIconPath = g_strdup_printf ("%s/%s", CAIRO_DOCK_SHARE_DATA_DIR, CAIRO_DOCK_ICON);
 
1579
        const gchar *cIconPath = CAIRO_DOCK_SHARE_DATA_DIR"/"CAIRO_DOCK_ICON;
1567
1580
 
1568
1581
        int iClickedButton = cairo_dock_show_dialog_and_wait (cMessage, pIcon, pContainer, 0, cIconPath, pWidget);
1569
 
        g_free (cIconPath);
1570
1582
 
1571
1583
        gchar *cAnswer = (iClickedButton == 0 || iClickedButton == -1 ? g_strdup (gtk_entry_get_text (GTK_ENTRY (pWidget))) : NULL);
1572
1584
        cd_message ("cAnswer : %s", cAnswer);
1663
1675
 
1664
1676
void cairo_dock_hide_dialog (CairoDialog *pDialog)
1665
1677
{
1666
 
        gtk_widget_hide (pDialog->pWidget);
1667
 
        pDialog->bInside = FALSE;
 
1678
        if (GTK_WIDGET_VISIBLE (pDialog->container.pWidget))
 
1679
        {
 
1680
                pDialog->bAllowMinimize = TRUE;
 
1681
                gtk_widget_hide (pDialog->container.pWidget);
 
1682
                pDialog->container.bInside = FALSE;
 
1683
                cairo_dock_replace_all_dialogs ();
 
1684
                if (pDialog->pIcon && pDialog->pIcon->cParentDockName != NULL)
 
1685
                        cairo_dock_dialog_window_destroyed ();
 
1686
        }
1668
1687
}
1669
1688
 
1670
1689
void cairo_dock_unhide_dialog (CairoDialog *pDialog)
1671
1690
{
1672
 
        if (! GTK_WIDGET_VISIBLE (pDialog->pWidget))
 
1691
        if (! GTK_WIDGET_VISIBLE (pDialog->container.pWidget))
1673
1692
        {
1674
1693
                if (pDialog->pInteractiveWidget != NULL)
1675
1694
                        gtk_widget_grab_focus (pDialog->pInteractiveWidget);
1678
1697
                {
1679
1698
                        CairoContainer *pContainer = cairo_dock_search_container_from_icon (pIcon);
1680
1699
                        cairo_dock_place_dialog (pDialog, pContainer);
 
1700
                        if (pIcon->cParentDockName != NULL)
 
1701
                                cairo_dock_dialog_window_created ();
1681
1702
                }
1682
1703
        }
1683
 
        gtk_window_present (GTK_WINDOW (pDialog->pWidget));
 
1704
        gtk_window_present (GTK_WINDOW (pDialog->container.pWidget));
1684
1705
}
1685
1706
 
1686
1707
void cairo_dock_toggle_dialog_visibility (CairoDialog *pDialog)
1687
1708
{
1688
 
        if (GTK_WIDGET_VISIBLE (pDialog->pWidget))
 
1709
        if (GTK_WIDGET_VISIBLE (pDialog->container.pWidget))
1689
1710
                cairo_dock_hide_dialog (pDialog);
1690
1711
        else
1691
1712
                cairo_dock_unhide_dialog (pDialog);
1741
1762
                        CairoContainer *pContainer = cairo_dock_search_container_from_icon (pDialog->pIcon);
1742
1763
                        cairo_dock_place_dialog (pDialog, pContainer);
1743
1764
                }
1744
 
                gtk_widget_queue_draw (pDialog->pWidget);
 
1765
                gtk_widget_queue_draw (pDialog->container.pWidget);
1745
1766
        }
1746
1767
        else
1747
1768
        {
1776
1797
                        CairoContainer *pContainer = cairo_dock_search_container_from_icon (pDialog->pIcon);
1777
1798
                        cairo_dock_place_dialog (pDialog, pContainer);
1778
1799
                }
1779
 
                gtk_widget_queue_draw (pDialog->pWidget);
 
1800
                gtk_widget_queue_draw (pDialog->container.pWidget);
1780
1801
        }
1781
1802
        else
1782
1803
        {
1822
1843
 
1823
1844
void cairo_dock_damage_icon_dialog (CairoDialog *pDialog)
1824
1845
{
1825
 
        if (pDialog->fReflectAlpha == 0)
1826
 
                gtk_widget_queue_draw_area (pDialog->pWidget,
 
1846
        if (!pDialog->container.bUseReflect)
 
1847
                gtk_widget_queue_draw_area (pDialog->container.pWidget,
1827
1848
                        pDialog->iLeftMargin,
1828
 
                        (pDialog->bDirectionUp ? 
 
1849
                        (pDialog->container.bDirectionUp ? 
1829
1850
                                pDialog->iTopMargin :
1830
 
                                pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight)),
 
1851
                                pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight)),
1831
1852
                        pDialog->iIconSize,
1832
1853
                        pDialog->iIconSize);
1833
1854
        else
1834
 
                gtk_widget_queue_draw (pDialog->pWidget);
 
1855
                gtk_widget_queue_draw (pDialog->container.pWidget);
1835
1856
}
1836
1857
 
1837
1858
void cairo_dock_damage_text_dialog (CairoDialog *pDialog)
1838
1859
{
1839
 
        if (pDialog->fReflectAlpha == 0)
1840
 
                gtk_widget_queue_draw_area (pDialog->pWidget,
 
1860
        if (!pDialog->container.bUseReflect)
 
1861
                gtk_widget_queue_draw_area (pDialog->container.pWidget,
1841
1862
                        pDialog->iLeftMargin + pDialog->iIconSize + CAIRO_DIALOG_TEXT_MARGIN,
1842
 
                        (pDialog->bDirectionUp ? 
 
1863
                        (pDialog->container.bDirectionUp ? 
1843
1864
                                pDialog->iTopMargin :
1844
 
                                pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight)),
 
1865
                                pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight)),
1845
1866
                        _drawn_text_width (pDialog),
1846
1867
                        pDialog->iTextHeight);
1847
1868
        else
1848
 
                gtk_widget_queue_draw (pDialog->pWidget);
 
1869
                gtk_widget_queue_draw (pDialog->container.pWidget);
1849
1870
}
1850
1871
 
1851
1872
void cairo_dock_damage_interactive_widget_dialog (CairoDialog *pDialog)
1852
1873
{
1853
 
        if (pDialog->fReflectAlpha == 0)
1854
 
                gtk_widget_queue_draw_area (pDialog->pWidget,
 
1874
        if (!pDialog->container.bUseReflect)
 
1875
                gtk_widget_queue_draw_area (pDialog->container.pWidget,
1855
1876
                        pDialog->iLeftMargin,
1856
 
                        (pDialog->bDirectionUp ? 
 
1877
                        (pDialog->container.bDirectionUp ? 
1857
1878
                                pDialog->iTopMargin + pDialog->iMessageHeight :
1858
 
                                pDialog->iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight) + pDialog->iMessageHeight),
 
1879
                                pDialog->container.iHeight - (pDialog->iTopMargin + pDialog->iBubbleHeight) + pDialog->iMessageHeight),
1859
1880
                        pDialog->iInteractiveWidth,
1860
1881
                        pDialog->iInteractiveHeight);
1861
1882
        else
1862
 
                gtk_widget_queue_draw (pDialog->pWidget);
 
1883
                gtk_widget_queue_draw (pDialog->container.pWidget);
1863
1884
}