← Back to branch summary

~ubuntu-branches/ubuntu/quantal/openmotif/quantal

« back to all changes in this revision

Viewing changes to lib/Xm/Simple.c

  • Committer: Bazaar Package Importer
  • Author(s): Stefan Bauer
  • Date: 2010-06-23 12:12:31 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100623121231-u89gxdp51sg9wjj2
Tags: 2.3.0-1
http://bugs.debian.org/379258
http://bugs.debian.org/494375
http://bugs.debian.org/288537
* New Maintainer (Closes: #379258) 
* Acknowledge NMU changes
* New upstream release (Closes: #494375)
* Get rid of security patches as they are already part of new upstream
  release (00-xpmvuln.openmotif.patch, 342092-CVE-2005-3964.patch)
* Bump Standards to 3.8.4
* Added {misc:Depends} to make the package lintian cleaner
* Fix weak-library-dev-dependency by adding ${binary:Version}) for the
  -dev Package of openmotif
* Let package depend on autotools-dev to use newer autotools-helper-files
* Work around an autoconf-bug (Gentoo-Bug #1475)
* Added Client-side anti-aliased fonts support via XFT
* Added UTF-8 and UTF8_STRING atom support
* Ability to show text and pixmaps in Label, LabelGadget and all
  derived widgets
* Support of PNG/JPEG image formats in the same way as XPM is supported
* Increase FILE_OFFSET_BITS to 64 to show files >2GB in file-selector
  Idea taken from Magne Oestlyngen (Closes: #288537)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/Xm/Simple.c
 
1
/* 
 
2
 *  @OPENGROUP_COPYRIGHT@
 
3
 *  COPYRIGHT NOTICE
 
4
 *  Copyright (c) 1990, 1991, 1992, 1993 Open Software Foundation, Inc.
 
5
 *  Copyright (c) 1996, 1997, 1998, 1999, 2000 The Open Group
 
6
 *  ALL RIGHTS RESERVED (MOTIF). See the file named COPYRIGHT.MOTIF for
 
7
 *  the full copyright text.
 
8
 *  
 
9
 *  This software is subject to an open license. It may only be
 
10
 *  used on, with or for operating systems which are themselves open
 
11
 *  source systems. You must contact The Open Group for a license
 
12
 *  allowing distribution and sublicensing of this software on, with,
 
13
 *  or for operating systems which are not Open Source programs.
 
14
 *  
 
15
 *  See http://www.opengroup.org/openmotif/license for full
 
16
 *  details of the license agreement. Any use, reproduction, or
 
17
 *  distribution of the program constitutes recipient's acceptance of
 
18
 *  this agreement.
 
19
 *  
 
20
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
 
21
 *  PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 
22
 *  KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY
 
23
 *  WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
 
24
 *  OR FITNESS FOR A PARTICULAR PURPOSE
 
25
 *  
 
26
 *  EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
 
27
 *  NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT,
 
28
 *  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
29
 *  DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED
 
30
 *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 
31
 *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 
32
 *  ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
 
33
 *  EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
 
34
 *  POSSIBILITY OF SUCH DAMAGES.
 
35
*/ 
 
36
/* 
 
37
 * HISTORY
 
38
*/ 
 
39
#ifdef REV_INFO
 
40
#ifndef lint
 
41
static char rcsid[] = "$XConsortium: Simple.c /main/11 1995/09/19 23:08:54 cde-sun $"
 
42
#endif
 
43
#endif
 
44
/*
 
45
*  (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */
 
46
 
 
47
#ifdef HAVE_CONFIG_H
 
48
#include <config.h>
 
49
#endif
 
50
 
 
51
 
 
52
#include <stdio.h>
 
53
#include <X11/StringDefs.h>
 
54
#include <Xm/RowColumnP.h>
 
55
#include <Xm/PushBG.h>
 
56
#include <Xm/ToggleBG.h>
 
57
#include <Xm/CascadeBG.h>
 
58
#include <Xm/LabelG.h>
 
59
#include <Xm/SeparatoG.h>
 
60
#include "XmI.h"
 
61
 
 
62
/********    Static Function Declarations    ********/
 
63
 
 
64
static void EvaluateConvenienceStructure( 
 
65
                        Widget wid,
 
66
                        XmSimpleMenu sm) ;
 
67
 
 
68
/********    End Static Function Declarations    ********/
 
69
 
 
70
static XtResource SimpleMenuResources[] =
 
71
{
 
72
        { XmNbuttonCount, XmCButtonCount, XmRInt, sizeof(int),
 
73
          XtOffsetOf( struct _XmSimpleMenuRec, count),
 
74
          XmRImmediate, (XtPointer) 0
 
75
        },
 
76
        { XmNpostFromButton, XmCPostFromButton, XmRInt, sizeof(int),
 
77
          XtOffsetOf( struct _XmSimpleMenuRec, post_from_button),
 
78
          XmRImmediate, (XtPointer) -1
 
79
        },
 
80
        { XmNsimpleCallback, XmCCallback, XmRCallbackProc, 
 
81
          sizeof(XtCallbackProc), XtOffsetOf( struct _XmSimpleMenuRec, callback),
 
82
          XmRImmediate, (XtPointer) NULL
 
83
        },
 
84
        { XmNbuttons, XmCButtons, XmRXmStringTable,
 
85
          sizeof(XmStringTable), XtOffsetOf( struct _XmSimpleMenuRec, label_string),
 
86
          XmRImmediate, (XtPointer) NULL
 
87
        },
 
88
        { XmNbuttonAccelerators, XmCButtonAccelerators, XmRStringTable, 
 
89
          sizeof(String *), XtOffsetOf( struct _XmSimpleMenuRec,  accelerator),
 
90
          XmRImmediate, (XtPointer) NULL
 
91
        },
 
92
        { XmNbuttonAcceleratorText, XmCButtonAcceleratorText, 
 
93
          XmRXmStringTable, sizeof(XmStringTable),
 
94
          XtOffsetOf( struct _XmSimpleMenuRec, accelerator_text),
 
95
          XmRImmediate, (XtPointer) NULL
 
96
        },
 
97
        { XmNbuttonMnemonics, XmCButtonMnemonics, XmRKeySymTable,
 
98
          sizeof(XmKeySymTable), XtOffsetOf( struct _XmSimpleMenuRec, mnemonic),
 
99
          XmRImmediate, (XtPointer) NULL
 
100
        },
 
101
        { XmNbuttonMnemonicCharSets, XmCButtonMnemonicCharSets, 
 
102
          XmRCharSetTable, sizeof(XmStringCharSetTable),
 
103
          XtOffsetOf( struct _XmSimpleMenuRec, mnemonic_charset),
 
104
          XmRImmediate, (XtPointer) NULL
 
105
        },
 
106
        { XmNbuttonType, XmCButtonType, XmRButtonType,
 
107
          sizeof(XmButtonTypeTable), XtOffsetOf( struct _XmSimpleMenuRec, button_type),
 
108
          XmRImmediate, (XtPointer) NULL
 
109
        },
 
110
        { XmNbuttonSet, XmCButtonSet, XmRInt,
 
111
          sizeof(int), XtOffsetOf( struct _XmSimpleMenuRec, button_set),
 
112
          XmRImmediate, (XtPointer) -1
 
113
        },
 
114
        { XmNoptionLabel, XmCOptionLabel, XmRXmString,
 
115
          sizeof(XmString), XtOffsetOf( struct _XmSimpleMenuRec, option_label),
 
116
          XmRImmediate, (XtPointer) NULL
 
117
        },
 
118
        { XmNoptionMnemonic, XmCOptionMnemonic, XmRKeySym,
 
119
          sizeof (KeySym), XtOffsetOf( struct _XmSimpleMenuRec, option_mnemonic),
 
120
          XmRImmediate, (XtPointer) NULL
 
121
        },
 
122
};
 
123
 
 
124
static void 
 
125
EvaluateConvenienceStructure(
 
126
        Widget wid,
 
127
        XmSimpleMenu sm )
 
128
{
 
129
        XmRowColumnWidget rc = (XmRowColumnWidget) wid ;
 
130
        int i, n;
 
131
        char name_buf[20];
 
132
        int button_count = 0;
 
133
        int separator_count = 0;
 
134
        int label_count = 0;
 
135
        Arg args[6];
 
136
        Widget child;
 
137
        XmButtonType btype;
 
138
 
 
139
        for (i = 0; i < sm->count; i++)
 
140
        {
 
141
                n = 0;
 
142
                if (sm->label_string && sm->label_string[i])
 
143
                {
 
144
                        XtSetArg(args[n], XmNlabelString, sm->label_string[i]);
 
145
                        n++;
 
146
                }
 
147
                if (sm->accelerator && sm->accelerator[i])
 
148
                {
 
149
                        XtSetArg(args[n], XmNaccelerator, sm->accelerator[i]);
 
150
                        n++;
 
151
                }
 
152
                if (sm->accelerator_text && sm->accelerator_text[i])
 
153
                {
 
154
                        XtSetArg(args[n], XmNacceleratorText, 
 
155
                                sm->accelerator_text[i]); 
 
156
                        n++;
 
157
                }
 
158
                if (sm->mnemonic && sm->mnemonic[i])
 
159
                {
 
160
                        XtSetArg(args[n], XmNmnemonic, sm->mnemonic[i]);
 
161
                        n++;
 
162
                }
 
163
                if (sm->mnemonic_charset && sm->mnemonic_charset[i])
 
164
                {
 
165
                        XtSetArg(args[n], XmNmnemonicCharSet, 
 
166
                                sm->mnemonic_charset[i]); 
 
167
                        n++;
 
168
                }
 
169
                
 
170
                /* Dynamic Defaulting of button type */
 
171
 
 
172
                if (sm->button_type && sm->button_type[i])
 
173
                        btype = sm->button_type[i];
 
174
                else
 
175
                        btype = XmNONE;
 
176
 
 
177
                if (btype == XmNONE)
 
178
                {
 
179
                        if (rc->row_column.type == XmMENU_BAR)
 
180
                                btype = XmCASCADEBUTTON;
 
181
                        else
 
182
                                btype = XmPUSHBUTTON;
 
183
                }
 
184
                
 
185
                switch (btype)
 
186
                {
 
187
                        case XmTITLE:
 
188
                                sprintf(name_buf,"label_%d", label_count++);
 
189
                                child = XtCreateManagedWidget( name_buf,
 
190
                                     xmLabelGadgetClass, (Widget) rc, args, n);
 
191
                        break;
 
192
                        case XmDOUBLE_SEPARATOR:
 
193
                                XtSetArg(args[n], XmNseparatorType, XmDOUBLE_LINE); n++;
 
194
                        case XmSEPARATOR:
 
195
                                sprintf(name_buf,"separator_%d", separator_count++);
 
196
                                child = XtCreateManagedWidget(name_buf, 
 
197
                                 xmSeparatorGadgetClass, (Widget) rc, args, n);
 
198
                        break;
 
199
                        case XmPUSHBUTTON:
 
200
                                sprintf(name_buf,"button_%d", button_count++);
 
201
                                child = XtCreateManagedWidget(name_buf, 
 
202
                                                       xmPushButtonGadgetClass,
 
203
                                                         (Widget) rc, args, n);
 
204
                                if (sm->callback)
 
205
                                        XtAddCallback(child,
 
206
                                             XmNactivateCallback, sm->callback,
 
207
                                               (XtPointer)(unsigned long)(button_count - 1));
 
208
                        break;
 
209
                        case XmRADIOBUTTON:
 
210
                                XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
 
211
                        case XmCHECKBUTTON:
 
212
                                sprintf(name_buf,"button_%d", button_count++);
 
213
                                XtSetArg(args[n], XmNindicatorOn, TRUE); n++;
 
214
                                child = XtCreateManagedWidget(name_buf,
 
215
                                                     xmToggleButtonGadgetClass,
 
216
                                                         (Widget) rc, args, n);
 
217
                                if (sm->callback)
 
218
                                        XtAddCallback(child,
 
219
                                         XmNvalueChangedCallback, sm->callback,
 
220
                                               (XtPointer)(unsigned long)(button_count - 1));
 
221
                        break;
 
222
                        case XmCASCADEBUTTON:
 
223
                                sprintf(name_buf,"button_%d", button_count++);
 
224
                                child = XtCreateManagedWidget(name_buf,
 
225
                                                    xmCascadeButtonGadgetClass,
 
226
                                                         (Widget) rc, args, n);
 
227
                                if (sm->callback)
 
228
                                        XtAddCallback(child,
 
229
                                             XmNactivateCallback, sm->callback,
 
230
                                               (XtPointer)(unsigned long)(button_count - 1));
 
231
                        break;
 
232
                        default:
 
233
                                /* this is an error condition */
 
234
                                ;
 
235
                        break;
 
236
                }
 
237
        }
 
238
}
 
239
 
 
240
Widget 
 
241
XmCreateSimpleMenuBar(
 
242
        Widget parent,
 
243
        String name,
 
244
        ArgList args,
 
245
        Cardinal arg_count )
 
246
{
 
247
        Widget rc;
 
248
        XmSimpleMenuRec mr;
 
249
        _XmWidgetToAppContext(parent);
 
250
 
 
251
        _XmAppLock(app);
 
252
 
 
253
        XtGetSubresources(parent, &mr, name, XmCSimpleMenuBar,
 
254
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
255
                args, arg_count);
 
256
 
 
257
        rc = XmCreateMenuBar(parent, name, args, arg_count);
 
258
 
 
259
        EvaluateConvenienceStructure( rc, &mr);
 
260
 
 
261
        _XmAppUnlock(app);
 
262
        return(rc);
 
263
}
 
264
 
 
265
Widget 
 
266
XmCreateSimplePopupMenu(
 
267
        Widget parent,
 
268
        String name,
 
269
        ArgList args,
 
270
        Cardinal arg_count )
 
271
{
 
272
        Widget rc;
 
273
        XmSimpleMenuRec mr;
 
274
        _XmWidgetToAppContext(parent);
 
275
 
 
276
        _XmAppLock(app);
 
277
 
 
278
        XtGetSubresources(parent, &mr, name, XmCSimplePopupMenu,
 
279
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
280
                args, arg_count);
 
281
 
 
282
        rc = XmCreatePopupMenu(parent, name, args, arg_count);
 
283
 
 
284
        EvaluateConvenienceStructure( rc, &mr);
 
285
 
 
286
        _XmAppUnlock(app);
 
287
        return(rc);
 
288
}
 
289
 
 
290
Widget 
 
291
XmCreateSimplePulldownMenu(
 
292
        Widget parent,
 
293
        String name,
 
294
        ArgList args,
 
295
        Cardinal arg_count )
 
296
{
 
297
        Widget rc;
 
298
        XmSimpleMenuRec mr;
 
299
        int n, i;
 
300
        Arg local_args[3];
 
301
        WidgetList buttons;
 
302
        Cardinal num_buttons;
 
303
 
 
304
        _XmWidgetToAppContext(parent);
 
305
        _XmAppLock(app);
 
306
 
 
307
        XtGetSubresources(parent, &mr, name, XmCSimplePulldownMenu,
 
308
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
309
                args, arg_count);
 
310
        
 
311
        rc = XmCreatePulldownMenu(parent, name, args, arg_count);
 
312
 
 
313
        EvaluateConvenienceStructure(rc, &mr);
 
314
 
 
315
        if (mr.post_from_button >= 0)
 
316
        {
 
317
                n = 0;
 
318
                XtSetArg(local_args[n], XtNchildren, &buttons); n++;
 
319
                XtSetArg(local_args[n], XtNnumChildren, &num_buttons); n++;
 
320
                XtGetValues(parent, local_args, n);
 
321
 
 
322
                if (!num_buttons)
 
323
                {
 
324
                        /* error condition */
 
325
                        _XmAppUnlock(app);
 
326
                        return(rc);
 
327
                }
 
328
                else
 
329
                {
 
330
                        for (i = 0; i < num_buttons; i++)
 
331
                        {
 
332
                                if (((XmIsCascadeButtonGadget(buttons[i])) ||
 
333
                                        (XmIsCascadeButton(buttons[i])))
 
334
                                        &&
 
335
                                        (i == mr.post_from_button))
 
336
                                        break;
 
337
                        }
 
338
 
 
339
                        if ( i < num_buttons)
 
340
                        {
 
341
                                n = 0;
 
342
                                XtSetArg(local_args[n], XmNsubMenuId, rc); n++;
 
343
                                XtSetValues(buttons[i], local_args, n);
 
344
                        }
 
345
                }
 
346
        }
 
347
        _XmAppUnlock(app);
 
348
        return(rc);
 
349
}
 
350
 
 
351
Widget 
 
352
XmCreateSimpleOptionMenu(
 
353
        Widget parent,
 
354
        String name,
 
355
        ArgList args,
 
356
        Cardinal arg_count )
 
357
{
 
358
        Widget rc, sub_rc;
 
359
        XmSimpleMenuRec mr;
 
360
        int n, i, button_count;
 
361
        Arg local_args[5];
 
362
        WidgetList buttons;
 
363
        Cardinal num_buttons;
 
364
        _XmWidgetToAppContext(parent);
 
365
 
 
366
        _XmAppLock(app);
 
367
 
 
368
        XtGetSubresources(parent, &mr, name, XmCSimpleOptionMenu,
 
369
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
370
                args, arg_count);
 
371
        
 
372
        rc = XmCreateOptionMenu(parent, name, args, arg_count);
 
373
 
 
374
        sub_rc = XmCreatePulldownMenu(parent, name, args, arg_count);
 
375
 
 
376
        EvaluateConvenienceStructure(sub_rc, &mr);
 
377
 
 
378
        n = 0;
 
379
        if (mr.option_label)
 
380
        {
 
381
                XtSetArg(local_args[n], XmNlabelString, mr.option_label); n++;
 
382
        }
 
383
        if (mr.option_mnemonic)
 
384
        {
 
385
                XtSetArg(local_args[n], XmNmnemonic, mr.option_mnemonic); n++;
 
386
        }
 
387
        
 
388
        XtSetArg(local_args[n], XmNsubMenuId, sub_rc); n++;
 
389
        XtSetValues(rc, local_args, n);
 
390
 
 
391
        if (mr.button_set >= 0)
 
392
        {
 
393
                n = 0;
 
394
                XtSetArg(local_args[n], XtNchildren, &buttons); n++;
 
395
                XtSetArg(local_args[n], XtNnumChildren, &num_buttons); n++;
 
396
                XtGetValues(sub_rc, local_args, n);
 
397
 
 
398
                if (!num_buttons)
 
399
                {
 
400
                        /* error condition */
 
401
                        _XmAppUnlock(app);
 
402
                        return(rc);
 
403
                }
 
404
                else
 
405
                {
 
406
                        button_count = 0;
 
407
                        for (i = 0; i < num_buttons; i++)
 
408
                        {                               /* count only PushB */
 
409
                                if ((XmIsPushButtonGadget(buttons[i])) ||
 
410
                                        (XmIsPushButton(buttons[i])))
 
411
                                {
 
412
                                        if (button_count == mr.button_set)
 
413
                                                break;
 
414
                                        button_count++;
 
415
                                }
 
416
                        }
 
417
 
 
418
                        if ( i < num_buttons)
 
419
                        {
 
420
                                n = 0;
 
421
                                XtSetArg(local_args[n], XmNmenuHistory, buttons[i]); n++;
 
422
                                XtSetValues(rc, local_args, n);
 
423
                        }
 
424
                }
 
425
        }
 
426
 
 
427
        _XmAppUnlock(app);
 
428
        return(rc);
 
429
}
 
430
 
 
431
Widget 
 
432
XmCreateSimpleRadioBox(
 
433
        Widget parent,
 
434
        String name,
 
435
        ArgList args,
 
436
        Cardinal arg_count )
 
437
{
 
438
        Arg local_args[5];
 
439
        Widget rc, child;
 
440
        int i, n;
 
441
        XmSimpleMenuRec mr;
 
442
        char name_buf[20];
 
443
 
 
444
        rc = XmCreateRadioBox(parent, name, args, arg_count);
 
445
 
 
446
        XtGetSubresources(parent, &mr, name, XmCSimpleRadioBox,
 
447
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
448
                args, arg_count);
 
449
 
 
450
        for(i=0; i < mr.count; i++)
 
451
        {
 
452
                sprintf(name_buf,"button_%d", i);
 
453
 
 
454
                n = 0;
 
455
                if (mr.label_string && mr.label_string[i])
 
456
                {
 
457
                        XtSetArg(local_args[n], 
 
458
                                XmNlabelString, mr.label_string[i]); n++;
 
459
                }
 
460
                if (mr.button_set == i)
 
461
                {
 
462
                        XtSetArg(local_args[n], XmNset, TRUE); n++;
 
463
                }
 
464
                child = XtCreateManagedWidget(name_buf, 
 
465
                        xmToggleButtonGadgetClass, (Widget) rc, local_args, n);
 
466
                if (mr.callback)
 
467
                        XtAddCallback(child, XmNvalueChangedCallback,
 
468
                                mr.callback, (XtPointer)(unsigned long)i);
 
469
        }
 
470
        
 
471
        return(rc);
 
472
}
 
473
 
 
474
Widget 
 
475
XmCreateSimpleCheckBox(
 
476
        Widget parent,
 
477
        String name,
 
478
        ArgList args,
 
479
        Cardinal arg_count )
 
480
{
 
481
        Arg local_args[5];
 
482
        Widget rc, child;
 
483
        int i, n;
 
484
        XmSimpleMenuRec mr;
 
485
        char name_buf[20];
 
486
 
 
487
 
 
488
        rc = XmCreateRadioBox(parent, name, args, arg_count);
 
489
 
 
490
        n = 0;
 
491
        XtSetArg(local_args[n], XmNradioBehavior, FALSE); n++;
 
492
 
 
493
        XtSetValues(rc, local_args, n);
 
494
        
 
495
 
 
496
        XtGetSubresources(parent, &mr, name, XmCSimpleCheckBox,
 
497
                SimpleMenuResources, XtNumber(SimpleMenuResources), 
 
498
                args, arg_count);
 
499
 
 
500
        for(i=0; i < mr.count; i++)
 
501
        {
 
502
                sprintf(name_buf,"button_%d", i);
 
503
 
 
504
                n = 0;
 
505
                if (mr.label_string && mr.label_string[i])
 
506
                {
 
507
                        XtSetArg(local_args[n], 
 
508
                                XmNlabelString, mr.label_string[i]); n++;
 
509
                }
 
510
                child = XtCreateManagedWidget(name_buf,
 
511
                        xmToggleButtonGadgetClass, (Widget) rc, local_args, n);
 
512
                if (mr.callback)
 
513
                        XtAddCallback(child, XmNvalueChangedCallback,
 
514
                                mr.callback, (XtPointer)(unsigned long)i);
 
515
        }
 
516
 
 
517
        return(rc);
 
518
}