← Back to branch summary

~profzoom/ubuntu/quantal/wmaker/bug-1079925

« back to all changes in this revision

Viewing changes to WINGs/wpanel.c

  • Committer: Bazaar Package Importer
  • Author(s): Marcelo E. Magallon
  • Date: 2004-11-10 14:05:30 UTC
  • Revision ID: james.westby@ubuntu.com-20041110140530-qpd66b5lm38x7apk
Tags: upstream-0.91.0
Import upstream version 0.91.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
WINGs/wpanel.c
 
1
 
 
2
 
 
3
#include "WINGsP.h"
 
4
 
 
5
#include <X11/keysym.h>
 
6
 
 
7
 
 
8
 
 
9
static void
 
10
alertPanelOnClick(WMWidget *self, void *clientData)
 
11
{
 
12
    WMAlertPanel *panel = clientData;
 
13
 
 
14
    WMBreakModalLoop(WMWidgetScreen(self));
 
15
    if (self == panel->defBtn) {
 
16
        panel->result = WAPRDefault;
 
17
    } else if (self == panel->othBtn) {
 
18
        panel->result = WAPROther;
 
19
    } else if (self == panel->altBtn) {
 
20
        panel->result = WAPRAlternate;
 
21
    }
 
22
}
 
23
 
 
24
 
 
25
static void
 
26
handleKeyPress(XEvent *event, void *clientData)
 
27
{
 
28
    WMAlertPanel *panel = (WMAlertPanel*)clientData;
 
29
    KeySym ksym;
 
30
 
 
31
    XLookupString(&event->xkey, NULL, 0, &ksym, NULL);
 
32
 
 
33
    if (ksym == XK_Return && panel->defBtn) {
 
34
        WMPerformButtonClick(panel->defBtn);
 
35
    } else if (ksym == XK_Escape) {
 
36
        if (panel->altBtn || panel->othBtn) {
 
37
            WMPerformButtonClick(panel->othBtn ? panel->othBtn : panel->altBtn);
 
38
        } else {
 
39
            panel->result = WAPRDefault;
 
40
            WMBreakModalLoop(WMWidgetScreen(panel->win));
 
41
        }
 
42
    }
 
43
}
 
44
 
 
45
 
 
46
int
 
47
WMRunAlertPanel(WMScreen *scrPtr, WMWindow *owner,
 
48
                char *title, char *msg, char *defaultButton,
 
49
                char *alternateButton, char *otherButton)
 
50
{
 
51
    WMAlertPanel *panel;
 
52
    int tmp;
 
53
 
 
54
    panel = WMCreateAlertPanel(scrPtr, owner, title, msg, defaultButton,
 
55
                               alternateButton, otherButton);
 
56
 
 
57
    {
 
58
        int px, py;
 
59
        WMView *view = WMWidgetView(panel->win);
 
60
 
 
61
        if (owner) {
 
62
            WMView *oview = WMWidgetView(owner);
 
63
            WMPoint pt = WMGetViewScreenPosition(oview);
 
64
 
 
65
            px = (W_VIEW_WIDTH(oview)-W_VIEW_WIDTH(view))/2;
 
66
            py = (W_VIEW_HEIGHT(oview)-W_VIEW_HEIGHT(view))/2;
 
67
 
 
68
            px += pt.x;
 
69
            py += pt.y;
 
70
        } else {
 
71
            px = (W_VIEW_WIDTH(scrPtr->rootView)-W_VIEW_WIDTH(view))/2;
 
72
            py = (W_VIEW_HEIGHT(scrPtr->rootView)-W_VIEW_HEIGHT(view))/2;
 
73
        }
 
74
        WMSetWindowInitialPosition(panel->win, px, py);
 
75
    }
 
76
 
 
77
    WMMapWidget(panel->win);
 
78
 
 
79
    WMRunModalLoop(scrPtr, W_VIEW(panel->win));
 
80
 
 
81
    tmp = panel->result;
 
82
 
 
83
    WMDestroyAlertPanel(panel);
 
84
 
 
85
    return tmp;
 
86
}
 
87
 
 
88
 
 
89
void
 
90
WMDestroyAlertPanel(WMAlertPanel *panel)
 
91
{
 
92
    WMUnmapWidget(panel->win);
 
93
    WMDestroyWidget(panel->win);
 
94
    wfree(panel);
 
95
}
 
96
 
 
97
 
 
98
WMAlertPanel*
 
99
WMCreateAlertPanel(WMScreen *scrPtr, WMWindow *owner,
 
100
                   char *title, char *msg, char *defaultButton,
 
101
                   char *alternateButton, char *otherButton)
 
102
{
 
103
    WMAlertPanel *panel;
 
104
    int dw=0, aw=0, ow=0, w;
 
105
    WMBox *hbox;
 
106
    WMPixmap *icon;
 
107
 
 
108
 
 
109
    panel = wmalloc(sizeof(WMAlertPanel));
 
110
    memset(panel, 0, sizeof(WMAlertPanel));
 
111
 
 
112
    if (owner) {
 
113
        panel->win = WMCreatePanelWithStyleForWindow(owner, "alertPanel",
 
114
                                                     WMTitledWindowMask);
 
115
    } else {
 
116
        panel->win = WMCreateWindowWithStyle(scrPtr, "alertPanel",
 
117
                                             WMTitledWindowMask);
 
118
    }
 
119
 
 
120
    WMSetWindowInitialPosition(panel->win,
 
121
                               (scrPtr->rootView->size.width - WMWidgetWidth(panel->win))/2,
 
122
                               (scrPtr->rootView->size.height - WMWidgetHeight(panel->win))/2);
 
123
 
 
124
    WMSetWindowTitle(panel->win, "");
 
125
 
 
126
    panel->vbox = WMCreateBox(panel->win);
 
127
    WMSetViewExpandsToParent(WMWidgetView(panel->vbox), 0, 0, 0, 0);
 
128
    WMSetBoxHorizontal(panel->vbox, False);
 
129
    WMMapWidget(panel->vbox);
 
130
 
 
131
    hbox = WMCreateBox(panel->vbox);
 
132
    WMSetBoxBorderWidth(hbox, 5);
 
133
    WMSetBoxHorizontal(hbox, True);
 
134
    WMMapWidget(hbox);
 
135
    WMAddBoxSubview(panel->vbox, WMWidgetView(hbox), False, True, 74, 0, 5);
 
136
 
 
137
    panel->iLbl = WMCreateLabel(hbox);
 
138
    WMSetLabelImagePosition(panel->iLbl, WIPImageOnly);
 
139
    WMMapWidget(panel->iLbl);
 
140
    WMAddBoxSubview(hbox, WMWidgetView(panel->iLbl), False, True, 64, 0, 10);
 
141
    icon = WMCreateApplicationIconBlendedPixmap(scrPtr, (RColor*)NULL);
 
142
    if (icon) {
 
143
        WMSetLabelImage(panel->iLbl, icon);
 
144
        WMReleasePixmap(icon);
 
145
    } else {
 
146
        WMSetLabelImage(panel->iLbl, scrPtr->applicationIconPixmap);
 
147
    }
 
148
 
 
149
    if (title) {
 
150
        WMFont *largeFont;
 
151
 
 
152
        largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
 
153
 
 
154
        panel->tLbl = WMCreateLabel(hbox);
 
155
        WMMapWidget(panel->tLbl);
 
156
        WMAddBoxSubview(hbox, WMWidgetView(panel->tLbl), True, True,
 
157
                        64, 0, 0);
 
158
        WMSetLabelText(panel->tLbl, title);
 
159
        WMSetLabelTextAlignment(panel->tLbl, WALeft);
 
160
        WMSetLabelFont(panel->tLbl, largeFont);
 
161
 
 
162
        WMReleaseFont(largeFont);
 
163
    }
 
164
 
 
165
    /* create divider line */
 
166
 
 
167
    panel->line = WMCreateFrame(panel->win);
 
168
    WMMapWidget(panel->line);
 
169
    WMAddBoxSubview(panel->vbox, WMWidgetView(panel->line), False, True,
 
170
                    2, 2, 5);
 
171
    WMSetFrameRelief(panel->line, WRGroove);
 
172
 
 
173
 
 
174
    if (msg) {
 
175
        panel->mLbl = WMCreateLabel(panel->vbox);
 
176
        WMSetLabelWraps(panel->mLbl, True);
 
177
        WMMapWidget(panel->mLbl);
 
178
        WMAddBoxSubview(panel->vbox, WMWidgetView(panel->mLbl), True, True,
 
179
                        WMFontHeight(scrPtr->normalFont)*4, 0, 5);
 
180
        WMSetLabelText(panel->mLbl, msg);
 
181
        WMSetLabelTextAlignment(panel->mLbl, WACenter);
 
182
    }
 
183
 
 
184
    panel->hbox = WMCreateBox(panel->vbox);
 
185
    WMSetBoxBorderWidth(panel->hbox, 10);
 
186
    WMSetBoxHorizontal(panel->hbox, True);
 
187
    WMMapWidget(panel->hbox);
 
188
    WMAddBoxSubview(panel->vbox, WMWidgetView(panel->hbox), False, True, 44, 0, 0);
 
189
 
 
190
    /* create buttons */
 
191
    if (otherButton)
 
192
        ow = WMWidthOfString(scrPtr->normalFont, otherButton,
 
193
                             strlen(otherButton));
 
194
 
 
195
    if (alternateButton)
 
196
        aw = WMWidthOfString(scrPtr->normalFont, alternateButton,
 
197
                             strlen(alternateButton));
 
198
 
 
199
    if (defaultButton)
 
200
        dw = WMWidthOfString(scrPtr->normalFont, defaultButton,
 
201
                             strlen(defaultButton));
 
202
 
 
203
    dw = dw + (scrPtr->buttonArrow ? scrPtr->buttonArrow->width : 0);
 
204
 
 
205
    aw += 30;
 
206
    ow += 30;
 
207
    dw += 30;
 
208
 
 
209
    w = WMAX(dw, WMAX(aw, ow));
 
210
    if ((w+10)*3 < 400) {
 
211
        aw = w;
 
212
        ow = w;
 
213
        dw = w;
 
214
    } else {
 
215
        int t;
 
216
 
 
217
        t = 400 - 40 - aw - ow - dw;
 
218
        aw += t/3;
 
219
        ow += t/3;
 
220
        dw += t/3;
 
221
    }
 
222
 
 
223
    if (defaultButton) {
 
224
        panel->defBtn = WMCreateCommandButton(panel->hbox);
 
225
        WMSetButtonAction(panel->defBtn, alertPanelOnClick, panel);
 
226
        WMAddBoxSubviewAtEnd(panel->hbox, WMWidgetView(panel->defBtn),
 
227
                             False, True, dw, 0, 0);
 
228
        WMSetButtonText(panel->defBtn, defaultButton);
 
229
        WMSetButtonImage(panel->defBtn, scrPtr->buttonArrow);
 
230
        WMSetButtonAltImage(panel->defBtn, scrPtr->pushedButtonArrow);
 
231
        WMSetButtonImagePosition(panel->defBtn, WIPRight);
 
232
    }
 
233
    if (alternateButton) {
 
234
        panel->altBtn = WMCreateCommandButton(panel->hbox);
 
235
        WMAddBoxSubviewAtEnd(panel->hbox, WMWidgetView(panel->altBtn),
 
236
                             False, True, aw, 0, 5);
 
237
        WMSetButtonAction(panel->altBtn, alertPanelOnClick, panel);
 
238
        WMSetButtonText(panel->altBtn, alternateButton);
 
239
    }
 
240
    if (otherButton) {
 
241
        panel->othBtn = WMCreateCommandButton(panel->hbox);
 
242
        WMSetButtonAction(panel->othBtn, alertPanelOnClick, panel);
 
243
        WMAddBoxSubviewAtEnd(panel->hbox, WMWidgetView(panel->othBtn),
 
244
                             False, True, ow, 0, 5);
 
245
        WMSetButtonText(panel->othBtn, otherButton);
 
246
    }
 
247
 
 
248
    WMMapSubwidgets(panel->hbox);
 
249
 
 
250
    WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask,
 
251
                         handleKeyPress, panel);
 
252
 
 
253
    WMRealizeWidget(panel->win);
 
254
    WMMapSubwidgets(panel->win);
 
255
 
 
256
    return panel;
 
257
}
 
258
 
 
259
 
 
260
 
 
261
 
 
262
 
 
263
static void
 
264
inputBoxOnClick(WMWidget *self, void *clientData)
 
265
{
 
266
    WMInputPanel *panel = clientData;
 
267
 
 
268
    WMBreakModalLoop(WMWidgetScreen(self));
 
269
    if (self == panel->defBtn) {
 
270
        panel->result = WAPRDefault;
 
271
    } else if (self == panel->altBtn) {
 
272
        panel->result = WAPRAlternate;
 
273
    }
 
274
}
 
275
 
 
276
 
 
277
 
 
278
static void
 
279
handleKeyPress2(XEvent *event, void *clientData)
 
280
{
 
281
    WMInputPanel *panel = (WMInputPanel*)clientData;
 
282
    KeySym ksym;
 
283
 
 
284
    XLookupString(&event->xkey, NULL, 0, &ksym, NULL);
 
285
 
 
286
    if (ksym == XK_Return && panel->defBtn) {
 
287
        WMPerformButtonClick(panel->defBtn);
 
288
    } else if (ksym == XK_Escape) {
 
289
        if (panel->altBtn) {
 
290
            WMPerformButtonClick(panel->altBtn);
 
291
        } else {
 
292
            /*           printf("got esc\n");*/
 
293
            WMBreakModalLoop(WMWidgetScreen(panel->win));
 
294
            panel->result = WAPRDefault;
 
295
        }
 
296
    }
 
297
}
 
298
 
 
299
 
 
300
char*
 
301
WMRunInputPanel(WMScreen *scrPtr, WMWindow *owner, char *title,
 
302
                char *msg, char *defaultText,
 
303
                char *okButton, char *cancelButton)
 
304
{
 
305
    WMInputPanel *panel;
 
306
    char *tmp;
 
307
 
 
308
    panel = WMCreateInputPanel(scrPtr, owner, title, msg, defaultText,
 
309
                               okButton, cancelButton);
 
310
 
 
311
 
 
312
    {
 
313
        int px, py;
 
314
        WMView *view = WMWidgetView(panel->win);
 
315
 
 
316
        if (owner) {
 
317
            WMView *oview = WMWidgetView(owner);
 
318
            WMPoint pt = WMGetViewScreenPosition(oview);
 
319
 
 
320
            px = (W_VIEW_WIDTH(oview)-W_VIEW_WIDTH(view))/2;
 
321
            py = (W_VIEW_HEIGHT(oview)-W_VIEW_HEIGHT(view))/2;
 
322
 
 
323
            px += pt.x;
 
324
            py += pt.y;
 
325
        } else {
 
326
            px = (W_VIEW_WIDTH(scrPtr->rootView)-W_VIEW_WIDTH(view))/2;
 
327
            py = (W_VIEW_HEIGHT(scrPtr->rootView)-W_VIEW_HEIGHT(view))/2;
 
328
        }
 
329
        WMSetWindowInitialPosition(panel->win, px, py);
 
330
    }
 
331
 
 
332
    WMMapWidget(panel->win);
 
333
 
 
334
    WMRunModalLoop(scrPtr, W_VIEW(panel->win));
 
335
 
 
336
    if (panel->result == WAPRDefault)
 
337
        tmp = WMGetTextFieldText(panel->text);
 
338
    else
 
339
        tmp = NULL;
 
340
 
 
341
    WMDestroyInputPanel(panel);
 
342
 
 
343
    return tmp;
 
344
}
 
345
 
 
346
 
 
347
void
 
348
WMDestroyInputPanel(WMInputPanel *panel)
 
349
{
 
350
    WMRemoveNotificationObserver(panel);
 
351
    WMUnmapWidget(panel->win);
 
352
    WMDestroyWidget(panel->win);
 
353
    wfree(panel);
 
354
}
 
355
 
 
356
 
 
357
 
 
358
static void
 
359
endedEditingObserver(void *observerData, WMNotification *notification)
 
360
{
 
361
    WMInputPanel *panel = (WMInputPanel*)observerData;
 
362
 
 
363
    switch ((int)WMGetNotificationClientData(notification)) {
 
364
    case WMReturnTextMovement:
 
365
        if (panel->defBtn)
 
366
            WMPerformButtonClick(panel->defBtn);
 
367
        break;
 
368
    case WMEscapeTextMovement:
 
369
        if (panel->altBtn)
 
370
            WMPerformButtonClick(panel->altBtn);
 
371
        else {
 
372
            WMBreakModalLoop(WMWidgetScreen(panel->win));
 
373
            panel->result = WAPRDefault;
 
374
        }
 
375
        break;
 
376
    default:
 
377
        break;
 
378
    }
 
379
}
 
380
 
 
381
 
 
382
WMInputPanel*
 
383
WMCreateInputPanel(WMScreen *scrPtr, WMWindow *owner, char *title, char *msg,
 
384
                   char *defaultText, char *okButton, char *cancelButton)
 
385
{
 
386
    WMInputPanel *panel;
 
387
    int x, dw=0, aw=0, w;
 
388
 
 
389
 
 
390
    panel = wmalloc(sizeof(WMInputPanel));
 
391
    memset(panel, 0, sizeof(WMInputPanel));
 
392
 
 
393
    if (owner)
 
394
        panel->win = WMCreatePanelWithStyleForWindow(owner, "inputPanel",
 
395
                                                     WMTitledWindowMask);
 
396
    else
 
397
        panel->win = WMCreateWindowWithStyle(scrPtr, "inputPanel",
 
398
                                             WMTitledWindowMask);
 
399
    WMSetWindowTitle(panel->win, "");
 
400
 
 
401
    WMResizeWidget(panel->win, 320, 160);
 
402
 
 
403
    if (title) {
 
404
        WMFont *largeFont;
 
405
 
 
406
        largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
 
407
 
 
408
        panel->tLbl = WMCreateLabel(panel->win);
 
409
        WMMoveWidget(panel->tLbl, 20, 16);
 
410
        WMResizeWidget(panel->tLbl, 320 - 40, WMFontHeight(largeFont)+4);
 
411
        WMSetLabelText(panel->tLbl, title);
 
412
        WMSetLabelTextAlignment(panel->tLbl, WALeft);
 
413
        WMSetLabelFont(panel->tLbl, largeFont);
 
414
 
 
415
        WMReleaseFont(largeFont);
 
416
    }
 
417
 
 
418
 
 
419
    if (msg) {
 
420
        panel->mLbl = WMCreateLabel(panel->win);
 
421
        WMMoveWidget(panel->mLbl, 20, 50);
 
422
        WMResizeWidget(panel->mLbl, 320 - 40,
 
423
                       WMFontHeight(scrPtr->normalFont)*2);
 
424
        WMSetLabelText(panel->mLbl, msg);
 
425
        WMSetLabelTextAlignment(panel->mLbl, WALeft);
 
426
    }
 
427
 
 
428
    panel->text = WMCreateTextField(panel->win);
 
429
    WMMoveWidget(panel->text, 20, 85);
 
430
    WMResizeWidget(panel->text, 320 - 40, WMWidgetHeight(panel->text));
 
431
    WMSetTextFieldText(panel->text, defaultText);
 
432
 
 
433
    WMAddNotificationObserver(endedEditingObserver, panel,
 
434
                              WMTextDidEndEditingNotification, panel->text);
 
435
 
 
436
    /* create buttons */
 
437
    if (cancelButton)
 
438
        aw = WMWidthOfString(scrPtr->normalFont, cancelButton,
 
439
                             strlen(cancelButton));
 
440
 
 
441
    if (okButton)
 
442
        dw = WMWidthOfString(scrPtr->normalFont, okButton,
 
443
                             strlen(okButton));
 
444
 
 
445
    w = dw + (scrPtr->buttonArrow ? scrPtr->buttonArrow->width : 0);
 
446
    if (aw > w)
 
447
        w = aw;
 
448
 
 
449
    w += 30;
 
450
    x = 310;
 
451
 
 
452
    if (okButton) {
 
453
        x -= w + 10;
 
454
 
 
455
        panel->defBtn = WMCreateCustomButton(panel->win, WBBPushInMask
 
456
                                             |WBBPushChangeMask
 
457
                                             |WBBPushLightMask);
 
458
        WMSetButtonAction(panel->defBtn, inputBoxOnClick, panel);
 
459
        WMMoveWidget(panel->defBtn, x, 124);
 
460
        WMResizeWidget(panel->defBtn, w, 24);
 
461
        WMSetButtonText(panel->defBtn, okButton);
 
462
        WMSetButtonImage(panel->defBtn, scrPtr->buttonArrow);
 
463
        WMSetButtonAltImage(panel->defBtn, scrPtr->pushedButtonArrow);
 
464
        WMSetButtonImagePosition(panel->defBtn, WIPRight);
 
465
    }
 
466
    if (cancelButton) {
 
467
        x -= w + 10;
 
468
 
 
469
        panel->altBtn = WMCreateCommandButton(panel->win);
 
470
        WMSetButtonAction(panel->altBtn, inputBoxOnClick, panel);
 
471
        WMMoveWidget(panel->altBtn, x, 124);
 
472
        WMResizeWidget(panel->altBtn, w, 24);
 
473
        WMSetButtonText(panel->altBtn, cancelButton);
 
474
    }
 
475
 
 
476
    WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask,
 
477
                         handleKeyPress2, panel);
 
478
 
 
479
    WMRealizeWidget(panel->win);
 
480
    WMMapSubwidgets(panel->win);
 
481
 
 
482
    WMSetFocusToWidget(panel->text);
 
483
 
 
484
    return panel;
 
485
}
 
486
 
 
487
 
 
488
 
 
489
 
 
490
static void
 
491
handleKeyPress3(XEvent *event, void *clientData)
 
492
{
 
493
    WMGenericPanel *panel = (WMGenericPanel*)clientData;
 
494
    KeySym ksym;
 
495
 
 
496
    XLookupString(&event->xkey, NULL, 0, &ksym, NULL);
 
497
 
 
498
    if (ksym == XK_Return && panel->defBtn) {
 
499
        WMPerformButtonClick(panel->defBtn);
 
500
    } else if (ksym == XK_Escape) {
 
501
        if (panel->altBtn) {
 
502
            WMPerformButtonClick(panel->altBtn);
 
503
        } else {
 
504
            panel->result = WAPRDefault;
 
505
            WMBreakModalLoop(WMWidgetScreen(panel->win));
 
506
        }
 
507
    }
 
508
}
 
509
 
 
510
 
 
511
void
 
512
WMDestroyGenericPanel(WMGenericPanel *panel)
 
513
{
 
514
    WMUnmapWidget(panel->win);
 
515
    WMDestroyWidget(panel->win);
 
516
    wfree(panel);
 
517
}
 
518
 
 
519
 
 
520
WMGenericPanel*
 
521
WMCreateGenericPanel(WMScreen *scrPtr, WMWindow *owner,
 
522
                     char *title, char *defaultButton,
 
523
                     char *alternateButton)
 
524
{
 
525
    WMGenericPanel *panel;
 
526
    int dw=0, aw=0, w;
 
527
    WMBox *hbox;
 
528
    WMPixmap *icon;
 
529
 
 
530
 
 
531
    panel = wmalloc(sizeof(WMGenericPanel));
 
532
    memset(panel, 0, sizeof(WMGenericPanel));
 
533
 
 
534
    if (owner) {
 
535
        panel->win = WMCreatePanelWithStyleForWindow(owner, "genericPanel",
 
536
                                                     WMTitledWindowMask);
 
537
    } else {
 
538
        panel->win = WMCreateWindowWithStyle(scrPtr, "genericPanel",
 
539
                                             WMTitledWindowMask);
 
540
    }
 
541
 
 
542
    WMSetWindowInitialPosition(panel->win,
 
543
                               (scrPtr->rootView->size.width - WMWidgetWidth(panel->win))/2,
 
544
                               (scrPtr->rootView->size.height - WMWidgetHeight(panel->win))/2);
 
545
 
 
546
    WMSetWindowTitle(panel->win, "");
 
547
 
 
548
    panel->vbox = WMCreateBox(panel->win);
 
549
    WMSetViewExpandsToParent(WMWidgetView(panel->vbox), 0, 0, 0, 0);
 
550
    WMSetBoxHorizontal(panel->vbox, False);
 
551
    WMMapWidget(panel->vbox);
 
552
 
 
553
    hbox = WMCreateBox(panel->vbox);
 
554
    WMSetBoxBorderWidth(hbox, 5);
 
555
    WMSetBoxHorizontal(hbox, True);
 
556
    WMMapWidget(hbox);
 
557
    WMAddBoxSubview(panel->vbox, WMWidgetView(hbox), False, True, 74, 0, 5);
 
558
 
 
559
    panel->iLbl = WMCreateLabel(hbox);
 
560
    WMSetLabelImagePosition(panel->iLbl, WIPImageOnly);
 
561
    WMMapWidget(panel->iLbl);
 
562
    WMAddBoxSubview(hbox, WMWidgetView(panel->iLbl), False, True, 64, 0, 10);
 
563
    icon = WMCreateApplicationIconBlendedPixmap(scrPtr, (RColor*)NULL);
 
564
    if (icon) {
 
565
        WMSetLabelImage(panel->iLbl, icon);
 
566
        WMReleasePixmap(icon);
 
567
    } else {
 
568
        WMSetLabelImage(panel->iLbl, scrPtr->applicationIconPixmap);
 
569
    }
 
570
 
 
571
    if (title) {
 
572
        WMFont *largeFont;
 
573
 
 
574
        largeFont = WMBoldSystemFontOfSize(scrPtr, 24);
 
575
 
 
576
        panel->tLbl = WMCreateLabel(hbox);
 
577
        WMMapWidget(panel->tLbl);
 
578
        WMAddBoxSubview(hbox, WMWidgetView(panel->tLbl), True, True,
 
579
                        64, 0, 0);
 
580
        WMSetLabelText(panel->tLbl, title);
 
581
        WMSetLabelTextAlignment(panel->tLbl, WALeft);
 
582
        WMSetLabelFont(panel->tLbl, largeFont);
 
583
 
 
584
        WMReleaseFont(largeFont);
 
585
    }
 
586
 
 
587
    /* create divider line */
 
588
 
 
589
    panel->line = WMCreateFrame(panel->vbox);
 
590
    WMMapWidget(panel->line);
 
591
    WMAddBoxSubview(panel->vbox, WMWidgetView(panel->line), False, True,
 
592
                    2, 2, 5);
 
593
    WMSetFrameRelief(panel->line, WRGroove);
 
594
 
 
595
 
 
596
    panel->content = WMCreateFrame(panel->vbox);
 
597
    WMMapWidget(panel->content);
 
598
    WMAddBoxSubview(panel->vbox, WMWidgetView(panel->content), True, True,
 
599
                    50, 0, 5);
 
600
    WMSetFrameRelief(panel->content, WRFlat);
 
601
 
 
602
    hbox = WMCreateBox(panel->vbox);
 
603
    WMSetBoxBorderWidth(hbox, 10);
 
604
    WMSetBoxHorizontal(hbox, True);
 
605
    WMMapWidget(hbox);
 
606
    WMAddBoxSubview(panel->vbox, WMWidgetView(hbox), False, True, 44, 0, 0);
 
607
 
 
608
    /* create buttons */
 
609
    if (defaultButton)
 
610
        dw = WMWidthOfString(scrPtr->normalFont, defaultButton,
 
611
                             strlen(defaultButton));
 
612
 
 
613
    if (alternateButton)
 
614
        aw = WMWidthOfString(scrPtr->normalFont, alternateButton,
 
615
                             strlen(alternateButton));
 
616
 
 
617
 
 
618
    dw = dw + (scrPtr->buttonArrow ? scrPtr->buttonArrow->width : 0);
 
619
 
 
620
    aw += 30;
 
621
    dw += 30;
 
622
 
 
623
    w = WMAX(dw, aw);
 
624
    if ((w+10)*2 < 400) {
 
625
        aw = w;
 
626
        dw = w;
 
627
    } else {
 
628
        int t;
 
629
 
 
630
        t = 400 - 40 - aw - dw;
 
631
        aw += t/2;
 
632
        dw += t/2;
 
633
    }
 
634
 
 
635
    if (defaultButton) {
 
636
        panel->defBtn = WMCreateCommandButton(hbox);
 
637
        WMSetButtonAction(panel->defBtn, alertPanelOnClick, panel);
 
638
        WMAddBoxSubviewAtEnd(hbox, WMWidgetView(panel->defBtn),
 
639
                             False, True, dw, 0, 0);
 
640
        WMSetButtonText(panel->defBtn, defaultButton);
 
641
        WMSetButtonImage(panel->defBtn, scrPtr->buttonArrow);
 
642
        WMSetButtonAltImage(panel->defBtn, scrPtr->pushedButtonArrow);
 
643
        WMSetButtonImagePosition(panel->defBtn, WIPRight);
 
644
    }
 
645
 
 
646
    WMMapSubwidgets(hbox);
 
647
 
 
648
    WMCreateEventHandler(W_VIEW(panel->win), KeyPressMask,
 
649
                         handleKeyPress3, panel);
 
650
 
 
651
    WMRealizeWidget(panel->win);
 
652
    WMMapSubwidgets(panel->win);
 
653
 
 
654
    return panel;
 
655
}
 
656
 
 
657