cde/programs/dtmail/dtmail/options_util.C

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-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 libraries 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 /* $TOG: options_util.C /main/8 1999/07/07 13:20:04 mgreess $ */
  24 #include <ctype.h>
  25 #include <stdlib.h>
  26 #include <stdint.h>
  27 #include <X11/Intrinsic.h>
  28 #include <Xm/DialogS.h>
  29 #include <Xm/Form.h>
  30 #include <Xm/PanedW.h>
  31 #include <Xm/RowColumn.h>
  32 #include <Xm/Separator.h>
  33 #include <Xm/Label.h>
  34 #include <Xm/PushB.h>
  35 #include <Xm/ToggleB.h>
  36 #include <Xm/SSpinB.h>
  37 #include <Xm/ScrollBar.h>
  38 #include <Xm/TextF.h>
  39 #include <Xm/ScrolledW.h>
  40 #include <Xm/List.h>
  41 #include <Xm/Text.h>
  42 #include <Xm/Scale.h>
  43 #include <DtMail/DtVirtArray.hh>
  44 #include <DtMail/options_util.h>
  45
  46 #define OK      0
  47 #define ERROR   -1
  48 Boolean props_changed;
  49 void
  50 options_checkbox_init(
  51     Widget              checkbox,
  52     Boolean             *dirty_bit
  53 )
  54 {
  55     XtVaSetValues(checkbox, XmNuserData,(XtArgVal)OPTIONS_EDIT , NULL);
  56     XtAddCallback(checkbox, XmNvalueChangedCallback,
  57                   options_setting_chgCB, (XtPointer)dirty_bit);
  58 }
  59
  60 int
  61 options_checkbox_set_value(
  62     Widget              checkbox,
  63     Boolean             b_value,
  64     Boolean             set_dirty_bit
  65 )
  66 {
  67   if (!set_dirty_bit)
  68     /* Set state so dirty-bit is not triggered */
  69     XtVaSetValues(checkbox, XmNuserData, (XtArgVal)OPTIONS_LOAD, NULL);
  70
  71   XmToggleButtonSetState(checkbox, b_value, set_dirty_bit? TRUE : FALSE);
  72
  73   if (!set_dirty_bit)
  74     /* Reset state */
  75     XtVaSetValues(checkbox, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
  76
  77 return OK;
  78 }
  79
  80 Boolean
  81 options_checkbox_get_value(Widget checkbox)
  82 {
  83
  84   return((Boolean)XmToggleButtonGetState(checkbox));
  85
  86 }
  87
  88 void
  89 options_radiobox_init(
  90     Widget              radiobox,
  91     int                 num_items,
  92     WidgetList          items,
  93     int                 *item_values,
  94     Boolean             *dirty_bit
  95 )
  96 {
  97     int i;
  98
  99     for (i=0; i < num_items; i++)
 100     {
 101         XtVaSetValues(items[i], XmNuserData, (XtArgVal)item_values[i], NULL);
 102         XtAddCallback(items[i], XmNvalueChangedCallback,
 103                         options_setting_chgCB, (XtPointer)dirty_bit);
 104         XtAddCallback(items[i], XmNvalueChangedCallback,
 105                         options_radiobox_itemCB, (XtPointer) (intptr_t) item_values[i]);
 106
 107         /* Ensure Radiobox has a default Value set */
 108         if (i == 0)
 109         {
 110             XtVaSetValues(items[i], XmNset, True, NULL);
 111             XtVaSetValues(radiobox, XmNuserData, (XtArgVal)item_values[i], NULL);
 112         }
 113     }
 114
 115 }
 116
 117 int
 118 options_radiobox_get_value(
 119     Widget      radiobox
 120 )
 121 {
 122     XtArgVal value;
 123
 124     XtVaGetValues(radiobox, XmNuserData, &value, NULL);
 125
 126     return((int)value);
 127 }
 128
 129 int
 130 options_radiobox_set_value(
 131     Widget           radiobox,
 132     int              value,
 133     Boolean          set_dirty_bit
 134 )
 135 {
 136     int         num_children = 0;
 137     WidgetList  children = NULL;
 138     XtArgVal    childval = 0;
 139     Boolean     found = FALSE;
 140     int         i = 0;
 141
 142     set_dirty_bit = set_dirty_bit;
 143     XtVaGetValues(radiobox,
 144         XtNnumChildren,    &num_children,
 145         XtNchildren,       &children,
 146         NULL);
 147
 148     for (i = 0; i < num_children; i++)
 149     {
 150         XtVaGetValues(children[i], XmNuserData, &childval, NULL);
 151         XmToggleButtonSetState(children[i], childval == value? TRUE : FALSE, FALSE);
 152         if (childval == value)
 153         {
 154             found = TRUE;
 155             XtVaSetValues(radiobox, XmNuserData, (XtArgVal)value, NULL);
 156         }
 157     }
 158     if (!found)
 159         return ERROR;
 160
 161     return OK;
 162 }
 163
 164 /*
 165  * Callback: choice value has changed...turnon dirty bit
 166  */
 167 void
 168 options_setting_chgCB(
 169      Widget widget,
 170      XtPointer clientdata,
 171      XtPointer calldata
 172 )
 173 {
 174      Boolean    *dirty_bit = (Boolean *)clientdata;
 175      calldata = calldata;
 176      widget = widget;
 177
 178      *dirty_bit = TRUE;
 179      props_changed = TRUE;
 180 }
 181
 182 /*
 183  * Callback: item in exclusive choice has been set...store it's
 184  *           value in the parent radiobox
 185  */
 186 void
 187 options_radiobox_itemCB(
 188     Widget item,
 189     XtPointer clientdata,
 190     XtPointer calldata
 191 )
 192 {
 193     XmToggleButtonCallbackStruct *state = (XmToggleButtonCallbackStruct*)calldata;
 194     int    value = (int)((long)clientdata);
 195     Widget excl_setting;
 196
 197     if (state->set)
 198     {
 199         excl_setting = XtParent(item);
 200         XtVaSetValues(excl_setting, XmNuserData, (XtArgVal)value, NULL);
 201     }
 202
 203 }
 204
 205 void
 206 options_field_init(
 207     Widget              field,
 208     Boolean             *dirty_bit)
 209 {
 210
 211     XtAddCallback(field, XmNvalueChangedCallback,
 212                 options_field_chgCB, (XtPointer)dirty_bit);
 213
 214     XtVaSetValues(field, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
 215
 216 }
 217
 218 /* NOTE: caller must free memory allocated by XmTextFieldGetString() */
 219 String
 220 options_field_get_value(
 221     Widget              field
 222 )
 223 {
 224     String      value;
 225
 226     value = XmTextFieldGetString(field);
 227
 228     return value;
 229 }
 230
 231 int
 232 options_field_set_value(
 233     Widget              field,
 234     String              value,
 235     Boolean             set_dirty_bit
 236 )
 237 {
 238     if (!set_dirty_bit)
 239         /* Set state so dirty-bit is not triggered */
 240         XtVaSetValues(field, XmNuserData, (XtArgVal)OPTIONS_LOAD, NULL);
 241
 242     /* Set field value */
 243     XmTextFieldSetString(field, value);
 244
 245     if (!set_dirty_bit)
 246         /* Reset state */
 247         XtVaSetValues(field, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
 248
 249     return OK;
 250
 251 }
 252
 253 void
 254 options_field_chgCB(
 255      Widget widget,
 256      XtPointer clientdata,
 257      XtPointer calldata
 258 )
 259 {
 260      Boolean     *dirty_bit = (Boolean *)clientdata;
 261      XtArgVal    field_mode;
 262
 263      calldata = calldata;
 264      XtVaGetValues(widget, XmNuserData, &field_mode, NULL);
 265      if (field_mode == OPTIONS_EDIT)
 266         *dirty_bit = TRUE;
 267      props_changed = TRUE;
 268
 269 }
 270 static Boolean
 271 all_digits(char *string) {
 272
 273         while (*string) {
 274                 if (!isdigit(*string++))
 275                         return(False);
 276         }
 277
 278         return(True);
 279 }
 280
 281 void
 282 options_spinbox_modCB(
 283      Widget widget,
 284      XtPointer clientdata,
 285      XtPointer calldata
 286 )
 287 {
 288      Widget     spinbox = (Widget) clientdata;
 289      int        mvalue, value;
 290      Display    *dpy = XtDisplayOfObject(widget);
 291      char       *text = XtMalloc(BUFSIZ);
 292      char       *textvalue;
 293      XmTextVerifyCallbackStruct *cbs = (XmTextVerifyCallbackStruct*) calldata;
 294
 295      if (NULL == cbs->text->ptr) return;
 296      if (!all_digits(cbs->text->ptr))
 297      {
 298          cbs->doit = FALSE;
 299          XBell(dpy, 50);
 300      }
 301
 302      textvalue = XmTextGetString(widget);
 303      strncpy(text, textvalue, cbs->startPos);
 304      text[cbs->startPos] = '\0';
 305      strcat(text, cbs->text->ptr);
 306      strcat(text, textvalue+cbs->endPos);
 307
 308      XtVaGetValues(spinbox, XmNmaximumValue, &mvalue, NULL);
 309      value = (int) strtol(text, NULL, 10);
 310      if (value > mvalue)
 311      {
 312          cbs->doit = FALSE;
 313          XBell(dpy, 50);
 314      }
 315      XtFree(text);
 316      XtFree(textvalue);
 317 }
 318
 319 void
 320 options_spinbox_chgCB(
 321      Widget widget,
 322      XtPointer clientdata,
 323      XtPointer calldata
 324 )
 325 {
 326      Widget  spinbox = (Widget) clientdata;
 327      int             mvalue, value =
 328                         (int) strtol(XmTextGetString(widget), NULL, 10);
 329      Display         *dpy = XtDisplayOfObject(widget);
 330      calldata = calldata;
 331
 332      props_changed = TRUE;
 333      if (!all_digits(XmTextGetString(widget))){
 334         XtVaSetValues(spinbox, XmNposition, 1, NULL);
 335         XBell(dpy, 50);
 336         return;
 337      }
 338      XtVaGetValues(spinbox, XmNmaximumValue, &mvalue, NULL);
 339      if (value > mvalue) {
 340         XtVaSetValues(spinbox, XmNposition, mvalue, NULL);
 341         XBell(dpy, 50);
 342         return;
 343      }
 344      // It could never be less than the minimum value because a
 345      // '-' is an invalid entry and it would be cleared and reset
 346      // if entered. So if we made it here it is a valid entry. We
 347      // also have to reset the insertion point! Another spinbox bug
 348      // we have to work around.
 349      XtVaSetValues(spinbox, XmNposition, value, NULL);
 350      int shift = 1;
 351      while ((value /= 10) > 0)
 352         shift++;
 353      XmTextSetInsertionPosition(widget, shift);
 354 }
 355
 356 void
 357 options_spinbox_init(
 358     Widget              spinbox,
 359     Boolean             *dirty_bit
 360 )
 361 {
 362     Widget textfield;
 363     dirty_bit = dirty_bit;
 364
 365     XtVaGetValues(spinbox, XmNtextField, &textfield, NULL);
 366     XtAddCallback(textfield, XmNvalueChangedCallback,
 367                 options_spinbox_chgCB, spinbox);
 368     XtAddCallback(textfield, XmNmodifyVerifyCallback,
 369                 options_spinbox_modCB, spinbox);
 370
 371     XtVaSetValues(spinbox, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
 372
 373 }
 374
 375
 376 int
 377 options_spinbox_get_value(
 378     Widget              spinbox
 379 )
 380 {
 381     int      value;
 382
 383     XtVaGetValues(spinbox,
 384                   XmNposition, &value,
 385                   NULL);
 386
 387     return value;
 388 }
 389
 390 int
 391 options_spinbox_set_value(
 392     Widget              spinbox,
 393     int                 value,
 394     Boolean             set_dirty_bit
 395 )
 396 {
 397     if (!set_dirty_bit)
 398       /* Set state so dirty-bit is not triggered */
 399       XtVaSetValues(spinbox, XmNuserData, (XtArgVal)OPTIONS_LOAD, NULL);
 400
 401     /* Set spinbox value */
 402     XtVaSetValues(spinbox, XmNposition, value, NULL);
 403
 404     if (!set_dirty_bit)
 405         /* Reset state */
 406         XtVaSetValues(spinbox, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
 407
 408     return OK;
 409
 410 }
 411 void
 412 options_list_init(Widget list,
 413                   DtVirtArray<char *> *item_list
 414                   )
 415 {
 416   int           num_items;
 417
 418   int           i;
 419   XmStringTable str_list;
 420
 421   if(item_list == NULL)
 422     return;
 423
 424   num_items = item_list->length();
 425   if (0 == num_items) return;
 426
 427   str_list = (XmStringTable)XtMalloc(num_items * sizeof(XmString *));
 428
 429   for(i = 0; i < num_items; i++)
 430     str_list[i] = XmStringCreateLocalized((*item_list)[i]);
 431
 432   XtVaSetValues(list,
 433                 XmNitemCount, num_items,
 434                 XmNitems, str_list,
 435                 NULL);
 436
 437   for(i = 0; i < num_items; i++)
 438     XmStringFree(str_list[i]);
 439   XtFree((char *)str_list);
 440
 441 }
 442
 443 void listAddButtonCB(
 444      Widget widget,
 445      XtPointer clientdata,
 446      XtPointer calldata
 447 )
 448 {
 449   ListUiItem *list = (ListUiItem *)clientdata;
 450   calldata = calldata;
 451   widget = widget;
 452
 453   list->handleAddButtonPress();
 454
 455 }
 456
 457 void listDeleteButtonCB(
 458      Widget widget,
 459      XtPointer clientdata,
 460      XtPointer calldata
 461 )
 462 {
 463   ListUiItem *list = (ListUiItem *)clientdata;
 464   calldata = calldata;
 465   widget = widget;
 466
 467   list->handleDeleteButtonPress();
 468
 469 }
 470
 471 void listChangeButtonCB(
 472      Widget widget,
 473      XtPointer clientdata,
 474      XtPointer calldata
 475 )
 476 {
 477   ListUiItem *list = (ListUiItem *)clientdata;
 478   calldata = calldata;
 479   widget = widget;
 480
 481   list->handleChangeButtonPress();
 482
 483 }
 484
 485 void add_cbs_to_list(ListUiItem *list,
 486                      Widget add_butt,
 487                      Widget del_butt,
 488                      Widget chg_butt)
 489 {
 490   XtAddCallback(add_butt,
 491                 XmNactivateCallback,
 492                 listAddButtonCB,
 493                 list);
 494
 495   XtAddCallback(del_butt,
 496                 XmNactivateCallback,
 497                 listDeleteButtonCB,
 498                 list);
 499
 500   XtAddCallback(chg_butt,
 501                 XmNactivateCallback,
 502                 listChangeButtonCB,
 503                 list);
 504
 505 }
 506
 507 int
 508 options_scale_get_value(
 509     Widget              scale
 510 )
 511 {
 512     int      value;
 513
 514     XtVaGetValues(scale, XmNvalue, &value, NULL);
 515
 516     return value;
 517 }
 518
 519 int
 520 options_scale_set_value(
 521     Widget              scale,
 522     char                *value,
 523     Boolean             set_dirty_bit
 524 )
 525 {
 526     int val_int;
 527
 528     if (!set_dirty_bit)
 529         /* Set state so dirty-bit is not triggered */
 530         XtVaSetValues(scale, XmNuserData, (XtArgVal)OPTIONS_LOAD, NULL);
 531
 532     val_int = (int) strtol(value, NULL, 10);
 533     /* Set scale value */
 534
 535     XtVaSetValues(scale,  XmNvalue, val_int, NULL);
 536
 537     if (!set_dirty_bit)
 538         /* Reset state */
 539         XtVaSetValues(scale, XmNuserData, (XtArgVal)OPTIONS_EDIT, NULL);
 540
 541     return OK;
 542
 543 }