cde/programs/dtcm/dtcm/props_pu.c

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