1 /**
2 *
3 * $Header: /cvsroot/lesstif/lesstif/lib/Xm-2.1/ResConvert.c,v 1.16 2006/04/19 18:42:22 dannybackx Exp $
4 *
5 * Copyright (C) 1995 Free Software Foundation, Inc.
6 * Copyright � 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2004, 2005 LessTif Development Team
7 *
8 * This file is part of the GNU LessTif Library.
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Library General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Library General Public License for more details.
19 *
20 * You should have received a copy of the GNU Library General Public
21 * License along with this library; if not, write to the Free
22 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 **/
25
26 static const char rcsid[] = "$Id: ResConvert.c,v 1.16 2006/04/19 18:42:22 dannybackx Exp $";
27
28 #include <LTconfig.h>
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <stdarg.h>
33 #include <ctype.h>
34 #include <string.h>
35
36 #include <X11/Xlib.h>
37 #include <X11/Xfuncproto.h>
38 #include <X11/Xresource.h>
39
40 #include <XmI/XmI.h>
41 #include <Xm/XmP.h>
42 #include <Xm/AtomMgr.h>
43 #include <Xm/RepType.h>
44 #include <Xm/BulletinBP.h>
45 #include <Xm/MenuShellP.h>
46 #include <Xm/VendorSEP.h>
47 #include <Xm/ExtObjectP.h>
48 #include <Xm/XmosP.h>
49 #include <XmI/LTmisc.h>
50
51 #include <XmI/DebugUtil.h>
52
53 #if USE_XFT
54 #include <X11/Xft/Xft.h>
55 #endif
56
57 enum
58 {
59 ST_ATOM_LIST, ST_BUTTON_TYPE, ST_KEY_SYM_TABLE, ST_STRING_TABLE,
60 ST_XM_STRING_TABLE
61 };
62
63 static Boolean _XmCvtStringToXmString(Display *, XrmValue *,
64 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
65 static Boolean _XmCvtStringToXmFontList(Display *, XrmValue *,
66 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
67 static Boolean _XmCvtStringToCardinal(Display *, XrmValue *,
68 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
69 static Boolean _XmCvtStringToKeySym(Display *, XrmValue *,
70 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
71 static Boolean _XmCvtStringToResIndPosition(Display *, XrmValue *,
72 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
73 static Boolean _XmCvtStringToResIndDimension(Display *, XrmValue *,
74 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
75 static Boolean _XmCvtStringToResIndInt(Display *, XrmValue *,
76 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
77 static Boolean _XmCvtStringToWidget(Display *, XrmValue *,
78 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
79 static Boolean _XmCvtStringToWindow(Display *, XrmValue *,
80 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
81 static Boolean _XmCvtStringToBooleanDimension(Display *, XrmValue *,
82 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
83 static Boolean _XmCvtStringToChar(Display *, XrmValue *,
84 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
85 static Boolean _XmCvtStringToTextPosition(Display *, XrmValue *,
86 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
87 static Boolean _XmCvtStringToTopItemPosition(Display *, XrmValue *,
88 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
89 static Boolean _XmCvtStringToSomeTable(Display *, XrmValue *,
90 Cardinal *, XrmValue *, XrmValue *, XtPointer *);
91
92 static void destroy_font_list(XtAppContext app, XrmValue *to,
93 XtPointer converer_data, XrmValue *args,
94 Cardinal *num_args);
95 static void destroy_table(XtAppContext app, XrmValue *to,
96 XtPointer converer_data, XrmValue *args,
97 Cardinal *num_args);
98 static void destroy_string_table(XtAppContext app, XrmValue *to,
99 XtPointer converer_data, XrmValue *args,
100 Cardinal *num_args);
101 static void destroy_xm_string_table(XtAppContext app, XrmValue *to,
102 XtPointer converer_data, XrmValue *args,
103 Cardinal *num_args);
104 static void get_unit_type(Widget w, Cardinal *size, XrmValue *val);
105
106 static Boolean _XmCvtStringToTabList(Display *display, XrmValue *args,
107 Cardinal *num_args, XrmValue *from, XrmValue *to,
108 XtPointer *converter_data);
109 static Boolean _XmCvtStringToRenderTable(Display *display, XrmValue *args,
110 Cardinal *num_args, XrmValue *from, XrmValue *to,
111 XtPointer *converter_data);
112 static void _XmCvtRenderTableFree(XtAppContext app, XrmValue *to,
113 XtPointer converter_data, XrmValue *args,
114 Cardinal *num_args);
115 #if USE_XFT
116 static Boolean XmuCvtStringToXftColor(Display *dpy,
117 XrmValue *args, Cardinal *num_args,
118 XrmValue *fromVal, XrmValue *toVal,
119 XtPointer *converter_data);
120 static void XmuFreeXftColor(XtAppContext app, XrmValuePtr toVal, XtPointer closure,
121 XrmValuePtr args, Cardinal *num_args);
122 #endif /* USE_XFT */
123
124
125 /*
126 xmUseVersion is used for a sanity check by developers. It is used within
127 a M*tif applications to ensure the version of the (shared) M*tif library
128 being used corresponds to the M*tif toolkit header the application was
129 compiled against. 8/3/98, pgw@ma.ultranet.com
130 amai: it seems that at least OM 2.1 initializes this number
131 immediately, instead of waiting for XmRegisterConverters()
132 to be called. We try to stay as compatible as possible here ...
133 */
134 #if XmVersion < 2001
135 int xmUseVersion = 0;
136 #else
137 int xmUseVersion = XmVersion;
138 #endif
139
XmVersionString(void)140 extern char *XmVersionString(void)
141 {
142 return LesstifVERSION_STRING;
143 }
144
145
146 /* please be careful if you're editting these arrays, as
147 * the strings have to be in the _same_ order as the
148 * enumerated constants in the include files. Failure to comply
149 * will bring about the death of your firstborn. Have
150 * a nice day.
151 */
152
153 static char *multi_click[] =
154 {
155 "multiclick_discard",
156 "multiclick_keep"
157 };
158
159 static char *packing_styles[] =
160 {
161 "no_packing",
162 "pack_tight",
163 "pack_column",
164 "pack_none"
165 };
166
167 static char *focus_policies[] =
168 {
169 "explicit",
170 "pointer"
171 };
172
173 static char *label_types[] =
174 {
175 "pixmap",
176 "string"
177 };
178 static unsigned char label_type_values[] =
179 {
180 XmPIXMAP,
181 XmSTRING
182 };
183
184 static char *vertical_alignments[] =
185 {
186 "alignment_baseline_top",
187 "alignment_center",
188 "alignment_baseline_bottom",
189 "alignment_contents_top",
190 "alignment_contents_bottom"
191 };
192
193 static char *child_vertical_alignments[] =
194 {
195 "alignment_baseline_top",
196 "alignment_center",
197 "alignment_baseline_bottom",
198 "alignment_widget_top",
199 "alignment_widget_bottom"
200 };
201
202 static char *horizontal_alignments[] =
203 {
204 "alignment_beginning",
205 "alignment_center",
206 "alignment_end"
207 };
208
209 static char *arrow_directions[] =
210 {
211 "arrow_up",
212 "arrow_down",
213 "arrow_left",
214 "arrow_right"
215 };
216
217 static char *attachments[] =
218 {
219 "attach_none",
220 "attach_form",
221 "attach_opposite_form",
222 "attach_widget",
223 "attach_opposite_widget",
224 "attach_position",
225 "attach_self"
226 };
227
228 static char *audible_warnings[] =
229 {
230 "none",
231 "bell"
232 };
233
234 static char *frame_child_types[] =
235 {
236 "frame_generic_child",
237 "frame_workarea_child",
238 "frame_title_child"
239 };
240
241 static char *delete_responses[] =
242 {
243 "destroy",
244 "unmap",
245 "do_nothing"
246 };
247
248 static char *navigation_types[] =
249 {
250 "none",
251 "tab_group",
252 "sticky_tab_group",
253 "exclusive_tab_group"
254 };
255
256 static char *orientations[] =
257 {
258 "vertical",
259 "horizontal",
260 };
261 static unsigned char orientation_values[] =
262 {
263 XmVERTICAL,
264 XmHORIZONTAL
265 };
266
267 static char *protocol_styles[] =
268 {
269 "drag_none",
270 "drag_drop_only",
271 "drag_prefer_preregister",
272 "drag_preregister",
273 "drag_prefer_dynamic",
274 "drag_dynamic",
275 "drag_prefer_receiver"
276 };
277
278 static char *scrollbar_placement[] =
279 {
280 "bottom_right",
281 "top_right",
282 "bottom_left",
283 "top_left"
284 };
285
286 static char *scrolling_policy[] =
287 {
288 "automatic",
289 "application_defined"
290 };
291
292 static char *scrollbar_policy[] =
293 {
294 "static",
295 "as_needed"
296 };
297
298 static char *edit_mode[] =
299 {
300 "multi_line_edit",
301 "single_line_edit"
302 };
303
304 static char *unit_types[] =
305 {
306 "pixels",
307 "100th_millimeters",
308 "1000th_inches",
309 "100th_points",
310 "100th_font_units"
311 };
312
313 /*
314 * These are the values of XmNdialogType for XmMessageBox
315 * This is the value type XmRDialogType.
316 * The class of this resource is XmCDialogType.
317 */
318 static char *dialog_types[] =
319 {
320 "dialog_template",
321 "dialog_error",
322 "dialog_information",
323 "dialog_message",
324 "dialog_question",
325 "dialog_warning",
326 "dialog_working"
327 };
328
329 /*
330 * These are the values of XmNdialogType for XmSelectionBox
331 * This is the value type XmRSelectionType.
332 * The class of this resource is (also) XmCDialogType
333 */
334 static char *selection_dialog_types[] = {
335 "dialog_work_area",
336 "dialog_prompt",
337 "dialog_selection",
338 "dialog_command",
339 "dialog_file_selection",
340 };
341
342 static char *dialog_styles[] =
343 {
344 "dialog_modeless",
345 "dialog_primary_application_modal",
346 "dialog_full_application_modal",
347 "dialog_system_modal"
348 };
349
350 static char *shadow_types[] =
351 {
352 "shadow_in",
353 "shadow_out",
354 "shadow_etched_in",
355 "shadow_etched_out"
356 };
357 static unsigned char shadow_type_values[] =
358 {
359 XmSHADOW_IN,
360 XmSHADOW_OUT,
361 XmSHADOW_ETCHED_IN,
362 XmSHADOW_ETCHED_OUT
363 };
364
365 static char *separator_types[] =
366 {
367 "no_line",
368 "single_line",
369 "double_line",
370 "single_dashed_line",
371 "double_dashed_line",
372 "shadow_etched_in",
373 "shadow_etched_out",
374 "shadow_etched_in_dash",
375 "shadow_etched_out_dash"
376 };
377
378 static char *row_column_types[] =
379 {
380 "work_area",
381 "menu_bar",
382 "menu_pulldown",
383 "menu_popup",
384 "menu_option"
385 };
386 static unsigned char row_column_type_values[] =
387 {
388 XmWORK_AREA,
389 XmMENU_BAR,
390 XmMENU_PULLDOWN,
391 XmMENU_POPUP,
392 XmMENU_OPTION
393 };
394
395 static char *indicator_types[] =
396 {
397 "n_of_many",
398 "one_of_many",
399 "one_of_many_round",
400 "one_of_many_diamond"
401 };
402 static unsigned char indicator_type_values[] =
403 {
404 XmN_OF_MANY,
405 XmONE_OF_MANY,
406 XmONE_OF_MANY_ROUND,
407 XmONE_OF_MANY_DIAMOND
408 };
409
410 static char *resize_policies[] =
411 {
412 "resize_none",
413 "resize_grow",
414 "resize_any"
415 };
416
417 static char *extension_types[] =
418 {
419 "cache_extension",
420 "desktop_extension",
421 "shell_extension",
422 "protocol_extension",
423 "default_extension"
424 };
425
426 static unsigned char extension_type_values[] =
427 {
428 XmCACHE_EXTENSION,
429 XmDESKTOP_EXTENSION,
430 XmSHELL_EXTENSION,
431 XmPROTOCOL_EXTENSION,
432 XmDEFAULT_EXTENSION
433 };
434
435 static char *icon_attachments[] =
436 {
437 "attach_north_west",
438 "attach_north",
439 "attach_north_east",
440 "attach_east",
441 "attach_south_east",
442 "attach_south",
443 "attach_south_west",
444 "attach_west",
445 "attach_center",
446 "attach_hot"
447 };
448
449 static char *transfer_statuses[] =
450 {
451 "transfer_failure",
452 "transfer_success"
453 };
454
455 static char *file_types[] =
456 {
457 "file_directory",
458 "file_regular",
459 "file_any_type"
460 };
461 static unsigned char file_type_values[] =
462 {
463 XmFILE_DIRECTORY,
464 XmFILE_REGULAR,
465 XmFILE_ANY_TYPE
466 };
467
468 static char *string_directions[] =
469 {
470 "string_direction_l_to_r",
471 "string_direction_r_to_l"
472 };
473
474 static char *command_locations[] =
475 {
476 "command_above_workspace",
477 "command_below_workspace"
478 };
479
480 static char *default_button_types[] =
481 {
482 "dialog_none",
483 "dialog_cancel_button",
484 "dialog_ok_button",
485 "dialog_help_button"
486 };
487 static unsigned char default_button_type_values[] =
488 {
489 XmDIALOG_NONE,
490 XmDIALOG_CANCEL_BUTTON,
491 XmDIALOG_OK_BUTTON,
492 XmDIALOG_HELP_BUTTON
493 };
494
495 static char *processing_directions[] =
496 {
497 "max_on_top",
498 "max_on_bottom",
499 "max_on_left",
500 "max_on_right"
501 };
502
503 static char *unpost_behaviours[] =
504 {
505 "unpost",
506 "unpost_and_replay"
507 };
508
509 static char *visual_policies[] =
510 {
511 "variable",
512 "constant"
513 };
514
515 static char *child_placements[] =
516 {
517 "place_top",
518 "place_above_selection",
519 "place_below_selection"
520 };
521
522 static char *selection_policies[] =
523 {
524 "single_select",
525 "multiple_select",
526 "extended_select",
527 "browse_select"
528 };
529
530 static char *list_size_policies[] =
531 {
532 "variable",
533 "constant",
534 "resize_if_possible"
535 };
536
537 static XtConvertArgRec parentArgs[] = {
538 { XtBaseOffset,
539 (XtPointer)XtOffsetOf(WidgetRec, core.parent),
540 sizeof(Widget) }
541 };
542
543 static XtConvertArgRec selfArgs[] = {
544 { XtBaseOffset,
545 (XtPointer)XtOffsetOf(WidgetRec, core.self),
546 sizeof(Widget) }
547 };
548
549 static char *toggle_mode[] =
550 {
551 "toggle_boolean",
552 "toggle_indeterminate"
553 };
554
555 /* ComboBox */
556
557 static char *combobox_type[] =
558 {
559 "combo_box",
560 "drop_down_combo_box",
561 "drop_down_list",
562 };
563
564 static unsigned char combobox_type_values[] =
565 {
566 XmCOMBO_BOX,
567 XmDROP_DOWN_COMBO_BOX,
568 XmDROP_DOWN_LIST,
569 };
570
571 /* Spinbox */
572 static char *spb_child_types[] =
573 {
574 "numeric",
575 "string"
576 };
577
578 static unsigned char spb_child_type_values[] =
579 {
580 XmNUMERIC,
581 XmSTRING
582 };
583
584 static char *spb_arrow_layouts[] =
585 {
586 "arrows_beginning",
587 "arrows_end",
588 "arrows_split"
589 };
590
591 static unsigned char spb_arrow_layout_values[] =
592 {
593 XmARROWS_END,
594 XmARROWS_BEGINNING,
595 XmARROWS_SPLIT,
596 XmARROWS_FLAT_END,
597 XmARROWS_FLAT_BEGINNING
598 };
599
600 /* Notebook */
601 static char *nb_child_types[] =
602 {
603 "none",
604 "page",
605 "major_tab",
606 "minor_tab",
607 "status_area",
608 "page_scroller"
609 };
610
611 static unsigned char nb_child_type_values[] =
612 {
613 XmNONE,
614 XmPAGE,
615 XmMAJOR_TAB,
616 XmMINOR_TAB,
617 XmSTATUS_AREA,
618 XmPAGE_SCROLLER
619 };
620
621 static char *indicator_on[] =
622 {
623 "indicator_none",
624 "indicator_fill",
625 "indicator_check",
626 "indicator_check_box",
627 "indicator_cross",
628 "indicator_cross_box",
629 "false", /* Support 1.2 compatible defaults */
630 "true", /* Support 1.2 compatible defaults */
631 "off", /* Boolean compatible values */
632 "on",
633 "0",
634 "1",
635 "no",
636 "yes",
637 };
638
639 static unsigned char indicator_on_values[] =
640 {
641 XmINDICATOR_NONE,
642 XmINDICATOR_FILL,
643 XmINDICATOR_CHECK,
644 XmINDICATOR_CHECK_BOX,
645 XmINDICATOR_CROSS,
646 XmINDICATOR_CROSS_BOX,
647 XmINDICATOR_NONE, /* False */
648 XmINDICATOR_FILL, /* True */
649 XmINDICATOR_NONE, /* Off */
650 XmINDICATOR_FILL, /* On */
651 XmINDICATOR_NONE, /* 0 */
652 XmINDICATOR_FILL, /* 1 */
653 XmINDICATOR_NONE, /* no */
654 XmINDICATOR_FILL, /* yes */
655 };
656
657
658 #ifdef USE_XFT
659 static XtConvertArgRec xftColorConvertArgs[] = {
660 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
661 sizeof(Screen *)},
662 {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
663 sizeof(Colormap)}
664 };
665
666 #define XtRXftColor "XftColor"
667 #endif /* USE_XFT */
668
669 static char *filter_styles[] =
670 {
671 "filter_none",
672 "filter_hidden_files"
673 };
674
675 static char *path_mode_names[] =
676 {
677 "path_mode_full",
678 "path_mode_relative"
679 };
680
681 static char *font_types[] =
682 {
683 "FONT_IS_FONT",
684 "FONT_IS_FONTSET",
685 "FONT_IS_XOC",
686 "FONT_IS_XFT"
687 };
688 static unsigned char font_type_values[] =
689 {
690 XmFONT_IS_FONT,
691 XmFONT_IS_FONTSET,
692 XmFONT_IS_XOC,
693 XmFONT_IS_XFT
694 };
695 extern void
XmRegisterConverters(void)696 XmRegisterConverters(void)
697 {
698 /* don't really know the difference between the two, so
699 we'll just call the other from here for now. */
700
701 _XmRegisterConverters();
702 }
703
704
705 extern void
_XmRegisterConverters(void)706 _XmRegisterConverters(void)
707 {
708 static Boolean first = True;
709 static XtConvertArgRec immediate_arg = {XtImmediate, 0, sizeof(XtPointer)};
710 static XtConvertArgRec horizontal_args[] = {
711 { XtWidgetBaseOffset, (XtPointer)XtOffset(Widget, core.screen), sizeof(Screen *) },
712 { XtImmediate, (XtPointer)XmHORIZONTAL, sizeof(XtPointer) },
713 { XtProcedureArg, (XtPointer)get_unit_type, 0 }
714 };
715 static XtConvertArgRec vertical_args[] = {
716 { XtWidgetBaseOffset, (XtPointer)XtOffset(Widget, core.screen), sizeof(Screen *) },
717 { XtImmediate, (XtPointer)XmVERTICAL, sizeof(XtPointer) },
718 { XtProcedureArg, (XtPointer)get_unit_type, 0 }
719 };
720
721 if (first) {
722 first = False;
723 } else {
724 return;
725 }
726
727 /* See comment at declaration at beginning of this file */
728 #if XmVersion < 2001
729 xmUseVersion = XmVersion;
730 #endif
731
732 #define REPTYPE_REGISTER(reptype,array) \
733 XmRepTypeRegister((reptype), \
734 (array), \
735 NULL, XtNumber((array)));
736 #define REPTYPE_REGISTER_WITH_VALUES(reptype,array,values) \
737 XmRepTypeRegister((reptype), \
738 (array), \
739 (values), XtNumber((array)));
740
741 REPTYPE_REGISTER(XmRMultiClick, multi_click);
742 REPTYPE_REGISTER(XmRPacking, packing_styles);
743 REPTYPE_REGISTER(XmRKeyboardFocusPolicy, focus_policies);
744 REPTYPE_REGISTER(XmRVerticalAlignment, vertical_alignments);
745 REPTYPE_REGISTER(XmRChildVerticalAlignment, child_vertical_alignments);
746 REPTYPE_REGISTER(XmRAlignment, horizontal_alignments);
747 REPTYPE_REGISTER(XmRChildHorizontalAlignment, horizontal_alignments);
748 REPTYPE_REGISTER(XmRArrowDirection, arrow_directions);
749 REPTYPE_REGISTER(XmRAttachment, attachments);
750 REPTYPE_REGISTER(XmRAudibleWarning, audible_warnings);
751 REPTYPE_REGISTER(XmRChildType, frame_child_types);
752 REPTYPE_REGISTER(XmRDeleteResponse, delete_responses);
753 REPTYPE_REGISTER(XmRNavigationType, navigation_types);
754 REPTYPE_REGISTER(XmRScrollBarPlacement, scrollbar_placement);
755 REPTYPE_REGISTER(XmRScrollingPolicy, scrolling_policy);
756 REPTYPE_REGISTER(XmRScrollBarDisplayPolicy, scrollbar_policy);
757 REPTYPE_REGISTER(XmREditMode, edit_mode);
758 REPTYPE_REGISTER(XmRDragInitiatorProtocolStyle, protocol_styles);
759 REPTYPE_REGISTER(XmRDragReceiverProtocolStyle, protocol_styles);
760 REPTYPE_REGISTER(XmRUnitType, unit_types);
761 REPTYPE_REGISTER(XmRDialogType, dialog_types);
762 REPTYPE_REGISTER(XmRSelectionType, selection_dialog_types);
763 REPTYPE_REGISTER(XmRDialogStyle, dialog_styles);
764 REPTYPE_REGISTER(XmRSeparatorType, separator_types);
765 REPTYPE_REGISTER(XmRResizePolicy, resize_policies);
766 REPTYPE_REGISTER(XmRIconAttachment, icon_attachments);
767 REPTYPE_REGISTER(XmRTransferStatus, transfer_statuses);
768 REPTYPE_REGISTER(XmRStringDirection, string_directions);
769 REPTYPE_REGISTER(XmRCommandWindowLocation, command_locations);
770 REPTYPE_REGISTER(XmRProcessingDirection, processing_directions);
771 REPTYPE_REGISTER(XmRUnpostBehavior, unpost_behaviours);
772 REPTYPE_REGISTER(XmRVisualPolicy, visual_policies);
773 REPTYPE_REGISTER(XmRChildPlacement, child_placements);
774 REPTYPE_REGISTER(XmRSelectionPolicy, selection_policies);
775 REPTYPE_REGISTER(XmRListSizePolicy, list_size_policies);
776
777 REPTYPE_REGISTER_WITH_VALUES(XmRLabelType, label_types, label_type_values);
778 REPTYPE_REGISTER_WITH_VALUES(XmRShadowType, shadow_types, shadow_type_values);
779 REPTYPE_REGISTER_WITH_VALUES(XmRRowColumnType, row_column_types, row_column_type_values);
780 REPTYPE_REGISTER_WITH_VALUES(XmRExtensionType, extension_types, extension_type_values);
781 REPTYPE_REGISTER_WITH_VALUES(XmRFileTypeMask, file_types, file_type_values);
782 REPTYPE_REGISTER_WITH_VALUES(XmRDefaultButtonType, default_button_types,
783 default_button_type_values);
784 REPTYPE_REGISTER_WITH_VALUES(XmROrientation, orientations, orientation_values);
785 REPTYPE_REGISTER_WITH_VALUES(XmRIndicatorType, indicator_types, indicator_type_values);
786
787 /* Motif 2.x */
788 REPTYPE_REGISTER(XmRToggleMode, toggle_mode);
789 REPTYPE_REGISTER_WITH_VALUES(XmRArrowLayout, spb_arrow_layouts, spb_arrow_layout_values);
790 REPTYPE_REGISTER_WITH_VALUES(XmRSpinBoxChildType, spb_child_types, spb_child_type_values);
791 REPTYPE_REGISTER_WITH_VALUES(XmRIndicatorOn, indicator_on, indicator_on_values);
792 REPTYPE_REGISTER_WITH_VALUES(XmRNotebookChildType, nb_child_types, nb_child_type_values);
793 REPTYPE_REGISTER_WITH_VALUES(XmRComboBoxType, combobox_type, combobox_type_values);
794
795 REPTYPE_REGISTER(XmRFileFilterStyle, filter_styles);
796 REPTYPE_REGISTER(XmRPathMode, path_mode_names);
797
798 XmRepTypeInstallTearOffModelConverter();
799
800 /* now we install the other toolkit converters */
801
802 XtSetTypeConverter(XtRString, /* source type */
803 XmRXmString, /* target type */
804 _XmCvtStringToXmString, /* converter routine */
805 NULL, /* args for converter routine */
806 0, /* number of args to converter routine */
807 XtCacheAll, /* caching instructions */
808 NULL); /* destructor function */
809 /* Don't cache */
810 XtSetTypeConverter(XtRString, /* source type */
811 XmRFontList, /* target type */
812 _XmCvtStringToXmFontList, /* converter routine */
813 NULL, /* args for converter routine */
814 0, /* number of args to converter routine */
815 XtCacheByDisplay, /* caching instructions */
816 destroy_font_list); /* destructor function */
817 XtSetTypeConverter(XtRString, /* source type */
818 XmRHorizontalDimension, /* target type */
819 _XmCvtStringToResIndDimension, /* converter routine */
820 horizontal_args, /* args for converter routine */
821 XtNumber(horizontal_args), /* number of args to converter routine */
822 XtCacheNone, /* caching instructions */
823 NULL); /* destructor function */
824
825 XtSetTypeConverter(XtRString, /* source type */
826 XmRShellHorizDim, /* target type */
827 _XmCvtStringToResIndDimension, /* converter routine */
828 horizontal_args, /* args for converter routine */
829 XtNumber(horizontal_args), /* number of args to converter routine */
830 XtCacheNone, /* caching instructions */
831 NULL); /* destructor function */
832
833 XtSetTypeConverter(XtRString, /* source type */
834 XmRHorizontalInt, /* target type */
835 _XmCvtStringToResIndInt, /* converter routine */
836 horizontal_args, /* args for converter routine */
837 XtNumber(horizontal_args), /* number of args to converter routine */
838 XtCacheNone, /* caching instructions */
839 NULL); /* destructor function */
840
841 XtSetTypeConverter(XtRString, /* source type */
842 XmRHorizontalPosition, /* target type */
843 _XmCvtStringToResIndPosition, /* converter routine */
844 horizontal_args, /* args for converter routine */
845 XtNumber(horizontal_args), /* number of args to converter routine */
846 XtCacheNone, /* caching instructions */
847 NULL); /* destructor function */
848
849 XtSetTypeConverter(XtRString, /* source type */
850 XmRShellHorizPos, /* target type */
851 _XmCvtStringToResIndPosition, /* converter routine */
852 horizontal_args, /* args for converter routine */
853 XtNumber(horizontal_args), /* number of args to converter routine */
854 XtCacheNone, /* caching instructions */
855 NULL); /* destructor function */
856
857 XtSetTypeConverter(XtRString, /* source type */
858 XmRShellVertPos, /* target type */
859 _XmCvtStringToResIndPosition, /* converter routine */
860 vertical_args, /* args for converter routine */
861 XtNumber(vertical_args), /* number of args to converter routine */
862 XtCacheNone, /* caching instructions */
863 NULL); /* destructor function */
864
865 XtSetTypeConverter(XtRString, /* source type */
866 XmRVerticalPosition, /* target type */
867 _XmCvtStringToResIndPosition, /* converter routine */
868 vertical_args, /* args for converter routine */
869 XtNumber(vertical_args), /* number of args to converter routine */
870 XtCacheNone, /* caching instructions */
871 NULL); /* destructor function */
872
873 XtSetTypeConverter(XtRString, /* source type */
874 XmRShellVertDim, /* target type */
875 _XmCvtStringToResIndDimension, /* converter routine */
876 vertical_args, /* args for converter routine */
877 XtNumber(vertical_args), /* number of args to converter routine */
878 XtCacheNone, /* caching instructions */
879 NULL); /* destructor function */
880
881 XtSetTypeConverter(XtRString, /* source type */
882 XmRVerticalDimension, /* target type */
883 _XmCvtStringToResIndDimension, /* converter routine */
884 vertical_args, /* args for converter routine */
885 XtNumber(vertical_args), /* number of args to converter routine */
886 XtCacheNone, /* caching instructions */
887 NULL); /* destructor function */
888
889 XtSetTypeConverter(XtRString, /* source type */
890 XmRVerticalInt, /* target type */
891 _XmCvtStringToResIndInt, /* converter routine */
892 vertical_args, /* args for converter routine */
893 XtNumber(vertical_args), /* number of args to converter routine */
894 XtCacheNone, /* caching instructions */
895 NULL); /* destructor function */
896
897 XtSetTypeConverter(XtRString, /* source type */
898 XmRKeySym, /* target type */
899 _XmCvtStringToKeySym, /* converter routine */
900 NULL, /* args for converter routine */
901 0, /* number of args to converter routine */
902 XtCacheAll, /* caching instructions */
903 NULL); /* destructor function */
904
905 #if 0
906 XtSetTypeConverter(XtRString, /* source type */
907 XmRNavigation, /* target type */
908 _XmCvtStringToXmNavigation, /* converter routine */
909 NULL, /* args for converter routine */
910 0, /* number of args to converter routine */
911 XtCacheNone, /* caching instructions */
912 NULL); /* destructor function */
913 #endif
914
915 immediate_arg.address_id = (XtPointer)ST_ATOM_LIST;
916 XtSetTypeConverter(XtRString, /* source type */
917 XmRAtomList, /* target type */
918 _XmCvtStringToSomeTable, /* converter routine */
919 &immediate_arg, /* args for converter routine */
920 1, /* number of args to converter routine */
921 XtCacheNone | XtCacheRefCount, /* caching instructions */
922 destroy_table); /* destructor function */
923
924 immediate_arg.address_id = (XtPointer)ST_BUTTON_TYPE;
925 XtSetTypeConverter(XtRString, /* source type */
926 XmRButtonType, /* target type */
927 _XmCvtStringToSomeTable, /* converter routine */
928 &immediate_arg, /* args for converter routine */
929 1, /* number of args to converter routine */
930 XtCacheNone | XtCacheRefCount, /* caching instructions */
931 destroy_table); /* destructor function */
932
933 immediate_arg.address_id = (XtPointer)ST_STRING_TABLE;
934 XtSetTypeConverter(XtRString, /* source type */
935 XmRCharSetTable, /* target type */
936 _XmCvtStringToSomeTable, /* converter routine */
937 &immediate_arg, /* args for converter routine */
938 1, /* number of args to converter routine */
939 XtCacheNone | XtCacheRefCount, /* caching instructions */
940 destroy_string_table); /* destructor function */
941
942 immediate_arg.address_id = (XtPointer)ST_KEY_SYM_TABLE;
943 XtSetTypeConverter(XtRString, /* source type */
944 XmRKeySymTable, /* target type */
945 _XmCvtStringToSomeTable, /* converter routine */
946 &immediate_arg, /* args for converter routine */
947 1, /* number of args to converter routine */
948 XtCacheNone | XtCacheRefCount, /* caching instructions */
949 destroy_table); /* destructor function */
950
951 immediate_arg.address_id = (XtPointer)ST_STRING_TABLE;
952 XtSetTypeConverter(XtRString, /* source type */
953 XmRStringTable, /* target type */
954 _XmCvtStringToSomeTable, /* converter routine */
955 &immediate_arg, /* args for converter routine */
956 1, /* number of args to converter routine */
957 XtCacheNone | XtCacheRefCount, /* caching instructions */
958 destroy_string_table); /* destructor function */
959
960 immediate_arg.address_id = (XtPointer)ST_XM_STRING_TABLE;
961 XtSetTypeConverter(XtRString, /* source type */
962 XmRXmStringTable, /* target type */
963 _XmCvtStringToSomeTable, /* converter routine */
964 &immediate_arg, /* args for converter routine */
965 1, /* number of args to converter routine */
966 XtCacheNone | XtCacheRefCount, /* caching instructions */
967 destroy_xm_string_table); /* destructor function */
968
969 XtSetTypeConverter(XtRString, /* source type */
970 XmRWidget, /* target type */
971 _XmCvtStringToWidget, /* converter routine */
972 parentArgs, /* args for converter routine */
973 XtNumber(parentArgs), /* number of args to converter routine */
974 XtCacheNone, /* caching instructions */
975 NULL); /* destructor function */
976
977 XtSetTypeConverter(XtRString, /* source type */
978 XmRWindow, /* target type */
979 _XmCvtStringToWindow, /* converter routine */
980 parentArgs, /* args for converter routine */
981 XtNumber(parentArgs), /* number of args to converter routine */
982 XtCacheNone, /* caching instructions */
983 NULL); /* destructor function */
984
985 XtSetTypeConverter(XtRString, /* source type */
986 XmRCardinal, /* target type */
987 _XmCvtStringToCardinal, /* converter routine */
988 NULL, /* args for converter routine */
989 0, /* number of args to converter routine */
990 XtCacheNone, /* caching instructions */
991 NULL); /* destructor function */
992
993 XtSetTypeConverter(XtRString, /* source type */
994 XmRBooleanDimension, /* target type */
995 _XmCvtStringToBooleanDimension, /* converter routine */
996 horizontal_args, /* args for converter routine */
997 XtNumber(horizontal_args), /* number of args to converter routine */
998 XtCacheNone, /* caching instructions */
999 NULL); /* destructor function */
1000
1001 XtSetTypeConverter(XtRString, /* source type */
1002 XmRChar, /* target type */
1003 _XmCvtStringToChar, /* converter routine */
1004 NULL, /* args for converter routine */
1005 0, /* number of args to converter routine */
1006 XtCacheNone, /* caching instructions */
1007 NULL); /* destructor function */
1008
1009 XtSetTypeConverter(XtRString, /* source type */
1010 XmRTextPosition, /* target type */
1011 _XmCvtStringToTextPosition, /* converter routine */
1012 NULL, /* args for converter routine */
1013 0, /* number of args to converter routine */
1014 XtCacheNone, /* caching instructions */
1015 NULL); /* destructor function */
1016
1017 XtSetTypeConverter(XtRString, /* source type */
1018 XmRTopItemPosition, /* target type */
1019 _XmCvtStringToTopItemPosition, /* converter routine */
1020 NULL, /* args for converter routine */
1021 0, /* number of args to converter routine */
1022 XtCacheNone, /* caching instructions */
1023 NULL); /* destructor function */
1024 XtSetTypeConverter(XtRString, /* source type */
1025 XmRTabList, /* target type */
1026 _XmCvtStringToTabList, /* converter routine */
1027 NULL, /* args for converter routine */
1028 0, /* number of args to converter routine */
1029 XtCacheNone, /* caching instructions */
1030 NULL); /* destructor function */
1031
1032 XtSetTypeConverter(XtRString, /* source type */
1033 XmRRenderTable, /* target type */
1034 _XmCvtStringToRenderTable, /* converter routine */
1035 selfArgs, /* args for converter routine */
1036 XtNumber(selfArgs), /* number of args to converter routine */
1037 XtCacheByDisplay | XtCacheRefCount, /* caching instructions */
1038 _XmCvtRenderTableFree); /* destructor function */
1039 #if USE_XFT
1040 XtSetTypeConverter(XtRString,
1041 XtRXftColor,
1042 XmuCvtStringToXftColor,
1043 xftColorConvertArgs,
1044 XtNumber(xftColorConvertArgs),
1045 XtCacheByDisplay,
1046 XmuFreeXftColor);
1047 #endif /* USE_XFT */
1048
1049 #ifdef NONSTANDARD_CONVERTERS
1050 _XmRegisterNSEConverters();
1051 #endif
1052 REPTYPE_REGISTER_WITH_VALUES(XmRFontType, font_types, font_type_values);
1053
1054 #undef REPTYPE_REGISTER
1055 #undef REPTYPE_REGISTER_WITH_VALUES
1056 }
1057
1058
1059 /*
1060 * error convenience
1061 */
1062 void
_XmError(Widget w,const char * fmt,...)1063 _XmError(Widget w, const char *fmt, ...)
1064 {
1065 va_list arg_list;
1066 char buf[1024];
1067 int charsleft=sizeof(buf);
1068
1069 va_start(arg_list, fmt);
1070 #ifdef HAVE_VSNPRINTF
1071 charsleft -= vsnprintf(buf, sizeof(buf), fmt, arg_list);
1072 #else
1073 charsleft -= vsprintf(buf, fmt, arg_list);
1074 /* one might add a catch here ... */
1075 #endif
1076 va_end(arg_list);
1077 if (w) {
1078 XtAppError(XtWidgetToApplicationContext(w), buf);
1079 } else {
1080 XtError(buf);
1081 }
1082 }
1083
1084
1085 /*
1086 * Warning convenience
1087 *
1088 * Added _LtDebug stuff here to be able to avoid infinite loops in applications
1089 * that redirect stderr to a scrolledText. ML suffers from this, due to LessTif
1090 * bugs of course :-(
1091 */
1092 static void
_LtWarning(Widget w,const char * fmt,va_list arg_list)1093 _LtWarning(Widget w, const char *fmt, va_list arg_list)
1094 {
1095 /* Somewhere it's pointed out that we shouldn't exceed 1024 characters here.
1096 Let's reserve two chars for \n\000
1097 If we don't have (v)snprintf() we have a vulnerable piece of
1098 code here ... */
1099 #define BUFLEN 1026
1100 char buf[BUFLEN]="";
1101 int charsleft=BUFLEN;
1102 static Boolean redirect=False;
1103 #ifndef LESSTIF_PRODUCTION
1104 static Boolean init=False;
1105
1106
1107 if (!init) {
1108 if (getenv("DEBUG_REDIRECT_XMWARNING"))
1109 redirect = True;
1110 init=True;
1111 }
1112 #endif /* !LESSTIF_PRODUCTION */
1113
1114 if (w)
1115 {
1116 #ifdef HAVE_SNPRINTF
1117 charsleft -= snprintf(buf, charsleft,
1118 "\n Name: %s\n Class: %s\n ",
1119 XtName(w), XtClass(w)->core_class.class_name);
1120 #else
1121 #ifndef VOID_SPRINTF
1122 charsleft -=
1123 #endif
1124 sprintf(buf, "\n Name: %s\n Class: %s\n ",
1125 XtName(w), XtClass(w)->core_class.class_name);
1126 #ifdef VOID_SPRINTF
1127 charsleft -= strlen(buf);
1128 #endif
1129 /* one might add a catch here ... */
1130 #endif
1131
1132 #ifdef HAVE_VSNPRINTF
1133 charsleft -= vsnprintf(buf + strlen(buf), charsleft,
1134 fmt, arg_list);
1135 #else
1136 charsleft -= vsprintf(buf + strlen(buf),
1137 fmt, arg_list);
1138 /* one might add a catch here ... */
1139 #endif
1140
1141 strcat(buf, "\n");
1142
1143 if (redirect)
1144 {
1145 _LtDebugPrintString(buf);
1146 }
1147 else
1148 {
1149 XtAppWarning(XtWidgetToApplicationContext(w), buf);
1150 }
1151 }
1152 else
1153 {
1154 #ifdef HAVE_VSNPRINTF
1155 charsleft -= vsnprintf(buf + strlen(buf), charsleft,
1156 fmt, arg_list);
1157 #else
1158 charsleft -= vsprintf(buf + strlen(buf),
1159 fmt, arg_list);
1160 #endif
1161
1162 if (redirect)
1163 {
1164 _LtDebugPrintString(buf);
1165 }
1166 else
1167 {
1168 XtWarning(buf);
1169 }
1170 } /* if(w) */
1171 }
1172
1173 /*
1174 * Warning convenience
1175 *
1176 * Added _LtDebug stuff here to be able to avoid infinite loops in applications
1177 * that redirect stderr to a scrolledText. ML suffers from this, due to LessTif
1178 * bugs of course :-(
1179 */
1180
1181 #ifdef _XmWarning
1182 #undef _XmWarning
1183 #endif
1184
1185 extern void
_XmWarning(Widget w,const char * fmt,...)1186 _XmWarning(Widget w, const char *fmt, ...)
1187 {
1188 va_list arg_list;
1189
1190 va_start(arg_list, fmt);
1191 _LtWarning(w, fmt, arg_list);
1192 va_end(arg_list);
1193 }
1194
1195
1196 extern void
XmeWarning(Widget w,const char * fmt,...)1197 XmeWarning(Widget w, const char *fmt, ...)
1198 {
1199 va_list arg_list;
1200
1201 va_start(arg_list, fmt);
1202 _LtWarning(w, fmt, arg_list);
1203 va_end(arg_list);
1204 }
1205
1206
1207 extern char *
XmRegisterSegmentEncoding(char * fontlist_tag,char * ct_encoding)1208 XmRegisterSegmentEncoding(char *fontlist_tag, char *ct_encoding)
1209 {
1210 return NULL;
1211 }
1212
1213
1214 extern char *
XmMapSegmentEncoding(char * fontlist_tag)1215 XmMapSegmentEncoding(char *fontlist_tag)
1216 {
1217 return NULL;
1218 }
1219
1220
1221 extern XmString
XmCvtCTToXmString(char * text)1222 XmCvtCTToXmString(char *text)
1223 {
1224 return XmStringCreate(text, XmFONTLIST_DEFAULT_TAG);
1225 }
1226
1227
1228 extern Boolean
XmCvtTextToXmString(Display * display,XrmValuePtr args,Cardinal * num_args,XrmValue * from_val,XrmValue * to_val,XtPointer * converter_data)1229 XmCvtTextToXmString(Display *display, XrmValuePtr args,
1230 Cardinal *num_args, XrmValue *from_val, XrmValue *to_val,
1231 XtPointer *converter_data)
1232 {
1233 return False;
1234 }
1235
1236
1237 extern char *
XmCvtXmStringToCT(XmString string)1238 XmCvtXmStringToCT(XmString string)
1239 {
1240 char *text = (char *)NULL;
1241 XmStringContext context = NULL;
1242 char *pbuf = (char *)NULL, *pstr;
1243 XmStringCharSet tag;
1244 XmStringDirection direction;
1245 Boolean separator;
1246
1247 DEBUGOUT(_LtDebug(__FILE__, NULL, "XmCvtXmStringToCT\n"));
1248
1249 if (XmStringInitContext(&context, string) == True)
1250 {
1251 while (XmStringGetNextSegment(context,
1252 &text,
1253 &tag,
1254 &direction,
1255 &separator) == True)
1256 {
1257 if (pbuf == NULL)
1258 {
1259 /* allocate space for the buffer and init it */
1260 pbuf = XtMalloc(strlen(text) + 2);
1261 *pbuf = '\0';
1262 }
1263 else
1264 {
1265 /* allocate more space for the buffer */
1266 pbuf = XtRealloc(pbuf, sizeof(pbuf) + strlen(text) + 2);
1267 }
1268
1269 /* reset the pointer pstr to point back at pbuf */
1270 pstr = pbuf;
1271
1272 pstr += (strlen(strcat(pstr, text)));
1273 if (separator == True)
1274 { /* add newline */
1275 *pstr++ = '\n';
1276 *pstr = '\0';
1277 }
1278
1279 /* free the text segment we just grabbed */
1280 XtFree(text);
1281 }
1282 text = pbuf;
1283 }
1284
1285 return text;
1286 }
1287
1288 extern Boolean
XmCvtXmStringToText(Display * display,XrmValuePtr args,Cardinal * num_args,XrmValue * from_val,XrmValue * to_val,XtPointer * converter_data)1289 XmCvtXmStringToText(Display *display, XrmValuePtr args,
1290 Cardinal *num_args, XrmValue *from_val, XrmValue *to_val,
1291 XtPointer *converter_data)
1292 {
1293 char *value = XtNewString("");
1294 XmString m = (XmString)from_val->addr;
1295 XmStringContext c;
1296 XmStringComponentType t = XmSTRING_COMPONENT_UNKNOWN;
1297
1298 if (*num_args != 0)
1299 {
1300 XtWarningMsg("wrongParameters", "XmCvtXmStringToText",
1301 "XtToolkitError",
1302 "XmString to String conversion needs no extra arguments",
1303 (String *)NULL, (Cardinal *)NULL);
1304 }
1305
1306 XmStringInitContext(&c, m);
1307
1308 while (t != XmSTRING_COMPONENT_END)
1309 {
1310 char *s_text = NULL;
1311 XmStringCharSet s_cs = NULL;
1312 XmStringDirection d = XmSTRING_DIRECTION_DEFAULT;
1313 XmStringComponentType u = XmSTRING_COMPONENT_UNKNOWN;
1314 unsigned short ul = 0;
1315 unsigned char *s_uv = NULL;
1316 char *text = NULL;
1317
1318 t = XmStringGetNextComponent(c, &s_text, &s_cs, &d, &u, &ul, &s_uv);
1319
1320 switch (t)
1321 {
1322 case XmSTRING_COMPONENT_TEXT:
1323 case XmSTRING_COMPONENT_LOCALE_TEXT:
1324 text = s_text;
1325 break;
1326
1327 case XmSTRING_COMPONENT_SEPARATOR:
1328 text = "\n";
1329 break;
1330
1331 default:
1332 /* Unknown component */
1333 text = NULL;
1334 break;
1335 }
1336
1337 if (text != NULL)
1338 {
1339 value = XtRealloc(value, strlen(value) + strlen(text) + 1);
1340 strcat(value, text);
1341 }
1342
1343 XtFree(s_text);
1344 XtFree(s_cs);
1345 XtFree((char *)s_uv);
1346 }
1347
1348 to_val->addr = value;
1349 to_val->size = strlen(value); /* FIXME: should this be sizeof(value)? */
1350
1351 DEBUGOUT(_LtDebug(__FILE__, NULL,
1352 "XmCvtXmStringToText(%p) => %s\n",
1353 from_val->addr, to_val->addr));
1354
1355 return True;
1356 }
1357
1358
1359 /*
1360 * Compare two strings to see if they're equivalent. This one is used
1361 * whenever comparing motif constants with resource string values. The
1362 * motif constants must have the Xm prefix stripped off and must be
1363 * in lower case.
1364 */
1365 extern Boolean
_XmStringsAreEqual(char * in_str,char * text_str)1366 _XmStringsAreEqual(char *in_str,
1367 char *text_str)
1368 {
1369 if (in_str[0] && (tolower(in_str[0]) == 'x') &&
1370 in_str[1] && (tolower(in_str[1]) == 'm'))
1371 {
1372 in_str += 2; /* skip the Xm prefix */
1373 }
1374
1375 while (*in_str)
1376 {
1377 if (tolower(*in_str) != *text_str)
1378 return False;
1379 in_str++;
1380 text_str++;
1381 }
1382
1383 return *text_str ? False : True;
1384 }
1385
1386
1387 /*
1388 * Fixed this thing to make a COPY of the fontlist it returns.
1389 * Danny 16/4/1996
1390 */
1391 extern XmFontList
_XmGetDefaultFontList(Widget w,unsigned char fontListType)1392 _XmGetDefaultFontList(Widget w, unsigned char fontListType)
1393 {
1394 XmFontList labelFontList = NULL;
1395 XmFontList buttonFontList = NULL;
1396 XmFontList textFontList = NULL;
1397 XmFontListEntry newEntry;
1398
1399 Widget par = w;
1400 XmFontList fontlist, r;
1401 XmVendorShellExtObject ve = NULL;
1402
1403 fontlist = NULL;
1404 switch (fontListType)
1405 {
1406 case XmTEXT_FONTLIST:
1407 while ((par = XtParent(par)) != NULL)
1408 {
1409 if (XmIsBulletinBoard(par) && BB_TextFontList(par) != NULL)
1410 {
1411 fontlist = BB_TextFontList(par);
1412 break;
1413 }
1414 else if (XmIsVendorShell(par))
1415 {
1416 /* Danny, I found out the hard way that this function can
1417 * get called before the VSEP child is valid, but the context
1418 * has been set. It was with that UIL compiler you sent.
1419 * Thus the next three ve checks have been converted.
1420 * - MLM
1421 */
1422 ve = (XmVendorShellExtObject)_LtFindVendorExt((Widget)par);
1423 if (ve && VSEP_TextFontList(ve) != NULL)
1424 {
1425 fontlist = VSEP_TextFontList(ve);
1426 break;
1427 }
1428 }
1429 }
1430 if (fontlist)
1431 {
1432 XmFontList r = XmFontListCopy(fontlist);
1433 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(XmTEXT_FONTLIST) -> %p\n", r));
1434 return r;
1435 }
1436
1437 newEntry = XmFontListEntryLoad(XtDisplay(w),
1438 XmDEFAULT_FONT,
1439 XmFONT_IS_FONT,
1440 XmFONTLIST_DEFAULT_TAG);
1441 textFontList = XmFontListAppendEntry(NULL, newEntry);
1442 XmFontListEntryFree(&newEntry);
1443
1444 if (textFontList == NULL) {
1445 _XmWarning(w, "_XmGetDefaultFontList: textFontList NULL\n");
1446 }
1447
1448 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(textFontList) -> %p\n",
1449 textFontList));
1450 return textFontList;
1451
1452 case XmBUTTON_FONTLIST:
1453 while ((par = XtParent(par)) != NULL)
1454 {
1455 if (XmIsBulletinBoard(par) && BB_ButtonFontList(par) != NULL)
1456 {
1457 fontlist = BB_ButtonFontList(par);
1458 break;
1459 }
1460 else if (XmIsMenuShell(par) && MS_ButtonFontList(par) != NULL)
1461 {
1462 fontlist = MS_ButtonFontList(par);
1463 break;
1464 }
1465 else if (XmIsVendorShell(par))
1466 {
1467 ve = (XmVendorShellExtObject)_LtFindVendorExt((Widget)par);
1468 if (ve && VSEP_ButtonFontList(ve) != NULL)
1469 {
1470 fontlist = VSEP_ButtonFontList(ve);
1471 break;
1472 }
1473 }
1474 }
1475 if (fontlist) {
1476 r = XmFontListCopy(fontlist);
1477 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(XmBUTTON_FONTLIST) -> %p\n", r));
1478 return r;
1479 }
1480
1481 newEntry = XmFontListEntryLoad(XtDisplay(w),
1482 XmDEFAULT_FONT,
1483 XmFONT_IS_FONT,
1484 XmFONTLIST_DEFAULT_TAG);
1485 buttonFontList = XmFontListAppendEntry(NULL, newEntry);
1486 XmFontListEntryFree(&newEntry);
1487
1488 if (buttonFontList == NULL) {
1489 _XmWarning(w, "_XmGetDefaultFontList: buttonFontlist NULL\n");
1490 }
1491
1492 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(buttonFontList) -> %p\n",
1493 buttonFontList));
1494 return buttonFontList;
1495
1496 default:
1497 case XmLABEL_FONTLIST:
1498 while ((par = XtParent(par)) != NULL)
1499 {
1500 if (XmIsBulletinBoard(par) && BB_LabelFontList(par) != NULL)
1501 {
1502 fontlist = BB_LabelFontList(par);
1503 break;
1504 }
1505 else if (XmIsMenuShell(par) && MS_LabelFontList(par) != NULL)
1506 {
1507 fontlist = MS_LabelFontList(par);
1508 break;
1509 }
1510 else if (XmIsVendorShell(par))
1511 {
1512 ve = (XmVendorShellExtObject)_LtFindVendorExt((Widget)par);
1513 if (ve && VSEP_LabelFontList(ve) != NULL)
1514 {
1515 fontlist = VSEP_LabelFontList(ve);
1516 break;
1517 }
1518 }
1519 }
1520
1521 if (fontlist)
1522 {
1523 r = XmFontListCopy(fontlist);
1524 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(XmLABEL_FONTLIST) -> %p\n", r));
1525 return r;
1526 }
1527
1528 newEntry = XmFontListEntryLoad(XtDisplay(w),
1529 XmDEFAULT_FONT,
1530 XmFONT_IS_FONT,
1531 XmFONTLIST_DEFAULT_TAG);
1532 labelFontList = XmFontListAppendEntry(NULL, newEntry);
1533 XmFontListEntryFree(&newEntry);
1534
1535 if (labelFontList == NULL) {
1536 _XmWarning(w, "_XmGetDefaultFontList: labelFontList NULL\n");
1537 }
1538
1539 DEBUGOUT(_LtDebug(__FILE__, w, "_XmGetDefaultFontList(labelFontList) -> %p\n",
1540 labelFontList));
1541 return labelFontList;
1542 }
1543 }
1544
1545 /* resource converters, of various types */
1546
1547 extern char *
_XmConvertCSToString(XmString cs)1548 _XmConvertCSToString(XmString cs)
1549 {
1550 return NULL;
1551 }
1552
1553
1554 extern Boolean
_XmCvtXmStringToCT(XrmValue * from,XrmValue * to)1555 _XmCvtXmStringToCT(XrmValue *from,
1556 XrmValue *to)
1557 {
1558 return False;
1559 }
1560
1561 /*
1562 * One to convert from String (char *) to XmString
1563 */
1564 static Boolean
_XmCvtStringToXmString(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)1565 _XmCvtStringToXmString(Display *display,
1566 XrmValue *args,
1567 Cardinal *num_args,
1568 XrmValue *from,
1569 XrmValue *to,
1570 XtPointer *converter_data)
1571 {
1572 static XmString newString = NULL;
1573
1574 if (*num_args != 0)
1575 {
1576 XtWarningMsg("wrongParameters", "cvtStringToXmString",
1577 "XtToolkitError",
1578 "String to XmString conversion needs no extra arguments",
1579 (String *)NULL, (Cardinal *)NULL);
1580 }
1581 newString = XmStringCreateLtoR(from->addr, XmFONTLIST_DEFAULT_TAG);
1582
1583 if (newString)
1584 {
1585 if (to->addr == NULL)
1586 {
1587 to->addr = (XPointer)&newString;
1588 to->size = sizeof(XmString);
1589 }
1590 else
1591 {
1592 if (to->size >= sizeof(XmString))
1593 {
1594 *((XmString *)to->addr) = newString;
1595 to->size = sizeof(XmString);
1596 }
1597 else
1598 {
1599 XtDisplayStringConversionWarning(display, (char *)from->addr,
1600 XmRXmString);
1601 }
1602 }
1603 }
1604 else
1605 {
1606 XtDisplayStringConversionWarning(display, (char *)from->addr,
1607 XmRXmString);
1608 }
1609
1610 DEBUGOUT(_LtDebug(__FILE__, NULL,
1611 "_XmCvtStringToXmString(%s) => %p\n",
1612 from->addr, to->addr));
1613
1614 return True;
1615 }
1616
1617 /*
1618 * This function is only used by the _XmCvtStringToXmFontlist resource
1619 * converter
1620 *
1621 * According to the docs, a font entry is :
1622 * font_entry = font_name [ ";" font_name ]+ ":" [ tag ]
1623 * | font_name [ "=" tag ]
1624 * font_name = XLFD font name
1625 * tag = a string (no space, comma, colon, semicolon, equalsign)
1626 *
1627 * For a simple example, see test/Xm/international/test1.
1628 */
1629 static XmFontList
__XmFontListResourceAddEntry(Display * display,char * full_entry,XmFontList oldFontList)1630 __XmFontListResourceAddEntry(Display *display,
1631 char *full_entry,
1632 XmFontList oldFontList)
1633 {
1634 XmFontList newFontList;
1635 XmFontListEntry newEntry;
1636 char *eq, *end, *fn, *ft, *tag, *font, *semi, *colon;
1637
1638 DEBUGOUT(_LtDebug(__FILE__, NULL,
1639 "__XmFontListResourceAddEntry(%s)\n", full_entry));
1640
1641 eq = strchr(full_entry, (int)'=');
1642
1643 /* there was an equal sign, the left side is the font,
1644 and the right side the tag. */
1645 if (eq)
1646 {
1647 /* set the equal sign to a null so we can XtNewString the font */
1648 *eq = 0;
1649 fn = font = XtNewString(full_entry);
1650
1651 /* set it back again, and XtNewString the tag */
1652 *eq = '=';
1653 ft = tag = XtNewString(eq + 1);
1654
1655 end = font + strlen(font);
1656 while (isspace(*font) && font < end)
1657 {
1658 font++;
1659 }
1660 while (isspace(*end) && end > font)
1661 {
1662 end--;
1663 }
1664
1665 if (end != font + strlen(font))
1666 {
1667 end++;
1668 *end = 0;
1669 }
1670
1671 end = tag + strlen(tag);
1672 while (isspace(*tag) && tag < end)
1673 {
1674 tag++;
1675 }
1676 while (isspace(*end) && end > tag)
1677 {
1678 end--;
1679 }
1680
1681 if (end != tag + strlen(tag))
1682 {
1683 end++;
1684 *end = 0;
1685 }
1686
1687 newEntry = XmFontListEntryLoad(display,
1688 font, XmFONT_IS_FONT, tag);
1689 newFontList = XmFontListAppendEntry(oldFontList, newEntry);
1690
1691 XtFree(ft);
1692 XtFree(fn);
1693
1694 return newFontList;
1695 }
1696
1697 /* Now treat the case with no equal sign */
1698 semi = strchr(full_entry, ';');
1699 colon = strchr(full_entry, ':');
1700
1701 if (semi || colon)
1702 {
1703 /* font_entry = font_name [ ";" font_name ]+ ":" [ tag ] */
1704
1705 /* First find the tag if there is one */
1706 if (colon)
1707 {
1708 tag = colon + 1;
1709 while (tag && *tag != '\0' && isspace(*tag))
1710 {
1711 tag++;
1712 }
1713 if (*tag == '\0')
1714 {
1715 tag = XmFONTLIST_DEFAULT_TAG;
1716 }
1717 }
1718 else
1719 {
1720 tag = XmFONTLIST_DEFAULT_TAG;
1721 }
1722
1723 while((semi = strchr(full_entry, ';')) != NULL)
1724 {
1725 *semi = ',';
1726 }
1727
1728 /* Find all the font names and process them */
1729 fn = font = XtNewString(full_entry);
1730 colon = strchr(fn, ':');
1731
1732 if (colon)
1733 {
1734 *colon = '\0';
1735 }
1736 newEntry = XmFontListEntryLoad(display,
1737 fn, XmFONT_IS_FONTSET, tag);
1738 newFontList = XmFontListAppendEntry(oldFontList, newEntry);
1739
1740 XtFree(fn);
1741
1742 return newFontList;
1743 }
1744
1745 /* A simple font name */
1746 fn = font = XtNewString(full_entry);
1747
1748 end = font + strlen(font);
1749 while (isspace(*font) && font < end)
1750 {
1751 font++;
1752 }
1753
1754 while (isspace(*end) && end > font)
1755 {
1756 end--;
1757 }
1758
1759 if (end != font + strlen(font))
1760 {
1761 end++;
1762 *end = 0;
1763 }
1764 newEntry = XmFontListEntryLoad(display,
1765 full_entry, XmFONT_IS_FONT, XmFONTLIST_DEFAULT_TAG);
1766 newFontList = XmFontListAppendEntry(oldFontList, newEntry);
1767 XtFree(fn);
1768 return newFontList;
1769 }
1770
1771 /*
1772 * This thing should do reference counting, or make copies
1773 * Danny 16/4/1996
1774 */
1775 /*
1776 * According to the docs, the following format should be converted :
1777 * font_list = font_entry [ "," font_entry ]+
1778 * font_entry = font_name [ ";" font_name ]+ ":" [ tag ]
1779 * | font_name [ "=" tag ]
1780 * font_name = XLFD font name
1781 * tag = a string (no space, comma, colon, semicolon, equalsign)
1782 *
1783 * For a simple example, see test/Xm/international/test1.
1784 */
1785 static Boolean
_XmCvtStringToXmFontList(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)1786 _XmCvtStringToXmFontList(Display *display,
1787 XrmValue *args,
1788 Cardinal *num_args,
1789 XrmValue *from,
1790 XrmValue *to,
1791 XtPointer *converter_data)
1792 {
1793 XmFontList newFontList = NULL;
1794 char *p, *end, *font, *fn, *buf;
1795
1796 if (*num_args != 0) {
1797 XtWarningMsg("wrongParameters", "cvtStringToFontlist",
1798 "XtToolkitError",
1799 "String to Fontlist conversion needs no extra arguments",
1800 (String *)NULL, (Cardinal *)NULL);
1801 }
1802
1803 /* there is an implicit rule here. strtok() modifies the passed in buffer
1804 * at least on Linux, so if a comma is found, a \0 is put there. This is
1805 * bad, as this memory didn't come from us, but from the Intrinsics, and
1806 * may get used again (especially if it's in the resource cache)! */
1807
1808 buf = XtNewString(from->addr);
1809
1810 p = strtok(buf, ",");
1811
1812 /* if there was actually a comma character in the string. */
1813 if (p)
1814 {
1815 do
1816 {
1817 fn = font = XtNewString(p);
1818
1819 end = font + strlen(font);
1820 while (isspace(*font) && font < end)
1821 {
1822 font++;
1823 }
1824 while (isspace(*end) && end > font)
1825 {
1826 end--;
1827 }
1828 if (end != font + strlen(font))
1829 {
1830 end++;
1831 *end = 0;
1832 }
1833
1834 newFontList = __XmFontListResourceAddEntry(display, font,
1835 newFontList);
1836
1837 XtFree(fn);
1838 p = strtok(NULL, ",");
1839
1840 }
1841 while (p != NULL);
1842
1843 XtFree(buf);
1844 }
1845 else
1846 {
1847 fn = font = buf;
1848
1849 end = font + strlen(font);
1850 while (isspace(*font) && font < end)
1851 {
1852 font++;
1853 }
1854 while (isspace(*end) && end > font)
1855 {
1856 end--;
1857 }
1858
1859 if (end != font + strlen(font))
1860 {
1861 end++;
1862 *end = 0;
1863 }
1864 newFontList = __XmFontListResourceAddEntry(display, font, newFontList);
1865
1866 XtFree(buf);
1867 }
1868
1869 if (newFontList)
1870 {
1871 if (to->addr == NULL)
1872 {
1873 to->addr = (XPointer)&newFontList;
1874 to->size = sizeof(XmFontList);
1875 }
1876 else
1877 {
1878 if (to->size >= sizeof(XmFontList))
1879 {
1880 *((XmFontList *)to->addr) = newFontList;
1881 to->size = sizeof(XmFontList);
1882 }
1883 else
1884 {
1885 XtDisplayStringConversionWarning(display, (char *)from->addr,
1886 XmRFontList);
1887 }
1888 }
1889 }
1890 else
1891 {
1892 XtDisplayStringConversionWarning(display, (char *)from->addr,
1893 XmRFontList);
1894 }
1895
1896 DEBUGOUT(_LtDebug(__FILE__, NULL, "_XmCvtStringToXmFontList(%s) -> %p\n",
1897 from->addr, *((XmFontList *)to->addr)));
1898
1899 return True;
1900 }
1901
1902 #if 0
1903 /* One from String to XmNavigationType */
1904 static Boolean
1905 _XmCvtStringToXmNavigation(Display *display,
1906 XrmValue *args,
1907 Cardinal *num_args,
1908 XrmValue *from,
1909 XrmValue *to,
1910 XtPointer *converter_data)
1911 {
1912 static XmNavigationType navType;
1913
1914 navType = 10;
1915
1916 if (*num_args != 0)
1917 {
1918 XtWarningMsg("wrongParameters", "cvtStringToXmNavigation",
1919 "XtToolkitError",
1920 "String to XmNavigation conversion needs no extra arguments",
1921 (String *)NULL, (Cardinal *)NULL);
1922 }
1923
1924 if (!strcmp((char *)from->addr, "NONE"))
1925 {
1926 navType = XmNONE;
1927 }
1928 else if (!strcmp((char *)from->addr, "TAB_GROUP"))
1929 {
1930 navType = XmTAB_GROUP;
1931 }
1932 else if (!strcmp((char *)from->addr, "STICKY_TAB_GROUP"))
1933 {
1934 navType = XmSTICKY_TAB_GROUP;
1935 }
1936 else if (!strcmp((char *)from->addr, "EXCLUSIVE_TAB_GROUP"))
1937 {
1938 navType = XmEXCLUSIVE_TAB_GROUP;
1939 }
1940
1941 if (navType != 10)
1942 {
1943 if (to->addr == NULL)
1944 {
1945 to->addr = (XtPointer)&navType;
1946 to->size = sizeof(XmNavigationType);
1947 }
1948 else
1949 {
1950 if (to->size >= sizeof(XmNavigationType))
1951 {
1952 *((XmNavigationType *)to->addr) = navType;
1953 to->size = sizeof(XmNavigationType);
1954 }
1955 else
1956 {
1957 XtDisplayStringConversionWarning(display, (char *)from->addr,
1958 XmRNavigationType);
1959 }
1960 }
1961 }
1962 else
1963 {
1964 XtDisplayStringConversionWarning(display, (char *)from->addr,
1965 XmRNavigationType);
1966 }
1967
1968 return True;
1969 }
1970 #endif
1971
1972 static Boolean
_XmCvtStringToCardinal(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)1973 _XmCvtStringToCardinal(Display *display,
1974 XrmValue *args,
1975 Cardinal *num_args,
1976 XrmValue *from,
1977 XrmValue *to,
1978 XtPointer *converter_data)
1979 {
1980 static Cardinal value;
1981 char *end;
1982
1983 value = 0;
1984 if (*num_args != 0)
1985 {
1986 XtWarningMsg("wrongParameters", "cvtStringToCardinal",
1987 "XtToolkitError",
1988 "String to Cardinal conversion needs no extra arguments",
1989 (String *)NULL, (Cardinal *)NULL);
1990 }
1991
1992 value = strtoul((char *)from->addr, &end, 10);
1993
1994 if (*end == '\0')
1995 {
1996 if (to->addr == NULL)
1997 {
1998 to->addr = (XPointer)&value;
1999 to->size = sizeof(Cardinal);
2000 }
2001 else
2002 {
2003 if (to->size >= sizeof(Cardinal))
2004 {
2005 *((Cardinal *)to->addr) = value;
2006 to->size = sizeof(Cardinal);
2007 }
2008 else
2009 {
2010 XtDisplayStringConversionWarning(display,
2011 (char *)from->addr,
2012 XmRCardinal);
2013 }
2014 }
2015 }
2016 else
2017 {
2018 XtDisplayStringConversionWarning(display,
2019 (char *)from->addr,
2020 XmRCardinal);
2021 }
2022
2023 return True;
2024 }
2025
2026 static Boolean
_XmCvtStringToKeySym(Display * d,XrmValue * args,Cardinal * nargs,XrmValue * from,XrmValue * to,XtPointer * data)2027 _XmCvtStringToKeySym(Display *d, XrmValue *args, Cardinal *nargs,
2028 XrmValue *from, XrmValue *to, XtPointer *data)
2029 {
2030 static KeySym k;
2031
2032 k = XStringToKeysym((char *)from->addr);
2033
2034 if (k != NoSymbol)
2035 {
2036 if (to->addr == NULL)
2037 {
2038 to->addr = (XPointer)&k;
2039 to->size = sizeof(k);
2040 return True;
2041 }
2042 else
2043 {
2044 if (to->size >= sizeof(KeySym))
2045 {
2046 *((KeySym *)to->addr) = k;
2047 to->size = sizeof(k);
2048 return True;
2049 }
2050 else
2051 {
2052 XtDisplayStringConversionWarning(d, (char *)from->addr,
2053 XmRKeySym);
2054 DEBUGOUT(_LtDebug(__FILE__, NULL,
2055 "_XmCvtStringToKeySym fail at line %d\n",
2056 __LINE__));
2057 return False;
2058 }
2059 }
2060 }
2061
2062 XtDisplayStringConversionWarning(d, (char *)from->addr, XmRKeySym);
2063
2064 DEBUGOUT(_LtDebug(__FILE__, NULL,
2065 "_XmCvtStringToKeySym fail at line %d\n", __LINE__));
2066 return False;
2067 }
2068
2069
2070 static Boolean
_XmCvtStringToResIndPosition(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2071 _XmCvtStringToResIndPosition(Display *display,
2072 XrmValue *args,
2073 Cardinal *num_args,
2074 XrmValue *from,
2075 XrmValue *to,
2076 XtPointer *converter_data)
2077 {
2078 static Position pos;
2079
2080 if (*num_args != 3)
2081 XtWarningMsg("wrongParameters", "_XmCvtStringToResIndPosition",
2082 "XtToolkitError",
2083 "String to XmRHorizontal/VerticalPosition conversion needs no extra arguments",
2084 (String *)NULL, (Cardinal *)NULL);
2085
2086 pos = (Position)_XmConvertUnits(*(Screen **)args[0].addr,
2087 (int)(long)*(XtPointer *)args[1].addr,
2088 *(unsigned char *)args[2].addr,
2089 atoi(from->addr),
2090 XmPIXELS);
2091
2092 if (to->addr == NULL)
2093 {
2094 to->addr = (XPointer)&pos;
2095 to->size = sizeof pos;
2096 }
2097 else
2098 {
2099 if (to->size < sizeof pos)
2100 {
2101 XtDisplayStringConversionWarning(display, (char *)from->addr,
2102 (int)(long)*(XtPointer *)args[1].addr == XmHORIZONTAL
2103 ? XmRHorizontalPosition : XmRVerticalPosition);
2104 return False;
2105 }
2106 *(Position *)to->addr = pos;
2107 to->size = sizeof pos;
2108 }
2109
2110 return True;
2111 }
2112
2113
2114 static Boolean
_XmCvtStringToResIndDimension(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2115 _XmCvtStringToResIndDimension(Display *display,
2116 XrmValue *args,
2117 Cardinal *num_args,
2118 XrmValue *from,
2119 XrmValue *to,
2120 XtPointer *converter_data)
2121 {
2122 static Dimension dim;
2123
2124 if (*num_args != 3)
2125 XtWarningMsg("wrongParameters", "_XmCvtStringToResIndDimension",
2126 "XtToolkitError",
2127 "String to XmRHorizontal/VerticalDimension conversion needs no extra arguments",
2128 (String *)NULL, (Cardinal *)NULL);
2129
2130 dim = (Dimension)_XmConvertUnits(*(Screen **)args[0].addr,
2131 (int)(long)*(XtPointer *)args[1].addr,
2132 *(unsigned char *)args[2].addr,
2133 atoi(from->addr),
2134 XmPIXELS);
2135
2136 if (to->addr == NULL)
2137 {
2138 to->addr = (XPointer)&dim;
2139 to->size = sizeof dim;
2140 }
2141 else
2142 {
2143 if (to->size < sizeof dim)
2144 {
2145 XtDisplayStringConversionWarning(display, (char *)from->addr,
2146 (int)(long)*(XtPointer *)args[1].addr == XmHORIZONTAL
2147 ? XmRHorizontalDimension : XmRVerticalDimension);
2148 return False;
2149 }
2150 *(Dimension *)to->addr = dim;
2151 to->size = sizeof dim;
2152 }
2153
2154 return True;
2155 }
2156
2157
2158 static Boolean
_XmCvtStringToResIndInt(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2159 _XmCvtStringToResIndInt(Display *display,
2160 XrmValue *args,
2161 Cardinal *num_args,
2162 XrmValue *from,
2163 XrmValue *to,
2164 XtPointer *converter_data)
2165 {
2166 static int pos;
2167
2168 if (*num_args != 3)
2169 XtWarningMsg("wrongParameters", "_XmCvtStringToResIndInt",
2170 "XtToolkitError",
2171 "String to XmRHorizontal/VerticalInt conversion needs no extra arguments",
2172 (String *)NULL, (Cardinal *)NULL);
2173
2174 pos = _XmConvertUnits(*(Screen **)args[0].addr,
2175 (int)(long)*(XtPointer *)args[1].addr,
2176 *(unsigned char *)args[2].addr,
2177 atoi(from->addr),
2178 XmPIXELS);
2179
2180 if (to->addr == NULL)
2181 {
2182 to->addr = (XPointer)&pos;
2183 to->size = sizeof pos;
2184 }
2185 else
2186 {
2187 if (to->size < sizeof pos)
2188 {
2189 XtDisplayStringConversionWarning(display, (char *)from->addr,
2190 (int)(long)*(XtPointer *)args[1].addr == XmHORIZONTAL
2191 ? XmRHorizontalInt : XmRVerticalInt);
2192 return False;
2193 }
2194 *(int *)to->addr = pos;
2195 to->size = sizeof pos;
2196 }
2197
2198 return True;
2199 }
2200
2201
2202 static Boolean
_XmCvtStringToWidget(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2203 _XmCvtStringToWidget( Display *display,
2204 XrmValue *args,
2205 Cardinal *num_args,
2206 XrmValue *from,
2207 XrmValue *to,
2208 XtPointer *converter_data)
2209 {
2210 Widget parent;
2211 static Widget child;
2212 char *name;
2213
2214 if (*num_args != 1)
2215 XtWarningMsg("wrongParameters", "cvtStringToWidget",
2216 "XtToolkitError",
2217 "String to Widget conversion needs an extra argument",
2218 (String *)NULL, (Cardinal *)NULL);
2219
2220 name = (char *)from->addr;
2221
2222 parent = * (Widget *) args[0].addr;
2223
2224 if (name != NULL)
2225 {
2226 child = XtNameToWidget(parent, name);
2227
2228 if (to->addr == NULL)
2229 {
2230 to->addr = (XPointer)&child;
2231 to->size = sizeof(Widget);
2232 }
2233 else
2234 {
2235 if (to->size >= sizeof(Widget))
2236 {
2237 *((Widget *)to->addr) = child;
2238 to->size = sizeof(Widget);
2239 }
2240 else
2241 {
2242 XtDisplayStringConversionWarning(display, (char *)from->addr,
2243 XmRWidget);
2244 }
2245 }
2246 }
2247 else
2248 {
2249 XtDisplayStringConversionWarning(display, (char *)from->addr,
2250 XmRWidget);
2251 }
2252
2253 return True;
2254 }
2255
2256
2257 static Boolean
_XmCvtStringToWindow(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2258 _XmCvtStringToWindow(Display *display,
2259 XrmValue *args,
2260 Cardinal *num_args,
2261 XrmValue *from,
2262 XrmValue *to,
2263 XtPointer *converter_data)
2264 {
2265 static Window win;
2266
2267 win = atoi( from->addr);
2268 if (to->addr == NULL) {
2269 to->addr = (XPointer)&win;
2270 to->size = sizeof win;
2271 } else {
2272 if (!to->size) {
2273 XtDisplayStringConversionWarning(display, from->addr, XmRWindow);
2274 return False;
2275 }
2276 *to->addr = win;
2277 to->size = sizeof win;
2278 }
2279
2280 return True;
2281 }
2282
2283
2284 static Boolean
_XmCvtStringToBooleanDimension(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2285 _XmCvtStringToBooleanDimension( Display *display,
2286 XrmValue *args,
2287 Cardinal *num_args,
2288 XrmValue *from,
2289 XrmValue *to,
2290 XtPointer *converter_data)
2291 {
2292 static Dimension value;
2293 int preval;
2294 String str;
2295
2296 str = (String)from->addr;
2297
2298 if (*num_args != 3) {
2299 XtWarningMsg("wrongParameters", "cvtStringToBooleanDimension",
2300 "XtToolkitError",
2301 "String to BooleanDimension conversion needs no extra arguments",
2302 (String *)NULL, (Cardinal *)NULL);
2303 }
2304
2305 if (str != NULL) {
2306 if (isdigit(str[0])) {
2307 preval = atoi(from->addr);
2308 value = (Dimension)_XmConvertUnits(*(Screen **)args[0].addr,
2309 (int)(long)*(XtPointer *)args[1].addr,
2310 *(unsigned char *)args[2].addr,
2311 preval,
2312 XmPIXELS);
2313 if (!value && preval)
2314 value = 1;
2315 } else {
2316 if ((strcasecmp(str, "true") == 0) || (strcasecmp(str, "yes") == 0)
2317 || (strcasecmp(str, "on") == 0)) {
2318 value = True;
2319 } else if ((strcasecmp(str, "false") == 0)
2320 || (strcasecmp(str, "no") == 0)
2321 || (strcasecmp(str, "off") == 0)) {
2322 value = False;
2323 } else {
2324 XtDisplayStringConversionWarning(display, str,
2325 XmRBooleanDimension);
2326 return False;
2327 }
2328 }
2329
2330 if (to->addr == NULL) {
2331 to->addr = (XPointer)&value;
2332 to->size = sizeof(value);
2333 } else {
2334 if (to->size >= sizeof(value)) {
2335 *((Dimension *)to->addr) = value;
2336 to->size = sizeof(Dimension);
2337 } else {
2338 XtDisplayStringConversionWarning(display, str,
2339 XmRBooleanDimension);
2340 return False;
2341 }
2342 }
2343 } else {
2344 XtDisplayStringConversionWarning(display, str, XmRBooleanDimension);
2345 return False;
2346 }
2347
2348 return True;
2349 }
2350
2351
2352 static Boolean
_XmCvtStringToChar(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2353 _XmCvtStringToChar( Display *display,
2354 XrmValue *args,
2355 Cardinal *num_args,
2356 XrmValue *from,
2357 XrmValue *to,
2358 XtPointer *converter_data)
2359 {
2360 static char c;
2361
2362 c = from->addr[0];
2363 if (to->addr == NULL) {
2364 to->addr = &c;
2365 to->size = 1;
2366 } else {
2367 if (!to->size) {
2368 XtDisplayStringConversionWarning(display, from->addr, XmRChar);
2369 return False;
2370 }
2371 *to->addr = c;
2372 to->size = 1;
2373 }
2374
2375 return True;
2376 }
2377
2378
2379 static Boolean
_XmCvtStringToTextPosition(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2380 _XmCvtStringToTextPosition( Display *display,
2381 XrmValue *args,
2382 Cardinal *num_args,
2383 XrmValue *from,
2384 XrmValue *to,
2385 XtPointer *converter_data)
2386 {
2387 static XmTextPosition tp;
2388
2389 tp = atol( from->addr);
2390 if (to->addr == NULL) {
2391 to->addr = (XPointer)&tp;
2392 to->size = sizeof tp;
2393 } else {
2394 if (to->size < sizeof tp) {
2395 XtDisplayStringConversionWarning(display, from->addr,
2396 XmRTextPosition);
2397 return False;
2398 }
2399 *(XmTextPosition *)to->addr = tp;
2400 to->size = sizeof tp;
2401 }
2402
2403 return True;
2404 }
2405
2406
2407 static Boolean
_XmCvtStringToTopItemPosition(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2408 _XmCvtStringToTopItemPosition( Display *display,
2409 XrmValue *args,
2410 Cardinal *num_args,
2411 XrmValue *from,
2412 XrmValue *to,
2413 XtPointer *converter_data)
2414 {
2415 static int tip;
2416
2417 tip = atoi( from->addr);
2418 if (to->addr == NULL) {
2419 to->addr = (XPointer)&tip;
2420 to->size = sizeof tip;
2421 } else {
2422 if (to->size < sizeof tip) {
2423 XtDisplayStringConversionWarning(display, from->addr,
2424 XmRTopItemPosition);
2425 return False;
2426 }
2427 *(XmTextPosition *)to->addr = tip;
2428 to->size = sizeof tip;
2429 }
2430
2431 return True;
2432 }
2433
2434
2435 /* Converter for various tables of comma-separated strings,
2436 * with those strings converted each in their own way.
2437 */
2438
2439 static Boolean
_XmCvtStringToSomeTable(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2440 _XmCvtStringToSomeTable( Display *display,
2441 XrmValue *args,
2442 Cardinal *num_args,
2443 XrmValue *from,
2444 XrmValue *to,
2445 XtPointer *converter_data)
2446 {
2447 int nitems, tabsize, tabtype, escaped, anyescaped;
2448 char *item, *p, *str, *sp;
2449 static XtPointer *table;
2450
2451 /* Separate the resource string at commas.
2452 * The commas may be escaped by a backslash
2453 * (leading whitespace and backslashes themselves may be escaped too).
2454 */
2455
2456 table = (XtPointer *)XtMalloc((tabsize = 64) * sizeof(XtPointer));
2457 nitems = 0;
2458 item = NULL;
2459 escaped = anyescaped = False;
2460 tabtype = (int)(long)*(XtPointer *)args[0].addr;
2461 for (p = from->addr;; p++)
2462 {
2463 if (escaped)
2464 {
2465 /* A previously escaped character.
2466 * Treat it like a normal character (not comma, backslash or space)
2467 */
2468
2469 escaped = False;
2470 if (!item)
2471 item = p;
2472 }
2473 else if (p >= from->addr + from->size || !*p || *p == ',')
2474 {
2475 /* End of a string in the table.
2476 * Make a copy to work with, both to add a nul and unescape.
2477 */
2478
2479 if (!item)
2480 item = p;
2481 str = XtMalloc((p - item) + 1);
2482 memcpy(str, item, p - item);
2483 str[p - item] = 0;
2484 if (anyescaped)
2485 {
2486 /* Removed escape characters */
2487
2488 anyescaped = False;
2489 for (sp = str; *sp; sp++)
2490 if (*sp == '\\' && sp[1])
2491 {
2492 memmove(sp, sp + 1, strlen(sp));
2493 sp++;
2494 }
2495 }
2496
2497 /* Encode the string into something and put it in the list */
2498
2499 switch (tabtype)
2500 {
2501 case ST_BUTTON_TYPE:
2502 /* This should use probably use RepType stuff. But that
2503 * converter isn't there, and if it did its name would be
2504 * XmRButtonType, which this erroneously is.
2505 */
2506
2507 if (_XmStringsAreEqual( str, "pushbutton"))
2508 ((XmButtonType *)table)[nitems] = XmPUSHBUTTON;
2509 else if (_XmStringsAreEqual( str, "togglebutton"))
2510 ((XmButtonType *)table)[nitems] = XmTOGGLEBUTTON;
2511 else if (_XmStringsAreEqual( str, "radiobutton"))
2512 ((XmButtonType *)table)[nitems] = XmRADIOBUTTON;
2513 else if (_XmStringsAreEqual( str, "cascadebutton"))
2514 ((XmButtonType *)table)[nitems] = XmCASCADEBUTTON;
2515 else if (_XmStringsAreEqual( str, "separator"))
2516 ((XmButtonType *)table)[nitems] = XmSEPARATOR;
2517 else if (_XmStringsAreEqual( str, "double_separator"))
2518 ((XmButtonType *)table)[nitems] = XmDOUBLE_SEPARATOR;
2519 else if (_XmStringsAreEqual( str, "title"))
2520 ((XmButtonType *)table)[nitems] = XmTITLE;
2521 else
2522 {
2523 XtDisplayStringConversionWarning(display, from->addr,
2524 XmRButtonType);
2525 XtFree(str);
2526 XtFree((char *)table);
2527 return False;
2528 }
2529 break;
2530
2531 case ST_KEY_SYM_TABLE:
2532 if ((table[nitems] = (XtPointer)XStringToKeysym(str)) ==
2533 NoSymbol)
2534 {
2535 XtDisplayStringConversionWarning(display, from->addr,
2536 XmRKeySymTable);
2537 XtFree(str);
2538 XtFree((char *)table);
2539 return False;
2540 }
2541 XtFree(str);
2542 break;
2543
2544 case ST_ATOM_LIST:
2545 /* Convert to atoms later */
2546 case ST_STRING_TABLE:
2547 table[nitems] = str;
2548 break;
2549
2550 case ST_XM_STRING_TABLE:
2551 table[nitems] =
2552 (XtPointer)XmStringCreateLtoR(str, XmFONTLIST_DEFAULT_TAG);
2553 XtFree(str);
2554 }
2555
2556 /* If this is the end of the string, stop looking */
2557
2558 nitems++;
2559 if (p >= from->addr + from->size || !*p)
2560 break;
2561 item = NULL;
2562
2563 /* Bump up the table size, re-allocating if needed */
2564
2565 if (nitems == tabsize)
2566 table = (XtPointer *)XtRealloc((char *)table,
2567 (tabsize <<= 1) * sizeof(XtPointer));
2568 }
2569 else if (*p == '\\' && p < from->addr + from->size - 1 && p[1])
2570 {
2571 /* Escape the next character after a blackslash
2572 * (unless this is the end of the string)
2573 */
2574
2575 escaped = anyescaped = True;
2576 }
2577 else if (!item && !isspace(*p))
2578 {
2579 /* Skip leading whitespace for each item.
2580 * Strangely, trailing whitespace stays.
2581 */
2582
2583 item = p;
2584 }
2585 }
2586
2587 /* Wrap up the conversion, including null-terminating the table */
2588
2589 switch (tabtype)
2590 {
2591 case ST_ATOM_LIST:
2592 /* Now that we have all the atoms, convert them all at once */
2593 {
2594 Atom *atoms = (Atom *)XtMalloc((nitems + 1) * sizeof(Atom));
2595
2596 atoms[nitems] = None;
2597 #if XlibSpecificationRelease > 5
2598 XInternAtoms(display, (char **)table, nitems, False, atoms);
2599 #else
2600 while (nitems--)
2601 XmInternAtom(display, ((char **)table)[nitems], False);
2602 #endif
2603 XtFree((char *)table);
2604 table = (XtPointer *)atoms;
2605 }
2606 break;
2607
2608 case ST_BUTTON_TYPE:
2609 table = (XtPointer *)
2610 XtRealloc((char *)table, (nitems + 1) * sizeof(XmButtonType));
2611 ((XmButtonType *)table)[nitems] = 0;
2612 break;
2613
2614 default:
2615 table = (XtPointer *)
2616 XtRealloc((char *)table, (nitems + 1) * sizeof(XtPointer));
2617 table[nitems] = NULL;
2618 }
2619
2620 if (to->addr == NULL) {
2621 to->addr = (XPointer)&table;
2622 to->size = sizeof table;
2623 } else {
2624 if (to->size < sizeof table) {
2625 XtDisplayStringConversionWarning(display, from->addr,
2626 tabtype == ST_ATOM_LIST ? XmRAtomList :
2627 tabtype == ST_KEY_SYM_TABLE ? XmRKeySymTable :
2628 tabtype == ST_STRING_TABLE ? XmRStringTable :
2629 XmRXmStringTable);
2630 return False;
2631 }
2632 *(XtPointer **)to->addr = table;
2633 to->size = sizeof table;
2634 }
2635
2636 return True;
2637 }
2638
2639
2640 static void
destroy_font_list(XtAppContext app,XrmValue * to,XtPointer converer_data,XrmValue * args,Cardinal * num_args)2641 destroy_font_list(XtAppContext app, XrmValue *to,
2642 XtPointer converer_data, XrmValue *args,
2643 Cardinal *num_args)
2644 {
2645 fprintf(stderr, "_XmCvtStringToXmFontList()\n");
2646 XmFontListFree(*(XmFontList *)to->addr);
2647 }
2648
2649
2650 static void
destroy_table(XtAppContext app,XrmValue * to,XtPointer converer_data,XrmValue * args,Cardinal * num_args)2651 destroy_table(XtAppContext app, XrmValue *to,
2652 XtPointer converer_data, XrmValue *args,
2653 Cardinal *num_args)
2654 {
2655 XtFree(*(char **)to->addr);
2656 }
2657
2658
2659 static void
destroy_string_table(XtAppContext app,XrmValue * to,XtPointer converer_data,XrmValue * args,Cardinal * num_args)2660 destroy_string_table(XtAppContext app, XrmValue *to,
2661 XtPointer converer_data, XrmValue *args,
2662 Cardinal *num_args)
2663 {
2664 int i;
2665 String *table = *(String **)to->addr;
2666
2667 for (i = 0; table[i]; i++)
2668 XtFree(table[i]);
2669 XtFree((char *)table);
2670 }
2671
2672
2673 static void
destroy_xm_string_table(XtAppContext app,XrmValue * to,XtPointer converer_data,XrmValue * args,Cardinal * num_args)2674 destroy_xm_string_table(XtAppContext app, XrmValue *to,
2675 XtPointer converer_data, XrmValue *args,
2676 Cardinal *num_args)
2677 {
2678 int i;
2679 XmStringTable table = *(XmStringTable *)to->addr;
2680
2681 for (i = 0; table[i]; i++)
2682 XmStringFree(table[i]);
2683 XtFree((char *)table);
2684 }
2685
2686
2687 static void
get_unit_type(Widget w,Cardinal * size,XrmValue * val)2688 get_unit_type(Widget w, Cardinal *size, XrmValue *val)
2689 {
2690 static unsigned char ut;
2691
2692 val->addr = (XPointer)&ut;
2693 val->size = sizeof ut;
2694 ut = _XmGetUnitType(w);
2695 }
2696
2697 /*
2698 * XmConvertStringToUnits converts a string specification value and returns
2699 * the converted value as the return value from the function. This function
2700 * uses the specified screen's resolution to compute the number of units for
2701 * the string specification.
2702 */
2703 extern int
XmConvertStringToUnits(Screen * screen,String spec,int orientation,int to_type,XtEnum * parse_error)2704 XmConvertStringToUnits(Screen *screen, String spec, int orientation,
2705 int to_type, XtEnum *parse_error)
2706 {
2707 /* FIX ME not implemented yet */
2708 _XmWarning(NULL, "XmConvertStringToUnits() is not implemented yet!\n");
2709
2710 if (screen == NULL)
2711 return 0;
2712
2713 if (orientation != XmHORIZONTAL && orientation != XmVERTICAL)
2714 return 0;
2715
2716 switch (to_type) {
2717 case XmPIXELS:
2718 case XmMILLIMETERS:
2719 case Xm100TH_MILLIMETERS:
2720 case XmCENTIMETERS:
2721 case XmINCHES:
2722 case Xm1000TH_INCHES:
2723 case XmPOINTS:
2724 case Xm100TH_POINTS:
2725 case XmFONT_UNITS:
2726 case Xm100TH_FONT_UNITS:
2727 break;
2728 default:
2729 return 0;
2730 }
2731 return 0;
2732 }
2733
2734 static Boolean
_XmCvtStringToTabList(Display * display,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)2735 _XmCvtStringToTabList(Display *display,
2736 XrmValue *args,
2737 Cardinal *num_args,
2738 XrmValue *from,
2739 XrmValue *to,
2740 XtPointer *converter_data)
2741 {
2742 int i, count;
2743 struct _XmTabRec **tabs, *thistab;
2744 char *c, *p, *q;
2745 struct _XmTabListRec **d;
2746
2747 DEBUGOUT(_LtDebug(__FILE__, NULL, "_XmCvtStringToTabList(%s)\n", from->addr));
2748 for (i=0, count=1; from->addr[i]; i++)
2749 if (from->addr[i] == ',')
2750 count++;
2751
2752 tabs = (struct _XmTabRec **)XtCalloc(count, sizeof(struct _XmTabRec *));
2753 for (i=0; i<count; i++)
2754 tabs[i] = (struct _XmTabRec *)XtMalloc(sizeof(struct _XmTabRec));
2755
2756 c = q = XtNewString(from->addr);
2757 i=0;
2758 while (q) {
2759 char unit[20];
2760
2761 thistab = tabs[i];
2762 p = strchr(q, ',');
2763 if (p) {
2764 *p = '\0';
2765 }
2766 /* Convert this into an entry */
2767 while (isspace(*q)) q++;
2768 thistab->offset_model = (*q == '+') ? XmRELATIVE : XmABSOLUTE;
2769
2770 unit[0] = '\0';
2771 (void) sscanf(q, "%f%s", &thistab->value, &unit[0]);
2772
2773 /* FIX ME I haven't a clue */
2774 if (strcasecmp("in", unit) == 0) {
2775 thistab->units = XmINCHES;
2776 } else if (strcasecmp("mm", unit) == 0) {
2777 thistab->units = XmMILLIMETERS;
2778 } else if (strcasecmp("cm", unit) == 0) {
2779 thistab->units = XmCENTIMETERS;
2780 } else {
2781 thistab->units = XmPIXELS;
2782 }
2783
2784 thistab->alignment = XmALIGNMENT_BEGINNING;
2785 thistab->decimal = 0;
2786
2787 if (p) {
2788 q = p+1;
2789 } else {
2790 break;
2791 }
2792 i++;
2793 }
2794 XtFree(c);
2795
2796 if (to->addr == NULL) {
2797 to->size = sizeof(XtPointer);
2798 return False;
2799 } else {
2800 if (to->size < sizeof(XtPointer)) {
2801 to->size = sizeof(XtPointer);
2802 return False;
2803 } else {
2804 d = (struct _XmTabListRec **)to->addr;
2805 *d = (struct _XmTabListRec *)XtMalloc(sizeof(struct _XmTabListRec));
2806 (*d)->tabs = tabs;
2807 (*d)->count = count;
2808 }
2809 }
2810
2811 /*
2812 if (to->addr == NULL) {
2813 to->addr = (XPointer)&tip;
2814 to->size = sizeof tip;
2815 } else {
2816 if (to->size < sizeof tip) {
2817 XtDisplayStringConversionWarning(display, from->addr,
2818 XmRTopItemPosition);
2819 return False;
2820 }
2821 *(XmTextPosition *)to->addr = tip;
2822 to->size = sizeof tip;
2823 }
2824 */
2825 return True;
2826 }
2827
2828 #define offset(x) XtOffsetOf(struct __XmRenditionRec, x)
2829
2830 static XtResource rt_res[] = {
2831 #if USE_XFT
2832 { XmNrenditionForeground, XmCRenditionForeground, XtRXftColor,
2833 sizeof(XftColor), offset(xft_foreground.pixel),
2834 XmRImmediate, (XtPointer)XmUNSPECIFIED_PIXEL },
2835 { XmNrenditionBackground, XmCRenditionBackground, XtRXftColor,
2836 sizeof(XftColor), offset(xft_background.pixel),
2837 XmRImmediate, (XtPointer)XmUNSPECIFIED_PIXEL },
2838 #else
2839 { XmNrenditionForeground, XmCRenditionForeground, XmRPixel,
2840 sizeof(Pixel), offset(rendition_foreground),
2841 XmRImmediate, (XtPointer)XmUNSPECIFIED_PIXEL },
2842 { XmNrenditionBackground, XmCRenditionBackground, XmRPixel,
2843 sizeof(Pixel), offset(rendition_background),
2844 XmRImmediate, (XtPointer)XmUNSPECIFIED_PIXEL },
2845 #endif
2846 { XmNfont, XmCFont, XmRFontList,
2847 sizeof(XmFontList), offset(font),
2848 XmRImmediate, (XtPointer)XmAS_IS },
2849 { XmNfontName, XmCFontName, XmRString,
2850 sizeof(String), offset(font_name),
2851 XmRImmediate, (XtPointer)XmAS_IS },
2852 #if USE_XFT
2853 { XmNfontStyle, XmCFontStyle, XmRString,
2854 sizeof(String), offset(font_style),
2855 XmRImmediate, (XtPointer)NULL },
2856 { XmNfontFoundry, XmCFontFoundry, XmRString,
2857 sizeof(String), offset(font_foundry),
2858 XmRImmediate, (XtPointer)NULL },
2859 { XmNfontEncoding, XmCFontEncoding, XmRString,
2860 sizeof(String), offset(font_encoding),
2861 XmRImmediate, (XtPointer)NULL },
2862 { XmNfontSize, XmCFontSize, XmRInt,
2863 sizeof(int), offset(font_size),
2864 XmRImmediate, (XtPointer)0 },
2865 #endif
2866 { XmNloadModel, XmCLoadModel, XmRUnsignedChar,
2867 sizeof(unsigned char), offset(load_model),
2868 XmRImmediate, (XtPointer)XmAS_IS },
2869 { XmNstrikethruType, XmCStrikethruType, XmRUnsignedChar,
2870 sizeof(unsigned char), offset(strike_thru_type),
2871 XmRImmediate, (XtPointer)XmAS_IS },
2872 { XmNtabList, XmCTabList, XmRTabList,
2873 sizeof(XmTabList), offset(tab_list),
2874 XmRImmediate, (XtPointer)XmAS_IS },
2875 { XmNunderlineType, XmCUnderlineType, XmRUnsignedChar,
2876 sizeof(unsigned char), offset(underline_type),
2877 XmRImmediate, (XtPointer)XmAS_IS },
2878 { XmNfontType, XmCFontType, XmRFontType,
2879 sizeof(XmFontType), offset(type), XmRImmediate, NULL },
2880 };
2881
2882 /*
2883 * Recursively build a list of names/classes for this widget
2884 * Recursion necessary because we need them in the reverse order.
2885 */
InitNCList(Widget w,XrmName * names,XrmClass * classes,int * ix)2886 static void InitNCList(Widget w, XrmName *names, XrmClass *classes, int *ix)
2887 {
2888 Widget p;
2889 XrmQuark cn;
2890
2891 if (w == NULL)
2892 return;
2893 p = XtParent(w);
2894 if (p) {
2895 InitNCList(p, names, classes, ix);
2896 cn = XrmStringToQuark(w->core.widget_class->core_class.class_name);
2897 } else {
2898 if (XtIsApplicationShell(w)) {
2899 /*
2900 * Need to figure out the application class name
2901 */
2902 cn = ((ApplicationShellWidget)w)->application.xrm_class;
2903 } else {
2904 /* Assuming that this doesn't happen,
2905 * but the assignment below won't harm. */
2906 cn = XrmStringToQuark(w->core.widget_class->core_class.class_name);
2907 }
2908 }
2909
2910
2911 DEBUGOUT(_LtDebug(__FILE__, w, "InitNCList(%s, %s, %d)\n", XtName(w),
2912 XrmQuarkToString(cn), *ix));
2913
2914 names[*ix] = XrmStringToQuark(XtName(w));
2915 classes[*ix] = cn;
2916 (*ix)++;
2917 }
2918 /*
2919 * Create a rendition from the resources.
2920 * Returns true if found.
2921 */
2922 static Boolean
_XmRenditionFromResources(Display * dpy,Widget w,String name,String cl,XmStringTag tag,XmRendition * rp)2923 _XmRenditionFromResources(Display *dpy,
2924 Widget w,
2925 String name,
2926 String cl,
2927 XmStringTag tag,
2928 XmRendition *rp)
2929 {
2930 XmRendition r;
2931 XrmName nn[10], *names = &nn[0];
2932 XrmClass cll[10], *classes = &cll[0];
2933 XrmHashTable *searchlist = 0;
2934 XrmDatabase db = NULL;
2935 int len = 8; /* Means initially 16 */
2936 int i, ix;
2937 Boolean found = False;
2938 XrmRepresentation tr;
2939 XrmValue v, to;
2940
2941 DEBUGOUT(_LtDebug(__FILE__, w,
2942 "_XmRenditionFromResources(name %s, class %s, tag %s)\n",
2943 name, cl, tag));
2944
2945 /* Initialise names and classes to create a search list from */
2946 ix = 0;
2947 InitNCList(w, names, classes, &ix);
2948
2949 names[ix] = XrmStringToQuark(name);
2950 classes[ix++] = XrmStringToQuark(cl);
2951 if (tag && strlen(tag)) {
2952 names[ix] = XrmStringToQuark(tag);
2953 classes[ix++] = XrmStringToQuark(XmCRendition);
2954 }
2955 names[ix] = NULLQUARK;
2956 classes[ix++] = NULLQUARK;
2957
2958 /* Search the database in an efficient way, using a prepared search list */
2959
2960 db = XtScreenDatabase(XtScreenOfObject(w));
2961
2962 /* Set up a search list */
2963 do {
2964 len *= 2;
2965 searchlist = (XrmHashTable *)XtRealloc((char *)searchlist,
2966 sizeof(XrmHashTable) * len);
2967 for (i=0; i<len; i++)
2968 searchlist[i]=0; /* Not necessary */
2969 } while (! XrmQGetSearchList(db, names, classes, searchlist, len));
2970
2971 /* Create a rendition to fill up */
2972 r = XmRenditionCreate(w, tag, NULL, 0);
2973
2974 /* Find resource values and convert them and store them */
2975 for (i=0; i<XtNumber(rt_res); i++) {
2976 if (XrmQGetSearchResource(searchlist,
2977 XrmStringToQuark(rt_res[i].resource_name),
2978 XrmStringToQuark(rt_res[i].resource_class),
2979 &tr, &v)) {
2980 Boolean success;
2981
2982 to.addr = ((char *)r) + rt_res[i].resource_offset;
2983 to.size = rt_res[i].resource_size;
2984
2985 success = XtConvertAndStore(w,
2986 XmRString, &v,
2987 rt_res[i].resource_type, &to);
2988 if (!success) {
2989 /* Hack FIX ME This cannot be right */
2990 if (strcmp(rt_res[i].resource_type, XmRString) == 0) {
2991 /* String to string */
2992 char **d = (char **)to.addr;
2993 *d = XtNewString(v.addr);
2994 found = True;
2995 DEBUGOUT(_LtDebug(__FILE__, w,
2996 "Convert from %s to %s value %s, %s\n",
2997 XmRString,
2998 rt_res[i].resource_type,
2999 v.addr,
3000 "fixed"));
3001 continue;
3002 }
3003 /* Conversion failure */
3004 DEBUGOUT(_LtDebug(__FILE__, w,
3005 "Convert from %s to %s value %s, %s\n",
3006 XmRString,
3007 rt_res[i].resource_type,
3008 v.addr,
3009 success ? "success" : "failed"));
3010 continue;
3011 } else {
3012 DEBUGOUT(_LtDebug(__FILE__, w,
3013 "Convert from %s to %s value %s, %s\n",
3014 XmRString,
3015 rt_res[i].resource_type,
3016 v.addr,
3017 success ? "success" : "failed"));
3018 }
3019
3020 found = True;
3021
3022 DEBUGOUT(_LtDebug(__FILE__, w,
3023 "_XmRenditionFromResources(%s,%s) -> %s (%p)\n",
3024 rt_res[i].resource_name,
3025 rt_res[i].resource_class,
3026 (char *)v.addr, r));
3027 #if 0
3028 } else {
3029 DEBUGOUT(_LtDebug(__FILE__, w, "_XmRenditionFromResources: no %s, %s\n",
3030 rt_res[i].resource_name,
3031 rt_res[i].resource_class));
3032 #endif
3033 }
3034 }
3035
3036 #if 0
3037 for (i=0; i<XtNumber(rt_res); i++) {
3038 char st[32];
3039 if (XrmGetResource(db,
3040 rt_res[i].resource_name, rt_res[i].resource_class, &st, &v)) {
3041 fprintf(stderr, "Found %s (%s)\n", rt_res[i].resource_name, v);
3042 }
3043 }
3044 #endif
3045 if (searchlist)
3046 XtFree((char *)searchlist);
3047 if (found && rp) {
3048 *rp = r;
3049 return True;
3050 }
3051 return False;
3052 }
3053
3054 static Boolean
_XmCvtStringToRenderTable(Display * dpy,XrmValue * args,Cardinal * num_args,XrmValue * from,XrmValue * to,XtPointer * converter_data)3055 _XmCvtStringToRenderTable(Display *dpy,
3056 XrmValue *args,
3057 Cardinal *num_args,
3058 XrmValue *from,
3059 XrmValue *to,
3060 XtPointer *converter_data)
3061 {
3062 char *list, *l;
3063 XmRendition r;
3064 XmRenderTable rt = NULL, ort;
3065 int i, count = 0;
3066 Boolean found;
3067
3068 Widget w = * (Widget *) args[0].addr;
3069
3070 /*
3071 * *One.renderTable: green, variable
3072 * *One.renderTable.green.renditionForeground: Green
3073 * *One.renderTable.green.fontName: AS_IS
3074 * *One.renderTable.variable.underlineType: SINGLE_LINE
3075 * *One.renderTable.variable.renditionForeground: Red
3076 *
3077 * _MOTIF_DEFAULT_LOCALE
3078 *
3079 * If the search of the render table results in no font
3080 * or fontset, then if there is a rendition in the
3081 * render table with a tag of _MOTIF_DEFAULT_LOCALE,
3082 * and if that rendition specifies a font, then that
3083 * font will be used. If no font or fontset is specified
3084 * at this point, the text component will not be rendered
3085 * and a warning message will be displayed.
3086 */
3087 /*
3088 * We've got a comma-separated list in 'from',
3089 * split it up and create renditions for it.
3090 */
3091 l = list = XtMalloc(from->size + 1);
3092 strncpy(list, from->addr, from->size);
3093 list[from->size] = '\0';
3094
3095 DEBUGOUT(_LtDebug(__FILE__, w, "_XmCvtStringToRenderTable(%s)\n", list));
3096
3097 while (1) {
3098 char *p = strchr(l, ',');
3099 int last = 0;
3100
3101 if (p)
3102 *p = '\0';
3103 else
3104 last = 1;
3105 /* We've got one, cut leading spaces */
3106 while (isspace(*l))
3107 l++;
3108
3109 found = _XmRenditionFromResources(dpy, w,
3110 XmNrenderTable, XmCRenderTable,
3111 l, &r);
3112 if (found) {
3113 ort = rt;
3114 rt = XmRenderTableAddRenditions(ort, &r, 1, XmMERGE_REPLACE);
3115 XmRenderTableFree(ort);
3116 count++;
3117 }
3118
3119 /* Look for more entries */
3120 l = p+1;
3121 if (last)
3122 break;
3123 }
3124 XtFree(list);
3125
3126 #if 1
3127 /*
3128 * Is this an additional case or mutually exclusive with the loop above ??
3129 * FIX ME
3130 *
3131 * Support the case of an empty renderTable list, as in
3132 * *One.renderTable:
3133 * *One.renderTable.renditionForeground: Green
3134 * *One.renderTable.fontName: AS_IS
3135 */
3136 found = _XmRenditionFromResources(dpy, w,
3137 XmNrenderTable, XmCRenderTable,
3138 NULL, &r);
3139 if (found) {
3140 /* Now this rendition's tag is NULL, replace it by something sensible */
3141 if (r->tag == NULL)
3142 r->tag = _MOTIF_DEFAULT_LOCALE;
3143
3144 ort = rt;
3145 rt = XmRenderTableAddRenditions(ort, &r, 1, XmMERGE_REPLACE);
3146 XmRenderTableFree(ort);
3147 count++;
3148 }
3149 #endif
3150 /*
3151 * Apart from the explicit list above, also scan for the
3152 * _MOTIF_DEFAULT_LOCALE specifications.
3153 */
3154 found = _XmRenditionFromResources(dpy, w,
3155 XmNrenderTable, XmCRenderTable,
3156 "_MOTIF_DEFAULT_LOCALE", &r);
3157 if (found) {
3158 ort = rt;
3159 rt = XmRenderTableAddRenditions(ort, &r, 1, XmMERGE_REPLACE);
3160 XmRenderTableFree(ort);
3161 count++;
3162 }
3163
3164 #if 0
3165 /*
3166 * This crashes XBAE/examples/multibyte/multibyte
3167 */
3168 XmRenditionFree(r); /* ??? Leak removal ??? */
3169 #endif
3170
3171 /*
3172 * The test below is a silly hack.
3173 */
3174 if (!rt) {
3175 to->addr = NULL;
3176 to->size = sizeof(&rt);
3177 XmRenderTableFree(rt);
3178 DEBUGOUT(_LtDebug(__FILE__, w, "_XmCvtStringToRenderTable -> failed 1\n"));
3179 return False;
3180 }
3181 #if 0
3182 /*
3183 * Defining this gets us to have both an X Core font and an Xft font.
3184 * Unnecessary, time consuming, ..
3185 */
3186 #define XFT_FALLBACK
3187 #endif
3188
3189 #if defined(XFT_FALLBACK) || !defined(USE_XFT)
3190 /*
3191 * Even though we want to implement font rendering through Xft,
3192 * we do (currently still) need the font information to be present
3193 * by loading the font.
3194 * This should eventually only be executed when we're not using Xft.
3195 * FIX ME
3196 */
3197 for (i=0; i<rt->count; i++) {
3198 XmRendition r = rt->renditions[i];
3199 if (r->font_name && r->font == (XFontSet)XmAS_IS) {
3200 if (r->type == XmFONT_IS_FONT) {
3201 XFontStruct *fs = XLoadQueryFont(XtDisplay(w), r->font_name);
3202 if (fs) {
3203 r->font = (XFontSet)fs;
3204 DEBUGOUT(_LtDebug(__FILE__, w, "StringToFont(%s) -> %p\n",
3205 r->font_name, fs));
3206 } else {
3207 fs = XLoadQueryFont(XtDisplay(w), "fixed");
3208 if (fs) {
3209 r->font = (XFontSet)fs;
3210 DEBUGOUT(_LtDebug(__FILE__, w,
3211 "StringToFont(fixed) -> %p\n", fs));
3212 } else {
3213 _XmWarning(w, "Couldn't load default font");
3214 }
3215 }
3216 } else if (r->type == XmFONT_IS_FONTSET) {
3217 XFontSet fs;
3218 char **mclr = NULL;
3219 int mccr;
3220 fs = XCreateFontSet(XtDisplay(w), r->font_name,
3221 &mclr, &mccr, NULL);
3222 DEBUGOUT(_LtDebug(__FILE__, w,
3223 "XCreateFontSet(%s) -> %p, %d missing\n",
3224 r->font_name, fs, mccr));
3225 r->font = fs;
3226 }
3227 }
3228 }
3229 #endif
3230
3231 /*
3232 * Let's also do this for Xft here,
3233 * even though I'm not at all sure that this is the best place.
3234 */
3235 #ifdef USE_XFT
3236 for (i=0; i<rt->count; i++) {
3237 if (rt->renditions[i]->xft_font == 0 &&
3238 (rt->renditions[i]->pattern || rt->renditions[i]->font_name)) {
3239 XmRendition r = rt->renditions[i];
3240 XftResult res;
3241 XftPattern *p;
3242
3243 r->pattern = FcPatternCreate();
3244 if (r->font_name)
3245 FcPatternAddString(r->pattern, XFT_FAMILY,
3246 (unsigned char*)r->font_name);
3247 if (r->font_foundry)
3248 FcPatternAddString(r->pattern, XFT_FOUNDRY,
3249 (unsigned char*)r->font_foundry);
3250 if (r->font_encoding)
3251 FcPatternAddString(r->pattern, XFT_ENCODING,
3252 (unsigned char*)r->font_encoding);
3253 if (r->font_style)
3254 FcPatternAddString(r->pattern, XFT_STYLE,
3255 (unsigned char*)r->font_style);
3256 if (r->font_size)
3257 FcPatternAddInteger(r->pattern, XFT_SIZE, r->font_size);
3258 if (r->pixel_size)
3259 FcPatternAddInteger(r->pattern, XFT_PIXEL_SIZE, r->pixel_size);
3260 if (r->font_slant)
3261 FcPatternAddInteger(r->pattern, XFT_SLANT, r->font_slant);
3262 if (r->font_weight)
3263 FcPatternAddInteger(r->pattern, XFT_WEIGHT, r->font_weight);
3264 if (r->font_spacing)
3265 FcPatternAddInteger(r->pattern, XFT_SPACING, r->font_spacing);
3266
3267 p = XftFontMatch(XtDisplay(w), 0, r->pattern, &res);
3268 r->xft_font = XftFontOpenPattern(XtDisplay(w), p);
3269 _XmXftFontAverageWidth(w,
3270 (XtPointer)r->xft_font,
3271 &r->font_average_width,
3272 &r->font_average_height);
3273
3274 r->type = XmFONT_IS_XFT;
3275 r->font = NULL; /* HACK */
3276
3277 DEBUGOUT(_LtDebug(__FILE__, w,
3278 "Xft Find Font(fn %s) -> font %p\n",
3279 r->font_name, r->xft_font));
3280 }
3281 }
3282 #endif
3283
3284 /* Make sure we have a display */
3285 if (! rt->dpy)
3286 rt->dpy = dpy;
3287
3288 /*
3289 * Do the dance, as in any Xt converter, to return your info.
3290 */
3291 if (to->size < sizeof(&rt)) {
3292 to->size = sizeof(&rt);
3293 XmRenderTableFree(rt);
3294 to->addr = NULL;
3295 DEBUGOUT(_LtDebug(__FILE__, w, "_XmCvtStringToRenderTable -> failed 2\n"));
3296 return False;
3297 }
3298 if (to->addr == NULL)
3299 to->addr = (XtPointer)&rt;
3300 else
3301 *(XmRenderTable *)(to->addr) = rt;
3302
3303 to->addr = (XtPointer)&rt;
3304
3305 DEBUGOUT(_LtDebug(__FILE__, w,
3306 "_XmCvtStringToRenderTable -> %p, %d elements\n", rt, count));
3307
3308 return True;
3309 }
3310
3311 static void
_XmCvtRenderTableFree(XtAppContext app,XrmValue * to,XtPointer converter_data,XrmValue * args,Cardinal * num_args)3312 _XmCvtRenderTableFree(XtAppContext app, XrmValue *to,
3313 XtPointer converter_data, XrmValue *args,
3314 Cardinal *num_args)
3315 {
3316 int i;
3317 XmRenderTable table = *(XmRenderTable *)to->addr;
3318
3319 for (i=0; i<table->count; i++) {
3320 if (table->renditions[i]->type == XmFONT_IS_FONT) {
3321 XFreeFont(table->dpy, (XFontStruct *)table->renditions[i]->font);
3322 } else {
3323 /* FIX ME */
3324 }
3325 }
3326
3327 #if 0
3328 fprintf(stderr, "_XmCvtRenderTableFree(%p)\n", table);
3329 #endif
3330 DEBUGOUT(_LtDebug(__FILE__, NULL, "_XmCvtRenderTableFree(%p)\n", table));
3331 XmRenderTableFree(table);
3332 }
3333
3334 #if USE_XFT
3335 /*
3336 * The functions XmuCvtStringToXftColor() and XmuFreeXftColor() were
3337 * "stolen" from the xclock source (xc/programs/xclock/Clock.c).
3338 * The source file carried the following license text at the time :
3339 *
3340 * Copyright 1987, 1988, 1998 The Open Group
3341 *
3342 * Permission to use, copy, modify, distribute, and sell this software and its
3343 * documentation for any purpose is hereby granted without fee, provided that
3344 * the above copyright notice appear in all copies and that both that
3345 * copyright notice and this permission notice appear in supporting
3346 * documentation.
3347 *
3348 * The above copyright notice and this permission notice shall be included in
3349 * all copies or substantial portions of the Software.
3350 *
3351 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3352 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3353 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
3354 * OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
3355 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
3356 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
3357 *
3358 * Except as contained in this notice, the name of The Open Group shall not be
3359 * used in advertising or otherwise to promote the sale, use or other dealings
3360 * in this Software without prior written authorization from The Open Group.
3361 *
3362 *
3363 * Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts.
3364 *
3365 * All Rights Reserved
3366 *
3367 * Permission to use, copy, modify, and distribute this software and its
3368 * documentation for any purpose and without fee is hereby granted,
3369 * provided that the above copyright notice appear in all copies and that
3370 * both that copyright notice and this permission notice appear in
3371 * supporting documentation, and that the name of Digital not be
3372 * used in advertising or publicity pertaining to distribution of the
3373 * software without specific, written prior permission.
3374 *
3375 * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
3376 * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
3377 * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
3378 * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
3379 * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
3380 * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
3381 * SOFTWARE.
3382 */
3383
3384 #define donestr(type, value, tstr) \
3385 { \
3386 if (toVal->addr != NULL) { \
3387 if (toVal->size < sizeof(type)) { \
3388 toVal->size = sizeof(type); \
3389 XtDisplayStringConversionWarning(dpy, \
3390 (char*) fromVal->addr, tstr); \
3391 return False; \
3392 } \
3393 *(type*)(toVal->addr) = (value); \
3394 } \
3395 else { \
3396 static type static_val; \
3397 static_val = (value); \
3398 toVal->addr = (XPointer)&static_val; \
3399 } \
3400 toVal->size = sizeof(type); \
3401 return True; \
3402 }
3403
3404 static Boolean
XmuCvtStringToXftColor(Display * dpy,XrmValue * args,Cardinal * num_args,XrmValue * fromVal,XrmValue * toVal,XtPointer * converter_data)3405 XmuCvtStringToXftColor(Display *dpy,
3406 XrmValue *args, Cardinal *num_args,
3407 XrmValue *fromVal, XrmValue *toVal,
3408 XtPointer *converter_data)
3409 {
3410 char *spec;
3411 XRenderColor renderColor;
3412 XftColor xftColor;
3413 Screen *screen;
3414 Colormap colormap;
3415
3416 if (*num_args != 2)
3417 {
3418 XtAppErrorMsg (XtDisplayToApplicationContext (dpy),
3419 "cvtStringToXftColor", "wrongParameters",
3420 "XtToolkitError",
3421 "String to render color conversion needs screen and colormap arguments",
3422 (String *) NULL, (Cardinal *)NULL);
3423 return False;
3424 }
3425
3426 screen = *((Screen **) args[0].addr);
3427 colormap = *((Colormap *) args[1].addr);
3428
3429 spec = (char *) fromVal->addr;
3430 if (strcasecmp (spec, XtDefaultForeground) == 0)
3431 {
3432 renderColor.red = 0;
3433 renderColor.green = 0;
3434 renderColor.blue = 0;
3435 renderColor.alpha = 0xffff;
3436 }
3437 else if (strcasecmp (spec, XtDefaultBackground) == 0)
3438 {
3439 renderColor.red = 0xffff;
3440 renderColor.green = 0xffff;
3441 renderColor.blue = 0xffff;
3442 renderColor.alpha = 0xffff;
3443 }
3444 else if (!XRenderParseColor (dpy, spec, &renderColor))
3445 return False;
3446 if (!XftColorAllocValue (dpy,
3447 DefaultVisual (dpy,
3448 XScreenNumberOfScreen (screen)),
3449 colormap,
3450 &renderColor,
3451 &xftColor))
3452 return False;
3453
3454 donestr (XftColor, xftColor, XtRXftColor);
3455 }
3456
3457 static void
XmuFreeXftColor(XtAppContext app,XrmValuePtr toVal,XtPointer closure,XrmValuePtr args,Cardinal * num_args)3458 XmuFreeXftColor (XtAppContext app, XrmValuePtr toVal, XtPointer closure,
3459 XrmValuePtr args, Cardinal *num_args)
3460 {
3461 Screen *screen;
3462 Colormap colormap;
3463 XftColor *color;
3464
3465 if (*num_args != 2)
3466 {
3467 XtAppErrorMsg (app,
3468 "freeXftColor", "wrongParameters",
3469 "XtToolkitError",
3470 "Freeing an XftColor requires screen and colormap arguments",
3471 (String *) NULL, (Cardinal *)NULL);
3472 return;
3473 }
3474
3475 screen = *((Screen **) args[0].addr);
3476 colormap = *((Colormap *) args[1].addr);
3477 color = (XftColor *) toVal->addr;
3478 XftColorFree (DisplayOfScreen (screen),
3479 DefaultVisual (DisplayOfScreen (screen),
3480 XScreenNumberOfScreen (screen)),
3481 colormap, color);
3482 }
3483
3484
3485 #endif
3486
3487 extern unsigned int
XmCvtXmStringToByteStream(XmString string,unsigned char ** prop_return)3488 XmCvtXmStringToByteStream(XmString string,
3489 unsigned char **prop_return)
3490 {
3491 _XmWarning(NULL, "XmConvertStringToUnits() is not implemented yet!\n");
3492 return 0;
3493 }
3494
3495
3496
3497 extern XmString
XmCvtByteStreamToXmString(unsigned char * property)3498 XmCvtByteStreamToXmString(unsigned char *property)
3499 {
3500 _XmWarning(NULL, "XmCvtByteStreamToXmString() is not implemented yet!\n");
3501 return NULL;
3502 }
3503
3504
3505 extern int
XmCvtXmStringTableToTextProperty(Display * display,XmStringTable string_table,int count,XmICCEncodingStyle style,XTextProperty * text_prop_return)3506 XmCvtXmStringTableToTextProperty (Display *display,
3507 XmStringTable string_table,
3508 int count,
3509 XmICCEncodingStyle style,
3510 XTextProperty *text_prop_return)
3511 {
3512 _XmWarning(NULL, "XmCvtXmStringTableToTextProperty() is not implemented yet!\n");
3513 return 0;
3514 }
3515