gwenhywfar  4.8.0beta
fox16_gui_dialog.cpp
Go to the documentation of this file.
1 /***************************************************************************
2  begin : Fri Jan 22 2010
3  copyright : (C) 2010 by Martin Preuss
4  email : martin@libchipcard.de
5 
6  ***************************************************************************
7  * Please see toplevel file COPYING for license details *
8  ***************************************************************************/
9 
10 #ifdef HAVE_CONFIG_H
11 # include <config.h>
12 #endif
13 
14 #include "fox16_gui_dialog_l.hpp"
16 #include "fox16_htmllabel.hpp"
17 #include "fox16_htmltext.hpp"
18 
19 #include "theme.h"
20 
21 #include <gwenhywfar/dialog_be.h>
22 #include <gwenhywfar/directory.h>
23 #include <gwenhywfar/debug.h>
24 
25 #include <list>
26 #include <string>
27 #include <assert.h>
28 
29 #include <fxkeys.h>
30 
31 
32 #define FOX16_DIALOG_WIDGET_REAL 0
33 #define FOX16_DIALOG_WIDGET_CONTENT 1
34 
35 #define FOX16_DIALOG_STRING_TITLE 0
36 #define FOX16_DIALOG_STRING_VALUE 1
37 
38 
39 
40 
41 
42 FXDEFMAP(FOX16_GuiDialog) FOX16_GuiDialogMap[]={
47 };
48 
49 
50 FXIMPLEMENT(FOX16_GuiDialog, FXObject, FOX16_GuiDialogMap, ARRAYNUMBER(FOX16_GuiDialogMap))
51 
52 
53 
55 :FXObject()
56 ,CppDialog()
57 ,_gui(NULL)
58 ,_widgetCount(0)
59 ,_mainWidget(NULL)
60 ,m_iconSource(NULL)
61 ,m_sizeChanged(FALSE)
62 {
63 }
64 
65 
66 
68 :FXObject()
69 ,CppDialog(dlg)
70 ,_gui(gui)
71 ,_widgetCount(0)
72 ,_mainWidget(NULL)
73 ,m_iconSource(NULL)
74 ,m_sizeChanged(FALSE)
75 {
76 }
77 
78 
79 
81  if (_mainWidget)
82  delete _mainWidget;
83  if (!m_iconList.empty()) {
84  std::list<FXIcon*>::iterator it;
85 
86  for (it=m_iconList.begin(); it!=m_iconList.end(); it++)
87  delete *it;
88  m_iconList.clear();
89  }
90  if (m_iconSource)
91  delete m_iconSource;
92 
93  if (!m_radioGroups.empty()) {
94  std::list<RadioButtonGroup*>::iterator it;
95 
96  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++)
97  delete *it;
98  }
99 }
100 
101 
102 
104  CppDialog *cppDlg;
105 
106  cppDlg=CppDialog::getDialog(dlg);
107  if (cppDlg)
108  return dynamic_cast<FOX16_GuiDialog*>(cppDlg);
109  return NULL;
110 }
111 
112 
113 
114 FXIcon *FOX16_GuiDialog::getIcon(const char *fileName) {
115  GWEN_STRINGLIST *sl;
116 
118  if (sl) {
119  GWEN_BUFFER *tbuf;
120  int rv;
121  FXIcon *ic;
122 
123  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
124  rv=GWEN_Directory_FindFileInPaths(sl, fileName, tbuf);
125  if (rv<0) {
126  DBG_ERROR(GWEN_LOGDOMAIN, "here (%d)", rv);
127  GWEN_Buffer_free(tbuf);
128  return NULL;
129  }
130 
131  if (m_iconSource==NULL)
132  m_iconSource=new FXIconSource(FXApp::instance());
133 
134  DBG_DEBUG(GWEN_LOGDOMAIN, "Loading [%s]", GWEN_Buffer_GetStart(tbuf));
135  ic=m_iconSource->loadIconFile(GWEN_Buffer_GetStart(tbuf));
136  if (ic==NULL) {
137  DBG_ERROR(GWEN_LOGDOMAIN, "Could not load icon [%s]", GWEN_Buffer_GetStart(tbuf));
138  GWEN_Buffer_free(tbuf);
139  return NULL;
140  }
141  m_iconList.push_back(ic);
142  GWEN_Buffer_free(tbuf);
143  return ic;
144  }
145  else {
146  DBG_ERROR(GWEN_LOGDOMAIN, "No media paths in dialog");
147  return NULL;
148  }
149 }
150 
151 
152 
154  FXDialogBox *dialogBox;
155  int rv;
156 
157  dialogBox=_mainWidget;
158 
159  /* execute dialog */
160  dialogBox->show(PLACEMENT_OWNER);
161  rv=dialogBox->execute();
163 
164  if (rv==0) {
165  /* aborted */
166  return 0;
167  }
168  else
169  /* accepted */
170  return 1;
171 }
172 
173 
176  int index,
177  int value,
178  int doSignal) {
179  DBG_DEBUG(GWEN_LOGDOMAIN, "SetIntProperty([%s], %d)", GWEN_Widget_GetName(w), value);
180 
181  switch(GWEN_Widget_GetType(w)) {
183  return GWEN_ERROR_GENERIC;
184 
186  return GWEN_ERROR_GENERIC;
187 
189  {
190  THEMECOMBOBOX *f;
191 
193  assert(f);
194 
195  switch(prop) {
197  if (value<f->getNumItems()) {
198  f->setCurrentItem(value, doSignal?TRUE:FALSE);
199  return 0;
200  }
201  else {
202  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range in widget [%s]", value, GWEN_Widget_GetName(w));
203  return GWEN_ERROR_INVALID;
204  }
205 
207  f->clearItems();
208  return 0;
209 
210  default:
211  break;
212  }
213  break;
214  }
215 
217  {
218  FXRadioButton *f;
219 
221  assert(f);
222 
223  switch(prop) {
225  f->setCheck((value==0)?FALSE:TRUE, doSignal?TRUE:FALSE);
226  return 0;
227 
228  default:
229  break;
230  }
231  break;
232  }
233 
235  {
236  FXProgressBar *f;
237 
239  assert(f);
240 
241  switch(prop) {
243  f->setProgress(value);
244  return 0;
245 
247  if (value!=0) {
248  DBG_ERROR(GWEN_LOGDOMAIN, "MinValue should be 0!");
249  return GWEN_ERROR_INVALID;
250  }
251  return 0;
252 
254  f->setTotal(value);
255  return 0;
256 
257  default:
258  break;
259  }
260  break;
261  }
262 
264  {
265  FXSpinner *f;
266 
268  assert(f);
269 
270  switch(prop) {
272  f->setValue(value);
273  return 0;
274 
276  FXint lo, hi;
277 
278  f->getRange(lo, hi);
279  lo=value;
280  f->setRange(lo, hi);
281  return 0;
282  }
283 
285  FXint lo, hi;
286 
287  f->getRange(lo, hi);
288  hi=value;
289  if (hi<lo)
290  hi=lo;
291  f->setRange(lo, hi);
292  return 0;
293  }
294 
295  default:
296  break;
297  }
298  break;
299  }
300 
302  {
304  FXFoldingItem *fi;
305  int i=0;
306 
308  assert(f);
309 
310  switch(prop) {
312  fi=f->getFirstItem();
313  while(fi && i<value) {
314  fi=fi->getNext();
315  i++;
316  }
317  if (fi && i==value)
318  f->setCurrentItem(fi, doSignal?TRUE:FALSE);
319  else {
320  DBG_ERROR(GWEN_LOGDOMAIN, "Value %d out of range", value);
321  return GWEN_ERROR_INVALID;
322  }
323  return 0;
324 
326  f->setHeaderSize(index, value);
327  return 0;
328 
330  switch(value) {
332  /* simply fall-through */
334  f->setListStyle(FOLDINGLIST_BROWSESELECT);
335  return 0;
337  f->setListStyle(FOLDINGLIST_EXTENDEDSELECT);
338  return 0;
339  ;
340  }
341  DBG_ERROR(GWEN_LOGDOMAIN, "Unknown SelectionMode %d", value);
342  return GWEN_ERROR_INVALID;
343 
345  {
346  FXFoldingItem *ti;
347 
348  ti=f->getItem(index);
349  if (ti==NULL) {
350  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
351  return GWEN_ERROR_INVALID;
352  }
353  ti->setSelected((value==0)?FALSE:TRUE);
354  return 0;
355  }
356 
358  f->clearItems();
359  return 0;
360 
362  {
363  int i;
364 
365  for (i=0; i<f->getNumHeaders(); i++) {
366  if (i==index) {
367  switch(value) {
369  f->setHeaderArrowDir(i, MAYBE);
370  break;
372  f->setHeaderArrowDir(i, TRUE);
373  break;
375  f->setHeaderArrowDir(i, FALSE);
376  break;
377  }
378  }
379  else
380  f->setHeaderArrowDir(i, MAYBE);
381  }
382 
383  switch(value) {
385  break;
387  f->sortByColumn(i, true);
388  break;
390  f->sortByColumn(i, false);
391  break;
392  }
393  }
394  return 0;
395 
397  {
398  int i;
399 
400  for (i=0; i<f->getNumHeaders(); i++) {
401  FXbool b;
402 
403  b=f->getHeaderArrowDir(i);
404  if (b!=MAYBE) {
405  if (b==TRUE)
406  f->sortByColumn(i, true);
407  else
408  f->sortByColumn(i, false);
409  break;
410  }
411  }
412  }
413  return 0;
414 
415 
416  default:
417  break;
418  }
419  break;
420  }
421 
423  {
424  FXCheckButton *f;
425 
427  assert(f);
428 
429  switch(prop) {
431  f->setCheck((value==0)?FALSE:TRUE, doSignal?TRUE:FALSE);
432  return 0;
433 
434  default:
435  break;
436  }
437  break;
438  }
439 
441  {
442  FXTabBook *f;
443 
445  assert(f);
446 
447  switch(prop) {
449  f->setCurrent(value, doSignal?TRUE:FALSE);
450  return 0;
451 
452  default:
453  break;
454  }
455  break;
456  }
457 
459  {
460  FXSwitcher *f;
461 
463  assert(f);
464 
465  switch(prop) {
467  f->setCurrent(value, doSignal?TRUE:FALSE);
468  return 0;
469 
470  default:
471  break;
472  }
473  break;
474  }
475 
492  ;
493  }
494 
495  {
496  FXWindow *f;
497 
499  assert(f);
500 
501  switch(prop) {
503  f->recalc();
504  f->resize(value, f->getHeight());
505  m_sizeChanged=TRUE;
506  return 0;
508  f->recalc();
509  f->resize(f->getWidth(), value);
510  m_sizeChanged=TRUE;
511  return 0;
513  if (value==0)
514  f->disable();
515  else
516  f->enable();
517  return 0;
518 
520  f->setFocus();
521  return 0;
522 
524  if (value==0) {
525  f->hide();
526  f->recalc();
527  }
528  else {
529  f->show();
530  f->recalc();
531  }
532  return 0;
533 
549  ;
550  }
551  }
552 
553  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
555  return GWEN_ERROR_INVALID;
556 }
557 
558 
559 
562  int index,
563  int defaultValue) {
564  switch(GWEN_Widget_GetType(w)) {
567  return defaultValue;
568 
570  {
571  THEMECOMBOBOX *f;
572 
574  assert(f);
575 
576  switch(prop) {
578  return f->getCurrentItem();
579 
581  return f->getNumItems();
582 
583  default:
584  break;
585  }
586  break;
587  }
588 
590  {
591  FXRadioButton *f;
592 
594  assert(f);
595 
596  switch(prop) {
598  return (f->getCheck()==TRUE)?1:0;
599 
600  default:
601  break;
602  }
603  break;
604  }
605 
607  {
608  FXProgressBar *f;
609 
611  assert(f);
612 
613  switch(prop) {
615  return f->getProgress();
616 
618  return 0;
619 
621  return f->getTotal();
622 
623  default:
624  break;
625  }
626 
627  break;
628  }
629 
631  {
632  FXSpinner *f;
633 
635  assert(f);
636 
637  switch(prop) {
639  return f->getValue();
640 
642  FXint lo, hi;
643 
644  f->getRange(lo, hi);
645  return lo;
646  }
647 
649  FXint lo, hi;
650 
651  f->getRange(lo, hi);
652  return hi;
653  }
654 
655  default:
656  break;
657  }
658 
659  break;
660  }
661 
663  {
665  FXFoldingItem *fi;
666  int i=0;
667 
669  assert(f);
670 
671  switch(prop) {
673  fi=f->getCurrentItem();
674  if (fi==NULL)
675  return defaultValue;
676  else {
677  FXFoldingItem *ti;
678 
679  ti=fi;
680  while( (ti=ti->getPrev()) )
681  i++;
682 
683  return i;
684  }
685 
687  return f->getNumItems();
688 
690  return f->getHeaderSize(index);
691 
693  {
694  switch(f->getListStyle()) {
695  case FOLDINGLIST_BROWSESELECT:
697  case FOLDINGLIST_EXTENDEDSELECT:
699  default:
701  }
702  break;
703  }
704 
706  {
707  FXFoldingItem *ti;
708  int i=index;
709 
710  ti=f->getFirstItem();
711  while(ti && i) {
712  ti=ti->getNext();
713  i--;
714  }
715 
716  if (ti)
717  return (ti->isSelected()==TRUE)?1:0;
718  return defaultValue;
719  }
720 
722  {
723  int i;
724 
725  for (i=0; i<f->getNumHeaders(); i++) {
726  if (i==index) {
727  FXbool b;
728 
729  b=f->getHeaderArrowDir(i);
730  if (b==MAYBE)
732  else if (b==TRUE)
734  else
736  }
737  }
738  DBG_ERROR(GWEN_LOGDOMAIN, "Column %d out of range", index);
739  }
740  return defaultValue;
741 
742  default:
743  break;
744  }
745 
746  break;
747  }
748 
750  {
751  FXCheckButton *f;
752 
754  assert(f);
755 
756  switch(prop) {
758  return (f->getCheck()==TRUE)?1:0;
759 
760  default:
761  break;
762  }
763 
764  break;
765  }
766 
768  {
769  FXTabBook *f;
770 
772  assert(f);
773 
774  switch(prop) {
776  return f->getCurrent();
777 
778  default:
779  break;
780  }
781 
782  break;
783  }
784 
786  {
787  FXSwitcher *f;
788 
790  assert(f);
791 
792  switch(prop) {
794  return f->getCurrent();
795 
796  default:
797  break;
798  }
799 
800  break;
801  }
802 
819  break;
820  }
821 
822  /* generic properties every widget has */
823  {
824  FXWindow *f;
825 
827  assert(f);
828 
829  switch(prop) {
831  return f->getWidth();
832 
834  return f->getHeight();
835 
837  return (f->isEnabled()==TRUE)?1:0;
838 
840  return (f->hasFocus())?1:0;
841 
858  ;
859  }
860  }
861 
862 
863  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
865  return defaultValue;
866 }
867 
868 
869 
872  int index,
873  const char *value,
874  int doSignal) {
875 
876  FXString strValue;
877  FXString htmlValue;
878 
879  if (value && *value) {
880  strValue=FOX16_Gui::getRawText(value);
881  htmlValue=FOX16_Gui::getHtmlText(value);
882  }
883 
884  switch(GWEN_Widget_GetType(w)) {
886  return GWEN_ERROR_GENERIC;
888  return GWEN_ERROR_GENERIC;
889 
891  {
892  FOX16_HtmlLabel *f;
893 
895  assert(f);
896 
897  switch(prop) {
899  f->setText(htmlValue);
900  return 0;
901 
902  default:
903  break;
904  }
905  break;
906  }
907 
909  {
910  FOX16_HtmlText *f;
911 
913  assert(f);
914 
915  switch(prop) {
917  f->setText(htmlValue);
918  f->makePositionVisible(strValue.length());
919  return 0;
920 
922  f->setText(f->getText()+htmlValue);
923  return 0;
924 
926  f->setText("");
927  return 0;
928 
929  default:
930  break;
931  }
932  break;
933 
934  }
935 
937  {
938  THEMEBUTTON *f;
939 
941  assert(f);
942 
943  switch(prop) {
945  f->setText(value);
946  return 0;
947 
949  f->setTipText(htmlValue);
950  return 0;
951 
952  default:
953  break;
954  }
955  break;
956  }
957 
959  {
960  FXTextField *f;
961 
963  assert(f);
964 
965  switch(prop) {
967  f->setText(value, doSignal?TRUE:FALSE);
968  return 0;
969 
971  f->setTipText(htmlValue);
972  return 0;
973 
974  default:
975  break;
976  }
977  break;
978  }
979 
981  {
982  FXText *f;
983 
985  assert(f);
986 
987  switch(prop) {
989  f->setText(strValue);
990  return 0;
991 
993  f->setTipText(htmlValue);
994  return 0;
995 
996  default:
997  break;
998  }
999  break;
1000  }
1001 
1003  {
1004  THEMECOMBOBOX *f;
1005 
1007  assert(f);
1008 
1009  switch(prop) {
1011  // undefined
1012  break;
1013 
1015  f->setTipText(htmlValue);
1016  return 0;
1017 
1019  {
1020  int i;
1021 
1022  f->appendItem(strValue);
1023  i=f->getNumItems();
1024  if (i>10)
1025  i=10;
1026  f->setNumVisible(i);
1027  return 0;
1028  }
1029 
1031  f->clearItems();
1032  return 0;
1033 
1034  default:
1035  break;
1036  }
1037  break;
1038  }
1039 
1041  {
1042  FXGroupBox *f;
1043 
1045  assert(f);
1046 
1047  switch(prop) {
1049  f->setText(strValue);
1050  return 0;
1051  default:
1052  break;
1053  }
1054  break;
1055  }
1056 
1058  {
1059  FXRadioButton *f;
1060 
1061  f=(FXRadioButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1062  assert(f);
1063 
1064  switch(prop) {
1066  f->setText(strValue);
1067  return 0;
1068 
1070  f->setTipText(htmlValue);
1071  return 0;
1072 
1073  default:
1074  break;
1075  }
1076  break;
1077  }
1078 
1080  {
1081  FXCheckButton *f;
1082 
1083  f=(FXCheckButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1084  assert(f);
1085 
1086  switch(prop) {
1088  f->setText(strValue);
1089  return 0;
1090 
1092  f->setTipText(htmlValue);
1093  return 0;
1094 
1095  default:
1096  break;
1097  }
1098  break;
1099  }
1100 
1102  {
1103  FXWindow *f1;
1104  THEMETABITEM *f2;
1105 
1107  assert(f1);
1108  f2=(THEMETABITEM*) (f1->getPrev());
1109  assert(f2);
1110 
1111  switch(prop) {
1113  f2->setText(strValue);
1114  return 0;
1115 
1117  f2->setTipText(htmlValue);
1118  return 0;
1119 
1120  default:
1121  break;
1122  }
1123  break;
1124  }
1125 
1127  {
1128  FXDialogBox *f;
1129 
1131  assert(f);
1132 
1133  switch(prop) {
1135  f->setTitle(strValue);
1136  return 0;
1137  default:
1138  break;
1139  }
1140  break;
1141  }
1142 
1144  {
1145  FXFoldingList *f;
1146  FXString str;
1147  FXString t;
1148  FXint n=0;
1149 
1150  f=(FXFoldingList*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1151  assert(f);
1152 
1153  switch(prop) {
1155  f->getHeader()->clearItems();
1156  str=strValue;
1157  while(!(t=str.section('\t',n)).empty()){
1158  f->appendHeader(t, NULL, 20);
1159  n++;
1160  }
1161  return 0;
1162 
1164  f->appendItem(NULL, strValue);
1165  return 0;
1166 
1168  f->clearItems();
1169  return 0;
1170 
1171  default:
1172  break;
1173  }
1174  break;
1175  }
1176 
1178  {
1179  FXSpinner *f;
1180 
1182  assert(f);
1183 
1184  switch(prop) {
1186  f->setTipText(htmlValue);
1187  return 0;
1188 
1189  default:
1190  break;
1191  }
1192  break;
1193  }
1194 
1204  case GWEN_Widget_TypeHLine:
1205  case GWEN_Widget_TypeVLine:
1206  ;
1207  }
1208 
1209  /* this block is just to make sure we get warnings when new
1210  * properties are available but not handled here
1211  */
1212  switch(prop) {
1233  break;
1234  }
1235 
1236  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
1238  return GWEN_ERROR_INVALID;
1239 }
1240 
1241 
1242 
1244  GWEN_DIALOG_PROPERTY prop,
1245  int index,
1246  const char *defaultValue) {
1247  FXString str;
1248 
1249  switch(GWEN_Widget_GetType(w)) {
1251  return defaultValue;
1252  case GWEN_Widget_TypeNone:
1253  return defaultValue;
1254 
1255  case GWEN_Widget_TypeLabel:
1256  {
1257  FOX16_HtmlLabel *f;
1258 
1260  assert(f);
1261 
1262  switch(prop) {
1264  str=f->getText();
1265  if (str.empty())
1266  return defaultValue;
1267  else {
1270  }
1271 
1272  default:
1273  break;
1274  }
1275  break;
1276  }
1277 
1279  {
1280  THEMEBUTTON *f;
1281 
1283  assert(f);
1284 
1285  switch(prop) {
1287  str=f->getText();
1288  if (str.empty())
1289  return defaultValue;
1290  else {
1293  }
1294 
1295  default:
1296  break;
1297  }
1298  break;
1299  }
1300 
1302  {
1303  FXTextField *f;
1304 
1306  assert(f);
1307 
1308  switch(prop) {
1310  str=f->getText();
1311  if (str.empty())
1312  return defaultValue;
1313  else {
1316  }
1317 
1318  default:
1319  break;
1320  }
1321  break;
1322  }
1323 
1325  {
1326  FXText *f;
1327 
1329  assert(f);
1330 
1331  switch(prop) {
1333  str=f->getText();
1334  if (str.empty())
1335  return defaultValue;
1336  else {
1339  }
1340 
1341  default:
1342  break;
1343  }
1344  break;
1345  }
1346 
1348  {
1349  FOX16_HtmlText *f;
1350 
1352  assert(f);
1353 
1354  switch(prop) {
1356  str=f->getText();
1357  if (str.empty())
1358  return defaultValue;
1359  else {
1362  }
1363 
1364  default:
1365  break;
1366  }
1367  break;
1368  }
1369 
1371  {
1372  THEMECOMBOBOX *f;
1373 
1375  assert(f);
1376 
1377  switch(prop) {
1379  if (index<f->getNumItems()) {
1380  str=f->getItem(index);
1381  if (str.empty())
1382  return defaultValue;
1383  else {
1386  }
1387  }
1388  else {
1389  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
1390  return defaultValue;
1391  }
1392 
1393  default:
1394  break;
1395  }
1396  break;
1397  }
1398 
1400  {
1401  FXGroupBox *f;
1402 
1404  assert(f);
1405 
1406  switch(prop) {
1408  str=f->getText();
1409  if (str.empty())
1410  return defaultValue;
1411  else {
1414  }
1415 
1416  default:
1417  break;
1418  }
1419  break;
1420  }
1421 
1423  {
1424  FXRadioButton *f;
1425 
1426  f=(FXRadioButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1427  assert(f);
1428 
1429  switch(prop) {
1431  str=f->getText();
1432  if (str.empty())
1433  return defaultValue;
1434  else {
1437  }
1438 
1439  default:
1440  break;
1441  }
1442  break;
1443  }
1444 
1446  {
1447  FXCheckButton *f;
1448 
1449  f=(FXCheckButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1450  assert(f);
1451 
1452  switch(prop) {
1454  str=f->getText();
1455  if (str.empty())
1456  return defaultValue;
1457  else {
1460  }
1461 
1462  default:
1463  break;
1464  }
1465  break;
1466  }
1467 
1469  {
1470  FXWindow *f1;
1471  THEMETABITEM *f2;
1472 
1474  assert(f1);
1475  f2=(THEMETABITEM*) (f1->getPrev());
1476  assert(f2);
1477 
1478  switch(prop) {
1480  str=f2->getText();
1481  if (str.empty())
1482  return defaultValue;
1483  else {
1486  }
1487 
1488  default:
1489  break;
1490  }
1491 
1492  break;
1493  }
1494 
1496  {
1497  FXDialogBox *f;
1498 
1500  assert(f);
1501 
1502  switch(prop) {
1504  str=f->getTitle();
1505  if (str.empty())
1506  return defaultValue;
1507  else {
1510  }
1511 
1512  default:
1513  break;
1514  }
1515  break;
1516  }
1517 
1519  {
1520  FXFoldingList *f;
1521  FXHeader *fh;
1522  FXFoldingItem *fi;
1523 
1524  f=(FXFoldingList*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1525  assert(f);
1526 
1527  switch(prop) {
1529  fh=f->getHeader();
1530  if (fh) {
1531  int i;
1532 
1533  for (i=0; i<fh->getNumItems(); i++) {
1534  if (!str.empty())
1535  str+="\t";
1536  str+=fh->getItemText(i);
1537  }
1538  }
1539 
1540  if (str.empty())
1541  return defaultValue;
1542  else {
1545  }
1546 
1548  fi=f->getFirstItem();
1549  if (fi) {
1550  int i=index;
1551 
1552  while(fi && i>0) {
1553  fi=fi->getNext();
1554  i--;
1555  }
1556  if (fi) {
1557  str=fi->getText();
1558  if (str.empty())
1559  return defaultValue;
1562  }
1563  else {
1564  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
1565  return defaultValue;
1566  }
1567  }
1568  else {
1569  DBG_ERROR(GWEN_LOGDOMAIN, "Empty list");
1570  return defaultValue;
1571  }
1572 
1573  default:
1574  break;
1575  }
1576  break;
1577  }
1578 
1579 
1590  case GWEN_Widget_TypeHLine:
1591  case GWEN_Widget_TypeVLine:
1592  break;
1593  }
1594 
1595  /* this block is just to make sure we get warnings when new
1596  * properties are available but not handled here
1597  */
1598  switch(prop) {
1619  break;
1620  }
1621 
1622 
1623  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
1625  return defaultValue;
1626 }
1627 
1628 
1629 
1630 
1631 
1632 long FOX16_GuiDialog::onSelCommand(FXObject *sender, FXSelector sel, void *ptr) {
1633  GWEN_WIDGET *w;
1634  const char *wname;
1636  FXDialogBox *dialogBox;
1637 
1639  if (w==NULL) {
1640  if (!m_radioGroups.empty()) {
1641  std::list<RadioButtonGroup*>::iterator it;
1642  RadioButtonGroup *grp=NULL;
1643 
1644  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++) {
1645  if ((*it)->getDataTarget()==sender) {
1646  grp=*it;
1647  break;
1648  }
1649  }
1650 
1651  if (grp==NULL) {
1652  DBG_WARN(GWEN_LOGDOMAIN, "Widget or RadioButtonGroup not found");
1653  return 0;
1654  }
1655  else {
1656  DBG_INFO(0, "Found button group %d: %d", grp->getGroupId(), grp->getRadioValue());
1657  // no signal for now
1658  return 1;
1659  }
1660  }
1661  }
1662  wname=GWEN_Widget_GetName(w);
1663 
1664  dialogBox=_mainWidget;
1665 
1666  DBG_DEBUG(GWEN_LOGDOMAIN, "Command for [%s] (type: %s)",
1667  wname?wname:"(unnamed)",
1669 
1670  switch(GWEN_Widget_GetType(w)) {
1672  return GWEN_ERROR_GENERIC;
1673 
1674  case GWEN_Widget_TypeNone:
1675  return GWEN_ERROR_GENERIC;
1676 
1682  case GWEN_Widget_TypeLabel:
1686  GWEN_Widget_GetName(w));
1687  break;
1691  GWEN_Widget_GetName(w));
1692  break;
1693 
1694  case GWEN_Widget_TypeRadioButton: /* use SEL_UPDATED for FXRadioButton */
1707  case GWEN_Widget_TypeHLine:
1708  case GWEN_Widget_TypeVLine:
1710  /* nothing to do for these types */
1711  ;
1712  }
1713 
1715  dialogBox->getApp()->stopModal(dialogBox, 1);
1716  }
1717  else if (rv==GWEN_DialogEvent_ResultReject) {
1718  dialogBox->getApp()->stopModal(dialogBox, 0);
1719  }
1720 
1721  return 1;
1722 }
1723 
1724 
1725 
1726 long FOX16_GuiDialog::onSelChanged(FXObject *sender, FXSelector sel, void *ptr) {
1727  GWEN_WIDGET *w;
1729  FXDialogBox *dialogBox;
1730 
1732  if (w==NULL) {
1733  DBG_INFO(0, "Widget not found");
1734  return 0;
1735  }
1736 
1737  dialogBox=_mainWidget;
1738 
1739  switch(GWEN_Widget_GetType(w)) {
1741  return GWEN_ERROR_GENERIC;
1742  case GWEN_Widget_TypeNone:
1743  return GWEN_ERROR_GENERIC;
1748  GWEN_Widget_GetName(w));
1749  break;
1750 
1751  case GWEN_Widget_TypeLabel:
1770  case GWEN_Widget_TypeHLine:
1771  case GWEN_Widget_TypeVLine:
1773  ;
1774  }
1775 
1778  dialogBox->getApp()->stopModal(dialogBox, 1);
1779  }
1780  else if (rv==GWEN_DialogEvent_ResultReject) {
1782  dialogBox->getApp()->stopModal(dialogBox, 0);
1783  }
1784 
1785  return 1;
1786 }
1787 
1788 
1789 
1790 long FOX16_GuiDialog::onSelKeyPress(FXObject *sender, FXSelector sel, void *ptr) {
1791  GWEN_WIDGET *w;
1792 
1794  if (w==NULL) {
1795  DBG_INFO(0, "Widget not found");
1796  return 0;
1797  }
1798 
1799  switch(GWEN_Widget_GetType(w)) {
1801  case GWEN_Widget_TypeNone:
1802  return 0;
1803 
1805  /* catch ENTER key */
1806  if (((FXEvent*)ptr)->code==KEY_Return || ((FXEvent*)ptr)->code==KEY_KP_Enter) {
1807  return 1;
1808  }
1809  return 0;
1810 
1811  case GWEN_Widget_TypeLabel:
1831  case GWEN_Widget_TypeHLine:
1832  case GWEN_Widget_TypeVLine:
1834  ;
1835  }
1836 
1837  return 0;
1838 }
1839 
1840 
1841 
1842 long FOX16_GuiDialog::onSelKeyRelease(FXObject *sender, FXSelector sel, void *ptr) {
1843  GWEN_WIDGET *w;
1844 
1846  if (w==NULL) {
1847  DBG_INFO(0, "Widget not found");
1848  return 0;
1849  }
1850 
1851  switch(GWEN_Widget_GetType(w)) {
1853  /* catch ENTER key */
1854  if (((FXEvent*)ptr)->code==KEY_Return || ((FXEvent*)ptr)->code==KEY_KP_Enter) {
1855  return 1;
1856  }
1857  return 0;
1858 
1860  case GWEN_Widget_TypeNone:
1861  case GWEN_Widget_TypeLabel:
1881  case GWEN_Widget_TypeHLine:
1882  case GWEN_Widget_TypeVLine:
1884  ;
1885  }
1886 
1887  return 0;
1888 }
1889 
1890 
1891 
1892 bool FOX16_GuiDialog::setup(FXWindow *parentWindow) {
1893  FXWindow *xw;
1894  GWEN_WIDGET_TREE *wtree;
1895  GWEN_WIDGET *w;
1896  int rv;
1897 
1899  if (wtree==NULL) {
1900  DBG_ERROR(GWEN_LOGDOMAIN, "No widget tree in dialog");
1901  return false;
1902  }
1903  w=GWEN_Widget_Tree_GetFirst(wtree);
1904  if (w==NULL) {
1905  DBG_ERROR(GWEN_LOGDOMAIN, "No widgets in dialog");
1906  return false;
1907  }
1908 
1909  xw=setupTree(parentWindow, w);
1910  if (xw==NULL) {
1911  DBG_INFO(0, "here");
1912  return false;
1913  }
1914 
1915  _mainWidget=dynamic_cast<FXDialogBox*>(xw);
1916  assert(_mainWidget);
1917 
1918  /* create X11 server side resources */
1919  xw->create();
1920 
1921  m_sizeChanged=FALSE;
1923  if (rv<0) {
1924  DBG_INFO(0, "Error initializing dialog: %d", rv);
1925  return false;
1926  }
1927  if (!m_sizeChanged) {
1928  DBG_ERROR(0, "Resizing dialog myself");
1929  xw->resize(xw->getDefaultWidth(), xw->getDefaultHeight());
1930  }
1931  xw->layout();
1932 
1933  return true;
1934 }
1935 
1936 
1937 
1938 
1939 FXWindow *FOX16_GuiDialog::setupTree(FXWindow *parentWindow, GWEN_WIDGET *w) {
1940  const char *s;
1941  const char *name;
1942  FXuint opts=0;
1943  uint32_t flags;
1944  FXString text;
1945  FXString htmlText;
1946  FXComposite *parentComposite=NULL;
1947  FXWindow *wChild=NULL;
1948  FXWindow *wContent=NULL;
1949  GWEN_WIDGET *parentWidget;
1950  int cols;
1951  int rows;
1952 
1953  /* sample data */
1954  flags=GWEN_Widget_GetFlags(w);
1955  s=GWEN_Widget_GetText(w, 0);
1956  if (s) {
1957  text=FXString(s);
1958  htmlText=FOX16_Gui::getHtmlText(s);
1959  }
1960  name=GWEN_Widget_GetName(w);
1961  cols=GWEN_Widget_GetColumns(w);
1962  rows=GWEN_Widget_GetRows(w);
1963 
1964  parentWidget=GWEN_Widget_Tree_GetParent(w);
1965 
1966  /* check for parent type */
1967  if (parentWindow)
1968  parentComposite=dynamic_cast<FXComposite*>(parentWindow);
1969  if (parentComposite==NULL) {
1970  switch(GWEN_Widget_GetType(w)) {
1972  /* these types don't need the parent to be a FXComposite */
1973  break;
1974  default:
1975  DBG_ERROR(GWEN_LOGDOMAIN, "Parent of widget [%s] (type %d) is not a composite",
1976  name?name:"(unnamed)", GWEN_Widget_GetType(w));
1977  return NULL;
1978  }
1979  }
1980 
1981  /* setup info for new widget */
1982  if (flags & GWEN_WIDGET_FLAGS_FILLX)
1983  opts|=LAYOUT_FILL_X | LAYOUT_FILL_COLUMN;
1984  if (flags & GWEN_WIDGET_FLAGS_FILLY)
1985  opts|=LAYOUT_FILL_Y;
1987  opts|=DECOR_SHRINKABLE;
1989  opts|=DECOR_STRETCHABLE;
1991  opts|=DECOR_MINIMIZE;
1993  opts|=DECOR_MAXIMIZE;
1994  if (flags & GWEN_WIDGET_FLAGS_DECOR_CLOSE)
1995  opts|=DECOR_CLOSE;
1996  if (flags & GWEN_WIDGET_FLAGS_DECOR_MENU)
1997  opts|=DECOR_MENU;
1998  if (flags & GWEN_WIDGET_FLAGS_EQUAL_WIDTH)
1999  opts|=PACK_UNIFORM_WIDTH;
2000  if (flags & GWEN_WIDGET_FLAGS_EQUAL_HEIGHT)
2001  opts|=PACK_UNIFORM_HEIGHT;
2002  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_LEFT)
2003  opts|=JUSTIFY_LEFT;
2004  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_RIGHT)
2005  opts|=JUSTIFY_RIGHT;
2006  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_TOP)
2007  opts|=JUSTIFY_TOP;
2009  opts|=JUSTIFY_BOTTOM;
2011  opts|=JUSTIFY_CENTER_X;
2013  opts|=JUSTIFY_CENTER_Y;
2014 
2015  /* create THIS widget */
2016  switch(GWEN_Widget_GetType(w)) {
2017 
2018  case GWEN_Widget_TypeLabel: {
2019  FOX16_HtmlLabel *label;
2020  int wi;
2021  const char *s;
2023 
2024  if (flags & GWEN_WIDGET_FLAGS_NO_WORDWRAP)
2026  label=new FOX16_HtmlLabel(parentComposite,
2027  htmlText,
2028  opts);
2030  if (s && *s) {
2031  FXIcon *ic;
2032 
2033  ic=getIcon(s);
2034  if (ic)
2035  label->setIcon(ic);
2036  }
2037 
2038  wi=GWEN_Widget_GetWidth(w);
2039  if (wi>0)
2040  label->setMaxDefaultWidth(wi);
2041 
2042  /* copy media paths to label */
2044  while(se) {
2045  const char *s;
2046 
2048  assert(s);
2049  label->addMediaPath(s);
2051  }
2052 
2053  wChild=label;
2054  break;
2055  }
2056 
2058  const char *s;
2059  FXIcon *ic=NULL;
2060 
2062  opts|=BUTTON_DEFAULT | BUTTON_INITIAL | BUTTON_NORMAL;
2063  else
2064  opts|=BUTTON_NORMAL;
2066  if (s && *s)
2067  ic=getIcon(s);
2068 
2069  wChild=new THEMEBUTTON(parentComposite,
2070  text,
2071  ic, /* icon */
2072  this,
2074  opts);
2075  break;
2076  }
2077 
2079  if (flags & GWEN_WIDGET_FLAGS_PASSWORD)
2080  opts|=TEXTFIELD_PASSWD;
2081  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2082  opts|=TEXTFIELD_READONLY;
2083  wChild=new FXTextField(parentComposite,
2084  cols?cols:16,
2085  this,
2087  opts | TEXTFIELD_NORMAL | TEXTFIELD_ENTER_ONLY);
2088  break;
2089 
2091  {
2092  FXText *f;
2093 
2094  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2095  opts|=TEXT_READONLY;
2096  f=new FXText(parentComposite,
2097  this,
2099  opts | HSCROLLING_OFF);
2100  if (cols)
2101  f->setVisibleColumns(cols);
2102  if (rows)
2103  f->setVisibleRows(rows);
2104  wChild=f;
2105  break;
2106  }
2107 
2109  {
2110  FOX16_HtmlText *f;
2111 
2112  f=new FOX16_HtmlText(parentComposite, "",
2113  opts | HSCROLLING_OFF);
2114  wChild=f;
2115  break;
2116  }
2117 
2119  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2120  opts|=COMBOBOX_STATIC;
2121  wChild=new THEMECOMBOBOX(parentComposite,
2122  cols?cols:16,
2123  this,
2125  opts);
2126  break;
2127 
2129  FXRadioButton *rb;
2130  int groupId;
2131  RadioButtonGroup *grp=NULL;
2132  std::list<RadioButtonGroup*>::iterator it;
2133 
2134  groupId=GWEN_Widget_GetGroupId(w);
2135 
2136 
2137  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++) {
2138  if ((*it)->getGroupId()==groupId) {
2139  grp=*it;
2140  }
2141  }
2142  if (grp==NULL) {
2143  grp=new RadioButtonGroup(groupId, this, ID_WIDGET_FIRST+_widgetCount);
2144  m_radioGroups.push_back(grp);
2145  }
2146 
2147  rb=new FXRadioButton(parentComposite,
2148  text,
2149  grp->getDataTarget(),
2150  FXDataTarget::ID_OPTION+grp->getButtonCount(),
2151  opts | RADIOBUTTON_NORMAL);
2152  grp->addButton(rb);
2153  wChild=rb;
2154  break;
2155  }
2156 
2158  wChild=new FXProgressBar(parentComposite,
2159  this,
2161  opts | PROGRESSBAR_NORMAL | PROGRESSBAR_PERCENTAGE);
2162  break;
2163 
2165  wChild=new FXGroupBox(parentComposite,
2166  text,
2167  opts | GROUPBOX_NORMAL | FRAME_LINE);
2168  break;
2169 
2171  wChild=new FXSpring(parentComposite, opts | LAYOUT_FILL_X);
2172  break;
2173 
2175  wChild=new FXSpring(parentComposite, opts | LAYOUT_FILL_Y);
2176  break;
2177 
2179  wChild=new FXHorizontalFrame(parentComposite, opts,
2180  0, 0, 0, 0, 0, 0, 0, 0);
2181  break;
2182 
2184  wChild=new FXVerticalFrame(parentComposite, opts,
2185  0, 0, 0, 0, 0, 0, 0, 0);
2186  break;
2187 
2189  if (cols & rows) {
2190  DBG_ERROR(GWEN_LOGDOMAIN, "State columns *or* rows, not both in widget [%s]",
2191  name?name:"(unnamed)");
2192  return NULL;
2193  }
2194  if (cols)
2195  wChild=new FXMatrix(parentComposite, cols,
2196  opts | MATRIX_BY_COLUMNS,
2197  0, 0, 0, 0, 0, 0, 0, 0);
2198  else
2199  wChild=new FXMatrix(parentComposite, rows,
2200  opts | MATRIX_BY_ROWS,
2201  0, 0, 0, 0, 0, 0, 0, 0);
2202  break;
2203 
2205  wChild=new FOX16_GuiSortingList(parentComposite,
2206  this,
2208  opts | FRAME_SUNKEN|FRAME_THICK | LISTBOX_NORMAL);
2209  break;
2210 
2212  if (parentWindow)
2213  wChild=new FXDialogBox(parentWindow,
2214  name?FXString(name):FXString(""),
2215  opts | DECOR_TITLE | DECOR_BORDER);
2216  else
2217  wChild=new FXDialogBox(FXApp::instance(),
2218  name?FXString(name):FXString(""),
2219  opts | DECOR_TITLE | DECOR_BORDER);
2220  break;
2221 
2223  wChild=new FXTabBook(parentComposite,
2224  this,
2226  opts | TABBOOK_NORMAL);
2227  break;
2228 
2230  if (parentWidget==NULL) {
2231  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] has no parent", name?name:"(unnamed)");
2232  return NULL;
2233  }
2234  else {
2235  FXTabBook *tbook=dynamic_cast<FXTabBook*>(parentWindow);
2236  if (tbook==NULL) {
2237  DBG_ERROR(GWEN_LOGDOMAIN, "Parent of widget [%s] needs to be of type TabBook", name?name:"(unnamed)");
2238  return NULL;
2239  }
2240 
2241  new THEMETABITEM(tbook, text, NULL, opts | TAB_TOP_NORMAL);
2242  wChild=new FXVerticalFrame(tbook, opts);
2243  }
2244  break;
2245 
2247  wChild=new FXCheckButton(parentComposite,
2248  text,
2249  this,
2251  opts | CHECKBUTTON_NORMAL);
2252  break;
2253 
2255  {
2256  FXScrollWindow *f;
2257 
2258  f=new FXScrollWindow(parentComposite, opts);
2259  wChild=f;
2260  wContent=f->contentWindow();
2261  break;
2262  }
2263 
2265  wChild=new FXSwitcher(parentComposite, opts);
2266  break;
2267 
2268  case GWEN_Widget_TypeHLine:
2269  wChild=new FXHorizontalSeparator(parentComposite, opts | SEPARATOR_GROOVE);
2270  break;
2271 
2272  case GWEN_Widget_TypeVLine:
2273  wChild=new FXVerticalSeparator(parentComposite, opts | SEPARATOR_GROOVE);
2274  break;
2275 
2277  wChild=new FXSpinner(parentComposite,
2278  cols?cols:16,
2279  this,
2281  opts | SPIN_NORMAL);
2282  break;
2283 
2285  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] is of type \'unknown\'", name?name:"(unnamed)");
2286  return NULL;
2287  case GWEN_Widget_TypeNone:
2288  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] is of type \'none\'", name?name:"(unnamed)");
2289  return NULL;
2290  }
2291 
2292  assert(wChild);
2293  _widgetCount++;
2294 
2295  if (wContent==NULL)
2296  wContent=wChild;
2297 
2300 
2301  /* handle children */
2302  w=GWEN_Widget_Tree_GetFirstChild(w);
2303  while(w) {
2304  if (NULL==setupTree(wContent, w))
2305  return NULL;
2306  w=GWEN_Widget_Tree_GetNext(w);
2307  }
2308 
2309  return wChild;
2310 }
2311 
2312 
2313 
2315  FXDialogBox *dialogBox;
2316 
2317  dialogBox=_mainWidget;
2318  return dialogBox->getApp()->runModalFor(dialogBox);
2319 }
2320 
2321 
2322 
2324  FXDialogBox *dialogBox;
2325 
2326  dialogBox=_mainWidget;
2327 
2328  /* show dialog */
2329  dialogBox->layout();
2330  dialogBox->show(PLACEMENT_OWNER);
2331 
2332  return 0;
2333 }
2334 
2335 
2336 
2338  FXDialogBox *dialogBox;
2339 
2340  dialogBox=_mainWidget;
2341 
2342  /* let dialog write its settings */
2344 
2345  /* hide dialog */
2346  dialogBox->hide();
2347  delete _mainWidget;
2348  _mainWidget=NULL;
2349 
2350  return 0;
2351 }
2352 
2353 
2354