← Back to branch summary

~ubuntu-branches/ubuntu/utopic/gridengine/utopic

« back to all changes in this revision

Viewing changes to source/3rdparty/qmon/Xmt310/Xmt310_212.diff

  • Committer: Bazaar Package Importer
  • Author(s): Mark Hymers
  • Date: 2008-06-25 22:36:13 UTC
  • Revision ID: james.westby@ubuntu.com-20080625223613-tvd9xlhuoct9kyhm
Tags: upstream-6.2~beta2
Import upstream version 6.2~beta2

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/3rdparty/qmon/Xmt310/Xmt310_212.diff
 
1
diff -b -r xmt_212/Xmt/AskForBool.c Xmt310/Xmt/AskForBool.c
 
2
118c121
 
3
< static Cardinal button_values[] = {
 
4
---
 
5
> static int button_values[] = {
 
6
274c277
 
7
<                          long icon_type_default,
 
8
---
 
9
>                          int icon_type_default,
 
10
290c293
 
11
< long icon_type_default;
 
12
---
 
13
> int icon_type_default;
 
14
360,363c363,366
 
15
<     title = XmtCreateLocalizedXmString(w, data.title);
 
16
<     yes_label = XmtCreateLocalizedXmString(w, data.yes_label);
 
17
<     no_label = XmtCreateLocalizedXmString(w, data.no_label);
 
18
<     cancel_label = XmtCreateLocalizedXmString(w, data.cancel_label);
 
19
---
 
20
>     title = XmtCreateXmString(data.title);
 
21
>     yes_label = XmtCreateXmString(data.yes_label);
 
22
>     no_label = XmtCreateXmString(data.no_label);
 
23
>     cancel_label = XmtCreateXmString(data.cancel_label);
 
24
 
 
25
 
 
26
 
 
27
diff -b -r xmt_212/Xmt/AskForFile.c Xmt310/Xmt/AskForFile.c
 
28
23d25
 
29
< #include <Xm/List.h>
 
30
40d41
 
31
< /*     extern int errno; */
 
32
239,242c240,243
 
33
<     message = XmtCreateLocalizedXmString(w, data.message);
 
34
<     title = XmtCreateLocalizedXmString(w, data.title);
 
35
<     directory = XmtCreateLocalizedXmString(w, data.directory);
 
36
<     pattern = XmtCreateLocalizedXmString(w, data.pattern);
 
37
---
 
38
>     message = XmtCreateXmString(data.message);
 
39
>     title = XmtCreateXmString(data.title);
 
40
>     directory = XmtCreateXmString(data.directory);
 
41
>     pattern = XmtCreateXmString(data.pattern);
 
42
 
 
43
 
 
44
 
 
45
diff -b -r xmt_212/Xmt/AskForItem.c Xmt310/Xmt/AskForItem.c
 
46
< #include <Xm/List.h>
 
47
197,199c199,201
 
48
<     message = XmtCreateLocalizedXmString(w, data.message);
 
49
<     title = XmtCreateLocalizedXmString(w, data.title);
 
50
<     list_title = XmtCreateLocalizedXmString(w, data.list_title);
 
51
---
 
52
>     message = XmtCreateXmString(data.message);
 
53
>     title = XmtCreateXmString(data.title);
 
54
>     list_title = XmtCreateXmString(data.list_title);
 
55
216c218
 
56
<         item_labels[i] = XmtCreateLocalizedXmString(w, data.items[i]);
 
57
---
 
58
>       item_labels[i] = XmtCreateXmString(data.items[i]);
 
59
221c223
 
60
<         default_item_label = XmtCreateLocalizedXmString(w, buffer_return);
 
61
---
 
62
>       default_item_label = XmtCreateXmString(buffer_return);
 
63
 
 
64
 
 
65
 
 
66
diff -b -r xmt_212/Xmt/AskForString.c Xmt310/Xmt/AskForString.c
 
67
234a238
 
68
>     Widget text_widget;
 
69
323,324c327,328
 
70
<     message = XmtCreateLocalizedXmString(w, data.message);
 
71
<     title = XmtCreateLocalizedXmString(w, data.title);
 
72
---
 
73
>     message = XmtCreateXmString(data.message);
 
74
>     title = XmtCreateXmString(data.title);
 
75
 
 
76
 
 
77
 
 
78
diff -b -r xmt_212/Xmt/AssertClass.c Xmt310/Xmt/AssertClass.c
 
79
< #include <stdlib.h>
 
80
< 
 
81
36a38,39
 
82
>     extern void abort();
 
83
>     
 
84
 
 
85
 
 
86
 
 
87
diff -b -r xmt_212/Xmt/CallbackCvt.c Xmt310/Xmt/CallbackCvt.c
 
88
531d533
 
89
<    return True;
 
90
 
 
91
 
 
92
diff -b -r xmt_212/Xmt/Chooser.c Xmt310/Xmt/Chooser.c
 
93
205,206d207
 
94
< /* printf("cw->chooser.type => %d\n", cw->chooser.type); */
 
95
<     
 
96
509c510
 
97
<     size_t size = cw->chooser.num_items * cw->chooser.value_size;
 
98
---
 
99
>     int size = cw->chooser.num_items * cw->chooser.value_size;
 
100
586c587
 
101
<     static Cardinal values[] = {
 
102
---
 
103
>     static int values[] = {
 
104
817,818c818
 
105
<             item_labels[i] = XmtCreateLocalizedXmString((Widget) nw, 
 
106
<                                                 nw->chooser.strings[i]);
 
107
---
 
108
>           item_labels[i] = XmtCreateXmString(nw->chooser.strings[i]);
 
109
 
 
110
 
 
111
 
 
112
diff -b -r xmt_212/Xmt/Chooser.h Xmt310/Xmt/Chooser.h
 
113
18c21
 
114
<     XmtChooserRadioBox = 0, /* one-of-many toggles */
 
115
---
 
116
>     XmtChooserRadioBox,     /* one-of-many toggles */
 
117
 
 
118
 
 
119
 
 
120
diff -b -r xmt_212/Xmt/Cli.c Xmt310/Xmt/Cli.c
 
121
735c738
 
122
<     buf = XtMalloc(len+2);
 
123
---
 
124
>     buf = XtMalloc(len+1);
 
125
740c743
 
126
<     if (cw->cli.escape_newlines && (len > 0) && buf[len-1] == '\\') {
 
127
---
 
128
>     if (cw->cli.escape_newlines && buf[len-1] == '\\') {
 
129
974c977
 
130
<     XmString label = XmtCreateLocalizedXmString((Widget) cw, cw->cli.page_string);
 
131
---
 
132
>     XmString label = XmtCreateXmString(cw->cli.page_string);
 
133
1493,1494d1495
 
134
<     if (!s)
 
135
<       s = "";
 
136
 
 
137
 
 
138
 
 
139
diff -b -r xmt_212/Xmt/Color.c Xmt310/Xmt/Color.c
 
140
12,17d14
 
141
< /*
 
142
< ** undefine if you don't want the full colormap fix
 
143
< ** contributed by Glenn Carr 
 
144
< */
 
145
< #define CLOSEST_COLOR
 
146
< 
 
147
99,227d95
 
148
< #ifdef CLOSEST_COLOR
 
149
< 
 
150
< /* Legal Garbage:  I borrowed the basis of this code from the...
 
151
<  *
 
152
<  * The Tk Toolkit
 
153
<  * by John Ousterhout (and many others at Sun Microsystems and elsewhere)
 
154
<  * john.ousterhout@eng.sun.com
 
155
<  *
 
156
<  * This software is copyrighted by the Regents of the University of
 
157
<  * California, Sun Microsystems, Inc., and other parties.  The following
 
158
<  * terms apply to all files associated with the software unless explicitly
 
159
<  * disclaimed in individual files.
 
160
<  * 
 
161
<  * The authors hereby grant permission to use, copy, modify, distribute,
 
162
<  * and license this software and its documentation for any purpose, provided
 
163
<  * that existing copyright notices are retained in all copies and that this
 
164
<  * notice is included verbatim in any distributions. No written agreement,
 
165
<  * license, or royalty fee is required for any of the authorized uses.
 
166
<  * Modifications to this software may be copyrighted by their authors
 
167
<  * and need not follow the licensing terms described here, provided that
 
168
<  * the new terms are clearly indicated on the first page of each file where
 
169
<  * they apply.
 
170
<  * 
 
171
<  * IN NO EVENT SHALL THE AUTHORS OR DISTRIBUTORS BE LIABLE TO ANY PARTY
 
172
<  * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 
173
<  * ARISING OUT OF THE USE OF THIS SOFTWARE, ITS DOCUMENTATION, OR ANY
 
174
<  * DERIVATIVES THEREOF, EVEN IF THE AUTHORS HAVE BEEN ADVISED OF THE
 
175
<  * POSSIBILITY OF SUCH DAMAGE.
 
176
<  * 
 
177
<  * THE AUTHORS AND DISTRIBUTORS SPECIFICALLY DISCLAIM ANY WARRANTIES,
 
178
<  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY,
 
179
<  * FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.  THIS SOFTWARE
 
180
<  * IS PROVIDED ON AN "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE
 
181
<  * NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR
 
182
<  * MODIFICATIONS.
 
183
<  * 
 
184
<  * RESTRICTED RIGHTS: Use, duplication or disclosure by the government
 
185
<  * is subject to the restrictions as set forth in subparagraph (c) (1) (ii)
 
186
<  * of the Rights in Technical Data and Computer Software Clause as DFARS
 
187
<  * 252.227-7013 and FAR 52.227-19.
 
188
<  */
 
189
< 
 
190
< #if NeedFunctionPrototypes
 
191
< static void
 
192
< FindClosestColor(Screen * screen,
 
193
<                  Colormap colormap,
 
194
<                  XColor * pxcolorDesired,
 
195
<                  XColor * pxcolorActual)
 
196
< #else
 
197
< static void
 
198
< FindClosestColor(screen, colormap, pxcolorDesired, pxcolorActual)
 
199
< Screen * screen;
 
200
< Colormap colormap;
 
201
< XColor * pxcolorDesired;
 
202
< XColor * pxcolorActual;
 
203
< #endif
 
204
< {
 
205
<     float           closestDistance, distance, tmp;
 
206
<     Display        *dpy = DisplayOfScreen(screen);
 
207
<     XtAppContext    appContext = XtDisplayToApplicationContext(dpy);
 
208
<     Visual         *pvisual = XDefaultVisualOfScreen(screen);
 
209
<     static XColor  *pxcolors;
 
210
<     int             i, closest;
 
211
<     int             nColors = pvisual->map_entries;
 
212
< 
 
213
<     /*
 
214
<      * Get all the colors from the colormap.  These should all be
 
215
<      * allocated, otherwise we wouldn't be here.
 
216
<      */
 
217
<     if (NULL == pxcolors) {
 
218
<         pxcolors = calloc(nColors, sizeof(*pxcolors));
 
219
<         for (i = 0; i < nColors; i++)
 
220
<             pxcolors[i].pixel = i;
 
221
<     }
 
222
<     XQueryColors(dpy, colormap, pxcolors, pvisual->map_entries);
 
223
< 
 
224
<     while (nColors > 0) {
 
225
<         closestDistance = 1e30;
 
226
<         closest = 0;
 
227
<         for (i = 0; i < nColors; i++) {
 
228
<             /*
 
229
<              * Use Euclidean distance in RGB space, weighted by Y (of YIQ)
 
230
<              * as the objective function;  this accounts for differences
 
231
<              * in the color sensitivity of the eye.
 
232
<              */
 
233
<             tmp = .30 * (((int) pxcolorDesired->red) - (int) pxcolors[i].red);
 
234
<             distance = tmp * tmp;
 
235
<             tmp = .61 * (((int) pxcolorDesired->green) - (int) pxcolors[i].green);
 
236
<             distance += tmp * tmp;
 
237
<             tmp = .11 * (((int) pxcolorDesired->blue) - (int) pxcolors[i].blue);
 
238
<             distance += tmp * tmp;
 
239
<             if (distance < closestDistance) {
 
240
<                 closest = i;
 
241
<                 closestDistance = distance;
 
242
<             }
 
243
<         }
 
244
<         if (XAllocColor(dpy, colormap, &pxcolors[closest])) {
 
245
<             *pxcolorActual = pxcolors[closest];
 
246
<             return;
 
247
<         }
 
248
<         pxcolors[closest] = pxcolors[nColors - 1];
 
249
<         nColors -= 1;
 
250
<     }
 
251
< 
 
252
<     /*
 
253
<      * Should never get here, but just in case...
 
254
<      */
 
255
<     {
 
256
<         char            szColor[64];
 
257
<         Cardinal        num_params = 1;
 
258
<         String          params[1]; 
 
259
< 
 
260
<         params[0] = szColor;
 
261
< 
 
262
<         sprintf(szColor, "#%04x%04x%04x",
 
263
<                 pxcolorDesired->red,
 
264
<                 pxcolorDesired->green,
 
265
<                 pxcolorDesired->blue);
 
266
< 
 
267
<         XtAppWarningMsg(appContext, "badValue", "cvtStringToPixel",
 
268
<                         "FindClosestColor",
 
269
<                         "Can't find approximation for color \"%s\"",
 
270
<                         params, &num_params);
 
271
<     }
 
272
< 
 
273
< }                               /* FindClosestColor */
 
274
< 
 
275
< #endif
 
276
< 
 
277
262,265d129
 
278
< #ifdef CLOSEST_COLOR
 
279
<     Screen* screen = XtScreen(w);
 
280
< #endif
 
281
< 
 
282
304,307d167
 
283
< #ifdef CLOSEST_COLOR
 
284
<         if (XAllocColor(dpy, cmap, &c1) == 0)
 
285
<             FindClosestColor(screen, cmap, &c1, &c1);
 
286
< #else
 
287
309d168
 
288
< #endif
 
289
316,319d174
 
290
< #ifdef CLOSEST_COLOR
 
291
<         if (XAllocColor(dpy, cmap, &c1) == 0)
 
292
<             FindClosestColor(screen, cmap, &c1, &c1);
 
293
< #else
 
294
321d175
 
295
< #endif
 
296
354,360d207
 
297
< #ifdef CLOSEST_COLOR
 
298
<             if (XLookupColor(dpy, cmap, name, &c1, &c2)) {
 
299
<                 FindClosestColor(screen, cmap, &c2, &c2);
 
300
<                 *pixel_return = c2.pixel;
 
301
<                 return 0;
 
302
<             }
 
303
< #else
 
304
362d208
 
305
< #endif
 
306
368d213
 
307
< 
 
308
504c349
 
309
<          * GDI doesn't include a function for storing colors in
 
310
---
 
311
>        * API doesn't include a function for storing colors in
 
312
 
 
313
 
 
314
 
 
315
diff -b -r xmt_212/Xmt/ColorTable.c Xmt310/Xmt/ColorTable.c
 
316
180c183
 
317
<     static char name[14];
 
318
---
 
319
>     char name[14];
 
320
186d188
 
321
<     color.red = color.green = color.blue = 0;
 
322
 
 
323
 
 
324
diff -b -r xmt_212/Xmt/Converters.h Xmt310/Xmt/Converters.h
 
325
37,38c40,41
 
326
< extern void XmtRegisterEnumConverter(StringConst, String *, Cardinal *,
 
327
<                                      Cardinal, String *);
 
328
---
 
329
> extern void XmtRegisterEnumConverter(StringConst, String *, int *,
 
330
>                                    int, String *);
 
331
 
 
332
 
 
333
 
 
334
diff -b -r xmt_212/Xmt/Create.c Xmt310/Xmt/Create.c
 
335
24a28,30
 
336
> #include <unistd.h>
 
337
> 
 
338
> 
 
339
317c323
 
340
<             (*styles)[*num_styles] = style;
 
341
---
 
342
>           *styles[*num_styles] = style;
 
343
765,776c771
 
344
<     if (((CompositeWidget)shell)->composite.num_children) {
 
345
< #if XTECH 
 
346
<       /* _AA
 
347
<       ** I love Motif uaahh, for our xtech Motif(SUN4) the dialog shells
 
348
<       ** have four children for protocol stuff 
 
349
<       ** the last child is the real child of the shell 
 
350
<       ** I try this workaround
 
351
<       ** get the number of children and return the last one
 
352
<       */
 
353
<       int last = ((CompositeWidget)shell)->composite.num_children - 1;
 
354
<         return ((CompositeWidget)shell)->composite.children[last];
 
355
< #endif
 
356
---
 
357
>     if (((CompositeWidget)shell)->composite.num_children)
 
358
778d772
 
359
<    }
 
360
 
 
361
 
 
362
diff -b -r xmt_212/Xmt/Dialog.c Xmt310/Xmt/Dialog.c
 
363
97,100c100
 
364
<             if (d->types[i]->set_value_proc) {
 
365
<                   /*_AA*/
 
366
<                   if (XtIsManaged(d->widgets[i]))
 
367
<                   /*_AA*/
 
368
---
 
369
>           if (d->types[i]->set_value_proc)
 
370
104d103
 
371
<             }
 
372
107c106
 
373
<                      "Resource '%s':\n\twidget type '%s' has no set value procedure",
 
374
---
 
375
>                    "Resource '%s':\n\twidget type '%s' nas no set value procedure",
 
376
395,398c394,396
 
377
<     d->widgets = num_resources ? 
 
378
<                   (Widget *)XtCalloc(num_resources, sizeof(Widget)) : NULL;
 
379
<     d->types = num_resources ? (XmtWidgetType **)
 
380
<         XtCalloc(num_resources, sizeof(XmtWidgetType *)) : NULL;
 
381
---
 
382
>     d->widgets = (Widget *)XtCalloc(num_resources, sizeof(Widget));
 
383
>     d->types = (XmtWidgetType **)
 
384
>       XtCalloc(num_resources, sizeof(XmtWidgetType *));
 
385
 
 
386
 
 
387
 
 
388
diff -b -r xmt_212/Xmt/Dialogs.h Xmt310/Xmt/Dialogs.h
 
389
225c228
 
390
<                                 XmtButtonType, long, XmtWideBoolean, Boolean *,
 
391
---
 
392
>                               XmtButtonType, int, XmtWideBoolean, Boolean *,
 
393
 
 
394
 
 
395
 
 
396
diff -b -r xmt_212/Xmt/EnumCvt.c Xmt310/Xmt/EnumCvt.c
 
397
18,19c21,22
 
398
<                                XrmValuePtr args, Cardinal *num_args,
 
399
<                                XrmValuePtr from, XrmValuePtr to, XtPointer *data)
 
400
---
 
401
>                              XrmValue *args, Cardinal *num_args,
 
402
>                              XrmValue *from, XrmValue *to, XtPointer *data)
 
403
23c26
 
404
< XrmValuePtr args;
 
405
---
 
406
> XrmValue *args;
 
407
25,26c28,29
 
408
< XrmValuePtr from;
 
409
< XrmValuePtr to;
 
410
---
 
411
> XrmValue *from;
 
412
> XrmValue *to;
 
413
32,35c35,36
 
414
< /*     Cardinal *values = *(Cardinal**)args[2].addr; */
 
415
< /*     Cardinal num = (Cardinal)*(XtPointer*)args[3].addr; */
 
416
<     Cardinal *values = (Cardinal*)*(XtPointer*)args[2].addr;
 
417
<     Cardinal num = (Cardinal)*(XtPointer*)args[3].addr;
 
418
---
 
419
>     int *values = *(int **)args[2].addr;
 
420
>     int num = *(int *)args[3].addr;
 
421
40c41
 
422
<     static Cardinal value;  /* static for converter return */
 
423
---
 
424
>     static int value;  /* static for converter return */
 
425
61,63d61
 
426
< 
 
427
< /* printf("XmtBSearch(target, names, num) => %d\n", i); */
 
428
< 
 
429
80,84d77
 
430
< #ifdef CRAY /* short and int are the same size (8 bytes) on the Cray */
 
431
<         case sizeof(int):
 
432
<             *(int *)to->addr = value;
 
433
<             break;
 
434
< #else
 
435
88,89c81,82
 
436
<         case sizeof(Cardinal):
 
437
<             *(Cardinal *)to->addr = value;
 
438
---
 
439
>       case sizeof(int):
 
440
>           *(int *)to->addr = value;
 
441
91d83
 
442
< #endif
 
443
93,95c85,87
 
444
<             if (to->size > sizeof(Cardinal)) {
 
445
<                 to->size = sizeof(Cardinal);
 
446
<                 *(Cardinal *)to->addr = value;
 
447
---
 
448
>           if (to->size > sizeof(int)) {
 
449
>               to->size = sizeof(int);
 
450
>               *(int *)to->addr = value;
 
451
98c90
 
452
<                 to->size = sizeof(Cardinal);
 
453
---
 
454
>               to->size = sizeof(int);
 
455
113,114c105,106
 
456
< void XmtRegisterEnumConverter(StringConst type, String *names, Cardinal *values,
 
457
<                               Cardinal num, String *prefixes)
 
458
---
 
459
> void XmtRegisterEnumConverter(StringConst type, String *names, int *values,
 
460
>                             int num, String *prefixes)
 
461
119,120c111,112
 
462
< Cardinal *values;
 
463
< Cardinal num;
 
464
---
 
465
> int *values;
 
466
> int num;
 
467
 
 
468
 
 
469
 
 
470
diff -b -r xmt_212/Xmt/FindFile.c Xmt310/Xmt/FindFile.c
 
471
18d20
 
472
< #include <stdlib.h>
 
473
20,22d21
 
474
< #include <stdlib.h>
 
475
< #include <unistd.h>
 
476
< 
 
477
34,35d32
 
478
< /* _AA */
 
479
< #if 0
 
480
39d35
 
481
< #endif 
 
482
41d36
 
483
< 
 
484
44d38
 
485
< #include <unistd.h>
 
486
59a54
 
487
>     extern uid_t getuid();
 
488
61a57
 
489
>     extern int getuid();
 
490
91,93d86
 
491
< #ifdef NeedFunctionPrototypes
 
492
< static Boolean DebugPredicate(String path)
 
493
< #else
 
494
96d88
 
495
< #endif
 
496
 
 
497
 
 
498
 
 
499
diff -b -r xmt_212/Xmt/FontListCvt.c Xmt310/Xmt/FontListCvt.c
 
500
40d42
 
501
< #if 0    
 
502
42,49d43
 
503
<     XFontSet fontset;
 
504
<     char **missing_list;
 
505
<     int missing_count;
 
506
<     int i;
 
507
<     char *def_string = NULL; 
 
508
< #endif    
 
509
<     XmFontListEntry entry;
 
510
<     
 
511
118,119d111
 
512
<    if (next_entry == NULL)
 
513
<       next_entry = strchr(s, ':');
 
514
151,181d142
 
515
< #if 0
 
516
<    /*
 
517
<    ** fontset support it is a bit tricky, but needed for multibyte chars
 
518
<    ** FIXME: figure out how to do it
 
519
<    */
 
520
< 
 
521
<         fontset = XCreateFontSet(dpy, s, &missing_list, &missing_count,
 
522
<                                  &def_string);
 
523
<         for (i=0; i<missing_count; i++) {
 
524
<             printf("missing_list[%d]: '%s'\n", i, missing_list[i]);
 
525
<             XtFree(missing_list[i]);
 
526
<         }    
 
527
<         XtFree((char *)missing_list);
 
528
< #if  !defined(SOLARIS) && !defined(SOLARIS64)
 
529
<         entry = XmFontListEntryLoad(dpy, s, XmFONT_IS_FONT, tag);
 
530
< #else        
 
531
<         entry = XmFontListEntryLoad(dpy, s, XmFONT_IS_FONTSET, tag);
 
532
< #endif        
 
533
< 
 
534
< #endif
 
535
<         /*
 
536
<         ** FIXME: replace the following line with the correct version
 
537
<         **        for multibyte chars and fontsets
 
538
<         */
 
539
<         entry = XmFontListEntryLoad(dpy, s, XmFONT_IS_FONT, tag);
 
540
< 
 
541
<         fontlist = XmFontListAppendEntry(fontlist, entry);
 
542
<         XmFontListEntryFree(&entry);
 
543
<         
 
544
< 
 
545
< #if 0
 
546
188d148
 
547
< 
 
548
204d163
 
549
< #endif
 
550
 
 
551
 
 
552
 
 
553
diff -b -r xmt_212/Xmt/GetPixmap.c Xmt310/Xmt/GetPixmap.c
 
554
14,16d16
 
555
< #include <stdlib.h>
 
556
< #include <unistd.h>
 
557
< 
 
558
60a61
 
559
>     extern char *getenv();
 
560
 
 
561
 
 
562
 
 
563
diff -b -r xmt_212/Xmt/HSLtoRGB.c Xmt310/Xmt/HSLtoRGB.c
 
564
< #include <Xmt/Xmt.h>
 
565
< 
 
566
 
 
567
 
 
568
 
 
569
diff -b -r xmt_212/Xmt/Hash.c Xmt310/Xmt/Hash.c
 
570
28,30c31,33
 
571
<     long size;                   /* log2 of the size */
 
572
<     long mask;                   /* Current size of hash table minus 1. */
 
573
<     long numentries;             /* Number of entries currently in table. */
 
574
---
 
575
>     int size;                   /* log2 of the size */
 
576
>     int mask;                 /* Current size of hash table minus 1. */
 
577
>     int numentries;           /* Number of entries currently in table. */
 
578
35c38
 
579
<     (ht)->table[(((long)(key)) >> 2) & (ht)->mask]
 
580
---
 
581
>     (ht)->table[(((int)(key)) >> 2) & (ht)->mask]
 
582
46c49
 
583
<     long otablesize;
 
584
---
 
585
>     int otablesize;
 
586
48c51
 
587
<     register long i;
 
588
---
 
589
>     register int i;
 
590
94c97
 
591
<     register long i;
 
592
---
 
593
>     register int i;
 
594
115c118
 
595
<     register long i;
 
596
---
 
597
>     register int i;
 
598
 
 
599
 
 
600
 
 
601
diff -b -r xmt_212/Xmt/HelpBox.c Xmt310/Xmt/HelpBox.c
 
602
201,202c204,205
 
603
<     int lines = 0;
 
604
<     Dimension width = 0, height = 0;
 
605
---
 
606
>     int lines;
 
607
>     Dimension width, height;
 
608
237,238c240
 
609
< /*AA*/    
 
610
<     height = ((int)(height-4) * hb->help_box.visible_lines) / (lines + 4);
 
611
---
 
612
>     height = ((int)(height-4) * hb->help_box.visible_lines) / lines + 4;
 
613
 
 
614
 
 
615
 
 
616
diff -b -r xmt_212/Xmt/HelpBrowser.c Xmt310/Xmt/HelpBrowser.c
 
617
422c425
 
618
<     label = XmtCreateLocalizedXmString(w, hb->help_browser.toc_label);
 
619
---
 
620
>     label = XmtCreateXmString(hb->help_browser.toc_label);
 
621
435c438
 
622
<     label = XmtCreateLocalizedXmString(w, hb->help_browser.index_label);
 
623
---
 
624
>     label = XmtCreateXmString(hb->help_browser.index_label);
 
625
465c468
 
626
<     label = XmtCreateLocalizedXmString(w, hb->help_browser.crossref_label);
 
627
---
 
628
>     label = XmtCreateXmString(hb->help_browser.crossref_label);
 
629
568c571
 
630
<         (XtArgVal)XmtCreateLocalizedXmString(w, hb->help_browser.next_label);
 
631
---
 
632
>       (XtArgVal)XmtCreateXmString(hb->help_browser.next_label);
 
633
574c577
 
634
<         (XtArgVal)XmtCreateLocalizedXmString(w, hb->help_browser.prev_label);
 
635
---
 
636
>       (XtArgVal)XmtCreateXmString(hb->help_browser.prev_label);
 
637
580c583
 
638
<         (XtArgVal)XmtCreateLocalizedXmString(w, hb->help_browser.done_label);
 
639
---
 
640
>       (XtArgVal)XmtCreateXmString(hb->help_browser.done_label);
 
641
1318c1321
 
642
<         label = XmtCreateLocalizedXmString((Widget) sw, sw->help_browser.next_label);
 
643
---
 
644
>       label = XmtCreateXmString(sw->help_browser.next_label);
 
645
1324c1327
 
646
<         label = XmtCreateLocalizedXmString((Widget) sw, sw->help_browser.prev_label);
 
647
---
 
648
>       label = XmtCreateXmString(sw->help_browser.prev_label);
 
649
1330c1333
 
650
<         label = XmtCreateLocalizedXmString((Widget) sw, sw->help_browser.done_label);
 
651
---
 
652
>       label = XmtCreateXmString(sw->help_browser.done_label);
 
653
 
 
654
 
 
655
 
 
656
diff -b -r xmt_212/Xmt/HelpNode.c Xmt310/Xmt/HelpNode.c
 
657
310,311d312
 
658
< /*     extern int errno; */
 
659
<     
 
660
 
 
661
 
 
662
 
 
663
diff -b -r xmt_212/Xmt/IBMManage.c Xmt310/Xmt/IBMManage.c
 
664
51c54
 
665
< #include <X11/IntrinsicP.h>
 
666
---
 
667
> #include "IntrinsicP.h"
 
668
 
 
669
 
 
670
diff -b -r xmt_212/Xmt/Include.c Xmt310/Xmt/Include.c
 
671
31d33
 
672
< /*     extern int errno; */
 
673
60c62
 
674
<     static Boolean required_quarks_inited = False;
 
675
---
 
676
>     static required_quarks_inited = False;
 
677
70c72
 
678
<     XtPointer dummy = NULL;
 
679
---
 
680
>     XtPointer dummy;
 
681
 
 
682
 
 
683
 
 
684
diff -b -r xmt_212/Xmt/InputField.c Xmt310/Xmt/InputField.c
 
685
13a17
 
686
> #include <string.h>
 
687
267c271
 
688
< #if NeedFunctionPrototypes
 
689
---
 
690
> #if NeedFunctionPrototype
 
691
284a289,296
 
692
> /* ARGSUSED */
 
693
> #if NeedFunctionPrototypes
 
694
> static int isoctal(int c)
 
695
> #else
 
696
> static int isoctal(c)
 
697
> int c;
 
698
> #endif
 
699
> {
 
700
285a298,300
 
701
>     return (int)(strchr ("01234567", c));
 
702
> }
 
703
> 
 
704
287a303,313
 
705
> static int ishex(int c)
 
706
> #else
 
707
> static int ishex(c)
 
708
> int c;
 
709
> #endif
 
710
> {
 
711
>     return (int)(strchr ("0123456789abcdefABCDEF", c));
 
712
> }
 
713
> 
 
714
> /* ARGSUSED */
 
715
> #if NeedFunctionPrototypes
 
716
325c351,353
 
717
<                     ((*c >= 'A')&&(*c <= 'C')))
 
718
---
 
719
>                   ((*c >= 'A')&&(*c <= 'C')) ||
 
720
>                   (*c == 'h') ||
 
721
>                   (*c == 'o'))
 
722
370a399,404
 
723
>         case 'o':
 
724
>         if (!isoctal(*c)) data->doit = False;
 
725
>         break;
 
726
>         case 'h':
 
727
>         if (!ishex(*c)) data->doit = False;
 
728
>           break;
 
729
706d739
 
730
<     if (input)
 
731
708,709d740
 
732
<     else 
 
733
<       input_length = 0; 
 
734
904,909c935,936
 
735
<     /* 
 
736
<     ** if there is a pattern, get its length. Copy it, because it is
 
737
<     ** free'd in the SetValue() and Destroy() routines
 
738
<     */
 
739
<     if (iw->input_field.pattern) {
 
740
<         iw->input_field.pattern = XtNewString(iw->input_field.pattern);
 
741
---
 
742
>     /* if there is a pattern, get its length */
 
743
>     if (iw->input_field.pattern)
 
744
911d937
 
745
<     }
 
746
1163c1189
 
747
<     if (iw->input_field.input) {
 
748
---
 
749
>     if (iw->input_field.input)
 
750
1165,1166d1190
 
751
<         iw->input_field.input = NULL;
 
752
<     }
 
753
1171d1194
 
754
< 
 
755
1236,1241d1258
 
756
<     /*
 
757
<     ** changed by _AA, there was no test if s is not NULL, if 
 
758
<     ** yes everything works, but if s == NULL tha atoi() calls 
 
759
<     ** fail on some architectures
 
760
<     */
 
761
<     if (!s) {
 
762
1243,1280d1259
 
763
<            *(String *)address = NULL;
 
764
<        else if (type == XmtQBuffer) {
 
765
<              strncpy(address, "", size-1);
 
766
<            ((char *)address)[size-1] = '\0';
 
767
<        }
 
768
<        /* XXX
 
769
<         * unsigned values should be handled better here.
 
770
<         * the XmtInputField should also probably have resources to
 
771
<         * set that will automatically verify that the value is valid.
 
772
<         */
 
773
<        else if ((type == XmtQShort) || (type == XmtQPosition) ||
 
774
<                 (type == XmtQDimension))
 
775
<            *(short *)address = 0;
 
776
<        else if ((type == XmtQInt) || (type == XmtQCardinal))
 
777
<            *(int *)address = 0;
 
778
<        else if (type == XmtQFloat)
 
779
<            *(float *)address = 0.0;
 
780
<        else if (type == XmtQDouble)
 
781
<            *(double *)address = 0.0;
 
782
<        else
 
783
<            XmtWarningMsg("XmtInputField", "getvalue",
 
784
<                          "Type mismatch:\n\tCan't set input value on a resource of type '%s'.  String or Buffer expected.",
 
785
<                          XrmQuarkToString(type));
 
786
< 
 
787
< 
 
788
<        return;
 
789
<     }
 
790
<       
 
791
<    
 
792
< /* printf("XrmQuark type %d %s '%s'\n", type, XrmQuarkToString(type), s); */
 
793
< 
 
794
< 
 
795
< /*
 
796
< ** Changed by _AA, we get a copy of the string of an input field
 
797
< ** cause with this statement the memory gets corrupted in using
 
798
< ** XmtDialogSetDialogValues
 
799
< **
 
800
<     if (type == XmtQString)
 
801
1282,1284d1260
 
802
< */
 
803
<     if (type == XmtQString)
 
804
<         *(String *)address = XtNewString(s);
 
805
 
 
806
 
 
807
 
 
808
diff -b -r xmt_212/Xmt/InputFieldP.h Xmt310/Xmt/InputFieldP.h
 
809
55,56c58,59
 
810
<     Cardinal pattern_length;   /* strlen(pattern); */
 
811
<     Cardinal pattern_skip;     /* state variable for HandlePattern() */
 
812
---
 
813
>     short pattern_length;   /* strlen(pattern); */
 
814
>     short pattern_skip;     /* state variable for HandlePattern() */
 
815
61c64
 
816
<     Cardinal max_length;         /* used with overstrike mode */
 
817
---
 
818
>     int max_length;         /* used with overstrike mode */
 
819
 
 
820
 
 
821
 
 
822
diff -b -r xmt_212/Xmt/Layout.c Xmt310/Xmt/Layout.c
 
823
22,24d24
 
824
< #if (XmVersion >= 2000)
 
825
< #include <Xm/RowColumnP.h>  /* declaration of Motif drawing routines */
 
826
< #endif
 
827
262c262
 
828
<     static Cardinal justification_values[] = {
 
829
---
 
830
>     static int justification_values[] = {
 
831
270c270
 
832
<     static Cardinal edge_values[] = {
 
833
---
 
834
>     static int edge_values[] = {
 
835
279c279
 
836
<     static Cardinal line_type_values[] = {
 
837
---
 
838
>     static int line_type_values[] = {
 
839
289c289
 
840
<     static Cardinal frame_type_values[] = {
 
841
---
 
842
>     static int frame_type_values[] = {
 
843
296c296
 
844
<     static Cardinal position_values[] = {
 
845
---
 
846
>     static int position_values[] = {
 
847
303c303
 
848
<     static Cardinal space_type_values[] = {
 
849
---
 
850
>     static int space_type_values[] = {
 
851
445a446,449
 
852
> #if (XmVersion >= 2001)
 
853
>                   XmRenderTableAddRenditions(NULL, &rendition, 1,
 
854
>                                              XmMERGE_REPLACE);
 
855
> #else
 
856
446a451
 
857
> #endif
 
858
690a696,698
 
859
> #if (XmVersion >= 2001)
 
860
>            XmRenderTableAddRenditions(NULL, &rendition, 1, XmMERGE_REPLACE);
 
861
> #else
 
862
691a700
 
863
> #endif
 
864
805,810d813
 
865
< /* _AA 
 
866
<    printf("+++++++++++++++++++++++++++++\n");
 
867
<    printf("lw/lw->layout.toplevel: 0x%x/0x%x/%s\n", 
 
868
<             lw, lw->layout.toplevel, XtName(lw->layout.toplevel));
 
869
<    printf("+++++++++++++++++++++++++++++\n");
 
870
<  _AA */
 
871
1044,1046c1047,1049
 
872
<     int x=0, y=0, w=0, h=0;      /* coordinates of widget */
 
873
<     int fx=0, fy=0, fw=0, fh=0;  /* coordinates of outside of frame */
 
874
<     int cx=0, cy=0, cw=0, ch=0;  /* coordinates of caption bounding box*/
 
875
---
 
876
>     int x, y, w, h;      /* coordinates of widget */
 
877
>     int fx, fy, fw, fh;  /* coordinates of outside of frame */
 
878
>     int cx, cy, cw, ch;  /* coordinates of caption bounding box*/
 
879
1053c1056
 
880
<     int caption_total_width=0, caption_total_height=0;
 
881
---
 
882
>     int caption_total_width, caption_total_height;
 
883
1067,1068c1070,1071
 
884
<     frame_type = (XmtLayoutFrameType) cc->frame_type;
 
885
<     frame_line_type = (XmtLayoutFrameLineType) cc->frame_line_type;
 
886
---
 
887
>     frame_type = cc->frame_type;
 
888
>     frame_line_type = cc->frame_line_type;
 
889
1071c1074
 
890
<     frame_position = (XmtLayoutFramePosition) cc->frame_position;
 
891
---
 
892
>     frame_position = cc->frame_position;
 
893
1383c1386,1387
 
894
<     Dimension width, height;
 
895
---
 
896
>     Position x,y;
 
897
>     Dimension width, height, border_width;
 
898
1456c1460
 
899
<     if ((request->request_mode & (CWWidth | CWHeight)) == (CWWidth | CWHeight)
 
900
---
 
901
>     if (request->request_mode & (CWWidth | CWHeight) == (CWWidth | CWHeight)
 
902
2028c2032
 
903
<                       "Widget %s: can't set XtNx or XtNy resources of a child of\n\tan XmtLayout widget.  Changes ignored.", XtName((Widget) set));
 
904
---
 
905
>                     "Widget %s: can't set XtNx or XtNy resources of a child of\n\tan XmtLayout widget.  Changes ignored.");
 
906
 
 
907
 
 
908
 
 
909
diff -b -r xmt_212/Xmt/LayoutBox.c Xmt310/Xmt/LayoutBox.c
 
910
23,27d25
 
911
< #if _AA 
 
912
< {XmNbackgroundPixmap, XmCPixmap, XtRPixmap,
 
913
<      sizeof(Pixmap), offset(backgroundPixmap),
 
914
<      XtRImmediate, (XtPointer) None},
 
915
< #endif
 
916
130,139d127
 
917
< #if _AA
 
918
<    if (lb->layout_box.backgroundPixmap != None &&
 
919
<          lb->layout_box.backgroundPixmap != XtUnspecifiedPixmap) {
 
920
<       XGCValues gcv;
 
921
<       gcv.tile = lb->layout_box.backgroundPixmap;
 
922
<       gcv.fill_style = FillTiled;
 
923
<       lb->layout_box.gc = XtGetGC(init, GCTile|GCFillStyle, &gcv);
 
924
<    }
 
925
<    else if (lb->layout_box.background != (Pixel)-1) {
 
926
< #else
 
927
141d128
 
928
< #endif
 
929
289,290c276,277
 
930
<         frame_type = (XmtLayoutFrameType) cc->frame_type;
 
931
<         frame_position = (XmtLayoutFramePosition) cc->frame_position;
 
932
---
 
933
>       frame_type = cc->frame_type;
 
934
>       frame_position = cc->frame_position;
 
935
371,372c358,359
 
936
<         frame_type = (XmtLayoutFrameType) cc->frame_type;
 
937
<         frame_position = (XmtLayoutFramePosition) cc->frame_position;
 
938
---
 
939
>       frame_type = cc->frame_type;
 
940
>       frame_position = cc->frame_position;
 
941
474,477c461,464
 
942
<     int major_start = 0, minor_start = 0;    /* instead of x, y */
 
943
<     int major_length = 0, minor_length = 0;  /* instead of width, height */
 
944
<     int cx = 0, cy = 0;  /* child x, y */
 
945
<     int cw = 0, ch = 0;  /* child w, h */
 
946
---
 
947
>     int major_start, minor_start;    /* instead of x, y */
 
948
>     int major_length, minor_length;  /* instead of width, height */
 
949
>     int cx, cy;  /* child x, y */
 
950
>     int cw, ch;  /* child w, h */
 
951
481c468
 
952
<     int margin_width = 0, margin_height = 0, top_margin = 0, left_margin = 0;
 
953
---
 
954
>     int margin_width, margin_height, top_margin, left_margin;
 
955
484c471
 
956
<     int total_space, space, interval=0;
 
957
---
 
958
>     int total_space, space, interval;
 
959
496,499c483,484
 
960
<         cmajor0 = &cx; 
 
961
<    cminor0 = &cy;
 
962
<         cmajorlen = &cw; 
 
963
<    cminorlen = &ch;
 
964
---
 
965
>       cmajor0 = &cx; cminor0 = &cy;
 
966
>       cmajorlen = &cw; cminorlen = &ch;
 
967
508,511c493,494
 
968
<         cmajor0 = &cy; 
 
969
<    cminor0 = &cx;
 
970
<         cmajorlen = &ch; 
 
971
<    cminorlen = &cw;
 
972
---
 
973
>       cmajor0 = &cy; cminor0 = &cx;
 
974
>       cmajorlen = &ch; cminorlen = &cw;
 
975
 
 
976
 
 
977
 
 
978
diff -b -r xmt_212/Xmt/LayoutGP.h Xmt310/Xmt/LayoutGP.h
 
979
116,118d118
 
980
< #if _AA
 
981
<     Pixmap backgroundPixmap;
 
982
< #endif
 
983
 
 
984
 
 
985
 
 
986
diff -b -r xmt_212/Xmt/LayoutParse.c Xmt310/Xmt/LayoutParse.c
 
987
359,360c362
 
988
<         i->constraints.caption = XmtCreateLocalizedXmString((Widget)lw, 
 
989
<                                                             GetStrValue());
 
990
---
 
991
>       i->constraints.caption = XmtCreateXmString(GetStrValue());
 
992
 
 
993
 
 
994
 
 
995
diff -b -r xmt_212/Xmt/LayoutString.c Xmt310/Xmt/LayoutString.c
 
996
216c219
 
997
<             XmtCreateLocalizedXmString((Widget) lw, ls->layout_string.label);
 
998
---
 
999
>           XmtCreateXmString(ls->layout_string.label);
 
1000
261d263
 
1001
<     Dimension cs_width, cs_height;
 
1002
269,270d270
 
1003
<         cs_width  = cs->layout_string.width;
 
1004
<         cs_height = cs->layout_string.height;
 
1005
272,273d271
 
1006
<         if (cs_width  != ss->layout_string.width ||
 
1007
<                 cs_height != ss->layout_string.height)
 
1008
275,276d272
 
1009
<         else  
 
1010
<             redisplay = True;
 
1011
282c278
 
1012
<             XmtCreateLocalizedXmString((Widget) lw, ss->layout_string.label);
 
1013
---
 
1014
>           XmtCreateXmString(ss->layout_string.label);
 
1015
284,285d279
 
1016
<         cs_width  = cs->layout_string.width;
 
1017
<         cs_height = cs->layout_string.height;
 
1018
287,288d280
 
1019
<         if (cs_width  != ss->layout_string.width ||
 
1020
<                 cs_height != ss->layout_string.height)
 
1021
290,291d281
 
1022
<         else
 
1023
<             redisplay = True;
 
1024
327,330c317
 
1025
<     if (redisplay && XtIsRealized((Widget)lw)) {
 
1026
<          Redisplay((Widget)ss, (XEvent *)NULL, (Region)NULL);
 
1027
<     }
 
1028
<     else if ( relayout && XtIsRealized((Widget)lw)) {
 
1029
---
 
1030
>     if ((redisplay | relayout) && XtIsRealized((Widget)lw))
 
1031
335d321
 
1032
<     }
 
1033
 
 
1034
 
 
1035
 
 
1036
Only in xmt_212/Xmt: Makefile
 
1037
 
 
1038
diff -b -r xmt_212/Xmt/Makefile.aimk Xmt310/Xmt/Makefile.aimk
 
1039
7c7
 
1040
< XMT_SDIR = ../xmt_212/Xmt
 
1041
---
 
1042
> XMT_SDIR = ../qmon/Xmt310/Xmt
 
1043
9,10d8
 
1044
< XMTFLAGS = $(CFLAGS) -I../xmt_212
 
1045
< 
 
1046
276d273
 
1047
< XMTLIB      = libXmt$(LIBEXT)
 
1048
278c275
 
1049
< all: $(XMTLIB)
 
1050
---
 
1051
> all: libXmt.a
 
1052
284,286d280
 
1053
< libXmt$(SHAREDEXT): $(XMT_OBJS) $(XMT_UNSHAREDOBJS)
 
1054
<       $(SHAREDLD) $(XLFLAGS) $(SHARED_LFLAGS) -o libXmt$(SHAREDEXT) $(XMT_OBJS) $(XMT_UNSHAREDOBJS) $(XLIBS)
 
1055
< 
 
1056
292c286
 
1057
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/All.c 
 
1058
---
 
1059
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/All.c 
 
1060
294c288
 
1061
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AppRes.c 
 
1062
---
 
1063
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AppRes.c 
 
1064
296c290
 
1065
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AskForBool.c 
 
1066
---
 
1067
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AskForBool.c 
 
1068
298c292
 
1069
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AskForFile.c 
 
1070
---
 
1071
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AskForFile.c 
 
1072
300c294
 
1073
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AskForItem.c 
 
1074
---
 
1075
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AskForItem.c 
 
1076
302c296
 
1077
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AskForString.c 
 
1078
---
 
1079
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AskForString.c 
 
1080
304c298
 
1081
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/AssertClass.c 
 
1082
---
 
1083
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/AssertClass.c 
 
1084
306c300
 
1085
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/BSearch.c 
 
1086
---
 
1087
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/BSearch.c 
 
1088
308c302
 
1089
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/BitmapCvt.c 
 
1090
---
 
1091
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/BitmapCvt.c 
 
1092
310c304
 
1093
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Block.c 
 
1094
---
 
1095
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Block.c 
 
1096
312c306
 
1097
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/CallbackCvt.c 
 
1098
---
 
1099
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/CallbackCvt.c 
 
1100
314c308
 
1101
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/CheckFormat.c 
 
1102
---
 
1103
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/CheckFormat.c 
 
1104
316c310
 
1105
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Chooser.c 
 
1106
---
 
1107
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Chooser.c 
 
1108
318c312
 
1109
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Cli.c 
 
1110
---
 
1111
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Cli.c 
 
1112
320c314
 
1113
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Color.c 
 
1114
---
 
1115
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Color.c 
 
1116
322c316
 
1117
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ColorTable.c 
 
1118
---
 
1119
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ColorTable.c 
 
1120
324c318
 
1121
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ColorTblCvt.c 
 
1122
---
 
1123
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ColorTblCvt.c 
 
1124
326c320
 
1125
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ContextHelp.c 
 
1126
---
 
1127
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ContextHelp.c 
 
1128
328c322
 
1129
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Create.c 
 
1130
---
 
1131
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Create.c 
 
1132
330c324
 
1133
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Cursor.c 
 
1134
---
 
1135
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Cursor.c 
 
1136
332c326
 
1137
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/DECHack.c 
 
1138
---
 
1139
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/DECHack.c 
 
1140
334c328
 
1141
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Dialog.c 
 
1142
---
 
1143
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Dialog.c 
 
1144
336c330
 
1145
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/DialogPos.c 
 
1146
---
 
1147
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/DialogPos.c 
 
1148
338c332
 
1149
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Dialogs.c 
 
1150
---
 
1151
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Dialogs.c 
 
1152
340c334
 
1153
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Discard.c 
 
1154
---
 
1155
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Discard.c 
 
1156
342c336
 
1157
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/EnumCvt.c 
 
1158
---
 
1159
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/EnumCvt.c 
 
1160
344c338
 
1161
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/FindFile.c 
 
1162
---
 
1163
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/FindFile.c 
 
1164
346c340
 
1165
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/FontListCvt.c 
 
1166
---
 
1167
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/FontListCvt.c 
 
1168
348c342
 
1169
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/GetPixmap.c 
 
1170
---
 
1171
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/GetPixmap.c 
 
1172
350c344
 
1173
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HSLtoRGB.c 
 
1174
---
 
1175
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HSLtoRGB.c 
 
1176
352c346
 
1177
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Hash.c 
 
1178
---
 
1179
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Hash.c 
 
1180
354c348
 
1181
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HelpBox.c 
 
1182
---
 
1183
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HelpBox.c 
 
1184
356c350
 
1185
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HelpBrowser.c 
 
1186
---
 
1187
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HelpBrowser.c 
 
1188
358c352
 
1189
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HelpNode.c 
 
1190
---
 
1191
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HelpNode.c 
 
1192
360c354
 
1193
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/IBMManage.c 
 
1194
---
 
1195
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/IBMManage.c 
 
1196
362c356
 
1197
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Icon.c 
 
1198
---
 
1199
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Icon.c 
 
1200
364c358
 
1201
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Icons.c 
 
1202
---
 
1203
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Icons.c 
 
1204
366c360
 
1205
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Include.c 
 
1206
---
 
1207
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Include.c 
 
1208
368c362
 
1209
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/InitFocus.c 
 
1210
---
 
1211
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/InitFocus.c 
 
1212
370c364
 
1213
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Initialize.c 
 
1214
---
 
1215
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Initialize.c 
 
1216
372c366
 
1217
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/InputField.c 
 
1218
---
 
1219
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/InputField.c 
 
1220
374c368
 
1221
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Layout.c 
 
1222
---
 
1223
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Layout.c 
 
1224
376c370
 
1225
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutBox.c 
 
1226
---
 
1227
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutBox.c 
 
1228
378c372
 
1229
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutCreate.c 
 
1230
---
 
1231
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutCreate.c 
 
1232
380c374
 
1233
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutGadget.c 
 
1234
---
 
1235
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutGadget.c 
 
1236
382c376
 
1237
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutParse.c 
 
1238
---
 
1239
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutParse.c 
 
1240
384c378
 
1241
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutPixmap.c 
 
1242
---
 
1243
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutPixmap.c 
 
1244
386c380
 
1245
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutSep.c 
 
1246
---
 
1247
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutSep.c 
 
1248
388c382
 
1249
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutSpace.c 
 
1250
---
 
1251
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutSpace.c 
 
1252
390c384
 
1253
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutString.c 
 
1254
---
 
1255
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutString.c 
 
1256
392c386
 
1257
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Lexer.c 
 
1258
---
 
1259
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Lexer.c 
 
1260
394c388
 
1261
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Localize.c 
 
1262
---
 
1263
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Localize.c 
 
1264
396c390
 
1265
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Lookup.c 
 
1266
---
 
1267
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Lookup.c 
 
1268
398c392
 
1269
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Menu.c 
 
1270
---
 
1271
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Menu.c 
 
1272
400c394
 
1273
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MenuCvt.c 
 
1274
---
 
1275
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MenuCvt.c 
 
1276
402c396
 
1277
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MotifWidgets.c 
 
1278
---
 
1279
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MotifWidgets.c 
 
1280
404c398
 
1281
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MsgDialogs.c 
 
1282
---
 
1283
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MsgDialogs.c 
 
1284
406c400
 
1285
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MsgLine.c 
 
1286
---
 
1287
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MsgLine.c 
 
1288
408c402
 
1289
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/NameToWidget.c 
 
1290
---
 
1291
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/NameToWidget.c 
 
1292
410c404
 
1293
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/PixelCvt.c 
 
1294
---
 
1295
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/PixelCvt.c 
 
1296
412c406
 
1297
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Pixmap.c 
 
1298
---
 
1299
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Pixmap.c 
 
1300
414c408
 
1301
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/PixmapCvt.c 
 
1302
---
 
1303
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/PixmapCvt.c 
 
1304
416c410
 
1305
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/PixmapLstCvt.c 
 
1306
---
 
1307
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/PixmapLstCvt.c 
 
1308
418c412
 
1309
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Procedures.c 
 
1310
---
 
1311
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Procedures.c 
 
1312
420c414
 
1313
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Quarks.c 
 
1314
---
 
1315
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Quarks.c 
 
1316
422c416
 
1317
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/RGBtoHSL.c 
 
1318
---
 
1319
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/RGBtoHSL.c 
 
1320
424c418
 
1321
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Screen.c 
 
1322
---
 
1323
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Screen.c 
 
1324
426c420
 
1325
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/SetValue.c 
 
1326
---
 
1327
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/SetValue.c 
 
1328
428c422
 
1329
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ShellUtil.c 
 
1330
---
 
1331
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ShellUtil.c 
 
1332
430c424
 
1333
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/StringLstCvt.c 
 
1334
---
 
1335
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/StringLstCvt.c 
 
1336
432c426
 
1337
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Symbols.c 
 
1338
---
 
1339
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Symbols.c 
 
1340
434c428
 
1341
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Template.c 
 
1342
---
 
1343
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Template.c 
 
1344
436c430
 
1345
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Visual.c 
 
1346
---
 
1347
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Visual.c 
 
1348
438c432
 
1349
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/UnixProcs.c 
 
1350
---
 
1351
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/UnixProcs.c 
 
1352
440c434
 
1353
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Wait.c 
 
1354
---
 
1355
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Wait.c 
 
1356
442c436
 
1357
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Warning.c 
 
1358
---
 
1359
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Warning.c 
 
1360
444c438
 
1361
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/WidgetCvt.c 
 
1362
---
 
1363
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/WidgetCvt.c 
 
1364
446c440
 
1365
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/WidgetType.c 
 
1366
---
 
1367
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/WidgetType.c 
 
1368
448c442
 
1369
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Working.c 
 
1370
---
 
1371
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Working.c 
 
1372
450c444
 
1373
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/WorkingBox.c 
 
1374
---
 
1375
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/WorkingBox.c 
 
1376
452c446
 
1377
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Xbm.c 
 
1378
---
 
1379
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Xbm.c 
 
1380
454c448
 
1381
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmCSText.c 
 
1382
---
 
1383
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmCSText.c 
 
1384
456c450
 
1385
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmComboBox.c 
 
1386
---
 
1387
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmComboBox.c 
 
1388
458c452
 
1389
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmScale.c 
 
1390
---
 
1391
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmScale.c 
 
1392
460c454
 
1393
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmStringCvt.c 
 
1394
---
 
1395
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmStringCvt.c 
 
1396
462c456
 
1397
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmText.c 
 
1398
---
 
1399
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmText.c 
 
1400
464c458
 
1401
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmTextField.c 
 
1402
---
 
1403
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmTextField.c 
 
1404
466c460
 
1405
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmToggleB.c 
 
1406
---
 
1407
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmToggleB.c 
 
1408
468c462
 
1409
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmtProcs.c 
 
1410
---
 
1411
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmtProcs.c 
 
1412
470c464
 
1413
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XmtWidgets.c 
 
1414
---
 
1415
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XmtWidgets.c 
 
1416
472c466
 
1417
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/Xpm.c 
 
1418
---
 
1419
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/Xpm.c 
 
1420
474c468
 
1421
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XpmParse.c 
 
1422
---
 
1423
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XpmParse.c 
 
1424
476c470
 
1425
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/XtProcs.c 
 
1426
---
 
1427
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/XtProcs.c 
 
1428
479c473
 
1429
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ConvertData.c 
 
1430
---
 
1431
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ConvertData.c 
 
1432
481c475
 
1433
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/ChooserS.c 
 
1434
---
 
1435
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/ChooserS.c 
 
1436
483c477
 
1437
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/CliS.c 
 
1438
---
 
1439
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/CliS.c 
 
1440
485c479
 
1441
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HelpBoxS.c 
 
1442
---
 
1443
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HelpBoxS.c 
 
1444
487c481
 
1445
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/HelpBrowserS.c 
 
1446
---
 
1447
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/HelpBrowserS.c 
 
1448
489c483
 
1449
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/InputFieldS.c 
 
1450
---
 
1451
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/InputFieldS.c 
 
1452
491c485
 
1453
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/LayoutS.c 
 
1454
---
 
1455
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/LayoutS.c 
 
1456
493c487
 
1457
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MenuS.c 
 
1458
---
 
1459
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MenuS.c 
 
1460
495c489
 
1461
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/MsgLineS.c 
 
1462
---
 
1463
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/MsgLineS.c 
 
1464
497c491
 
1465
<       $(CC) -c $(XMTFLAGS) $(XCFLAGS) $(SHARED_CFLAGS) $(XMT_SDIR)/WorkingBoxS.c 
 
1466
---
 
1467
>       $(CC) -c $(CFLAGS) $(XCFLAGS) $(XMT_SDIR)/WorkingBoxS.c 
 
1468
502c496
 
1469
<       $(RM) libXmt.a libXmt$(SHAREDEXT)
 
1470
---
 
1471
>       $(RM) libXmt.a
 
1472
 
 
1473
 
 
1474
Only in Xmt310/Xmt: Makefile.simple
 
1475
 
 
1476
 
 
1477
 
 
1478
diff -b -r xmt_212/Xmt/Menu.c Xmt310/Xmt/Menu.c
 
1479
29d31
 
1480
< #include <Xm/TraitP.h>
 
1481
31a34,36
 
1482
> #if XmVersion >= 2001
 
1483
> #include <Xm/TraitP.h>
 
1484
> #endif
 
1485
61c66
 
1486
< #if NeedFunctionPrototypes
 
1487
---
 
1488
> #if NeedFunctionPrototype
 
1489
197c202
 
1490
< #if XmVersion >= 2000
 
1491
---
 
1492
> #if XmVersion == 2000
 
1493
199,200c204
 
1494
< /* extern XmMenuSystemTraitRec _XmRC_menuSystemRecord; */
 
1495
< static XmMenuSystemTraitRec *xmt_menuSystemRecord;
 
1496
---
 
1497
> extern XmMenuSystemTraitRec _XmRC_menuSystemRecord;
 
1498
220c224
 
1499
< #if XmVersion >= 2000
 
1500
---
 
1501
> #if XmVersion == 2000
 
1502
222,228d225
 
1503
< /*     XmeTraitSet((XtPointer) xmtMenuWidgetClass, XmQTmenuSystem, */
 
1504
< /*                 (XtPointer) &_XmRC_menuSystemRecord);  */
 
1505
<     /*
 
1506
<     ** set trait record of the superclass
 
1507
<     */
 
1508
<     xmt_menuSystemRecord = XmeTraitGet((XtPointer) xmRowColumnWidgetClass, 
 
1509
<                                           XmQTmenuSystem);
 
1510
230c227
 
1511
<                 (XtPointer) xmt_menuSystemRecord); 
 
1512
---
 
1513
>                 (XtPointer) &_XmRC_menuSystemRecord);
 
1514
231a229,234
 
1515
> #if XmVersion >= 2001
 
1516
>     /* Trait records */
 
1517
>     XmeTraitSet((XtPointer) xmtMenuWidgetClass, XmQTmenuSystem,
 
1518
>                 XmeTraitGet ((XtPointer) xmRowColumnWidgetClass,
 
1519
>                            XmQTmenuSystem));
 
1520
> #endif
 
1521
281c284
 
1522
<     XmToggleButtonSetState(item->w, (int)value, False);
 
1523
---
 
1524
>     XmToggleButtonSetState(item->w, value, False);
 
1525
339,341c342,344
 
1526
<     XmString accel_label = NULL;
 
1527
<     char namebuf[20], submenu_buf[30];
 
1528
<     char *name = NULL, *submenu_name;
 
1529
---
 
1530
>     XmString accel_label;
 
1531
>     char namebuf[10], submenu_buf[20];
 
1532
>     char *name, *submenu_name;
 
1533
416c419
 
1534
<             else item->label1 = XmtCreateLocalizedXmString(w, item->alt_label);
 
1535
---
 
1536
>           else item->label1 = XmtCreateXmString(item->alt_label);
 
1537
431c434
 
1538
<             else item->label0 = XmtCreateLocalizedXmString(w, item->label);
 
1539
---
 
1540
>           else item->label0 = XmtCreateXmString(item->label);
 
1541
 
 
1542
 
 
1543
 
 
1544
diff -b -r xmt_212/Xmt/MenuCvt.c Xmt310/Xmt/MenuCvt.c
 
1545
396c399
 
1546
<         int len = 0;
 
1547
---
 
1548
>       int len;
 
1549
398c401
 
1550
<         Boolean stat = False;
 
1551
---
 
1552
>       Boolean stat;
 
1553
 
 
1554
 
 
1555
 
 
1556
diff -b -r xmt_212/Xmt/MotifWidgets.c Xmt310/Xmt/MotifWidgets.c
 
1557
134c137
 
1558
< #if (XmVersion == 2000)
 
1559
---
 
1560
> #if XmVersion == 2000
 
1561
 
 
1562
 
 
1563
 
 
1564
diff -b -r xmt_212/Xmt/MsgDialogs.c Xmt310/Xmt/MsgDialogs.c
 
1565
118c121
 
1566
<     help = XmtCreateLocalizedXmString(w, cache->help_strings[i]);
 
1567
---
 
1568
>     help = XmtCreateXmString(cache->help_strings[i]);
 
1569
230c233
 
1570
<     Widget dialog = 0, help_button;
 
1571
---
 
1572
>     Widget dialog, help_button;
 
1573
451,452c454,455
 
1574
<     msg = XmtCreateLocalizedXmString(w, data.message);
 
1575
<     title = XmtCreateLocalizedXmString(w, data.title);
 
1576
---
 
1577
>     msg = XmtCreateXmString(data.message);
 
1578
>     title = XmtCreateXmString(data.title);
 
1579
 
 
1580
 
 
1581
 
 
1582
diff -b -r xmt_212/Xmt/MsgLine.c Xmt310/Xmt/MsgLine.c
 
1583
427d429
 
1584
<     mw->msgline.input_type = STRING;
 
1585
 
 
1586
 
 
1587
 
 
1588
diff -b -r xmt_212/Xmt/NameToWidget.c Xmt310/Xmt/NameToWidget.c
 
1589
180,182d182
 
1590
< #if NeedFunctionPrototypes
 
1591
< typedef Widget (*NameMatchProc)(XrmNameList, XrmBindingList, int, WidgetList, int, int, int*, int*);
 
1592
< #else
 
1593
184d183
 
1594
< #endif
 
1595
331c330
 
1596
< static Widget NameListToWidget(Widget root,
 
1597
---
 
1598
> static Widget NameListToWidget(register Widget root,
 
1599
338c337
 
1600
< Widget root;
 
1601
---
 
1602
> register Widget root;
 
1603
 
 
1604
 
 
1605
 
 
1606
diff -b -r xmt_212/Xmt/PixelCvt.c Xmt310/Xmt/PixelCvt.c
 
1607
43,47d45
 
1608
< /* _AA 
 
1609
<  XmtWarningMsg("XmtConvertStringToPixel","info","addr visual is %p", &visual);
 
1610
<  XmtWarningMsg("XmtConvertStringToPixel","info","visual is %p", visual);
 
1611
<  _AA **/
 
1612
< 
 
1613
 
 
1614
 
 
1615
 
 
1616
diff -b -r xmt_212/Xmt/PixmapCvt.c Xmt310/Xmt/PixmapCvt.c
 
1617
12,13d14
 
1618
< #define XMT_CDE_BUG_FIX 
 
1619
< 
 
1620
38,40d38
 
1621
< #ifdef XMT_CDE_BUG_FIX 
 
1622
<     if (strcmp(str, "unspecified_pixmap")) {
 
1623
< #endif
 
1624
46,51d43
 
1625
< #ifdef XMT_CDE_BUG_FIX 
 
1626
<     }
 
1627
<     else
 
1628
<         pixmap = XmUNSPECIFIED_PIXMAP;
 
1629
< #endif
 
1630
< 
 
1631
 
 
1632
 
 
1633
 
 
1634
diff -b -r xmt_212/Xmt/Procedures.c Xmt310/Xmt/Procedures.c
 
1635
51c54
 
1636
<         XmtProcedureInfo *p = NULL; 
 
1637
---
 
1638
>         XmtProcedureInfo *p; 
 
1639
 
 
1640
 
 
1641
 
 
1642
diff -b -r xmt_212/Xmt/Quarks.c Xmt310/Xmt/Quarks.c
 
1643
35c38
 
1644
<     static int inited = False;
 
1645
---
 
1646
>     static inited = False;
 
1647
 
 
1648
 
 
1649
 
 
1650
diff -b -r xmt_212/Xmt/RGBtoHSL.c Xmt310/Xmt/RGBtoHSL.c
 
1651
12,13d14
 
1652
< #include <Xmt/Xmt.h>
 
1653
< 
 
1654
 
 
1655
 
 
1656
 
 
1657
diff -b -r xmt_212/Xmt/ScreenP.h Xmt310/Xmt/ScreenP.h
 
1658
25,29d27
 
1659
< /* _AA added XmtAskForTime(), XmtAskForMemory() */
 
1660
<     Widget time_dialog;
 
1661
<     Widget memory_dialog;
 
1662
<     Widget items_dialog;
 
1663
< /******_AA******************/
 
1664
 
 
1665
 
 
1666
 
 
1667
diff -b -r xmt_212/Xmt/SetValue.c Xmt310/Xmt/SetValue.c
 
1668
48,50d50
 
1669
<         if (strcmp(type, XtRString) == 0) {
 
1670
<             arg.value = (XtArgVal) to.addr;
 
1671
<         } else {
 
1672
52,56d51
 
1673
< #ifdef CRAY
 
1674
<                 case sizeof(char):   arg.value = (XtArgVal)*(char *)to.addr; break;
 
1675
<                 case sizeof(int):    arg.value = (XtArgVal)*(int *)to.addr; break;
 
1676
<                 default:             arg.value = (XtArgVal)to.addr; break;
 
1677
< #else
 
1678
61d55
 
1679
< #endif
 
1680
63d56
 
1681
<         }
 
1682
 
 
1683
 
 
1684
 
 
1685
diff -b -r xmt_212/Xmt/ShellUtil.c Xmt310/Xmt/ShellUtil.c
 
1686
70c73
 
1687
<     static Atom wm_delete_window = 0;
 
1688
---
 
1689
>     static Atom wm_delete_window;
 
1690
261c264
 
1691
< static Cardinal focus_values[] = {FocusSetInput, FocusMove, FocusNone, FocusWarp};
 
1692
---
 
1693
> static int focus_values[] = {FocusSetInput, FocusMove, FocusNone, FocusWarp};
 
1694
 
 
1695
 
 
1696
 
 
1697
diff -b -r xmt_212/Xmt/Symbols.c Xmt310/Xmt/Symbols.c
 
1698
18,25d20
 
1699
< #if NeedFunctionPrototypes
 
1700
<         void _XtCopyToArg(XtPointer, XtArgVal *, Cardinal);
 
1701
<         void _XtCopyFromArg(XtArgVal, XtPointer, Cardinal);
 
1702
< #else
 
1703
<         void _XtCopyToArg();
 
1704
<         void _XtCopyFromArg();
 
1705
< #endif
 
1706
< 
 
1707
256a252
 
1708
>     extern void _XtCopyFromArg();
 
1709
334a331
 
1710
>     extern void _XtCopyToArg();
 
1711
381a379,380
 
1712
>     extern void _XtCopyToArg();
 
1713
> 
 
1714
 
 
1715
 
 
1716
 
 
1717
diff -b -r xmt_212/Xmt/UnixProcs.c Xmt310/Xmt/UnixProcs.c
 
1718
13d15
 
1719
< #include <X11/Xos.h>
 
1720
24a27,31
 
1721
> /* these aren't declared in SunOS 4.1.1 */
 
1722
> extern int puts();
 
1723
> extern int system();
 
1724
> 
 
1725
> 
 
1726
 
 
1727
 
 
1728
 
 
1729
diff -b -r xmt_212/Xmt/Util.h Xmt310/Xmt/Util.h
 
1730
38d40
 
1731
< extern XmString XmtCreateLocalizedXmString(Widget, StringConst);
 
1732
60d61
 
1733
< extern String _XmtLocalize(Screen* , StringConst, StringConst, StringConst);
 
1734
75d75
 
1735
< extern XmString XmtCreateLocalizedXmString();
 
1736
 
 
1737
 
 
1738
 
 
1739
diff -b -r xmt_212/Xmt/Visual.c Xmt310/Xmt/Visual.c
 
1740
24d26
 
1741
< #ifdef ENABLE_ALT_VISUALS
 
1742
28d29
 
1743
< #endif
 
1744
47d47
 
1745
< #ifdef ENABLE_ALT_VISUALS
 
1746
51d50
 
1747
< #endif
 
1748
 
 
1749
 
 
1750
 
 
1751
diff -b -r xmt_212/Xmt/WidgetType.c Xmt310/Xmt/WidgetType.c
 
1752
39c42
 
1753
<                       (XtPointer)(long) XrmPermStringToQuark(name),
 
1754
---
 
1755
>                     (XtPointer)XrmPermStringToQuark(name),
 
1756
65c68
 
1757
<                       (XtPointer)(long)XrmPermStringToQuark(name),
 
1758
---
 
1759
>                     (XtPointer)XrmPermStringToQuark(name),
 
1760
90c93
 
1761
<                       (XtPointer)(long)XrmPermStringToQuark(name),
 
1762
---
 
1763
>                     (XtPointer)XrmPermStringToQuark(name),
 
1764
116c119
 
1765
<                       (XtPointer)(long)XrmPermStringToQuark(name),
 
1766
---
 
1767
>                     (XtPointer)XrmPermStringToQuark(name),
 
1768
135c138
 
1769
<                           (XtPointer)(long)XrmPermStringToQuark(types[i].name),
 
1770
---
 
1771
>                         (XtPointer)XrmPermStringToQuark(types[i].name),
 
1772
193c196
 
1773
<                            (XtPointer) (long)XrmStringToQuark(name),
 
1774
---
 
1775
>                          (XtPointer) XrmStringToQuark(name),
 
1776
 
 
1777
 
 
1778
 
 
1779
diff -b -r xmt_212/Xmt/WidgetType.h Xmt310/Xmt/WidgetType.h
 
1780
37c40
 
1781
<     Cardinal popup;
 
1782
---
 
1783
>     int popup;
 
1784
57,63d59
 
1785
< #if XmVersion >= 2000
 
1786
< extern void XmtRegisterXmComboBox(void);
 
1787
< #endif /* XmVersion >= 2000 */
 
1788
< #if (XmVersion == 2000)
 
1789
< extern void XmtRegisterXmCSText(void);
 
1790
< extern void XmtRegisterXmScrolledCSText(void);
 
1791
< #endif /* XmVersion >= 2000 */
 
1792
79,85d74
 
1793
< #if XmVersion >= 2000
 
1794
< extern void XmtRegisterXmComboBox();
 
1795
< #endif   /* XmVersion >= 2000 */
 
1796
< #if (XmVersion == 2000)
 
1797
< extern void XmtRegisterXmCSText();
 
1798
< extern void XmtRegisterXmScrolledCSText();
 
1799
< #endif   /* XmVersion == 2000 */
 
1800
 
 
1801
 
 
1802
 
 
1803
diff -b -r xmt_212/Xmt/Working.c Xmt310/Xmt/Working.c
 
1804
132c135
 
1805
<     title = XmtCreateLocalizedXmString(w, data.title);
 
1806
---
 
1807
>     title = XmtCreateXmString(data.title);
 
1808
 
 
1809
 
 
1810
 
 
1811
diff -b -r xmt_212/Xmt/WorkingBox.c Xmt310/Xmt/WorkingBox.c
 
1812
282c285
 
1813
<     label = XmtCreateLocalizedXmString((Widget) wd, wd->working_box.message);
 
1814
---
 
1815
>     label = XmtCreateXmString(wd->working_box.message);
 
1816
294c297
 
1817
<     label = XmtCreateLocalizedXmString((Widget)wd, wd->working_box.scale_label);
 
1818
---
 
1819
>     label = XmtCreateXmString(wd->working_box.scale_label);
 
1820
314c317
 
1821
<     label = XmtCreateLocalizedXmString((Widget) wd, wd->working_box.button_label);
 
1822
---
 
1823
>     label = XmtCreateXmString(wd->working_box.button_label);
 
1824
389c392
 
1825
<             label = XmtCreateLocalizedXmString((Widget) sw, sw->working_box.message);
 
1826
---
 
1827
>           label = XmtCreateXmString(sw->working_box.message);
 
1828
399c402
 
1829
<             label = XmtCreateLocalizedXmString((Widget) sw, sw->working_box.scale_label);
 
1830
---
 
1831
>           label = XmtCreateXmString(sw->working_box.scale_label);
 
1832
409c412
 
1833
<             label = XmtCreateLocalizedXmString((Widget) sw, sw->working_box.button_label);
 
1834
---
 
1835
>           label = XmtCreateXmString(sw->working_box.button_label);
 
1836
 
 
1837
 
 
1838
 
 
1839
diff -b -r xmt_212/Xmt/XmCSText.c Xmt310/Xmt/XmCSText.c
 
1840
19c22
 
1841
< #if (XmVersion == 2000)
 
1842
---
 
1843
> #if XmVersion == 2000
 
1844
23d25
 
1845
< 
 
1846
26d27
 
1847
< 
 
1848
42c43
 
1849
<         xmString = XmtCreateLocalizedXmString(w, *(String *)address);
 
1850
---
 
1851
>         xmString = XmtCreateXmString(*(String *)address);
 
1852
47c48
 
1853
<         xmString = XmtCreateLocalizedXmString(w, (char *)address);
 
1854
---
 
1855
>         xmString = XmtCreateXmString((char *)address);
 
1856
113c114
 
1857
<     (XmtWidgetConstructor)XmCreateCSText,
 
1858
---
 
1859
>     XmCreateCSText,
 
1860
121c122
 
1861
<     (XmtWidgetConstructor)XmCreateScrolledCSText,
 
1862
---
 
1863
>     XmCreateScrolledCSText,
 
1864
146c147
 
1865
< #else  /* if XmVersion < 2000 */
 
1866
---
 
1867
> #else  /* if XmVersion = 2000 */
 
1868
 
 
1869
 
 
1870
 
 
1871
diff -b -r xmt_212/Xmt/XmStringCvt.c Xmt310/Xmt/XmStringCvt.c
 
1872
12d14
 
1873
< #include <stdlib.h>
 
1874
16,17c18
 
1875
< #if 0 
 
1876
< /* #if XmVersion >= 2000 */
 
1877
---
 
1878
> #if XmVersion >= 2000
 
1879
61,62d61
 
1880
< /* printf("...> '%s'\n", (char *) *text); */
 
1881
< 
 
1882
104c103
 
1883
<        if ( indicator == '{' )
 
1884
---
 
1885
>        if ( indicator == '[' )
 
1886
106c105
 
1887
<                          "'@{' locale indicator may occur only at beginning of string.");
 
1888
---
 
1889
>                        "'@[' locale indicator may occur only at beginning of string.");
 
1890
205c204
 
1891
<         Arg args[4];
 
1892
---
 
1893
>       Arg args[3];
 
1894
210d208
 
1895
<         XtSetArg(args[n], XmNpatternType, XmMULTIBYTE_TEXT); n++;
 
1896
217d214
 
1897
<         XtSetArg(args[n], XmNpatternType, XmMULTIBYTE_TEXT); n++;
 
1898
225d221
 
1899
<         XtSetArg(args[n], XmNpatternType, XmMULTIBYTE_TEXT); n++;
 
1900
233c229
 
1901
<     return XmStringParseText((XtPointer) str, NULL, NULL, XmMULTIBYTE_TEXT,
 
1902
---
 
1903
>     return XmStringParseText((XtPointer) str, NULL, NULL, XmCHARSET_TEXT,
 
1904
252d247
 
1905
< #if 0
 
1906
254,295d248
 
1907
<    char *mtxt = NULL;
 
1908
<       
 
1909
<    if (fixup) {
 
1910
<       wchar_t *s, *t;
 
1911
<       wchar_t *ws = NULL;
 
1912
<       int n;
 
1913
< 
 
1914
<       n = mbstowcs(NULL, txt, 0);
 
1915
<       if (n>0) {
 
1916
<          ws = (wchar_t*)malloc(sizeof(wchar_t)*(n+1));
 
1917
<       }
 
1918
<       if (ws) {
 
1919
<          mbstowcs(ws, txt, (n+1));
 
1920
<       }  
 
1921
<       for(s=t=ws; *s; s++, t++) {
 
1922
<             *t = *s;
 
1923
<             if ((*s == L'@') && (*(s+1) == L'@')) s++;
 
1924
<        }
 
1925
<        *t = *s;  /* copy the terminating '\0' */
 
1926
<        n = wcstombs(NULL, ws, 0);
 
1927
<        if (n > 0) {
 
1928
<          mtxt = (char*)malloc(sizeof(char)*(n+1));
 
1929
<       }
 
1930
<       if (mtxt) {
 
1931
<          wcstombs(mtxt, ws, (n+1));
 
1932
<       }  
 
1933
<       else {
 
1934
<          mtxt = strdup(txt);
 
1935
<       }   
 
1936
<       XtFree((char*)ws);
 
1937
<    }
 
1938
< 
 
1939
<    s1 = XmStringSegmentCreate(mtxt, charset, XmSTRING_DIRECTION_L_TO_R, sep);
 
1940
<    if (!to) return s1;
 
1941
<    s2 = XmStringConcat(to, s1);
 
1942
<    XmStringFree(to);
 
1943
<    XmStringFree(s1);
 
1944
<    XtFree(mtxt);
 
1945
<    return s2;
 
1946
< 
 
1947
< #else
 
1948
<     XmString s1, s2;
 
1949
312d264
 
1950
< #endif    
 
1951
322d273
 
1952
< #if 0
 
1953
341,345d291
 
1954
<     /*
 
1955
<      * make a copy of the string so we can frob with it
 
1956
<      * We keep pointer r so we can free it when done
 
1957
<      */
 
1958
<     r = s = XtNewString(str);
 
1959
347,421d292
 
1960
< 
 
1961
<     for(t = s; *s; s++) {
 
1962
<         switch(*s) {
 
1963
<         case '\n':
 
1964
<             *s = '\0';  /* null terminate the string */
 
1965
<             result = appendstring(t, result, True, charset, fixup);
 
1966
<             fixup = False;
 
1967
<             t = s+1;
 
1968
<             break;
 
1969
<         case '@':
 
1970
<             if ((*s == '@') && (*(s+1) == '@')) {
 
1971
<                 /* set a flag to strip doubled escapes later */
 
1972
<                 fixup = True;
 
1973
<                 s++;
 
1974
<                 break;
 
1975
<             }
 
1976
<             else if (*(s+1) != 'f') break;
 
1977
<             /* its a font change, so add the string up to here, if any */
 
1978
<             *s = '\0'; /* null terminate the string */
 
1979
<             if (s != t)
 
1980
<                 result = appendstring(t, result, False, charset, fixup);
 
1981
<             fixup = False;
 
1982
< 
 
1983
<             /* and now get the new charset */
 
1984
<             if (*(s+2) == '\0') break;
 
1985
<             s+=2;
 
1986
<             if (*s == '[') {  /* read till close ']' */
 
1987
<                 s = charset = s+1;
 
1988
<                 while (*s && (*s != ']')) s++;
 
1989
<                 if (*s == '\0') break;
 
1990
<                 *s = '\0';  /* null-terminate the charset string */
 
1991
<             }
 
1992
<             else if (*s == '(') { /* charset is next 2 chars */
 
1993
<                 if (*(s+1)) s++; else break;
 
1994
<                 charset_buf[0] = *s;
 
1995
<                 if (*(s+1)) s++; else break;
 
1996
<                 charset_buf[1] = *s;
 
1997
<                 charset_buf[2] = '\0';
 
1998
<                 charset = charset_buf;
 
1999
<             }
 
2000
<             else if (*s) { /* charset is single current character */
 
2001
<                 charset_buf[0] = *s;
 
2002
<                 charset_buf[1] = '\0';
 
2003
<                 charset = charset_buf;
 
2004
<             }
 
2005
< 
 
2006
<             t = s+1;
 
2007
<             break;
 
2008
<         }
 
2009
<     }
 
2010
<     if (s != t) result = appendstring(t, result, False, charset, fixup);
 
2011
<     
 
2012
<     XtFree(r);
 
2013
< 
 
2014
<     return result;
 
2015
< 
 
2016
< #else
 
2017
<     String r, s, t;
 
2018
< #ifdef XMSTRING_TO_COMPOUND_TEXT_BUG
 
2019
<     String charset = XmSTRING_DEFAULT_CHARSET;
 
2020
< #else    
 
2021
< #  if XmVersion < 1002
 
2022
<     String charset = XmSTRING_DEFAULT_CHARSET;
 
2023
< #  else
 
2024
<     String charset = XmFONTLIST_DEFAULT_TAG;
 
2025
< #  endif
 
2026
< #endif    
 
2027
<     char charset_buf[3];
 
2028
<     XmString result = NULL;
 
2029
<     Boolean fixup = False;
 
2030
<     
 
2031
<     if (!str) return NULL;
 
2032
<     else if (!*str)
 
2033
<         return XmStringSegmentCreate((String)str, charset,
 
2034
<                                      XmSTRING_DIRECTION_L_TO_R, False);
 
2035
428d298
 
2036
< 
 
2037
477a348
 
2038
> 
 
2039
481d351
 
2040
< 
 
2041
483,484d352
 
2042
< #endif    
 
2043
< /*     return XmStringCreateLocalized(str); */
 
2044
491c359,362
 
2045
< static XmString XmtCreateLocalizedXmString_(Screen *screen, StringConst str)
 
2046
---
 
2047
> Boolean XmtConvertStringToXmString(Display *dpy,
 
2048
>                                  XrmValue *args, Cardinal *num_args,
 
2049
>                                  XrmValue *from, XrmValue *to,
 
2050
>                                  XtPointer *converter_data)
 
2051
493,495c364,371
 
2052
< static XmString XmtCreateLocalizedXmString_(screen, str)
 
2053
< Screen* screen;
 
2054
< StringConst str;
 
2055
---
 
2056
> Boolean XmtConvertStringToXmString(dpy, args, num_args,
 
2057
>                                  from, to, converter_data)
 
2058
> Display *dpy;
 
2059
> XrmValue *args;
 
2060
> Cardinal *num_args;
 
2061
> XrmValue *from;
 
2062
> XrmValue *to;
 
2063
> XtPointer *converter_data;
 
2064
498,499c374,376
 
2065
<     XmString value = NULL;
 
2066
<     String category, tag, defaultstr;
 
2067
---
 
2068
>     String s = (String) from->addr;
 
2069
>     Screen *screen = *(Screen **)args[0].addr;
 
2070
>     String category, tag;
 
2071
501c378
 
2072
<     String s = NULL;
 
2073
---
 
2074
>     XmString value;
 
2075
508,511d384
 
2076
<     if (!str)
 
2077
<         return NULL;
 
2078
< 
 
2079
< /* printf("==> '%s'\n", str); */
 
2080
513,514c386,387
 
2081
<     if ((str[0] == '@') && (str[1] == '{')) {
 
2082
<         s = XtNewString(str);
 
2083
---
 
2084
>     if ((s[0] == '@') && (s[1] == '[')) {
 
2085
>       s = XtNewString(s);
 
2086
517d389
 
2087
< /* printf("=-> '%s'\n", s); */
 
2088
519,520c391
 
2089
<         tag = NULL;
 
2090
<         defaultstr = s;
 
2091
---
 
2092
>       tag = s;
 
2093
524,525c395,396
 
2094
<                 category = defaultstr;
 
2095
<                 defaultstr = s+1;
 
2096
---
 
2097
>               category = tag;
 
2098
>               tag = s+1;
 
2099
527c398
 
2100
<             if (*s == '.' && !tag) {
 
2101
---
 
2102
>           if (*s == ']') {
 
2103
529,533d399
 
2104
<                 tag = defaultstr;
 
2105
<                 defaultstr = s+1;
 
2106
<             }
 
2107
<             if (*s == '}') {
 
2108
<                 *s = '\0';
 
2109
538d403
 
2110
< /* printf("-=> '%s'\n", free_me+2); */
 
2111
540,541d404
 
2112
<         if (!tag)
 
2113
<            tag = defaultstr;
 
2114
544c407
 
2115
<         s = _XmtLocalize(screen, defaultstr, category, tag);
 
2116
---
 
2117
>       s = _XmtLocalize(screen, s, category, tag);
 
2118
546,548d408
 
2119
<     else {
 
2120
<         s = (String)str;
 
2121
<     }
 
2122
550,551d409
 
2123
< /* printf("--> '%s'\n", s); */
 
2124
< 
 
2125
553d410
 
2126
< 
 
2127
555a413
 
2128
>     done(XmString, value);
 
2129
557,558d414
 
2130
<     return value;
 
2131
< 
 
2132
561c417,418
 
2133
<     return NULL;
 
2134
---
 
2135
>     XtDisplayStringConversionWarning(dpy, (String)from->addr, XmRXmString);
 
2136
>     return False;
 
2137
581,625d437
 
2138
< 
 
2139
< 
 
2140
< 
 
2141
< /* ARGSUSED */
 
2142
< #if NeedFunctionPrototypes
 
2143
< Boolean XmtConvertStringToXmString(Display *dpy,
 
2144
<                                    XrmValue *args, Cardinal *num_args,
 
2145
<                                    XrmValue *from, XrmValue *to,
 
2146
<                                    XtPointer *converter_data)
 
2147
< #else
 
2148
< Boolean XmtConvertStringToXmString(dpy, args, num_args,
 
2149
<                                    from, to, converter_data)
 
2150
< Display *dpy;
 
2151
< XrmValue *args;
 
2152
< Cardinal *num_args;
 
2153
< XrmValue *from;
 
2154
< XrmValue *to;
 
2155
< XtPointer *converter_data;
 
2156
< #endif
 
2157
< {
 
2158
<     String s = (String) from->addr;
 
2159
<     Screen *screen = *(Screen **)args[0].addr;
 
2160
<     XmString value;
 
2161
<     
 
2162
<     value = XmtCreateLocalizedXmString_(screen, s);
 
2163
<     if (!value) goto error;
 
2164
<     done(XmString, value);
 
2165
< 
 
2166
<  error:
 
2167
<     XtDisplayStringConversionWarning(dpy, (String)from->addr, XmRXmString);
 
2168
<     return False;
 
2169
< }
 
2170
< 
 
2171
< /* ARGSUSED */
 
2172
< #if NeedFunctionPrototypes
 
2173
< XmString XmtCreateLocalizedXmString(Widget w, StringConst s)
 
2174
< #else
 
2175
< XmString XmtCreateLocalizedXmString(w, s)
 
2176
< Widget w;
 
2177
< StringConst s;
 
2178
< #endif
 
2179
< {
 
2180
<    return XmtCreateLocalizedXmString_(XtScreen(w), s);
 
2181
< }
 
2182
< 
 
2183
 
 
2184
 
 
2185
 
 
2186
diff -b -r xmt_212/Xmt/Xmt.h Xmt310/Xmt/Xmt.h
 
2187
19a23,31
 
2188
> #if !defined (XMT_HAS_STRERROR)
 
2189
> # if defined (XMT_HAS_SYS_ERRLIST)
 
2190
> extern char *sys_errlist[];
 
2191
> #   define strerror(err) sys_errlist[err]
 
2192
> # else
 
2193
> #   define strerror(err) "strerror is unsupported"
 
2194
> # endif /* XMT_HAS_SYS_ERRLIST */
 
2195
> #endif /* !XMT_HAS_STERROR */
 
2196
> 
 
2197
43c55
 
2198
< #define XmtVERSION      2
 
2199
---
 
2200
> #define XmtVERSION      3
 
2201
46c58
 
2202
< #define XmtPatchlevel   2
 
2203
---
 
2204
> #define XmtPatchlevel   0
 
2205
80,86c92,98
 
2206
< #ifdef __cplusplus              /* for C++ V2.0 */
 
2207
< #define _XFUNCPROTOBEGIN extern "C" {
 
2208
< #define _XFUNCPROTOEND }
 
2209
< #else
 
2210
< #define _XFUNCPROTOBEGIN
 
2211
< #define _XFUNCPROTOEND
 
2212
< #endif /* __cplusplus */
 
2213
---
 
2214
> #  ifdef __cplusplus          /* for C++ V2.0 */
 
2215
> #    define _XFUNCPROTOBEGIN extern "C" {
 
2216
> #    define _XFUNCPROTOEND }
 
2217
> #  else
 
2218
> #    define _XFUNCPROTOBEGIN
 
2219
> #    define _XFUNCPROTOEND
 
2220
> #  endif /* __cplusplus */
 
2221
333c345
 
2222
< #define memmove(a,b,n) bcopy((char*)(b),(char*)(a),n)
 
2223
---
 
2224
> #define memmove(a,b,n) bcopy(b,a,n)
 
2225
 
 
2226
 
 
2227
 
 
2228
diff -b -r xmt_212/Xmt/Xpm.c Xmt310/Xmt/Xpm.c
 
2229
264c267
 
2230
<         (char *) XtMalloc(((*image_return)->bytes_per_line * height));
 
2231
---
 
2232
>       (char *) XtMalloc((*image_return)->bytes_per_line * height);
 
2233
496,499c499,500
 
2234
<     else {
 
2235
< /*         XtFree((char *)alloc_pixels_return); */
 
2236
<         XtFree((char *)alloc_pixels);
 
2237
<     }
 
2238
---
 
2239
>     else
 
2240
>       XtFree((char *)alloc_pixels_return);
 
2241
844c845
 
2242
< #if !defined(WORD64) && !defined(LONG64) && !defined(SOLARIS64)
 
2243
---
 
2244
> #if !defined(WORD64) && !defined(LONG64)
 
2245
 
 
2246
 
 
2247
 
 
2248
diff -b -r xmt_212/Xmt/XpmParse.c Xmt310/Xmt/XpmParse.c
 
2249
86,89c89,92
 
2250
<  {"", '\0', '\n', "", "", "", "" },     /* Natural type */
 
2251
<  {"C", '"', '"', ",\n", "static char *", "[] = {\n", "};\n" },
 
2252
<  {"Lisp", '"', '"', "\n", "(setq ", " '(\n", "))\n" },
 
2253
<  {NULL, 0, 0, NULL, NULL, NULL, NULL }
 
2254
---
 
2255
>  "", '\0', '\n', "", "", "", "",      /* Natural type */
 
2256
>  "C", '"', '"', ",\n", "static char *", "[] = {\n", "};\n",
 
2257
>  "Lisp", '"', '"', "\n", "(setq ", " '(\n", "))\n",
 
2258
>  NULL, 0, 0, NULL, NULL, NULL, NULL
 
2259
321,322d323
 
2260
< /*     extern int errno; */
 
2261
<