gwenhywfar  4.3.3
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 {
62 }
63 
64 
65 
67 :FXObject()
68 ,CppDialog(dlg)
69 ,_gui(gui)
70 ,_widgetCount(0)
71 ,_mainWidget(NULL)
72 ,m_iconSource(NULL)
73 {
74 }
75 
76 
77 
79  if (_mainWidget)
80  delete _mainWidget;
81  if (!m_iconList.empty()) {
82  std::list<FXIcon*>::iterator it;
83 
84  for (it=m_iconList.begin(); it!=m_iconList.end(); it++)
85  delete *it;
86  m_iconList.clear();
87  }
88  if (m_iconSource)
89  delete m_iconSource;
90 
91  if (!m_radioGroups.empty()) {
92  std::list<RadioButtonGroup*>::iterator it;
93 
94  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++)
95  delete *it;
96  }
97 }
98 
99 
100 
102  CppDialog *cppDlg;
103 
104  cppDlg=CppDialog::getDialog(dlg);
105  if (cppDlg)
106  return dynamic_cast<FOX16_GuiDialog*>(cppDlg);
107  return NULL;
108 }
109 
110 
111 
112 FXIcon *FOX16_GuiDialog::getIcon(const char *fileName) {
113  GWEN_STRINGLIST *sl;
114 
116  if (sl) {
117  GWEN_BUFFER *tbuf;
118  int rv;
119  FXIcon *ic;
120 
121  tbuf=GWEN_Buffer_new(0, 256, 0, 1);
122  rv=GWEN_Directory_FindFileInPaths(sl, fileName, tbuf);
123  if (rv<0) {
124  DBG_ERROR(GWEN_LOGDOMAIN, "here (%d)", rv);
125  GWEN_Buffer_free(tbuf);
126  return NULL;
127  }
128 
129  if (m_iconSource==NULL)
130  m_iconSource=new FXIconSource(FXApp::instance());
131 
132  DBG_DEBUG(GWEN_LOGDOMAIN, "Loading [%s]", GWEN_Buffer_GetStart(tbuf));
133  ic=m_iconSource->loadIconFile(GWEN_Buffer_GetStart(tbuf));
134  if (ic==NULL) {
135  DBG_ERROR(GWEN_LOGDOMAIN, "Could not load icon [%s]", GWEN_Buffer_GetStart(tbuf));
136  GWEN_Buffer_free(tbuf);
137  return NULL;
138  }
139  m_iconList.push_back(ic);
140  GWEN_Buffer_free(tbuf);
141  return ic;
142  }
143  else {
144  DBG_ERROR(GWEN_LOGDOMAIN, "No media paths in dialog");
145  return NULL;
146  }
147 }
148 
149 
150 
152  FXDialogBox *dialogBox;
153  int rv;
154 
155  dialogBox=_mainWidget;
156 
157  /* execute dialog */
158  dialogBox->show(PLACEMENT_OWNER);
159  rv=dialogBox->execute();
161 
162  if (rv==0) {
163  /* aborted */
164  return 0;
165  }
166  else
167  /* accepted */
168  return 1;
169 }
170 
171 
174  int index,
175  int value,
176  int doSignal) {
177  DBG_DEBUG(GWEN_LOGDOMAIN, "SetIntProperty([%s], %d)", GWEN_Widget_GetName(w), value);
178 
179  switch(GWEN_Widget_GetType(w)) {
181  return GWEN_ERROR_GENERIC;
182 
184  return GWEN_ERROR_GENERIC;
185 
187  {
188  THEMECOMBOBOX *f;
189 
191  assert(f);
192 
193  switch(prop) {
195  if (value<f->getNumItems()) {
196  f->setCurrentItem(value, doSignal?TRUE:FALSE);
197  return 0;
198  }
199  else {
200  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range in widget [%s]", value, GWEN_Widget_GetName(w));
201  return GWEN_ERROR_INVALID;
202  }
203 
205  f->clearItems();
206  return 0;
207 
208  default:
209  break;
210  }
211  break;
212  }
213 
215  {
216  FXRadioButton *f;
217 
219  assert(f);
220 
221  switch(prop) {
223  f->setCheck((value==0)?FALSE:TRUE, doSignal?TRUE:FALSE);
224  return 0;
225 
226  default:
227  break;
228  }
229  break;
230  }
231 
233  {
234  FXProgressBar *f;
235 
237  assert(f);
238 
239  switch(prop) {
241  f->setProgress(value);
242  return 0;
243 
245  if (value!=0) {
246  DBG_ERROR(GWEN_LOGDOMAIN, "MinValue should be 0!");
247  return GWEN_ERROR_INVALID;
248  }
249  return 0;
250 
252  f->setTotal(value);
253  return 0;
254 
255  default:
256  break;
257  }
258  break;
259  }
260 
262  {
263  FXSpinner *f;
264 
266  assert(f);
267 
268  switch(prop) {
270  f->setValue(value);
271  return 0;
272 
274  FXint lo, hi;
275 
276  f->getRange(lo, hi);
277  lo=value;
278  f->setRange(lo, hi);
279  return 0;
280  }
281 
283  FXint lo, hi;
284 
285  f->getRange(lo, hi);
286  hi=value;
287  if (hi<lo)
288  hi=lo;
289  f->setRange(lo, hi);
290  return 0;
291  }
292 
293  default:
294  break;
295  }
296  break;
297  }
298 
300  {
302  FXFoldingItem *fi;
303  int i=0;
304 
306  assert(f);
307 
308  switch(prop) {
310  fi=f->getFirstItem();
311  while(fi && i<value) {
312  fi=fi->getNext();
313  i++;
314  }
315  if (fi && i==value)
316  f->setCurrentItem(fi, doSignal?TRUE:FALSE);
317  else {
318  DBG_ERROR(GWEN_LOGDOMAIN, "Value %d out of range", value);
319  return GWEN_ERROR_INVALID;
320  }
321  return 0;
322 
324  f->setHeaderSize(index, value);
325  return 0;
326 
328  switch(value) {
330  /* simply fall-through */
332  f->setListStyle(FOLDINGLIST_BROWSESELECT);
333  return 0;
335  f->setListStyle(FOLDINGLIST_EXTENDEDSELECT);
336  return 0;
337  ;
338  }
339  DBG_ERROR(GWEN_LOGDOMAIN, "Unknown SelectionMode %d", value);
340  return GWEN_ERROR_INVALID;
341 
343  {
344  FXFoldingItem *ti;
345 
346  ti=f->getItem(index);
347  if (ti==NULL) {
348  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
349  return GWEN_ERROR_INVALID;
350  }
351  ti->setSelected((value==0)?FALSE:TRUE);
352  return 0;
353  }
354 
356  f->clearItems();
357  return 0;
358 
360  {
361  int i;
362 
363  for (i=0; i<f->getNumHeaders(); i++) {
364  if (i==index) {
365  switch(value) {
367  f->setHeaderArrowDir(i, MAYBE);
368  break;
370  f->setHeaderArrowDir(i, TRUE);
371  break;
373  f->setHeaderArrowDir(i, FALSE);
374  break;
375  }
376  }
377  else
378  f->setHeaderArrowDir(i, MAYBE);
379  }
380 
381  switch(value) {
383  break;
385  f->sortByColumn(i, true);
386  break;
388  f->sortByColumn(i, false);
389  break;
390  }
391  }
392  return 0;
393 
395  {
396  int i;
397 
398  for (i=0; i<f->getNumHeaders(); i++) {
399  FXbool b;
400 
401  b=f->getHeaderArrowDir(i);
402  if (b!=MAYBE) {
403  if (b==TRUE)
404  f->sortByColumn(i, true);
405  else
406  f->sortByColumn(i, false);
407  break;
408  }
409  }
410  }
411  return 0;
412 
413 
414  default:
415  break;
416  }
417  break;
418  }
419 
421  {
422  FXCheckButton *f;
423 
425  assert(f);
426 
427  switch(prop) {
429  f->setCheck((value==0)?FALSE:TRUE, doSignal?TRUE:FALSE);
430  return 0;
431 
432  default:
433  break;
434  }
435  break;
436  }
437 
439  {
440  FXTabBook *f;
441 
443  assert(f);
444 
445  switch(prop) {
447  f->setCurrent(value, doSignal?TRUE:FALSE);
448  return 0;
449 
450  default:
451  break;
452  }
453  break;
454  }
455 
457  {
458  FXSwitcher *f;
459 
461  assert(f);
462 
463  switch(prop) {
465  f->setCurrent(value, doSignal?TRUE:FALSE);
466  return 0;
467 
468  default:
469  break;
470  }
471  break;
472  }
473 
490  ;
491  }
492 
493  {
494  FXWindow *f;
495 
497  assert(f);
498 
499  switch(prop) {
501  f->recalc();
502  f->resize(value, f->getHeight());
503  return 0;
505  f->recalc();
506  f->resize(f->getWidth(), value);
507  return 0;
509  if (value==0)
510  f->disable();
511  else
512  f->enable();
513  return 0;
514 
516  f->setFocus();
517  return 0;
518 
520  if (value==0) {
521  f->hide();
522  f->recalc();
523  }
524  else {
525  f->show();
526  f->recalc();
527  }
528  return 0;
529 
545  ;
546  }
547  }
548 
549  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
551  return GWEN_ERROR_INVALID;
552 }
553 
554 
555 
558  int index,
559  int defaultValue) {
560  switch(GWEN_Widget_GetType(w)) {
563  return defaultValue;
564 
566  {
567  THEMECOMBOBOX *f;
568 
570  assert(f);
571 
572  switch(prop) {
574  return f->getCurrentItem();
575 
577  return f->getNumItems();
578 
579  default:
580  break;
581  }
582  break;
583  }
584 
586  {
587  FXRadioButton *f;
588 
590  assert(f);
591 
592  switch(prop) {
594  return (f->getCheck()==TRUE)?1:0;
595 
596  default:
597  break;
598  }
599  break;
600  }
601 
603  {
604  FXProgressBar *f;
605 
607  assert(f);
608 
609  switch(prop) {
611  return f->getProgress();
612 
614  return 0;
615 
617  return f->getTotal();
618 
619  default:
620  break;
621  }
622 
623  break;
624  }
625 
627  {
628  FXSpinner *f;
629 
631  assert(f);
632 
633  switch(prop) {
635  return f->getValue();
636 
638  FXint lo, hi;
639 
640  f->getRange(lo, hi);
641  return lo;
642  }
643 
645  FXint lo, hi;
646 
647  f->getRange(lo, hi);
648  return hi;
649  }
650 
651  default:
652  break;
653  }
654 
655  break;
656  }
657 
659  {
661  FXFoldingItem *fi;
662  int i=0;
663 
665  assert(f);
666 
667  switch(prop) {
669  fi=f->getCurrentItem();
670  if (fi==NULL)
671  return defaultValue;
672  else {
673  FXFoldingItem *ti;
674 
675  ti=fi;
676  while( (ti=ti->getPrev()) )
677  i++;
678 
679  return i;
680  }
681 
683  return f->getNumItems();
684 
686  return f->getHeaderSize(index);
687 
689  {
690  switch(f->getListStyle()) {
691  case FOLDINGLIST_BROWSESELECT:
693  case FOLDINGLIST_EXTENDEDSELECT:
695  default:
697  }
698  break;
699  }
700 
702  {
703  FXFoldingItem *ti;
704  int i=index;
705 
706  ti=f->getFirstItem();
707  while(ti && i) {
708  ti=ti->getNext();
709  i--;
710  }
711 
712  if (ti)
713  return (ti->isSelected()==TRUE)?1:0;
714  return defaultValue;
715  }
716 
718  {
719  int i;
720 
721  for (i=0; i<f->getNumHeaders(); i++) {
722  if (i==index) {
723  FXbool b;
724 
725  b=f->getHeaderArrowDir(i);
726  if (b==MAYBE)
728  else if (b==TRUE)
730  else
732  }
733  }
734  DBG_ERROR(GWEN_LOGDOMAIN, "Column %d out of range", index);
735  }
736  return defaultValue;
737 
738  default:
739  break;
740  }
741 
742  break;
743  }
744 
746  {
747  FXCheckButton *f;
748 
750  assert(f);
751 
752  switch(prop) {
754  return (f->getCheck()==TRUE)?1:0;
755 
756  default:
757  break;
758  }
759 
760  break;
761  }
762 
764  {
765  FXTabBook *f;
766 
768  assert(f);
769 
770  switch(prop) {
772  return f->getCurrent();
773 
774  default:
775  break;
776  }
777 
778  break;
779  }
780 
782  {
783  FXSwitcher *f;
784 
786  assert(f);
787 
788  switch(prop) {
790  return f->getCurrent();
791 
792  default:
793  break;
794  }
795 
796  break;
797  }
798 
815  break;
816  }
817 
818  /* generic properties every widget has */
819  {
820  FXWindow *f;
821 
823  assert(f);
824 
825  switch(prop) {
827  return f->getWidth();
828 
830  return f->getHeight();
831 
833  return (f->isEnabled()==TRUE)?1:0;
834 
836  return (f->hasFocus())?1:0;
837 
854  ;
855  }
856  }
857 
858 
859  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
861  return defaultValue;
862 }
863 
864 
865 
868  int index,
869  const char *value,
870  int doSignal) {
871 
872  FXString strValue;
873  FXString htmlValue;
874 
875  if (value && *value) {
876  strValue=FOX16_Gui::getRawText(value);
877  htmlValue=FOX16_Gui::getHtmlText(value);
878  }
879 
880  switch(GWEN_Widget_GetType(w)) {
882  return GWEN_ERROR_GENERIC;
884  return GWEN_ERROR_GENERIC;
885 
887  {
888  FOX16_HtmlLabel *f;
889 
891  assert(f);
892 
893  switch(prop) {
895  f->setText(htmlValue);
896  return 0;
897 
898  default:
899  break;
900  }
901  break;
902  }
903 
905  {
906  FOX16_HtmlText *f;
907 
909  assert(f);
910 
911  switch(prop) {
913  f->setText(htmlValue);
914  f->makePositionVisible(strValue.length());
915  return 0;
916 
918  f->setText(f->getText()+htmlValue);
919  return 0;
920 
922  f->setText("");
923  return 0;
924 
925  default:
926  break;
927  }
928  break;
929 
930  }
931 
933  {
934  THEMEBUTTON *f;
935 
937  assert(f);
938 
939  switch(prop) {
941  f->setText(value);
942  return 0;
943 
945  f->setTipText(htmlValue);
946  return 0;
947 
948  default:
949  break;
950  }
951  break;
952  }
953 
955  {
956  FXTextField *f;
957 
959  assert(f);
960 
961  switch(prop) {
963  f->setText(value, doSignal?TRUE:FALSE);
964  return 0;
965 
967  f->setTipText(htmlValue);
968  return 0;
969 
970  default:
971  break;
972  }
973  break;
974  }
975 
977  {
978  FXText *f;
979 
981  assert(f);
982 
983  switch(prop) {
985  f->setText(strValue);
986  return 0;
987 
989  f->setTipText(htmlValue);
990  return 0;
991 
992  default:
993  break;
994  }
995  break;
996  }
997 
999  {
1000  THEMECOMBOBOX *f;
1001 
1003  assert(f);
1004 
1005  switch(prop) {
1007  // undefined
1008  break;
1009 
1011  f->setTipText(htmlValue);
1012  return 0;
1013 
1015  {
1016  int i;
1017 
1018  f->appendItem(strValue);
1019  i=f->getNumItems();
1020  if (i>10)
1021  i=10;
1022  f->setNumVisible(i);
1023  return 0;
1024  }
1025 
1027  f->clearItems();
1028  return 0;
1029 
1030  default:
1031  break;
1032  }
1033  break;
1034  }
1035 
1037  {
1038  FXGroupBox *f;
1039 
1041  assert(f);
1042 
1043  switch(prop) {
1045  f->setText(strValue);
1046  return 0;
1047  default:
1048  break;
1049  }
1050  break;
1051  }
1052 
1054  {
1055  FXRadioButton *f;
1056 
1057  f=(FXRadioButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1058  assert(f);
1059 
1060  switch(prop) {
1062  f->setText(strValue);
1063  return 0;
1064 
1066  f->setTipText(htmlValue);
1067  return 0;
1068 
1069  default:
1070  break;
1071  }
1072  break;
1073  }
1074 
1076  {
1077  FXCheckButton *f;
1078 
1079  f=(FXCheckButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1080  assert(f);
1081 
1082  switch(prop) {
1084  f->setText(strValue);
1085  return 0;
1086 
1088  f->setTipText(htmlValue);
1089  return 0;
1090 
1091  default:
1092  break;
1093  }
1094  break;
1095  }
1096 
1098  {
1099  FXWindow *f1;
1100  THEMETABITEM *f2;
1101 
1103  assert(f1);
1104  f2=(THEMETABITEM*) (f1->getPrev());
1105  assert(f2);
1106 
1107  switch(prop) {
1109  f2->setText(strValue);
1110  return 0;
1111 
1113  f2->setTipText(htmlValue);
1114  return 0;
1115 
1116  default:
1117  break;
1118  }
1119  break;
1120  }
1121 
1123  {
1124  FXDialogBox *f;
1125 
1127  assert(f);
1128 
1129  switch(prop) {
1131  f->setTitle(strValue);
1132  return 0;
1133  default:
1134  break;
1135  }
1136  break;
1137  }
1138 
1140  {
1141  FXFoldingList *f;
1142  FXString str;
1143  FXString t;
1144  FXint n=0;
1145 
1146  f=(FXFoldingList*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1147  assert(f);
1148 
1149  switch(prop) {
1151  f->getHeader()->clearItems();
1152  str=strValue;
1153  while(!(t=str.section('\t',n)).empty()){
1154  f->appendHeader(t, NULL, 20);
1155  n++;
1156  }
1157  return 0;
1158 
1160  f->appendItem(NULL, strValue);
1161  return 0;
1162 
1164  f->clearItems();
1165  return 0;
1166 
1167  default:
1168  break;
1169  }
1170  break;
1171  }
1172 
1174  {
1175  FXSpinner *f;
1176 
1178  assert(f);
1179 
1180  switch(prop) {
1182  f->setTipText(htmlValue);
1183  return 0;
1184 
1185  default:
1186  break;
1187  }
1188  break;
1189  }
1190 
1200  case GWEN_Widget_TypeHLine:
1201  case GWEN_Widget_TypeVLine:
1202  ;
1203  }
1204 
1205  /* this block is just to make sure we get warnings when new
1206  * properties are available but not handled here
1207  */
1208  switch(prop) {
1229  break;
1230  }
1231 
1232  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
1234  return GWEN_ERROR_INVALID;
1235 }
1236 
1237 
1238 
1240  GWEN_DIALOG_PROPERTY prop,
1241  int index,
1242  const char *defaultValue) {
1243  FXString str;
1244 
1245  switch(GWEN_Widget_GetType(w)) {
1247  return defaultValue;
1248  case GWEN_Widget_TypeNone:
1249  return defaultValue;
1250 
1251  case GWEN_Widget_TypeLabel:
1252  {
1253  FOX16_HtmlLabel *f;
1254 
1256  assert(f);
1257 
1258  switch(prop) {
1260  str=f->getText();
1261  if (str.empty())
1262  return defaultValue;
1263  else {
1266  }
1267 
1268  default:
1269  break;
1270  }
1271  break;
1272  }
1273 
1275  {
1276  THEMEBUTTON *f;
1277 
1279  assert(f);
1280 
1281  switch(prop) {
1283  str=f->getText();
1284  if (str.empty())
1285  return defaultValue;
1286  else {
1289  }
1290 
1291  default:
1292  break;
1293  }
1294  break;
1295  }
1296 
1298  {
1299  FXTextField *f;
1300 
1302  assert(f);
1303 
1304  switch(prop) {
1306  str=f->getText();
1307  if (str.empty())
1308  return defaultValue;
1309  else {
1312  }
1313 
1314  default:
1315  break;
1316  }
1317  break;
1318  }
1319 
1321  {
1322  FXText *f;
1323 
1325  assert(f);
1326 
1327  switch(prop) {
1329  str=f->getText();
1330  if (str.empty())
1331  return defaultValue;
1332  else {
1335  }
1336 
1337  default:
1338  break;
1339  }
1340  break;
1341  }
1342 
1344  {
1345  FOX16_HtmlText *f;
1346 
1348  assert(f);
1349 
1350  switch(prop) {
1352  str=f->getText();
1353  if (str.empty())
1354  return defaultValue;
1355  else {
1358  }
1359 
1360  default:
1361  break;
1362  }
1363  break;
1364  }
1365 
1367  {
1368  THEMECOMBOBOX *f;
1369 
1371  assert(f);
1372 
1373  switch(prop) {
1375  if (index<f->getNumItems()) {
1376  str=f->getItem(index);
1377  if (str.empty())
1378  return defaultValue;
1379  else {
1382  }
1383  }
1384  else {
1385  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
1386  return defaultValue;
1387  }
1388 
1389  default:
1390  break;
1391  }
1392  break;
1393  }
1394 
1396  {
1397  FXGroupBox *f;
1398 
1400  assert(f);
1401 
1402  switch(prop) {
1404  str=f->getText();
1405  if (str.empty())
1406  return defaultValue;
1407  else {
1410  }
1411 
1412  default:
1413  break;
1414  }
1415  break;
1416  }
1417 
1419  {
1420  FXRadioButton *f;
1421 
1422  f=(FXRadioButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1423  assert(f);
1424 
1425  switch(prop) {
1427  str=f->getText();
1428  if (str.empty())
1429  return defaultValue;
1430  else {
1433  }
1434 
1435  default:
1436  break;
1437  }
1438  break;
1439  }
1440 
1442  {
1443  FXCheckButton *f;
1444 
1445  f=(FXCheckButton*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1446  assert(f);
1447 
1448  switch(prop) {
1450  str=f->getText();
1451  if (str.empty())
1452  return defaultValue;
1453  else {
1456  }
1457 
1458  default:
1459  break;
1460  }
1461  break;
1462  }
1463 
1465  {
1466  FXWindow *f1;
1467  THEMETABITEM *f2;
1468 
1470  assert(f1);
1471  f2=(THEMETABITEM*) (f1->getPrev());
1472  assert(f2);
1473 
1474  switch(prop) {
1476  str=f2->getText();
1477  if (str.empty())
1478  return defaultValue;
1479  else {
1482  }
1483 
1484  default:
1485  break;
1486  }
1487 
1488  break;
1489  }
1490 
1492  {
1493  FXDialogBox *f;
1494 
1496  assert(f);
1497 
1498  switch(prop) {
1500  str=f->getTitle();
1501  if (str.empty())
1502  return defaultValue;
1503  else {
1506  }
1507 
1508  default:
1509  break;
1510  }
1511  break;
1512  }
1513 
1515  {
1516  FXFoldingList *f;
1517  FXHeader *fh;
1518  FXFoldingItem *fi;
1519 
1520  f=(FXFoldingList*)GWEN_Widget_GetImplData(w, FOX16_DIALOG_WIDGET_REAL);
1521  assert(f);
1522 
1523  switch(prop) {
1525  fh=f->getHeader();
1526  if (fh) {
1527  int i;
1528 
1529  for (i=0; i<fh->getNumItems(); i++) {
1530  if (!str.empty())
1531  str+="\t";
1532  str+=fh->getItemText(i);
1533  }
1534  }
1535 
1536  if (str.empty())
1537  return defaultValue;
1538  else {
1541  }
1542 
1544  fi=f->getFirstItem();
1545  if (fi) {
1546  int i=index;
1547 
1548  while(fi && i>0) {
1549  fi=fi->getNext();
1550  i--;
1551  }
1552  if (fi) {
1553  str=fi->getText();
1554  if (str.empty())
1555  return defaultValue;
1558  }
1559  else {
1560  DBG_ERROR(GWEN_LOGDOMAIN, "Index %d out of range", index);
1561  return defaultValue;
1562  }
1563  }
1564  else {
1565  DBG_ERROR(GWEN_LOGDOMAIN, "Empty list");
1566  return defaultValue;
1567  }
1568 
1569  default:
1570  break;
1571  }
1572  break;
1573  }
1574 
1575 
1586  case GWEN_Widget_TypeHLine:
1587  case GWEN_Widget_TypeVLine:
1588  break;
1589  }
1590 
1591  /* this block is just to make sure we get warnings when new
1592  * properties are available but not handled here
1593  */
1594  switch(prop) {
1615  break;
1616  }
1617 
1618 
1619  DBG_WARN(0, "Function is not appropriate for this type of widget (%s)",
1621  return defaultValue;
1622 }
1623 
1624 
1625 
1626 
1627 
1628 long FOX16_GuiDialog::onSelCommand(FXObject *sender, FXSelector sel, void *ptr) {
1629  GWEN_WIDGET *w;
1630  const char *wname;
1632  FXDialogBox *dialogBox;
1633 
1635  if (w==NULL) {
1636  if (!m_radioGroups.empty()) {
1637  std::list<RadioButtonGroup*>::iterator it;
1638  RadioButtonGroup *grp=NULL;
1639 
1640  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++) {
1641  if ((*it)->getDataTarget()==sender) {
1642  grp=*it;
1643  break;
1644  }
1645  }
1646 
1647  if (grp==NULL) {
1648  DBG_WARN(GWEN_LOGDOMAIN, "Widget or RadioButtonGroup not found");
1649  return 0;
1650  }
1651  else {
1652  DBG_INFO(0, "Found button group %d: %d", grp->getGroupId(), grp->getRadioValue());
1653  // no signal for now
1654  return 1;
1655  }
1656  }
1657  }
1658  wname=GWEN_Widget_GetName(w);
1659 
1660  dialogBox=_mainWidget;
1661 
1662  DBG_DEBUG(GWEN_LOGDOMAIN, "Command for [%s] (type: %s)",
1663  wname?wname:"(unnamed)",
1665 
1666  switch(GWEN_Widget_GetType(w)) {
1668  return GWEN_ERROR_GENERIC;
1669 
1670  case GWEN_Widget_TypeNone:
1671  return GWEN_ERROR_GENERIC;
1672 
1678  case GWEN_Widget_TypeLabel:
1682  GWEN_Widget_GetName(w));
1683  break;
1687  GWEN_Widget_GetName(w));
1688  break;
1689 
1690  case GWEN_Widget_TypeRadioButton: /* use SEL_UPDATED for FXRadioButton */
1703  case GWEN_Widget_TypeHLine:
1704  case GWEN_Widget_TypeVLine:
1706  /* nothing to do for these types */
1707  ;
1708  }
1709 
1711  dialogBox->getApp()->stopModal(dialogBox, 1);
1712  }
1713  else if (rv==GWEN_DialogEvent_ResultReject) {
1714  dialogBox->getApp()->stopModal(dialogBox, 0);
1715  }
1716 
1717  return 1;
1718 }
1719 
1720 
1721 
1722 long FOX16_GuiDialog::onSelChanged(FXObject *sender, FXSelector sel, void *ptr) {
1723  GWEN_WIDGET *w;
1725  FXDialogBox *dialogBox;
1726 
1728  if (w==NULL) {
1729  DBG_INFO(0, "Widget not found");
1730  return 0;
1731  }
1732 
1733  dialogBox=_mainWidget;
1734 
1735  switch(GWEN_Widget_GetType(w)) {
1737  return GWEN_ERROR_GENERIC;
1738  case GWEN_Widget_TypeNone:
1739  return GWEN_ERROR_GENERIC;
1744  GWEN_Widget_GetName(w));
1745  break;
1746 
1747  case GWEN_Widget_TypeLabel:
1766  case GWEN_Widget_TypeHLine:
1767  case GWEN_Widget_TypeVLine:
1769  ;
1770  }
1771 
1774  dialogBox->getApp()->stopModal(dialogBox, 1);
1775  }
1776  else if (rv==GWEN_DialogEvent_ResultReject) {
1778  dialogBox->getApp()->stopModal(dialogBox, 0);
1779  }
1780 
1781  return 1;
1782 }
1783 
1784 
1785 
1786 long FOX16_GuiDialog::onSelKeyPress(FXObject *sender, FXSelector sel, void *ptr) {
1787  GWEN_WIDGET *w;
1788 
1790  if (w==NULL) {
1791  DBG_INFO(0, "Widget not found");
1792  return 0;
1793  }
1794 
1795  switch(GWEN_Widget_GetType(w)) {
1797  case GWEN_Widget_TypeNone:
1798  return 0;
1799 
1801  /* catch ENTER key */
1802  if (((FXEvent*)ptr)->code==KEY_Return || ((FXEvent*)ptr)->code==KEY_KP_Enter) {
1803  return 1;
1804  }
1805  return 0;
1806 
1807  case GWEN_Widget_TypeLabel:
1827  case GWEN_Widget_TypeHLine:
1828  case GWEN_Widget_TypeVLine:
1830  ;
1831  }
1832 
1833  return 0;
1834 }
1835 
1836 
1837 
1838 long FOX16_GuiDialog::onSelKeyRelease(FXObject *sender, FXSelector sel, void *ptr) {
1839  GWEN_WIDGET *w;
1840 
1842  if (w==NULL) {
1843  DBG_INFO(0, "Widget not found");
1844  return 0;
1845  }
1846 
1847  switch(GWEN_Widget_GetType(w)) {
1849  /* catch ENTER key */
1850  if (((FXEvent*)ptr)->code==KEY_Return || ((FXEvent*)ptr)->code==KEY_KP_Enter) {
1851  return 1;
1852  }
1853  return 0;
1854 
1856  case GWEN_Widget_TypeNone:
1857  case GWEN_Widget_TypeLabel:
1877  case GWEN_Widget_TypeHLine:
1878  case GWEN_Widget_TypeVLine:
1880  ;
1881  }
1882 
1883  return 0;
1884 }
1885 
1886 
1887 
1888 bool FOX16_GuiDialog::setup(FXWindow *parentWindow) {
1889  FXWindow *xw;
1890  GWEN_WIDGET_TREE *wtree;
1891  GWEN_WIDGET *w;
1892  int rv;
1893 
1895  if (wtree==NULL) {
1896  DBG_ERROR(GWEN_LOGDOMAIN, "No widget tree in dialog");
1897  return false;
1898  }
1899  w=GWEN_Widget_Tree_GetFirst(wtree);
1900  if (w==NULL) {
1901  DBG_ERROR(GWEN_LOGDOMAIN, "No widgets in dialog");
1902  return false;
1903  }
1904 
1905  xw=setupTree(parentWindow, w);
1906  if (xw==NULL) {
1907  DBG_INFO(0, "here");
1908  return false;
1909  }
1910 
1911  _mainWidget=dynamic_cast<FXDialogBox*>(xw);
1912  assert(_mainWidget);
1913 
1915  if (rv<0) {
1916  DBG_INFO(0, "Error initializing dialog: %d", rv);
1917  return false;
1918  }
1919 
1920  /* create X11 server side resources */
1921  xw->create();
1922 
1923  xw->layout();
1924 
1925  return true;
1926 }
1927 
1928 
1929 
1930 
1931 FXWindow *FOX16_GuiDialog::setupTree(FXWindow *parentWindow, GWEN_WIDGET *w) {
1932  const char *s;
1933  const char *name;
1934  FXuint opts=0;
1935  uint32_t flags;
1936  FXString text;
1937  FXString htmlText;
1938  FXComposite *parentComposite=NULL;
1939  FXWindow *wChild=NULL;
1940  FXWindow *wContent=NULL;
1941  GWEN_WIDGET *parentWidget;
1942  int cols;
1943  int rows;
1944 
1945  /* sample data */
1946  flags=GWEN_Widget_GetFlags(w);
1947  s=GWEN_Widget_GetText(w, 0);
1948  if (s) {
1949  text=FXString(s);
1950  htmlText=FOX16_Gui::getHtmlText(s);
1951  }
1952  name=GWEN_Widget_GetName(w);
1953  cols=GWEN_Widget_GetColumns(w);
1954  rows=GWEN_Widget_GetRows(w);
1955 
1956  parentWidget=GWEN_Widget_Tree_GetParent(w);
1957 
1958  /* check for parent type */
1959  if (parentWindow)
1960  parentComposite=dynamic_cast<FXComposite*>(parentWindow);
1961  if (parentComposite==NULL) {
1962  switch(GWEN_Widget_GetType(w)) {
1964  /* these types don't need the parent to be a FXComposite */
1965  break;
1966  default:
1967  DBG_ERROR(GWEN_LOGDOMAIN, "Parent of widget [%s] (type %d) is not a composite",
1968  name?name:"(unnamed)", GWEN_Widget_GetType(w));
1969  return NULL;
1970  }
1971  }
1972 
1973  /* setup info for new widget */
1974  if (flags & GWEN_WIDGET_FLAGS_FILLX)
1975  opts|=LAYOUT_FILL_X | LAYOUT_FILL_COLUMN;
1976  if (flags & GWEN_WIDGET_FLAGS_FILLY)
1977  opts|=LAYOUT_FILL_Y;
1979  opts|=DECOR_SHRINKABLE;
1981  opts|=DECOR_STRETCHABLE;
1983  opts|=DECOR_MINIMIZE;
1985  opts|=DECOR_MAXIMIZE;
1986  if (flags & GWEN_WIDGET_FLAGS_DECOR_CLOSE)
1987  opts|=DECOR_CLOSE;
1988  if (flags & GWEN_WIDGET_FLAGS_DECOR_MENU)
1989  opts|=DECOR_MENU;
1990  if (flags & GWEN_WIDGET_FLAGS_EQUAL_WIDTH)
1991  opts|=PACK_UNIFORM_WIDTH;
1992  if (flags & GWEN_WIDGET_FLAGS_EQUAL_HEIGHT)
1993  opts|=PACK_UNIFORM_HEIGHT;
1994  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_LEFT)
1995  opts|=JUSTIFY_LEFT;
1996  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_RIGHT)
1997  opts|=JUSTIFY_RIGHT;
1998  if (flags & GWEN_WIDGET_FLAGS_JUSTIFY_TOP)
1999  opts|=JUSTIFY_TOP;
2001  opts|=JUSTIFY_BOTTOM;
2003  opts|=JUSTIFY_CENTER_X;
2005  opts|=JUSTIFY_CENTER_Y;
2006 
2007  /* create THIS widget */
2008  switch(GWEN_Widget_GetType(w)) {
2009 
2010  case GWEN_Widget_TypeLabel: {
2011  FOX16_HtmlLabel *label;
2012  int wi;
2013  const char *s;
2015 
2016  if (flags & GWEN_WIDGET_FLAGS_NO_WORDWRAP)
2018  label=new FOX16_HtmlLabel(parentComposite,
2019  htmlText,
2020  opts);
2022  if (s && *s) {
2023  FXIcon *ic;
2024 
2025  ic=getIcon(s);
2026  if (ic)
2027  label->setIcon(ic);
2028  }
2029 
2030  wi=GWEN_Widget_GetWidth(w);
2031  if (wi>0)
2032  label->setMaxDefaultWidth(wi);
2033 
2034  /* copy media paths to label */
2036  while(se) {
2037  const char *s;
2038 
2040  assert(s);
2041  label->addMediaPath(s);
2043  }
2044 
2045  wChild=label;
2046  break;
2047  }
2048 
2050  const char *s;
2051  FXIcon *ic=NULL;
2052 
2054  opts|=BUTTON_DEFAULT | BUTTON_INITIAL | BUTTON_NORMAL;
2055  else
2056  opts|=BUTTON_NORMAL;
2058  if (s && *s)
2059  ic=getIcon(s);
2060 
2061  wChild=new THEMEBUTTON(parentComposite,
2062  text,
2063  ic, /* icon */
2064  this,
2066  opts);
2067  break;
2068  }
2069 
2071  if (flags & GWEN_WIDGET_FLAGS_PASSWORD)
2072  opts|=TEXTFIELD_PASSWD;
2073  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2074  opts|=TEXTFIELD_READONLY;
2075  wChild=new FXTextField(parentComposite,
2076  cols?cols:16,
2077  this,
2079  opts | TEXTFIELD_NORMAL | TEXTFIELD_ENTER_ONLY);
2080  break;
2081 
2083  {
2084  FXText *f;
2085 
2086  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2087  opts|=TEXT_READONLY;
2088  f=new FXText(parentComposite,
2089  this,
2091  opts | HSCROLLING_OFF);
2092  if (cols)
2093  f->setVisibleColumns(cols);
2094  if (rows)
2095  f->setVisibleRows(rows);
2096  wChild=f;
2097  break;
2098  }
2099 
2101  {
2102  FOX16_HtmlText *f;
2103 
2104  f=new FOX16_HtmlText(parentComposite, "",
2105  opts | HSCROLLING_OFF);
2106  wChild=f;
2107  break;
2108  }
2109 
2111  if (flags & GWEN_WIDGET_FLAGS_READONLY)
2112  opts|=COMBOBOX_STATIC;
2113  wChild=new THEMECOMBOBOX(parentComposite,
2114  cols?cols:16,
2115  this,
2117  opts);
2118  break;
2119 
2121  FXRadioButton *rb;
2122  int groupId;
2123  RadioButtonGroup *grp=NULL;
2124  std::list<RadioButtonGroup*>::iterator it;
2125 
2126  groupId=GWEN_Widget_GetGroupId(w);
2127 
2128 
2129  for (it=m_radioGroups.begin(); it!=m_radioGroups.end(); it++) {
2130  if ((*it)->getGroupId()==groupId) {
2131  grp=*it;
2132  }
2133  }
2134  if (grp==NULL) {
2135  grp=new RadioButtonGroup(groupId, this, ID_WIDGET_FIRST+_widgetCount);
2136  m_radioGroups.push_back(grp);
2137  }
2138 
2139  rb=new FXRadioButton(parentComposite,
2140  text,
2141  grp->getDataTarget(),
2142  FXDataTarget::ID_OPTION+grp->getButtonCount(),
2143  opts | RADIOBUTTON_NORMAL);
2144  grp->addButton(rb);
2145  wChild=rb;
2146  break;
2147  }
2148 
2150  wChild=new FXProgressBar(parentComposite,
2151  this,
2153  opts | PROGRESSBAR_NORMAL | PROGRESSBAR_PERCENTAGE);
2154  break;
2155 
2157  wChild=new FXGroupBox(parentComposite,
2158  text,
2159  opts | GROUPBOX_NORMAL | FRAME_LINE);
2160  break;
2161 
2163  wChild=new FXSpring(parentComposite, opts | LAYOUT_FILL_X);
2164  break;
2165 
2167  wChild=new FXSpring(parentComposite, opts | LAYOUT_FILL_Y);
2168  break;
2169 
2171  wChild=new FXHorizontalFrame(parentComposite, opts,
2172  0, 0, 0, 0, 0, 0, 0, 0);
2173  break;
2174 
2176  wChild=new FXVerticalFrame(parentComposite, opts,
2177  0, 0, 0, 0, 0, 0, 0, 0);
2178  break;
2179 
2181  if (cols & rows) {
2182  DBG_ERROR(GWEN_LOGDOMAIN, "State columns *or* rows, not both in widget [%s]",
2183  name?name:"(unnamed)");
2184  return NULL;
2185  }
2186  if (cols)
2187  wChild=new FXMatrix(parentComposite, cols,
2188  opts | MATRIX_BY_COLUMNS,
2189  0, 0, 0, 0, 0, 0, 0, 0);
2190  else
2191  wChild=new FXMatrix(parentComposite, rows,
2192  opts | MATRIX_BY_ROWS,
2193  0, 0, 0, 0, 0, 0, 0, 0);
2194  break;
2195 
2197  wChild=new FOX16_GuiSortingList(parentComposite,
2198  this,
2200  opts | FRAME_SUNKEN|FRAME_THICK | LISTBOX_NORMAL);
2201  break;
2202 
2204  if (parentWindow)
2205  wChild=new FXDialogBox(parentWindow,
2206  name?FXString(name):FXString(""),
2207  opts | DECOR_TITLE | DECOR_BORDER);
2208  else
2209  wChild=new FXDialogBox(FXApp::instance(),
2210  name?FXString(name):FXString(""),
2211  opts | DECOR_TITLE | DECOR_BORDER);
2212  break;
2213 
2215  wChild=new FXTabBook(parentComposite,
2216  this,
2218  opts | TABBOOK_NORMAL);
2219  break;
2220 
2222  if (parentWidget==NULL) {
2223  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] has no parent", name?name:"(unnamed)");
2224  return NULL;
2225  }
2226  else {
2227  FXTabBook *tbook=dynamic_cast<FXTabBook*>(parentWindow);
2228  if (tbook==NULL) {
2229  DBG_ERROR(GWEN_LOGDOMAIN, "Parent of widget [%s] needs to be of type TabBook", name?name:"(unnamed)");
2230  return NULL;
2231  }
2232 
2233  new THEMETABITEM(tbook, text, NULL, opts | TAB_TOP_NORMAL);
2234  wChild=new FXVerticalFrame(tbook, opts);
2235  }
2236  break;
2237 
2239  wChild=new FXCheckButton(parentComposite,
2240  text,
2241  this,
2243  opts | CHECKBUTTON_NORMAL);
2244  break;
2245 
2247  {
2248  FXScrollWindow *f;
2249 
2250  f=new FXScrollWindow(parentComposite, opts);
2251  wChild=f;
2252  wContent=f->contentWindow();
2253  break;
2254  }
2255 
2257  wChild=new FXSwitcher(parentComposite, opts);
2258  break;
2259 
2260  case GWEN_Widget_TypeHLine:
2261  wChild=new FXHorizontalSeparator(parentComposite, opts | SEPARATOR_GROOVE);
2262  break;
2263 
2264  case GWEN_Widget_TypeVLine:
2265  wChild=new FXVerticalSeparator(parentComposite, opts | SEPARATOR_GROOVE);
2266  break;
2267 
2269  wChild=new FXSpinner(parentComposite,
2270  cols?cols:16,
2271  this,
2273  opts | SPIN_NORMAL);
2274  break;
2275 
2277  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] is of type \'unknown\'", name?name:"(unnamed)");
2278  return NULL;
2279  case GWEN_Widget_TypeNone:
2280  DBG_ERROR(GWEN_LOGDOMAIN, "Widget [%s] is of type \'none\'", name?name:"(unnamed)");
2281  return NULL;
2282  }
2283 
2284  assert(wChild);
2285  _widgetCount++;
2286 
2287  if (wContent==NULL)
2288  wContent=wChild;
2289 
2292 
2293  /* handle children */
2294  w=GWEN_Widget_Tree_GetFirstChild(w);
2295  while(w) {
2296  if (NULL==setupTree(wContent, w))
2297  return NULL;
2298  w=GWEN_Widget_Tree_GetNext(w);
2299  }
2300 
2301  return wChild;
2302 }
2303 
2304 
2305 
2307  FXDialogBox *dialogBox;
2308 
2309  dialogBox=_mainWidget;
2310  return dialogBox->getApp()->runModalFor(dialogBox);
2311 }
2312 
2313 
2314 
2316  FXDialogBox *dialogBox;
2317 
2318  dialogBox=_mainWidget;
2319 
2320  /* show dialog */
2321  dialogBox->layout();
2322  dialogBox->show(PLACEMENT_OWNER);
2323 
2324  return 0;
2325 }
2326 
2327 
2328 
2330  FXDialogBox *dialogBox;
2331 
2332  dialogBox=_mainWidget;
2333 
2334  /* let dialog write its settings */
2336 
2337  /* hide dialog */
2338  dialogBox->hide();
2339  delete _mainWidget;
2340  _mainWidget=NULL;
2341 
2342  return 0;
2343 }
2344 
2345 
2346