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