1 /*
2 * Motif
3 *
4 * Copyright (c) 1987-2012, The Open Group. All rights reserved.
5 *
6 * These libraries and programs are free software; you can
7 * redistribute them and/or modify them under the terms of the GNU
8 * Lesser General Public License as published by the Free Software
9 * Foundation; either version 2 of the License, or (at your option)
10 * any later version.
11 *
12 * These libraries and programs are distributed in the hope that
13 * they will be useful, but WITHOUT ANY WARRANTY; without even the
14 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
15 * PURPOSE. See the GNU Lesser General Public License for more
16 * details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with these librararies and programs; if not, write
20 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
21 * Floor, Boston, MA 02110-1301 USA
22 */
23 /*
24 * HISTORY
25 */
26 #ifdef REV_INFO
27 #ifndef lint
28 static char rcsid[] = "$XConsortium: wsmData.c /main/6 1995/07/14 09:48:38 drk $"
29 #endif
30 #endif
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <Xm/Xm.h>
34 #include "wsm.h"
35 #include "wsmDebug.h"
36 #include "xrmLib.h"
37
38 void
39 LongListDestructor(
40 XtAppContext ,
41 XrmValuePtr,
42 XtPointer,
43 XrmValuePtr ,
44 Cardinal *
45 );
46
47 Boolean CvtStringToLongList(
48 Display *,
49 XrmValuePtr,
50 Cardinal *,
51 XrmValuePtr,
52 XrmValuePtr,
53 XtPointer *
54 );
55
56
57 extern XrmQuark hideq;
58 extern IndexStruct wsm_index;
59 extern Widget shell;
60 extern Space *current_space;
61 extern Space *space_list;
62
63
64 /*------------------------------------------------------------------
65 UpdateXrm
66
67 Save the current workspaceList, backgroundList, and labelPixmapList
68 ------------------------------------------------------------------*/
69 void
UpdateXrm()70 UpdateXrm()
71 {
72 Space *s;
73 char *s_list;
74 char *b_list;
75 char *p_list;
76 char *c_space;
77 int curr_size = 0;
78 int max_size =200;
79
80 s_list = (char*) XtMalloc(max_size *sizeof(char));
81 s_list[0] = '\0';
82 for (s = space_list; s != NULL; s = s->next)
83 {
84 curr_size = strlen(s->name) + 2;
85 if (curr_size > max_size)
86 {
87 max_size +=100;
88 s_list = (char*)XtRealloc(s_list,max_size*sizeof(char));
89 }
90 strcat(s_list,s->name);
91 if (s->next != NULL)
92 strcat(s_list,",");
93 }
94
95 max_size = 200;
96 b_list = (char*) XtMalloc(max_size *sizeof(char));
97 b_list[0] = '\0';
98 for (s = space_list; s != NULL; s = s->next)
99 {
100 curr_size = strlen(s->background) + 2;
101 if (curr_size > max_size)
102 {
103 max_size +=100;
104 b_list = (char*)XtRealloc(b_list,max_size*sizeof(char));
105 }
106 strcat(b_list,s->background);
107 if (s->next != NULL)
108 strcat(b_list,",");
109 }
110
111 max_size = 200;
112 p_list = (char*) XtMalloc(max_size *sizeof(char));
113 p_list[0] = '\0';
114 for (s = space_list; s != NULL; s = s->next)
115 {
116 curr_size = strlen(s->pixmap_name) + 2;
117 if (curr_size > max_size)
118 {
119 max_size +=100;
120 p_list = (char*)XtRealloc(p_list,max_size*sizeof(char));
121 }
122 strcat(p_list,s->pixmap_name);
123 if (s->next != NULL)
124 strcat(p_list,",");
125 }
126
127 max_size = strlen(current_space->name) +1;
128 c_space = (char*) XtMalloc( max_size*sizeof(char));
129 strcpy(c_space,current_space->name);
130 (void )SaveSpaceListResources(s_list,b_list,p_list,c_space);
131
132 XtFree((char*)s_list);
133 XtFree((char*)b_list);
134 XtFree((char*)p_list);
135 XtFree((char*)c_space);
136 }
137
138
139
140 /*------------------------------------------------------------------
141 ConvertToWsmData
142
143 Convert an XrmValue into a WSMWinData
144 ------------------------------------------------------------------*/
145 Boolean
ConvertToWSMData(XrmValue * value,WSMWinData * win_data,WSMWinData * start_data,WSMAttribute * attrib)146 ConvertToWSMData(XrmValue *value,
147 WSMWinData *win_data,
148 WSMWinData *start_data,
149 WSMAttribute *attrib)
150 {
151 XrmValue toVal;
152 XtPointer fByte;
153 int i,j;
154 static Boolean register_long_converter;
155 toVal.size = sizeof(fByte);
156 toVal.addr = (XtPointer)&fByte;
157 if (!(attrib->is_list))
158 {
159 if (XtConvertAndStore(shell,
160 XtRString,
161 value,
162 XtRInt,
163 &toVal))
164 {
165 if (start_data->type == WSM_NONE ||
166 (int) *(int*)toVal.addr != (int) start_data->data.value )
167 {
168 win_data->nameq = attrib->nameq;
169 win_data->data.value = *(int*)toVal.addr;
170 win_data->type = WSM_VALUE_DATA;
171 #ifdef DEBUG2
172 PRINT(" value %s %s %ld %ld\n",XrmQuarkToString(attrib->nameq),
173 (char*)value->addr,*(int*)toVal.addr,start_data->data.value);
174 #endif
175 return True;
176 }
177 else return False;
178 }
179 }
180 else if (attrib->size == sizeof(long)*8)
181 {
182 if (!register_long_converter)
183 {
184 XtSetTypeConverter(XtRString,"LongList",CvtStringToLongList,NULL,
185 0, XtCacheNone,LongListDestructor);
186 register_long_converter = True;
187 }
188 if (XtConvertAndStore(shell,
189 XtRString,
190 value,
191 "LongList",
192 &toVal))
193 {
194 win_data->nameq = attrib->nameq;
195 win_data->data.long_ptr = *(long**)toVal.addr;
196 win_data->data_len = toVal.size;
197 win_data->type = WSM_LONG_LIST_DATA;
198 #ifdef DEBUG2
199 PRINT("value stackingOrder %d: ", win_data->data_len);
200 for (j = 0; j < toVal.size; j++)
201 PRINT(" %ld ",win_data->data.long_ptr[j]);
202 PRINT("\n");
203 #endif
204 return True;
205 }
206 }
207 else
208 {
209 PRINT("not converted to wsm struct\n");
210 }
211 return False;
212 }
213
214
215
216 /*------------------------------------------------------------------
217 WinDataCopy
218
219 Copy a WSMWinData structure
220 ------------------------------------------------------------------*/
221 void
WinDataCopy(WSMWinData * w_data,WSMWinData * copy_data)222 WinDataCopy(WSMWinData *w_data,
223 WSMWinData *copy_data)
224 {
225 int i;
226 switch(copy_data->type) {
227 case WSM_CHAR_LIST_DATA:
228 {
229 w_data->type = WSM_CHAR_LIST_DATA;
230 break;
231 }
232 case WSM_SHORT_LIST_DATA:
233 {
234 w_data->type = WSM_SHORT_LIST_DATA;
235 break;
236 }
237 case WSM_LONG_LIST_DATA:
238 {
239 /* long *long_list;
240 if (w_data->data_len != 0)
241 XtFree((XtPointer)w_data->data.long_ptr);
242 long_list = (long*)XtMalloc(copy_data->data_len*sizeof(long));
243 for (i = 0; i < copy_data->data_len; i ++)
244 long_list[i] = copy_data->data.long_ptr[i];
245 w_data->data.long_ptr =long_list;
246 */
247 w_data->type = WSM_LONG_LIST_DATA;
248 break;
249 }
250 case WSM_VALUE_DATA:
251 {
252 w_data->data.value =copy_data->data.value;
253 w_data->type = WSM_VALUE_DATA;
254 break;
255 }
256 case WSM_NONE:
257 /* Not handled case */
258 break;
259 }
260 w_data->nameq = copy_data->nameq;
261
262 }
263
264
265
266 /*------------------------------------------------------------------
267 CreateWSMWinData
268
269 Create WSMWinData list from an XrmValue list
270 ------------------------------------------------------------------*/
271 Boolean
CreateWSMWinData(XrmValue * value_list,Boolean diffs_allowed,WorkWindow * w_window,WSMWinData ** win_data_return,int * num_data_return)272 CreateWSMWinData(XrmValue *value_list,
273 Boolean diffs_allowed,
274 WorkWindow *w_window, /* return */
275 WSMWinData **win_data_return, /* return */
276 int *num_data_return) /* return */
277 {
278 int i;
279 Boolean retval = False;
280 WSMWinData *win_data;
281 Boolean in_dbase;
282 int num_data = 0;
283 *num_data_return = 0;
284
285 win_data = NULL;
286 #ifdef DEBUG
287 PRINT("enter CreateWinData ......\n");
288 #endif
289 /* win_data is returned for use in a set state request */
290 win_data = (WSMWinData*)XtMalloc(w_window->num_attrib_list*sizeof(WSMWinData));
291
292 /* loop through attributes and convert value_list to win_data */
293 for (i = 0; i < w_window->num_attrib_list; i++)
294 {
295 in_dbase = False;
296 /* if value in database */
297 if (value_list != NULL)
298 if (value_list[i].size > 0)
299 {
300 /* convert it and assign */
301 if (ConvertToWSMData(&(value_list[i]),
302 &(win_data[num_data]),
303 &(w_window->win_data[i]),
304 &(w_window->attrib_list[i])))
305 {
306 WinDataCopy(&(w_window->win_data[i]), &(win_data[num_data]));
307 num_data++;
308 retval = True;
309 in_dbase = True;
310 }
311 }
312 /* if not in database and diffs aren't allowed*/
313 if (!diffs_allowed && !in_dbase && w_window->win_data != NULL)
314 {
315 #ifdef DEBUG
316 PRINT(" no %s\n",XrmQuarkToString(w_window->attrib_qlist[0]));
317 #endif
318 WinDataCopy(&(win_data[num_data]),&(w_window->win_data[i]));
319 num_data++;
320 }
321 }
322
323 if (num_data !=0)
324 {
325 win_data = (WSMWinData*) XtRealloc((char *)win_data, num_data *sizeof(WSMWinData));
326 *win_data_return = win_data;
327 }
328 else
329 {
330 XtFree((char*)win_data);
331 *win_data_return = NULL;
332 }
333 *num_data_return = num_data;
334 #ifdef DEBUG
335 PRINT("return\n");
336 #endif
337 return retval;
338 }
339
340
341
342
343 /*------------------------------------------------------------------
344 CreateStartWSMWinData
345
346 Create WSMWinData list from an XrmValue list and initialize
347 a windows WSMWinData list.
348 ------------------------------------------------------------------*/
349 Boolean
CreateStartWSMWinData(XrmValue * value_list,Boolean diffs_allowed,WSMWinData * start_win_data,int num_start_win_data,WorkWindow * w_window,WSMWinData ** win_data_return,int * num_data_return)350 CreateStartWSMWinData(XrmValue *value_list,
351 Boolean diffs_allowed,
352 WSMWinData *start_win_data,
353 int num_start_win_data,
354 WorkWindow *w_window,
355 WSMWinData **win_data_return, /* return */
356 int *num_data_return) /* return */
357 {
358 int i;
359 WSMWinData *start_data;
360
361 /* set internal start_win_data_return */
362 if (start_win_data != NULL)
363 {
364 for (i = 0; i < w_window->num_attrib_list; i++)
365 {
366 start_data = _WSMGetMatchingWinData(start_win_data,
367 num_start_win_data,
368 w_window->attrib_qlist[i]);
369 if (start_data != NULL)
370 WinDataCopy(&(w_window->win_data[i]),start_data);
371 }
372 }
373
374 return CreateWSMWinData(value_list,
375 diffs_allowed,
376 w_window,
377 win_data_return,
378 num_data_return);
379 }
380
381
382
383
384
385 /*------------------------------------------------------------------
386 CreateHideWSMWinData
387
388 Create WSMData list with hidden = True.
389 ------------------------------------------------------------------*/
390 void
CreateHideWSMWinData(Boolean diffs_allowed,WorkWindow * w_window,WSMWinData ** win_data_return,int * num_data_return)391 CreateHideWSMWinData(Boolean diffs_allowed,
392 WorkWindow *w_window,
393 WSMWinData **win_data_return,
394 int *num_data_return)
395 {
396 int i;
397 WSMWinData *win_data = NULL;
398 int num_data = 0;
399
400 *num_data_return = 0;
401
402 #ifdef DEBUG
403 PRINT("enter CreateHideWSMWinData ......");
404 #endif
405
406 if (diffs_allowed && _WSMGetConfigFormatType(w_window->window) == WSM_WINDOW_FMT)
407 {
408 win_data = (WSMWinData*)XtMalloc(sizeof(WSMWinData));
409 num_data = 1;
410 win_data[0].data.value = 1;
411 win_data[0].nameq = hideq;
412 win_data[0].type = WSM_VALUE_DATA;
413 WinDataCopy(&(w_window->win_data[wsm_index.hide]), &(win_data[0]));
414 }
415
416 else if (_WSMGetConfigFormatType(w_window->window) == WSM_WINDOW_FMT)
417 {
418 win_data = (WSMWinData*)XtMalloc(w_window->num_attrib_list *sizeof(WSMWinData));
419 for (i = 0; i < w_window->num_attrib_list; i++)
420 {
421 if (w_window->attrib_qlist[i] == hideq)
422 win_data[i].data.value = 1;
423 else
424 WinDataCopy(&(win_data[num_data]),&(w_window->win_data[i]));
425 num_data++;
426 }
427 w_window->win_data[wsm_index.hide].data.value = 1;
428 }
429
430 *win_data_return = win_data;
431 *num_data_return = num_data;
432 #ifdef DEBUG
433 PRINT("return\n");
434 #endif
435 }
436
437
438
439
440 /*------------------------------------------------------------------
441 CreateStartHideWSMWinData
442
443 Create WSMWinData list with hidden = True and initialize window's
444 WSMWinData list
445 ------------------------------------------------------------------*/
446 void
CreateStartHideWSMWinData(Boolean diffs_allowed,WSMWinData * start_win_data,int num_start_win_data,WorkWindow * w_window,WSMWinData ** win_data_return,int * num_data_return)447 CreateStartHideWSMWinData(Boolean diffs_allowed,
448 WSMWinData *start_win_data,
449 int num_start_win_data,
450 WorkWindow *w_window,
451 WSMWinData **win_data_return,
452 int *num_data_return)
453 {
454 int i;
455 WSMWinData *start_data;
456
457
458 for (i = 0; i < w_window->num_attrib_list; i++)
459 {
460 if (w_window->attrib_list[i].nameq == hideq)
461 {
462 w_window->win_data[i].data.value = 1;
463 w_window->win_data[i].nameq = hideq;
464 w_window->win_data[i].type = WSM_VALUE_DATA;
465 }
466 else
467 {
468 if (start_win_data != NULL)
469 {
470 start_data = _WSMGetMatchingWinData(start_win_data,
471 num_start_win_data,
472 w_window->attrib_qlist[i]);
473 if (start_data != NULL)
474 WinDataCopy(&(w_window->win_data[i]),start_data);
475 }
476 }
477 }
478
479 CreateHideWSMWinData(diffs_allowed,
480 w_window,
481 win_data_return,
482 num_data_return);
483
484 }
485
486
487 /*------------------------------------------------------------------
488 CreateUnhideWSMWinData
489
490 Create WSMWinData list with hidden = False
491 ------------------------------------------------------------------*/
492 void
CreateUnhideWSMWinData(XrmValue * value,WorkWindow * w_window,WSMWinData ** win_data_return,int * num_data_return)493 CreateUnhideWSMWinData(XrmValue *value,
494 WorkWindow *w_window,
495 WSMWinData **win_data_return,
496 int *num_data_return)
497 {
498 WSMWinData *win_data;
499 XrmValue toVal;
500 XtPointer fByte;
501 int num_data = 0;
502 *num_data_return = 0;
503
504 #ifdef DEBUG
505 PRINT("enter CreateUnhideWSMWinData ......\n");
506 #endif
507
508 win_data = NULL;
509 num_data = 0;
510
511 if (_WSMGetConfigFormatType(w_window->window) == WSM_WINDOW_FMT)
512 {
513 if (win_data == NULL)
514 win_data = (WSMWinData*)XtMalloc(sizeof(WSMWinData));
515 win_data[num_data].data.value = 0;
516 win_data[num_data].nameq = hideq;
517 win_data[num_data].type = WSM_VALUE_DATA;
518 w_window->win_data[wsm_index.hide].data.value = 0;
519 num_data++;
520 }
521 *win_data_return = win_data;
522 *num_data_return = num_data;
523 #ifdef DEBUG
524 PRINT("return\n");
525 #endif
526 }
527
528
529
530
531 /*------------------------------------------------------------------
532 FreeValues
533
534 Free values created in CreateValues
535 ------------------------------------------------------------------*/
536 void
FreeValues(int num_values,XrmValue * value_list)537 FreeValues(int num_values, XrmValue *value_list)
538 {
539 int i;
540 if (value_list == NULL) return;
541 for (i = 0; i < num_values; i++)
542 {
543 if (value_list[i].size !=0 && value_list[i].addr != NULL)
544 XtFree((XtPointer)value_list[i].addr);
545 }
546 XtFree((XtPointer)value_list);
547
548 }
549
550
551 /*------------------------------------------------------------------
552 CreateValues
553
554 Create XrmValue list from WSMWinData list
555 ------------------------------------------------------------------*/
556 Boolean
CreateValues(WorkWindow * w_window,WSMWinData * data_list,int num_data_list,XrmValue ** value_list_return)557 CreateValues(WorkWindow *w_window,
558 WSMWinData *data_list,
559 int num_data_list,
560 XrmValue **value_list_return)
561 {
562
563 int i;
564 WSMWinData *win_data;
565 XrmValue *values;
566 char* str;
567 char tempstr[10];
568 int num_values;
569
570
571 #ifdef DEBUG
572 PRINT("enter CreateValues ...\n");
573 #endif
574 win_data = NULL;
575 num_values = 0;
576 values = (XrmValue*)XtMalloc(w_window->num_attrib_list*sizeof(XrmValue));
577 for (i = 0; i < w_window->num_attrib_list; i++)
578 {
579 win_data = _WSMGetMatchingWinData(data_list,
580 num_data_list,
581 w_window->attrib_qlist[i]);
582 if (win_data != NULL)
583 {
584 switch(win_data->type) {
585 case WSM_CHAR_LIST_DATA:
586 {
587 }
588 case WSM_SHORT_LIST_DATA:
589 {
590 }
591 case WSM_LONG_LIST_DATA:
592 {
593 str = (char*)XtMalloc(10 * (win_data->data_len) *sizeof(char));
594 str[0] = '\0';
595 for (i = 0; i < win_data->data_len; i++)
596 {
597 sprintf(tempstr,"%ld",win_data->data.long_ptr[i]);
598 strcat(str,tempstr);
599 if (i < win_data->data_len -1) strcat(str,",");
600 }
601 values[num_values].addr = str;
602 values[num_values].size = strlen(str)+1;
603 num_values++;
604 break;
605 }
606 case WSM_VALUE_DATA:
607 {
608 str = (char*)XtMalloc(10 *sizeof(char));
609 sprintf(str,"%ld", win_data->data.value);
610 values[num_values].addr = str;
611 values[num_values].size = strlen(str) +1;
612 #ifdef DEBUG
613 PRINT(" V: %s = %s \n",XrmQuarkToString(w_window->attrib_qlist[i]),str);
614 #endif
615 num_values++;
616 break;
617 }
618 case WSM_NONE:
619 /* Not handled case */
620 break;
621 }
622 }
623 else
624 {
625 values[num_values].addr = NULL;
626 values[num_values].size = 0;
627 num_values++;
628 }
629 }
630 *value_list_return = values;
631 #ifdef DEBUG
632 PRINT("return\n");
633 #endif
634 if (num_values == 0) return False;
635 else return True;
636 }
637
638
639
640 /*------------------------------------------------------------------
641 UpdateWinData
642 ------------------------------------------------------------------*/
643 void
UpdateWinData(WSMWinData * win_data,int win_data_count,WSMWinData * start_win_data,int start_win_data_count)644 UpdateWinData(WSMWinData *win_data,
645 int win_data_count,
646 WSMWinData *start_win_data,
647 int start_win_data_count)
648 {
649 int i;
650 WSMWinData *start_data;
651
652 for (i = 0; i < win_data_count; i++)
653 {
654 start_data = _WSMGetMatchingWinData(start_win_data,
655 start_win_data_count,
656 win_data[i].nameq);
657 if (start_data != NULL)
658 WinDataCopy(start_data,&(win_data[i]));
659 }
660
661 }
662
663
664 Boolean
CvtStringToLongList(Display * dpy,XrmValuePtr args,Cardinal * num_args,XrmValuePtr from,XrmValuePtr to,XtPointer * data)665 CvtStringToLongList(Display *dpy, XrmValuePtr args,
666 Cardinal *num_args, XrmValuePtr from, XrmValuePtr to, XtPointer *data)
667 {
668
669 register int i, count = 1;
670 register char *ch;
671 char *start = from->addr;
672 int len;
673 static long *list;
674 Boolean reset;
675 char *str;
676 XrmValue value, toVal;
677 if (*num_args != 0)
678 {
679 XtAppErrorMsg(XtDisplayToApplicationContext(dpy),
680 "cvtStringToSTringList", "wrongParamters",
681 "XtToolkitError",
682 "String to string list conversion needs no extra args",
683 (String *) NULL, (Cardinal *) NULL);
684 }
685 if (to->addr != NULL && to->size < sizeof(XtPointer)) {
686 to->size = sizeof(XtPointer);
687 return FALSE;
688 }
689
690 if (start == NULL || *start == '\0') list = NULL;
691 else
692 {
693 count = 1;
694 for (ch = start; *ch != '\0'; ch++)
695 {
696 if (*ch == ',')
697 count++;
698 }
699 list = (long*)XtMalloc(count*sizeof(long));
700 str = (char*)XtMalloc(10*sizeof(char));
701 for (i = 0; i < count; i++)
702 {
703 for (ch = start; *ch != ',' && *ch != '\0'; ch++){}
704 len = ch - start;
705 strncpy(str,start,len);
706 str[len] = '\0';
707 list[i] = atol(str);
708 start = ch+1;
709 }
710 XtFree((XtPointer) str);
711 }
712 if (to->addr == NULL) to->addr = (caddr_t)&list;
713 else *(long**) to->addr = list;
714 to->size = count;
715 return TRUE;
716
717 }
718
719
720 void
LongListDestructor(XtAppContext app,XrmValuePtr to,XtPointer converter_data,XrmValuePtr args,Cardinal * num_args)721 LongListDestructor(XtAppContext app, XrmValuePtr to ,
722 XtPointer converter_data,
723 XrmValuePtr args,
724 Cardinal *num_args)
725 {
726 long *list = (long *) to->addr;
727 long *entry;
728
729 if (list == NULL) return;
730
731 for (entry = list; entry != NULL; entry++)
732 {
733 XtFree((XtPointer)entry);
734 }
735
736 XtFree((XtPointer)list);
737 }
738