cde/programs/dtcm/dtcm/props_pu.c

   1 /* $TOG: props_pu.c /main/22 1999/05/26 09:45:49 mgreess $ */
   2 /*
   3  *  (c) Copyright 1993, 1994 Hewlett-Packard Company
   4  *  (c) Copyright 1993, 1994 International Business Machines Corp.
   5  *  (c) Copyright 1993, 1994 Novell, Inc.
   6  *  (c) Copyright 1993, 1994 Sun Microsystems, Inc.
   7  */
   8
   9 #include <EUSCompat.h>
  10 #include <stdlib.h>
  11 #include <malloc.h>
  12 #include <ctype.h>
  13 #include <sys/param.h>
  14 #include <Xm/Xm.h>
  15 #include <Xm/Form.h>
  16 #include <Xm/LabelG.h>
  17 #include <Xm/List.h>
  18 #include <Xm/DialogS.h>
  19 #include <Xm/PushBG.h>
  20 #include <Xm/RowColumn.h>
  21 #include <Xm/Scale.h>
  22 #include <Xm/SeparatoG.h>
  23 #include <Xm/TextF.h>
  24 #include <Xm/Text.h>
  25 #include <Xm/ToggleB.h>
  26 #include <Xm/ToggleBG.h>
  27 #include <Xm/ComboBox.h>
  28 #include <Xm/SSpinB.h>
  29 #include <Dt/HourGlass.h>
  30 #include <Dt/PrintOptionsP.h>
  31 #include <csa.h>
  32 #include "props_pu.h"
  33 #include "print.h"
  34 #include "editor.h"
  35 #include "group_editor.h"
  36 #include "todo.h"
  37 #include "calendar.h"
  38 #include "browser.h"
  39 #include "dayglance.h"
  40 #include "deskset.h"
  41 #include "rfp.h"
  42 #include "help.h"
  43 #include "getdate.h"
  44 #include "util.h"
  45
  46 static void p_gap_clear_toggles(Props_pu *p);
  47 static void p_gap_center_cat_menu(Widget, Widget);
  48 static void p_create_v4_group_access_pane(Props_pu *);
  49 static Boolean valid_margin_str(Props_pu *, char *);
  50 static void print_option_error(Props_pu *, int, int, char *);
  51
  52 static void activate_ui(Props_pu *p, PaneType item_no);
  53 static void show_ui(Props_pu *p, PaneType item_no);
  54
  55 extern void p_create_v5_group_access_pane(Props_pu *);
  56 extern void v5_gap_clear_pending_change(Props_pu *p);
  57 extern Dimension ComputeMaxWidth(Widget, Widget, Widget, Widget);
  58
  59 extern  void _i18n_HighestWidget( int num, Widget *ret, Dimension *dim, ... );
  60 extern  void _i18n_HighestWidgetAdjust( int num, Widget *ret, Dimension *dim, ... );
  61 extern  void _i18n_WidestWidget( int num, Widget *ret, Dimension *dim, ... );
  62
  63
  64
  65 /*******************************************************************************
  66 **
  67 **  Constants
  68 **
  69 *******************************************************************************/
  70 #define NAME_LEN        23
  71 #define PERMISSION_LEN  6
  72
  73 static XmString Pane_XmStrs[DATE_FORMAT_PANE + 1];
  74
  75 /*******************************************************************************
  76 **
  77 **  Functions static to props_pu.c
  78 **
  79 *******************************************************************************/
  80
  81
  82
  83 static void
  84 v4_gap_pending_change(Widget w, XtPointer data, XtPointer cbs) {
  85         Props_pu *p = (Props_pu *) data;
  86
  87         if (p->v4_gap_pending_message_up == False) {
  88                 p->v4_gap_pending_message_up = True;
  89                 XtSetSensitive(p->gap_add_button, True);
  90         }
  91 }
  92
  93 static void
  94 v4_gap_clear_pending_change(Props_pu *p) {
  95
  96         if (p->v4_gap_pending_message_up == True) {
  97                 p->v4_gap_pending_message_up = False;
  98                 XtSetSensitive(p->gap_add_button, False);
  99         }
 100 }
 101
 102 extern void
 103 p_set_change(Props_pu *p) {
 104
 105         if (!p)
 106                 return;
 107
 108         p->changed_flag = True;
 109
 110         if (p->ok_button)
 111                 XtSetSensitive(p->ok_button, True);
 112         if (p->apply_button)
 113                 XtSetSensitive(p->apply_button, True);
 114         if (p->defaults_button)
 115                 XtSetSensitive(p->defaults_button, True);
 116         if (p->base_form_mgr)
 117                 XtVaSetValues(p->base_form_mgr, XmNdefaultButton, p->apply_button, NULL);
 118 }
 119
 120 static void
 121 p_clear_change(Props_pu *p) {
 122
 123         p->changed_flag = False;
 124
 125         XtSetSensitive(p->ok_button, False);
 126         XtSetSensitive(p->apply_button, False);
 127         XtSetSensitive(p->defaults_button, False);
 128         if (p->cal->my_cal_version >= DATAVER4) {
 129                 char    *str;
 130                 if (*(str = (char *)XmTextGetString(p->gap_user_text))=='\0') {
 131                         v5_gap_clear_pending_change(p);
 132                 } else {
 133                         XtFree(str);
 134                         if (p->v5_gap_pending_message_up == False) {
 135                                 p->v5_gap_pending_message_up = True;
 136                                 XtSetSensitive(p->gap2_add_button, True);
 137                         }
 138                 }
 139                 XtSetSensitive(p->gap2_change_button, False);
 140         } else
 141                 v4_gap_clear_pending_change(p);
 142
 143         XtSetSensitive(p->gap_remove_button, False);
 144         XtVaSetValues(p->base_form_mgr, XmNdefaultButton, p->close_button, NULL);
 145 }
 146 static void
 147 p_mark_change(Widget w, XtPointer data, XtPointer cbs) {
 148
 149         Props_pu        *p = (Props_pu *)data;
 150
 151         p_set_change(p);
 152 }
 153
 154 static void
 155 set_menu_marker(Widget menu, Props_pu *p) {
 156
 157         Widget          submenu;
 158         WidgetList      children;
 159         Cardinal        num_c;
 160
 161         XtVaGetValues(menu, XmNsubMenuId, &submenu, NULL);
 162         XtVaGetValues(submenu,
 163                 XmNchildren, &children,
 164                 XmNnumChildren, &num_c,
 165                 NULL);
 166
 167         while (num_c > 0)
 168                 XtAddCallback(children[--num_c], XmNactivateCallback, p_mark_change, p);
 169 }
 170
 171 #define GAP 5
 172
 173 static void
 174 p_create_editor_pane(
 175         Calendar        *c)
 176 {
 177         int              ac;
 178         Arg              args[10];
 179         char             buf[MAXNAMELEN];
 180         Props           *p = (Props *)c->properties;
 181         Widget           ep_form_mgr;
 182         Widget           text_field;
 183         Props_pu        *pu = (Props_pu *)c->properties_pu;
 184         XmString         xmstr;
 185         Dimension        max_left_label_width;
 186         Widget           widgets[7];
 187         Dimension       widest, highest;
 188         Dimension       _toLabel, _toText, _toMenu, _toRC;
 189         Widget          prev, curr;
 190
 191         /*
 192         **  Base form
 193         */
 194         ep_form_mgr = XtVaCreateWidget("ep_form_mgr",
 195                 xmFormWidgetClass, pu->base_form_mgr,
 196                 XmNautoUnmanage,        False,
 197                 XmNtopAttachment,       XmATTACH_WIDGET,
 198                 XmNtopWidget,           pu->separator1,
 199                 XmNleftAttachment,      XmATTACH_FORM,
 200                 XmNrightAttachment,     XmATTACH_FORM,
 201                 XmNbottomOffset,        10,
 202                 NULL);
 203         pu->pane_list[EDITOR_PANE] = ep_form_mgr;
 204
 205         /*
 206         **  Default start time and duration for appointments - use DSSW widget
 207         **  for start time stuff.
 208         */
 209         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 644,
 210                                                 "Appointment Times:"));
 211         pu->ep_appt_label = XtVaCreateWidget("apptTimes",
 212                 xmLabelGadgetClass, ep_form_mgr,
 213                 XmNlabelString,         xmstr,
 214                 XmNtopAttachment,       XmATTACH_FORM,
 215                 XmNtopOffset,           GAP,
 216                 XmNleftAttachment,      XmATTACH_FORM,
 217                 XmNleftOffset,          GAP,
 218                 NULL);
 219         XmStringFree(xmstr);
 220
 221         build_dssw(&pu->ep_dssw, c, ep_form_mgr, False, False);
 222
 223
 224
 225         XtUnmanageChild(pu->ep_dssw.what_scrollwindow);
 226
 227         widgets[0] = pu->ep_dssw.start_label;
 228         widgets[1] = pu->ep_dssw.start_text;
 229         widgets[2] = pu->ep_dssw.start_menu;
 230         widgets[3] = pu->ep_dssw.start_ampm_rc_mgr;
 231
 232         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 645,
 233                                                 "Duration:"));
 234         pu->ep_dur_label = widgets[4] = XtVaCreateWidget("duration",
 235                 xmLabelGadgetClass, pu->ep_dssw.dssw_form_mgr,
 236                 XmNlabelString, xmstr,
 237                 NULL);
 238         XmStringFree(xmstr);
 239
 240         ac = 0;
 241         XtSetArg(args[ac], XmNcomboBoxType,     XmDROP_DOWN_COMBO_BOX); ++ac;
 242         XtSetArg(args[ac], XmNvisibleItemCount, 5); ++ac;
 243         XtSetArg(args[ac], XmNpositionMode, XmONE_BASED); ++ac;
 244         pu->ep_dur_cb = widgets[5] = XmCreateComboBox(pu->ep_dssw.dssw_form_mgr,
 245                                          "ep_dur_cb", args, ac);
 246         XtManageChild(pu->ep_dur_cb);
 247         XtVaSetValues(pu->ep_dur_cb, XmNwidth, 75, NULL);
 248
 249         for(ac = 15; ac <= 90; ac += 15) {
 250                 if (ac != 75) {
 251                         sprintf(buf, "%d", ac);
 252                         xmstr = XmStringCreateLocalized(buf);
 253                         XmComboBoxAddItem((Widget)pu->ep_dur_cb,
 254                                           xmstr, 0, False);
 255                         XmStringFree(xmstr);
 256                 }
 257         }
 258
 259         XtVaGetValues(pu->ep_dur_cb, XmNtextField, &text_field, 0);
 260         XtAddCallback(text_field, XmNvalueChangedCallback, p_mark_change, pu);
 261         XtAddCallback(pu->ep_dur_cb, XmNselectionCallback, p_mark_change, pu);
 262
 263         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 646, "Minutes"));
 264         pu->ep_dur_message = widgets[6] = XtVaCreateWidget("message",
 265                 xmLabelGadgetClass, pu->ep_dssw.dssw_form_mgr,
 266                 XmNlabelString,         xmstr,
 267                 NULL);
 268         XmStringFree(xmstr);
 269
 270         /*
 271          * Do a layout
 272          */
 273         _i18n_WidestWidget( 2, &curr, &max_left_label_width, pu->ep_dur_label,
 274                          pu->ep_dssw.start_label );
 275         _toText = max_left_label_width + 2 * GAP;
 276         _i18n_WidestWidget( 1, &curr, &widest, pu->ep_dur_label );
 277         _toLabel = _toText - GAP - widest;
 278         _i18n_WidestWidget( 1, &curr, &widest, pu->ep_dur_cb );
 279         _toMenu = _toText + widest + GAP;
 280
 281         /*
 282          * pu->ep_dur_label, pu->ep_dur_cb, pu->ep_dur_message
 283          */
 284         _i18n_HighestWidgetAdjust( 3, &curr, &highest, pu->ep_dur_label,
 285                         pu->ep_dur_cb, pu->ep_dur_message );
 286
 287         XtVaSetValues( curr,
 288                         XmNtopAttachment, XmATTACH_FORM,
 289                         XmNtopOffset, GAP,
 290                         NULL );
 291         XtVaSetValues( pu->ep_dur_label,
 292                         XmNleftAttachment, XmATTACH_FORM,
 293                         XmNleftOffset, _toLabel,
 294                         NULL );
 295         XtVaSetValues( pu->ep_dur_cb,
 296                         XmNleftAttachment, XmATTACH_FORM,
 297                         XmNleftOffset, _toText,
 298                         NULL );
 299         XtVaSetValues( pu->ep_dur_message,
 300                         XmNleftAttachment, XmATTACH_FORM,
 301                         XmNleftOffset, _toMenu,
 302                         NULL );
 303         prev = curr;
 304
 305         /*
 306          * pu->ep_dssw.start_label,  pu->ep_dssw.start_text,
 307          * pu->ep_dssw.start_menu,  pu->ep_dssw.start_ampm_rc_mgr
 308          */
 309         _i18n_WidestWidget( 1, &curr, &widest, pu->ep_dssw.start_label );
 310         _toLabel = _toText - GAP - widest;
 311         _i18n_WidestWidget( 1, &curr, &widest, pu->ep_dssw.start_text );
 312         _toMenu = _toText + widest + GAP;
 313         _i18n_WidestWidget( 1, &curr, &widest, pu->ep_dssw.start_menu );
 314         _toRC = _toMenu + widest + GAP;
 315         _i18n_HighestWidgetAdjust( 4, &curr, &highest, pu->ep_dssw.start_label,
 316                                         pu->ep_dssw.start_text,
 317                                         pu->ep_dssw.start_menu,
 318                                         pu->ep_dssw.start_ampm_rc_mgr );
 319         XtVaSetValues( curr,
 320                         XmNtopAttachment, XmATTACH_WIDGET,
 321                         XmNtopWidget, prev,
 322                         XmNtopOffset, GAP,
 323                         NULL );
 324         XtVaSetValues( pu->ep_dssw.start_label,
 325                         XmNleftAttachment, XmATTACH_FORM,
 326                         XmNleftOffset, _toLabel,
 327                         NULL );
 328         XtVaSetValues( pu->ep_dssw.start_text,
 329                         XmNleftAttachment, XmATTACH_FORM,
 330                         XmNleftOffset, _toText,
 331                         NULL );
 332         XtVaSetValues( pu->ep_dssw.start_menu,
 333                         XmNleftAttachment, XmATTACH_FORM,
 334                         XmNleftOffset, _toMenu,
 335                         NULL );
 336         XtVaSetValues( pu->ep_dssw.start_ampm_rc_mgr,
 337                         XmNleftAttachment, XmATTACH_FORM,
 338                         XmNleftOffset, _toRC,
 339                         NULL );
 340
 341         XtVaSetValues(pu->ep_dssw.dssw_form_mgr,
 342                 XmNtopAttachment,       XmATTACH_WIDGET,
 343                 XmNtopWidget,           pu->ep_appt_label,
 344                 XmNtopOffset,           10,
 345                 XmNrightAttachment,     XmATTACH_FORM,
 346                 XmNleftAttachment,      XmATTACH_OPPOSITE_WIDGET,
 347                 XmNleftWidget,          pu->ep_appt_label,
 348                 XmNleftOffset,          0,
 349                 NULL);
 350
 351         XtManageChildren(widgets, 7);
 352
 353         /*
 354          *  Reminders widget (self contained)
 355          */
 356         build_reminders(&pu->ep_reminders, c, ep_form_mgr);
 357         XtVaSetValues(pu->ep_reminders.bfpm_form_mgr,
 358                 XmNtopAttachment, XmATTACH_WIDGET,
 359                 XmNtopWidget, pu->ep_dssw.dssw_form_mgr,
 360                 XmNtopOffset, 5,
 361                 XmNleftAttachment, XmATTACH_FORM,
 362                 NULL);
 363
 364         /*
 365         **  Build the stuff for privacy ...
 366         */
 367         xmstr = XmStringCreateLocalized(
 368                                 catgets(c->DT_catd, 1, 390, "Privacy:"));
 369         pu->privacy_label = XtVaCreateWidget("privacy",
 370                 xmLabelGadgetClass,     pu->ep_reminders.bfpm_form_mgr,
 371                 XmNlabelString,         xmstr,
 372                 NULL);
 373         XmStringFree(xmstr);
 374
 375         pu->privacy_menu = create_privacy_menu(pu->ep_reminders.bfpm_form_mgr);
 376         XtVaSetValues(pu->privacy_menu,
 377                 XmNuserData,            0,
 378                 NULL);
 379         ManageChildren(pu->ep_reminders.bfpm_form_mgr);
 380
 381         /*
 382          * Do layout
 383          */
 384         _i18n_WidestWidget( 1, &prev, &widest, pu->privacy_label );
 385         _i18n_HighestWidget( 2, &prev, &highest, pu->ep_reminders.mailto_label,
 386                                 pu->ep_reminders.mailto_text );
 387         _i18n_HighestWidgetAdjust( 2, &curr, &highest,
 388                          pu->privacy_label, pu->privacy_menu );
 389         XtVaSetValues( curr,
 390                         XmNtopAttachment, XmATTACH_WIDGET,
 391                         XmNtopWidget, prev,
 392                         XmNtopOffset, 30,
 393                         XmNbottomAttachment, XmATTACH_FORM,
 394                         XmNbottomOffset, 10,
 395                         NULL );
 396         XtVaSetValues( pu->privacy_label,
 397                         XmNleftAttachment, XmATTACH_FORM,
 398                         XmNleftOffset, 15,   /* See reminders.c l. 783 */
 399                         NULL );
 400         XtVaSetValues( pu->privacy_menu,
 401                         XmNleftAttachment, XmATTACH_FORM,
 402                         XmNleftOffset, 15 + widest + 5,
 403                         NULL );
 404
 405         XtAddCallback(pu->privacy_menu, XmNselectionCallback, p_mark_change, pu);
 406
 407         XtAddCallback(pu->ep_dssw.start_text, XmNvalueChangedCallback, p_mark_change, pu);
 408         XtAddCallback(pu->ep_dssw.start_am, XmNvalueChangedCallback, p_mark_change, pu);
 409         XtAddCallback(pu->ep_dssw.start_pm, XmNvalueChangedCallback, p_mark_change, pu);
 410         XtAddCallback(pu->ep_reminders.beep_text, XmNvalueChangedCallback, p_mark_change, pu);
 411         XtAddCallback(pu->ep_reminders.beep_toggle, XmNvalueChangedCallback, p_mark_change, pu);
 412
 413         set_menu_marker(pu->ep_reminders.beep_menu, pu);
 414         XtAddCallback(pu->ep_reminders.flash_text,
 415                         XmNvalueChangedCallback, p_mark_change, pu);
 416         XtAddCallback(pu->ep_reminders.flash_toggle,
 417                         XmNvalueChangedCallback, p_mark_change, pu);
 418         set_menu_marker(pu->ep_reminders.flash_menu, pu);
 419         XtAddCallback(pu->ep_reminders.mail_text,
 420                         XmNvalueChangedCallback, p_mark_change, pu);
 421         XtAddCallback(pu->ep_reminders.mail_toggle,
 422                         XmNvalueChangedCallback, p_mark_change, pu);
 423         set_menu_marker(pu->ep_reminders.mail_menu, pu);
 424         XtAddCallback(pu->ep_reminders.mailto_text,
 425                         XmNvalueChangedCallback, p_mark_change, pu);
 426         XtAddCallback(pu->ep_reminders.popup_text,
 427                         XmNvalueChangedCallback, p_mark_change, pu);
 428         XtAddCallback(pu->ep_reminders.popup_toggle,
 429                         XmNvalueChangedCallback, p_mark_change, pu);
 430         set_menu_marker(pu->ep_reminders.popup_menu, pu);
 431
 432         ManageChildren(ep_form_mgr);
 433 }
 434
 435 static void
 436 format_hour(char buffer[], int hour, DisplayType dt, Calendar *c)
 437
 438 {
 439         if (dt == HOUR12) {
 440                 if ((hour == 24) || (hour == 0))
 441                         cm_strcpy(buffer, catgets(c->DT_catd, 1, 758,"midnight"));
 442                 else if (hour > 12)
 443                                 sprintf(buffer, "%2d:00 %s", hour-12,
 444                                         catgets(c->DT_catd, 1, 3, "pm"));
 445                 else
 446                                 sprintf(buffer, "%2d:00 %s", hour,
 447                                         catgets(c->DT_catd, 1, 4, "am"));
 448         }
 449         else
 450                 sprintf(buffer, " %02d00", hour);
 451 }
 452
 453 static void
 454 set_scale_value(Widget w, int val, Props_pu *p)
 455
 456 {
 457         char                    label_buffer[50];
 458         XmString                xmstr;
 459         Calendar                *c = p->cal;
 460         Props                   *props = (Props *) c->properties;
 461
 462         format_hour(label_buffer, val, (DisplayType) get_int_prop(props, CP_DEFAULTDISP), c);
 463
 464         xmstr = XmStringCreateLocalized(label_buffer);
 465
 466         XtVaSetValues(w,
 467                 XmNlabelString, xmstr,
 468                 NULL);
 469
 470         XmStringFree(xmstr);
 471 }
 472
 473
 474 static void
 475 print_it(Widget w, XtPointer data, XtPointer cbs) {
 476         int                     val;
 477         Props_pu                *p = (Props_pu *)data;
 478         XmScaleCallbackStruct   *scbs = (XmScaleCallbackStruct *)cbs;
 479
 480 }
 481 /*
 482 **  Functions related to the display pane
 483 */
 484 static void
 485 p_dp_scale_mod_proc(Widget w, XtPointer data, XtPointer cbs) {
 486         int                     val;
 487         Props_pu                *p = (Props_pu *)data;
 488         XmScaleCallbackStruct   *scbs = (XmScaleCallbackStruct *)cbs;
 489
 490         if (!p)
 491                 return;
 492
 493         if (w == p->dp_beg_scale) {
 494                 XmScaleGetValue(p->dp_end_scale, &val);
 495                 if (val < scbs->value)
 496                 {
 497                         XmScaleSetValue(p->dp_end_scale, scbs->value + 1);
 498                         set_scale_value(p->dp_end_value, scbs->value + 1, p);
 499                 }
 500                 set_scale_value(p->dp_beg_value, scbs->value, p);
 501
 502
 503         } else {
 504                 XmScaleGetValue(p->dp_beg_scale, &val);
 505                 if (val > scbs->value)
 506                 {
 507                         XmScaleSetValue(p->dp_beg_scale, scbs->value - 1);
 508                         set_scale_value(p->dp_beg_value, scbs->value - 1, p);
 509                 }
 510                 set_scale_value(p->dp_end_value, scbs->value, p);
 511
 512         }
 513
 514         p_set_change(p);
 515 }
 516
 517 static void
 518 p_create_display_pane(Props_pu *p) {
 519         Calendar        *c = calendar;
 520         Widget          dp_form_mgr;
 521         XmString        xmstr;
 522         Widget          widgets[2];
 523         Dimension widest, highest;
 524         Widget    prev, curr;
 525         Dimension _to1st, _to2nd, _to3rd;
 526
 527         /*
 528         **  Base form
 529         */
 530         dp_form_mgr = XtVaCreateWidget("dp_form_mgr",
 531                 xmFormWidgetClass, p->base_form_mgr,
 532                 XmNautoUnmanage,        False,
 533                 XmNtopAttachment,       XmATTACH_WIDGET,
 534                 XmNtopWidget,           p->separator1,
 535                 XmNleftAttachment,      XmATTACH_FORM,
 536                 XmNrightAttachment,     XmATTACH_FORM,
 537                 XmNbottomAttachment,    XmATTACH_WIDGET,
 538                 XmNbottomOffset,        10,
 539                 XmNbottomWidget,        p->separator2,
 540                 NULL);
 541         p->pane_list[DISPLAY_PANE] = dp_form_mgr;
 542
 543         /*
 544         **  User Calendar Location label and text field
 545         */
 546         xmstr = XmStringCreateLocalized(
 547                         catgets(c->DT_catd, 1, 391, "User Calendar Location:"));
 548         p->dp_loc_label = XtVaCreateWidget("location",
 549                 xmLabelGadgetClass, dp_form_mgr,
 550                 XmNlabelString,         xmstr,
 551                 NULL);
 552         XmStringFree(xmstr);
 553
 554         p->dp_loc_text = XtVaCreateWidget("dp_loc_text",
 555                 xmTextWidgetClass, dp_form_mgr,
 556                 NULL);
 557
 558         XtAddCallback(p->dp_loc_text,
 559                         XmNvalueChangedCallback, p_mark_change, p);
 560
 561         /*
 562         **  Day Boundaries label and beginning/ending sliders
 563         */
 564
 565         /* There is some additional, very odd layout stuff that
 566            happens elsewhere.  This is because sliders do not align
 567            well with text widgets at all.  We want to align the
 568            centers of the text and slider widgets.  This is done by
 569            finding the relative heights of the widgets, and using half
 570            the differenmce as a bottom offset.  Why don't you see that
 571            below?  Well, it's because the stupid toolkit reports the
 572            height of a slider as 0 unless that slider is mapped.  Thus,
 573            this bit of alignment cannot happen until the panel with these
 574            items is mapped.  Pretty stupid.  Thus the positioning happens
 575            just after the panel is mapped. */
 576         xmstr = XmStringCreateLocalized(
 577                                 catgets(c->DT_catd, 1, 392, "Day Boundaries:"));
 578         p->dp_day_label = XtVaCreateWidget("dayBoundaries",
 579                 xmLabelGadgetClass, dp_form_mgr,
 580                 XmNlabelString,         xmstr,
 581                 NULL);
 582         XmStringFree(xmstr);
 583
 584         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 393, "Begin:"));
 585         p->dp_beg_label = XtVaCreateWidget("begin",
 586                 xmLabelGadgetClass, dp_form_mgr,
 587                 XmNlabelString,         xmstr,
 588                 NULL);
 589         XmStringFree(xmstr);
 590
 591         p->dp_beg_scale = XtVaCreateWidget("dp_beg_scale",
 592                 xmScaleWidgetClass, dp_form_mgr,
 593                 XmNorientation,         XmHORIZONTAL,
 594                 XmNmaximum,             23,
 595                 XmNminimum,             0,
 596                 XmNvalue,               0,
 597                 XmNscaleMultiple,       1,
 598                 NULL);
 599         XtAddCallback(p->dp_beg_scale, XmNvalueChangedCallback,
 600                       p_dp_scale_mod_proc, p);
 601         XtAddCallback(p->dp_beg_scale, XmNdragCallback,
 602                       p_dp_scale_mod_proc, p);
 603
 604         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 759, "value"));
 605         p->dp_beg_value = XtVaCreateWidget("begin",
 606                 xmLabelGadgetClass, dp_form_mgr,
 607                 XmNlabelString,         xmstr,
 608                 NULL);
 609         XmStringFree(xmstr);
 610
 611         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 394, "End:"));
 612         p->dp_end_label = XtVaCreateWidget("end",
 613                 xmLabelGadgetClass, dp_form_mgr,
 614                 XmNlabelString,         xmstr,
 615                 NULL);
 616         XmStringFree(xmstr);
 617
 618         p->dp_end_scale = XtVaCreateWidget("dp_end_scale",
 619                 xmScaleWidgetClass, dp_form_mgr,
 620                 XmNorientation,         XmHORIZONTAL,
 621                 XmNmaximum,             24,
 622                 XmNminimum,             1,
 623                 XmNvalue,               1,
 624                 XmNscaleMultiple,       1,
 625                 NULL);
 626         XtAddCallback(p->dp_end_scale, XmNvalueChangedCallback,
 627                       p_dp_scale_mod_proc, p);
 628         XtAddCallback(p->dp_end_scale, XmNdragCallback,
 629                       p_dp_scale_mod_proc, p);
 630
 631         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 760, "value"));
 632         p->dp_end_value = XtVaCreateWidget("begin",
 633                 xmLabelGadgetClass, dp_form_mgr,
 634                 XmNlabelString,         xmstr,
 635                 NULL);
 636         XmStringFree(xmstr);
 637
 638         /*
 639         **  12/24 Hour Display label and toggle buttons
 640         */
 641         xmstr = XmStringCreateLocalized(
 642                                 catgets(c->DT_catd, 1, 395, "Hour Display:"));
 643         p->dp_hour_label = XtVaCreateWidget("hourDisplay",
 644                 xmLabelGadgetClass, dp_form_mgr,
 645                 XmNlabelString,         xmstr,
 646                 NULL);
 647         XmStringFree(xmstr);
 648
 649         p->dp_hour_rc_mgr = XtVaCreateWidget("dp_hour_rc_mgr",
 650                 xmRowColumnWidgetClass, dp_form_mgr,
 651                 XmNpacking,             XmPACK_COLUMN,
 652                 XmNorientation,         XmHORIZONTAL,
 653                 XmNradioBehavior,       True,
 654                 XmNisHomogeneous,       True,
 655                 XmNentryClass,          xmToggleButtonGadgetClass,
 656                 NULL);
 657
 658         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 396, "12 Hour"));
 659         p->dp_hour12_toggle = widgets[0] = XtVaCreateWidget("twelveHour",
 660                 xmToggleButtonGadgetClass, p->dp_hour_rc_mgr,
 661                 XmNlabelString,         xmstr,
 662                 NULL);
 663         XmStringFree(xmstr);
 664
 665         XtAddCallback(p->dp_hour12_toggle,
 666                         XmNvalueChangedCallback, p_mark_change, p);
 667
 668         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 397, "24 Hour"));
 669         p->dp_hour24_toggle = widgets[1] = XtVaCreateWidget("twentyFourHour",
 670                 xmToggleButtonGadgetClass, p->dp_hour_rc_mgr,
 671                 XmNlabelString,         xmstr,
 672                 NULL);
 673         XmStringFree(xmstr);
 674
 675         XtAddCallback(p->dp_hour24_toggle,
 676                         XmNvalueChangedCallback, p_mark_change, p);
 677
 678         XtManageChildren(widgets, 2);
 679
 680         /*
 681         **  Default view label and toggle buttons
 682         */
 683         xmstr = XmStringCreateLocalized(
 684                                 catgets(c->DT_catd, 1, 398, "Default View:"));
 685         p->dp_view_label = XtVaCreateWidget("defaultView:",
 686                 xmLabelGadgetClass, dp_form_mgr,
 687                 XmNlabelString,         xmstr,
 688                 NULL);
 689         XmStringFree(xmstr);
 690
 691         p->dp_view_rc_mgr = XtVaCreateWidget("dp_view_rc_mgr",
 692                 xmRowColumnWidgetClass, dp_form_mgr,
 693                 XmNpacking,             XmPACK_COLUMN,
 694                 XmNorientation,         XmHORIZONTAL,
 695                 XmNradioBehavior,       True,
 696                 XmNisHomogeneous,       True,
 697                 XmNentryClass,          xmToggleButtonGadgetClass,
 698                 NULL);
 699
 700
 701         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 402, "Day"));
 702         p->dp_view_day_toggle = XtVaCreateWidget("day",
 703                 xmToggleButtonGadgetClass, p->dp_view_rc_mgr,
 704                 XmNlabelString,         xmstr,
 705                 NULL);
 706         XmStringFree(xmstr);
 707
 708         XtAddCallback(p->dp_view_day_toggle,
 709                         XmNvalueChangedCallback, p_mark_change, p);
 710
 711         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 401, "Week"));
 712         p->dp_view_week_toggle = XtVaCreateWidget("week",
 713                 xmToggleButtonGadgetClass, p->dp_view_rc_mgr,
 714                 XmNlabelString,         xmstr,
 715                 NULL);
 716         XmStringFree(xmstr);
 717
 718         XtAddCallback(p->dp_view_week_toggle,
 719                         XmNvalueChangedCallback, p_mark_change, p);
 720
 721         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 400, "Month"));
 722         p->dp_view_month_toggle = XtVaCreateWidget("month",
 723                 xmToggleButtonGadgetClass, p->dp_view_rc_mgr,
 724                 XmNlabelString,         xmstr,
 725                 NULL);
 726         XmStringFree(xmstr);
 727
 728         XtAddCallback(p->dp_view_month_toggle,
 729                         XmNvalueChangedCallback, p_mark_change, p);
 730
 731         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 399, "Year"));
 732         p->dp_view_year_toggle = XtVaCreateWidget("year",
 733                 xmToggleButtonGadgetClass, p->dp_view_rc_mgr,
 734                 XmNlabelString,         xmstr,
 735                 NULL);
 736         XmStringFree(xmstr);
 737
 738         XtAddCallback(p->dp_view_year_toggle,
 739                         XmNvalueChangedCallback, p_mark_change, p);
 740
 741         ManageChildren(p->dp_view_rc_mgr);
 742
 743         /*
 744         **  Initial Calendar View label and text field
 745         */
 746         xmstr = XmStringCreateLocalized(
 747                         catgets(c->DT_catd, 1, 403, "Initial Calendar View:"));
 748         p->dp_init_view_label = XtVaCreateWidget("initialView",
 749                 xmLabelGadgetClass, dp_form_mgr,
 750                 XmNlabelString,         xmstr,
 751                 NULL);
 752         XmStringFree(xmstr);
 753
 754         p->dp_init_view_text = XtVaCreateWidget("dp_init_view_text",
 755                 xmTextWidgetClass, dp_form_mgr,
 756                 NULL);
 757
 758         XtAddCallback(p->dp_init_view_text,
 759                         XmNvalueChangedCallback, p_mark_change, p);
 760
 761         /*
 762          * Here, do a layout
 763          */
 764         _i18n_WidestWidget( 7, &curr, &widest, p->dp_loc_label,
 765                                 p->dp_day_label, p->dp_beg_label,
 766                                 p->dp_end_label, p->dp_hour_label,
 767                                 p->dp_view_label, p->dp_init_view_label );
 768         _to2nd = 5 + widest + 10;
 769
 770         /*
 771          * p->dp_loc_label, p->dp_loc_text
 772          */
 773         _i18n_WidestWidget( 1, &curr, &widest, p->dp_loc_label );
 774         _to1st = _to2nd - 10 - widest;
 775         _i18n_HighestWidgetAdjust( 2, &curr, &highest, p->dp_loc_label,
 776                                         p->dp_loc_text );
 777         XtVaSetValues( curr,
 778                         XmNtopAttachment, XmATTACH_FORM,
 779                         XmNtopOffset, 12,
 780                         NULL );
 781         XtVaSetValues( p->dp_loc_label,
 782                         XmNleftAttachment, XmATTACH_FORM,
 783                         XmNleftOffset, _to1st,
 784                         NULL );
 785         XtVaSetValues( p->dp_loc_text,
 786                         XmNleftAttachment, XmATTACH_FORM,
 787                         XmNleftOffset, _to2nd,
 788                         NULL );
 789         prev = curr;
 790
 791         /*
 792          * p->dp_day_label
 793          */
 794         _i18n_WidestWidget( 1, &curr, &widest, p->dp_day_label );
 795         _to1st = _to2nd - 10 - widest;
 796         XtVaSetValues( p->dp_day_label,
 797                         XmNtopAttachment, XmATTACH_WIDGET,
 798                         XmNtopWidget, prev,
 799                         XmNtopOffset, 10,
 800                         NULL );
 801         XtVaSetValues( p->dp_day_label,
 802                         XmNleftAttachment, XmATTACH_FORM,
 803                         XmNleftOffset, _to1st,
 804                         NULL );
 805         prev = p->dp_day_label;
 806
 807         /*
 808          * p->dp_beg_label, p->dp_beg_scale, p->dp_beg_value
 809          */
 810         _i18n_WidestWidget( 1, &curr, &widest, p->dp_beg_label );
 811         _to1st = _to2nd - 10 - widest;
 812         _i18n_WidestWidget( 1, &curr, &widest, p->dp_beg_scale );
 813         _to3rd = _to2nd + widest + 5;
 814         _i18n_HighestWidgetAdjust( 3, &curr, &highest, p->dp_beg_label,
 815                                         p->dp_beg_scale, p->dp_beg_value );
 816         XtVaSetValues( curr,
 817                         XmNtopAttachment, XmATTACH_WIDGET,
 818                         XmNtopWidget, prev,
 819                         XmNtopOffset, 12,
 820                         NULL );
 821         XtVaSetValues( p->dp_beg_label,
 822                         XmNleftAttachment, XmATTACH_FORM,
 823                         XmNleftOffset, _to1st,
 824                         NULL );
 825         XtVaSetValues( p->dp_beg_scale,
 826                         XmNleftAttachment, XmATTACH_FORM,
 827                         XmNleftOffset, _to2nd,
 828                         NULL );
 829         XtVaSetValues( p->dp_beg_value,
 830                         XmNleftAttachment, XmATTACH_FORM,
 831                         XmNleftOffset, _to3rd,
 832                         NULL );
 833         prev = curr;
 834
 835         /*
 836          * p->dp_end_label, p->dp_end_scale, p->dp_end_value
 837          */
 838         _i18n_WidestWidget( 1, &curr, &widest, p->dp_end_label );
 839         _to1st = _to2nd - 10 - widest;
 840         _i18n_WidestWidget( 1, &curr, &widest, p->dp_end_scale );
 841         _to3rd = _to2nd + widest + 5;
 842         _i18n_HighestWidgetAdjust( 3, &curr, &highest, p->dp_end_label,
 843                                         p->dp_end_scale, p->dp_end_value );
 844         XtVaSetValues( curr,
 845                         XmNtopAttachment, XmATTACH_WIDGET,
 846                         XmNtopWidget, prev,
 847                         XmNtopOffset, 12,
 848                         NULL );
 849         XtVaSetValues( p->dp_end_label,
 850                         XmNleftAttachment, XmATTACH_FORM,
 851                         XmNleftOffset, _to1st,
 852                         NULL );
 853         XtVaSetValues( p->dp_end_scale,
 854                         XmNleftAttachment, XmATTACH_FORM,
 855                         XmNleftOffset, _to2nd,
 856                         NULL );
 857         XtVaSetValues( p->dp_end_value,
 858                         XmNleftAttachment, XmATTACH_FORM,
 859                         XmNleftOffset, _to3rd,
 860                         NULL );
 861         prev = curr;
 862
 863         /*
 864          * p->dp_hour_label, p->dp_hour_rc_mgr
 865          */
 866         _i18n_WidestWidget( 1, &curr, &widest, p->dp_hour_label );
 867         _to1st = _to2nd - 10 - widest;
 868         _i18n_HighestWidgetAdjust( 2, &curr, &highest, p->dp_hour_label,
 869                                         p->dp_hour_rc_mgr );
 870         XtVaSetValues( curr,
 871                         XmNtopAttachment, XmATTACH_WIDGET,
 872                         XmNtopWidget, prev,
 873                         XmNtopOffset, 12,
 874                         NULL );
 875         XtVaSetValues( p->dp_hour_label,
 876                         XmNleftAttachment, XmATTACH_FORM,
 877                         XmNleftOffset, _to1st,
 878                         NULL );
 879         XtVaSetValues( p->dp_hour_rc_mgr,
 880                         XmNleftAttachment, XmATTACH_FORM,
 881                         XmNleftOffset, _to2nd,
 882                         NULL );
 883         prev = curr;
 884
 885         /*
 886          * p->dp_view_label, p->dp_view_rc_mgr
 887          */
 888         _i18n_WidestWidget( 1, &curr, &widest, p->dp_view_label );
 889         _to1st = _to2nd - 10 - widest;
 890         _i18n_HighestWidgetAdjust( 2, &curr, &highest, p->dp_view_label,
 891                                         p->dp_view_rc_mgr );
 892         XtVaSetValues( curr,
 893                         XmNtopAttachment, XmATTACH_WIDGET,
 894                         XmNtopWidget, prev,
 895                         XmNtopOffset, 12,
 896                         NULL );
 897         XtVaSetValues( p->dp_view_label,
 898                         XmNleftAttachment, XmATTACH_FORM,
 899                         XmNleftOffset, _to1st,
 900                         NULL );
 901         XtVaSetValues( p->dp_view_rc_mgr,
 902                         XmNleftAttachment, XmATTACH_FORM,
 903                         XmNleftOffset, _to2nd,
 904                         NULL );
 905         prev = curr;
 906
 907         /*
 908          * p->dp_init_view_label, p->dp_init_view_text
 909          */
 910         _i18n_WidestWidget( 1, &curr, &widest, p->dp_init_view_label );
 911         _to1st = _to2nd - 10 - widest;
 912         _i18n_HighestWidgetAdjust( 2, &curr, &highest, p->dp_init_view_label,
 913                                         p->dp_init_view_text );
 914         XtVaSetValues( curr,
 915                         XmNtopAttachment, XmATTACH_WIDGET,
 916                         XmNtopWidget, prev,
 917                         XmNtopOffset, 12,
 918                         NULL );
 919         XtVaSetValues( p->dp_init_view_label,
 920                         XmNleftAttachment, XmATTACH_FORM,
 921                         XmNleftOffset, _to1st,
 922                         NULL );
 923         XtVaSetValues( p->dp_init_view_text,
 924                         XmNleftAttachment, XmATTACH_FORM,
 925                         XmNleftOffset, _to2nd,
 926                         NULL );
 927         prev = curr;
 928
 929
 930         ManageChildren(dp_form_mgr);
 931 }
 932
 933 extern unsigned int
 934 p_gap_convert_permissions(
 935         Props_pu        *p)
 936 {
 937         Calendar        *c = calendar;
 938         unsigned int     perm_val = 0;
 939
 940         /*
 941          * V5DEP: If this is a V5 server w/V1 backing store probably should use
 942          * old access flags.
 943          */
 944         if (p->cal->my_cal_version >= DATAVER4) {
 945                 if (XmToggleButtonGadgetGetState(p->gap2_public_tog[GAP_VIEW]))
 946                         perm_val |= CSA_VIEW_PUBLIC_ENTRIES;
 947                 if (XmToggleButtonGadgetGetState(
 948                                         p->gap2_public_tog[GAP_INSERT]))
 949                         perm_val |= CSA_INSERT_PUBLIC_ENTRIES;
 950                 if (XmToggleButtonGadgetGetState(
 951                                         p->gap2_public_tog[GAP_CHANGE]))
 952                         perm_val |= CSA_CHANGE_PUBLIC_ENTRIES;
 953                 if (XmToggleButtonGadgetGetState(
 954                                         p->gap2_semi_tog[GAP_VIEW]))
 955                         perm_val |= CSA_VIEW_CONFIDENTIAL_ENTRIES;
 956                 if (XmToggleButtonGadgetGetState(
 957                                         p->gap2_semi_tog[GAP_INSERT]))
 958                         perm_val |= CSA_INSERT_CONFIDENTIAL_ENTRIES;
 959                 if (XmToggleButtonGadgetGetState(
 960                                         p->gap2_semi_tog[GAP_CHANGE]))
 961                         perm_val |= CSA_CHANGE_CONFIDENTIAL_ENTRIES;
 962                 if (XmToggleButtonGadgetGetState(
 963                                         p->gap2_private_tog[GAP_VIEW]))
 964                         perm_val |= CSA_VIEW_PRIVATE_ENTRIES;
 965                 if (XmToggleButtonGadgetGetState(
 966                                         p->gap2_private_tog[GAP_INSERT]))
 967                         perm_val |= CSA_INSERT_PRIVATE_ENTRIES;
 968                 if (XmToggleButtonGadgetGetState(
 969                                         p->gap2_private_tog[GAP_CHANGE]))
 970                         perm_val |= CSA_CHANGE_PRIVATE_ENTRIES;
 971                 if (perm_val)
 972                         perm_val |= CSA_ORGANIZER_RIGHTS;
 973         } else {
 974                 if (XmToggleButtonGadgetGetState(p->gap_browse_toggle))
 975                         perm_val |= CSA_X_DT_BROWSE_ACCESS;
 976                 if (XmToggleButtonGadgetGetState(p->gap_insert_toggle))
 977                         perm_val |= CSA_X_DT_INSERT_ACCESS;
 978                 if (XmToggleButtonGadgetGetState(p->gap_delete_toggle))
 979                         perm_val |= CSA_X_DT_DELETE_ACCESS;
 980         }
 981
 982         if (perm_val == 0) {
 983                 char *title = XtNewString(catgets(c->DT_catd, 1, 750,
 984                               "Calendar : Error - Access List and Permissions"));
 985                 char *text = XtNewString(catgets(c->DT_catd, 1, 405,
 986                               "Please select at least one permission.        "));
 987                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95,
 988                                 "Continue"));
 989                 dialog_popup(p->frame,
 990                         DIALOG_TITLE, title,
 991                         DIALOG_TEXT, text,
 992                         BUTTON_IDENT, 1, ident1,
 993                         BUTTON_HELP, ACCESS_RIGHTS_ERROR_HELP,
 994                         DIALOG_IMAGE, p->xm_error_pixmap,
 995                         NULL);
 996                 XtFree(ident1);
 997                 XtFree(text);
 998                 XtFree(title);
 999         }
1000
1001         return perm_val;
1002 }
1003
1004 static char*
1005 p_gap_create_perm_str(CSA_flags perm_val) {
1006         int     i = 0;
1007         char    c_value[PERMISSION_LEN + 1];
1008
1009         if (perm_val & CSA_X_DT_BROWSE_ACCESS) {
1010                 c_value[i++] = 'B';
1011                 c_value[i++] = ' ';
1012         }
1013         if (perm_val & CSA_X_DT_INSERT_ACCESS) {
1014                 c_value[i++] = 'I';
1015                 c_value[i++] = ' ';
1016         }
1017         if (perm_val & CSA_X_DT_DELETE_ACCESS) {
1018                 c_value[i++] = 'D';
1019                 c_value[i++] = ' ';
1020         }
1021         c_value[i] = '\0';
1022         return cm_strdup(c_value);
1023 }
1024
1025 static void
1026 p_gap_create_entry_string(Props_pu *p, char *who, char *p_str, XmString *val) {
1027         char            *buf;
1028
1029         buf = (char *)ckalloc(NAME_LEN + PERMISSION_LEN + 1);
1030         sprintf(buf, "%-*s%s", NAME_LEN, who, p_str);
1031         *val = XmStringCreateLocalized(buf);
1032         free(buf);
1033 }
1034
1035 static void
1036 p_gap_add_proc(Widget w, XtPointer client_data, XtPointer callback_struct) {
1037         int             *item_list = NULL, item_cnt = 0;
1038         CSA_flags       pt;
1039         char            *who, *p_str;
1040         Props_pu        *p = (Props_pu *)client_data;
1041         XmString        xmstr;
1042         CSA_access_list step = p->gap_list, last = NULL, new_e;
1043
1044         /*
1045         **  First, get the necessary strings from the UI
1046         */
1047         if (!(pt = p_gap_convert_permissions(p)))
1048                 return;
1049         p_str = p_gap_create_perm_str(pt);
1050         who = (char *)XmTextGetString(p->gap_user_text);
1051         p_gap_create_entry_string(p, who, p_str, &xmstr);
1052         free(p_str);
1053
1054         /*
1055         **  Either add or change the item on the UI and to the Access_Entry
1056         **  linked list.
1057         */
1058         new_e = (CSA_access_list)ckalloc(sizeof(CSA_access_rights));
1059         new_e->user = (CSA_calendar_user *)ckalloc(sizeof(CSA_calendar_user));
1060         new_e->user->user_name = cm_strdup(who);
1061         new_e->rights = pt;
1062         new_e->next = NULL;
1063         XtFree(who);
1064
1065         if (XmListGetSelectedPos(p->gap_access_list, &item_list, &item_cnt)) {
1066                 /*
1067                 **  We're changing the value, find the item in the linked list
1068                 */
1069                 item_cnt = 1;
1070                 while(item_cnt < *item_list) {
1071                         last = step;
1072                         step = step->next;
1073                         ++item_cnt;
1074                 }
1075                 if (last)
1076                         last->next = new_e;
1077                 else
1078                         p->gap_list = new_e;
1079
1080                 new_e->next = step->next;
1081                 free(step->user);
1082                 free(step);
1083
1084                 XmListReplaceItemsPos(p->gap_access_list, &xmstr, 1, *item_list);
1085                 XtFree((XtPointer)item_list);
1086         } else {
1087                 /*
1088                 **  Add the Access_Entry item to the end of the list
1089                 */
1090                 if (!p->gap_list)
1091                         p->gap_list = new_e;
1092                 else {
1093                         while (step->next)
1094                                 step = step->next;
1095                         step->next = new_e;
1096                 }
1097                 XmListAddItem(p->gap_access_list, xmstr, 0);
1098         }
1099         XmStringFree(xmstr);
1100         p_set_change(p);
1101 }
1102
1103 extern void
1104 p_gap_remove_proc(Widget w, XtPointer client_data, XtPointer callback_struct) {
1105         Calendar *c = calendar;
1106         int             *item_list = NULL, item_cnt = 0;
1107         Props_pu        *p = (Props_pu *)client_data;
1108         CSA_access_list step = p->gap_list, last = NULL;
1109
1110         if (XmListGetSelectedPos(p->gap_access_list, &item_list, &item_cnt)) {
1111                 /*
1112                 **  Find and delete the Access_Entry from the list
1113                 */
1114                 item_cnt = 1;
1115                 while(item_cnt < *item_list) {
1116                         last = step;
1117                         step = step->next;
1118                         ++item_cnt;
1119                 }
1120                 if (last)
1121                         last->next = step->next;
1122                 else
1123                         p->gap_list = step->next;
1124
1125                 free(step->user);
1126                 free(step);
1127
1128                 XmListDeleteItemsPos(p->gap_access_list, 1, *item_list);
1129                 XmTextSetString(p->gap_user_text, "\0");
1130                 p_gap_clear_toggles(p);
1131                 p_set_change(p);
1132                 if (p->cal->my_cal_version >= DATAVER4) {
1133                         v5_gap_clear_pending_change(p);
1134                         XtSetSensitive(p->gap2_change_button, False);
1135                         XtSetSensitive(p->gap_remove_button, False);
1136                 }  else
1137                         v4_gap_clear_pending_change(p);
1138                 XtFree((XtPointer)item_list);
1139         }
1140         else {
1141                 char *title = XtNewString(catgets(c->DT_catd, 1, 750, "Calendar : Error - Access List and Permissions"));
1142                 char *text = XtNewString(catgets(c->DT_catd, 1, 408,  "Please select a name first.                   "));
1143                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
1144                 dialog_popup(p->frame,
1145                         DIALOG_TITLE, title,
1146                         DIALOG_TEXT, text,
1147                         BUTTON_IDENT, 1, ident1,
1148                         DIALOG_IMAGE, p->xm_error_pixmap,
1149                         NULL);
1150                 XtFree(ident1);
1151                 XtFree(text);
1152                 XtFree(title);
1153         }
1154 }
1155
1156 extern void
1157 gap_list_select_proc(Widget w, XtPointer client_data, XtPointer data) {
1158         int             *item_list = NULL, item_cnt = 0;
1159         Props_pu        *p = (Props_pu *)client_data;
1160         CSA_access_list step = p->gap_list;
1161
1162         if (!XmListGetSelectedPos(p->gap_access_list, &item_list, &item_cnt))
1163                 return;
1164
1165         if (item_cnt <= 0) {
1166                 if (p->cal->my_cal_version >= DATAVER4)
1167                         XtSetSensitive(p->gap2_change_button, False);
1168                 XtSetSensitive(p->gap_remove_button, False);
1169         } else {
1170                 if (p->cal->my_cal_version >= DATAVER4)
1171                         XtSetSensitive(p->gap2_change_button, True);
1172                 XtSetSensitive(p->gap_remove_button, True);
1173         }
1174
1175         item_cnt = 1;
1176         while(step && item_cnt < *item_list) {
1177                 step = step->next;
1178                 ++item_cnt;
1179         }
1180         XmTextSetString(p->gap_user_text, step->user->user_name);
1181
1182         /*
1183          * V5DEP: If this is a V5 server w/V1 backing store probably
1184          * should use old access flags.
1185          */
1186         if (p->cal->my_cal_version >= DATAVER4) {
1187                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_VIEW],
1188                         (step->rights & CSA_VIEW_PUBLIC_ENTRIES) ? True : False,
1189                         True);
1190                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_INSERT],
1191                         (step->rights & CSA_INSERT_PUBLIC_ENTRIES) ?
1192                                 True : False, True);
1193                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_CHANGE],
1194                         (step->rights & CSA_CHANGE_PUBLIC_ENTRIES) ?
1195                                 True : False, True);
1196                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_VIEW],
1197                         (step->rights & CSA_VIEW_CONFIDENTIAL_ENTRIES) ?
1198                                 True : False, True);
1199                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_INSERT],
1200                         (step->rights & CSA_INSERT_CONFIDENTIAL_ENTRIES) ?
1201                                 True : False, True);
1202                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_CHANGE],
1203                         (step->rights & CSA_CHANGE_CONFIDENTIAL_ENTRIES) ?
1204                                 True : False, True);
1205                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_VIEW],
1206                         (step->rights & CSA_VIEW_PRIVATE_ENTRIES) ?
1207                                 True : False, True);
1208                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_INSERT],
1209                         (step->rights & CSA_INSERT_PRIVATE_ENTRIES) ?
1210                                 True : False, True);
1211                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_CHANGE],
1212                         (step->rights & CSA_CHANGE_PRIVATE_ENTRIES) ?
1213                                 True : False, True);
1214         } else {
1215                 XmToggleButtonGadgetSetState(p->gap_browse_toggle,
1216                         (step->rights & CSA_X_DT_BROWSE_ACCESS) ? True : False,
1217                         True);
1218                 XmToggleButtonGadgetSetState(p->gap_insert_toggle,
1219                         (step->rights & CSA_X_DT_INSERT_ACCESS) ? True : False,
1220                         True);
1221                 XmToggleButtonGadgetSetState(p->gap_delete_toggle,
1222                         (step->rights & CSA_X_DT_DELETE_ACCESS) ? True : False,
1223                         True);
1224         }
1225
1226         XtFree((XtPointer)item_list);
1227 }
1228
1229
1230
1231 static void
1232 p_create_v4_group_access_pane(Props_pu *p) {
1233         Calendar *c = calendar;
1234         char    *buf;
1235         Widget  gap_form_mgr;
1236         XmString        xmstr;
1237         Dimension widest, highest, dmy;
1238         Widget prev, curr;
1239         Dimension _toEdge;
1240
1241         /*
1242         **  Base form
1243         */
1244         gap_form_mgr = XtVaCreateWidget("gap_form_mgr",
1245                 xmFormWidgetClass, p->base_form_mgr,
1246                 XmNautoUnmanage,        False,
1247                 XmNtopAttachment,       XmATTACH_WIDGET,
1248                 XmNtopWidget,           p->separator1,
1249                 XmNleftAttachment,      XmATTACH_FORM,
1250                 XmNrightAttachment,     XmATTACH_FORM,
1251                 XmNbottomAttachment,    XmATTACH_WIDGET,
1252                 XmNbottomOffset,        10,
1253                 XmNbottomWidget,        p->separator2,
1254                 NULL);
1255         p->pane_list[GROUP_ACCESS_PANE] = gap_form_mgr;
1256
1257         /*
1258         **  User Name label, text field, and add button
1259         */
1260         xmstr = XmStringCreateLocalized(
1261                         catgets(c->DT_catd, 1, 410, "User Name:"));
1262         p->gap_user_label = XtVaCreateWidget("userName",
1263                 xmLabelGadgetClass, gap_form_mgr,
1264                 XmNlabelString,         xmstr,
1265                 NULL);
1266         XmStringFree(xmstr);
1267
1268         p->gap_user_text = XtVaCreateWidget("gap_user_text",
1269                 xmTextWidgetClass, gap_form_mgr,
1270                 NULL);
1271
1272         XtAddCallback(p->gap_user_text,
1273                         XmNvalueChangedCallback, v4_gap_pending_change,
1274                         (XtPointer)p);
1275
1276         xmstr = XmStringCreateLocalized(
1277                                 catgets(c->DT_catd, 1, 411, "Add Name"));
1278         p->gap_add_button = XtVaCreateWidget("addName",
1279                 xmPushButtonGadgetClass, gap_form_mgr,
1280                 XmNlabelString,         xmstr,
1281                 XmNnavigationType,      XmTAB_GROUP,
1282                 XmNsensitive,           False,
1283                 NULL);
1284         XmStringFree(xmstr);
1285         XtAddCallback(p->gap_add_button,
1286                         XmNactivateCallback, p_gap_add_proc, p);
1287
1288         /*
1289         **  Access list stuff and remove button
1290         */
1291         {
1292           char *user = XtNewString(catgets(c->DT_catd, 1, 983, "User Name"));
1293           char *perm = XtNewString(catgets(c->DT_catd, 1, 413, "Permissions"));
1294           buf = (char *)ckalloc(cm_strlen(user) + cm_strlen(perm) + 10);
1295           sprintf(buf, "%-*s%s", NAME_LEN, user, perm);
1296           xmstr = XmStringCreateLocalized(buf);
1297           XtFree(perm);
1298           XtFree(user);
1299         }
1300
1301         p->gap_access_header = XtVaCreateManagedWidget("gap_access_header",
1302                 xmLabelGadgetClass, gap_form_mgr,
1303                 XmNlabelString,         xmstr,
1304                 NULL);
1305         XmStringFree(xmstr);
1306         free(buf);
1307
1308         p->gap_list = NULL;
1309         p->gap_access_list = (Widget)XmCreateScrolledList(gap_form_mgr,
1310                 "gap_access_list", NULL, 0);
1311         p->gap_access_list_sw = XtParent(p->gap_access_list);
1312         XtVaSetValues(p->gap_access_list_sw,
1313                 NULL);
1314         XtVaSetValues(p->gap_access_list,
1315                 XmNvisibleItemCount,    10,
1316                 XmNdoubleClickInterval, 5,
1317                 NULL);
1318         XtAddCallback(p->gap_access_list,
1319                 XmNbrowseSelectionCallback, gap_list_select_proc, p);
1320         XtManageChild(p->gap_access_list);
1321
1322         xmstr = XmStringCreateLocalized(
1323                         catgets(c->DT_catd, 1, 414, "Remove Name"));
1324         p->gap_remove_button = XtVaCreateWidget("removeName",
1325                 xmPushButtonGadgetClass, gap_form_mgr,
1326                 XmNlabelString,         xmstr,
1327                 XmNnavigationType,      XmTAB_GROUP,
1328                 XmNsensitive,           False,
1329                 NULL);
1330         XmStringFree(xmstr);
1331         XtAddCallback(p->gap_remove_button,
1332                 XmNactivateCallback, p_gap_remove_proc, p);
1333
1334         xmstr = XmStringCreateLocalized(
1335                catgets(c->DT_catd, 1, 415, "B = Browse I = Insert D = Delete"));
1336         p->gap_access_msg = XtVaCreateWidget("browseInsertDelete",
1337                 xmLabelGadgetClass, gap_form_mgr,
1338                 XmNlabelString,         xmstr,
1339                 NULL);
1340         XmStringFree(xmstr);
1341
1342         /*
1343         **  Finally, permissions label and choice toggle list
1344         */
1345         xmstr = XmStringCreateLocalized(
1346                                 catgets(c->DT_catd, 1, 416, "Permissions:"));
1347         p->gap_perm_label = XtVaCreateWidget("permissions",
1348                 xmLabelGadgetClass, gap_form_mgr,
1349                 XmNlabelString,         xmstr,
1350                 NULL);
1351         XmStringFree(xmstr);
1352
1353         p->gap_perm_rc_mgr = XtVaCreateWidget("gap_perm_rc_mgr",
1354                 xmRowColumnWidgetClass, gap_form_mgr,
1355                 XmNpacking,             XmPACK_COLUMN,
1356                 XmNorientation,         XmHORIZONTAL,
1357                 XmNradioBehavior,       False,
1358                 XmNisHomogeneous,       True,
1359                 XmNindicatorType,       XmN_OF_MANY,
1360                 XmNentryClass,          xmToggleButtonGadgetClass,
1361                 NULL);
1362
1363         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 417, "Browse"));
1364         p->gap_browse_toggle = XtVaCreateWidget("browse",
1365                 xmToggleButtonGadgetClass, p->gap_perm_rc_mgr,
1366                 XmNlabelString,         xmstr,
1367                 NULL);
1368         XmStringFree(xmstr);
1369
1370         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 342, "Insert"));
1371         p->gap_insert_toggle = XtVaCreateWidget("insert",
1372                 xmToggleButtonGadgetClass, p->gap_perm_rc_mgr,
1373                 XmNlabelString,         xmstr,
1374                 NULL);
1375         XmStringFree(xmstr);
1376
1377         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 419, "Delete"));
1378         p->gap_delete_toggle = XtVaCreateWidget("delete",
1379                 xmToggleButtonGadgetClass, p->gap_perm_rc_mgr,
1380                 XmNlabelString,         xmstr,
1381                 NULL);
1382         XmStringFree(xmstr);
1383
1384         /*
1385          * Do a layout
1386          */
1387
1388         /*
1389          * p->gap_user_label, p->gap_user_text, p->gap_add_button
1390          */
1391         _i18n_HighestWidgetAdjust( 3, &curr, &highest, p->gap_user_label,
1392                                         p->gap_user_text, p->gap_add_button );
1393         XtVaSetValues( curr,
1394                         XmNtopAttachment, XmATTACH_FORM,
1395                         XmNtopOffset, 12,
1396                         NULL );
1397         prev = curr;
1398         XtVaSetValues( p->gap_user_label,
1399                         XmNleftAttachment, XmATTACH_FORM,
1400                         XmNleftOffset, 5,
1401                         NULL );
1402         _i18n_WidestWidget( 1, &curr, &widest, p->gap_user_label );
1403         XtVaSetValues( p->gap_user_text,
1404                         XmNleftAttachment, XmATTACH_FORM,
1405                         XmNleftOffset, 5 + widest + 10,
1406                         NULL );
1407         _i18n_WidestWidget( 1, &curr, &dmy, p->gap_user_text );
1408         _toEdge = 5 + widest + 10 + dmy;
1409         XtVaSetValues( p->gap_add_button,
1410                         XmNleftAttachment, XmATTACH_FORM,
1411                         XmNleftOffset, _toEdge + 10,
1412                         NULL );
1413
1414         /*
1415          * p->gap_access_header
1416          */
1417         XtVaSetValues( p->gap_access_header,
1418                         XmNleftAttachment, XmATTACH_FORM,
1419                         XmNleftOffset, 5,
1420                         XmNtopAttachment, XmATTACH_WIDGET,
1421                         XmNtopWidget, prev,
1422                         XmNtopOffset, 10,
1423                         NULL );
1424         prev = p->gap_access_header;
1425
1426         /*
1427          * p->gap_access_list_sw, p->gap_remove_button
1428          */
1429         _i18n_HighestWidget( 2, &curr, &highest, p->gap_access_list_sw,
1430                                 p->gap_remove_button );
1431         XtVaSetValues( p->gap_access_list_sw,
1432                         XmNleftAttachment, XmATTACH_FORM,
1433                         XmNleftOffset, 5,
1434                         XmNrightAttachment, XmATTACH_OPPOSITE_FORM,
1435                         XmNrightOffset, -1 * _toEdge,
1436                         XmNtopAttachment, XmATTACH_WIDGET,
1437                         XmNtopWidget, prev,
1438                         XmNtopOffset, 5,
1439                         NULL ),
1440         XtVaSetValues( p->gap_remove_button,
1441                         XmNleftAttachment, XmATTACH_FORM,
1442                         XmNleftOffset, _toEdge + 10,
1443                         XmNtopAttachment, XmATTACH_WIDGET,
1444                         XmNtopWidget, prev,
1445                         XmNtopOffset, 5,
1446                         NULL ),
1447         prev = curr;
1448
1449         /*
1450          * p->gap_access_msg
1451          */
1452         XtVaSetValues( p->gap_access_msg,
1453                         XmNleftAttachment, XmATTACH_FORM,
1454                         XmNleftOffset, 5,
1455                         XmNtopAttachment, XmATTACH_WIDGET,
1456                         XmNtopWidget, prev,
1457                         XmNtopOffset, 5,
1458                         NULL );
1459         prev = p->gap_access_msg;
1460
1461         /*
1462          * p->gap_perm_label, p->gap_perm_rc_mgr
1463          */
1464         _i18n_HighestWidgetAdjust( 2, &curr, &highest, p->gap_perm_label,
1465                                         p->gap_perm_rc_mgr );
1466         XtVaSetValues( curr,
1467                         XmNtopAttachment, XmATTACH_WIDGET,
1468                         XmNtopWidget, prev,
1469                         XmNtopOffset, 12,
1470                         NULL );
1471         prev = curr;
1472         XtVaSetValues( p->gap_perm_label,
1473                         XmNleftAttachment, XmATTACH_FORM,
1474                         XmNleftOffset, 5,
1475                         NULL );
1476         _i18n_WidestWidget( 1, &curr, &widest, p->gap_perm_label );
1477         XtVaSetValues( p->gap_perm_rc_mgr,
1478                         XmNleftAttachment, XmATTACH_FORM,
1479                         XmNleftOffset, 5 + widest + 5,
1480                         NULL );
1481
1482         ManageChildren(p->gap_perm_rc_mgr);
1483         ManageChildren(gap_form_mgr);
1484 }
1485
1486 /*
1487 **  Functions related to the printer ops pane
1488 */
1489
1490 static char *hdrDefaults[] =
1491 {
1492   "Date",
1493   "User Id",
1494   "Page Number",
1495   "Report Type",
1496   "None"
1497 };
1498 static char *hdrStrings[POP_HDR_NUM_CHOICES];
1499
1500 static void
1501 p_create_printer_ops_pane(
1502         Props_pu        *p)
1503  {
1504         Calendar        *c = calendar;
1505         Widget           pop_form_mgr;
1506         XmString         xmstr;
1507         int              i;
1508         Widget           optionPane;
1509
1510         /*
1511         **  Base form
1512         */
1513         pop_form_mgr = XtVaCreateWidget("pop_form_mgr",
1514                 xmFormWidgetClass, p->base_form_mgr,
1515                 XmNautoUnmanage,        False,
1516                 XmNtopAttachment,       XmATTACH_WIDGET,
1517                 XmNtopWidget,           p->separator1,
1518                 XmNtopOffset,           GAP,
1519                 XmNleftAttachment,      XmATTACH_FORM,
1520                 XmNleftOffset,          GAP,
1521                 XmNrightAttachment,     XmATTACH_FORM,
1522                 XmNrightOffset,         GAP,
1523                 XmNbottomAttachment,    XmATTACH_WIDGET,
1524                 XmNbottomWidget,        p->separator2,
1525                 XmNbottomOffset,        GAP,
1526                 NULL);
1527         p->pane_list[PRINTER_OPS_PANE] = pop_form_mgr;
1528
1529         p->pop_margin_frame = _DtPrintCreateMarginFrame(pop_form_mgr);
1530         XtVaSetValues(p->pop_margin_frame,
1531                       XmNtopAttachment, XmATTACH_FORM,
1532                       XmNtopOffset, 0,
1533                       XmNleftAttachment, XmATTACH_FORM,
1534                       XmNleftOffset, 0,
1535                       XmNrightAttachment, XmATTACH_FORM,
1536                       XmNrightOffset, 0,
1537                       NULL);
1538         p->pop_left_text =
1539           _DtPrintMarginFrameEnumToWidget(p->pop_margin_frame,
1540                                           DTPRINT_OPTION_MARGIN_LEFT);
1541         XtAddCallback(p->pop_left_text, XmNvalueChangedCallback,
1542                       p_mark_change, (XtPointer)p);
1543         p->pop_top_text =
1544           _DtPrintMarginFrameEnumToWidget(p->pop_margin_frame,
1545                                           DTPRINT_OPTION_MARGIN_TOP);
1546         XtAddCallback(p->pop_top_text, XmNvalueChangedCallback,
1547                       p_mark_change, (XtPointer)p);
1548         p->pop_right_text =
1549           _DtPrintMarginFrameEnumToWidget(p->pop_margin_frame,
1550                                           DTPRINT_OPTION_MARGIN_RIGHT);
1551         XtAddCallback(p->pop_right_text, XmNvalueChangedCallback,
1552                       p_mark_change, (XtPointer)p);
1553         p->pop_bottom_text =
1554           _DtPrintMarginFrameEnumToWidget(p->pop_margin_frame,
1555                                           DTPRINT_OPTION_MARGIN_BOTTOM);
1556         XtAddCallback(p->pop_bottom_text, XmNvalueChangedCallback,
1557                       p_mark_change, (XtPointer)p);
1558
1559         for (i = 0; i < POP_HDR_NUM_CHOICES; i++)
1560           hdrStrings[i] = XtNewString(catgets(c->DT_catd, 1, 1106 + i,
1561                                               hdrDefaults[i]));
1562
1563         p->pop_header_frame =
1564           _DtPrintCreateHdrFtrFrame(pop_form_mgr, POP_HDR_NUM_CHOICES,
1565                                     hdrStrings, (void **)NULL);
1566         XtVaSetValues(p->pop_header_frame,
1567                       XmNtopAttachment, XmATTACH_WIDGET,
1568                       XmNtopWidget, p->pop_margin_frame,
1569                       XmNtopOffset, GAP,
1570                       XmNleftAttachment, XmATTACH_FORM,
1571                       XmNleftOffset, 0,
1572                       XmNrightAttachment, XmATTACH_FORM,
1573                       XmNrightOffset, 0,
1574                       NULL);
1575         _DtPrintHdrFtrFrameMenuWidgets(p->pop_header_frame,
1576                                        &optionPane,
1577                                        (int *)NULL,
1578                                        (Widget **)NULL);
1579         XtAddCallback(optionPane, XmNentryCallback,
1580                       p_mark_change, (XtPointer)p);
1581
1582         p->pop_tl_option =
1583           _DtPrintHdrFtrFrameEnumToWidget(p->pop_header_frame,
1584                                           DTPRINT_OPTION_HEADER_LEFT);
1585
1586         p->pop_tr_option =
1587           _DtPrintHdrFtrFrameEnumToWidget(p->pop_header_frame,
1588                                           DTPRINT_OPTION_HEADER_RIGHT);
1589
1590         p->pop_bl_option =
1591           _DtPrintHdrFtrFrameEnumToWidget(p->pop_header_frame,
1592                                           DTPRINT_OPTION_FOOTER_LEFT);
1593
1594         p->pop_br_option =
1595           _DtPrintHdrFtrFrameEnumToWidget(p->pop_header_frame,
1596                                           DTPRINT_OPTION_FOOTER_RIGHT);
1597
1598         xmstr = XmStringCreateLocalized(
1599                                 catgets(c->DT_catd, 1, 434, "Include:"));
1600         p->pop_privacy_label = XtVaCreateWidget("include",
1601                 xmLabelGadgetClass, pop_form_mgr,
1602                 XmNlabelString, xmstr,
1603                 XmNtopAttachment, XmATTACH_WIDGET,
1604                 XmNtopOffset, GAP,
1605                 XmNtopWidget, p->pop_header_frame,
1606                 XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1607                 XmNleftOffset, 0,
1608                 XmNleftWidget, p->pop_margin_frame,
1609                 NULL);
1610         XmStringFree(xmstr);
1611
1612         /*
1613         **  Include label and toggle choice
1614         */
1615         p->pop_privacy_rc_mgr = XtVaCreateWidget("pop_privacy_rc_mgr",
1616                 xmRowColumnWidgetClass, pop_form_mgr,
1617                 XmNpacking,             XmPACK_COLUMN,
1618                 XmNorientation,         XmVERTICAL,
1619                 XmNradioBehavior,       False,
1620                 XmNisHomogeneous,       True,
1621                 XmNindicatorType,       XmN_OF_MANY,
1622                 XmNentryClass,          xmToggleButtonGadgetClass,
1623                 XmNmarginHeight,        0,
1624                 XmNmarginWidth,         0,
1625                 XmNtopAttachment,       XmATTACH_OPPOSITE_WIDGET,
1626                 XmNtopOffset,           0,
1627                 XmNtopWidget,           p->pop_privacy_label,
1628                 XmNleftAttachment,      XmATTACH_WIDGET,
1629                 XmNleftOffset,          GAP,
1630                 XmNleftWidget,          p->pop_privacy_label,
1631                 NULL);
1632
1633         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 435,
1634                                                 "Show Time and Text Appts"));
1635         p->pop_privacy_public_toggle = XtVaCreateWidget(
1636                 "showTimeText",
1637                 xmToggleButtonGadgetClass, p->pop_privacy_rc_mgr,
1638                 XmNlabelString,         xmstr,
1639                 NULL);
1640         XmStringFree(xmstr);
1641
1642         XtAddCallback(p->pop_privacy_public_toggle,
1643                       XmNvalueChangedCallback, p_mark_change, p);
1644
1645         xmstr = XmStringCreateLocalized( catgets(c->DT_catd, 1, 436,
1646                                                 "Show Time Only Appts"));
1647         p->pop_privacy_semi_toggle = XtVaCreateWidget(
1648                 "showTimeOnly",
1649                 xmToggleButtonGadgetClass, p->pop_privacy_rc_mgr,
1650                 XmNlabelString,         xmstr,
1651                 NULL);
1652         XmStringFree(xmstr);
1653
1654         XtAddCallback(p->pop_privacy_semi_toggle,
1655                       XmNvalueChangedCallback, p_mark_change, p);
1656
1657         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 437,
1658                                                 "Show Nothing Appts"));
1659         p->pop_privacy_private_toggle = XtVaCreateWidget(
1660                 "showNothing",
1661                 xmToggleButtonGadgetClass, p->pop_privacy_rc_mgr,
1662                 XmNlabelString,         xmstr,
1663                 NULL);
1664         XmStringFree(xmstr);
1665
1666         XtAddCallback(p->pop_privacy_private_toggle,
1667                       XmNvalueChangedCallback, p_mark_change, p);
1668
1669         ManageChildren(p->pop_privacy_rc_mgr);
1670         ManageChildren (pop_form_mgr);
1671 }
1672
1673 /*
1674 **  Functions related to the date format pane
1675 */
1676 static void
1677 p_create_date_format_pane(
1678         Props_pu        *p)
1679 {
1680         Calendar        *c = calendar;
1681         Widget           dfp_form_mgr;
1682         XmString         xmstr;
1683         Dimension        max_left_label_width;
1684
1685         /*
1686         **  Base form
1687         */
1688         dfp_form_mgr = XtVaCreateWidget("dfp_form_mgr",
1689                 xmFormWidgetClass, p->base_form_mgr,
1690                 XmNautoUnmanage,        False,
1691                 XmNtopAttachment,       XmATTACH_WIDGET,
1692                 XmNtopWidget,           p->separator1,
1693                 XmNleftAttachment,      XmATTACH_FORM,
1694                 XmNrightAttachment,     XmATTACH_FORM,
1695                 XmNbottomAttachment,    XmATTACH_WIDGET,
1696                 XmNbottomOffset,        10,
1697                 XmNbottomWidget,        p->separator2,
1698                 NULL);
1699         p->pane_list[DATE_FORMAT_PANE] = dfp_form_mgr;
1700
1701         /*
1702         **  Date ordering label and choice toggle widget
1703         */
1704         xmstr = XmStringCreateLocalized(
1705                                 catgets(c->DT_catd, 1, 438, "Date Ordering:"));
1706         p->dfp_order_label = XtVaCreateWidget("dateOrdering",
1707                 xmLabelGadgetClass, dfp_form_mgr,
1708                 XmNlabelString,         xmstr,
1709                 NULL);
1710         XmStringFree(xmstr);
1711
1712         xmstr = XmStringCreateLocalized(
1713                                 catgets(c->DT_catd, 1, 442, "Date Separator:"));
1714         p->dfp_sep_label = XtVaCreateWidget("dateSeparator",
1715                 xmLabelGadgetClass, dfp_form_mgr,
1716                 XmNlabelString,         xmstr,
1717                 NULL);
1718         XmStringFree(xmstr);
1719
1720         max_left_label_width = ComputeMaxWidth(p->dfp_order_label,
1721                                                p->dfp_sep_label,
1722                                                NULL, NULL) + 2 * GAP;
1723
1724         p->dfp_order_rc_mgr = XtVaCreateWidget("dfp_order_rc_mgr",
1725                 xmRowColumnWidgetClass, dfp_form_mgr,
1726                 XmNpacking,             XmPACK_COLUMN,
1727                 XmNorientation,         XmVERTICAL,
1728                 XmNradioBehavior,       True,
1729                 XmNisHomogeneous,       True,
1730                 XmNentryClass,          xmToggleButtonGadgetClass,
1731                 XmNleftAttachment,      XmATTACH_FORM,
1732                 XmNleftOffset,          max_left_label_width,
1733                 XmNtopAttachment,       XmATTACH_FORM,
1734                 XmNtopOffset,           GAP,
1735                 NULL);
1736
1737         xmstr = XmStringCreateLocalized(
1738                                 catgets(c->DT_catd, 1, 439, "MM | DD | YY"));
1739         p->dfp_order_mmddyy_toggle = XtVaCreateWidget("mmddyy",
1740                 xmToggleButtonGadgetClass, p->dfp_order_rc_mgr,
1741                 XmNlabelString, xmstr,
1742                 NULL);
1743         XmStringFree(xmstr);
1744
1745         XtAddCallback(p->dfp_order_mmddyy_toggle,
1746                                 XmNvalueChangedCallback, p_mark_change, p);
1747
1748         xmstr = XmStringCreateLocalized(
1749                                 catgets(c->DT_catd, 1, 440, "DD | MM | YY"));
1750         p->dfp_order_ddmmyy_toggle = XtVaCreateWidget("ddmmyy",
1751                 xmToggleButtonGadgetClass, p->dfp_order_rc_mgr,
1752                 XmNlabelString, xmstr,
1753                 NULL);
1754         XmStringFree(xmstr);
1755
1756         XtAddCallback(p->dfp_order_ddmmyy_toggle,
1757                                 XmNvalueChangedCallback, p_mark_change, p);
1758
1759         xmstr = XmStringCreateLocalized(
1760                                 catgets(c->DT_catd, 1, 441, "YY | MM | DD"));
1761         p->dfp_order_yymmdd_toggle = XtVaCreateWidget("yymmdd",
1762                 xmToggleButtonGadgetClass, p->dfp_order_rc_mgr,
1763                 XmNlabelString, xmstr,
1764                 NULL);
1765         XmStringFree(xmstr);
1766
1767         XtAddCallback(p->dfp_order_yymmdd_toggle,
1768                                 XmNvalueChangedCallback, p_mark_change, p);
1769
1770         ManageChildren(p->dfp_order_rc_mgr);
1771
1772         /*
1773         **  Date separator label and choice toggle widget
1774         */
1775         p->dfp_sep_rc_mgr = XtVaCreateWidget("dfp_sep_rc_mgr",
1776                 xmRowColumnWidgetClass, dfp_form_mgr,
1777                 XmNpacking,             XmPACK_COLUMN,
1778                 XmNorientation,         XmVERTICAL,
1779                 XmNradioBehavior,       True,
1780                 XmNisHomogeneous,       True,
1781                 XmNentryClass,          xmToggleButtonGadgetClass,
1782                 XmNleftAttachment,      XmATTACH_FORM,
1783                 XmNleftOffset,          max_left_label_width,
1784                 XmNtopAttachment,       XmATTACH_WIDGET,
1785                 XmNtopWidget,           p->dfp_order_rc_mgr,
1786                 XmNtopOffset,           GAP,
1787                 NULL);
1788
1789         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 443, "Blank"));
1790         p->dfp_sep_blank_toggle = XtVaCreateWidget("blank",
1791                 xmToggleButtonGadgetClass, p->dfp_sep_rc_mgr,
1792                 XmNlabelString, xmstr,
1793                 NULL);
1794         XmStringFree(xmstr);
1795
1796         XtAddCallback(p->dfp_sep_blank_toggle,
1797                                 XmNvalueChangedCallback, p_mark_change, p);
1798
1799         xmstr = XmStringCreateLocalized("/");
1800         p->dfp_sep_slash_toggle = XtVaCreateWidget("oblique",
1801                 xmToggleButtonGadgetClass, p->dfp_sep_rc_mgr,
1802                 XmNlabelString, xmstr,
1803                 NULL);
1804         XmStringFree(xmstr);
1805
1806         XtAddCallback(p->dfp_sep_slash_toggle,
1807                                 XmNvalueChangedCallback, p_mark_change, p);
1808
1809         xmstr = XmStringCreateLocalized(".");
1810         p->dfp_sep_period_toggle = XtVaCreateWidget("period",
1811                 xmToggleButtonGadgetClass, p->dfp_sep_rc_mgr,
1812                 XmNlabelString, xmstr,
1813                 NULL);
1814         XmStringFree(xmstr);
1815
1816         XtAddCallback(p->dfp_sep_period_toggle,
1817                                 XmNvalueChangedCallback, p_mark_change, p);
1818
1819         xmstr = XmStringCreateLocalized("-");
1820         p->dfp_sep_dash_toggle = XtVaCreateWidget("hyphen",
1821                 xmToggleButtonGadgetClass, p->dfp_sep_rc_mgr,
1822                 XmNlabelString, xmstr,
1823                 NULL);
1824         XmStringFree(xmstr);
1825
1826         XtAddCallback(p->dfp_sep_dash_toggle,
1827                                 XmNvalueChangedCallback, p_mark_change, p);
1828
1829         XtVaSetValues(p->dfp_order_label,
1830                 XmNtopAttachment,       XmATTACH_OPPOSITE_WIDGET,
1831                 XmNtopWidget,           p->dfp_order_rc_mgr,
1832                 XmNtopOffset,           GAP,
1833                 XmNrightAttachment,     XmATTACH_WIDGET,
1834                 XmNrightWidget,         p->dfp_order_rc_mgr,
1835                 XmNrightOffset,         GAP,
1836                 NULL);
1837
1838         XtVaSetValues(p->dfp_sep_label,
1839                 XmNtopAttachment,       XmATTACH_OPPOSITE_WIDGET,
1840                 XmNtopWidget,           p->dfp_sep_rc_mgr,
1841                 XmNtopOffset,           GAP,
1842                 XmNrightAttachment,     XmATTACH_WIDGET,
1843                 XmNrightWidget,         p->dfp_sep_rc_mgr,
1844                 XmNrightOffset,         GAP,
1845                 NULL);
1846
1847         ManageChildren(p->dfp_sep_rc_mgr);
1848         ManageChildren(dfp_form_mgr);
1849 }
1850
1851 /*
1852 **  Callback from the category option menu
1853 */
1854 static void
1855 p_category_notify(Widget w, XtPointer client_data, XtPointer call_data)
1856 {
1857   Widget        base_form_mgr = XtParent(XtParent(XtParent(w)));
1858   PaneType      item_no = (PaneType)client_data;
1859   Props_pu      *p = (Props_pu *)NULL;
1860
1861   /*
1862    **  Note this cheesy hack.  The convenience functions allow you NO
1863    **  method which which to attach user data to the buttons on menus ...
1864    **  so the user data on the base form was set to contain a pointer to
1865    **  the Props_pu structure and we go up through the heirarchical levels
1866    **  using the widget parameter to retrieve this pointer.
1867    **
1868    **  This sucks, but Motif sucks worse and I could find no other method.
1869    */
1870   XtVaGetValues(base_form_mgr, XmNuserData, &p,
1871                 NULL);
1872   if (p)
1873     show_ui(p, item_no);
1874 }
1875
1876 static void
1877 activate_ui(Props_pu *p, PaneType item_no)
1878 {
1879   Arg args[10];
1880   int nargs;
1881   Widget optMenu = (Widget)NULL;
1882   WidgetList children;
1883   int nChildren;
1884
1885   nargs = 0;
1886   XtSetArg(args[nargs], XmNsubMenuId, &optMenu); nargs++;
1887   XtGetValues(p->category_menu, args, nargs);
1888
1889   if (optMenu != (Widget)NULL)
1890   {
1891     nargs = 0;
1892     XtSetArg(args[nargs], XmNchildren, &children); nargs++;
1893     XtSetArg(args[nargs], XmNnumChildren, &nChildren); nargs++;
1894     XtGetValues(optMenu, args, nargs);
1895
1896     if (item_no < nChildren)
1897     {
1898       nargs = 0;
1899       XtSetArg(args[nargs], XmNmenuHistory, children[item_no]); nargs++;
1900       XtSetValues(p->category_menu, args, nargs);
1901
1902       show_ui(p, item_no);
1903     }
1904   }
1905 }
1906
1907 static void
1908 show_ui(Props_pu *p, PaneType item_no)
1909 {
1910         Calendar        *c;
1911         Dimension       label_height, slider_height;
1912
1913         /* determine if there are uncommited changes in the property
1914            sheet that need to be flushed. */
1915
1916         c = p->cal;
1917         if (p_flush_changes(c) == False)
1918         {
1919           Widget optMenu = (Widget)NULL;
1920           WidgetList children;
1921           int nChildren;
1922
1923           XtVaGetValues(p->category_menu, XmNsubMenuId, &optMenu, NULL);
1924           XtVaGetValues(optMenu, XmNchildren, &children,
1925                         XmNnumChildren, &nChildren, NULL);
1926           if (p->last_props_pane < nChildren)
1927             XtVaSetValues(p->category_menu, XmNmenuHistory,
1928                           children[p->last_props_pane], NULL);
1929           return;
1930         }
1931
1932         /*
1933         **  Performance optimization - don't create each panel until it's
1934         **  asked for (except for the editor pane which is the first one ...).
1935         **
1936         **  Motif, however, is not liking this optimization (bug in toolkit? I
1937         **  would guess yes ...).  It's not resizing the pop-up correctly and
1938         **  it's leaving a number of fields blank ... it doesn't do this if the
1939         **  panes are all created before the window is poped up ... so all the
1940         **  panes are created before and this "if" statement will never evaluate
1941         **  to true.  When (or if) this is fixed in the toolkit, remove the
1942         **  create statements from the p_make_props_pu function.
1943         */
1944         if (!p->pane_list[item_no]) {
1945                 switch(item_no) {
1946                 case DISPLAY_PANE:
1947                         p_create_display_pane(p);
1948                         break;
1949                 case GROUP_ACCESS_PANE:
1950                         if (p->cal->my_cal_version < DATAVER4)
1951                                 p_create_v4_group_access_pane(p);
1952                         else
1953                                 p_create_v5_group_access_pane(p);
1954                         break;
1955                 case PRINTER_OPS_PANE:
1956                         p_create_printer_ops_pane(p);
1957                         break;
1958                 case DATE_FORMAT_PANE:
1959                         p_create_date_format_pane(p);
1960                         break;
1961                 case EDITOR_PANE:
1962                 default:
1963                         break;
1964                 }
1965         }
1966         if (!p->pane_list[item_no])
1967                 return;
1968
1969         XtUnmanageChild(p->pane_list[p->last_props_pane]);
1970         XtVaSetValues(p->separator2,
1971                 XmNtopWidget, p->pane_list[item_no],
1972                 NULL);
1973         XtManageChild(p->pane_list[item_no]);
1974         p->last_props_pane = item_no;
1975
1976
1977         /* code for display settings */
1978
1979         XtVaGetValues(p->dp_beg_label, XmNheight, &label_height, NULL);
1980         XtVaGetValues(p->dp_beg_scale, XmNheight, &slider_height, NULL);
1981         XtVaSetValues(p->dp_beg_scale, XmNbottomOffset, ((int) label_height - (int) slider_height)/2, NULL);
1982         XtVaSetValues(p->dp_end_scale, XmNbottomOffset, ((int) label_height - (int) slider_height)/2, NULL);
1983
1984
1985         /* Center Category menu */
1986         p_gap_center_cat_menu(p->pane_list[p->last_props_pane],
1987                               p->category_menu);
1988 }
1989
1990 extern void
1991 set_editor_defaults_later(XtPointer client_data, XtIntervalId *interval_id) {
1992         Calendar        *c = (Calendar *)client_data;
1993         Props_pu        *pu = (Props_pu *)c->properties_pu;
1994
1995         _DtTurnOnHourGlass(c->frame);
1996         _DtTurnOnHourGlass(pu->frame);
1997
1998         if (((Editor *) c->editor)->base_form_mgr) {
1999                 Editor *e = (Editor *) c->editor;
2000
2001                 set_editor_defaults(e, 0, 0, False);
2002         }
2003
2004         if (((GEditor *) c->geditor)->base_form_mgr) {
2005                 GEditor *ge = (GEditor *) c->geditor;
2006
2007                 set_geditor_defaults(ge, 0, 0);
2008         }
2009
2010         if (((ToDo *) c->todo)->base_form_mgr) {
2011                 ToDo *t = (ToDo *)c->todo;
2012
2013                 set_todo_defaults(t);
2014         }
2015
2016         _DtTurnOffHourGlass(c->frame);
2017         _DtTurnOffHourGlass(pu->frame);
2018 }
2019
2020 static Boolean
2021 p_save_changes(Calendar *c) {
2022
2023         Props           *p = (Props *)c->properties;
2024         Props_pu        *pu = (Props_pu *)c->properties_pu;
2025         int             redisplay_mask;
2026         int             val;
2027         Tick            current_mb_date = 0;
2028         char            *date = NULL;
2029         OrderingType    ot;
2030         SeparatorType   st;
2031         Browser         *b = (Browser*)c->browser;
2032         char            buf[BUFSIZ];
2033
2034         if (b) {
2035                 ot = get_int_prop(p, CP_DATEORDERING);
2036                 st = get_int_prop(p, CP_DATESEPARATOR);
2037
2038                 date = get_date_from_widget(c->view->date, b->datetext, ot, st);
2039
2040                 if (date)
2041                         current_mb_date = cm_getdate(date, NULL);
2042         }
2043
2044         if (get_props_from_ui(pu, p, &redisplay_mask) == True) {
2045                 return(False);
2046         }
2047
2048         if (!save_props(p)) {
2049                 char *title = XtNewString(catgets(c->DT_catd, 1, 454, "Calendar : Error - Options"));
2050                 char *text = XtNewString(catgets(c->DT_catd, 1, 445, "An error occurred writing to ~/.desksetdefaults.\nMake sure you have permission to write to this file."));
2051                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2052                 dialog_popup(pu->frame,
2053                         DIALOG_TITLE, title,
2054                         DIALOG_TEXT, text,
2055                         BUTTON_IDENT, 1, ident1,
2056                         BUTTON_HELP, DESKSET_DEFAULTS_ERROR_HELP,
2057                         DIALOG_IMAGE, pu->xm_error_pixmap,
2058                         NULL);
2059                 XtFree(ident1);
2060                 XtFree(text);
2061                 XtFree(title);
2062                 return(False);
2063         }
2064
2065         _DtTurnOnHourGlass(c->frame);
2066         _DtTurnOnHourGlass(pu->frame);
2067
2068         if (redisplay_mask & PROPS_REDO_DISPLAY) {
2069                 Dimension width, height;
2070
2071                 /* If this bit is set then it means that things controlling
2072                    the day boundaries, or some detail of date representation
2073                    has changed.  All the things that paint get changed here.
2074                    This is the main canvas, the multi-browse window, and
2075                    the todo and appointment list dialogs. */
2076
2077                 XtVaGetValues(c->canvas,
2078                                 XmNwidth,       &width,
2079                                 XmNheight,      &height,
2080                                 NULL);
2081                 cache_dims(c, width, height);
2082
2083                 if (c->view->glance != yearGlance)
2084                         paint_canvas(c, NULL, RENDER_CLEAR_FIRST);
2085
2086                 if (c->browser)
2087                         mb_refigure_chart(c);
2088
2089                 /* reformat the display values in the property sheet.
2090                    The property sheet must exist is we have to refigure
2091                    out the hour mode, so we don't need to check whether
2092                    it exists or not. */
2093
2094                 XmScaleGetValue(pu->dp_end_scale, &val);
2095                 set_scale_value(pu->dp_end_value, val, pu);
2096                 XmScaleGetValue(pu->dp_beg_scale, &val);
2097                 set_scale_value(pu->dp_beg_value, val, pu);
2098
2099                 if (c->editor && ((Editor *) c->editor)->view_list)
2100                         build_editor_view((Editor *) c->editor, ((Editor *) (c->editor))->view_list_glance, True);
2101
2102                 if (c->todo && ((ToDo *) c->todo)->view_frame)
2103                         build_todo_view((ToDo *) c->todo, ((ToDo *) (c->todo))->view_list_glance, True);
2104
2105
2106                 /* redo date entry in the multi-browser */
2107
2108                 if (b && current_mb_date) {
2109                         ot = get_int_prop(p, CP_DATEORDERING);
2110                         st = get_int_prop(p, CP_DATESEPARATOR);
2111                         format_tick(b->date, ot, st, buf);
2112                         XmTextSetString(b->datetext, buf);
2113                 }
2114         }
2115
2116         if (redisplay_mask & PROPS_REDO_EDITORS) {
2117
2118                 if (((Editor *) c->editor)->base_form_mgr) {
2119
2120                         Editor *e = (Editor *) c->editor;
2121                         DSSW *dssw = &((Editor *) c->editor)->dssw;
2122
2123                         set_dssw_menus(dssw, p);
2124
2125                         add_all_appt((Editor *) c->editor);
2126
2127
2128                 }
2129
2130                 if (((GEditor *) c->geditor)->base_form_mgr) {
2131                         GEditor *ge = (GEditor *) c->geditor;
2132                         DSSW *dssw = &((GEditor *) c->geditor)->dssw;
2133
2134                         set_dssw_menus(dssw, p);
2135
2136                         add_all_gappt(ge);
2137
2138                 }
2139
2140
2141                 if (((ToDo *) c->todo)->base_form_mgr) {
2142                         ToDo *t = (ToDo *)c->todo;
2143                         DSSW *dssw = &((ToDo *) c->todo)->dssw;
2144
2145                         set_dssw_menus(dssw, p);
2146
2147                         add_all_todo((ToDo *) c->todo);
2148                 }
2149
2150                 set_dssw_menus(&pu->ep_dssw, p);
2151
2152                 XtVaSetValues(c->browse_button, XmNsubMenuId, NULL, NULL);
2153                 update_browse_menu_names(c);
2154                 XtVaSetValues(c->browse_button, XmNsubMenuId, c->browse_menu, NULL);
2155                 if (c->browser)
2156                         browser_reset_list(c);
2157
2158                 /* This is really hateful.  The deal is that something
2159                    about the code that redefines the start and stop time
2160                    menus has a timing hole in it.  If I reset the values
2161                    for these two menus before the application returns to
2162                    the toolkit, the values will get clobbered later.
2163                    There seems to be no way to force the toolkit to
2164                    complete the restrucutring of the menus immediately,
2165                    so I have to add a timer proc to reset the defaults on
2166                    the dialog a little bit after returning to the notifier
2167                    loop.  Urk.  This really needs to be fixed some day. */
2168
2169                 XtAppAddTimeOut(c->xcontext->app, 50, set_editor_defaults_later, c);
2170
2171         }
2172         else
2173         {
2174           _DtTurnOffHourGlass(pu->frame);
2175           _DtTurnOffHourGlass(c->frame);
2176         }
2177
2178         if (redisplay_mask & PROPS_REDO_PRINT_DIALOG) {}
2179         p_clear_change(pu);
2180         return(True);
2181 }
2182
2183 /*
2184 **  Button callback procs
2185 */
2186 static void
2187 p_apply_proc(Widget w, XtPointer client_data, XtPointer data) {
2188         Calendar        *c = (Calendar *)client_data;
2189
2190         p_save_changes(c);
2191 }
2192
2193 static void
2194 p_ok_proc(
2195         Widget           w,
2196         XtPointer        client_data,
2197         XtPointer        data)
2198 {
2199         Calendar        *c = (Calendar *)client_data;
2200         Props_pu        *pu = (Props_pu *)c->properties_pu;
2201
2202
2203         if (p_save_changes(c) == True)
2204           XtUnmanageChild(pu->base_form_mgr);
2205 }
2206
2207 static void
2208 p_defaults_proc(Widget w, XtPointer client_data, XtPointer data) {
2209   p_defaults_proc_helper(client_data);
2210 }
2211
2212
2213 extern void p_defaults_proc_helper(XtPointer client_data){
2214         int             start, stop;
2215         Calendar        *c = (Calendar *)client_data;
2216         Props           *p = (Props *)c->properties;
2217         Props_pu        *pu = (Props_pu *)c->properties_pu;
2218
2219         if (!read_props(p)) {
2220                 char *title = XtNewString(catgets(c->DT_catd, 1, 454, "Calendar : Error - Options"));
2221                 char *text = XtNewString(catgets(c->DT_catd, 1, 448, "An error occurred reading from ~/.desksetdefaults.\nMake sure you have permission to read this file."));
2222                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2223                 dialog_popup(pu->frame,
2224                         DIALOG_TITLE, title,
2225                         DIALOG_TEXT, text,
2226                         BUTTON_IDENT, 1, ident1,
2227                         BUTTON_HELP, DESKSET_DEFAULTS_ERROR_HELP,
2228                         DIALOG_IMAGE, pu->xm_error_pixmap,
2229                         NULL);
2230                 XtFree(ident1);
2231                 XtFree(text);
2232                 XtFree(title);
2233         } else {
2234                 if ((start = get_int_prop(p, CP_DAYBEGIN)) < 0)
2235                         start = 0;
2236                 else if (start > 22)
2237                         start = 22;
2238                 if ((stop = get_int_prop(p, CP_DAYEND)) <= start)
2239                         stop = start + 1;
2240                 else if (stop > 23)
2241                         stop = 23;
2242                 set_int_prop(p, CP_DAYBEGIN, start);
2243                 set_int_prop(p, CP_DAYEND, stop);
2244
2245                 set_props_on_ui(pu, p);
2246         }
2247 }
2248
2249 static void
2250 p_close_proc(Widget w, XtPointer client_data, XtPointer data) {
2251         Props_pu *p = (Props_pu *)client_data;
2252
2253         XtUnmanageChild(p->base_form_mgr);
2254 }
2255
2256 extern Boolean
2257 p_flush_changes(Calendar *c) {
2258         Props           *p = (Props *)c->properties;
2259         Props_pu        *pu = (Props_pu *)c->properties_pu;
2260         static int      answer;
2261         int             redisplay_mask;
2262         int             val;
2263
2264         if (pu->changed_flag == True) {
2265                 char *title = XtNewString(catgets(c->DT_catd, 1, 450, "Calendar : Options - Help"));
2266                 char *text = XtNewString(catgets(c->DT_catd, 1, 451, "You have made unsaved changes.\nYou may save your changes, discard your changes, \nor return to your previous place in the dialog."));
2267                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 452, "Save"));
2268                 char *ident2 = XtNewString(catgets(c->DT_catd, 1, 700, "Discard"));
2269                 char *ident3 = XtNewString(catgets(c->DT_catd, 1, 923, "Cancel"));
2270                 answer = dialog_popup(pu->frame,
2271                         DIALOG_TITLE, title,
2272                         DIALOG_TEXT, text,
2273                         BUTTON_IDENT, 1, ident1,
2274                         BUTTON_IDENT, 2, ident2,
2275                         BUTTON_IDENT, 3, ident3,
2276                         DIALOG_IMAGE, pu->xm_warning_pixmap,
2277                         NULL);
2278                 XtFree(ident3);
2279                 XtFree(ident2);
2280                 XtFree(ident1);
2281                 XtFree(text);
2282                 XtFree(title);
2283                 if (answer == 1) {
2284
2285                         return(p_save_changes(c));
2286                 }
2287                 else if (answer == 2) {
2288                         set_props_on_ui(pu, p);
2289                         return(True);
2290                 }
2291                 else if (answer == 3) {
2292                         return(False);
2293                 }
2294         }
2295         else
2296                 return(True);
2297 }
2298
2299 static void
2300 p_quit_handler(Widget w, XtPointer cdata, XtPointer data) {
2301         Calendar        *c = (Calendar *)cdata;
2302         Props_pu        *pu = (Props_pu *)c->properties_pu;
2303
2304         if (p_flush_changes(c) == True)
2305           XtUnmanageChild(pu->base_form_mgr);
2306 }
2307
2308 static void
2309 p_make_props_pu(Calendar *c) {
2310         char            *buf;
2311         char            *popuplabel =
2312                              catgets(c->DT_catd, 1, 458, "Calendar : Options");
2313         PaneType        pt;
2314         Props_pu        *p = (Props_pu *)c->properties_pu;
2315         XmString        label;
2316         XmString        xmstr;
2317         Widget          widgets[10];
2318
2319         /*
2320         **  An array of panes will be used to "flip" through the different
2321         **  property choice sheets
2322         */
2323         p->cal = c;
2324         p->pane_list = (Widget *)ckalloc(sizeof(Widget)*(DATE_FORMAT_PANE + 1));
2325         memset(p->pane_list, 0, sizeof(Widget)*(DATE_FORMAT_PANE + 1));
2326
2327         /*
2328         **  Create the base frame and form manager
2329         */
2330         buf = (char *)ckalloc(cm_strlen(popuplabel)
2331                               + cm_strlen(c->calname) + 4);
2332         sprintf(buf, "%s - %s", popuplabel, c->calname);
2333
2334         p->frame = XtVaCreatePopupShell("frame",
2335                 xmDialogShellWidgetClass, c->frame,
2336                 XmNdeleteResponse, XmDO_NOTHING,
2337                 XmNtitle, buf,
2338                 XmNallowShellResize, True,
2339                 NULL);
2340         free(buf);
2341         setup_quit_handler(p->frame, p_quit_handler, (caddr_t)c);
2342
2343         p->base_form_mgr = XtVaCreateWidget("base_form_mgr",
2344                 xmFormWidgetClass, p->frame,
2345                 XmNautoUnmanage, False,
2346                 XmNhorizontalSpacing, 1,
2347                 XmNverticalSpacing, 1,
2348                 XmNuserData, p,
2349                 XmNresizable, False,
2350                 XmNfractionBase, 29,
2351                 XmNtopAttachment, XmATTACH_FORM,
2352                 XmNtopOffset, 0,
2353                 XmNbottomAttachment, XmATTACH_FORM,
2354                 XmNbottomOffset, 0,
2355                 XmNrightAttachment, XmATTACH_FORM,
2356                 XmNrightOffset, 0,
2357                 XmNleftAttachment, XmATTACH_FORM,
2358                 XmNleftOffset,  0,
2359                 NULL);
2360
2361         /*
2362         **  Now the "top" portion - the category menu and the first separator
2363         */
2364
2365         Pane_XmStrs[EDITOR_PANE] =
2366           XmStringCreateLocalized(catgets(c->DT_catd, 1, 762,
2367                                           "Editor Defaults"));
2368         Pane_XmStrs[DISPLAY_PANE] =
2369           XmStringCreateLocalized(catgets(c->DT_catd, 1, 763,
2370                                           "Display Settings"));
2371         Pane_XmStrs[GROUP_ACCESS_PANE] =
2372           XmStringCreateLocalized(catgets(c->DT_catd, 1, 764,
2373                                           "Access List and Permissions"));
2374         Pane_XmStrs[PRINTER_OPS_PANE] =
2375           XmStringCreateLocalized(catgets(c->DT_catd, 1, 765,
2376                                           "Printer Settings"));
2377         Pane_XmStrs[DATE_FORMAT_PANE] =
2378           XmStringCreateLocalized(catgets(c->DT_catd, 1, 766,
2379                                           "Date Format"));
2380
2381         label = XmStringCreateLocalized(
2382                                 catgets(c->DT_catd, 1, 459, "Category:"));
2383
2384         p->category_menu = widgets[0] =
2385                 XmVaCreateSimpleOptionMenu(p->base_form_mgr,
2386                 "category_menu",  label, NULL, 0, p_category_notify,
2387                 XmVaPUSHBUTTON, Pane_XmStrs[EDITOR_PANE], NULL, NULL, NULL,
2388                 XmVaPUSHBUTTON, Pane_XmStrs[DISPLAY_PANE], NULL, NULL, NULL,
2389                 XmVaPUSHBUTTON, Pane_XmStrs[GROUP_ACCESS_PANE], NULL, NULL,NULL,
2390                 XmVaPUSHBUTTON, Pane_XmStrs[PRINTER_OPS_PANE], NULL, NULL, NULL,
2391                 XmVaPUSHBUTTON, Pane_XmStrs[DATE_FORMAT_PANE], NULL, NULL, NULL,
2392                 XmNtopAttachment, XmATTACH_FORM,
2393                 XmNleftAttachment, XmATTACH_FORM,
2394                 XmNrightAttachment, XmATTACH_NONE,
2395                 XmNnavigationType, XmTAB_GROUP,
2396                 NULL);
2397         XmStringFree(label);
2398
2399         p->separator1 = widgets[1] = XtVaCreateWidget("separator1",
2400                 xmSeparatorGadgetClass, p->base_form_mgr,
2401                 XmNleftAttachment, XmATTACH_FORM,
2402                 XmNrightAttachment, XmATTACH_FORM,
2403                 XmNtopAttachment, XmATTACH_WIDGET,
2404                 XmNtopWidget, p->category_menu,
2405                 NULL);
2406
2407         /*
2408         **  Now create the "bottom" part - the separator and choice buttons
2409         */
2410         p_create_editor_pane(c);
2411
2412         p->separator2 = widgets[2] = XtVaCreateWidget("separator2",
2413                 xmSeparatorGadgetClass, p->base_form_mgr,
2414                 XmNleftAttachment, XmATTACH_FORM,
2415                 XmNrightAttachment, XmATTACH_FORM,
2416                 NULL);
2417
2418         /*
2419          * To get the pane to resize instead of the buttons at the bottom
2420          * of the option sheet we attach the bottom of the pane to the
2421          * separator instead of the other way around.
2422          */
2423         XtVaSetValues(p->pane_list[EDITOR_PANE],
2424                 XmNbottomAttachment, XmATTACH_WIDGET,
2425                 XmNbottomOffset, 10,
2426                 XmNbottomWidget, p->separator2,
2427                 NULL);
2428
2429         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 655, "OK"));
2430         p->ok_button = widgets[3] = XtVaCreateWidget("ok",
2431                 xmPushButtonGadgetClass, p->base_form_mgr,
2432                 XmNlabelString, xmstr,
2433                 XmNrecomputeSize,       False,
2434                 XmNbottomAttachment, XmATTACH_FORM,
2435                 XmNbottomOffset, 7,
2436                 XmNleftAttachment, XmATTACH_POSITION,
2437                 XmNleftPosition, 2,
2438                 XmNrightAttachment, XmATTACH_POSITION,
2439                 XmNrightPosition, 7,
2440                 XmNrightOffset, 5,
2441                 NULL);
2442         XmStringFree(xmstr);
2443         XtAddCallback(p->ok_button, XmNactivateCallback, p_ok_proc, c);
2444
2445         XtVaSetValues(p->separator2,
2446                 XmNbottomAttachment, XmATTACH_WIDGET,
2447                 XmNbottomOffset, 10,
2448                 XmNbottomWidget, p->ok_button,
2449                 NULL);
2450
2451         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 460, "Apply"));
2452         p->apply_button = widgets[4] = XtVaCreateWidget("apply",
2453                 xmPushButtonGadgetClass, p->base_form_mgr,
2454                 XmNlabelString, xmstr,
2455                 XmNrecomputeSize,       False,
2456                 XmNbottomAttachment, XmATTACH_FORM,
2457                 XmNbottomOffset, 7,
2458                 XmNtopWidget, p->separator2,
2459                 XmNleftAttachment, XmATTACH_POSITION,
2460                 XmNleftPosition, 7,
2461                 XmNrightAttachment, XmATTACH_POSITION,
2462                 XmNrightPosition, 12,
2463                 XmNrightOffset, 5,
2464                 NULL);
2465         XmStringFree(xmstr);
2466         XtAddCallback(p->apply_button, XmNactivateCallback, p_apply_proc, c);
2467
2468         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 691, "Reset"));
2469         p->defaults_button = widgets[5] = XtVaCreateWidget("reset",
2470                 xmPushButtonGadgetClass, p->base_form_mgr,
2471                 XmNlabelString, xmstr,
2472                 XmNrecomputeSize,       False,
2473                 XmNbottomAttachment, XmATTACH_FORM,
2474                 XmNbottomOffset, 7,
2475                 XmNleftAttachment, XmATTACH_POSITION,
2476                 XmNleftPosition, 12,
2477                 XmNrightAttachment, XmATTACH_POSITION,
2478                 XmNrightPosition, 17,
2479                 XmNrightOffset, 5,
2480                 NULL);
2481         XmStringFree(xmstr);
2482         XtAddCallback(p->defaults_button,
2483                 XmNactivateCallback, p_defaults_proc, c);
2484
2485         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 923, "Cancel"));
2486         p->close_button = widgets[6] = XtVaCreateWidget("close",
2487                 xmPushButtonGadgetClass, p->base_form_mgr,
2488                 XmNlabelString, xmstr,
2489                 XmNbottomAttachment, XmATTACH_FORM,
2490                 XmNbottomOffset, 7,
2491                 XmNtopWidget, p->separator2,
2492                 XmNleftAttachment, XmATTACH_POSITION,
2493                 XmNleftPosition, 17,
2494                 XmNrightAttachment, XmATTACH_POSITION,
2495                 XmNrightPosition, 22,
2496                 XmNrightOffset, 5,
2497                 NULL);
2498         XmStringFree(xmstr);
2499         XtAddCallback(p->close_button, XmNactivateCallback, p_close_proc, p);
2500
2501         xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 77, "Help"));
2502         p->help_button = widgets[7] = XtVaCreateWidget("help",
2503                 xmPushButtonGadgetClass, p->base_form_mgr,
2504                 XmNlabelString, xmstr,
2505                 XmNbottomAttachment, XmATTACH_FORM,
2506                 XmNbottomOffset, 7,
2507                 XmNtopWidget, p->separator2,
2508                 XmNleftAttachment, XmATTACH_POSITION,
2509                 XmNleftPosition, 22,
2510                 XmNrightAttachment, XmATTACH_POSITION,
2511                 XmNrightPosition, 27,
2512                 NULL);
2513         XmStringFree(xmstr);
2514         XtAddCallback(p->help_button, XmNactivateCallback,
2515                 (XtCallbackProc)help_cb, OPTIONS_HELP_BUTTON);
2516         XtAddCallback(p->base_form_mgr, XmNhelpCallback,
2517                (XtCallbackProc)help_cb, (XtPointer) OPTIONS_HELP_BUTTON);
2518
2519
2520         /*
2521         **  Last, create the remaining panes
2522         */
2523         p_create_display_pane(p);
2524         if (p->cal->my_cal_version < DATAVER4)
2525                 p_create_v4_group_access_pane(p);
2526         else
2527                 p_create_v5_group_access_pane(p);
2528
2529         p_create_printer_ops_pane(p);
2530         p_create_date_format_pane(p);
2531
2532         /*
2533         **  Manage the uppermost children (first pane is Editor Defaults)
2534         */
2535         p->last_props_pane = EDITOR_PANE;
2536         widgets[8] = p->pane_list[p->last_props_pane];
2537
2538         /* set default button */
2539         XtVaSetValues(p->base_form_mgr, XmNcancelButton,
2540                       p->close_button, NULL);
2541
2542
2543         XtManageChildren(widgets, 9);
2544 }
2545
2546 static Boolean
2547 string_is_number(char *str) {
2548
2549
2550         if (blank_buf(str)) {
2551                 return(False);
2552         }
2553
2554         while (str && *str) {
2555                 if (!isdigit(*str) && *str != ' ' && *str != '\t')
2556                         return(False);
2557
2558                 str++;
2559         }
2560
2561         return(True);
2562 }
2563
2564 static Boolean
2565 string_is_time(char *str) {
2566
2567         Boolean found_colon = False;
2568         int     found_first_number = 0;
2569         int     found_second_number = 0;
2570
2571         if (blank_buf(str)) {
2572                 return(False);
2573         }
2574
2575         /* a time is a pretty structured beast */
2576
2577         while (*str) {
2578                 if ((*str == ' ') || (*str == '\t')) {
2579                 }
2580                 else if (*str == ':') {
2581                         if (found_colon == True)
2582                                 return(False);
2583                         else if (found_first_number == False)
2584                                 return(False);
2585                         else
2586                                 found_colon = True;
2587                 }
2588                 else if (isdigit(*str)) {
2589                         if (found_colon == True)
2590                                 found_second_number++;
2591                         else
2592                                 found_first_number++;
2593                 }
2594                 else
2595                         return(False);
2596
2597                 str++;
2598         }
2599
2600         if ((found_colon == True) &&
2601             ((((found_first_number > 2) || (found_first_number < 1)) || (found_second_number != 2))))
2602                 return(False);
2603         else if ((found_colon == False) && ((found_first_number > 4) || found_first_number < 3))
2604                 return(False);
2605
2606         return(True);
2607 }
2608
2609
2610 /*******************************************************************************
2611 **
2612 **  Functions external to props_pu.c
2613 **
2614 *******************************************************************************/
2615 extern Boolean
2616 get_editor_vals_from_ui(Props_pu *pu, Props *p) {
2617         int             i, hr, min;
2618         char            buf[5];
2619         Widget          text;
2620         DisplayType     dt = get_int_prop(p, CP_DEFAULTDISP);
2621         Reminders_val   *val;
2622         char            *msg, *dur_txt;
2623         Reminder_val_op status;
2624         Calendar        *c = pu->cal;
2625
2626         XtVaGetValues(pu->ep_dur_cb, XmNtextField, &text, NULL);
2627         dur_txt = XmTextGetString(text);
2628
2629         if (string_is_number(dur_txt) == False) {
2630                 char *title = XtNewString(catgets(c->DT_catd, 1, 1079, "Calendar : Error - Editor Settings"));
2631                 char *text = XtNewString(catgets(c->DT_catd, 1, 819, "The Duration value must be an integer with no sign.\nYour properties settings have not been saved."));
2632                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2633
2634                 XtFree(dur_txt);
2635                 dialog_popup(pu->frame,
2636                         DIALOG_TITLE, title,
2637                         DIALOG_TEXT, text,
2638                         BUTTON_IDENT, 1, ident1,
2639                         BUTTON_HELP, DURATION_ERROR_HELP,
2640                         DIALOG_IMAGE, pu->xm_error_pixmap,
2641                         NULL);
2642                 XtFree(ident1);
2643                 XtFree(text);
2644                 XtFree(title);
2645                 return(True);
2646         }
2647
2648         if (atoi(dur_txt) >= (60 *24)) {
2649                 char *title = XtNewString(catgets(c->DT_catd, 1, 1079, "Calendar : Error - Editor Settings"));
2650                 char *text = XtNewString(catgets(c->DT_catd, 1, 916, "The Duration value must be less than 24 hours.\nYour properties settings have not been saved."));
2651                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2652
2653                 XtFree(dur_txt);
2654                 dialog_popup(pu->frame,
2655                         DIALOG_TITLE, title,
2656                         DIALOG_TEXT, text,
2657                         BUTTON_IDENT, 1, ident1,
2658                         BUTTON_HELP, DURATION_ERROR_HELP,
2659                         DIALOG_IMAGE, pu->xm_error_pixmap,
2660                         NULL);
2661                 XtFree(ident1);
2662                 XtFree(text);
2663                 XtFree(title);
2664                 return(True);
2665         }
2666
2667         get_dssw_times(&pu->ep_dssw);
2668
2669         if (string_is_time(pu->ep_dssw.start_val.val) == False) {
2670                 char *title = XtNewString(catgets(c->DT_catd, 1, 1079, "Calendar : Error - Editor Settings"));
2671                 char *text = XtNewString(catgets(c->DT_catd, 1, 820, "The start value must be a valid time.\nYour properties settings have not been saved."));
2672                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2673                 dialog_popup(pu->frame,
2674                         DIALOG_TITLE, title,
2675                         DIALOG_TEXT, text,
2676                         BUTTON_IDENT, 1, ident1,
2677                         BUTTON_HELP, START_ERROR_HELP,
2678                         DIALOG_IMAGE, pu->xm_error_pixmap,
2679                         NULL);
2680                 XtFree(ident1);
2681                 XtFree(text);
2682                 XtFree(title);
2683                 return(True);
2684         }
2685
2686
2687         strncpy(buf, pu->ep_dssw.start_val.val, 2);
2688         buf[2] = '\0';
2689         hr = atoi(buf) % 24;
2690
2691         if (dt == HOUR12) {
2692                 if (!XmToggleButtonGetState(pu->ep_dssw.start_am)) {
2693                         if (hr != 12)
2694                                 hr += 12;
2695                 } else if (hr == 12)
2696                         hr = 0;
2697                 strncpy(buf, &pu->ep_dssw.start_val.val[3], 2);
2698                 buf[2] = '\0';
2699         } else {
2700                 strncpy(buf, &pu->ep_dssw.start_val.val[2], 2);
2701                 buf[2] = '\0';
2702         }
2703         min = atoi(buf) % 60;
2704         set_int_prop(p, CP_APPTBEGIN, (hr * minsec) + min);
2705
2706         XtVaGetValues(pu->ep_dur_cb, XmNtextField, &text, NULL);
2707         if (text) {
2708                 min = atoi(XmTextGetString(text));
2709                 set_int_prop(p, CP_APPTDURATION, min);
2710         }
2711
2712         if ((status = get_reminders_vals(&pu->ep_reminders, False)) != REMINDERS_OK) {
2713                 char *title = XtNewString(catgets(c->DT_catd, 1, 1079, "Calendar : Error - Editor Settings"));
2714                 char *text;
2715                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2716                 switch (status) {
2717
2718                 case ADVANCE_BLANK : text = XtNewString(catgets(c->DT_catd, 1, 908, "You may not set a blank reminder value.\nYour properties settings have not been saved."));
2719                         break;
2720
2721                 case ADVANCE_CONTAINS_BLANK : text = XtNewString(catgets(c->DT_catd, 1, 909, "You may not set a reminder value with an embedded blank.\nYour properties settings have not been saved."));
2722                         break;
2723
2724                 case ADVANCE_NONNUMERIC : text = XtNewString(catgets(c->DT_catd, 1, 910, "Reminder values must be a number with an optional sign.\nYour properties settings have not been saved."));
2725                         break;
2726
2727                 }
2728                 dialog_popup(pu->frame,
2729                         DIALOG_TITLE, title,
2730                         DIALOG_TEXT, text,
2731                         BUTTON_IDENT, 1, ident1,
2732                         DIALOG_IMAGE, pu->xm_error_pixmap,
2733                         BUTTON_HELP, ADVANCE_ERROR_HELP,
2734                         NULL);
2735                 XtFree(ident1);
2736                 XtFree(text);
2737                 XtFree(title);
2738                 return(True);
2739         }
2740
2741         val = &pu->ep_reminders.beep_val;
2742         set_char_prop(p, CP_BEEPON, boolean_str(val->selected));
2743         set_int_prop(p, CP_BEEPADV, val->scope_val);
2744         set_char_prop(p, CP_BEEPUNIT, (char *)time_scope_str(val->scope));
2745
2746         val = &pu->ep_reminders.flash_val;
2747         set_char_prop(p, CP_FLASHON, boolean_str(val->selected));
2748         set_int_prop(p, CP_FLASHADV, val->scope_val);
2749         set_char_prop(p, CP_FLASHUNIT, (char *)time_scope_str(val->scope));
2750
2751         val = &pu->ep_reminders.popup_val;
2752         set_char_prop(p, CP_OPENON, boolean_str(val->selected));
2753         set_int_prop(p, CP_OPENADV, val->scope_val);
2754         set_char_prop(p, CP_OPENUNIT, (char *)time_scope_str(val->scope));
2755
2756         val = &pu->ep_reminders.mail_val;
2757         set_char_prop(p, CP_MAILON, boolean_str(val->selected));
2758         set_int_prop(p, CP_MAILADV, val->scope_val);
2759         set_char_prop(p, CP_MAILUNIT, (char *)time_scope_str(val->scope));
2760         set_char_prop(p, CP_MAILTO, pu->ep_reminders.mailto_val);
2761
2762         XtVaGetValues(pu->privacy_menu, XmNselectedPosition, &i, NULL);
2763         --i;
2764         set_char_prop(p, CP_PRIVACY, privacy_str(i));
2765
2766         return(False);
2767 }
2768
2769 extern Boolean
2770 get_display_vals_from_ui(Props_pu *pu, Props *p) {
2771         int     val;
2772         char    *str;
2773         Calendar *c = pu->cal;
2774
2775         set_char_prop(p, CP_CALLOC, str = XmTextGetString(pu->dp_loc_text));
2776         if (blank_buf(str) || embedded_blank(str)) {
2777                 char *title = XtNewString(catgets(c->DT_catd, 1, 1083, "Calendar : Error - Display Settings"));
2778                 char *text = XtNewString(catgets(c->DT_catd, 1, 772, "You may not save a blank User Calendar Location\nor one that contains blanks.\nYour properties settings have not been saved."));
2779                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2780                 dialog_popup(pu->frame,
2781                         DIALOG_TITLE, title,
2782                         DIALOG_TEXT, text,
2783                         BUTTON_IDENT, 1, ident1,
2784                         BUTTON_HELP, CAL_LOCATION_ERROR_HELP,
2785                         DIALOG_IMAGE, pu->xm_error_pixmap,
2786                         NULL);
2787                 XtFree(ident1);
2788                 XtFree(text);
2789                 XtFree(title);
2790                 XtFree(str);
2791                 return(True);
2792
2793         }
2794         XtFree(str);
2795
2796         XtVaGetValues(pu->dp_beg_scale, XmNvalue, &val,
2797                 NULL);
2798         set_int_prop(p, CP_DAYBEGIN, val);
2799         XtVaGetValues(pu->dp_end_scale, XmNvalue, &val,
2800                 NULL);
2801         set_int_prop(p, CP_DAYEND, val);
2802
2803         set_int_prop(p, CP_DEFAULTDISP, XmToggleButtonGadgetGetState(
2804                 pu->dp_hour24_toggle) ? HOUR24 : HOUR12);
2805
2806         if (XmToggleButtonGadgetGetState(pu->dp_view_day_toggle))
2807                 val = (int)DAY_VIEW;
2808         else if (XmToggleButtonGadgetGetState(pu->dp_view_month_toggle))
2809                 val = (int)MONTH_VIEW;
2810         else if (XmToggleButtonGadgetGetState(pu->dp_view_week_toggle))
2811                 val = (int)WEEK_VIEW;
2812         else if (XmToggleButtonGadgetGetState(pu->dp_view_year_toggle))
2813                 val = (int)YEAR_VIEW;
2814         set_int_prop(p, CP_DEFAULTVIEW, val);
2815
2816         set_char_prop(p, CP_DEFAULTCAL,
2817                 str = XmTextGetString(pu->dp_init_view_text));
2818
2819         if (blank_buf(str) || embedded_blank(str)) {
2820                 char *title = XtNewString(catgets(c->DT_catd, 1, 1083, "Calendar : Error - Display Settings"));
2821                 char *text = XtNewString(catgets(c->DT_catd, 1, 773, "You may not save a blank Initial Calendar View\nor one that contains blanks.\nYour properties settings have not been saved."));
2822                 char *ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2823                 dialog_popup(pu->frame,
2824                         DIALOG_TITLE, title,
2825                         DIALOG_TEXT, text,
2826                         BUTTON_IDENT, 1, ident1,
2827                         DIALOG_IMAGE, pu->xm_error_pixmap,
2828                         NULL);
2829                 XtFree(ident1);
2830                 XtFree(text);
2831                 XtFree(title);
2832                 XtFree(str);
2833                 return(True);
2834
2835         }
2836         XtFree(str);
2837
2838         return(False);
2839 }
2840
2841 extern Boolean
2842 get_gap_vals_from_ui(Props_pu *pu, Props *p) {
2843         CSA_return_code stat;
2844         Dtcm_calendar   *cal;
2845
2846         cal = allocate_cal_struct(appt_write,
2847                                         pu->cal->my_cal_version,
2848                                         CSA_CAL_ATTR_ACCESS_LIST_I,
2849                                         NULL);
2850         cal->access_list->value->item.access_list_value = pu->gap_list;
2851         pu->gap_list = NULL;
2852
2853         stat = csa_update_calendar_attributes(pu->cal->my_cal_handle, cal->count, cal->attrs, NULL);
2854         backend_err_msg(pu->frame, pu->cal->calname, stat, pu->xm_error_pixmap);
2855         free_cal_struct(&cal);
2856         set_gap_vals_on_ui(pu, p);
2857         return(False);
2858 }
2859
2860 static void
2861 print_option_error(Props_pu *pu, int setNum, int msgNum, char *str)
2862 {
2863   Calendar *c = pu->cal;
2864   char *text = XtNewString(catgets(c->DT_catd, setNum, msgNum, str));
2865   static char *title = (char *)NULL;
2866   static char *ident1 = (char *)NULL;
2867
2868   if (title == (char *)NULL)
2869     title = XtNewString(catgets(c->DT_catd, 1, 1085,
2870                                 "Calendar : Error - Printer Settings"));
2871   if (ident1 == (char *)NULL)
2872     ident1 = XtNewString(catgets(c->DT_catd, 1, 95, "Continue"));
2873
2874   dialog_popup(pu->frame,
2875                DIALOG_TITLE, title,
2876                DIALOG_TEXT, text,
2877                BUTTON_IDENT, 1, ident1,
2878                BUTTON_HELP, PRINT_HELP_BUTTON,
2879                DIALOG_IMAGE, pu->xm_error_pixmap,
2880                NULL);
2881   XtFree(text);
2882 }
2883
2884 extern Boolean
2885 get_printer_vals_from_ui(Props_pu *pu, Props *p) {
2886         char            *str;
2887         int             plevel = 0;
2888
2889         if ((str = _DtPrintGetMarginSpec(pu->pop_right_text)) != (char *)NULL)
2890         {
2891           if (valid_margin_str(pu, str))
2892           {
2893             set_char_prop(p, CP_PRINTRMARGIN, str);
2894             XtFree(str);
2895           }
2896           else
2897           {
2898             print_option_error(pu, 1, 821,
2899                                "You have specified an illegal right margin value.\nYour properties settings have not been saved.");
2900             XtFree(str);
2901             return True;
2902           }
2903         }
2904
2905         if ((str = _DtPrintGetMarginSpec(pu->pop_bottom_text)) != (char *)NULL)
2906         {
2907           if (valid_margin_str(pu, str))
2908           {
2909             set_char_prop(p, CP_PRINTBMARGIN, str);
2910             XtFree(str);
2911           }
2912           else
2913           {
2914             print_option_error(pu, 1, 822,
2915                                "You have specified an illegal bottom margin value.\nYour properties settings have not been saved.");
2916             XtFree(str);
2917             return True;
2918           }
2919         }
2920
2921         if ((str = _DtPrintGetMarginSpec(pu->pop_left_text)) != (char *)NULL)
2922         {
2923           if (valid_margin_str(pu, str))
2924           {
2925             set_char_prop(p, CP_PRINTLMARGIN, str);
2926             XtFree(str);
2927           }
2928           else
2929           {
2930             print_option_error(pu, 1, 911,
2931                                "You have specified an illegal left margin value.\nYour properties settings have not been saved.");
2932             XtFree(str);
2933             return True;
2934           }
2935         }
2936
2937         if ((str = _DtPrintGetMarginSpec(pu->pop_top_text)) != (char *)NULL)
2938         {
2939           if (valid_margin_str(pu, str))
2940           {
2941             set_char_prop(p, CP_PRINTTMARGIN, str);
2942             XtFree(str);
2943           }
2944           else
2945           {
2946             print_option_error(pu, 1, 912,
2947                                "You have specified an illegal top margin value.\nYour properties settings have not been saved.");
2948             XtFree(str);
2949             return True;
2950           }
2951         }
2952
2953         set_int_prop(p, CP_PRINTLHEADER,
2954                      _DtPrintGetHdrFtrIndex(pu->pop_tl_option));
2955         set_int_prop(p, CP_PRINTRHEADER,
2956                      _DtPrintGetHdrFtrIndex(pu->pop_tr_option));
2957         set_int_prop(p, CP_PRINTLFOOTER,
2958                      _DtPrintGetHdrFtrIndex(pu->pop_bl_option));
2959         set_int_prop(p, CP_PRINTRFOOTER,
2960                      _DtPrintGetHdrFtrIndex(pu->pop_br_option));
2961
2962         /*
2963         **  For backward compatability with the XView toggles (which used or'd
2964         **  values) - we must continue ...
2965         */
2966         if (XmToggleButtonGadgetGetState(pu->pop_privacy_public_toggle))
2967                 plevel |= PRINT_PUBLIC;
2968         if (XmToggleButtonGadgetGetState(pu->pop_privacy_semi_toggle))
2969                 plevel |= PRINT_SEMIPRIVATE;
2970         if (XmToggleButtonGadgetGetState(pu->pop_privacy_private_toggle))
2971                 plevel |= PRINT_PRIVATE;
2972         set_int_prop(p, CP_PRINTPRIVACY, plevel);
2973
2974         return False;
2975 }
2976
2977 extern Boolean
2978 get_date_vals_from_ui(Props_pu *pu, Props *p) {
2979         if (XmToggleButtonGadgetGetState(pu->dfp_order_mmddyy_toggle))
2980                 set_int_prop(p, CP_DATEORDERING, (int)ORDER_MDY);
2981         else if (XmToggleButtonGadgetGetState(pu->dfp_order_ddmmyy_toggle))
2982                 set_int_prop(p, CP_DATEORDERING, (int)ORDER_DMY);
2983         else if (XmToggleButtonGadgetGetState(pu->dfp_order_yymmdd_toggle))
2984                 set_int_prop(p, CP_DATEORDERING, (int)ORDER_YMD);
2985
2986         if (XmToggleButtonGadgetGetState(pu->dfp_sep_blank_toggle))
2987                 set_int_prop(p, CP_DATESEPARATOR, (int)SEPARATOR_BLANK);
2988         else if (XmToggleButtonGadgetGetState(pu->dfp_sep_slash_toggle))
2989                 set_int_prop(p, CP_DATESEPARATOR, (int)SEPARATOR_SLASH);
2990         else if (XmToggleButtonGadgetGetState(pu->dfp_sep_period_toggle))
2991                 set_int_prop(p, CP_DATESEPARATOR, (int)SEPARATOR_DOT);
2992         else if (XmToggleButtonGadgetGetState(pu->dfp_sep_dash_toggle))
2993                 set_int_prop(p, CP_DATESEPARATOR, (int)SEPARATOR_DASH);
2994
2995         return(False);
2996 }
2997
2998 extern Boolean
2999 get_props_from_ui(Props_pu *pu, Props *p, int *redisplay_mask) {
3000
3001         *redisplay_mask = 0;
3002
3003         /* we only ever have to get the values for one of the categories,
3004            as changing the nanes causes the values for the existing
3005            category to be flushed. */
3006
3007         switch(pu->last_props_pane) {
3008         case DISPLAY_PANE:
3009                 if (get_display_vals_from_ui(pu, p) == True)
3010                         return(True);
3011                 else
3012                         *redisplay_mask |= (PROPS_REDO_EDITORS | PROPS_REDO_DISPLAY);
3013                 break;
3014         case GROUP_ACCESS_PANE:
3015                 if (get_gap_vals_from_ui(pu, p) == True)
3016                                 return(True);
3017                 break;
3018         case PRINTER_OPS_PANE:
3019                 if (get_printer_vals_from_ui(pu, p) == True)
3020                         return(True);
3021                 else
3022                         *redisplay_mask |= PROPS_REDO_PRINT_DIALOG;
3023                 break;
3024         case DATE_FORMAT_PANE:
3025                 if (get_date_vals_from_ui(pu, p) == True)
3026                         return(True);
3027                 else
3028                         *redisplay_mask |= (PROPS_REDO_EDITORS | PROPS_REDO_DISPLAY);
3029                 break;
3030         case EDITOR_PANE:
3031                 if (get_editor_vals_from_ui(pu, p) == True)
3032                         return(True);
3033                 else
3034                         *redisplay_mask |= PROPS_REDO_EDITORS;
3035         default:
3036                 break;
3037         }
3038         return(False);
3039 }
3040
3041 extern void
3042 set_editor_vals_on_ui(Props_pu *pu, Props *p) {
3043         int             i;
3044         char            buf[MAXNAMELEN];
3045         Widget          text;
3046         Reminders_val   *val;
3047
3048         set_dssw_defaults(&pu->ep_dssw, now(), True);
3049         XtVaGetValues(pu->ep_dur_cb, XmNtextField, &text, NULL);
3050         if (text) {
3051                 sprintf(buf, "%d", get_int_prop(p, CP_APPTDURATION));
3052                 XmTextSetString(text, buf);
3053         }
3054
3055         val = &pu->ep_reminders.beep_val;
3056         val->selected = convert_boolean_str(get_char_prop(p, CP_BEEPON));
3057         val->scope = convert_time_scope_str(get_char_prop(p, CP_BEEPUNIT));
3058         val->scope_val = get_int_prop(p, CP_BEEPADV);
3059
3060         val = &pu->ep_reminders.flash_val;
3061         val->selected = convert_boolean_str(get_char_prop(p, CP_FLASHON));
3062         val->scope = convert_time_scope_str(get_char_prop(p, CP_FLASHUNIT));
3063         val->scope_val = get_int_prop(p, CP_FLASHADV);
3064
3065         val = &pu->ep_reminders.popup_val;
3066         val->selected = convert_boolean_str(get_char_prop(p, CP_OPENON));
3067         val->scope = convert_time_scope_str(get_char_prop(p, CP_OPENUNIT));
3068         val->scope_val = get_int_prop(p, CP_OPENADV);
3069
3070         val = &pu->ep_reminders.mail_val;
3071         val->selected = convert_boolean_str(get_char_prop(p, CP_MAILON));
3072         val->scope = convert_time_scope_str(get_char_prop(p, CP_MAILUNIT));
3073         val->scope_val = get_int_prop(p, CP_MAILADV);
3074         strcpy(pu->ep_reminders.mailto_val, get_char_prop(p, CP_MAILTO));
3075
3076         set_reminders_vals(&pu->ep_reminders, False);
3077
3078         i = convert_privacy_str_to_op(get_char_prop(p, CP_PRIVACY));
3079         XtVaSetValues(pu->privacy_menu, XmNselectedPosition, i + 1, NULL);
3080 }
3081
3082 extern void
3083 set_display_vals_on_ui(Props_pu *pu, Props *p) {
3084         XmTextSetString(pu->dp_loc_text, get_char_prop(p, CP_CALLOC));
3085
3086         XtVaSetValues(pu->dp_beg_scale, XmNvalue, get_int_prop(p, CP_DAYBEGIN),
3087                 NULL);
3088         set_scale_value(pu->dp_beg_value, get_int_prop(p, CP_DAYBEGIN), pu);
3089
3090         XtVaSetValues(pu->dp_end_scale, XmNvalue, get_int_prop(p, CP_DAYEND),
3091                 NULL);
3092         set_scale_value(pu->dp_end_value, get_int_prop(p, CP_DAYEND), pu);
3093
3094         XmToggleButtonGadgetSetState((get_int_prop(p, CP_DEFAULTDISP) == HOUR12)
3095                 ? pu->dp_hour12_toggle : pu->dp_hour24_toggle, True, True);
3096
3097         switch(get_int_prop(p, CP_DEFAULTVIEW)) {
3098         case DAY_VIEW:
3099                 XmToggleButtonGadgetSetState(pu->dp_view_day_toggle,
3100                         True, True);
3101                 break;
3102         case WEEK_VIEW:
3103                 XmToggleButtonGadgetSetState(pu->dp_view_week_toggle,
3104                         True, True);
3105                 break;
3106         case YEAR_VIEW:
3107                 XmToggleButtonGadgetSetState(pu->dp_view_year_toggle,
3108                         True, True);
3109                 break;
3110         case MONTH_VIEW:
3111         default:
3112                 XmToggleButtonGadgetSetState(pu->dp_view_month_toggle,
3113                         True, True);
3114                 break;
3115         }
3116
3117         XmTextSetString(pu->dp_init_view_text, get_char_prop(p, CP_DEFAULTCAL));
3118 }
3119
3120 extern void
3121 set_gap_vals_on_ui(Props_pu *pu, Props *p) {
3122         char            *p_str;
3123         XmString        xmstr;
3124         CSA_return_code stat;
3125         Dtcm_calendar   *cal;
3126         CSA_access_list step = NULL, holder = NULL, last;
3127
3128         cal = allocate_cal_struct(appt_read,
3129                                         pu->cal->my_cal_version,
3130                                         CSA_CAL_ATTR_ACCESS_LIST_I,
3131                                         NULL);
3132         stat = query_cal_struct(pu->cal->my_cal_handle, cal);
3133         backend_err_msg(pu->frame, pu->cal->calname, stat, pu->xm_error_pixmap);
3134         if (stat != CSA_SUCCESS) {
3135                 free_cal_struct(&cal);
3136                 return;
3137         }
3138         pu->gap_list = cal->access_list->value->item.access_list_value;
3139         cal->access_list->value->item.access_list_value = NULL;
3140
3141         XmListDeleteAllItems(pu->gap_access_list);
3142         step = pu->gap_list;
3143         while (step) {
3144                 if (pu->cal->my_cal_version < DATAVER4) {
3145                         p_str = p_gap_create_perm_str(step->rights);
3146                         p_gap_create_entry_string(pu, step->user->user_name,
3147                                                         p_str, &xmstr);
3148                         free(p_str);
3149                 } else
3150                         xmstr = XmStringCreateLocalized(step->user->user_name);
3151
3152                 XmListAddItem(pu->gap_access_list, xmstr, 0);
3153                 XmStringFree(xmstr);
3154                 step = step->next;
3155         }
3156         free_cal_struct(&cal);
3157 }
3158
3159 static Boolean
3160 valid_margin_str(Props_pu *pu, char *str)
3161 {
3162   XtEnum badStr;
3163
3164   XmConvertStringToUnits(XtScreen(pu->pop_margin_frame),
3165                          str, XmHORIZONTAL, XmINCHES, &badStr);
3166
3167   return (Boolean)!badStr;
3168 }
3169
3170 extern void
3171 set_printer_vals_on_ui(Props_pu *pu, Props *p) {
3172         int plevel;
3173
3174         _DtPrintSetMarginSpec(pu->pop_left_text,
3175                               get_char_prop(p, CP_PRINTLMARGIN));
3176
3177         _DtPrintSetMarginSpec(pu->pop_top_text,
3178                               get_char_prop(p, CP_PRINTTMARGIN));
3179
3180         _DtPrintSetMarginSpec(pu->pop_right_text,
3181                               get_char_prop(p, CP_PRINTRMARGIN));
3182
3183         _DtPrintSetMarginSpec(pu->pop_bottom_text,
3184                               get_char_prop(p, CP_PRINTBMARGIN));
3185
3186         _DtPrintSetHdrFtrByIndex(pu->pop_tl_option,
3187                                  get_int_prop(p, CP_PRINTLHEADER));
3188
3189         _DtPrintSetHdrFtrByIndex(pu->pop_tr_option,
3190                                  get_int_prop(p, CP_PRINTRHEADER));
3191
3192         _DtPrintSetHdrFtrByIndex(pu->pop_bl_option,
3193                                  get_int_prop(p, CP_PRINTLFOOTER));
3194
3195         _DtPrintSetHdrFtrByIndex(pu->pop_br_option,
3196                                  get_int_prop(p, CP_PRINTRFOOTER));
3197
3198         /*
3199         **  For backward compatability with the XView toggles (which used or'd
3200         **  values) - we must continue ...
3201         */
3202         plevel = get_int_prop(p, CP_PRINTPRIVACY);
3203         if (plevel & PRINT_PUBLIC)
3204                 XmToggleButtonGadgetSetState(pu->pop_privacy_public_toggle,
3205                         True, True);
3206         if (plevel & PRINT_SEMIPRIVATE)
3207                 XmToggleButtonGadgetSetState(pu->pop_privacy_semi_toggle,
3208                         True, True);
3209         if (plevel & PRINT_PRIVATE)
3210                 XmToggleButtonGadgetSetState(pu->pop_privacy_private_toggle,
3211                         True, True);
3212 }
3213
3214 extern void
3215 set_date_vals_on_ui(Props_pu *pu, Props *p) {
3216         SeparatorType   st = get_int_prop(p, CP_DATESEPARATOR);
3217         OrderingType    ot = get_int_prop(p, CP_DATEORDERING);
3218
3219         switch(ot) {
3220         case ORDER_MDY:
3221                 XmToggleButtonGadgetSetState(pu->dfp_order_mmddyy_toggle,
3222                         True, True);
3223                 break;
3224         case ORDER_DMY:
3225                 XmToggleButtonGadgetSetState(pu->dfp_order_ddmmyy_toggle,
3226                         True, True);
3227                 break;
3228         case ORDER_YMD:
3229         default:
3230                 XmToggleButtonGadgetSetState(pu->dfp_order_yymmdd_toggle,
3231                         True, True);
3232                 break;
3233         }
3234
3235         switch(st) {
3236         case SEPARATOR_BLANK:
3237                 XmToggleButtonGadgetSetState(pu->dfp_sep_blank_toggle,
3238                         True, True);
3239                 break;
3240         case SEPARATOR_SLASH:
3241                 XmToggleButtonGadgetSetState(pu->dfp_sep_slash_toggle,
3242                         True, True);
3243                 break;
3244         case SEPARATOR_DOT:
3245                 XmToggleButtonGadgetSetState(pu->dfp_sep_period_toggle,
3246                         True, True);
3247                 break;
3248         case SEPARATOR_DASH:
3249                 XmToggleButtonGadgetSetState(pu->dfp_sep_dash_toggle,
3250                         True, True);
3251                 break;
3252         }
3253 }
3254
3255 extern void
3256 set_props_on_ui(Props_pu *pu, Props *p) {
3257         set_editor_vals_on_ui(pu, p);
3258         set_display_vals_on_ui(pu, p);
3259         set_gap_vals_on_ui(pu, p);
3260         set_printer_vals_on_ui(pu, p);
3261         set_date_vals_on_ui(pu, p);
3262
3263
3264         p_clear_change(pu);
3265 }
3266
3267 extern void
3268 show_props_pu(Calendar *c) {
3269         Props           *p = (Props *)c->properties;
3270         Props_pu        *pu = (Props_pu *)c->properties_pu;
3271
3272
3273         if (!p || !pu)
3274                 return;
3275
3276
3277         if (!pu->frame)
3278                 p_make_props_pu(c);
3279
3280
3281
3282         if (!props_pu_showing(pu))
3283         {
3284           set_props_on_ui(pu, p);
3285           XtManageChild(pu->base_form_mgr);
3286
3287           /* Center Category menu */
3288           p_gap_center_cat_menu(pu->pane_list[pu->last_props_pane],
3289                                 pu->category_menu);
3290         }
3291
3292         /* reset default values.  takes care of 7:00/9:00 start problem */
3293         p_defaults_proc_helper(c);
3294
3295         XtPopup(pu->frame, XtGrabNone);
3296 }
3297
3298 void
3299 show_print_props_pu(Calendar *c)
3300 {
3301   Props *p = (Props *)c->properties;
3302   Props_pu *pu = (Props_pu *)c->properties_pu;
3303
3304   if (!p || !pu)
3305     return;
3306   if (!pu->frame)
3307     p_make_props_pu(c);
3308
3309   activate_ui(pu, PRINTER_OPS_PANE);
3310
3311   if (!props_pu_showing(pu))
3312   {
3313     set_props_on_ui(pu, p);
3314     XtManageChild(pu->base_form_mgr);
3315
3316     /* Center Category menu */
3317     p_gap_center_cat_menu(pu->pane_list[pu->last_props_pane],
3318                           pu->category_menu);
3319   }
3320 }
3321
3322 extern void
3323 props_pu_clean_up(Props_pu *p) {
3324         if (p->pane_list)
3325                 free(p->pane_list);
3326         p->pane_list = NULL;
3327 }
3328
3329 extern Boolean
3330 props_pu_showing(Props_pu *p) {
3331         if (p && p->base_form_mgr)
3332                 return XtIsManaged(p->base_form_mgr);
3333         return False;
3334 }
3335
3336 static void
3337 p_gap_clear_toggles(Props_pu *p)
3338 {
3339
3340         /*
3341          * V5DEP: If this is a V5 server w/V1 backing store probably
3342          * should use old access flags.
3343          */
3344         if (p->cal->my_cal_version >= DATAVER4) {
3345                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_VIEW],
3346                         False, True);
3347                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_INSERT],
3348                         False, True);
3349                 XmToggleButtonGadgetSetState(p->gap2_public_tog[GAP_CHANGE],
3350                         False, True);
3351                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_VIEW],
3352                         False, True);
3353                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_INSERT],
3354                         False, True);
3355                 XmToggleButtonGadgetSetState(p->gap2_semi_tog[GAP_CHANGE],
3356                         False, True);
3357                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_VIEW],
3358                         False, True);
3359                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_INSERT],
3360                         False, True);
3361                 XmToggleButtonGadgetSetState(p->gap2_private_tog[GAP_CHANGE],
3362                         False, True);
3363         } else {
3364                 XmToggleButtonGadgetSetState(p->gap_browse_toggle,
3365                         False, True);
3366                 XmToggleButtonGadgetSetState(p->gap_insert_toggle,
3367                         False, True);
3368                 XmToggleButtonGadgetSetState(p->gap_delete_toggle,
3369                         False, True);
3370         }
3371 }
3372
3373 static void
3374 p_gap_center_cat_menu(
3375         Widget          frame,
3376         Widget          menu)
3377 {
3378   Dimension frame_width, menu_width;
3379
3380   XtVaGetValues(frame, XmNwidth, &frame_width, NULL);
3381   XtVaGetValues(menu, XmNwidth, &menu_width, NULL);
3382
3383   XtVaSetValues(menu, XmNleftOffset, frame_width/2 - menu_width/2,
3384                 NULL);
3385 }