home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / editordialogs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  397.5 KB  |  13,501 lines
  1. /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. /* 
  20.  *
  21.  *  editordialogs.c --- Editor-specific dialogs.
  22.  *  Should only be built for the editor.
  23.  *  Created: David Williams <djw@netscape.com>, Mar-12-1996
  24.  *
  25.  *  RCSID: "$Id: editordialogs.c,v 3.1 1998/03/28 03:20:03 ltabb Exp $"
  26.  */
  27.  
  28. #include "mozilla.h"
  29. #include "xfe.h"
  30. #include <X11/keysym.h>   /* for editor key translation */
  31. #include <XmL/Folder.h>   /* tab folder stuff */
  32. #include <Xm/Label.h> 
  33. #include <Xm/DrawnB.h> 
  34. #include <Xm/XmP.h>       /* required for _XmFontListGetDefaultFont() */
  35. #include "DtWidgets/ComboBox.h"
  36. #include <xpgetstr.h>     /* for XP_GetString() */
  37.  
  38. #include <Xfe/Xfe.h>        /* for xfe widgets and utilities */
  39.  
  40. #ifdef EDITOR
  41.  
  42. #include "edttypes.h"
  43. #include "edt.h"
  44. #include "menu.h"
  45. #include "xeditor.h"
  46. #include "il_icons.h"           /* Image icon enumeration. */
  47. #include "prefapi.h"   /* Need some publishing prefs for EDT_PublishFile */
  48. #include "felocale.h"
  49.  
  50. /* no security btn on prefs
  51. #define _SECURITY_BTN_ON_PREFS
  52. */
  53.  
  54. /*
  55.  *    I don't like this "fix" for MAXPATHLEN, but I cannot log onto
  56.  *    a SCO machine to find the right way to do this...djw
  57.  */
  58. #ifdef SCO_SV
  59. #include "mcom_db.h"    /* for MAXPATHLEN */
  60. #endif
  61.  
  62. void fe_browse_file_of_text (MWContext *context, Widget text_field, Boolean dirp);
  63.  
  64. extern int XFE_ERROR_SAVING_OPTIONS;
  65. extern int XFE_VALUES_OUT_OF_RANGE;
  66. extern int XFE_VALUE_OUT_OF_RANGE;
  67. extern int XFE_EDITOR_TABLE_ROW_RANGE;
  68. extern int XFE_EDITOR_TABLE_COLUMN_RANGE;
  69. extern int XFE_EDITOR_TABLE_BORDER_RANGE;
  70. extern int XFE_EDITOR_TABLE_SPACING_RANGE;
  71. extern int XFE_EDITOR_TABLE_PADDING_RANGE;
  72. extern int XFE_EDITOR_TABLE_WIDTH_RANGE;
  73. extern int XFE_EDITOR_TABLE_HEIGHT_RANGE;
  74. extern int XFE_EDITOR_TABLE_IMAGE_WIDTH_RANGE;
  75. extern int XFE_EDITOR_TABLE_IMAGE_HEIGHT_RANGE;
  76. extern int XFE_EDITOR_TABLE_IMAGE_SPACE_RANGE;
  77. extern int XFE_ENTER_NEW_VALUE;
  78. extern int XFE_ENTER_NEW_VALUES;
  79. extern int XFE_EDITOR_LINK_TEXT_LABEL_NEW;
  80. extern int XFE_EDITOR_LINK_TEXT_LABEL_IMAGE;
  81. extern int XFE_EDITOR_LINK_TEXT_LABEL_TEXT;
  82. extern int XFE_EDITOR_LINK_TARGET_LABEL_NO_TARGETS;
  83. extern int XFE_EDITOR_LINK_TARGET_LABEL_SPECIFIED;
  84. extern int XFE_EDITOR_LINK_TARGET_LABEL_CURRENT;
  85. extern int XFE_EDITOR_WARNING_REMOVE_LINK;
  86. extern int XFE_UNKNOWN;
  87. extern int XFE_EDITOR_TAG_UNOPENED;
  88. extern int XFE_EDITOR_TAG_UNCLOSED;
  89. extern int XFE_EDITOR_TAG_UNTERMINATED_STRING;
  90. extern int XFE_EDITOR_TAG_PREMATURE_CLOSE;
  91. extern int XFE_EDITOR_TAG_TAGNAME_EXPECTED;
  92. extern int XFE_EDITOR_TAG_UNKNOWN;
  93. extern int XFE_EDITOR_TAG_OK;
  94. extern int XFE_EDITOR_AUTOSAVE_PERIOD_RANGE;
  95. extern int XFE_EDITOR_PUBLISH_LOCATION_INVALID;
  96. extern int XFE_EDITOR_IMAGE_IS_REMOTE;
  97. extern int XFE_CANNOT_READ_FILE;
  98.  
  99. #define TABLE_MAX_ROWS 100
  100. #define TABLE_MIN_ROWS 1
  101. #define TABLE_MAX_COLUMNS 100
  102. #define TABLE_MIN_COLUMNS 1
  103. #define TABLE_MAX_BORDER 10000
  104. #define TABLE_MIN_BORDER 0
  105. #define TABLE_MAX_SPACING 10000
  106. #define TABLE_MIN_SPACING 0
  107. #define TABLE_MAX_PADDING 10000
  108. #define TABLE_MIN_PADDING 0
  109. #define TABLE_MAX_PIXEL_WIDTH  10000
  110. #define TABLE_MIN_PIXEL_WIDTH  1
  111. #define TABLE_MAX_PERCENT_WIDTH 100
  112. #define TABLE_MIN_PERCENT_WIDTH 1
  113. #define TABLE_MAX_PIXEL_HEIGHT  10000
  114. #define TABLE_MIN_PIXEL_HEIGHT  1
  115. #define TABLE_MAX_PERCENT_HEIGHT 100
  116. #define TABLE_MIN_PERCENT_HEIGHT 1
  117. #define TABLE_MAX_CELL_NROWS 100
  118. #define TABLE_MIN_CELL_NROWS 1
  119. #define TABLE_MAX_CELL_NCOLUMNS 100
  120. #define TABLE_MIN_CELL_NCOLUMNS 1
  121.  
  122. #define IMAGE_MIN_WIDTH  1
  123. #define IMAGE_MAX_WIDTH  10000
  124. #define IMAGE_MIN_HEIGHT 1
  125. #define IMAGE_MAX_HEIGHT 10000
  126. #define IMAGE_MIN_HSPACE 0
  127. #define IMAGE_MAX_HSPACE 10000
  128. #define IMAGE_MIN_VSPACE 0
  129. #define IMAGE_MAX_VSPACE 10000
  130. #define IMAGE_MIN_BORDER 0
  131. #define IMAGE_MAX_BORDER 10000
  132.  
  133. #define HRULE_MIN_HEIGHT 1
  134. #define HRULE_MAX_HEIGHT 10000
  135. #define HRULE_MAX_PIXEL_WIDTH  10000
  136. #define HRULE_MIN_PIXEL_WIDTH  1
  137. #define HRULE_MAX_PERCENT_WIDTH 100
  138. #define HRULE_MIN_PERCENT_WIDTH 1
  139.  
  140. #define AUTOSAVE_MIN_PERIOD 0
  141. #define AUTOSAVE_MAX_PERIOD 600
  142.  
  143. #define RANGE_CHECK(o, a, b) ((o) < (a) || (o) > (b))
  144.  
  145. #define XFE_INVALID_TABLE_NROWS     1
  146. #define XFE_INVALID_TABLE_NCOLUMNS  2
  147. #define XFE_INVALID_TABLE_BORDER    3
  148. #define XFE_INVALID_TABLE_SPACING   4
  149. #define XFE_INVALID_TABLE_PADDING   5
  150. #define XFE_INVALID_TABLE_WIDTH     6
  151. #define XFE_INVALID_TABLE_HEIGHT    7
  152. #define XFE_INVALID_CELL_NROWS      8
  153. #define XFE_INVALID_CELL_NCOLUMNS   9
  154. #define XFE_INVALID_CELL_WIDTH      10
  155. #define XFE_INVALID_CELL_HEIGHT     11
  156.  
  157. #define XFE_INVALID_IMAGE_WIDTH     12
  158. #define XFE_INVALID_IMAGE_HEIGHT    13
  159. #define XFE_INVALID_IMAGE_HSPACE    14
  160. #define XFE_INVALID_IMAGE_VSPACE    15
  161. #define XFE_INVALID_IMAGE_BORDER    16
  162.  
  163. #define XFE_INVALID_HRULE_WIDTH     17
  164. #define XFE_INVALID_HRULE_HEIGHT    18
  165.  
  166. static void
  167. fe_error_dialog(MWContext* context, Widget parent, char* s)
  168. {
  169.     while (!XtIsWMShell(parent) && (XtParent(parent)!=0))
  170.         parent = XtParent(parent);
  171.  
  172.     fe_dialog(parent, "error", s, FALSE, 0, FALSE, FALSE, 0);
  173. }
  174.  
  175. static void
  176. fe_message_dialog(MWContext* context, Widget parent, char* s)
  177. {
  178.     Widget mainw;
  179.  
  180.     while (!XtIsWMShell(parent) && (XtParent(parent)!=0))
  181.         parent = XtParent(parent);
  182.  
  183.     /* yuck */
  184.     mainw = CONTEXT_WIDGET(context);
  185.     CONTEXT_WIDGET(context) = parent;
  186.  
  187.     fe_Message(context, s);
  188.  
  189.     CONTEXT_WIDGET(context) = mainw;
  190. }
  191.  
  192. static void
  193. fe_editor_range_error_dialog(MWContext* context, Widget parent,
  194.                              unsigned* errors, unsigned nerrors)
  195. {
  196.     unsigned i;
  197.     int      id;
  198.     char     be_lazy[8192];
  199.  
  200.     if (nerrors > 1)
  201.         id = XFE_VALUES_OUT_OF_RANGE; /* Some values are out of range: */
  202.     else if (nerrors == 1)
  203.         id = XFE_VALUE_OUT_OF_RANGE; /* The following value is out of range: */
  204.     else
  205.         return;
  206.  
  207.     strcpy(be_lazy, XP_GetString(id));
  208.     strcat(be_lazy, "\n\n");
  209.  
  210.     for (i = 0; i < nerrors; i++) {
  211.         switch (errors[i]) {
  212.         case XFE_INVALID_TABLE_NROWS:
  213.         case XFE_INVALID_CELL_NROWS:
  214.             id = XFE_EDITOR_TABLE_ROW_RANGE;
  215.             /* You can have between 1 and 100 rows. */
  216.             break;
  217.         case XFE_INVALID_TABLE_NCOLUMNS:
  218.         case XFE_INVALID_CELL_NCOLUMNS:
  219.             id = XFE_EDITOR_TABLE_COLUMN_RANGE;
  220.             /* You can have between 1 and 100 columns. */
  221.             break;
  222.         case XFE_INVALID_TABLE_BORDER:
  223.             id = XFE_EDITOR_TABLE_BORDER_RANGE;
  224.             /* For border width, you can have 0 to 10000 pixels. */
  225.             break;
  226.         case XFE_INVALID_TABLE_SPACING:
  227.             id = XFE_EDITOR_TABLE_SPACING_RANGE;
  228.             /* For cell spacing, you can have 0 to 10000 pixels. */
  229.             break;
  230.         case XFE_INVALID_TABLE_PADDING:
  231.             id = XFE_EDITOR_TABLE_PADDING_RANGE;
  232.             /* For cell padding, you can have 0 to 10000 pixels. */
  233.             break;
  234.         case XFE_INVALID_TABLE_WIDTH:
  235.         case XFE_INVALID_CELL_WIDTH:
  236.         case XFE_INVALID_HRULE_WIDTH:
  237.             id = XFE_EDITOR_TABLE_WIDTH_RANGE;
  238.             /* For width, you can have between 1 and 10000 pixels, */
  239.             /* or between 1 and 100%.                              */
  240.             break;
  241.         case XFE_INVALID_TABLE_HEIGHT:
  242.         case XFE_INVALID_CELL_HEIGHT:
  243.             id = XFE_EDITOR_TABLE_HEIGHT_RANGE;
  244.             /* For height, you can have between 1 and 10000 pixels, */
  245.             /* or between 1 and 100%.                               */
  246.             break;
  247.         case XFE_INVALID_IMAGE_WIDTH:
  248.             id = XFE_EDITOR_TABLE_IMAGE_WIDTH_RANGE;
  249.             /* For width, you can have between 1 and 10000 pixels. */
  250.             break;
  251.         case XFE_INVALID_IMAGE_HEIGHT:
  252.         case XFE_INVALID_HRULE_HEIGHT:
  253.             id = XFE_EDITOR_TABLE_IMAGE_HEIGHT_RANGE;
  254.             /* For height, you can have between 1 and 10000 pixels. */
  255.             break;
  256.         case XFE_INVALID_IMAGE_HSPACE:
  257.         case XFE_INVALID_IMAGE_VSPACE:
  258.         case XFE_INVALID_IMAGE_BORDER:
  259.             id = XFE_EDITOR_TABLE_IMAGE_SPACE_RANGE;
  260.             /* For space, you can have between 1 and 10000 pixels. */
  261.             break;
  262.         }
  263.  
  264.         strcat(be_lazy, XP_GetString(id));
  265.         strcat(be_lazy, "\n");
  266.     }
  267.  
  268.     if (nerrors > 1) {
  269.         id = XFE_ENTER_NEW_VALUES;
  270.         /* Please enter new values and try again. */
  271.     } else if (nerrors == 1) {
  272.         id = XFE_ENTER_NEW_VALUE;
  273.         /* Please enter a new value and try again. */
  274.     }
  275.  
  276.     strcat(be_lazy, "\n");
  277.     strcat(be_lazy, XP_GetString(id));
  278.  
  279.     fe_error_dialog(context, parent, be_lazy);
  280. }
  281.  
  282. #endif  /* EDITOR */
  283.  
  284. Widget
  285. fe_CreateTabForm(Widget parent, char* name, Arg* args, Cardinal n)
  286. {
  287.     Widget form;
  288.     Widget tab;
  289.     Pixel  bg;
  290.     char*    string;
  291.     XmString xm_string;
  292.  
  293.     XtVaGetValues(parent, XmNbackground, &bg, 0);
  294.     form = XtVaCreateWidget(name, xmFormWidgetClass, parent, XmNbackground, bg, NULL);
  295.  
  296.     string = XfeSubResourceGetWidgetStringValue(form, "tabLabelString", XmCXmString);
  297.     if (!string)
  298.         string = name;
  299.     xm_string = XmStringCreateSimple(string);
  300.     tab = XmLFolderAddTab(parent, xm_string);
  301.     XtVaSetValues(tab, XmNtabManagedWidget, form, NULL);
  302.  
  303.     return form;
  304. }
  305.  
  306. #ifdef EDITOR
  307.  
  308. void
  309. fe_WidgetSetSensitive(Widget widget, Boolean sensitive)
  310. {
  311.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  312. }
  313.  
  314. #define SWATCH_SIZE 60
  315.  
  316. Widget
  317. fe_CreateSwatch(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  318. {
  319.     return XmCreateDrawnButton(parent, name, p_args, p_n);
  320. }
  321.  
  322. void
  323. fe_SwatchSetSensitive(Widget widget, Boolean sensitive)
  324. {
  325.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  326. }
  327.  
  328. #endif  /* EDITOR */
  329.  
  330. void
  331. fe_SwatchSetColor(Widget widget, LO_Color* color)
  332. {
  333.     MWContext* context = fe_WidgetToMWContext(widget);
  334.     Pixel      pixel;
  335.  
  336.     if (color != NULL) {
  337.         pixel = fe_GetPixel(context, color->red, color->green, color->blue);
  338.     } else {
  339.         XtVaGetValues(XtParent(widget), XmNbackground, &pixel, 0);
  340.     }
  341.     
  342.     XtVaSetValues(widget, XmNbackground, pixel, 0);
  343. }
  344.  
  345. #ifdef EDITOR
  346.  
  347. Widget
  348. fe_CreatePasswordField(Widget parent, char* name, Arg* args, Cardinal n)
  349. {
  350.     Widget widget;
  351.     int    max_length;
  352.  
  353.     widget = fe_CreateTextField(parent, name, args, n);
  354.  
  355.     XtVaGetValues(widget, XmNmaxLength, &max_length, 0);
  356.  
  357.     fe_SetupPasswdText(widget, max_length);
  358.  
  359.     return widget;
  360. }
  361.  
  362. #endif  /* EDITOR */
  363.  
  364. void
  365. fe_TextFieldSetString(Widget widget, char* value, Boolean notify)
  366. {
  367.     XtCallbackRec buf[32]; /* hope that's enough! */
  368.     XtCallbackList callbacks;
  369.     int i;
  370.     if (notify == FALSE) {
  371.         XtVaGetValues(widget, XmNvalueChangedCallback, &callbacks, 0);
  372.         for (i = 0; callbacks[i].callback != NULL; i++) {
  373.             buf[i] = callbacks[i];
  374.         }
  375.         buf[i].callback = NULL;
  376.         buf[i].closure = NULL;
  377.         
  378.         XtRemoveAllCallbacks(widget, XmNvalueChangedCallback);
  379.     }
  380.     fe_SetTextFieldAndCallBack(widget, value);
  381.     if (notify == FALSE) {
  382.         XtAddCallbacks(widget, XmNvalueChangedCallback, buf);
  383.     }
  384. }
  385.  
  386. #ifdef EDITOR
  387.  
  388. static char*
  389. fe_TextFieldGetString(Widget widget)
  390. {
  391.     return fe_GetTextField(widget);
  392. }
  393.  
  394. static Pixel
  395. fe_get_text_field_background(Widget widget)
  396. {
  397.     return XfeSubResourceGetPixelValue(widget,
  398.                                        XtName(widget),
  399.                                        XfeClassNameForWidget(widget),
  400.                                        XmNbackground,
  401.                                        XmCBackground,
  402.                                        WhitePixelOfScreen(XtScreen(widget)));
  403. }
  404.  
  405. void
  406. fe_TextFieldSetEditable(MWContext* context, Widget widget, Boolean editable)
  407. {
  408.     Pixel bg_pixel;
  409.     Arg   args[16];
  410.     Cardinal n;
  411.  
  412.     /*
  413.      *    The TextField is so losing, it doesn't set the
  414.      *    background color to indicate the field is not-editable.
  415.      *    The Gods of Motif style say thou shalt bestow unto thine
  416.      *    non-editable TextField thine color of select color-ness.
  417.      *
  418.      *    Hmmm this looks butt ugly, maybe have to use a label instead.
  419.      */
  420.     if (editable) {
  421.         bg_pixel = fe_get_text_field_background(widget);
  422.     } else {
  423.         n = 0;
  424.         XtSetArg(args[n], XmNbackground, &bg_pixel); n++;
  425.         XtGetValues(XtParent(widget), args, n);
  426.  
  427. #if 0
  428.         /* use select color as background color */
  429.         XmGetColors(XtScreen(widget), fe_cmap(context),
  430.                     bg_pixel,
  431.                     NULL, /* foreground */
  432.                     NULL, /* top shadow */
  433.                     NULL, /* bottom shadow */
  434.                     &select_pixel);
  435.  
  436.         bg_pixel = select_pixel;
  437. #endif
  438.     }
  439.  
  440.     n = 0;
  441.     XtSetArg(args[n], XmNeditable, editable); n++;
  442.     XtSetArg(args[n], XmNcursorPositionVisible, editable); n++;
  443.     XtSetArg(args[n], XmNtraversalOn, editable); n++;
  444.     XtSetArg(args[n], XmNbackground, bg_pixel); n++;
  445.     XtSetValues(widget, args, n);
  446. }
  447.  
  448. Widget
  449. fe_CreateFrame(Widget parent, char* name,  Arg* p_args, Cardinal p_n)
  450. {
  451.     Widget   frame;
  452.     Widget   title;
  453.     char     namebuf[256];
  454.     Arg      args[16];
  455.     Cardinal n;
  456.  
  457.     for (n = 0; n < p_n; n++) {
  458.     XtSetArg(args[n], p_args[n].name, p_args[n].value);
  459.     }
  460.  
  461.     strcpy(namebuf, name);
  462.     strcat(namebuf, "Frame");
  463.  
  464.     XtSetArg(args[n], XmNshadowType, XmSHADOW_ETCHED_IN); n++;
  465.     frame = XmCreateFrame(parent, namebuf, args, n);
  466.     XtManageChild(frame);
  467.  
  468.     strcpy(namebuf, name);
  469.     strcat(namebuf, "Title");
  470.  
  471.     n = 0;
  472.     XtSetArg(args[n], XmNlabelType, XmSTRING); n++;
  473.     XtSetArg(args[n], XmNchildType, XmFRAME_TITLE_CHILD); n++;
  474.     XtSetArg(args[n], XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING); n++;
  475.     XtSetArg(args[n], XmNchildVerticalAlignment, XmALIGNMENT_CENTER); n++;
  476.     title = XmCreateLabelGadget(frame, namebuf, args, n);
  477.     XtManageChild(title);
  478.  
  479.     return frame;
  480. }
  481.  
  482. Widget
  483. fe_CreateFramedForm(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  484. {
  485.     Widget   frame;
  486.     Widget   form;
  487.     Arg      args[16];
  488.     Cardinal n;
  489.  
  490.     n = 0;
  491.     frame = fe_CreateFrame(parent, name, args, n);
  492.     XtManageChild(frame);
  493.  
  494.     for (n = 0; n < p_n; n++) {
  495.     XtSetArg(args[n], p_args[n].name, p_args[n].value);
  496.     }
  497.  
  498.     form = XmCreateForm(frame, name, args, n);
  499.  
  500.     return form;
  501. }
  502.  
  503. Widget
  504. fe_CreateFramedRowColumn(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  505. {
  506.     Widget   frame;
  507.     Widget   rowcol;
  508.     Arg      args[16];
  509.     Cardinal n;
  510.  
  511.     n = 0;
  512.     frame = fe_CreateFrame(parent, name, args, n);
  513.     XtManageChild(frame);
  514.  
  515.     for (n = 0; n < p_n; n++) {
  516.     XtSetArg(args[n], p_args[n].name, p_args[n].value);
  517.     }
  518.     rowcol = XmCreateRowColumn(frame, name, args, n);
  519.  
  520.     return rowcol;
  521. }
  522.  
  523. static Widget
  524. fe_CreateToggleButtonGadget(Widget parent, char* name,
  525.                 Arg* p_args, Cardinal p_nargs)
  526. {
  527.     Arg      args[16];
  528.     Cardinal n = 0;
  529.     Widget   widget;
  530.  
  531.     for (n = 0; n < p_nargs; n++) {
  532.     XtSetArg(args[n], p_args[n].name, p_args[n].value); n++;
  533.     }
  534.  
  535.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  536.     widget = XmCreateToggleButtonGadget(parent, name, args, n);
  537.     return widget;
  538. }
  539.  
  540.  
  541. static Widget
  542. fe_CreateRadioButtonGadget(Widget parent, char* name,
  543.                 Arg* p_args, Cardinal p_nargs)
  544. {
  545.     Arg      args[16];
  546.     Cardinal n = 0;
  547.     Widget   widget;
  548.  
  549.     for (n = 0; n < p_nargs; n++) {
  550.     XtSetArg(args[n], p_args[n].name, p_args[n].value); n++;
  551.     }
  552.  
  553.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  554.     widget = XmCreateToggleButtonGadget(parent, name, args, n);
  555.     return widget;
  556. }
  557.  
  558. #endif  /* EDITOR */
  559.  
  560. Widget
  561. fe_CreatePulldownMenu(Widget parent, char* name, Arg* p_argv, Cardinal p_argc)
  562. {
  563.   unsigned i;
  564.   Widget   popup_menu;
  565.   Arg      argv[8];
  566.   Cardinal argc;
  567.   Visual*  v = 0;
  568.   Colormap cmap = 0;
  569.   Cardinal depth = 0;
  570.   Widget   widget;
  571.  
  572.   XtCallbackRec* button_callback_rec = NULL;
  573.  
  574.   for (i = 0; i < p_argc; i++) {
  575.       if (p_argv[i].name == XmNactivateCallback)
  576.       button_callback_rec = (XtCallbackRec*)p_argv[i].value;
  577.   }
  578.  
  579.   for (widget = parent; !XtIsWMShell(widget); widget = XtParent(widget))
  580.       ;
  581.  
  582.   XtVaGetValues(widget, XtNvisual, &v, XtNcolormap, &cmap,
  583.     XtNdepth, &depth, 0);
  584.  
  585.   argc = 0;
  586.   XtSetArg (argv[argc], XmNvisual, v); argc++;
  587.   XtSetArg (argv[argc], XmNdepth, depth); argc++;
  588.   XtSetArg (argv[argc], XmNcolormap, cmap); argc++;
  589.  
  590.   popup_menu = XmCreatePulldownMenu(parent, name, argv, argc);
  591.  
  592.   return popup_menu;
  593. }
  594.  
  595. #ifdef EDITOR
  596.  
  597. static Widget
  598. fe_CreateOptionMenuNoLabel(Widget widget, char* name, Arg* args, Cardinal n)
  599. {
  600.     Widget menu = fe_CreateOptionMenu(widget, name, args, n);
  601.     fe_UnmanageChild_safe(XmOptionLabelGadget(menu));
  602.     return menu;
  603. }
  604.  
  605. /*
  606.  *    This dialog builder stuff was a wishful attempt at doing declarative
  607.  *    dialogs for XFE. I only got as far as using them for the simplest of
  608.  *    dialogs - the Horizontal Rule pref dialog. That's all that uses it,
  609.  *    so it could be ripped and replaced by some simple code for that dialog.
  610.  *    We really should spend the time to do some kind of easier dialog
  611.  *    builder for XFE. One day....djw
  612.  */
  613. typedef struct fe_DialogBuilderCreator {
  614.     char*   name;
  615.     Widget (*func)(Widget parent, char* name, ArgList args, Cardinal argcount);
  616.     Boolean recurse;
  617. } fe_DialogBuilderCreator;
  618.  
  619. static char XFE_DB_PUSHBUTTONGADGET[] = "XmPushButtonGadget";
  620. static char XFE_DB_LABELGADGET[] = "XmLabelGadget";
  621. static char XFE_DB_FRAME[] = "XmFrame";
  622. static char XFE_DB_FORM[] = "XmForm";
  623. static char XFE_DB_TEXTFIELD[] = "XmTextField";
  624. static char XFE_DB_OPTIONMENU[] = "XmOptionMenu";
  625. static char XFE_DB_PULLDOWNMENU[] = "fe_PulldownMenu";
  626. static char XFE_DB_ROWCOL[] = "XmRowColumn";
  627. static char XFE_DB_FRAMEDFORM[] = "fe_FramedForm";
  628. static char XFE_DB_TOGGLEGADGET[] = "fe_ToggleButtonGadget";
  629. static char XFE_DB_RADIOGADGET[] = "fe_RadioButtonGadget";
  630. static char XFE_DB_FRAMEDROWCOL[] = "fe_FramedRowCol";
  631.  
  632. static fe_DialogBuilderCreator fe_DialogBuilderDefaultCreators[] = {
  633.     { XFE_DB_PUSHBUTTONGADGET, XmCreatePushButtonGadget, FALSE },
  634.     { XFE_DB_LABELGADGET, XmCreateLabelGadget, FALSE },
  635.     { XFE_DB_TEXTFIELD, fe_CreateTextField, FALSE },
  636.     { XFE_DB_TOGGLEGADGET, fe_CreateToggleButtonGadget, FALSE },
  637.     { XFE_DB_RADIOGADGET, fe_CreateRadioButtonGadget, FALSE },
  638.  
  639.     { XFE_DB_FRAME, XmCreateFrame, TRUE },
  640.     { XFE_DB_FORM, XmCreateForm, TRUE },
  641.     { XFE_DB_PULLDOWNMENU, fe_CreatePulldownMenu, TRUE },
  642.     { XFE_DB_OPTIONMENU, fe_CreateOptionMenuNoLabel, FALSE },
  643.     { XFE_DB_ROWCOL, XmCreateRowColumn, TRUE },
  644.     { XFE_DB_FRAMEDFORM, fe_CreateFramedForm, TRUE },
  645.     { XFE_DB_FRAMEDROWCOL, fe_CreateFramedRowColumn, TRUE },
  646.     { 0 }
  647. };
  648.  
  649. static char XFE_DB_END[] = "end";
  650. static char XFE_DB_PUSH[] = "push";
  651. static char XFE_DB_POP[] = "pop";
  652. static char XFE_DB_WIDGETCALLED[] = "widgetcalled";
  653. static char XFE_DB_WIDEST[] = "widest";
  654. static char XFE_DB_TALLEST[] = "tallest";
  655. static char XFE_DB_SETVAL[] = "setval";
  656. static char XFE_DB_SETDATA[] = "setdata";
  657. static char XFE_DB_SETVALCALLED[] = "setvalcalled";
  658. static char XFE_DB_CALLBACK[] = "callback";
  659.  
  660. typedef struct fe_DialogBuilderArg {
  661.     char*     name;
  662.     XtPointer value;
  663. } fe_DialogBuilderArg;
  664.  
  665.  
  666. static fe_DialogBuilderCreator*
  667. find_creator(fe_DialogBuilderCreator* creators, char* name)
  668. {
  669.  
  670.     int i;
  671.     
  672.     for (i = 0; creators[i].name; i++) {
  673.     if (creators[i].name == name || strcmp(creators[i].name, name) == 0)
  674.         return &creators[i];
  675.     }
  676.     return NULL;
  677. }
  678.  
  679. Widget
  680. db_do_work(
  681.        MWContext* context,
  682.        Widget parent,
  683.        fe_DialogBuilderCreator* creators,
  684.        fe_DialogBuilderArg** instructions_a,
  685.        void* data)
  686. {
  687. #define MACHINE_NARGS     16
  688. #define MACHINE_NSTACK    16
  689. #define MACHINE_NCALLBACK 16
  690. #define MACHINE_NWIDGETS  32
  691.     Arg           args[MACHINE_NARGS];
  692.     XtPointer     stack[MACHINE_NSTACK];
  693.     XtCallbackRec callbacks[MACHINE_NCALLBACK];
  694.     Cardinal      stackposn;
  695. #define POP()   (stack[--stackposn])
  696. #define PUSH(x) (stack[stackposn++] = (XtPointer)(x))
  697.     Cardinal      nargs;
  698.     Cardinal      ncallbacks;
  699.     Widget        children[MACHINE_NWIDGETS];
  700.     Cardinal      nchildren;
  701.     char*         name;
  702.     XtPointer     value;
  703.     Dimension     width;
  704.     Dimension     max_width;
  705.     Dimension     height;
  706.     Dimension     max_height;
  707.     Widget widget = NULL;
  708.     Widget max_widget;
  709.     int i;
  710.     fe_DialogBuilderCreator* creator;
  711.  
  712.     nargs = 0;
  713.     stackposn = 0;
  714.     ncallbacks = 0;
  715.     nchildren = 0;
  716.  
  717.     for (; (*instructions_a)->name != XFE_DB_END; (*instructions_a)++) {
  718.     name = (*instructions_a)->name;
  719.     value = (*instructions_a)->value;
  720.  
  721.     if (value == (XtPointer)XFE_DB_POP) /* pop is only ever a value */
  722.         value = POP();
  723.  
  724.     if (name == XFE_DB_PUSH) {
  725.         /* push is only ever a name */
  726.         PUSH(value);
  727.     } else if (name == XFE_DB_WIDGETCALLED) {
  728.         for (i = 0; i < nchildren; i++) {
  729.         if (strcmp(XtName(children[i]), (char*)value) == 0) {
  730.             PUSH(children[i]);
  731.             break;
  732.         }
  733.         }
  734.         XP_ASSERT(i < nchildren);
  735.     } else if (name == XFE_DB_WIDEST) {
  736.         max_width = 0;
  737.         max_widget = 0;
  738.         for (i = 0; i < (unsigned)value; i++) {
  739.         widget = (Widget)POP();
  740.         XtVaGetValues(widget, XtNwidth, &width, 0);
  741.         if (width > max_width) {
  742.             max_width = width;
  743.             max_widget = widget;
  744.         }
  745.         }
  746.         PUSH(max_widget);
  747.     } else if (name == XFE_DB_TALLEST) {
  748.         max_height = 0;
  749.         max_widget = 0;
  750.         for (i = 0; i < (unsigned)value; i++) {
  751.         widget = (Widget)POP();
  752.         XtVaGetValues(widget, XtNheight, &height, 0);
  753.         if (height > max_height) {
  754.             max_height = height;
  755.             max_widget = widget;
  756.         }
  757.         }
  758.         PUSH(max_widget);
  759.     } else if (name == XFE_DB_SETVAL) {
  760.         widget = (Widget)POP();
  761.         XtSetValues(widget, args, nargs);
  762.         nargs = 0;
  763.     } else if (name == XFE_DB_SETVALCALLED) {
  764.         for (i = 0; i < nchildren; i++) {
  765.         if (strcmp(XtName(children[i]), (char*)value) == 0) {
  766.             XtSetValues(children[i], args, nargs);
  767.             nargs = 0;
  768.             break;
  769.         }
  770.         }
  771.         XP_ASSERT(i < nchildren);
  772.     } else if (name == XFE_DB_SETDATA) {
  773.         Widget* foo = (Widget*)(((char*) data) + (int) (value));
  774.         *foo = (Widget)POP();
  775.     } else if (name == XFE_DB_CALLBACK) {
  776.         callbacks[ncallbacks].callback = (XtCallbackProc)POP();
  777.         callbacks[ncallbacks].closure = (XtPointer)POP();
  778.         PUSH(&callbacks[ncallbacks++]);
  779.  
  780.         /*
  781.          *    See if it's a creator.
  782.          */
  783.     } else if ((creator = find_creator(creators, name))) {
  784.  
  785.         widget = (*creator->func)(
  786.                      parent,
  787.                      (char*)value,
  788.                      args,
  789.                      nargs
  790.                      );
  791.         /*
  792.          *    Hack, hack, hack for menus which get managed by cascades.
  793.          */
  794.         if (creator->name != XFE_DB_PULLDOWNMENU)
  795.             XtManageChild(widget);
  796.         children[nchildren++] = widget;
  797.         nargs = 0;
  798.         /* if (XtIsSubclass(widget, compositeWidgetClass)) { */
  799.         if (creator->recurse) {
  800.         (*instructions_a)++;
  801.         db_do_work(
  802.                context,
  803.                widget,
  804.                creators,
  805.                instructions_a,
  806.                data);
  807.         /* call ourselves */
  808.         }
  809.     } else { 
  810.         /*
  811.          *    Must be an argument.
  812.          */
  813.         args[nargs].name = name;
  814.         args[nargs].value = (XtArgVal)value;
  815.         nargs++;
  816.     }
  817.     }
  818.  
  819. #if 0
  820.     XtManageChildren(children, nchildren);
  821. #endif
  822.  
  823.     return children[0];
  824. }
  825.  
  826. /*
  827.  *    Stuff for dialogs.
  828.  */
  829. typedef struct fe_HorizontalRulePropertiesDialogData {
  830.     MWContext* context;
  831.     Widget height;
  832.     Widget width;
  833.     Widget width_menu;
  834.     Widget width_units;
  835.     Widget width_pixels;
  836.     Widget width_percent;
  837.     Widget align_left;
  838.     Widget align_center;
  839.     Widget align_right;
  840.     Widget three_d_shading;
  841. } fe_HorizontalRulePropertiesDialogData;
  842.  
  843. /*
  844.  *    DB program to build Horizontal Rule properties Dialog.
  845.  */
  846. static fe_DialogBuilderArg fe_HorizontalRulePropertiesDialogProgram[] = {
  847.  
  848. #define OFFSET(x) XtOffset(fe_HorizontalRulePropertiesDialogData *, x)
  849.  
  850.     { XmNorientation, (XtPointer)XmVERTICAL },
  851.     { XFE_DB_ROWCOL, (XtPointer)"rowcol" },
  852.  
  853.         { XFE_DB_FRAMEDFORM, "dimensions" },
  854.             { XFE_DB_LABELGADGET, "heightLabel" },
  855.             { XFE_DB_TEXTFIELD, "heightText" },
  856.             { XFE_DB_LABELGADGET, "pixels" },
  857.             { XFE_DB_LABELGADGET, "widthLabel" },
  858.             { XFE_DB_TEXTFIELD, "widthText" },
  859.             { XFE_DB_PULLDOWNMENU, "widthUnitsPulldown" },
  860.                 { XFE_DB_PUSHBUTTONGADGET, "percent" },
  861.                 { XFE_DB_PUSHBUTTONGADGET, "pixels" },
  862.  
  863.                 { XFE_DB_WIDGETCALLED, "percent" },
  864.                  { XFE_DB_SETDATA, (XtPointer)OFFSET(width_percent) },
  865.                 { XFE_DB_WIDGETCALLED, "pixels" },
  866.                  { XFE_DB_SETDATA, (XtPointer)OFFSET(width_pixels) },
  867.  
  868.                 { XFE_DB_END, "widthUnitsPulldown" },
  869.             { XFE_DB_WIDGETCALLED, "widthUnitsPulldown" },
  870.             { XmNsubMenuId, XFE_DB_POP },
  871.             { XFE_DB_OPTIONMENU, "widthUnits" },
  872.  
  873.             /* now do computed attachments, oh boy, we need a compiler */
  874.             { XmNtopAttachment, (XtPointer)XmATTACH_FORM },
  875.             { XmNleftAttachment, (XtPointer)XmATTACH_FORM },
  876.             { XFE_DB_SETVALCALLED, "heightLabel" }, /* set heightLabel */
  877.  
  878.             { XmNtopAttachment, (XtPointer)XmATTACH_FORM },
  879.             { XmNleftAttachment, (XtPointer)XmATTACH_WIDGET },
  880.             { XFE_DB_WIDGETCALLED, "heightLabel" },
  881.             { XFE_DB_WIDGETCALLED, "widthLabel" },
  882.             { XFE_DB_WIDEST, (XtPointer)2 },
  883.             { XmNleftWidget, XFE_DB_POP },
  884.             { XFE_DB_SETVALCALLED, "heightText" }, /* set heightText */
  885.  
  886.             { XmNtopAttachment, (XtPointer)XmATTACH_FORM },
  887.             { XmNleftAttachment, (XtPointer)XmATTACH_WIDGET },
  888.             { XFE_DB_WIDGETCALLED, "heightText" },
  889.             { XmNleftWidget, XFE_DB_POP },
  890.             { XFE_DB_SETVALCALLED, "pixels" },     /* set pixel */
  891.  
  892.             { XmNtopAttachment, (XtPointer)XmATTACH_WIDGET },
  893.             { XFE_DB_WIDGETCALLED, "heightText" },
  894.             { XmNtopWidget, XFE_DB_POP },
  895.             { XmNleftAttachment, (XtPointer)XmATTACH_FORM },
  896.             { XFE_DB_SETVALCALLED, "widthLabel" }, /* set widthLabel */
  897.  
  898.             { XmNtopAttachment, (XtPointer)XmATTACH_WIDGET },
  899.             { XFE_DB_WIDGETCALLED, "heightText" },
  900.             { XmNtopWidget, XFE_DB_POP },
  901.             { XmNleftAttachment, (XtPointer)XmATTACH_WIDGET },
  902.             { XFE_DB_WIDGETCALLED, "heightLabel" },
  903.             { XFE_DB_WIDGETCALLED, "widthLabel" },
  904.             { XFE_DB_WIDEST, (XtPointer)2 },
  905.             { XmNleftWidget, XFE_DB_POP },
  906.             { XFE_DB_SETVALCALLED, "widthText" }, /* set widthText */
  907.  
  908.             { XmNtopAttachment, (XtPointer)XmATTACH_WIDGET },
  909.             { XFE_DB_WIDGETCALLED, "heightText" },
  910.             { XmNtopWidget, XFE_DB_POP },
  911.             { XmNleftAttachment, (XtPointer)XmATTACH_WIDGET },
  912.             { XFE_DB_WIDGETCALLED, "widthText" },
  913.             { XmNleftWidget, XFE_DB_POP },
  914. #if 0
  915.             { XmNrightAttachment, (XtPointer)XmATTACH_FORM },
  916. #endif
  917.             { XFE_DB_SETVALCALLED, "widthUnits" }, /* set widthUnits */
  918.  
  919.              /* do offsets */
  920.             { XFE_DB_WIDGETCALLED, "widthText" },
  921.              { XFE_DB_SETDATA, (XtPointer)OFFSET(width) },
  922.             { XFE_DB_WIDGETCALLED, "heightText" },
  923.              { XFE_DB_SETDATA, (XtPointer)OFFSET(height) },
  924.             { XFE_DB_WIDGETCALLED, "widthUnitsPulldown" },
  925.              { XFE_DB_SETDATA, (XtPointer)OFFSET(width_menu) },
  926.             { XFE_DB_WIDGETCALLED, "widthUnits" },
  927.              { XFE_DB_SETDATA, (XtPointer)OFFSET(width_units) },
  928.  
  929.             { XFE_DB_END, "dimensions" },
  930.  
  931.         { XmNorientation, (XtPointer)XmHORIZONTAL },
  932.         { XmNradioBehavior, (XtPointer)TRUE },
  933.         { XFE_DB_FRAMEDROWCOL, "align" },
  934.             { XFE_DB_RADIOGADGET, "left" },
  935.             { XFE_DB_RADIOGADGET, "center" },
  936.             { XFE_DB_RADIOGADGET, "right" },
  937.  
  938.             { XFE_DB_WIDGETCALLED, "left" },
  939.              { XFE_DB_SETDATA, (XtPointer)OFFSET(align_left) },
  940.             { XFE_DB_WIDGETCALLED, "center" },
  941.              { XFE_DB_SETDATA, (XtPointer)OFFSET(align_center) },
  942.             { XFE_DB_WIDGETCALLED, "right" },
  943.              { XFE_DB_SETDATA, (XtPointer)OFFSET(align_right) },
  944.  
  945.             { XFE_DB_END, "align" },
  946.         { XFE_DB_TOGGLEGADGET, "threeDShading" },
  947.  
  948.         { XFE_DB_WIDGETCALLED, "threeDShading" },
  949.         { XFE_DB_SETDATA, (XtPointer)OFFSET(three_d_shading) },
  950.  
  951.         { XFE_DB_END, "rowcol" },
  952.  
  953.      { XFE_DB_END, "program" }
  954.  
  955. #undef OFFSET
  956.  
  957. };
  958.  
  959. #endif  /* EDITOR */
  960.  
  961. Widget
  962. fe_CreatePromptDialog(MWContext *context, char* name,
  963.               Boolean ok, Boolean cancel, Boolean apply, Boolean separator, Boolean modal)
  964. {
  965.   Widget mainw = CONTEXT_WIDGET(context);
  966.   Widget dialog;
  967.   Visual *v = 0;
  968.   Colormap cmap = 0;
  969.   Cardinal depth = 0;
  970.   Arg av [20];
  971.   int ac;
  972.  
  973.   XtVaGetValues (mainw, XtNvisual, &v, XtNcolormap, &cmap,
  974.                  XtNdepth, &depth, 0);
  975.   ac = 0;
  976.   XtSetArg (av[ac], XmNvisual, v); ac++;
  977.   XtSetArg (av[ac], XmNdepth, depth); ac++;
  978.   XtSetArg (av[ac], XmNcolormap, cmap); ac++;
  979.   XtSetArg (av[ac], XmNallowShellResize, TRUE); ac++;
  980.   XtSetArg (av[ac], XmNtransientFor, mainw); ac++;
  981.   if (modal) {
  982.       XtSetArg (av[ac], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); ac++;
  983.   }
  984.   XtSetArg (av[ac], XmNdialogType, XmDIALOG_QUESTION); ac++;
  985.   XtSetArg (av[ac], XmNdeleteResponse, XmDESTROY); ac++;
  986.   XtSetArg (av[ac], XmNautoUnmanage, False); ac++;
  987.   XtSetArg (av[ac], XmNnoResize, True); ac++;
  988.  
  989.   dialog = XmCreatePromptDialog (mainw, name, av, ac);
  990.  
  991.   if (!separator)
  992.       fe_UnmanageChild_safe(XmSelectionBoxGetChild(dialog,
  993.                                                    XmDIALOG_SEPARATOR));
  994.  
  995.   fe_UnmanageChild_safe (XmSelectionBoxGetChild (dialog, XmDIALOG_TEXT));
  996.   fe_UnmanageChild_safe (XmSelectionBoxGetChild (dialog,
  997.                                                 XmDIALOG_SELECTION_LABEL));
  998.   if (!ok)
  999.       fe_UnmanageChild_safe (XmSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON));
  1000.   if (!cancel)
  1001.       fe_UnmanageChild_safe (XmSelectionBoxGetChild (dialog,
  1002.                              XmDIALOG_CANCEL_BUTTON));
  1003. #ifdef NO_HELP
  1004.   fe_UnmanageChild_safe (XmSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON));
  1005. #endif
  1006.  
  1007.   if (apply)
  1008.       XtManageChild (XmSelectionBoxGetChild (dialog, XmDIALOG_APPLY_BUTTON));
  1009.  
  1010.   return dialog;
  1011. }
  1012.  
  1013. #ifdef EDITOR
  1014.  
  1015. static int
  1016. fe_get_numeric_text_field(Widget widget)
  1017. {
  1018.     char* p = XmTextFieldGetString(widget); /* numeric so no JIS fix */
  1019.     char* q;
  1020.     if (p) {
  1021.         while (isspace(*p))
  1022.             p++;
  1023.         if (*p == '\0') return -1;
  1024.         for (q = p; *q != '\0'; q++) {
  1025.             if (!(isdigit(*q) || isspace(*q)))
  1026.                 return -1; /* force error */
  1027.         }
  1028.         return atoi(p);
  1029.     } else {
  1030.         return -1;
  1031.     }
  1032. }
  1033.  
  1034. static void
  1035. fe_editor_hrule_properties_common(MWContext* context,
  1036.                                   EDT_HorizRuleData* data,
  1037.                               fe_HorizontalRulePropertiesDialogData* w_data)
  1038. {
  1039.     Widget widget;
  1040.     
  1041.     /* height */
  1042.     data->size = fe_get_numeric_text_field(w_data->height);
  1043.  
  1044.     /* width */
  1045.     XtVaGetValues(w_data->width_menu, XmNmenuHistory, &widget, 0);
  1046.  
  1047.     if (widget == w_data->width_pixels)
  1048.         data->bWidthPercent = FALSE;
  1049.     else
  1050.         data->bWidthPercent = TRUE;
  1051.     data->iWidth = fe_get_numeric_text_field(w_data->width);
  1052.  
  1053.     /* align */
  1054.     if (XmToggleButtonGadgetGetState(w_data->align_right) == TRUE)
  1055.         data->align = ED_ALIGN_RIGHT;
  1056.     else  if (XmToggleButtonGadgetGetState(w_data->align_left) == TRUE)
  1057.         data->align = ED_ALIGN_LEFT;
  1058.     else
  1059.         data->align = ED_ALIGN_CENTER;
  1060.  
  1061.     /* shading */
  1062.     if (XmToggleButtonGadgetGetState(w_data->three_d_shading) == TRUE)
  1063.         data->bNoShade = FALSE;
  1064.     else
  1065.         data->bNoShade = TRUE;
  1066.  
  1067.     data->pExtra = 0;
  1068. }
  1069.  
  1070. static Boolean
  1071. fe_editor_hrule_properties_validate(MWContext* context,
  1072.                               fe_HorizontalRulePropertiesDialogData* w_data)
  1073. {
  1074.     EDT_HorizRuleData  data;
  1075.     EDT_HorizRuleData* h = &data;
  1076.     unsigned       errors[16];
  1077.     unsigned       nerrors = 0;
  1078.  
  1079.     fe_editor_hrule_properties_common(context, &data, w_data);
  1080.     
  1081.     if (RANGE_CHECK(h->size, HRULE_MIN_HEIGHT, HRULE_MAX_HEIGHT))
  1082.         errors[nerrors++] = XFE_INVALID_HRULE_HEIGHT;
  1083.  
  1084.     if (h->bWidthPercent == TRUE) {
  1085.         if (RANGE_CHECK(h->iWidth,
  1086.                         HRULE_MIN_PERCENT_WIDTH, HRULE_MAX_PERCENT_WIDTH))
  1087.             errors[nerrors++] = XFE_INVALID_HRULE_WIDTH;
  1088.     } else {
  1089.         if (RANGE_CHECK(h->iWidth,
  1090.                         HRULE_MIN_PIXEL_WIDTH, HRULE_MAX_PIXEL_WIDTH))
  1091.             errors[nerrors++] = XFE_INVALID_HRULE_WIDTH;
  1092.     }
  1093.  
  1094.     if (nerrors > 0) {
  1095.         fe_editor_range_error_dialog(context, w_data->width,
  1096.                                      errors, nerrors);
  1097.         return FALSE;
  1098.     }
  1099.  
  1100.     return TRUE;
  1101. }
  1102.  
  1103. static void
  1104. fe_HorizontalRulePropertiesDialogSet(MWContext* context,
  1105.                                  fe_HorizontalRulePropertiesDialogData* w_data)
  1106. {
  1107.     EDT_HorizRuleData e_data;
  1108.  
  1109.     EDT_BeginBatchChanges(context);
  1110.     fe_editor_hrule_properties_common(context, &e_data, w_data);
  1111.  
  1112.     e_data.pExtra = 0;
  1113.     
  1114.     fe_EditorHorizontalRulePropertiesSet(context, &e_data);
  1115.     EDT_EndBatchChanges(context);
  1116. }
  1117.  
  1118. static void
  1119. fe_table_percent_label_set(Widget widget, Boolean nested);
  1120.  
  1121. static void
  1122. fe_HorizontalRulePropertiesDialogDataGet(
  1123.                 MWContext* context,
  1124.                 fe_HorizontalRulePropertiesDialogData* w_data
  1125. )
  1126. {
  1127.     EDT_HorizRuleData e_data;
  1128.     char buf[16];
  1129.     Boolean left;
  1130.     Boolean center;
  1131.     Boolean right;
  1132.     Boolean shading;
  1133.     Widget widget;
  1134.     Boolean is_nested;
  1135.  
  1136.     fe_EditorHorizontalRulePropertiesGet(context, &e_data);
  1137.     
  1138.     /* height */
  1139.     sprintf(buf, "%d", e_data.size);
  1140.     fe_SetTextFieldAndCallBack(w_data->height, buf);
  1141.  
  1142.     /* width */
  1143.     sprintf(buf, "%d", e_data.iWidth);
  1144.     fe_SetTextFieldAndCallBack(w_data->width, buf);
  1145.  
  1146.     if (e_data.bWidthPercent)
  1147.         widget = w_data->width_percent;
  1148.     else
  1149.         widget = w_data->width_pixels;
  1150.  
  1151.     is_nested = EDT_IsInsertPointInTable(context);
  1152.     fe_table_percent_label_set(w_data->width_percent, is_nested);
  1153.  
  1154.     XtVaSetValues(w_data->width_units, XmNmenuHistory, widget, 0);
  1155.  
  1156.     /* align */
  1157.     if (e_data.align == ED_ALIGN_RIGHT) {
  1158.         left = FALSE;
  1159.         center = FALSE;
  1160.         right = TRUE;
  1161.     } else if (e_data.align == ED_ALIGN_LEFT) {
  1162.         left = TRUE;
  1163.         center = FALSE;
  1164.         right = FALSE;
  1165.     } else {
  1166.         left = FALSE;
  1167.         center = TRUE;
  1168.         right = FALSE;
  1169.     }
  1170.     XmToggleButtonGadgetSetState(w_data->align_right, right, FALSE);
  1171.     XmToggleButtonGadgetSetState(w_data->align_left, left, FALSE);
  1172.     XmToggleButtonGadgetSetState(w_data->align_center, center, FALSE);
  1173.  
  1174.     if (e_data.bNoShade)
  1175.         shading = FALSE;
  1176.     else
  1177.         shading = TRUE;
  1178.     XmToggleButtonGadgetSetState(w_data->three_d_shading, shading, FALSE);
  1179. }
  1180.  
  1181. Widget
  1182. fe_EditorHorizontalRulePropertiesCreate(
  1183.                   MWContext* context,
  1184.                   fe_HorizontalRulePropertiesDialogData* data
  1185.                   )
  1186. {
  1187.   fe_DialogBuilderArg* code;
  1188.   Widget dialog;
  1189.  
  1190.   /*
  1191.    *     Make shell.
  1192.    */
  1193.   dialog = fe_CreatePromptDialog(context, "horizontalLineProperties",
  1194.                    TRUE, TRUE, FALSE, TRUE, TRUE);
  1195.  
  1196.   /*
  1197.    *   Make the rowcol, because we want to manage it.
  1198.    */
  1199.   code = fe_HorizontalRulePropertiesDialogProgram;
  1200.  
  1201.   db_do_work(context, dialog,
  1202.               fe_DialogBuilderDefaultCreators,
  1203.               &code,
  1204.               data);
  1205.  
  1206.   return dialog;
  1207. }
  1208.  
  1209. static void
  1210. fe_hrule_destroy_cb (Widget widget, XtPointer closure, XtPointer call_data)
  1211. {
  1212.     int* done = (int*)closure;
  1213.  
  1214.     *done = XFE_DIALOG_DESTROY_BUTTON;
  1215. }
  1216.  
  1217. static void
  1218. fe_hrule_ok_cb (Widget widget, XtPointer closure, XtPointer call_data)
  1219. {
  1220.     int* done = (int*)closure;
  1221.  
  1222.     *done = XmDIALOG_OK_BUTTON;
  1223. }
  1224.  
  1225. static void
  1226. fe_hrule_apply_cb (Widget widget, XtPointer closure, XtPointer call_data)
  1227. {
  1228.     int* done = (int*)closure;
  1229.  
  1230.     *done = XmDIALOG_APPLY_BUTTON;
  1231. }
  1232.  
  1233. static void
  1234. fe_hrule_cancel_cb (Widget widget, XtPointer closure, XtPointer call_data)
  1235. {
  1236.     int* done = (int*)closure;
  1237.  
  1238.     *done = XmDIALOG_CANCEL_BUTTON;
  1239. }
  1240.  
  1241. void
  1242. fe_EditorHorizontalRulePropertiesDialogDo(MWContext* context)
  1243. {
  1244.     fe_HorizontalRulePropertiesDialogData widgets;
  1245.     int done;
  1246.     Widget dialog;
  1247.  
  1248. #if 0
  1249.     if (!fe_EditorHorizontalRulePropertiesCanDo(context)) {
  1250.         XBell(XtDisplay(CONTEXT_WIDGET(context)), 0);
  1251.         return;
  1252.     }
  1253. #endif
  1254.  
  1255.     dialog = fe_EditorHorizontalRulePropertiesCreate(context, &widgets);
  1256.  
  1257.     /*
  1258.      *   Add a bunch of callbacks to the buttons.
  1259.      */
  1260.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  1261.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  1262.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  1263.  
  1264.     /*
  1265.      *    Load values.
  1266.      */
  1267.     fe_HorizontalRulePropertiesDialogDataGet(context, &widgets);
  1268.     
  1269.     /*
  1270.      *    Popup.
  1271.      */
  1272.     XtManageChild(dialog);
  1273.  
  1274.     /*
  1275.      *    Wait.
  1276.      */
  1277.     fe_NukeBackingStore(dialog); /* what does this do? */
  1278.     done = XmDIALOG_NONE;
  1279.     while (done == XmDIALOG_NONE) {
  1280.         fe_EventLoop();
  1281.  
  1282.         /*
  1283.          *    Unload data.
  1284.          */
  1285.         if (done == XmDIALOG_OK_BUTTON
  1286.             &&
  1287.             !fe_editor_hrule_properties_validate(context, &widgets)) {
  1288.             done = XmDIALOG_NONE;
  1289.         }
  1290.     }
  1291.  
  1292.     if (done == XmDIALOG_OK_BUTTON)
  1293.         fe_HorizontalRulePropertiesDialogSet(context, &widgets);
  1294.  
  1295.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  1296.         XtDestroyWidget(dialog);
  1297. }
  1298.  
  1299. static void
  1300. fe_destroy_cleanup_cb(Widget widget, XtPointer closure, XtPointer cb)
  1301. {
  1302.     if (closure)
  1303.         XtFree(closure);
  1304. }
  1305.  
  1306. void
  1307. fe_DependentListAddDependent(fe_DependentList** list_a,
  1308.                       Widget widget, fe_Dependency mask,
  1309.                       XtCallbackProc proc, XtPointer closure)
  1310. {
  1311.     fe_DependentList* list = XtNew(fe_DependentList);
  1312.  
  1313.     list->next = *list_a;
  1314.     list->widget = widget;
  1315.     list->mask = mask;
  1316.     list->callback.callback = proc;
  1317.     list->callback.closure = closure;
  1318.  
  1319.     *list_a = list;
  1320. }
  1321.         
  1322. void
  1323. fe_DependentListDestroy(fe_DependentList* list)
  1324. {
  1325.     fe_DependentList* next;
  1326.  
  1327.     for (; list; list = next) {
  1328.         next = list->next;
  1329.         XtFree((XtPointer)list);
  1330.     }
  1331. }
  1332.  
  1333. typedef struct fe_DependentListCallbackStruct
  1334. {
  1335.     int     reason;
  1336.     XEvent  *event;
  1337.     fe_Dependency mask;
  1338.     Widget  caller;
  1339.     XtPointer callers_data;
  1340. } fe_DependentListCallbackStruct;
  1341.  
  1342. void
  1343. fe_DependentListCallDependents(Widget caller,
  1344.                                fe_DependentList* list,
  1345.                                fe_Dependency mask,
  1346.                                XtPointer callers_data)
  1347. {
  1348.     fe_DependentListCallbackStruct call_data;
  1349.  
  1350.     call_data.reason = 0;
  1351.     call_data.event = 0;
  1352.     call_data.mask = mask;
  1353.     call_data.caller = caller;
  1354.     call_data.callers_data = callers_data;
  1355.  
  1356.     for (; list; list = list->next) {
  1357.         if ((list->mask & mask) != 0)
  1358.             (*list->callback.callback)(list->widget, list->callback.closure,
  1359.                                        &call_data);
  1360.     }
  1361. }
  1362.  
  1363. void
  1364. fe_MakeDependent(Widget widget, fe_Dependency mask, 
  1365.                  XtCallbackProc proc, XtPointer closure)
  1366. {
  1367.     MWContext* context = (MWContext *)fe_WidgetToMWContext(widget);
  1368.  
  1369.     fe_DependentListAddDependent(
  1370.                                  &(CONTEXT_DATA(context)->dependents),
  1371.                                  widget,
  1372.                                  mask,
  1373.                                  proc,
  1374.                                  closure);
  1375. }
  1376.     
  1377. void
  1378. fe_CallDependents(MWContext* context, fe_Dependency mask)
  1379. {
  1380.     fe_DependentListCallDependents(NULL, CONTEXT_DATA(context)->dependents,
  1381.                                    mask, NULL);
  1382. }
  1383.  
  1384. struct fe_EditorParagraphPropertiesWidgets;
  1385. struct fe_EditorCharacterPropertiesWidgets;
  1386. struct fe_EditorLinkPropertiesWidgets;
  1387. struct fe_EditorImagePropertiesWidgets;
  1388.  
  1389. typedef struct fe_EditorPropertiesWidgets {
  1390.     MWContext*                                  context;
  1391.     fe_DependentList*                           dependents;
  1392.     struct fe_EditorCharacterPropertiesWidgets* character;
  1393.     struct fe_EditorLinkPropertiesWidgets*      link;
  1394.     struct fe_EditorParagraphPropertiesWidgets* paragraph;
  1395.     struct fe_EditorImagePropertiesWidgets*     image;
  1396.     fe_Dependency                               changed;
  1397. } fe_EditorPropertiesWidgets;
  1398.  
  1399. typedef struct fe_EditorParagraphPropertiesWidgets {
  1400.     fe_EditorPropertiesWidgets* properties;
  1401.     Widget style_menu;
  1402.     Widget additional_menu;
  1403.     Widget list_style_menu;
  1404.     Widget bullet_style_menu;
  1405.     Widget start_text;
  1406.  
  1407.     Widget  numbering_pulldown;
  1408.     Widget  bullet_pulldown;
  1409.     TagType paragraph_style;
  1410.     TagType additional_style;
  1411.     TagType list_style;
  1412.     ED_ListType bullet_style;
  1413.     ED_Alignment align;
  1414.     unsigned start;
  1415. } fe_EditorParagraphPropertiesWidgets;
  1416.  
  1417. typedef enum fe_JavaScriptModes
  1418. {
  1419.     JAVASCRIPT_NONE = 0,
  1420.     JAVASCRIPT_SERVER,
  1421.     JAVASCRIPT_CLIENT
  1422. } fe_JavaScriptModes;
  1423.  
  1424. typedef struct fe_EditorCharacterPropertiesWidgets {
  1425.     fe_EditorPropertiesWidgets* properties;
  1426.     Widget form;
  1427.     Widget color_default;
  1428.     Widget color_custom;
  1429.     Widget color_swatch;
  1430.     /* something else to hold custom color I guess */
  1431.  
  1432.     Widget bold;
  1433.     Widget italic;
  1434.     Widget fixed;
  1435.     Widget strike_thru;
  1436.     Widget super_script;
  1437.     Widget sub_script;
  1438.     Widget blink;
  1439.     
  1440.     ED_FontSize font_size;
  1441.     ED_TextFormat text_attributes;
  1442.     ED_TextFormat changed_mask;
  1443.     LO_Color      color;
  1444.     Boolean is_custom_color;
  1445.     fe_JavaScriptModes js_mode;
  1446. } fe_EditorCharacterPropertiesWidgets;
  1447.  
  1448. typedef char* EDT_LtabbList_t;
  1449.  
  1450. typedef struct fe_EditorLinkPropertiesWidgets {
  1451.     fe_EditorPropertiesWidgets* properties;
  1452.     Widget form;
  1453.     Widget displayed_label;
  1454.     Widget displayed_text;
  1455.     Widget link_text;
  1456.     /* others I don't understand */
  1457.     Widget target_list;
  1458.     EDT_LtabbList_t target_list_data;
  1459.     Widget target_current_doc;
  1460.     Widget target_selected_file;
  1461.     Widget target_label;
  1462.     char* selected_filename;
  1463.     char* url;
  1464.     char* text;
  1465. } fe_EditorLinkPropertiesWidgets;
  1466.  
  1467. typedef struct fe_EditorImagePropertiesWidgets {
  1468.     fe_EditorPropertiesWidgets* properties;
  1469.     EDT_ImageData               image_data;
  1470.     Widget main_image;
  1471.     Widget alt_image;
  1472.     Widget alt_text;
  1473.     Widget image_height;
  1474.     Widget image_width;
  1475.     Widget margin_height;
  1476.     Widget margin_width;
  1477.     Widget margin_solid;
  1478.     Widget constrain;
  1479.     Boolean  existing_image; /* means there was an image when we loaded */
  1480.     Boolean  new_image;      /* means a new image gets loaded */
  1481.     Boolean  do_constrain;
  1482.     Boolean  do_custom_size;
  1483.     Boolean  default_border; /* Don't output a BORDER attribute at all. */
  1484. } fe_EditorImagePropertiesWidgets;
  1485.  
  1486. #define PROP_CHAR_BOLD    (0x1<<0)
  1487. #define PROP_CHAR_ITALIC  (0x1<<1)
  1488. #define PROP_CHAR_FIXED   (0x1<<2)
  1489. #define PROP_CHAR_SUPER   (0x1<<3)
  1490. #define PROP_CHAR_SUB     (0x1<<4)
  1491. #define PROP_CHAR_STRIKE  (0x1<<5)
  1492. #define PROP_CHAR_BLINK   (0x1<<6)
  1493. #define PROP_CHAR_COLOR   (0x1<<7)
  1494. #define PROP_CHAR_SIZE    (0x1<<8)
  1495.  
  1496. #define PROP_CHAR_SERVER    (0x1<<10)
  1497. #define PROP_CHAR_CLIENT    (0x1<<11)
  1498. #define PROP_CHAR_UNDERLINE (0x1<<12)
  1499.  
  1500. #define PROP_PARA_STYLE   (0x1<<13)
  1501. #define PROP_PARA_LIST    (0x1<<14)
  1502. #define PROP_PARA_BULLET  (0x1<<15)
  1503. #define PROP_PARA_ALIGN   (0x1<<16)
  1504. #define PROP_LINK_TEXT    (0x1<<17)
  1505. #define PROP_LINK_HREF    (0x1<<18)
  1506. #define PROP_IMAGE_MAIN_IMAGE (0x1<<19)
  1507. #define PROP_IMAGE_ALT_IMAGE  (0x1<<20)
  1508. #define PROP_IMAGE_ALT_TEXT   (0x1<<21)
  1509. #define PROP_IMAGE_ALIGN      (0x1<<22)
  1510. #define PROP_IMAGE_HEIGHT     (0x1<<23)
  1511. #define PROP_IMAGE_WIDTH      (0x1<<24)
  1512. #define PROP_IMAGE_MARGIN_HEIGHT (0x1<<25)
  1513. #define PROP_IMAGE_MARGIN_WIDTH  (0x1<<26)
  1514. #define PROP_IMAGE_MARGIN_BORDER (0x1<<27)
  1515. #define PROP_IMAGE_COPY       (0x1<<28)
  1516. #define PROP_IMAGE_IMAP       (0x1<<29)
  1517. #define PROP_LINK_LIST    (0x1<<30)
  1518.  
  1519. #define PROP_CHAR_STYLE   \
  1520. (PROP_CHAR_BOLD|PROP_CHAR_ITALIC|PROP_CHAR_UNDERLINE|PROP_CHAR_FIXED| \
  1521.  PROP_CHAR_STRIKE|PROP_CHAR_SUPER|PROP_CHAR_SUB|PROP_CHAR_BLINK)
  1522. #define PROP_CHAR_JAVASCRIPT (PROP_CHAR_CLIENT|PROP_CHAR_SERVER)
  1523. #define PROP_CHAR_ALL     \
  1524. (PROP_CHAR_STYLE|PROP_CHAR_COLOR|PROP_CHAR_SIZE|PROP_CHAR_JAVASCRIPT)
  1525. #define PROP_PARA_ALL     \
  1526. (PROP_PARA_STYLE|PROP_PARA_LIST|PROP_PARA_BULLET|PROP_PARA_ALIGN)
  1527. #define PROP_LINK_ALL     \
  1528. (PROP_LINK_TEXT|PROP_LINK_HREF|PROP_LINK_LIST)
  1529. #define PROP_IMAGE_DIMENSIONS (PROP_IMAGE_HEIGHT|PROP_IMAGE_WIDTH)
  1530. #define PROP_IMAGE_SPACE      \
  1531. (PROP_IMAGE_MARGIN_HEIGHT|PROP_IMAGE_MARGIN_WIDTH|PROP_IMAGE_MARGIN_BORDER)
  1532. #define PROP_IMAGE_ALL    \
  1533. (PROP_IMAGE_MAIN_IMAGE|PROP_IMAGE_ALT_IMAGE|PROP_IMAGE_ALT_TEXT|  \
  1534.  PROP_IMAGE_ALIGN|PROP_IMAGE_DIMENSIONS|PROP_IMAGE_SPACE|         \
  1535.  PROP_IMAGE_COPY|PROP_IMAGE_IMAP)
  1536.  
  1537. static void
  1538. fe_update_dependents(Widget caller,
  1539.                      fe_EditorPropertiesWidgets* p_data, fe_Dependency mask)
  1540. {
  1541.     p_data->changed |= mask;
  1542.     fe_DependentListCallDependents(caller, p_data->dependents, mask, NULL);
  1543. }
  1544.  
  1545. static void
  1546. fe_register_dependent(fe_EditorPropertiesWidgets* p_data, Widget widget,
  1547.                       fe_Dependency mask, XtCallbackProc proc, XtPointer closure)
  1548. {
  1549.     fe_DependentListAddDependent(&p_data->dependents,
  1550.                                  widget,
  1551.                                  mask,
  1552.                                  proc,
  1553.                                  closure);
  1554. }
  1555.  
  1556. typedef struct fe_style_data {
  1557.     char* name;
  1558.     unsigned data;
  1559. } fe_style_data;
  1560.  
  1561. static struct fe_style_data fe_paragraph_style[] = {
  1562.     { "normal",          P_NSDT       },
  1563.     { "headingOne",      P_HEADER_1   },
  1564.     { "headingTwo",      P_HEADER_2   },
  1565.     { "headingThree",    P_HEADER_3   },
  1566.     { "headingFour",     P_HEADER_4   },
  1567.     { "headingFive",     P_HEADER_5   },
  1568.     { "headingSix",      P_HEADER_6   },
  1569.     { "address",         P_ADDRESS    },
  1570.     { "formatted",       P_PREFORMAT  },
  1571.     { "listItem",        P_LIST_ITEM  },
  1572.     { "descriptionItem", P_DESC_TITLE },
  1573.     { "descriptionText", P_DESC_TEXT  },
  1574.     { 0 }
  1575. };
  1576.  
  1577. static struct fe_style_data fe_additional_style[] = {
  1578.     { "default",         P_NSDT       },
  1579.     { "list",            P_LIST_ITEM  },
  1580.     { "blockQuote",      P_BLOCKQUOTE },
  1581.     { 0 }
  1582. };
  1583.  
  1584. static struct fe_style_data fe_list_style[] = {
  1585.     { "unnumbered",      P_UNUM_LIST  },
  1586.     { "numbered",        P_NUM_LIST   },
  1587.     { "directory",       P_DIRECTORY  },
  1588.     { "menu",            P_MENU       },
  1589.     { "description",     P_DESC_LIST  },
  1590.     { 0 }
  1591. };
  1592.  
  1593. static struct fe_style_data fe_bullet_style[] = {
  1594.     { "automatic",       ED_LIST_TYPE_DEFAULT },
  1595.     { "solidCircle",     ED_LIST_TYPE_DISC    },
  1596.     { "openSquare",      ED_LIST_TYPE_SQUARE  },
  1597.     { "openCircle",      ED_LIST_TYPE_CIRCLE  },
  1598.     { 0 }
  1599. };
  1600.  
  1601. static struct fe_style_data fe_numbering_style[] = {
  1602.     { "automatic",       ED_LIST_TYPE_DEFAULT        },
  1603.     { "digital",         ED_LIST_TYPE_DIGIT          },
  1604.     { "upperRoman",      ED_LIST_TYPE_BIG_ROMAN      },
  1605.     { "lowerRoman",      ED_LIST_TYPE_SMALL_ROMAN    },
  1606.     { "upperAlpha",      ED_LIST_TYPE_BIG_LETTERS    },
  1607.     { "lowerAlpha",      ED_LIST_TYPE_SMALL_LETTERS  },
  1608.     { 0 }
  1609. };
  1610.  
  1611. static struct fe_style_data fe_align_style[] = {
  1612.     { "left",       ED_ALIGN_LEFT   },
  1613.     { "center",     ED_ALIGN_ABSCENTER },
  1614.     { "right",      ED_ALIGN_RIGHT  },
  1615.     { 0 }
  1616. };
  1617.  
  1618. static unsigned
  1619. fe_convert_value_to_index(fe_style_data* style_data, unsigned value)
  1620. {
  1621.     unsigned i;
  1622.  
  1623.     for (i = 0; style_data[i].name; i++) {
  1624.         if (style_data[i].data == value)
  1625.             return i;
  1626.     }
  1627.     /* maybe should assert */
  1628.     return 0;
  1629. }
  1630.  
  1631. static void
  1632. fe_paragraph_style_menu_update_cb(Widget widget, XtPointer closure,
  1633.                                   XtPointer call_data)
  1634. {
  1635.     fe_EditorParagraphPropertiesWidgets* w_data = (fe_EditorParagraphPropertiesWidgets*)closure;
  1636.  
  1637.     TagType  type = w_data->paragraph_style;
  1638.     unsigned index = fe_convert_value_to_index(fe_paragraph_style, type);
  1639.  
  1640.     fe_OptionMenuSetHistory(widget, index);
  1641. }
  1642.  
  1643. static void
  1644. fe_paragraph_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1645. {
  1646.     fe_EditorParagraphPropertiesWidgets* w_data
  1647.         = (fe_EditorParagraphPropertiesWidgets*)closure;
  1648.     unsigned foo = (unsigned)fe_GetUserData(widget);
  1649.     TagType  type = (TagType)foo;
  1650.  
  1651.     w_data->paragraph_style = type;
  1652.     if (type == P_LIST_ITEM) {
  1653.         w_data->additional_style = P_LIST_ITEM;
  1654.     } else if (w_data->additional_style == P_LIST_ITEM) {
  1655.         w_data->additional_style = P_NSDT; /* default */
  1656.     }
  1657.  
  1658.     fe_update_dependents(widget, w_data->properties, PROP_PARA_STYLE|PROP_PARA_LIST);
  1659. }
  1660.  
  1661. static void
  1662. fe_additional_style_menu_update_cb(Widget widget, XtPointer closure,
  1663.                                   XtPointer call_data)
  1664. {
  1665.     fe_EditorParagraphPropertiesWidgets* w_data = (fe_EditorParagraphPropertiesWidgets*)closure;
  1666.  
  1667.     TagType  type = w_data->additional_style;
  1668.     unsigned index = fe_convert_value_to_index(fe_additional_style, type);
  1669.  
  1670.     fe_OptionMenuSetHistory(widget, index);
  1671. }
  1672.  
  1673. static void
  1674. fe_additional_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1675. {
  1676.     fe_EditorParagraphPropertiesWidgets* w_data
  1677.         = (fe_EditorParagraphPropertiesWidgets*)closure;
  1678.     unsigned foo = (unsigned)fe_GetUserData(widget);
  1679.     TagType  type = (TagType)foo;
  1680.  
  1681.     w_data->additional_style = type;
  1682.     if (type == P_LIST_ITEM)
  1683.         w_data->paragraph_style = P_LIST_ITEM;
  1684.  
  1685.     fe_update_dependents(widget, w_data->properties, PROP_PARA_STYLE|PROP_PARA_LIST);
  1686. }
  1687.  
  1688. static void
  1689. fe_list_style_menu_update_cb(Widget widget, XtPointer closure,
  1690.                                   XtPointer call_data)
  1691. {
  1692.     fe_EditorParagraphPropertiesWidgets* w_data = (fe_EditorParagraphPropertiesWidgets*)closure;
  1693.  
  1694.     TagType  type = w_data->additional_style;
  1695.     Boolean  enabled = FALSE;
  1696.     unsigned index;
  1697.  
  1698.     if (type == P_LIST_ITEM) {
  1699.         type = w_data->list_style;
  1700.         index = fe_convert_value_to_index(fe_list_style, type);
  1701.         enabled = TRUE;
  1702.  
  1703.         fe_OptionMenuSetHistory(widget, index);
  1704.     }
  1705.  
  1706.     XtVaSetValues(XmOptionButtonGadget(widget), XmNsensitive, enabled, 0);
  1707. }
  1708.  
  1709. static void
  1710. fe_list_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1711. {
  1712.     fe_EditorParagraphPropertiesWidgets* w_data
  1713.         = (fe_EditorParagraphPropertiesWidgets*)closure;
  1714.     unsigned foo = (unsigned)fe_GetUserData(widget);
  1715.     TagType  type = (TagType)foo;
  1716.  
  1717.     w_data->list_style = type;
  1718.     
  1719.     fe_update_dependents(widget, w_data->properties, PROP_PARA_LIST|PROP_PARA_BULLET);
  1720. }
  1721.  
  1722. static void
  1723. fe_bullet_style_menu_update_cb(Widget widget, XtPointer closure,
  1724.                                   XtPointer call_data)
  1725. {
  1726.     fe_EditorParagraphPropertiesWidgets* w_data = (fe_EditorParagraphPropertiesWidgets*)closure;
  1727.  
  1728.     TagType  type = w_data->additional_style;
  1729.     Boolean  enabled = FALSE;
  1730.     unsigned index = 0;         /* keep -O happy */
  1731.     Widget   cascade = XmOptionButtonGadget(widget);
  1732.     Widget   pulldown = NULL;   /* keep -O happy */
  1733.  
  1734.     if (type == P_LIST_ITEM) {
  1735.         type = w_data->list_style;
  1736.         if (type == P_NUM_LIST) {
  1737.             enabled = TRUE;
  1738.             index = fe_convert_value_to_index(fe_numbering_style,
  1739.                                               w_data->bullet_style);
  1740.             pulldown = w_data->numbering_pulldown;
  1741.         } else if (type == P_UNUM_LIST) {
  1742.             enabled = TRUE;
  1743.             index = fe_convert_value_to_index(fe_bullet_style,
  1744.                                               w_data->bullet_style);
  1745.             pulldown = w_data->bullet_pulldown;
  1746.         }
  1747.  
  1748.         if (enabled) {
  1749.             XtVaSetValues(cascade, XmNsubMenuId, pulldown, 0);
  1750.             fe_OptionMenuSetHistory(widget, index);
  1751.         }
  1752.     }
  1753.  
  1754.     XtVaSetValues(cascade, XmNsensitive, enabled, 0);
  1755. }
  1756.  
  1757. static void
  1758. fe_bullet_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1759. {
  1760.     fe_EditorParagraphPropertiesWidgets* w_data = (fe_EditorParagraphPropertiesWidgets*)closure;
  1761.  
  1762.     ED_ListType    type = (ED_ListType)fe_GetUserData(widget);
  1763.  
  1764.     w_data->bullet_style = type;
  1765.  
  1766.     fe_update_dependents(widget, w_data->properties, PROP_PARA_BULLET);
  1767. }
  1768.  
  1769. static Widget
  1770. fe_create_style_pulldown(Widget parent, char* name, fe_style_data* style_data,
  1771.                      Arg* p_args, Cardinal p_n)
  1772. {
  1773.     Cardinal nchildren;
  1774.     Widget   children[16];
  1775.     Widget   pulldown;
  1776.     Arg      args[8];
  1777.     Cardinal n;
  1778.     Cardinal m;
  1779.     XtCallbackRec* button_callback_rec = 0;
  1780.     XtCallbackRec* update_callback_rec = 0;
  1781.  
  1782.     for (n = m = 0; n < p_n; n++) {
  1783.         if (p_args[n].name == XmNactivateCallback)
  1784.             button_callback_rec = (XtCallbackRec*)p_args[n].value;
  1785.         else if (p_args[n].name == XmNvalueChangedCallback)
  1786.             update_callback_rec = (XtCallbackRec*)p_args[n].value;
  1787.         else {
  1788.             XtSetArg(args[m], p_args[n].name, p_args[n].value); m++;
  1789.         }
  1790.     }
  1791.  
  1792.     n = m;
  1793.     pulldown = fe_CreatePulldownMenu(parent, name, args, n);
  1794.  
  1795.     for (nchildren = 0; style_data[nchildren].name; nchildren++) {
  1796.  
  1797.         n = 0;
  1798.         XtSetArg(args[n], XmNuserData, style_data[nchildren].data); n++;
  1799.         children[nchildren] = XmCreatePushButtonGadget(
  1800.                                                        pulldown,
  1801.                                                        style_data[nchildren].name,
  1802.                                                        args,
  1803.                                                        n
  1804.                                                        );
  1805.         if (button_callback_rec) {
  1806.             XtAddCallback(children[nchildren],
  1807.                           XmNactivateCallback,
  1808.                           button_callback_rec->callback,
  1809.                           (XtPointer)button_callback_rec->closure);
  1810.         }
  1811.     }
  1812.     XtManageChildren(children, nchildren);
  1813.     
  1814.     return pulldown;
  1815. }
  1816.  
  1817. static Widget
  1818. fe_create_style_menu(Widget parent, char* name, fe_style_data* style_data,
  1819.                      Arg* p_args, Cardinal p_n)
  1820. {
  1821.     Widget   pulldown;
  1822.     Widget   option;
  1823.     Arg      args[8];
  1824.     Arg      rc_args[8];
  1825.     Cardinal n;
  1826.     Cardinal my_n;
  1827.     Cardinal rc_n;
  1828.  
  1829.     for (my_n = rc_n = n = 0; n < p_n; n++) {
  1830.         if (
  1831.             p_args[n].name == XmNactivateCallback
  1832.             ||
  1833.             p_args[n].name == XmNvalueChangedCallback
  1834.         ) {
  1835.             XtSetArg(rc_args[rc_n], p_args[n].name, p_args[n].value); rc_n++;
  1836.         } else {
  1837.             XtSetArg(args[my_n], p_args[n].name, p_args[n].value); my_n++;
  1838.         }
  1839.     }
  1840.  
  1841.     pulldown = fe_create_style_pulldown(parent, name, style_data, rc_args, rc_n);
  1842.  
  1843.     XtSetArg(args[my_n], XmNsubMenuId, pulldown); my_n++;
  1844.     option = fe_CreateOptionMenu(parent,    name, args, my_n);
  1845.     fe_UnmanageChild_safe(XmOptionLabelGadget(option));
  1846.  
  1847.     return option;
  1848. }
  1849.  
  1850. static void
  1851. fe_paragraph_align_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1852. {
  1853.     fe_EditorParagraphPropertiesWidgets* w_data =
  1854.         (fe_EditorParagraphPropertiesWidgets*)closure;
  1855.     XmToggleButtonCallbackStruct* info =
  1856.         (XmToggleButtonCallbackStruct*)call_data;
  1857.  
  1858.     /*
  1859.      *    We get a callback on both the unset of the old toggle,
  1860.      *    and the set of the new, so ignore the former, it's not
  1861.      *    interesting.
  1862.      */
  1863.     if (info->set) {
  1864.  
  1865.         w_data->align = (ED_Alignment)fe_GetUserData(widget);    
  1866.  
  1867.         fe_update_dependents(widget, w_data->properties, PROP_PARA_ALIGN);
  1868.     }
  1869. }
  1870.  
  1871. static void
  1872. fe_paragraph_align_update_cb(Widget widget,
  1873.                              XtPointer closure, XtPointer call_data)
  1874. {
  1875.     fe_EditorParagraphPropertiesWidgets* w_data =
  1876.         (fe_EditorParagraphPropertiesWidgets*)closure;
  1877.     ED_Alignment align = (ED_Alignment)fe_GetUserData(widget);
  1878.     ED_Alignment w_align = w_data->align;
  1879.  
  1880.     if (w_align == ED_ALIGN_DEFAULT)
  1881.         w_align = ED_ALIGN_LEFT;
  1882.  
  1883.     if (w_align == ED_ALIGN_CENTER) /* just in case the BE changes */
  1884.         w_align = ED_ALIGN_ABSCENTER;
  1885.  
  1886.     XmToggleButtonGadgetSetState(widget, (w_align == align), FALSE);
  1887. }
  1888.  
  1889. static void
  1890. fe_set_text_field(Widget widget, char* value,
  1891.                   XtCallbackProc cb, XtPointer closure)
  1892. {
  1893.     if (cb)
  1894.         XtRemoveCallback(widget, XmNvalueChangedCallback,
  1895.                          cb, closure);
  1896.  
  1897.     if (!value)
  1898.         value = "";
  1899.  
  1900.     fe_SetTextFieldAndCallBack(widget, value);
  1901.     
  1902.     if (cb)
  1903.         XtAddCallback(widget, XmNvalueChangedCallback,
  1904.                       cb, closure);
  1905. }
  1906.  
  1907. static void
  1908. fe_set_numeric_text_field(Widget widget, unsigned value)
  1909. {
  1910.     char buf[32];
  1911.  
  1912.     sprintf(buf, "%d", value);
  1913.  
  1914.     fe_TextFieldSetString(widget, buf, FALSE);
  1915. }
  1916.  
  1917. static void
  1918. fe_paragraph_start_cb(Widget widget, XtPointer closure, XtPointer call_data)
  1919. {
  1920.     fe_EditorParagraphPropertiesWidgets* w_data =
  1921.         (fe_EditorParagraphPropertiesWidgets*)closure;
  1922.  
  1923.     fe_update_dependents(widget, w_data->properties, PROP_PARA_BULLET);
  1924. }
  1925.  
  1926. #if 0
  1927. static unsigned
  1928. fe_aztoui(char* s, Boolean upper)
  1929. {
  1930.     char* p;
  1931.     unsigned rv = 0;
  1932.     unsigned high;
  1933.     unsigned low;
  1934.     if (upper) {
  1935.       low = 'A';
  1936.       high = 'Z';
  1937.     } else {
  1938.       low = 'a';
  1939.       high = 'z';
  1940.     }
  1941.     for (p = s; *p >= low && *p <= high; p++) {
  1942.         rv *= 26;
  1943.         rv += (*p - low) + 1;
  1944.     }
  1945.     return rv;
  1946. } 
  1947.  
  1948. static int
  1949. fe_uitoaz(char* buf, unsigned value, Boolean upper)
  1950. {
  1951.     char* p;
  1952.     unsigned base = 26;
  1953.     unsigned low;
  1954.     if (upper) {
  1955.       low = 'A';
  1956.     } else {
  1957.       low = 'a';
  1958.     }
  1959.  
  1960.     if (value == 0) {
  1961.         buf[0] = '\0';
  1962.         return 0;
  1963.     }
  1964.     value--;
  1965.  
  1966.     for (p = buf; base < value; p++)
  1967.         base = base * 26;
  1968.  
  1969.     p[1] = '\0';
  1970.  
  1971.  
  1972.     for (; p >= buf; p--) {
  1973.         *p = (value % 26) + low;
  1974.         value /= 26;
  1975.     }
  1976.     return strlen(buf);
  1977. }
  1978. #endif
  1979.  
  1980. static void
  1981. fe_paragraph_start_update_cb(Widget widget,
  1982.                              XtPointer closure, XtPointer call_data)
  1983. {
  1984.     fe_EditorParagraphPropertiesWidgets* w_data =
  1985.         (fe_EditorParagraphPropertiesWidgets*)closure;
  1986.     fe_DependentListCallbackStruct* info = 
  1987.         (fe_DependentListCallbackStruct*)call_data;
  1988.     char buf[256];
  1989.     Boolean enabled;
  1990.  
  1991.     if (info->caller == widget)
  1992.         return; /* don't call ourselves */
  1993.  
  1994.     if (w_data->paragraph_style == P_LIST_ITEM
  1995.         &&
  1996.         w_data->list_style==P_NUM_LIST) {
  1997. #if 0
  1998.         if (
  1999.             w_data->bullet_style == ED_LIST_TYPE_DIGIT
  2000.             ||
  2001.             w_data->bullet_style == ED_LIST_TYPE_BIG_ROMAN
  2002.             ||
  2003.             w_data->bullet_style == ED_LIST_TYPE_SMALL_ROMAN
  2004.         ) {
  2005.             sprintf(buf, "%d", w_data->start);
  2006.         } else if (w_data->bullet_style == ED_LIST_TYPE_BIG_LETTERS) {
  2007.             fe_uitoaz(buf, w_data->start, TRUE);
  2008.         } else  if (w_data->bullet_style == ED_LIST_TYPE_SMALL_LETTERS) {
  2009.             fe_uitoaz(buf, w_data->start, FALSE);
  2010.         }
  2011. #else
  2012.         if (w_data->start < 1)
  2013.             w_data->start = 1;
  2014.         sprintf(buf, "%d", w_data->start);
  2015. #endif
  2016.         enabled = TRUE;
  2017.     } else {
  2018.         buf[0] = '\0';
  2019.         enabled = FALSE;
  2020.     }
  2021.  
  2022.     fe_TextFieldSetEditable(w_data->properties->context, widget, enabled);
  2023.     fe_set_text_field(widget, buf, fe_paragraph_start_cb, (XtPointer)w_data);
  2024. }
  2025.  
  2026. static void
  2027. fe_EditorParagraphPropertiesDialogDataGet(
  2028.                                   MWContext* context,
  2029.                                   fe_EditorParagraphPropertiesWidgets* w_data)
  2030. {
  2031.     EDT_ListData list_data;
  2032.  
  2033.     fe_EditorParagraphPropertiesGetAll(context,
  2034.                                        &w_data->paragraph_style,
  2035.                                        &list_data,
  2036.                                        &w_data->align);
  2037.     
  2038.     switch (list_data.iTagType) {
  2039.     case P_BLOCKQUOTE: /* block quotes */
  2040.         w_data->additional_style = P_BLOCKQUOTE;
  2041.         w_data->list_style = P_UNUM_LIST;
  2042.         w_data->bullet_style = ED_LIST_TYPE_DEFAULT;
  2043.         break;
  2044.  
  2045.     case P_NUM_LIST: /* lists */
  2046.         w_data->start = list_data.iStart;
  2047.         if (w_data->start < 1)
  2048.             w_data->start = 1;
  2049.         /*FALLTHRU*/
  2050.     case P_UNUM_LIST:
  2051.     case P_DIRECTORY:
  2052.     case P_MENU:
  2053.     case P_DESC_LIST:
  2054.         w_data->additional_style = P_LIST_ITEM;
  2055.         w_data->list_style = list_data.iTagType;
  2056.         w_data->bullet_style = list_data.eType;
  2057.         break;
  2058.  
  2059.     default:
  2060.         w_data->additional_style = P_NSDT;
  2061.         w_data->list_style = P_UNUM_LIST;
  2062.         w_data->bullet_style = ED_LIST_TYPE_DEFAULT;
  2063.         break;
  2064.     }
  2065.  
  2066.     /*
  2067.      *    Update the display.
  2068.      */
  2069.     fe_update_dependents(NULL, w_data->properties, PROP_PARA_ALL);
  2070. }
  2071.  
  2072. static void
  2073. fe_EditorParagraphPropertiesDialogSet(
  2074.                                  MWContext* context,
  2075.                                  fe_EditorParagraphPropertiesWidgets* w_data)
  2076. {
  2077.     EDT_ListData list_data;
  2078.     char* p = NULL;
  2079.  
  2080.     memset(&list_data, 0, sizeof(EDT_ListData));
  2081.  
  2082.     if (w_data->paragraph_style == P_LIST_ITEM) { /* do list stuff */
  2083.         list_data.iTagType = w_data->list_style;
  2084.         list_data.bCompact = 0; /* ??? */
  2085.         list_data.eType = w_data->bullet_style;
  2086.         p = fe_TextFieldGetString(w_data->start_text);
  2087.         list_data.iStart = atoi(p);
  2088.         if (p)
  2089.             XtFree(p);
  2090.  
  2091.         fe_EditorParagraphPropertiesSetAll(context,
  2092.                                            w_data->paragraph_style,
  2093.                                            &list_data,
  2094.                                            w_data->align);
  2095.         
  2096.     } else if (w_data->additional_style == P_BLOCKQUOTE) { /* do quote */
  2097.         
  2098.         list_data.iTagType = P_BLOCKQUOTE;
  2099.         list_data.bCompact = 0; /* ??? */
  2100.         list_data.eType = ED_LIST_TYPE_DEFAULT;
  2101.  
  2102.         fe_EditorParagraphPropertiesSetAll(context,
  2103.                                            w_data->paragraph_style,
  2104.                                            &list_data,
  2105.                                            w_data->align);
  2106.     } else {
  2107.         fe_EditorParagraphPropertiesSetAll(context,
  2108.                                            w_data->paragraph_style,
  2109.                                            NULL,
  2110.                                            w_data->align);
  2111.     }
  2112.     
  2113.  
  2114. }
  2115.  
  2116. static void
  2117. fe_make_paragraph_page(
  2118.                        MWContext *context,
  2119.                        Widget parent,
  2120.                        fe_EditorParagraphPropertiesWidgets* w_data)
  2121. {
  2122.     Arg args[16];
  2123.     Cardinal n;
  2124.     Widget form;
  2125.     Widget paragraph_label;
  2126.     Widget paragraph_option;
  2127.     Widget additional_label;
  2128.     Widget additional_option;
  2129.     Widget list_frame;
  2130.     Widget list_form;
  2131.     Widget list_style_label;
  2132.     Widget list_style_option;
  2133.     Widget bullet_style_option;
  2134.     Widget starting_text;
  2135.     Widget starting_label;
  2136.     Widget align_frame;
  2137.     Widget align_rc;
  2138.     Widget children[16];
  2139.     Cardinal nchildren;
  2140.     XtCallbackRec callback;
  2141.  
  2142. #if 0
  2143.     n = 0;
  2144.     form = XmCreateForm(parent, "paragraphProperties", args, n);
  2145.     XtManageChild(form);
  2146. #else
  2147.     form = parent;
  2148. #endif
  2149.  
  2150.     /*
  2151.      *    Paragraph Style.
  2152.      */
  2153.     n = 0;
  2154.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  2155.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2156.     paragraph_label = XmCreateLabelGadget(form, "styleLabel", args, n);
  2157.     XtManageChild(paragraph_label);
  2158.  
  2159.     n = 0;
  2160.     callback.callback = fe_paragraph_style_cb;
  2161.     callback.closure = (XtPointer)w_data;
  2162.     XtSetArg(args[n], XmNactivateCallback, &callback); n++;
  2163.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2164.     XtSetArg(args[n], XmNtopWidget, paragraph_label); n++;
  2165.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2166.     paragraph_option = fe_create_style_menu(form, "style", fe_paragraph_style,
  2167.                                             args, n);
  2168.     XtManageChild(paragraph_option);
  2169.  
  2170.     fe_register_dependent(w_data->properties, paragraph_option,
  2171.                           FE_MAKE_DEPENDENCY(PROP_PARA_STYLE|PROP_PARA_LIST),
  2172.                           fe_paragraph_style_menu_update_cb, (XtPointer)w_data);
  2173.  
  2174.     /*
  2175.      *    Additional Style.
  2176.      */
  2177.     n = 0;
  2178.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  2179.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  2180.     XtSetArg(args[n], XmNleftWidget, paragraph_option); n++;
  2181.     additional_label = XmCreateLabelGadget(form, "additionalLabel", args, n);
  2182.     XtManageChild(additional_label);
  2183.  
  2184.     n = 0;
  2185.     callback.callback = fe_additional_style_cb;
  2186.     callback.closure = (XtPointer)w_data;
  2187.     XtSetArg(args[n], XmNactivateCallback, &callback); n++;
  2188.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2189.     XtSetArg(args[n], XmNtopWidget, paragraph_label); n++;
  2190.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  2191.     XtSetArg(args[n], XmNleftWidget, paragraph_option); n++;
  2192.     additional_option = fe_create_style_menu(form, "additional", fe_additional_style,
  2193.                                             args, n);
  2194.     XtManageChild(additional_option);
  2195.  
  2196.     fe_register_dependent(w_data->properties, additional_option,
  2197.                           FE_MAKE_DEPENDENCY(PROP_PARA_STYLE|PROP_PARA_LIST),
  2198.                           fe_additional_style_menu_update_cb, (XtPointer)w_data);
  2199.     /*
  2200.      *    List frame and friends. THIS IS SO BORING!!!!!!!!!!!!!
  2201.      */
  2202.     n = 0;
  2203.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2204.     XtSetArg(args[n], XmNtopWidget, paragraph_option); n++;
  2205.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2206.     list_frame = fe_CreateFrame(form, "list", args, n);
  2207.     XtManageChild(list_frame);
  2208.     
  2209.     n = 0;
  2210.     list_form = XmCreateForm(list_frame, "list", args, n);
  2211.     XtManageChild(list_form);
  2212.  
  2213.     n = 0;
  2214.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  2215.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2216.     list_style_label = XmCreateLabelGadget(list_form, "listLabel", args, n);
  2217.     XtManageChild(list_style_label);
  2218.  
  2219.     n = 0;
  2220.     callback.callback = fe_list_style_cb;
  2221.     callback.closure = (XtPointer)w_data;
  2222.     XtSetArg(args[n], XmNactivateCallback, &callback); n++;
  2223.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2224.     XtSetArg(args[n], XmNtopWidget, list_style_label); n++;
  2225.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2226.     list_style_option = fe_create_style_menu(list_form, "listStyle", fe_list_style,
  2227.                                             args, n);
  2228.     XtManageChild(list_style_option);
  2229.  
  2230.     fe_register_dependent(w_data->properties, list_style_option,
  2231.                           FE_MAKE_DEPENDENCY(PROP_PARA_LIST),
  2232.                           fe_list_style_menu_update_cb, (XtPointer)w_data);
  2233.  
  2234.     n = 0;
  2235.     callback.callback = fe_bullet_style_cb;
  2236.     callback.closure = (XtPointer)w_data;
  2237.     XtSetArg(args[n], XmNactivateCallback, &callback); n++;
  2238.     w_data->numbering_pulldown = fe_create_style_pulldown(list_form,
  2239.                                                           "bulletStyle",
  2240.                                                           fe_numbering_style,
  2241.                                                           args, n);
  2242.     w_data->bullet_pulldown = fe_create_style_pulldown(list_form,
  2243.                                                        "bulletStyle",
  2244.                                                        fe_bullet_style,
  2245.                                                        args, n);
  2246.  
  2247.     n = 0;
  2248.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2249.     XtSetArg(args[n], XmNtopWidget, list_style_label); n++;
  2250.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  2251.     XtSetArg(args[n], XmNleftWidget, list_style_option); n++;
  2252.     XtSetArg(args[n], XmNsubMenuId, w_data->bullet_pulldown); n++;
  2253.     bullet_style_option = fe_CreateOptionMenu(list_form, "bulletStyle", args, n);
  2254.     fe_UnmanageChild_safe(XmOptionLabelGadget(bullet_style_option));
  2255.     XtManageChild(bullet_style_option);
  2256.  
  2257.     fe_register_dependent(w_data->properties, bullet_style_option,
  2258.                           FE_MAKE_DEPENDENCY(PROP_PARA_BULLET|PROP_PARA_LIST),
  2259.                           fe_bullet_style_menu_update_cb, (XtPointer)w_data);
  2260.  
  2261.     n = 0;
  2262.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2263.     XtSetArg(args[n], XmNtopWidget, bullet_style_option); n++;
  2264.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  2265.     XtSetArg(args[n], XmNrightWidget, bullet_style_option); n++;
  2266.     w_data->start_text = starting_text = 
  2267.         fe_CreateTextField(list_form, "startText", args, n);
  2268.     XtManageChild(starting_text);
  2269.  
  2270.     XtAddCallback(starting_text, XmNvalueChangedCallback,
  2271.                   fe_paragraph_start_cb, (XtPointer)w_data);
  2272.     fe_register_dependent(w_data->properties, starting_text,
  2273.                           FE_MAKE_DEPENDENCY(PROP_PARA_BULLET|PROP_PARA_LIST),
  2274.                           fe_paragraph_start_update_cb, (XtPointer)w_data);
  2275.  
  2276.     n = 0;
  2277.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2278.     XtSetArg(args[n], XmNtopWidget, bullet_style_option); n++;
  2279.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  2280.     XtSetArg(args[n], XmNrightWidget, starting_text); n++;
  2281.     starting_label = XmCreateLabelGadget(list_form, "startLabel", args, n);
  2282.     XtManageChild(starting_label);
  2283.  
  2284.     /*
  2285.      *    Align.
  2286.      */
  2287.     n = 0;
  2288.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2289.     XtSetArg(args[n], XmNtopWidget, list_frame); n++;
  2290.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2291.     align_frame = fe_CreateFrame(form, "align", args, n);
  2292.     XtManageChild(align_frame);
  2293.  
  2294.     n = 0;
  2295.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  2296.     XtSetArg(args[n], XmNradioBehavior, TRUE); n++;
  2297.     align_rc = XmCreateRowColumn(align_frame, "align", args, n);
  2298.     XtManageChild(align_rc);
  2299.  
  2300.     for (nchildren = 0; fe_align_style[nchildren].name; nchildren++) {
  2301.         n = 0;
  2302.         XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  2303.         XtSetArg(args[n], XmNuserData, fe_align_style[nchildren].data); n++;
  2304.         children[nchildren] = XmCreateToggleButtonGadget(
  2305.                                              align_rc,
  2306.                                              fe_align_style[nchildren].name,
  2307.                                              args, n);
  2308.  
  2309.         XtAddCallback(children[nchildren], XmNvalueChangedCallback,
  2310.                       fe_paragraph_align_cb, (XtPointer)w_data);
  2311.         fe_register_dependent(w_data->properties,
  2312.                              children[nchildren], 
  2313.                              FE_MAKE_DEPENDENCY(PROP_PARA_ALIGN),
  2314.                              fe_paragraph_align_update_cb, (XtPointer)w_data);
  2315.     }
  2316.  
  2317.     XtManageChildren(children, nchildren);
  2318.  
  2319. #if 0
  2320.     /* Humour for Beta */
  2321.     /* Apparently our testers have no humour - oh well */
  2322.     n = 0;
  2323.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  2324.     XtSetArg(args[n], XmNtopWidget, align_frame); n++;
  2325.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  2326.     align_rc = XmCreateLabelGadget(form, "spaceAvailable", args, n);
  2327.     XtManageChild(align_rc);
  2328. #endif
  2329. }
  2330.  
  2331. static void
  2332. fe_link_text_changed_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2333. {
  2334.     fe_EditorLinkPropertiesWidgets* w_data =
  2335.         (fe_EditorLinkPropertiesWidgets*)closure;
  2336.     
  2337.     fe_update_dependents(widget, w_data->properties, PROP_LINK_TEXT);
  2338. }
  2339.  
  2340. static char*
  2341. fe_image_get_name(fe_EditorImagePropertiesWidgets* w_data)
  2342. {
  2343.     char* p = NULL;
  2344.  
  2345.     if (w_data->main_image)
  2346.         p = fe_TextFieldGetString(w_data->main_image);
  2347.     
  2348.     if (!p && w_data->alt_image)
  2349.         p = fe_TextFieldGetString(w_data->alt_image);
  2350.  
  2351.     if (!p && w_data->alt_text)
  2352.         p = fe_TextFieldGetString(w_data->alt_text);
  2353.  
  2354.     return p;
  2355. }
  2356.  
  2357. static void
  2358. fe_link_text_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2359. {
  2360.     fe_EditorLinkPropertiesWidgets* w_data =
  2361.         (fe_EditorLinkPropertiesWidgets*)closure;
  2362.     fe_DependentListCallbackStruct* info = 
  2363.         (fe_DependentListCallbackStruct*)call_data;
  2364.     Boolean enabled = FALSE;
  2365.     char*   text;
  2366.     char* free_text = NULL;
  2367.     char* label_string;
  2368.     int   id;
  2369.     XmString xm_string;
  2370.  
  2371.     if (info->caller == widget)
  2372.         return; /* don't call ourselves */
  2373.  
  2374.     /*
  2375.      *    If we have an image, use the image name as the current
  2376.      *    displayed text.
  2377.      */
  2378.     if (w_data->properties->image != NULL) {
  2379.         free_text = text = fe_image_get_name(w_data->properties->image);
  2380.         enabled = FALSE;
  2381.         id = XFE_EDITOR_LINK_TEXT_LABEL_IMAGE;
  2382.         /* Linked image: */
  2383.     } else if (w_data->text) {
  2384.         text = w_data->text;
  2385.         enabled = FALSE;
  2386.         id = XFE_EDITOR_LINK_TEXT_LABEL_TEXT;
  2387.         /* Linked text: */
  2388.     } else {
  2389.         text = "";
  2390.         enabled = TRUE;
  2391.         id = XFE_EDITOR_LINK_TEXT_LABEL_NEW;
  2392.         /* Enter the text of the link: */
  2393.     }
  2394.  
  2395.     fe_set_text_field(widget, text, fe_link_text_changed_cb,(XtPointer)w_data);
  2396.     fe_TextFieldSetEditable(w_data->properties->context, widget, enabled);
  2397.     
  2398.     /*
  2399.      *    While we are here set the label also.
  2400.      */
  2401.     label_string = XP_GetString(id);
  2402.     xm_string = XmStringCreateLocalized(label_string);
  2403.     XtVaSetValues(w_data->displayed_label, XmNlabelString, xm_string, 0);
  2404.     XmStringFree(xm_string);
  2405.  
  2406.     if (free_text)
  2407.         XtFree(free_text);
  2408. }
  2409.  
  2410. static void
  2411. fe_link_href_changed_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2412. {
  2413.     
  2414.     fe_EditorLinkPropertiesWidgets* w_data =
  2415.         (fe_EditorLinkPropertiesWidgets*)closure;
  2416.  
  2417.     fe_update_dependents(widget, w_data->properties, PROP_LINK_HREF);
  2418. }
  2419.  
  2420. static void
  2421. fe_link_href_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2422. {
  2423.     fe_EditorLinkPropertiesWidgets* w_data =
  2424.         (fe_EditorLinkPropertiesWidgets*)closure;
  2425.     fe_DependentListCallbackStruct* info = 
  2426.         (fe_DependentListCallbackStruct*)call_data;
  2427.     char*   text;
  2428.  
  2429.     if (info->caller == widget)
  2430.         return; /* don't call ourselves */
  2431.  
  2432.     /*
  2433.      *    If we have an image, use the image name as the current
  2434.      *    displayed text.
  2435.      */
  2436.     if (w_data->url) {
  2437.         text = w_data->url;
  2438.     } else {
  2439.         text = "";
  2440.     }
  2441.  
  2442.     fe_set_text_field(widget, text, fe_link_href_changed_cb,(XtPointer)w_data);
  2443.     w_data->url = NULL;
  2444. }
  2445.  
  2446. static char*
  2447. fe_basename(char* target, char* source)
  2448. {
  2449.     char* p;
  2450.             
  2451.     p = strrchr(source, '/'); /* find last slash */
  2452.  
  2453.     if (p) { /* should be */
  2454.         strcpy(target, p+1);
  2455.     } else {
  2456.         strcpy(target, source);
  2457.     }
  2458.     return target;
  2459. }
  2460.  
  2461. static char*
  2462. fe_dirname(char* target, char* source)
  2463. {
  2464.     char* p;
  2465.             
  2466.     p = strrchr(source, '/'); /* find last slash */
  2467.  
  2468.     if (p) { /* should be */
  2469.         if (p == source) {
  2470.             strcpy(target, "/");
  2471.         } else {
  2472.             memcpy(target, source, p - source);
  2473.             target[p - source] = '\0';
  2474.         }
  2475.     } else {
  2476.         strcpy(target, ".");
  2477.     }
  2478.     return target;
  2479. }
  2480.  
  2481. static Boolean
  2482. fe_file_has_same_directory(MWContext* context, char* pathname)
  2483. {
  2484.     char my_dirname[MAXPATHLEN];
  2485.     char your_dirname[MAXPATHLEN];
  2486.  
  2487.     fe_EditorMakeName(context, your_dirname, sizeof(your_dirname));
  2488.     fe_dirname(my_dirname, your_dirname);
  2489.     fe_dirname(your_dirname, pathname);
  2490.  
  2491.     return (strcmp(my_dirname, your_dirname) == 0);
  2492. }
  2493.  
  2494. static void
  2495. fe_link_properties_list_update(fe_EditorLinkPropertiesWidgets*, Boolean);
  2496.  
  2497. static void
  2498. fe_editor_browse_file_of_text(MWContext* context, Widget text_field)
  2499. {
  2500.     char* before_save;
  2501.     char* before_changed = NULL;
  2502.     char* after;
  2503.     char* p;
  2504.  
  2505.     /*
  2506.      *    Strip #target from the browse default filename.
  2507.      */
  2508.     before_save = fe_TextFieldGetString(text_field);
  2509.  
  2510.     /*
  2511.      *    If the text field is a http: form URL, then zero it,
  2512.      *    because we are not browsing for a file.
  2513.      */
  2514.     if (before_save != NULL) {
  2515.         fe_StringTrim(before_save);
  2516.  
  2517.         if ((p = strchr(before_save, ':')) != NULL) {
  2518.             if (NET_IsLocalFileURL(before_save)) {
  2519.                 before_changed = XtNewString(&p[1]);
  2520.             } else {
  2521.                 before_changed = XtNewString("");
  2522.             }
  2523.         } else if ((p = strchr(before_save, '#')) != NULL) {
  2524.             *p = '\0';
  2525.             before_changed = XtNewString(before_save);
  2526.             *p = '#';
  2527.         }
  2528.         if (before_changed != NULL)
  2529.             fe_TextFieldSetString(text_field, before_changed, FALSE);
  2530.     }
  2531.     
  2532.     fe_browse_file_of_text(context, text_field, FALSE);
  2533.  
  2534.     after = fe_TextFieldGetString(text_field);
  2535.     fe_StringTrim(after);
  2536.  
  2537.     /*
  2538.      *    If we zapped it, and there was no change by the user,
  2539.      *    put it back the way it was.
  2540.      */
  2541.     if (before_changed != NULL && strcmp(after, before_changed) == 0) {
  2542.         fe_TextFieldSetString(text_field, before_save, FALSE);
  2543.     }
  2544.     /*
  2545.      *    Or, if the main file, and the link file are in the same
  2546.      *    directory, simplfy the name.
  2547.      */
  2548.     else if (fe_file_has_same_directory(context, after)) {
  2549.         char  basename[MAXPATHLEN];
  2550.         fe_basename(basename, after);
  2551.         fe_TextFieldSetString(text_field, basename, FALSE);
  2552.     }
  2553.  
  2554.     if (before_save)
  2555.         XtFree(before_save);
  2556.     if (before_changed)
  2557.         XtFree(before_changed);
  2558.     if (after)
  2559.         XtFree(after);
  2560. }
  2561.  
  2562. static void
  2563. fe_link_href_browse_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2564. {
  2565.     fe_EditorLinkPropertiesWidgets* w_data =
  2566.         (fe_EditorLinkPropertiesWidgets*)closure;
  2567.     MWContext* context = w_data->properties->context;
  2568.     Widget text_field = w_data->link_text;
  2569.  
  2570.     fe_editor_browse_file_of_text(context, text_field);
  2571.  
  2572.     fe_update_dependents(widget, w_data->properties, PROP_LINK_LIST);
  2573.  
  2574.     /*
  2575.      *    Set the toggle to selected file, and update.
  2576.      */
  2577.     XmToggleButtonGadgetSetState(w_data->target_current_doc, FALSE, FALSE);
  2578.     XmToggleButtonGadgetSetState(w_data->target_selected_file, TRUE, FALSE);
  2579.  
  2580.     fe_link_properties_list_update(w_data, FALSE);
  2581. }
  2582.  
  2583. static void
  2584. fe_browse_to_text_field_cb(Widget widget,
  2585.                            XtPointer closure, XtPointer call_data)
  2586. {
  2587.     MWContext* context = (MWContext*)closure;
  2588.     Widget     text_field = (Widget)fe_GetUserData(widget);
  2589.  
  2590.     fe_browse_file_of_text(context, text_field, FALSE);
  2591. }
  2592.  
  2593. static void
  2594. fe_link_tab_remove_link(fe_EditorLinkPropertiesWidgets* w_data)
  2595. {
  2596.     w_data->url = NULL;
  2597.  
  2598.     fe_update_dependents(NULL, w_data->properties, PROP_LINK_HREF);
  2599. }
  2600.  
  2601. static void
  2602. fe_link_href_remove_cb(Widget widget, XtPointer closure, XtPointer call_data)
  2603. {
  2604.     fe_EditorLinkPropertiesWidgets* w_data =
  2605.         (fe_EditorLinkPropertiesWidgets*)closure;
  2606.  
  2607.     fe_link_tab_remove_link(w_data);
  2608. }
  2609.  
  2610. static Boolean
  2611. fe_link_tab_has_link(fe_EditorLinkPropertiesWidgets* w_data)
  2612. {
  2613.     char*   link_text;
  2614.     Boolean rv = FALSE;
  2615.  
  2616.     if (w_data != NULL) {
  2617.         /* 
  2618.          *    get the link text, to see if there any.
  2619.          */
  2620.         link_text = fe_TextFieldGetString(w_data->link_text);
  2621.  
  2622.         if (link_text != NULL) {
  2623.             if (link_text[0] != '\0') /* has a link */
  2624.                 rv = TRUE;
  2625.             XP_FREEIF(link_text);
  2626.         }
  2627.     }
  2628.     
  2629.     return rv;
  2630. }
  2631.  
  2632. static void
  2633. fe_link_href_remove_update_cb(Widget widget,
  2634.                               XtPointer closure, XtPointer call_data)
  2635. {
  2636.     fe_EditorLinkPropertiesWidgets* w_data =
  2637.         (fe_EditorLinkPropertiesWidgets*)closure;
  2638.     Boolean sensitive = fe_link_tab_has_link(w_data);
  2639.  
  2640.     fe_WidgetSetSensitive(widget, sensitive);
  2641. }
  2642.  
  2643. #if 0
  2644. static void
  2645. fe_ListAddItems(Widget widget, char** items, unsigned nitems)
  2646. {
  2647.     unsigned i;
  2648.     XmString xm_string;
  2649.  
  2650.     XmListDeleteAllItems(widget);
  2651.  
  2652.     for (i = 0; i < nitems; i++) {
  2653.         xm_string = XmStringCreateLocalized(items[i]);
  2654.         XmListAddItem(widget, xm_string, i + 1); /* MOTIFism */
  2655.         XmStringFree(xm_string);
  2656.     }
  2657. }
  2658. #endif
  2659.  
  2660. static void
  2661. fe_ListSetFromLtabbList(Widget widget, EDT_LtabbList_t ltabb_list)
  2662. {
  2663.     char*    p;
  2664.     XmString xm_string;
  2665.     unsigned len;
  2666.     unsigned i;
  2667.  
  2668.     XmListDeleteAllItems(widget);
  2669.  
  2670.     if (ltabb_list) {
  2671.         for (p = ltabb_list, i = 0; (len = XP_STRLEN(p)) > 0; i++) {
  2672.             xm_string = XmStringCreateLocalized(p);
  2673.             XmListAddItem(widget, xm_string, i + 1); /* MOTIFism */
  2674.             XmStringFree(xm_string);
  2675.             p += len + 1;
  2676.         }
  2677.     }
  2678. }
  2679.  
  2680. static char*
  2681. fe_LtabbListGetItem(EDT_LtabbList_t ltabb_list, unsigned index)
  2682. {
  2683.     unsigned i;
  2684.     char* p;
  2685.     unsigned len;
  2686.  
  2687.     if (ltabb_list) {
  2688.         for (p = ltabb_list, i = 0; (len = XP_STRLEN(p)) > 0; i++) {
  2689.             if (i == index)
  2690.                 return p;
  2691.             p += len + 1;
  2692.         }
  2693.     }
  2694.     return NULL;
  2695. }
  2696.  
  2697. static void
  2698. fe_link_properties_list_cb(Widget widget, XtPointer closure,
  2699.                                     XtPointer foo)
  2700. {
  2701.     fe_EditorLinkPropertiesWidgets* w_data = 
  2702.       (fe_EditorLinkPropertiesWidgets*)closure;
  2703.     XmListCallbackStruct* cb_data = (XmListCallbackStruct*)foo;
  2704.     char  basename[MAXPATHLEN];
  2705.     char  buf[MAXPATHLEN];
  2706.     char* pathname;
  2707.     char* p;
  2708.     char* target_name;
  2709.     Boolean current_doc;
  2710.  
  2711.     current_doc = XmToggleButtonGadgetGetState(w_data->target_current_doc);
  2712.     
  2713.     if (cb_data->reason != XmCR_SINGLE_SELECT)
  2714.           return;
  2715.  
  2716.     if (cb_data->item_position > 0) {
  2717.         target_name = fe_LtabbListGetItem(w_data->target_list_data,
  2718.                                           cb_data->item_position - 1);
  2719.     } else {
  2720.         target_name = NULL;
  2721.     }
  2722.  
  2723.     if (current_doc) {
  2724.         pathname = NULL;
  2725.     } else {
  2726.         pathname = fe_TextFieldGetString(w_data->link_text);
  2727.  
  2728.         if ((p = strchr(pathname, '#')) != NULL) {
  2729.             memcpy(basename, pathname, p - pathname);
  2730.             basename[p - pathname] = '\0';
  2731.         } else {
  2732.             strcpy(basename, pathname);
  2733.         }
  2734.  
  2735.         XtFree(pathname);
  2736.         pathname = basename;
  2737.  
  2738.         if (pathname[0] == '\0')
  2739.             pathname = NULL;
  2740.     }
  2741.     
  2742.     if (pathname != NULL && target_name != NULL) {
  2743.         strcpy(buf, pathname);
  2744.         strcat(buf, "#");
  2745.         strcat(buf, target_name);
  2746.     } else if (target_name != NULL) {
  2747.         strcpy(buf, "#");
  2748.         strcat(buf, target_name);
  2749.     } else {
  2750.         buf[0] = '\0';
  2751.     }
  2752.  
  2753.     fe_TextFieldSetString(w_data->link_text, buf, FALSE);
  2754.     w_data->properties->changed |= PROP_LINK_HREF;
  2755. }
  2756.  
  2757. static void
  2758. fe_link_properties_list_update(fe_EditorLinkPropertiesWidgets* w_data,
  2759.                                   Boolean current_file)
  2760. {
  2761.     MWContext* context = w_data->properties->context;
  2762.     char* link_text;
  2763.     EDT_LtabbList_t list_data = NULL;
  2764.     char* crazy;
  2765.     XmString xm_string;
  2766.     int id;
  2767.  
  2768.     if (w_data->target_list_data)
  2769.         XP_FREE(w_data->target_list_data);
  2770.     
  2771.     if (current_file) {
  2772.         list_data = EDT_GetAllDocumentTargets(context);
  2773.     } else {
  2774.         link_text = fe_TextFieldGetString(w_data->link_text);
  2775.         if (link_text && link_text[0] != '\0') {
  2776.             list_data =    EDT_GetAllDocumentTargetsInFile(context, link_text);
  2777.         }
  2778.         XtFree(link_text);
  2779.     }
  2780.  
  2781.     if (list_data && XP_STRLEN(list_data) == 0) {
  2782.         XP_FREE(list_data);
  2783.         list_data = NULL;
  2784.     }
  2785.  
  2786.     if (list_data && current_file)
  2787.         id = XFE_EDITOR_LINK_TARGET_LABEL_CURRENT;
  2788.          /* Link to a named target in the current document (optional.) */
  2789.     else if (list_data && !current_file)
  2790.         id = XFE_EDITOR_LINK_TARGET_LABEL_SPECIFIED;
  2791.         /* Link to a named target in the specified document (optional.) */
  2792.     else
  2793.         id = XFE_EDITOR_LINK_TARGET_LABEL_NO_TARGETS;
  2794.         /* No targets in the selected document */
  2795.  
  2796.     crazy = XP_GetString(id);
  2797.     xm_string = XmStringCreateLocalized(crazy);
  2798.     XtVaSetValues(w_data->target_label, XmNlabelString, xm_string, 0);
  2799.     XmStringFree(xm_string);
  2800.     
  2801.     w_data->target_list_data = list_data;
  2802.  
  2803.     fe_ListSetFromLtabbList(w_data->target_list, w_data->target_list_data);
  2804.     XmToggleButtonGadgetSetState(w_data->target_current_doc,
  2805.                                  current_file, FALSE);
  2806.     XmToggleButtonGadgetSetState(w_data->target_selected_file,
  2807.                                  !current_file, FALSE);
  2808. }
  2809.  
  2810. static void
  2811. fe_link_properties_list_update_cb(Widget widget, XtPointer closure,
  2812.                                     XtPointer cb_data)
  2813. {
  2814.     fe_EditorLinkPropertiesWidgets* w_data = 
  2815.         (fe_EditorLinkPropertiesWidgets*)closure;
  2816.     Boolean set = XmToggleButtonGadgetGetState(w_data->target_current_doc);
  2817.  
  2818.     fe_link_properties_list_update(w_data, set);
  2819. }
  2820.  
  2821. static void
  2822. fe_link_properties_target_toggle_cb(Widget widget, XtPointer closure,
  2823.                                     XtPointer cb_data)
  2824. {
  2825.     fe_EditorLinkPropertiesWidgets* w_data = 
  2826.         (fe_EditorLinkPropertiesWidgets*)closure;
  2827.     Boolean current_file = (widget == w_data->target_current_doc);
  2828.     Boolean set = XmToggleButtonGadgetGetState(widget);
  2829.     
  2830.     fe_link_properties_list_update(w_data, (set == current_file));
  2831. }
  2832.  
  2833. /*
  2834.  *   Load the form context.
  2835.  */
  2836. static void
  2837. fe_editor_link_properties_dialog_data_init(
  2838.                                      MWContext* context,
  2839.                                      fe_EditorLinkPropertiesWidgets* w_data)
  2840. {
  2841.     char* text;
  2842.     char* href;
  2843.     char* p;
  2844.     Boolean text_exists;
  2845.  
  2846.     /*
  2847.      *    If we are on something a link, we display the text that is
  2848.      *    selected, or nothing. Text is read only. If we are not on
  2849.      *    a link, text field is editable.
  2850.      *
  2851.      *    If we are on a link, we display that link, this field
  2852.      *    is always editable.
  2853.      */
  2854.     text_exists = fe_EditorHrefGet(context, &text, &href);
  2855.  
  2856.     /* if (!text_exists)    
  2857.         return;
  2858.      */
  2859.  
  2860.     /*
  2861.      *   Replace CR/LF with spaces to avoid ugly break in static display
  2862.      */
  2863.     if (text) {
  2864.         for (p = text; *p; p++) {
  2865.             if (*p == '\n' || *p == '\r')
  2866.                 *p = ' ';
  2867.         }
  2868.         w_data->text = text;
  2869.     } else {
  2870.         w_data->text = NULL;
  2871.     }
  2872.  
  2873.     if (href) {
  2874.         w_data->url = href;
  2875.         if (w_data->text == NULL)
  2876.             w_data->text = "";
  2877.     } else {
  2878.         w_data->url = NULL;
  2879.     }
  2880.  
  2881.     fe_update_dependents(NULL, w_data->properties, PROP_LINK_ALL);
  2882.  
  2883.     /*
  2884.      *    Don't know what these are yet.
  2885.      */
  2886.     w_data->selected_filename = NULL;
  2887.     fe_link_properties_list_update(w_data, TRUE);
  2888.  
  2889.     if (text)
  2890.         XtFree(text);
  2891.     if (href)
  2892.         XtFree(href);
  2893. }
  2894.  
  2895. static void
  2896. fe_editor_link_properties_dialog_set(
  2897.                                      MWContext* context,
  2898.                                      fe_EditorLinkPropertiesWidgets* w_data)
  2899. {
  2900.     char* displayed_text;
  2901.     char* link_text;
  2902.  
  2903.     displayed_text = fe_TextFieldGetString(w_data->displayed_text);
  2904.     link_text = fe_TextFieldGetString(w_data->link_text);
  2905.     
  2906.     /*
  2907.      *    If the text field was editable, then we are creating a new
  2908.      *    link. I don't really like carrying state around in the
  2909.      *    values of the widgets, but this should work ok...djw.
  2910.      */
  2911.     if (XmTextFieldGetEditable(w_data->displayed_text)) {
  2912.         if (link_text && (link_text[0] != '\0')) /* don't anything if no link! */
  2913.             fe_EditorHrefInsert(context, displayed_text, link_text);
  2914.     } else { /* modify exiting link/text */
  2915.         if (link_text && link_text[0] == '\0')
  2916.             fe_EditorHrefSetUrl(context, NULL);
  2917.         else
  2918.             fe_EditorHrefSetUrl(context, link_text);
  2919.     }
  2920.     
  2921.     if (displayed_text)
  2922.         XP_FREEIF(displayed_text);
  2923.     if (link_text)
  2924.         XP_FREEIF(link_text);
  2925. }
  2926.  
  2927. static void
  2928. fe_make_link_page(
  2929.                   MWContext* context,
  2930.                   Widget     parent,
  2931.                   fe_EditorLinkPropertiesWidgets* w_data
  2932.                   )
  2933. {
  2934.   Arg av [50];
  2935.   int ac;
  2936.   Widget form;
  2937.   Widget linkSourceLabel, sourceFrame, sourceForm;
  2938.   Widget linkToLabel, linkToFrame, linkToForm;
  2939.   Widget sourceTextLabel;
  2940.   Widget linkedTextLabel;
  2941.   Widget linkToTarget;
  2942.   Widget linkToBrowseFile;
  2943.   Widget linkToRemoveLink;
  2944.   Widget linkPageTextField;
  2945.   Widget sourceTextField;
  2946.   Widget target_list;
  2947.   Widget SelectedFileToggle;
  2948.   Widget currentDocToggle;
  2949.   Widget linkToShowTargets;
  2950.   Widget kids [100];
  2951.   Widget target_rc;
  2952.   Widget list_parent;
  2953.   Pixel  parent_bg;
  2954.  
  2955.   int i;
  2956.  
  2957.   XtVaGetValues(parent, XmNbackground, &parent_bg, 0);
  2958.  
  2959. #if 0
  2960.   ac = 0;
  2961.   XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  2962.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  2963.   XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  2964.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  2965.   form = XmCreateForm(parent, "linkProperties", av, ac);
  2966.   XtManageChild (form);
  2967. #else
  2968.   form = parent;
  2969. #endif
  2970.   w_data->form = form;
  2971.     
  2972.   /**********************************************************************/
  2973.   /*  Create the Link source frame and form 28FEB96RCJ            */
  2974.   /**********************************************************************/
  2975.   ac = 0;
  2976.   XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  2977.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  2978.   XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  2979.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
  2980.   sourceFrame = XmCreateFrame (form, "linkSourceFrame", av, ac);
  2981.   ac = 0;
  2982.   XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  2983.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  2984.   XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  2985.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
  2986.   sourceForm = XmCreateForm (sourceFrame, "linkSourceForm", av, ac);
  2987.  
  2988.   /**********************************************************************/
  2989.   /*  Create the Link To frame and form 28FEB96RCJ            */
  2990.   /**********************************************************************/
  2991.   ac = 0;
  2992.   XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  2993.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  2994.   XtSetArg (av [ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  2995.   XtSetArg (av [ac], XmNtopWidget, sourceFrame); ac++;
  2996. #if 0
  2997.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  2998. #endif
  2999.   linkToFrame = XmCreateFrame (form, "linkToFrame", av, ac);
  3000.  
  3001.   ac = 0;
  3002.   XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  3003.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  3004.   XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  3005.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  3006.   linkToForm = XmCreateForm (linkToFrame, "linkToForm", av, ac);
  3007.  
  3008.   /**********************************************************************/
  3009.   /*  Create the titles for the frames 28FEB96RCJ            */
  3010.   /**********************************************************************/
  3011.   ac = 0;
  3012.   XtSetArg (av [ac], XmNchildType, XmFRAME_TITLE_CHILD); ac++;
  3013.   linkSourceLabel = XmCreateLabelGadget (sourceFrame, "linkSourceTitle", av, ac);
  3014.   linkToLabel = XmCreateLabelGadget (linkToFrame, "linkToTitle", av, ac);
  3015.  
  3016.   /**********************************************************************/
  3017.   /*  Create and manage the contents of the source form and frame    */
  3018.   /**********************************************************************/
  3019.   ac = 0;
  3020.   i = 0;
  3021.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_FORM); ac++;
  3022.   XtSetArg (av [ac], XmNleftAttachment,   XmATTACH_FORM); ac++;
  3023.   kids [i++] = sourceTextLabel = XmCreateLabelGadget (sourceForm, 
  3024.                                                       "linkSourceLabel",
  3025.                               av, ac);
  3026.   w_data->displayed_label = sourceTextLabel;
  3027.  
  3028.   ac = 0;
  3029.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  3030.   XtSetArg (av [ac], XmNtopWidget,       sourceTextLabel); ac++;
  3031.   XtSetArg (av [ac], XmNleftAttachment,  XmATTACH_FORM);   ac++;
  3032.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM);   ac++;
  3033.   kids [i++] = sourceTextField = fe_CreateTextField (sourceForm, 
  3034.                                                      "linkSourceText", 
  3035.                                                      av, ac);
  3036.   w_data->displayed_text = sourceTextField;
  3037.  
  3038.   XtAddCallback(sourceTextField, XmNvalueChangedCallback,
  3039.                 fe_link_text_changed_cb, (XtPointer)w_data);
  3040.   fe_register_dependent(w_data->properties, sourceTextField,
  3041.                         FE_MAKE_DEPENDENCY(PROP_LINK_TEXT),
  3042.                         fe_link_text_update_cb, (XtPointer)w_data);
  3043.  
  3044.   XtManageChildren (kids, i);
  3045.   XtManageChild (linkSourceLabel);
  3046.   XtManageChild (sourceForm);
  3047.  
  3048.   /**********************************************************************/
  3049.   /*  Create and manage the contents of the Link to form and frame    */
  3050.   /**********************************************************************/
  3051.   ac = 0;
  3052.   i = 0;
  3053.   XtSetArg (av [ac], XmNleftAttachment,   XmATTACH_FORM);   ac++;
  3054.   XtSetArg (av [ac], XmNtopAttachment,    XmATTACH_FORM);   ac++;
  3055.   kids [i++] = linkedTextLabel = XmCreateLabelGadget (linkToForm, 
  3056.                                                     "linkToLabel",
  3057.                             av, ac);
  3058.   ac = 0;
  3059.   XtSetArg (av [ac], XmNleftAttachment,   XmATTACH_WIDGET); ac++;
  3060.   XtSetArg (av [ac], XmNleftWidget,       linkedTextLabel); ac++;
  3061.   XtSetArg (av [ac], XmNtopAttachment,    XmATTACH_FORM);   ac++;
  3062.   kids [i++] = linkToBrowseFile = XmCreatePushButtonGadget (linkToForm,
  3063.                                                "browseFile",
  3064.                                                av, ac);
  3065.   XtAddCallback(linkToBrowseFile, XmNactivateCallback,
  3066.                 fe_link_href_browse_cb, (XtPointer)w_data);
  3067.  
  3068.   ac = 0;
  3069.   XtSetArg (av [ac], XmNleftAttachment,   XmATTACH_WIDGET);  ac++;
  3070.   XtSetArg (av [ac], XmNleftWidget,       linkToBrowseFile); ac++;
  3071.   XtSetArg (av [ac], XmNtopAttachment,    XmATTACH_FORM);    ac++;
  3072.   kids [i++] = linkToRemoveLink = XmCreatePushButtonGadget (linkToForm,
  3073.                                                "removeLink",
  3074.                                                av, ac);
  3075.   XtAddCallback(linkToRemoveLink, XmNactivateCallback,
  3076.                 fe_link_href_remove_cb, (XtPointer)w_data);
  3077.   fe_register_dependent(w_data->properties, linkToRemoveLink,
  3078.                         FE_MAKE_DEPENDENCY(PROP_LINK_HREF),
  3079.                         fe_link_href_remove_update_cb, (XtPointer)w_data);
  3080.   
  3081.   ac = 0;
  3082.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  3083.   XtSetArg (av [ac], XmNtopWidget,       linkedTextLabel); ac++;
  3084.   XtSetArg (av [ac], XmNtopOffset,       10);              ac++;
  3085.   XtSetArg (av [ac], XmNleftAttachment,  XmATTACH_FORM);   ac++;
  3086.   XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM);   ac++;
  3087.   kids [i++] = linkPageTextField = fe_CreateTextField (linkToForm, 
  3088.                                                        "linkPageTextField", 
  3089.                                                        av, ac);
  3090.   w_data->link_text = linkPageTextField;
  3091.   XtAddCallback(linkPageTextField, XmNvalueChangedCallback,
  3092.                 fe_link_href_changed_cb, (XtPointer)w_data);
  3093.   fe_register_dependent(w_data->properties, linkPageTextField,
  3094.                         FE_MAKE_DEPENDENCY(PROP_LINK_HREF),
  3095.                         fe_link_href_update_cb, (XtPointer)w_data);
  3096.  
  3097.   ac = 0;
  3098.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_WIDGET);   ac++;
  3099.   XtSetArg (av [ac], XmNtopWidget,       linkPageTextField); ac++;
  3100.   XtSetArg (av [ac], XmNleftAttachment,  XmATTACH_FORM);     ac++;
  3101.   XtSetArg (av [ac], XmNalignment, XmALIGNMENT_BEGINNING);   ac++;
  3102.   kids [i++] = linkToTarget = XmCreateLabelGadget (linkToForm,
  3103.                                                    "linkTarget",
  3104.                                                    av, ac);
  3105.   w_data->target_label = linkToTarget;
  3106.  
  3107.   /*
  3108.    *    RowColumn to hold the buttons to right of target text.
  3109.    */
  3110.   ac = 0;
  3111.   XtSetArg (av [ac], XmNorientation, XmVERTICAL);   ac++;
  3112.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_WIDGET);   ac++;
  3113.   XtSetArg (av [ac], XmNtopWidget,       linkToTarget);      ac++;
  3114.   XtSetArg (av [ac], XmNrightAttachment,  XmATTACH_FORM);     ac++;
  3115.   XtSetArg (av [ac], XmNpacking,  XmPACK_TIGHT);     ac++;
  3116.   kids[i++] = target_rc = XmCreateRowColumn(linkToForm,
  3117.                                             "targetRowColumn", av, ac);
  3118.  
  3119.   ac = 0;
  3120.   XtSetArg (av [ac], XmNtopAttachment,   XmATTACH_WIDGET);   ac++;
  3121.   XtSetArg (av [ac], XmNtopWidget,       linkToTarget);      ac++;
  3122.   XtSetArg (av [ac], XmNleftAttachment,  XmATTACH_FORM);     ac++;
  3123.   XtSetArg (av [ac], XmNrightAttachment,  XmATTACH_WIDGET);     ac++;
  3124.   XtSetArg (av [ac], XmNrightWidget,  target_rc);     ac++;
  3125. #if 0
  3126.   XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM);    ac++;
  3127. #endif
  3128.   XtSetArg(av[ac], XmNvisibleItemCount, 6); ac++;
  3129.   XtSetArg(av[ac], XmNselectionPolicy, XmSINGLE_SELECT); ac++;
  3130.   XtSetArg(av[ac], XmNbackground, parent_bg); ac++;
  3131.   target_list = XmCreateScrolledList(linkToForm, "targetList",
  3132.                                              av, ac);
  3133.   XtManageChild(target_list);
  3134.   kids [i++] = list_parent = XtParent(target_list);
  3135.  
  3136.   XtAddCallback(target_list, XmNsingleSelectionCallback,
  3137.                 fe_link_properties_list_cb, (XtPointer)w_data);
  3138.   fe_register_dependent(w_data->properties, target_list,
  3139.                         FE_MAKE_DEPENDENCY(PROP_LINK_LIST),
  3140.                         fe_link_properties_list_update_cb, (XtPointer)w_data);
  3141.  
  3142.   w_data->target_list = target_list;
  3143.  
  3144.   XtManageChildren (kids, i); /* children of form */
  3145.   XtManageChild (linkToLabel);
  3146.   XtManageChild (linkToForm);
  3147.  
  3148.   i = 0; /* no kids */
  3149.   ac = 0;
  3150.   XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  3151.   kids [i++] = linkToShowTargets = XmCreateLabelGadget(target_rc,
  3152.                                                        "showTargets",
  3153.                                                        av, ac);
  3154.  
  3155.   ac = 0;
  3156.   XtSetArg (av [ac], XmNalignment, XmALIGNMENT_BEGINNING);     ac++;
  3157.   XtSetArg(av[ac], XmNset, TRUE); ac++;
  3158.   XtSetArg(av[ac], XmNindicatorType, XmONE_OF_MANY); ac++;
  3159.   kids [i++] = currentDocToggle =
  3160.     XmCreateToggleButtonGadget(target_rc, "currentDocument", av, ac);
  3161.  
  3162.   w_data->target_current_doc = currentDocToggle;
  3163.  
  3164.   ac = 0;
  3165.   XtSetArg (av [ac], XmNalignment, XmALIGNMENT_BEGINNING);     ac++;
  3166.   XtSetArg(av[ac], XmNset, FALSE); ac++;
  3167.   XtSetArg(av[ac], XmNindicatorType, XmONE_OF_MANY); ac++;
  3168.   kids [i++] = SelectedFileToggle =
  3169.     XmCreateToggleButtonGadget (target_rc, "selectedFile", av, ac);
  3170.  
  3171.   w_data->target_selected_file = SelectedFileToggle;
  3172.   XtManageChildren (kids, i); /* children of rc */
  3173.  
  3174.   XtAddCallback(currentDocToggle, XmNvalueChangedCallback,
  3175.               fe_link_properties_target_toggle_cb, (XtPointer)w_data);
  3176.   XtAddCallback(SelectedFileToggle, XmNvalueChangedCallback,
  3177.               fe_link_properties_target_toggle_cb, (XtPointer)w_data);
  3178.  
  3179.   /**********************************************************************/
  3180.   /*  Manage all of the frame comprising the Link dialog box        */
  3181.   /**********************************************************************/
  3182.  
  3183.   i = 0;
  3184.   kids [i++] = sourceFrame;
  3185.   kids [i++] = linkToFrame;
  3186.   XtManageChildren (kids, i);
  3187.  
  3188. } /* end fe_make_link_page */
  3189.  
  3190. static struct fe_style_data fe_style_types[] = {
  3191.     { "bold",   TF_BOLD },
  3192.     { "italic", TF_ITALIC }, 
  3193.     { "underline", TF_UNDERLINE },
  3194.     { "fixed",  TF_FIXED },
  3195.     { "strikethrough", TF_STRIKEOUT },
  3196.     { "superscript",  TF_SUPER },
  3197.     { "subscript",    TF_SUB   },
  3198.     { "blink",  TF_BLINK },
  3199.     { 0 }
  3200. };
  3201.  
  3202. static struct fe_style_data fe_font_size_types[] = {
  3203.     { "minusTwo",  ED_FONTSIZE_MINUS_TWO },
  3204.     { "minusOne",  ED_FONTSIZE_MINUS_ONE },
  3205.     { "plusZero",  ED_FONTSIZE_ZERO      },
  3206.     { "plusOne",   ED_FONTSIZE_PLUS_ONE  },
  3207.     { "plusTwo",   ED_FONTSIZE_PLUS_TWO  },
  3208.     { "plusThree", ED_FONTSIZE_PLUS_THREE },
  3209.     { "plusFour",  ED_FONTSIZE_PLUS_FOUR },
  3210.     { NULL }
  3211. };
  3212.  
  3213. static void
  3214. fe_font_size_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3215. {
  3216.     fe_EditorCharacterPropertiesWidgets* w_data
  3217.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3218.  
  3219.     if (w_data->js_mode == JAVASCRIPT_NONE) {
  3220.         fe_OptionMenuSetHistory(widget, w_data->font_size - 1);
  3221.         fe_WidgetSetSensitive(XmOptionButtonGadget(widget), TRUE);
  3222.     } else {
  3223.         fe_OptionMenuSetHistory(widget, ED_FONTSIZE_ZERO - 1);
  3224.         fe_WidgetSetSensitive(XmOptionButtonGadget(widget), FALSE);
  3225.     }
  3226.     /*FIXME*/ /* fix sensitivity */
  3227. }
  3228.  
  3229. static void
  3230. fe_font_size_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3231. {
  3232.     fe_EditorCharacterPropertiesWidgets* w_data = (fe_EditorCharacterPropertiesWidgets*)closure;
  3233.  
  3234.     ED_FontSize size = (ED_FontSize)fe_GetUserData(widget);
  3235.  
  3236.     w_data->font_size = size;
  3237.     w_data->changed_mask |= TF_FONT_SIZE;
  3238.  
  3239.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_SIZE);
  3240. }
  3241.  
  3242. static void
  3243. fe_style_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3244. {
  3245.     fe_EditorCharacterPropertiesWidgets* w_data
  3246.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3247.     ED_TextFormat type;
  3248.     Boolean set;
  3249.     Boolean enabled;
  3250.     unsigned foo;
  3251.  
  3252.     if (w_data->js_mode == JAVASCRIPT_NONE) {
  3253.  
  3254.         foo = (unsigned)fe_GetUserData(widget);
  3255.         type = foo;
  3256.  
  3257.         if ((type &    w_data->text_attributes) != 0)
  3258.             set = TRUE;
  3259.         else
  3260.             set = FALSE;
  3261.  
  3262.         enabled = TRUE;
  3263.     } else {
  3264.         set = FALSE;
  3265.         enabled = FALSE;
  3266.     }
  3267.  
  3268.     XmToggleButtonGadgetSetState(widget, set, FALSE);
  3269.     fe_WidgetSetSensitive(widget, enabled);
  3270. }
  3271.                          
  3272. static void
  3273. fe_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3274. {
  3275.     fe_EditorCharacterPropertiesWidgets* w_data =
  3276.         (fe_EditorCharacterPropertiesWidgets*)closure;
  3277.     XmToggleButtonCallbackStruct* info =
  3278.         (XmToggleButtonCallbackStruct*)call_data;
  3279.     ED_TextFormat type;
  3280.     unsigned foo;
  3281.  
  3282.     foo = (unsigned)fe_GetUserData(widget);
  3283.     type = foo;
  3284.     
  3285.     if (info->set) {
  3286.         w_data->text_attributes |= type;
  3287.  
  3288.         /*
  3289.          *    Super and Sub should be mutually exclusive.
  3290.          */
  3291.         if (type == TF_SUPER)
  3292.             w_data->text_attributes &= ~TF_SUB;
  3293.         else if (type == TF_SUB)
  3294.             w_data->text_attributes &= ~TF_SUPER;
  3295.     } else {
  3296.         w_data->text_attributes &= ~type;
  3297.     }
  3298.  
  3299.     w_data->changed_mask |= type;
  3300.  
  3301.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_STYLE);
  3302. }
  3303.  
  3304. static void
  3305. fe_clear_style_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3306. {
  3307.     fe_EditorCharacterPropertiesWidgets*
  3308.         w_data = (fe_EditorCharacterPropertiesWidgets*)closure;
  3309.  
  3310.     w_data->text_attributes &= ~TF_ALL_MASK;
  3311.     w_data->changed_mask |= TF_ALL_MASK;
  3312.  
  3313.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_STYLE);
  3314. }
  3315.  
  3316. static void
  3317. fe_clearall_settings_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3318. {
  3319.     fe_EditorCharacterPropertiesWidgets* w_data
  3320.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3321.     MWContext* context;
  3322.     char* link_text;
  3323.  
  3324.     if (w_data->properties->link != NULL) {
  3325.         /* 
  3326.          *    get the link text, to see if there any.
  3327.          */
  3328.         link_text = fe_TextFieldGetString(w_data->properties->link->link_text);
  3329.  
  3330.         if (link_text != NULL && link_text[0] != '\0') { /* has a link */
  3331.             context = w_data->properties->context;
  3332.             /* Do you want to remove the link? */
  3333.             if (XFE_Confirm(context,
  3334.                             XP_GetString(XFE_EDITOR_WARNING_REMOVE_LINK)))
  3335.                 fe_link_tab_remove_link(w_data->properties->link);
  3336.         }
  3337.  
  3338.         if (link_text != NULL)
  3339.             XP_FREEIF(link_text);
  3340.     }
  3341.  
  3342.     w_data->js_mode = JAVASCRIPT_NONE;
  3343.     w_data->text_attributes &= ~TF_ALL_MASK;
  3344.     w_data->is_custom_color = FALSE;
  3345.     w_data->font_size = ED_FONTSIZE_ZERO;
  3346.     w_data->changed_mask |= TF_FONT_COLOR|TF_FONT_SIZE|TF_ALL_MASK|\
  3347.                             PROP_CHAR_CLIENT|PROP_CHAR_SERVER;
  3348.  
  3349.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_ALL);
  3350. }
  3351.  
  3352. static int
  3353. fe_color_do_work(MWContext* context, LO_Color* color_rv)
  3354. {
  3355.     Widget mainw = CONTEXT_WIDGET(context);
  3356.     Widget dialog;
  3357.     Arg args[8];
  3358.     Cardinal n;
  3359.     int done;
  3360.  
  3361.     n = 0;
  3362.     dialog = fe_CreateColorPickerDialog(mainw, "setColors", args, n);
  3363.     fe_ColorPickerDialogSetColor(dialog, color_rv);
  3364.     
  3365.     /*
  3366.      *   Add a bunch of callbacks to the buttons.
  3367.      */
  3368.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  3369.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  3370.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  3371.  
  3372.     /*
  3373.      *    Popup.
  3374.      */
  3375.     XtManageChild(dialog);
  3376.  
  3377.     /*
  3378.      *    Wait.
  3379.      */
  3380.     fe_NukeBackingStore(dialog); /* what does this do? */
  3381.  
  3382.     done = XmDIALOG_NONE;
  3383.     while (done == XmDIALOG_NONE) {
  3384.         fe_EventLoop();
  3385.     }
  3386.  
  3387.     if (done == XmDIALOG_OK_BUTTON)
  3388.         fe_ColorPickerDialogGetColor(dialog, color_rv);
  3389.     
  3390.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  3391.         XtDestroyWidget(dialog);
  3392.     
  3393.     if (done == XmDIALOG_OK_BUTTON)
  3394.         return XmDIALOG_OK_BUTTON;
  3395.     else
  3396.         return XmDIALOG_NONE;
  3397. }
  3398.  
  3399. static void
  3400. fe_color_swatch_update_cb(Widget widget, XtPointer closure,
  3401.                           XtPointer call_data)
  3402. {
  3403.     fe_EditorCharacterPropertiesWidgets* w_data
  3404.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3405.     LO_Color pooh;
  3406.     LO_Color* color;
  3407.     Boolean sensitive = FALSE;
  3408.  
  3409.     /*FIXME*/
  3410.     /*
  3411.      *    I'm not sure how to generate these colors.
  3412.      */
  3413.     if (w_data->js_mode == JAVASCRIPT_CLIENT) {
  3414.         pooh.red = 255;
  3415.         pooh.blue = 0;
  3416.         pooh.green = 0;
  3417.         color = &pooh;
  3418.     } else if (w_data->js_mode == JAVASCRIPT_SERVER) {
  3419.         pooh.red = 0;
  3420.         pooh.blue = 255;
  3421.         pooh.green = 0;
  3422.         color = &pooh;
  3423.     } else { /* JAVASCRIPT_NONE */
  3424.  
  3425.         if (w_data->is_custom_color) {
  3426.             color = &w_data->color;
  3427.             sensitive = TRUE;
  3428.         } else {
  3429.             MWContext* context = (MWContext *)fe_WidgetToMWContext(widget);
  3430.  
  3431.             fe_EditorDocumentGetColors(context,
  3432.                                        NULL, /* bg image */
  3433.                                        NULL,
  3434.                                        NULL, /* bg color */
  3435.                                        &pooh,/* normal color */
  3436.                                        NULL, /* link color */
  3437.                                        NULL, /* active color */
  3438.                                        NULL); /* followed color */
  3439.             color = &pooh;
  3440.         }
  3441.     } 
  3442.  
  3443.     fe_SwatchSetColor(widget, color);
  3444.     fe_SwatchSetSensitive(widget, sensitive);
  3445. }
  3446.  
  3447. Boolean
  3448. fe_ColorPicker(MWContext* context, LO_Color* in_out)
  3449. {
  3450.     LO_Color color = *in_out;
  3451.  
  3452.     if (fe_color_do_work(context, &color) == XmDIALOG_OK_BUTTON) {
  3453.         *in_out = color;
  3454.         return TRUE;
  3455.     }
  3456.     return FALSE;
  3457. }
  3458.  
  3459. static void
  3460. fe_editor_props_color_picker_cb(Widget widget,
  3461.                                 XtPointer closure, XtPointer call_data)
  3462. {
  3463.     fe_EditorCharacterPropertiesWidgets* w_data
  3464.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3465.     LO_Color color;
  3466.  
  3467.     color = w_data->color;
  3468.     if (fe_ColorPicker(w_data->properties->context, &color)) {
  3469.         w_data->color = color;
  3470.         w_data->is_custom_color = TRUE;
  3471.         w_data->changed_mask |= TF_FONT_COLOR;
  3472.     }
  3473.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_COLOR);
  3474. }
  3475.  
  3476. static void
  3477. fe_color_default_update_cb(Widget widget, XtPointer closure,
  3478.                            XtPointer call_data)
  3479. {
  3480.     fe_EditorCharacterPropertiesWidgets* w_data
  3481.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3482.     Boolean sensitive = (w_data->js_mode == JAVASCRIPT_NONE);
  3483.     Boolean set = !sensitive || (w_data->is_custom_color == FALSE);
  3484.  
  3485.     XmToggleButtonSetState(widget, set, FALSE);
  3486.     fe_WidgetSetSensitive(widget, sensitive);
  3487. }
  3488.  
  3489. static void
  3490. fe_color_default_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3491. {
  3492.     fe_EditorCharacterPropertiesWidgets* w_data =
  3493.         (fe_EditorCharacterPropertiesWidgets*)closure;
  3494.     XmToggleButtonCallbackStruct* info =
  3495.         (XmToggleButtonCallbackStruct*)call_data;
  3496.  
  3497.     if (info->set) {
  3498.         w_data->changed_mask |= TF_FONT_COLOR;
  3499.         w_data->is_custom_color = FALSE;
  3500.         fe_update_dependents(widget, w_data->properties, PROP_CHAR_COLOR);
  3501.     }
  3502. }
  3503.  
  3504. static void
  3505. fe_color_custom_update_cb(Widget widget, XtPointer closure,
  3506.                           XtPointer call_data)
  3507. {
  3508.     fe_EditorCharacterPropertiesWidgets* w_data
  3509.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3510.     Boolean sensitive = (w_data->js_mode == JAVASCRIPT_NONE);
  3511.     Boolean set = sensitive && (w_data->is_custom_color == TRUE);
  3512.  
  3513.     XmToggleButtonSetState(widget, set, FALSE);
  3514.     fe_WidgetSetSensitive(widget, sensitive);
  3515. }
  3516.  
  3517. static void
  3518. fe_choose_color_update_cb(Widget widget, XtPointer closure,
  3519.                           XtPointer call_data)
  3520. {
  3521.     fe_EditorCharacterPropertiesWidgets* w_data
  3522.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3523.     Boolean sensitive = (w_data->js_mode == JAVASCRIPT_NONE) &&
  3524.                         (w_data->is_custom_color == TRUE);
  3525.  
  3526.     fe_WidgetSetSensitive(widget, sensitive);
  3527. }
  3528.  
  3529. static void
  3530. fe_clear_styles_update_cb(Widget widget, XtPointer closure,
  3531.                           XtPointer call_data)
  3532. {
  3533.     fe_EditorCharacterPropertiesWidgets* w_data
  3534.         = (fe_EditorCharacterPropertiesWidgets*)closure;
  3535.     Boolean sensitive = (w_data->js_mode == JAVASCRIPT_NONE);
  3536.  
  3537.     fe_WidgetSetSensitive(widget, sensitive);
  3538. }
  3539.  
  3540. static void
  3541. fe_color_custom_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3542. {
  3543.     fe_EditorCharacterPropertiesWidgets* w_data =
  3544.         (fe_EditorCharacterPropertiesWidgets*)closure;
  3545.     XmToggleButtonCallbackStruct* info =
  3546.         (XmToggleButtonCallbackStruct*)call_data;
  3547.  
  3548.     if (info->set) {
  3549.         w_data->changed_mask |= TF_FONT_COLOR;
  3550.         w_data->is_custom_color = TRUE;
  3551.         fe_update_dependents(widget, w_data->properties, PROP_CHAR_COLOR);
  3552.     }
  3553. }
  3554.  
  3555. static void
  3556. fe_javascript_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3557. {
  3558.     fe_EditorCharacterPropertiesWidgets* w_data =
  3559.         (fe_EditorCharacterPropertiesWidgets*)closure;
  3560.     XmToggleButtonCallbackStruct* info =
  3561.         (XmToggleButtonCallbackStruct*)call_data;
  3562.     Boolean is_server = (fe_GetUserData(widget) != NULL);
  3563.  
  3564.     if (info->set) {
  3565.         if (is_server) {
  3566.             w_data->js_mode = JAVASCRIPT_SERVER;
  3567.         } else {
  3568.             w_data->js_mode = JAVASCRIPT_CLIENT;
  3569.         }
  3570.  
  3571.         /*
  3572.          *    Javascript text doesn't have links, clear it..
  3573.          */
  3574.         if (w_data->properties->link != NULL)
  3575.             fe_link_tab_remove_link(w_data->properties->link);
  3576.         
  3577.     } else {
  3578.         w_data->js_mode = JAVASCRIPT_NONE;
  3579.     }
  3580.     w_data->changed_mask |= PROP_CHAR_CLIENT|PROP_CHAR_SERVER;
  3581.  
  3582.     fe_update_dependents(widget, w_data->properties, PROP_CHAR_ALL);
  3583. }
  3584.  
  3585. static void
  3586. fe_javascript_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3587. {
  3588.     fe_EditorCharacterPropertiesWidgets* w_data =
  3589.         (fe_EditorCharacterPropertiesWidgets*)closure;
  3590.     Boolean is_server = (fe_GetUserData(widget) != NULL);
  3591.     Boolean set = FALSE;
  3592.  
  3593.     if (is_server && (w_data->js_mode == JAVASCRIPT_SERVER))
  3594.         set = TRUE;
  3595.     else if (!is_server && (w_data->js_mode == JAVASCRIPT_CLIENT))
  3596.         set = TRUE;
  3597.     
  3598.     XmToggleButtonGadgetSetState(widget, set, FALSE);
  3599. }
  3600.  
  3601. static void
  3602. fe_EditorCharacterPropertiesDialogDataGet(
  3603.                                  MWContext* context,
  3604.                                  fe_EditorCharacterPropertiesWidgets* w_data)
  3605. {
  3606.     w_data->text_attributes = fe_EditorCharacterPropertiesGet(context);
  3607.     w_data->font_size = fe_EditorFontSizeGet(context);
  3608.     w_data->changed_mask = 0;
  3609.  
  3610.     if ((w_data->text_attributes & TF_SERVER))
  3611.         w_data->js_mode = JAVASCRIPT_SERVER;
  3612.     else if ((w_data->text_attributes & TF_SCRIPT))
  3613.         w_data->js_mode = JAVASCRIPT_CLIENT;
  3614.     else
  3615.         w_data->js_mode = JAVASCRIPT_NONE;
  3616.     w_data->text_attributes &= ~(TF_SERVER|TF_SCRIPT);
  3617.  
  3618.     if (fe_EditorColorGet(context, &w_data->color))
  3619.         w_data->is_custom_color = TRUE;
  3620.     else
  3621.         w_data->is_custom_color = FALSE;
  3622.  
  3623.     fe_update_dependents(NULL, w_data->properties, PROP_CHAR_ALL);
  3624. }
  3625.  
  3626. static void
  3627. fe_EditorCharacterPropertiesDialogSet(
  3628.                                  MWContext* context,
  3629.                                  fe_EditorCharacterPropertiesWidgets* w_data)
  3630. {
  3631.     LO_Color* color;
  3632.  
  3633.     if ((w_data->js_mode == JAVASCRIPT_SERVER)) {
  3634.         fe_EditorCharacterPropertiesSet(context, TF_SERVER);
  3635.     } else if ((w_data->js_mode == JAVASCRIPT_CLIENT)) {
  3636.         fe_EditorCharacterPropertiesSet(context, TF_SCRIPT);
  3637.     } else {
  3638.  
  3639.         /* clear javascript */
  3640.         if (w_data->changed_mask & (PROP_CHAR_CLIENT|PROP_CHAR_SERVER)) {
  3641.             fe_EditorCharacterPropertiesSet(context, (TF_SERVER|TF_SCRIPT));
  3642.             w_data->changed_mask = ~0;
  3643.         }
  3644.  
  3645.         if ((w_data->changed_mask & TF_ALL_MASK)!= 0) {
  3646.             fe_EditorCharacterPropertiesSet(context, 
  3647.                                     (w_data->text_attributes & TF_ALL_MASK));
  3648.         }
  3649.  
  3650.         if ((w_data->changed_mask & TF_FONT_SIZE)!= 0)
  3651.             fe_EditorFontSizeSet(context, w_data->font_size);
  3652.  
  3653.         if ((w_data->changed_mask & TF_FONT_COLOR)!= 0) {
  3654.             
  3655.             if (w_data->is_custom_color)
  3656.                 color = &w_data->color;
  3657.             else
  3658.                 color = NULL;
  3659.  
  3660.             fe_EditorColorSet(context, color);
  3661.         }
  3662.     }
  3663. }
  3664.  
  3665. static void
  3666. fe_make_character_page(
  3667.                        MWContext *context,
  3668.                        Widget parent,
  3669.                        fe_EditorCharacterPropertiesWidgets* w_data)
  3670. {
  3671.     Arg    args[32];
  3672.     Cardinal n;
  3673.     Widget form;
  3674.     Widget color_frame;
  3675.     Widget color_form;
  3676.     Widget color_label;
  3677.     Widget color_swatch;
  3678.     Widget color_default;
  3679.     Widget color_custom;
  3680.     Widget color_choose;
  3681.     Widget color_text;
  3682.  
  3683.     Widget size_frame;
  3684.     Widget size_form;
  3685.     Widget size_menu;
  3686.     Widget size_text;
  3687.     Widget size_cascade;
  3688.  
  3689.     Widget style_frame;
  3690.     Widget style_outer_rc;
  3691.     Widget style_inner_rc;
  3692.     Widget style_clear;
  3693.  
  3694.     Widget java_frame;
  3695.     Widget java_rc;
  3696.     
  3697.     Widget clear_all;
  3698.  
  3699.     Dimension width;
  3700.     Dimension height;
  3701.  
  3702.     Widget children[16];
  3703.     Cardinal nchildren;
  3704.  
  3705. #if 0
  3706.     n = 0;
  3707.     form = XmCreateForm(parent, "characterProperties", args, n);
  3708.     XtManageChild(form);
  3709. #else
  3710.     form = parent;
  3711. #endif
  3712.     w_data->form = form;
  3713.  
  3714.     /*
  3715.      *    Color group.
  3716.      */
  3717.     n = 0;
  3718.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3719.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3720.     color_frame = fe_CreateFrame(form, "color", args, n);
  3721.     XtManageChild(color_frame);
  3722.  
  3723.     n = 0;
  3724.     color_form = XmCreateForm(color_frame, "color", args, n);
  3725.     XtManageChild(color_form);
  3726.  
  3727.     nchildren = 0;
  3728.     n = 0;
  3729.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3730.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3731.     children[nchildren++] = color_label = XmCreateLabelGadget(color_form, "colorLabel", args, n);
  3732.     
  3733.     n = 0;
  3734.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3735.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  3736.     XtSetArg(args[n], XmNleftWidget, color_label); n++;
  3737.     XtSetArg(args[n], XmNshadowThickness, 2); n++; /* make it look like label */
  3738.     children[nchildren++] = color_swatch = fe_CreateSwatch(color_form, "colorSwatch", args, n);
  3739.     w_data->color_swatch = color_swatch;
  3740.  
  3741.     fe_register_dependent(w_data->properties, color_swatch,
  3742.                                  FE_MAKE_DEPENDENCY(PROP_CHAR_COLOR),
  3743.                                  fe_color_swatch_update_cb, (XtPointer)w_data);
  3744.     XtAddCallback(color_swatch, XmNactivateCallback,
  3745.                   fe_editor_props_color_picker_cb, (XtPointer)w_data);
  3746.  
  3747.     n = 0;
  3748.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3749.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3750.     XtSetArg(args[n], XmNtopWidget, color_label); n++;
  3751.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  3752.     XtSetArg(args[n], XmNset, TRUE); n++;
  3753.     children[nchildren++] = color_default = XmCreateToggleButtonGadget(color_form, "default", args, n);
  3754.  
  3755.     XtAddCallback(color_default, XmNvalueChangedCallback,
  3756.                                  fe_color_default_cb, (XtPointer)w_data);
  3757.  
  3758.     fe_register_dependent(w_data->properties, color_default,
  3759.                                  FE_MAKE_DEPENDENCY(PROP_CHAR_COLOR),
  3760.                                  fe_color_default_update_cb, (XtPointer)w_data);
  3761.     
  3762.     n = 0;
  3763.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3764.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3765.     XtSetArg(args[n], XmNtopWidget, color_default); n++;
  3766.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  3767.     XtSetArg(args[n], XmNset, FALSE); n++;
  3768.     children[nchildren++] = color_custom = XmCreateToggleButtonGadget(color_form, "custom", args, n);
  3769.     
  3770.     XtAddCallback(color_custom, XmNvalueChangedCallback,
  3771.                                  fe_color_custom_cb, (XtPointer)w_data);
  3772.  
  3773.     fe_register_dependent(w_data->properties, color_custom,
  3774.                                  FE_MAKE_DEPENDENCY(PROP_CHAR_COLOR),
  3775.                                  fe_color_custom_update_cb, (XtPointer)w_data);
  3776.  
  3777.     n = 0;
  3778.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3779.     XtSetArg(args[n], XmNtopWidget, color_default); n++;
  3780.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  3781.     XtSetArg(args[n], XmNleftWidget, color_custom); n++;
  3782.     children[nchildren++] = color_choose = XmCreatePushButtonGadget(color_form, "chooseColor", args, n);
  3783.      
  3784.     XtAddCallback(color_choose, XmNactivateCallback,
  3785.                   fe_editor_props_color_picker_cb, (XtPointer)w_data);
  3786.     fe_register_dependent(w_data->properties, color_choose,
  3787.                           FE_MAKE_DEPENDENCY(PROP_CHAR_COLOR),
  3788.                           fe_choose_color_update_cb, (XtPointer)w_data);
  3789.  
  3790.     n = 0;
  3791.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3792.     XtSetArg(args[n], XmNtopWidget, color_custom); n++;
  3793.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3794.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  3795.     children[nchildren++] = color_text = XmCreateLabelGadget(color_form, "colorText", args, n);
  3796.  
  3797.     XtManageChildren(children, nchildren); /* children of color form */
  3798.  
  3799.     /*
  3800.      *    Set the swatch to be same height as label, and width as
  3801.      *    choose button.
  3802.      */
  3803.     XtVaGetValues(color_label, XmNheight, &height, 0);
  3804.     XtVaGetValues(color_choose, XmNwidth, &width, 0);
  3805.     n = 0;
  3806.     XtSetArg(args[n], XmNwidth, width); n++;
  3807.     XtSetArg(args[n], XmNheight, height); n++;
  3808.     XtSetValues(color_swatch, args, n);
  3809.  
  3810.     /*
  3811.      *    Size group.
  3812.      */
  3813.     n = 0;
  3814.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3815.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  3816.     XtSetArg(args[n], XmNleftWidget, color_frame); n++;
  3817.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  3818.     XtSetArg(args[n], XmNbottomWidget, color_frame); n++;
  3819.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  3820.     size_frame = fe_CreateFrame(form, "size", args, n);
  3821.     XtManageChild(size_frame);
  3822.  
  3823.     n = 0;
  3824.     size_form = XmCreateForm(size_frame, "size", args, n);
  3825.     XtManageChild(size_form);
  3826.     
  3827.     nchildren = 0;
  3828.     n = 0;
  3829.     size_menu = fe_CreatePulldownMenu(size_form,
  3830.                                       "fontSize",
  3831.                                       args, n);
  3832.  
  3833.     nchildren = 0;
  3834.     for (nchildren = 0; fe_font_size_types[nchildren].name; nchildren++) {
  3835.         n = 0;
  3836.         XtSetArg(args[n], XmNuserData, fe_font_size_types[nchildren].data); n++;
  3837.         children[nchildren] = XmCreatePushButtonGadget(
  3838.                                                    size_menu,
  3839.                                                    fe_font_size_types[nchildren].name,
  3840.                                                    args,
  3841.                                                    n
  3842.                                                    );
  3843.         XtAddCallback(children[nchildren], XmNactivateCallback,
  3844.                       fe_font_size_cb, (XtPointer)w_data);
  3845.                                                                
  3846.     }
  3847.     XtManageChildren(children, nchildren); /* size buttons */
  3848.     
  3849.     n = 0;
  3850.     XtSetArg(args[n], XmNsubMenuId, size_menu); n++;
  3851.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3852.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3853.     size_cascade = fe_CreateOptionMenu(
  3854.                                       size_form,
  3855.                                       "fontSizeOptionMenu",
  3856.                                       args, n);
  3857.     fe_UnmanageChild_safe(XmOptionLabelGadget(size_cascade));
  3858.     fe_register_dependent(w_data->properties, size_cascade,
  3859.                      FE_MAKE_DEPENDENCY(PROP_CHAR_SIZE),
  3860.                      fe_font_size_update_cb, (XtPointer)w_data);
  3861.  
  3862.     XtManageChild(size_cascade);
  3863.  
  3864.     n = 0;
  3865.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3866.     XtSetArg(args[n], XmNtopWidget, size_cascade); n++;
  3867.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3868.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  3869.     size_text = XmCreateLabelGadget(size_form, "sizeText",
  3870.                                     args, n);
  3871.     XtManageChild(size_text);
  3872.  
  3873.     /*
  3874.      *    Style group.
  3875.      */
  3876.     n = 0;
  3877.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3878.     XtSetArg(args[n], XmNtopWidget, color_frame); n++;
  3879.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3880.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  3881.     XtSetArg(args[n], XmNrightWidget, color_frame); n++;
  3882.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  3883.     style_frame = fe_CreateFrame(form, "style", args, n);
  3884.     XtManageChild(style_frame);
  3885.  
  3886.     n = 0;
  3887.     style_outer_rc = XmCreateForm(style_frame, "style", args, n);
  3888.     XtManageChild(style_outer_rc);
  3889.  
  3890.     n = 0;
  3891.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  3892.     XtSetArg(args[n], XmNnumColumns, 2); n++;
  3893.     XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
  3894.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3895.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  3896.     style_inner_rc = XmCreateRowColumn(style_outer_rc, "charProperties", args, n);
  3897.     XtManageChild(style_inner_rc);
  3898.  
  3899.     for (nchildren = 0; fe_style_types[nchildren].name; nchildren++) {
  3900.         n = 0;
  3901.         XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  3902.         XtSetArg(args[n], XmNuserData, fe_style_types[nchildren].data); n++;
  3903.         children[nchildren] = XmCreateToggleButtonGadget(
  3904.                                              style_inner_rc,
  3905.                                              fe_style_types[nchildren].name,
  3906.                                              args,
  3907.                                              n);
  3908.                                                                
  3909.         XtAddCallback(children[nchildren], XmNvalueChangedCallback,
  3910.                       fe_style_cb, (XtPointer)w_data);
  3911.  
  3912.         fe_register_dependent(w_data->properties, children[nchildren],
  3913.                           FE_MAKE_DEPENDENCY(fe_style_types[nchildren].data),
  3914.                           fe_style_update_cb, (XtPointer)w_data);
  3915.     }
  3916.     XtManageChildren(children, nchildren); /* style toggles */
  3917.  
  3918.     n = 0;
  3919.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  3920.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  3921.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3922.     XtSetArg(args[n], XmNtopWidget, style_inner_rc); n++;
  3923.     style_clear = XmCreatePushButtonGadget(style_outer_rc, "clearStyles",
  3924.                                            args, n);
  3925.     XtAddCallback(style_clear, XmNactivateCallback,
  3926.                   fe_clear_style_cb, (XtPointer)w_data);
  3927.     fe_register_dependent(w_data->properties, style_clear,
  3928.                           FE_MAKE_DEPENDENCY(PROP_CHAR_JAVASCRIPT),
  3929.                           fe_clear_styles_update_cb, (XtPointer)w_data);
  3930.  
  3931.     XtManageChild(style_clear);
  3932.  
  3933.     /*
  3934.      *    Java group.
  3935.      */
  3936.     n = 0;
  3937.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3938.     XtSetArg(args[n], XmNtopWidget, color_frame); n++;
  3939.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  3940.     XtSetArg(args[n], XmNleftWidget, color_frame); n++;
  3941.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  3942.     java_frame = fe_CreateFrame(form, "java", args, n);
  3943.     XtManageChild(java_frame);
  3944.  
  3945.     n = 0;
  3946.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  3947.     java_rc = XmCreateRowColumn(java_frame, "java", args, n);
  3948.     XtManageChild(java_rc);
  3949.  
  3950.     nchildren = 0;
  3951.     n = 0;
  3952.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  3953.     XtSetArg(args[n], XmNuserData, FALSE); n++;
  3954.     children[nchildren] = XmCreateToggleButtonGadget(java_rc, "client",
  3955.                                                      args, n);
  3956.     
  3957.     XtAddCallback(children[nchildren], XmNvalueChangedCallback,
  3958.                   fe_javascript_cb, (XtPointer)w_data);
  3959.     fe_register_dependent(w_data->properties, children[nchildren],
  3960.                           FE_MAKE_DEPENDENCY(PROP_CHAR_JAVASCRIPT), /* lazy */
  3961.                           fe_javascript_update_cb, (XtPointer)w_data);
  3962.     nchildren++;
  3963.  
  3964.     n = 0;
  3965.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  3966.     XtSetArg(args[n], XmNuserData, TRUE); n++;
  3967.     children[nchildren] = XmCreateToggleButtonGadget(java_rc, "server",
  3968.                                                        args, n);
  3969.     XtAddCallback(children[nchildren], XmNvalueChangedCallback,
  3970.                   fe_javascript_cb, (XtPointer)w_data);
  3971.     fe_register_dependent(w_data->properties, children[nchildren],
  3972.                           FE_MAKE_DEPENDENCY(PROP_CHAR_JAVASCRIPT), /* lazy */
  3973.                           fe_javascript_update_cb, (XtPointer)w_data);
  3974.     nchildren++;
  3975.  
  3976.     XtManageChildren(children, nchildren); /* java toggles */
  3977.  
  3978.     n = 0;
  3979.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  3980.     XtSetArg(args[n], XmNtopWidget, java_frame); n++;
  3981.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  3982.     XtSetArg(args[n], XmNleftWidget, java_frame); n++;
  3983.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  3984.     XtSetArg(args[n], XmNrightWidget, java_frame); n++;
  3985.     clear_all = XmCreatePushButtonGadget(form, "clearAll", args, n);
  3986.     XtManageChild(clear_all);
  3987.  
  3988.     XtAddCallback(clear_all, XmNactivateCallback,
  3989.                   fe_clearall_settings_cb, (XtPointer)w_data);
  3990. }
  3991.  
  3992. static void
  3993. fe_image_main_image_cb(Widget widget, XtPointer closure, XtPointer call_data)
  3994. {
  3995.     fe_EditorImagePropertiesWidgets* w_data =
  3996.         (fe_EditorImagePropertiesWidgets*)closure;
  3997.  
  3998.     /*
  3999.      *    Update changed tag, but don't call dependents (that's us).
  4000.      *    Well we have to, so that we update the copy button.
  4001.      *    No, we don't we'll set the tag here, but we'll only
  4002.      *    call update_dependents from the browse cb. That way
  4003.      *    we won't be *busy*. No, we have to, oh too bad!
  4004.      */
  4005.     w_data->new_image = TRUE;
  4006.     fe_update_dependents(widget, w_data->properties, 
  4007.                          PROP_IMAGE_MAIN_IMAGE|PROP_IMAGE_COPY|PROP_LINK_TEXT);
  4008. }
  4009.  
  4010. static void
  4011. fe_image_main_image_update_cb(Widget widget,
  4012.                               XtPointer closure, XtPointer call_data)
  4013. {
  4014.     fe_EditorImagePropertiesWidgets* w_data =
  4015.         (fe_EditorImagePropertiesWidgets*)closure;
  4016.     fe_DependentListCallbackStruct* info = 
  4017.         (fe_DependentListCallbackStruct*)call_data;
  4018.  
  4019.     if (info->caller == widget)
  4020.         return; /* don't call ourselves */
  4021.     
  4022.     fe_set_text_field(widget, w_data->image_data.pSrc,
  4023.                       fe_image_main_image_cb, (XtPointer)w_data);
  4024. }
  4025.  
  4026. static void
  4027. fe_url_browse_file_of_text(MWContext* context, Widget text_field)
  4028. {
  4029.     char* before_save;
  4030.     char* after;
  4031.     char* p = NULL;
  4032.     int type;
  4033.  
  4034.     before_save = fe_TextFieldGetString(text_field);
  4035.  
  4036.     if (before_save != NULL)
  4037.         fe_StringTrim(before_save);
  4038.  
  4039.     type = NET_URL_Type(before_save);
  4040.  
  4041.     if (type == 0) { /* unknown, might be file path */
  4042.         History_entry* hist_ent;
  4043.  
  4044.         if (!EDT_IS_NEW_DOCUMENT(context)) { /* don't bother looking */
  4045.             hist_ent = SHIST_GetCurrent(&context->hist);
  4046.  
  4047.             if (hist_ent != NULL
  4048.                 &&
  4049.                 hist_ent->address != NULL
  4050.                 &&
  4051.                 NET_IsLocalFileURL(hist_ent->address)) {
  4052.                 if (before_save[0] == '/' && before_save[1] != '/')
  4053.                     p = before_save;
  4054.             }
  4055.         }
  4056.     } else if (type == FILE_TYPE_URL) {
  4057.  
  4058.         if (XP_STRNCASECMP(before_save, "file:///", 8) == 0)
  4059.             p = &before_save[7];
  4060.         else if (XP_STRNCASECMP(before_save, "file://", 7) == 0)
  4061.             p = &before_save[6];
  4062.         else if (XP_STRNCASECMP(before_save, "file:/", 6) == 0)
  4063.             p = &before_save[5];
  4064.     }
  4065.  
  4066.     if (p == NULL)
  4067.         p = "";
  4068.  
  4069.     if (p != before_save)
  4070.         fe_TextFieldSetString(text_field, p, FALSE);
  4071.     
  4072.     fe_browse_file_of_text(context, text_field, FALSE);
  4073.  
  4074.     after = fe_TextFieldGetString(text_field);
  4075.     fe_StringTrim(after);
  4076.  
  4077.     if (XP_STRCMP(after, before_save) != 0) {
  4078.  
  4079.         p = (char*)XP_ALLOC(XP_STRLEN(after) + 8);
  4080.  
  4081.         XP_STRCPY(p, "file://");
  4082.         XP_STRCAT(p, after);
  4083.  
  4084.         fe_TextFieldSetString(text_field, p, FALSE);
  4085.  
  4086.         XP_FREE(p);
  4087.     }
  4088.  
  4089.     if (before_save)
  4090.         XtFree(before_save);
  4091.     if (after)
  4092.         XtFree(after);
  4093. }
  4094.  
  4095. static void
  4096. fe_image_main_image_browse_cb(Widget widget,
  4097.                               XtPointer closure, XtPointer call_data)
  4098. {
  4099.     fe_EditorImagePropertiesWidgets* w_data =
  4100.         (fe_EditorImagePropertiesWidgets*)closure;
  4101.  
  4102.     fe_url_browse_file_of_text(w_data->properties->context,
  4103.                                w_data->main_image);
  4104. }
  4105.  
  4106. static void
  4107. fe_image_alt_image_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4108. {
  4109.     fe_EditorImagePropertiesWidgets* w_data =
  4110.         (fe_EditorImagePropertiesWidgets*)closure;
  4111.  
  4112.     /*
  4113.      *    See discussion for main above.
  4114.      */
  4115.     w_data->new_image = TRUE;
  4116.     fe_update_dependents(widget, w_data->properties, 
  4117.                          PROP_IMAGE_ALT_IMAGE|PROP_IMAGE_COPY|PROP_LINK_TEXT);
  4118. }
  4119.  
  4120. static void
  4121. fe_image_alt_image_update_cb(Widget widget,
  4122.                               XtPointer closure, XtPointer call_data)
  4123. {
  4124.     fe_EditorImagePropertiesWidgets* w_data =
  4125.         (fe_EditorImagePropertiesWidgets*)closure;
  4126.     fe_DependentListCallbackStruct* info = 
  4127.         (fe_DependentListCallbackStruct*)call_data;
  4128.  
  4129.     if (info->caller == widget)
  4130.         return; /* don't call ourselves */
  4131.     
  4132.     fe_set_text_field(w_data->alt_image, w_data->image_data.pLowSrc,
  4133.                       fe_image_alt_image_cb, (XtPointer)w_data);
  4134. }
  4135.  
  4136. static void
  4137. fe_image_alt_image_browse_cb(Widget widget,
  4138.                               XtPointer closure, XtPointer call_data)
  4139. {
  4140.     fe_EditorImagePropertiesWidgets* w_data =
  4141.         (fe_EditorImagePropertiesWidgets*)closure;
  4142.  
  4143.     fe_url_browse_file_of_text(w_data->properties->context,
  4144.                                w_data->alt_image);
  4145. }
  4146.  
  4147. static void
  4148. fe_image_alt_text_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4149. {
  4150.     fe_EditorImagePropertiesWidgets* w_data =
  4151.         (fe_EditorImagePropertiesWidgets*)closure;
  4152.  
  4153.     fe_update_dependents(widget, w_data->properties,
  4154.                          PROP_IMAGE_ALT_TEXT|PROP_IMAGE_COPY|PROP_LINK_TEXT);
  4155. }
  4156.  
  4157. static void
  4158. fe_image_alt_text_update_cb(Widget widget,
  4159.                               XtPointer closure, XtPointer call_data)
  4160. {
  4161.     fe_EditorImagePropertiesWidgets* w_data =
  4162.         (fe_EditorImagePropertiesWidgets*)closure;
  4163.     fe_DependentListCallbackStruct* info = 
  4164.         (fe_DependentListCallbackStruct*)call_data;
  4165.  
  4166.     if (info->caller == widget)
  4167.         return; /* don't call ourselves */
  4168.     
  4169.     fe_set_text_field(w_data->alt_text, w_data->image_data.pAlt,
  4170.                       fe_image_alt_text_cb, (XtPointer)w_data);
  4171. }
  4172.  
  4173. static void
  4174. fe_image_align_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4175. {
  4176.     fe_EditorImagePropertiesWidgets* w_data =
  4177.         (fe_EditorImagePropertiesWidgets*)closure;
  4178.     XmToggleButtonCallbackStruct* info =
  4179.         (XmToggleButtonCallbackStruct*)call_data;
  4180.  
  4181.     /*
  4182.      *    We get a callback on both the unset of the old toggle,
  4183.      *    and the set of the new, so ignore the former, it's not
  4184.      *    interesting.
  4185.      */
  4186.     if (info->set) {
  4187.  
  4188.         w_data->image_data.align = (ED_Alignment)fe_GetUserData(widget);    
  4189.  
  4190.         fe_update_dependents(widget, w_data->properties, PROP_IMAGE_ALIGN);
  4191.     }
  4192. }
  4193.  
  4194. static void
  4195. fe_image_align_update_cb(Widget widget,
  4196.                          XtPointer closure, XtPointer call_data)
  4197. {
  4198.     fe_EditorImagePropertiesWidgets* w_data =
  4199.         (fe_EditorImagePropertiesWidgets*)closure;
  4200.     ED_Alignment align = (ED_Alignment)fe_GetUserData(widget);    
  4201.  
  4202.     XmToggleButtonGadgetSetState(widget, 
  4203.                                  (w_data->image_data.align == align),
  4204.                                  FALSE);
  4205. }
  4206.  
  4207. static void
  4208. fe_image_dimensions_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4209. {
  4210.     fe_EditorImagePropertiesWidgets* w_data =
  4211.         (fe_EditorImagePropertiesWidgets*)closure;
  4212.     Boolean constrainable =    !(w_data->image_data.bHeightPercent ||
  4213.                               w_data->image_data.bWidthPercent);
  4214.  
  4215.     w_data->properties->changed |= PROP_IMAGE_DIMENSIONS;
  4216.  
  4217.     /*
  4218.      *    If constrain is on, adjust the other value.
  4219.      */
  4220.     if (w_data->do_constrain && constrainable) {
  4221.         unsigned long new_value = fe_get_numeric_text_field(widget);
  4222.         unsigned long tmp;
  4223.         unsigned long foo;
  4224.         if (widget == w_data->image_width) { /* adjusting width, do height */
  4225.             w_data->image_data.iWidth = new_value;
  4226.             foo = w_data->image_data.iOriginalWidth;
  4227.             if (foo == 0)
  4228.                 foo++;
  4229.             tmp = new_value * w_data->image_data.iOriginalHeight;
  4230.             tmp = tmp / foo;
  4231.             w_data->image_data.iHeight = tmp;
  4232.         } else { /* adjusting height, do width */
  4233.             w_data->image_data.iHeight = new_value;
  4234.             foo = w_data->image_data.iOriginalHeight;
  4235.             if (foo == 0)
  4236.                 foo++;
  4237.             tmp = new_value * w_data->image_data.iOriginalWidth;
  4238.             tmp = tmp / foo;
  4239.             w_data->image_data.iWidth = tmp;
  4240.         }
  4241.         fe_update_dependents(widget, w_data->properties,
  4242.                              PROP_IMAGE_DIMENSIONS);
  4243.     }
  4244. }
  4245.  
  4246. static void
  4247. fe_image_dimensions_height_update_cb(Widget widget,
  4248.                                      XtPointer closure, XtPointer call_data)
  4249. {
  4250.     fe_EditorImagePropertiesWidgets* w_data =
  4251.         (fe_EditorImagePropertiesWidgets*)closure;
  4252.     fe_DependentListCallbackStruct* info = 
  4253.         (fe_DependentListCallbackStruct*)call_data;
  4254.     Boolean enabled = w_data->do_custom_size;
  4255.     unsigned height; 
  4256.  
  4257.     if (info->caller == widget)
  4258.         return; /* don't call ourselves */
  4259.  
  4260.     if (enabled)
  4261.         height = w_data->image_data.iHeight;
  4262.     else
  4263.         height = w_data->image_data.iOriginalHeight;
  4264.     
  4265.     fe_set_numeric_text_field(widget, height);
  4266.     fe_TextFieldSetEditable(w_data->properties->context, widget, enabled);
  4267. }
  4268.  
  4269. static void
  4270. fe_image_dimensions_width_update_cb(Widget widget,
  4271.                                      XtPointer closure, XtPointer call_data)
  4272. {
  4273.     fe_EditorImagePropertiesWidgets* w_data =
  4274.         (fe_EditorImagePropertiesWidgets*)closure;
  4275.     fe_DependentListCallbackStruct* info = 
  4276.         (fe_DependentListCallbackStruct*)call_data;
  4277.     Boolean enabled = w_data->do_custom_size;
  4278.     unsigned width;
  4279.  
  4280.     if (info->caller == widget)
  4281.         return; /* don't call ourselves */
  4282.     
  4283.     if (enabled)
  4284.         width = w_data->image_data.iWidth;
  4285.     else
  4286.         width = w_data->image_data.iOriginalWidth;
  4287.     
  4288.     fe_set_numeric_text_field(widget, width);
  4289.     fe_TextFieldSetEditable(w_data->properties->context, widget, enabled);
  4290. }
  4291.  
  4292. static void
  4293. fe_image_margin_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4294. {
  4295.     fe_EditorImagePropertiesWidgets* w_data =
  4296.         (fe_EditorImagePropertiesWidgets*)closure;
  4297.  
  4298.     w_data->properties->changed |= PROP_IMAGE_SPACE;
  4299. }
  4300.  
  4301. static void
  4302. fe_image_margin_height_update_cb(Widget widget,
  4303.                                      XtPointer closure, XtPointer call_data)
  4304. {
  4305.     fe_EditorImagePropertiesWidgets* w_data =
  4306.         (fe_EditorImagePropertiesWidgets*)closure;
  4307.     fe_DependentListCallbackStruct* info = 
  4308.         (fe_DependentListCallbackStruct*)call_data;
  4309.  
  4310.     if (info->caller == widget)
  4311.         return; /* don't call ourselves */
  4312.     
  4313.     fe_set_numeric_text_field(widget, w_data->image_data.iVSpace);
  4314. }
  4315.  
  4316. static void
  4317. fe_image_margin_width_update_cb(Widget widget,
  4318.                                      XtPointer closure, XtPointer call_data)
  4319. {
  4320.     fe_EditorImagePropertiesWidgets* w_data =
  4321.         (fe_EditorImagePropertiesWidgets*)closure;
  4322.     fe_DependentListCallbackStruct* info = 
  4323.         (fe_DependentListCallbackStruct*)call_data;
  4324.  
  4325.     if (info->caller == widget)
  4326.         return; /* don't call ourselves */
  4327.  
  4328.     fe_set_numeric_text_field(widget,
  4329.                               w_data->image_data.iHSpace);
  4330. }
  4331.  
  4332. static void
  4333. fe_image_margin_border_update_cb(Widget widget,
  4334.                                  XtPointer closure, XtPointer call_data)
  4335. {
  4336.     fe_EditorImagePropertiesWidgets* w_data =
  4337.         (fe_EditorImagePropertiesWidgets*)closure;
  4338.     fe_DependentListCallbackStruct* info = 
  4339.         (fe_DependentListCallbackStruct*)call_data;
  4340.  
  4341.     if (info->caller == widget)
  4342.         return; /* don't call ourselves */
  4343.  
  4344.     /* Logic for dealing with w_data->image_data.iBorder possibly being -1
  4345.        is now in fe_EditorImagePropertiesDialogDataGet. */
  4346.  
  4347.     fe_set_numeric_text_field(widget, w_data->image_data.iBorder);
  4348. }
  4349.  
  4350. static void
  4351. fe_image_original_size_cb(Widget widget,
  4352.                           XtPointer closure, XtPointer call_data)
  4353. {
  4354.     fe_EditorImagePropertiesWidgets* w_data =
  4355.         (fe_EditorImagePropertiesWidgets*)closure;
  4356.     XmToggleButtonCallbackStruct* info =
  4357.         (XmToggleButtonCallbackStruct*)call_data;
  4358.  
  4359.     w_data->do_custom_size = (info->set == FALSE);
  4360.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_DIMENSIONS);
  4361. }
  4362.  
  4363. static void
  4364. fe_image_original_size_update_cb(Widget widget,
  4365.                           XtPointer closure, XtPointer call_data)
  4366. {
  4367.     fe_EditorImagePropertiesWidgets* w_data =
  4368.         (fe_EditorImagePropertiesWidgets*)closure;
  4369.     Boolean set  = !w_data->do_custom_size;
  4370.     Boolean enabled = w_data->existing_image || w_data->new_image;
  4371.  
  4372.     XtVaSetValues(widget, XmNset, set, XmNsensitive, enabled, 0);
  4373. }
  4374.  
  4375. static void
  4376. fe_image_custom_size_cb(Widget widget,
  4377.                           XtPointer closure, XtPointer call_data)
  4378. {
  4379.     fe_EditorImagePropertiesWidgets* w_data =
  4380.         (fe_EditorImagePropertiesWidgets*)closure;
  4381.     XmToggleButtonCallbackStruct* info =
  4382.         (XmToggleButtonCallbackStruct*)call_data;
  4383.  
  4384.     w_data->do_custom_size = info->set;
  4385.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_DIMENSIONS);
  4386. }
  4387.  
  4388. static void
  4389. fe_image_custom_size_update_cb(Widget widget,
  4390.                           XtPointer closure, XtPointer call_data)
  4391. {
  4392.     fe_EditorImagePropertiesWidgets* w_data =
  4393.         (fe_EditorImagePropertiesWidgets*)closure;
  4394.     Boolean set  = w_data->do_custom_size;
  4395.     Boolean enabled = w_data->existing_image || w_data->new_image;
  4396.  
  4397.     XtVaSetValues(widget, XmNset, set, XmNsensitive, enabled, 0);
  4398. }
  4399.  
  4400. static void
  4401. fe_image_copy_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4402. {
  4403.     fe_EditorImagePropertiesWidgets* w_data =
  4404.         (fe_EditorImagePropertiesWidgets*)closure;
  4405.     XmToggleButtonCallbackStruct* info =
  4406.         (XmToggleButtonCallbackStruct*)call_data;
  4407.  
  4408.     w_data->image_data.bNoSave = info->set;
  4409.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_COPY);
  4410. }
  4411.  
  4412. static void
  4413. fe_image_copy_update_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4414. {
  4415.     fe_EditorImagePropertiesWidgets* w_data =
  4416.         (fe_EditorImagePropertiesWidgets*)closure;
  4417.     Arg args[8];
  4418.     Cardinal n;
  4419.  
  4420.     n = 0;
  4421.     XtSetArg(args[n], XmNset, (w_data->image_data.bNoSave)); n++;
  4422.     XtSetValues(widget, args, n);
  4423. }
  4424.  
  4425. static void
  4426. fe_image_remove_imap_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4427. {
  4428.     fe_EditorImagePropertiesWidgets* w_data =
  4429.         (fe_EditorImagePropertiesWidgets*)closure;
  4430.  
  4431.     w_data->image_data.bIsMap = FALSE;
  4432.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_IMAP);
  4433. }
  4434.  
  4435. static void
  4436. fe_image_remove_imap_update_cb(Widget widget,
  4437.                                XtPointer closure, XtPointer call_data)
  4438. {
  4439.     fe_EditorImagePropertiesWidgets* w_data =
  4440.         (fe_EditorImagePropertiesWidgets*)closure;
  4441.     Arg args[8];
  4442.     Cardinal n;
  4443.  
  4444.     n = 0;
  4445.     XtSetArg(args[n], XmNsensitive, (w_data->image_data.bIsMap != FALSE)); n++;
  4446.     XtSetValues(widget, args, n);
  4447. }
  4448.  
  4449. static void
  4450. fe_image_edit_image_do(MWContext* context,
  4451.                        Widget widget,
  4452.                        Widget image_widget)
  4453. {
  4454.     History_entry* hist_ent = SHIST_GetCurrent(&(context->hist));
  4455.     char* image;
  4456.     char* url;
  4457.     char* local_name;
  4458.     char buf[512];
  4459.  
  4460.     if (hist_ent == NULL || hist_ent->address == NULL)
  4461.         return; /* should not happen */
  4462.  
  4463.     image = fe_TextFieldGetString(image_widget);
  4464.  
  4465.     if (image == NULL || image[0] == '\0')
  4466.         return; /* also shouldn't happen */
  4467.  
  4468.     if (NET_IsHTTP_URL(image)) { /* remote url */
  4469.         fe_error_dialog(context, widget,
  4470.                         XP_GetString(XFE_EDITOR_IMAGE_IS_REMOTE));
  4471.         return;
  4472.     }
  4473.  
  4474.     url = NET_MakeAbsoluteURL(hist_ent->address, image); /* alloc */
  4475.     if (XP_ConvertUrlToLocalFile(url, &local_name)) {
  4476.         fe_EditorEditImage(context, local_name);
  4477.     } else {
  4478.         sprintf(buf, XP_GetString(XFE_CANNOT_READ_FILE), image);
  4479.  
  4480.         fe_error_dialog(context, widget, buf);
  4481.     }
  4482.  
  4483.     if (image)
  4484.         XP_FREEIF(image);
  4485.     if (url)
  4486.         XtFree(url);
  4487.     if (local_name)
  4488.         XtFree(local_name);
  4489. }
  4490.  
  4491. static void
  4492. fe_image_edit_image_cb(Widget widget, XtPointer closure, XtPointer call_data)
  4493. {
  4494.     fe_EditorImagePropertiesWidgets* w_data =
  4495.         (fe_EditorImagePropertiesWidgets*)closure;
  4496.     MWContext* context = w_data->properties->context;
  4497.  
  4498.     fe_image_edit_image_do(context, widget, w_data->main_image);
  4499. }
  4500.  
  4501. static void
  4502. fe_image_edit_image_update_cb(Widget widget,
  4503.                                XtPointer closure, XtPointer call_data)
  4504. {
  4505.     fe_EditorImagePropertiesWidgets* w_data =
  4506.         (fe_EditorImagePropertiesWidgets*)closure;
  4507.     Boolean sensitive = XmTextFieldGetLastPosition(w_data->main_image) != 0;
  4508.  
  4509.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  4510. }
  4511.  
  4512. static void
  4513. fe_image_edit_alt_image_cb(Widget widget,
  4514.                            XtPointer closure, XtPointer call_data)
  4515. {
  4516.     fe_EditorImagePropertiesWidgets* w_data =
  4517.         (fe_EditorImagePropertiesWidgets*)closure;
  4518.     MWContext* context = w_data->properties->context;
  4519.  
  4520.     fe_image_edit_image_do(context, widget, w_data->alt_image);
  4521. }
  4522.  
  4523. static void
  4524. fe_image_edit_alt_image_update_cb(Widget widget,
  4525.                                   XtPointer closure, XtPointer call_data)
  4526. {
  4527.     fe_EditorImagePropertiesWidgets* w_data =
  4528.         (fe_EditorImagePropertiesWidgets*)closure;
  4529.     Boolean sensitive = XmTextFieldGetLastPosition(w_data->alt_image) != 0;
  4530.  
  4531.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  4532. }
  4533.  
  4534. static void
  4535. fe_image_height_pixel_percent_cb(Widget widget,
  4536.                                  XtPointer closure, XtPointer call_data)
  4537. {
  4538.     fe_EditorImagePropertiesWidgets* w_data =
  4539.         (fe_EditorImagePropertiesWidgets*)closure;
  4540.     XP_Bool percent = (strcmp(XtName(widget), "percent") == 0);
  4541.  
  4542.     w_data->image_data.bHeightPercent = percent;
  4543.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_HEIGHT);
  4544. }
  4545.  
  4546. static void
  4547. fe_image_width_pixel_percent_cb(Widget widget,
  4548.                                 XtPointer closure, XtPointer call_data)
  4549. {
  4550.     fe_EditorImagePropertiesWidgets* w_data =
  4551.         (fe_EditorImagePropertiesWidgets*)closure;
  4552.     XP_Bool percent = (strcmp(XtName(widget), "percent") == 0);
  4553.  
  4554.     w_data->image_data.bWidthPercent = percent;
  4555.     fe_update_dependents(widget, w_data->properties, PROP_IMAGE_WIDTH);
  4556. }
  4557.  
  4558. /*
  4559.  *    Forward decalres for stuff used around here, because I'm just too
  4560.  *    tired to move stuff aorund.
  4561.  */
  4562. char* fe_SimpleOptionPixelPercent[];
  4563. Widget fe_CreateSimpleOptionMenu(Widget, char*, Arg*, Cardinal);
  4564.                                   
  4565. static void
  4566. fe_image_height_pixel_percent_update_cb(Widget widget,
  4567.                                 XtPointer closure, XtPointer call_data)
  4568. {
  4569.     fe_EditorImagePropertiesWidgets* w_data =
  4570.         (fe_EditorImagePropertiesWidgets*)closure;
  4571.     unsigned index = 0;
  4572.     Boolean enabled = w_data->do_custom_size;
  4573.  
  4574.     if (enabled && w_data->image_data.bHeightPercent)
  4575.         index = 1;
  4576.  
  4577.     XfeOptionMenuSetItem(widget, index);
  4578.     XtVaSetValues(widget, XmNsensitive, enabled, 0);
  4579. }
  4580.  
  4581. static void
  4582. fe_image_width_pixel_percent_update_cb(Widget widget,
  4583.                                 XtPointer closure, XtPointer call_data)
  4584. {
  4585.     fe_EditorImagePropertiesWidgets* w_data =
  4586.         (fe_EditorImagePropertiesWidgets*)closure;
  4587.     unsigned index = 0;
  4588.     Boolean enabled = w_data->do_custom_size;
  4589.  
  4590.     if (enabled && w_data->image_data.bWidthPercent)
  4591.         index = 1;
  4592.  
  4593.     XfeOptionMenuSetItem(widget, index);
  4594.     XtVaSetValues(widget, XmNsensitive, enabled, 0);
  4595. }
  4596.  
  4597. static void
  4598. fe_image_constrain_cb(Widget widget,
  4599.                       XtPointer closure, XtPointer call_data)
  4600. {
  4601.     fe_EditorImagePropertiesWidgets* w_data =
  4602.         (fe_EditorImagePropertiesWidgets*)closure;
  4603.     XmToggleButtonCallbackStruct* info =
  4604.         (XmToggleButtonCallbackStruct*)call_data;
  4605.  
  4606.     w_data->do_constrain = info->set;
  4607. }
  4608.  
  4609. static void
  4610. fe_image_constrain_update_cb(Widget widget,
  4611.                              XtPointer closure, XtPointer call_data)
  4612. {
  4613.     fe_EditorImagePropertiesWidgets* w_data =
  4614.         (fe_EditorImagePropertiesWidgets*)closure;
  4615.     Boolean enabled = w_data->do_custom_size;
  4616.     Boolean sensitive =    !(w_data->image_data.bHeightPercent ||
  4617.                           w_data->image_data.bWidthPercent);
  4618.     Boolean set = (w_data->do_constrain) && sensitive;
  4619.  
  4620. #if 0
  4621.     if (info->caller == widget)
  4622.         return; /* don't call ourselves */
  4623. #endif
  4624.  
  4625.     XtVaSetValues(widget,
  4626.                   XmNsensitive, (sensitive && enabled),
  4627.                   XmNset, set,
  4628.                   0);
  4629. }
  4630.  
  4631. static void
  4632. fe_EditorImagePropertiesDialogDataGet(MWContext* context,
  4633.                                   fe_EditorImagePropertiesWidgets* w_data)
  4634. {
  4635.     EDT_ImageData* old = NULL;
  4636.  
  4637.     if (EDT_GetCurrentElementType(context) == ED_ELEMENT_IMAGE) {
  4638.         old = EDT_GetImageData(context);
  4639.         memcpy(&w_data->image_data, old, sizeof(EDT_ImageData));
  4640.  
  4641.         if (w_data->image_data.iOriginalWidth != w_data->image_data.iWidth
  4642.             ||
  4643.             w_data->image_data.iOriginalHeight != w_data->image_data.iHeight)
  4644.             w_data->do_custom_size = TRUE;
  4645.         else
  4646.             w_data->do_custom_size = FALSE;
  4647.         w_data->existing_image = TRUE;
  4648.  
  4649.     } else {
  4650.         old = EDT_NewImageData();
  4651.         memcpy(&w_data->image_data, old, sizeof(EDT_ImageData));
  4652.         w_data->do_custom_size = FALSE;
  4653.         w_data->existing_image = FALSE;
  4654.     }
  4655.  
  4656.     w_data->new_image = FALSE;
  4657.     w_data->do_constrain = TRUE; /* ooo, we like this */
  4658.  
  4659.     if (w_data->image_data.iBorder == -1) {
  4660.         w_data->default_border = TRUE;
  4661.         w_data->image_data.iBorder = EDT_GetDefaultBorderWidth(context);
  4662.     }
  4663.     else {
  4664.         w_data->default_border = FALSE;
  4665.     }
  4666.  
  4667.     fe_update_dependents(NULL, w_data->properties, PROP_IMAGE_ALL);
  4668.     /* yes, that's all sally */
  4669.  
  4670.     if (old)
  4671.         EDT_FreeImageData(old);
  4672. }
  4673.  
  4674. static void
  4675. fe_copy_string_over(char** tgt, Widget widget)
  4676. {
  4677.     char* p = fe_TextFieldGetString(widget);
  4678.     
  4679.     if (*tgt)
  4680.         XP_FREE(*tgt);
  4681.     if (p && *p != '\0')
  4682.         *tgt = XP_STRDUP(p);
  4683.     else
  4684.         *tgt = NULL;
  4685.     if (p)
  4686.         XtFree(p);
  4687. }
  4688.  
  4689.  
  4690. static void
  4691. fe_editor_image_properties_common_set(MWContext* context,
  4692.                                       EDT_ImageData* data,
  4693.                                       fe_EditorImagePropertiesWidgets* w_data)
  4694. {
  4695.     if (w_data->do_custom_size) {
  4696.         /*
  4697.          *    probably don't nee dto do this now, as the valueChanged
  4698.          *    callbacks keep this up to date.
  4699.          */
  4700.         data->iWidth = fe_get_numeric_text_field(w_data->image_width);
  4701.         data->iHeight = fe_get_numeric_text_field(w_data->image_height);
  4702.         data->bWidthPercent = w_data->image_data.bWidthPercent;;
  4703.         data->bHeightPercent = w_data->image_data.bHeightPercent;
  4704.     } else {
  4705.         data->iWidth = w_data->image_data.iOriginalWidth;
  4706.         data->iHeight = w_data->image_data.iOriginalHeight;
  4707.         data->bWidthPercent = FALSE;
  4708.         data->bHeightPercent = FALSE;
  4709.     }
  4710.     data->iHSpace = fe_get_numeric_text_field(w_data->margin_width);
  4711.     data->iVSpace = fe_get_numeric_text_field(w_data->margin_height);
  4712.     data->iBorder = fe_get_numeric_text_field(w_data->margin_solid);
  4713. }
  4714.  
  4715. static Boolean
  4716. fe_editor_image_properties_validate(MWContext* context,
  4717.                                   fe_EditorImagePropertiesWidgets* w_data)
  4718. {
  4719.     EDT_ImageData  image_data;
  4720.     EDT_ImageData* i = &image_data;
  4721.     unsigned       errors[16];
  4722.     unsigned       nerrors = 0;
  4723.     
  4724.     fe_editor_image_properties_common_set(context, &image_data, w_data);
  4725.  
  4726.     if (w_data->do_custom_size) {
  4727.         
  4728.         unsigned low;
  4729.         unsigned high;
  4730.     
  4731.         if (i->bWidthPercent) {
  4732.             low = TABLE_MIN_PERCENT_WIDTH;
  4733.             high = TABLE_MAX_PERCENT_WIDTH;
  4734.         } else {
  4735.             low = IMAGE_MIN_WIDTH;
  4736.             high = IMAGE_MAX_WIDTH;
  4737.         }
  4738.     
  4739.         if (RANGE_CHECK(i->iWidth, low, high))
  4740.             errors[nerrors++] = XFE_EDITOR_TABLE_WIDTH_RANGE;
  4741.  
  4742.         if (i->bHeightPercent) {
  4743.             low = TABLE_MIN_PERCENT_HEIGHT;
  4744.             high = TABLE_MAX_PERCENT_HEIGHT;
  4745.         } else {
  4746.             low = IMAGE_MIN_HEIGHT;
  4747.             high = IMAGE_MAX_HEIGHT;
  4748.         }
  4749.  
  4750.         if (RANGE_CHECK(i->iHeight, low, high))
  4751.             errors[nerrors++] = XFE_EDITOR_TABLE_HEIGHT_RANGE;
  4752.     }
  4753.     
  4754.     if (RANGE_CHECK(i->iHSpace, IMAGE_MIN_HSPACE, IMAGE_MAX_HSPACE))
  4755.         errors[nerrors++] = XFE_INVALID_IMAGE_HSPACE;
  4756.     if (RANGE_CHECK(i->iVSpace, IMAGE_MIN_VSPACE, IMAGE_MAX_VSPACE))
  4757.         errors[nerrors++] = XFE_INVALID_IMAGE_VSPACE;
  4758.     if (RANGE_CHECK(i->iBorder, IMAGE_MIN_BORDER, IMAGE_MAX_BORDER))
  4759.         errors[nerrors++] = XFE_INVALID_IMAGE_BORDER;
  4760.  
  4761.     if (nerrors > 0) {
  4762.         fe_editor_range_error_dialog(context, w_data->image_width,
  4763.                                      errors, nerrors);
  4764.         return FALSE;
  4765.     }
  4766.  
  4767.     return TRUE;
  4768. }
  4769.  
  4770. static void
  4771. fe_editor_image_properties_set(MWContext* context,
  4772.                                   fe_EditorImagePropertiesWidgets* w_data)
  4773. {
  4774.     EDT_ImageData* old;
  4775.  
  4776.     if (w_data->existing_image)
  4777.         old = EDT_GetImageData(context);
  4778.     else
  4779.         old = EDT_NewImageData();
  4780.  
  4781.     if ((w_data->properties->changed & PROP_IMAGE_MAIN_IMAGE) != 0)
  4782.         fe_copy_string_over(&old->pSrc, w_data->main_image);
  4783.     
  4784.     if ((w_data->properties->changed & PROP_IMAGE_ALT_IMAGE) != 0)
  4785.         fe_copy_string_over(&old->pLowSrc, w_data->alt_image);
  4786.  
  4787.     if ((w_data->properties->changed & PROP_IMAGE_ALT_TEXT) != 0)
  4788.         fe_copy_string_over(&old->pAlt, w_data->alt_text);
  4789.     
  4790.     fe_editor_image_properties_common_set(context, old, w_data);
  4791.  
  4792.     old->align = w_data->image_data.align;
  4793.     old->bIsMap = w_data->image_data.bIsMap;
  4794.     old->bNoSave = w_data->image_data.bNoSave;
  4795.  
  4796.     if (w_data->default_border && old->iBorder == w_data->image_data.iBorder) {
  4797.         old->iBorder = -1;
  4798.     }
  4799.  
  4800.  
  4801.     /*
  4802.      *    We don't handle the link data here, let the link sheet
  4803.      *    do that.
  4804.      */
  4805.     if (old->pSrc != NULL) {
  4806.         if (w_data->existing_image)
  4807.             EDT_SetImageData(context, old, !w_data->image_data.bNoSave);
  4808.         else
  4809.             EDT_InsertImage(context, old, !w_data->image_data.bNoSave);
  4810.     }
  4811.  
  4812.     EDT_FreeImageData(old);
  4813. }
  4814.  
  4815. static struct fe_style_data fe_image_button_names[] = {
  4816.      { "alignTop",       ED_ALIGN_TOP       },
  4817.     { "alignAbsCenter", ED_ALIGN_ABSCENTER },
  4818.     { "alignCenter",    ED_ALIGN_CENTER    },
  4819.     { "alignBaseline",  ED_ALIGN_BASELINE  },
  4820.     { "alignAbsBottom", ED_ALIGN_ABSBOTTOM },
  4821.     { "alignLeft",      ED_ALIGN_LEFT      },
  4822.     { "alignRight",     ED_ALIGN_RIGHT     },
  4823.     { 0 }
  4824.  
  4825. #if 0
  4826.     { "alignAbsTop",    ED_ALIGN_ABSTOP    },
  4827.     { "alignBottom",    ED_ALIGN_BOTTOM    },
  4828. #endif
  4829. };
  4830.  
  4831. static void
  4832. fe_make_image_icons(MWContext *context, Widget parent,
  4833.                     fe_EditorImagePropertiesWidgets* w_data)
  4834. {
  4835.     Pixmap   p;
  4836.     Arg      args[16];
  4837.     Cardinal n;
  4838.     Cardinal i;
  4839.     Widget   children[16];
  4840.     char*    name;
  4841.  
  4842.     for (i = 0; fe_image_button_names[i].name; i++) {
  4843.       
  4844.         MWContextType old = context->type;
  4845.  
  4846.         context->type = MWContextEditor;
  4847.         p  = fe_ToolbarPixmap(context, IL_ALIGN1_RAISED+(2*i), False, False);
  4848.         context->type = old;
  4849.  
  4850.         name = fe_image_button_names[i].name;
  4851.  
  4852.         n = 0;
  4853.         XtSetArg(args[n], XmNlabelType, XmPIXMAP); n++;
  4854.         XtSetArg(args[n], XmNlabelPixmap, p); n++;
  4855.         XtSetArg(args[n], XmNuserData, fe_image_button_names[i].data); n++;
  4856.         XtSetArg(args[n], XmNindicatorOn, FALSE); n++; /* Windows-esk */
  4857. #if 0
  4858.         /* looks ugly */
  4859.         XtSetArg(args[n], XmNmarginHeight, 0); n++;
  4860.         XtSetArg(args[n], XmNmarginWidth, 0); n++;
  4861. #endif
  4862.         children[i] = XmCreateToggleButtonGadget(parent, name, args, n);
  4863.  
  4864.         XtAddCallback(children[i], XmNvalueChangedCallback,
  4865.                       fe_image_align_cb, (XtPointer)w_data);
  4866.         fe_register_dependent(w_data->properties, children[i],
  4867.                               FE_MAKE_DEPENDENCY(PROP_IMAGE_ALIGN),
  4868.                               fe_image_align_update_cb, (XtPointer)w_data);
  4869.     }
  4870.     
  4871.     XtManageChildren(children, i);
  4872. }
  4873.  
  4874. static void
  4875. fe_make_image_page(MWContext *context, Widget parent,
  4876.                    fe_EditorImagePropertiesWidgets* w_data)
  4877. {
  4878.     Arg av [32];
  4879.     int ac;
  4880.     Widget form;
  4881.     Widget kids[32];
  4882.     Widget main_image_frame;
  4883.     Widget main_image_form;
  4884.     Widget main_image_text;
  4885.     Widget main_image_browse;
  4886.     Widget main_image_edit;
  4887.     Widget main_image_leave;
  4888.     Widget alt_frame;
  4889.     Widget alt_form;
  4890.     Widget alt_image_label;
  4891.     Widget alt_image_text;
  4892.     Widget alt_image_browse;
  4893.     Widget alt_image_edit;
  4894.     Widget alt_text_label;
  4895.     Widget alt_text_text;
  4896.     Widget align_frame;
  4897.     Widget align_form;
  4898.     Widget align_rc;
  4899.     Widget align_info;
  4900.     Widget dimensions_frame;
  4901.     Widget dimensions_form;
  4902.     Widget original_radio;
  4903.     Widget custom_radio;
  4904.     Widget height_label;
  4905.     Widget height_text;
  4906.     Widget height_pixels;
  4907.     Widget width_label;
  4908.     Widget width_text;    
  4909.     Widget width_pixels;
  4910.     Widget constrain;
  4911.     Widget space_frame;
  4912.     Widget space_form;
  4913.     Widget left_right_label;
  4914.     Widget left_right_text;
  4915.     Widget left_right_pixels;
  4916.     Widget top_bottom_label;
  4917.     Widget top_bottom_text;
  4918.     Widget top_bottom_pixels;
  4919.     Widget solid_border_label;
  4920.     Widget solid_text;
  4921.     Widget solid_pixels;
  4922.     Widget remove_image_map;
  4923.     Dimension width;
  4924.     Dimension height;
  4925.     Widget wide_guy;
  4926.     int i;
  4927.     XtCallbackRec callback;
  4928.  
  4929. #if 0
  4930.     ac = 0;
  4931.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  4932.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  4933.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  4934.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  4935.     form = XmCreateForm(parent, "imageProperties", av, ac);
  4936. #else
  4937.     form = parent;
  4938. #endif
  4939.  
  4940.     /**********************************************************************/
  4941.     /*  Define the Image file name Frame and its form 4MAR96RCJ        */
  4942.     /**********************************************************************/
  4943.     ac = 0;
  4944.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  4945.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  4946.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  4947.     main_image_frame = fe_CreateFrame(form, "imageFile", av, ac);
  4948.  
  4949.     ac = 0;
  4950.     main_image_form = XmCreateForm(main_image_frame, "form", av, ac);
  4951.  
  4952.     i  = 0; /* number of children */
  4953.  
  4954.     /* top row: text, browse, edit */
  4955.     ac = 0;
  4956.     kids[i++] = main_image_text = fe_CreateTextField(main_image_form,
  4957.                                                      "imageFile",
  4958.                                                      av, ac);
  4959.     w_data->main_image = main_image_text;
  4960.     XtAddCallback(main_image_text, XmNvalueChangedCallback,
  4961.                   fe_image_main_image_cb,(XtPointer)w_data);
  4962.  
  4963.     ac = 0;
  4964.     kids[i++] = main_image_browse = XmCreatePushButtonGadget(main_image_form,
  4965.                                                              "browse", 
  4966.                                                              av, ac);
  4967.     XtAddCallback(main_image_browse, XmNactivateCallback,
  4968.                   fe_image_main_image_browse_cb, (XtPointer)w_data);
  4969.  
  4970.     ac = 0;
  4971.     XtSetArg(av[ac], XmNsensitive,        False);           ac++;
  4972.     kids[i++] = main_image_edit = XmCreatePushButtonGadget(main_image_form,
  4973.                                                            "editImage",
  4974.                                                            av, ac);
  4975.     XtAddCallback(main_image_edit, XmNactivateCallback,
  4976.                   fe_image_edit_image_cb, (XtPointer)w_data);
  4977.     fe_register_dependent(w_data->properties, main_image_edit,
  4978.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_MAIN_IMAGE),
  4979.                           fe_image_edit_image_update_cb, (XtPointer)w_data);
  4980.  
  4981.     /* attachments */
  4982.     ac = 0;
  4983.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  4984.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  4985.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  4986.     XtSetArg(av[ac], XmNrightWidget, main_image_browse); ac++;
  4987.     XtSetValues(main_image_text, av, ac);
  4988.  
  4989.     XtVaGetValues(main_image_text, XmNheight, &height, NULL);
  4990.   
  4991.     ac = 0;
  4992.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  4993.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  4994.     XtSetArg(av[ac], XmNrightWidget, main_image_edit); ac++;
  4995.     XtSetArg(av[ac], XmNheight, height); ac++;
  4996.     XtSetValues(main_image_browse, av, ac);
  4997.   
  4998.     ac = 0;
  4999.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5000.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  5001.     XtSetArg(av[ac], XmNheight, height); ac++;
  5002.     XtSetValues(main_image_edit, av, ac);
  5003.  
  5004.     /* next row: leave at original location, use as background */
  5005.     ac = 0;
  5006.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET);   ac++;
  5007.     XtSetArg(av[ac], XmNtopWidget, main_image_browse); ac++;
  5008.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);   ac++;
  5009.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM);   ac++;
  5010.     kids[i++] = main_image_leave = XmCreateToggleButtonGadget(main_image_form,
  5011.                                                               "leaveImage",
  5012.                                                               av, ac);
  5013.     XtAddCallback(main_image_leave, XmNvalueChangedCallback,
  5014.                   fe_image_copy_cb, (XtPointer)w_data);
  5015.  
  5016.     fe_register_dependent(w_data->properties,
  5017.                           main_image_leave, 
  5018.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_COPY),
  5019.                           fe_image_copy_update_cb, (XtPointer)w_data);
  5020.  
  5021. #if 0
  5022.     Widget use_as_background;
  5023.  
  5024.     ac = 0;
  5025.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET);   ac++;
  5026.     XtSetArg(av[ac], XmNtopWidget, main_image_browse); ac++;
  5027.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET);   ac++;
  5028.     XtSetArg(av[ac], XmNleftWidget, main_image_leave); ac++;
  5029.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  5030.     XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  5031.     use_as_background = XmCreateToggleButtonGadget(main_image_form,
  5032.                                                    "useAsBackground",
  5033.                                                    av, ac);
  5034.     kids[i++] = use_as_background;
  5035.  
  5036.     XtAddCallback(use_as_background, XmNvalueChangedCallback,
  5037.                   fe_image_copy_cb, (XtPointer)w_data);
  5038.  
  5039.     fe_register_dependent(w_data->properties,
  5040.                           use_as_background, 
  5041.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_COPY),
  5042.                           fe_image_copy_update_cb, (XtPointer)w_data);
  5043. #endif
  5044.     XtManageChildren(kids, i);
  5045.  
  5046.     /* alternative frame */
  5047.     ac = 0;
  5048.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5049.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  5050.     XtSetArg(av[ac], XmNtopAttachment,  XmATTACH_WIDGET);  ac++;
  5051.     XtSetArg(av[ac], XmNtopWidget,      main_image_frame);  ac++;
  5052.     alt_frame = fe_CreateFrame(form, "alternativeImage", av, ac);
  5053.     XtManageChild(alt_frame);
  5054.  
  5055.     ac = 0;
  5056.     alt_form = XmCreateForm(alt_frame, "form", av, ac);
  5057.     XtManageChild(alt_form);
  5058.  
  5059.     i  = 0; /* number of children */
  5060.  
  5061.     /* next row: alternative label, text, browse, edit */
  5062.     ac = 0;
  5063.     XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  5064.     kids[i++] = alt_image_label = XmCreateLabelGadget(alt_form, 
  5065.                                                       "alternativeImageLabel",
  5066.                                                       av, ac);
  5067.  
  5068.     ac = 0;
  5069.     kids[i++] = alt_image_text = fe_CreateTextField(alt_form,
  5070.                                                     "alternativeImage",
  5071.                                                     av, ac);
  5072.     w_data->alt_image = alt_image_text;
  5073.     XtAddCallback(alt_image_text, XmNvalueChangedCallback,
  5074.                   fe_image_alt_image_cb, (XtPointer)w_data);
  5075.     fe_register_dependent(w_data->properties, alt_image_text,
  5076.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_ALT_IMAGE),
  5077.                           fe_image_alt_image_update_cb, (XtPointer)w_data);
  5078.  
  5079.     ac = 0;
  5080.     kids[i++] = alt_image_browse = XmCreatePushButtonGadget(alt_form,
  5081.                                                             "browse",
  5082.                                                             av, ac);
  5083.     XtAddCallback(alt_image_browse, XmNactivateCallback,
  5084.                   fe_image_alt_image_browse_cb, (XtPointer)w_data);
  5085.  
  5086.     ac = 0;
  5087.     XtSetArg(av[ac], XmNsensitive,        False);           ac++;
  5088.     kids[i++] = alt_image_edit = XmCreatePushButtonGadget(alt_form,
  5089.                                                           "editImage",
  5090.                                                           av, ac);
  5091.     XtAddCallback(alt_image_edit, XmNactivateCallback,
  5092.                   fe_image_edit_alt_image_cb, (XtPointer)w_data);
  5093.     fe_register_dependent(w_data->properties, alt_image_edit,
  5094.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_ALT_IMAGE),
  5095.                           fe_image_edit_alt_image_update_cb, 
  5096.                           (XtPointer)w_data);
  5097.  
  5098.     /* attachments */
  5099.     ac = 0;
  5100.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5101.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5102.     XtSetArg(av[ac], XmNleftWidget, alt_image_label); ac++;
  5103.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  5104.     XtSetArg(av[ac], XmNrightWidget, alt_image_browse); ac++;
  5105.     XtSetValues(alt_image_text, av, ac);
  5106.  
  5107.     XtVaGetValues(alt_image_text, XmNheight, &height, NULL);
  5108.  
  5109.     ac = 0;
  5110.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5111.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);    ac++;
  5112.     XtSetArg(av[ac], XmNheight, height); ac++;
  5113.     XtSetValues(alt_image_label, av, ac);
  5114.  
  5115.     ac = 0;
  5116.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5117.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  5118.     XtSetArg(av[ac], XmNrightWidget, alt_image_edit); ac++;
  5119.     XtSetArg(av[ac], XmNheight, height); ac++;
  5120.     XtSetValues(alt_image_browse, av, ac);
  5121.  
  5122.     ac = 0;
  5123.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5124.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  5125.     XtSetArg(av[ac], XmNheight, height); ac++;
  5126.     XtSetValues(alt_image_edit, av, ac);
  5127.  
  5128.     /* next row: alternative text label, text */
  5129.     ac = 0;
  5130.     XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  5131.     kids[i++] = alt_text_label = XmCreateLabelGadget(alt_form, 
  5132.                                                      "alternativeTextLabel",
  5133.                                                      av, ac);
  5134.     ac = 0;
  5135.     kids[i++] = alt_text_text = fe_CreateTextField(alt_form,
  5136.                                                    "alternativeText",
  5137.                                                    av, ac);
  5138.     w_data->alt_text = alt_text_text;
  5139.  
  5140.     XtAddCallback(alt_text_text, XmNvalueChangedCallback,
  5141.                   fe_image_alt_text_cb, (XtPointer)w_data);
  5142.     fe_register_dependent(w_data->properties, alt_text_text,
  5143.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_ALT_TEXT),
  5144.                           fe_image_alt_text_update_cb, (XtPointer)w_data);
  5145.  
  5146.     /* attachments */
  5147.     ac = 0;
  5148.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5149.     XtSetArg(av[ac], XmNtopWidget, alt_image_text); ac++;
  5150.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5151.     XtSetArg(av[ac], XmNleftWidget, alt_image_label); ac++;
  5152.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  5153.     XtSetValues(alt_text_text, av, ac);
  5154.  
  5155.     XtVaGetValues(alt_text_text, XmNheight, &height, NULL);
  5156.  
  5157.     ac = 0;
  5158.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5159.     XtSetArg(av[ac], XmNtopWidget, alt_image_text); ac++;
  5160.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5161.     XtSetArg(av[ac], XmNheight, height); ac++;
  5162.     XtSetValues(alt_text_label, av, ac);
  5163.  
  5164.     XtManageChildren(kids, i);
  5165.  
  5166.     /**********************************************************************/
  5167.     /*  Define the Alignment Frame and its form    4MAR96RCJ        */
  5168.     /**********************************************************************/
  5169.     ac = 0;
  5170.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);   ac++;
  5171.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM);  ac++;
  5172.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET);  ac++;
  5173.     XtSetArg(av[ac], XmNtopWidget, alt_frame);       ac++;
  5174.     align_frame = fe_CreateFrame(form, "alignment", av, ac);
  5175.  
  5176.     ac = 0;
  5177.     align_form = XmCreateForm(align_frame, "alignmentForm", av, ac);
  5178.  
  5179.     ac = 0;
  5180.     XtSetArg(av[ac], XmNorientation, XmHORIZONTAL); ac++;
  5181.     XtSetArg(av[ac], XmNradioBehavior, TRUE); ac++;
  5182.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);   ac++;
  5183.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM);  ac++;
  5184.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM);  ac++;
  5185.     XtSetArg(av[ac], XmNspacing, 0);  ac++;
  5186.     align_rc = XmCreateRowColumn(align_form, "alignmentRowColumn", av, ac);
  5187.     XtManageChild(align_rc);
  5188.  
  5189.     fe_make_image_icons(context, align_rc, w_data);
  5190.  
  5191.     ac = 0;
  5192.     XtSetArg(av[ac], XmNalignment,         XmALIGNMENT_END); ac++;
  5193.     XtSetArg(av[ac], XmNrightAttachment,   XmATTACH_FORM);   ac++;
  5194.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5195.     XtSetArg(av[ac], XmNtopWidget,     align_rc);      ac++;
  5196. #if 0
  5197.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  5198. #endif
  5199.     align_info = XmCreateLabelGadget(align_form, "alignmentInfoLabel", av, ac);
  5200.     XtManageChild(align_info);
  5201.  
  5202.     /**********************************************************************/
  5203.     /*  Define the Buttons at bottom of Image Properties Tab Panel    */
  5204.     /**********************************************************************/
  5205.     i  = 0;
  5206.  
  5207.     ac = 0;
  5208.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM);   ac++;
  5209.     XtSetArg(av[ac], XmNleftAttachment,  XmATTACH_FORM); ac++;
  5210.     XtSetArg(av[ac], XmNsensitive,        False);           ac++;
  5211.     kids[i++] = remove_image_map = XmCreatePushButtonGadget(form,
  5212.                                                             "removeImageMap",
  5213.                                                             av, ac);
  5214.     XtAddCallback(remove_image_map, XmNactivateCallback,
  5215.                   fe_image_remove_imap_cb, (XtPointer)w_data);
  5216.     fe_register_dependent(w_data->properties, remove_image_map,
  5217.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_IMAP),
  5218.                           fe_image_remove_imap_update_cb, (XtPointer)w_data);
  5219.  
  5220.     XtManageChildren(kids, i);
  5221.  
  5222.     /**********************************************************************/
  5223.     /*  Define the Dimensions Frame and its form    4MAR96RCJ        */
  5224.     /**********************************************************************/
  5225.     ac = 0;
  5226.     XtSetArg(av[ac], XmNleftAttachment,   XmATTACH_FORM);   ac++;
  5227.     XtSetArg(av[ac], XmNtopAttachment,    XmATTACH_WIDGET); ac++;
  5228.     XtSetArg(av[ac], XmNtopWidget,        align_frame);      ac++;
  5229.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
  5230.     XtSetArg(av[ac], XmNbottomWidget,     remove_image_map);  ac++;
  5231.     dimensions_frame = fe_CreateFrame(form, "dimensions", av, ac);
  5232.  
  5233.     ac = 0;
  5234.     dimensions_form = XmCreateForm(dimensions_frame, 
  5235.                                    "dimensionsForm", av, ac);
  5236.     i  = 0;
  5237.  
  5238.     ac = 0;
  5239.     kids[i++] = height_label = XmCreateLabelGadget(dimensions_form, 
  5240.                                                    "heightLabel",
  5241.                                                    av, ac);
  5242.  
  5243.     ac = 0;
  5244.     kids[i++] = width_label = XmCreateLabelGadget(dimensions_form, 
  5245.                                                   "widthLabel",
  5246.                                                   av, ac);
  5247.  
  5248. #define PROP_DIM_UPDATE (PROP_IMAGE_COPY|PROP_IMAGE_DIMENSIONS)
  5249.  
  5250.     ac = 0;
  5251.     XtSetArg(av[ac], XmNuserData, FALSE); ac++;
  5252.     XtSetArg(av[ac], XmNindicatorType, XmONE_OF_MANY); ac++;
  5253.     kids[i++] = original_radio = XmCreateToggleButtonGadget(dimensions_form, 
  5254.                                                             "originalSize",
  5255.                                                             av, ac);
  5256.     XtAddCallback(original_radio, XmNvalueChangedCallback,
  5257.                   fe_image_original_size_cb, (XtPointer)w_data);
  5258.     fe_register_dependent(w_data->properties, original_radio,
  5259.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5260.                           fe_image_original_size_update_cb, (XtPointer)w_data);
  5261.  
  5262.     ac = 0;
  5263.     XtSetArg(av[ac], XmNuserData, TRUE); ac++;
  5264.     XtSetArg(av[ac], XmNindicatorType, XmONE_OF_MANY); ac++;
  5265.     kids[i++] = custom_radio = XmCreateToggleButtonGadget(dimensions_form, 
  5266.                                                           "customSize",
  5267.                                                           av, ac);
  5268.  
  5269.     XtAddCallback(custom_radio, XmNvalueChangedCallback,
  5270.                   fe_image_custom_size_cb, (XtPointer)w_data);
  5271.     fe_register_dependent(w_data->properties, custom_radio,
  5272.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5273.                           fe_image_custom_size_update_cb, (XtPointer)w_data);
  5274.  
  5275.     ac = 0;
  5276.     XtSetArg(av[ac], XmNcolumns, 4); ac++;
  5277.     kids[i++] = height_text = fe_CreateTextField(dimensions_form,
  5278.                                                  "imageHeight",
  5279.                                                  av, ac);
  5280.     w_data->image_height = height_text;
  5281.  
  5282.     XtAddCallback(height_text, XmNvalueChangedCallback,
  5283.                   fe_image_dimensions_cb, (XtPointer)w_data);
  5284.     fe_register_dependent(w_data->properties, height_text,
  5285.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5286.                           fe_image_dimensions_height_update_cb,
  5287.                           (XtPointer)w_data);
  5288.  
  5289.     callback.callback = fe_image_height_pixel_percent_cb;
  5290.     callback.closure = (XtPointer)w_data;
  5291.  
  5292.     ac = 0;
  5293.     XtSetArg(av[ac], XmNsimpleCallback, &callback); ac++;
  5294.     XtSetArg(av[ac], XmNbuttons, fe_SimpleOptionPixelPercent); ac++;
  5295.     XtSetArg(av[ac], XmNmarginHeight, 0); ac++;
  5296.     XtSetArg(av[ac], XmNmarginWidth, 0); ac++;
  5297.     height_pixels = fe_CreateSimpleOptionMenu(dimensions_form, "heightUnits",
  5298.                                               av, ac);
  5299.     fe_register_dependent(w_data->properties, height_pixels,
  5300.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5301.                           fe_image_height_pixel_percent_update_cb,
  5302.                           (XtPointer)w_data);
  5303.     kids[i++] = height_pixels;
  5304.  
  5305.     ac = 0;
  5306.     kids[i++] = width_text = fe_CreateTextField(dimensions_form,
  5307.                                                 "imageWidth",
  5308.                                                 av, ac);
  5309.     w_data->image_width = width_text;
  5310.  
  5311.     XtAddCallback(width_text, XmNvalueChangedCallback,
  5312.                   fe_image_dimensions_cb, (XtPointer)w_data);
  5313.     fe_register_dependent(w_data->properties, width_text,
  5314.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5315.                           fe_image_dimensions_width_update_cb,
  5316.                           (XtPointer)w_data);
  5317.  
  5318.     callback.callback = fe_image_width_pixel_percent_cb;
  5319.     callback.closure = (XtPointer)w_data;
  5320.  
  5321.     ac = 0;
  5322.     XtSetArg(av[ac], XmNsimpleCallback, &callback); ac++;
  5323.     XtSetArg(av[ac], XmNbuttons, fe_SimpleOptionPixelPercent); ac++;
  5324.     XtSetArg(av[ac], XmNmarginHeight, 0); ac++;
  5325.     XtSetArg(av[ac], XmNmarginWidth, 0); ac++;
  5326.     width_pixels = fe_CreateSimpleOptionMenu(dimensions_form, "widthUnits",
  5327.                                              av, ac);
  5328.     fe_register_dependent(w_data->properties, width_pixels,
  5329.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5330.                           fe_image_width_pixel_percent_update_cb,
  5331.                           (XtPointer)w_data);
  5332.     kids[i++] = width_pixels;
  5333.  
  5334.     ac = 0;
  5335.     kids[i++] = constrain = XmCreateToggleButtonGadget(dimensions_form,
  5336.                                                        "constrain",
  5337.                                                        av, ac);
  5338.     XtAddCallback(constrain, XmNvalueChangedCallback,
  5339.                   fe_image_constrain_cb, (XtPointer)w_data);
  5340.     fe_register_dependent(w_data->properties, constrain,
  5341.                           FE_MAKE_DEPENDENCY(PROP_DIM_UPDATE),
  5342.                           fe_image_constrain_update_cb, (XtPointer)w_data);
  5343.  
  5344.     /* do attachments */
  5345.     ac = 0;
  5346.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  5347.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5348.     XtSetValues(original_radio, av, ac);
  5349.  
  5350.     ac = 0;
  5351.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5352.     XtSetArg(av[ac], XmNtopWidget, original_radio); ac++;
  5353.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5354.     XtSetValues(custom_radio, av, ac);
  5355.  
  5356.     wide_guy = XfeBiggestWidget(TRUE, kids, 2); /* the two labels */
  5357.     XtVaGetValues(wide_guy, XmNwidth, &width, 0);
  5358.   
  5359.     ac = 0;
  5360.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5361.     XtSetArg(av[ac], XmNtopWidget, custom_radio); ac++;
  5362.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5363.     XtSetArg(av[ac], XmNwidth, width); ac++;
  5364.     XtSetValues(height_label, av, ac);
  5365.  
  5366.     ac = 0;
  5367.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
  5368.     XtSetArg(av[ac], XmNtopWidget, height_label); ac++;
  5369.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5370.     XtSetArg(av[ac], XmNleftWidget, wide_guy); ac++;
  5371.     XtSetValues(height_text, av, ac);
  5372.  
  5373.     ac = 0;
  5374.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
  5375.     XtSetArg(av[ac], XmNtopWidget, height_label); ac++;
  5376.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5377.     XtSetArg(av[ac], XmNleftWidget, height_text); ac++;
  5378.     XtSetValues(height_pixels, av, ac);
  5379.  
  5380.     ac = 0;
  5381.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5382.     XtSetArg(av[ac], XmNtopWidget, height_text); ac++;
  5383.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5384.     XtSetArg(av[ac], XmNwidth, width); ac++;
  5385.     XtSetValues(width_label, av, ac);
  5386.  
  5387.     ac = 0;
  5388.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
  5389.     XtSetArg(av[ac], XmNtopWidget, width_label); ac++;
  5390.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5391.     XtSetArg(av[ac], XmNleftWidget, wide_guy); ac++;
  5392.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
  5393.     XtSetArg(av[ac], XmNrightWidget, height_text); ac++;
  5394.     XtSetValues(width_text, av, ac);
  5395.  
  5396.     ac = 0;
  5397.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
  5398.     XtSetArg(av[ac], XmNtopWidget, width_label); ac++;
  5399.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  5400.     XtSetArg(av[ac], XmNleftWidget, height_text); ac++;
  5401.     XtSetValues(width_pixels, av, ac);
  5402.  
  5403.     ac = 0;
  5404.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  5405.     XtSetArg(av[ac], XmNtopWidget, width_text); ac++;
  5406.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  5407.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  5408.     XtSetValues(constrain, av, ac);
  5409.  
  5410.     XtManageChildren(kids, i);
  5411.  
  5412.     /**********************************************************************/
  5413.     /*  Create Space Around Image Frame, Form, Contents 6MAR96RCJ        */
  5414.     /**********************************************************************/
  5415.     ac = 0;
  5416.     i  = 0;
  5417.     XtSetArg(av[ac], XmNleftAttachment,   XmATTACH_WIDGET); ac++;
  5418.     XtSetArg(av[ac], XmNleftWidget,       dimensions_frame); ac++;
  5419.     XtSetArg(av[ac], XmNrightAttachment,  XmATTACH_FORM);   ac++;
  5420.     XtSetArg(av[ac], XmNtopAttachment,    XmATTACH_WIDGET); ac++;
  5421.     XtSetArg(av[ac], XmNtopWidget,        align_frame);      ac++;
  5422.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
  5423.     XtSetArg(av[ac], XmNbottomWidget,     remove_image_map);  ac++;
  5424.     space_frame = fe_CreateFrame(form, "imageSpace", av, ac);
  5425.  
  5426.     ac = 0;
  5427.     XtSetArg(av[ac], XmNleftAttachment,   XmATTACH_FORM); ac++;
  5428.     XtSetArg(av[ac], XmNrightAttachment,  XmATTACH_FORM); ac++;
  5429.     XtSetArg(av[ac], XmNtopAttachment,    XmATTACH_FORM); ac++;
  5430.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  5431.     space_form = XmCreateForm(space_frame, 
  5432.                               "imageSpaceForm", av, ac);
  5433.  
  5434.     ac = 0;
  5435.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);    ac++;
  5436.     XtSetArg(av[ac], XmNtopAttachment,  XmATTACH_FORM);    ac++;
  5437.     XtSetArg(av[ac], XmNalignment, XmALIGNMENT_BEGINNING); ac++;
  5438.     kids[i++] = left_right_label = XmCreateLabelGadget(space_form, 
  5439.                                                        "leftRightLabel",
  5440.                                                        av, ac);
  5441.     ac = 0;
  5442.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);   ac++;
  5443.     kids[i++] = top_bottom_label = XmCreateLabelGadget(space_form, 
  5444.                                                        "topBottomLabel",
  5445.                                                        av, ac);
  5446.  
  5447.     XtVaGetValues(top_bottom_label, XmNwidth,&width,NULL);
  5448.     XtVaSetValues(left_right_label, XmNwidth, width,NULL);
  5449.  
  5450.     ac = 0;
  5451.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM);  ac++;
  5452.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_FORM);  ac++;
  5453.     kids[i++] = left_right_pixels = XmCreateLabelGadget(space_form, 
  5454.                                                         "pixels",
  5455.                                                         av, ac);
  5456.     ac = 0;
  5457.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_FORM);   ac++;
  5458.     XtSetArg(av[ac], XmNleftAttachment,  XmATTACH_WIDGET); ac++;
  5459.     XtSetArg(av[ac], XmNleftWidget,      left_right_label);  ac++;
  5460.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  5461.     XtSetArg(av[ac], XmNrightWidget,     left_right_pixels);   ac++;
  5462.     XtSetArg(av[ac], XmNcolumns,     3);    ac++;
  5463.     kids[i++] = left_right_text = fe_CreateTextField(space_form,
  5464.                                                      "spaceWidth",
  5465.                                                      av, ac);
  5466.     w_data->margin_width = left_right_text;
  5467.  
  5468.     XtAddCallback(left_right_text, XmNvalueChangedCallback,
  5469.                   fe_image_margin_cb, (XtPointer)w_data);
  5470.     fe_register_dependent(w_data->properties, left_right_text,
  5471.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_MARGIN_WIDTH),
  5472.                           fe_image_margin_width_update_cb, (XtPointer)w_data);
  5473.  
  5474.     XtVaSetValues(top_bottom_label,
  5475.                   XmNtopAttachment,  XmATTACH_WIDGET,
  5476.                   XmNtopWidget,      left_right_text,
  5477.                   NULL);
  5478.     ac = 0;
  5479.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  5480.     XtSetArg(av[ac], XmNtopWidget,       left_right_text);   ac++;
  5481.     XtSetArg(av[ac], XmNleftAttachment,  XmATTACH_WIDGET); ac++;
  5482.     XtSetArg(av[ac], XmNleftWidget,      top_bottom_label);  ac++;
  5483.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  5484.     XtSetArg(av[ac], XmNrightWidget,     left_right_pixels);      ac++;
  5485.     XtSetArg(av[ac], XmNcolumns,     3);    ac++;
  5486.     kids[i++] = top_bottom_text = fe_CreateTextField(space_form,
  5487.                                                      "spaceHeight",
  5488.                                                      av, ac);
  5489.     w_data->margin_height = top_bottom_text;
  5490.     XtAddCallback(top_bottom_text, XmNvalueChangedCallback,
  5491.                   fe_image_margin_cb, (XtPointer)w_data);
  5492.     fe_register_dependent(w_data->properties, top_bottom_text,
  5493.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_MARGIN_HEIGHT),
  5494.                           fe_image_margin_height_update_cb, (XtPointer)w_data);
  5495.  
  5496.     ac = 0;
  5497.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM);   ac++;
  5498.     XtSetArg(av[ac], XmNtopAttachment,  XmATTACH_WIDGET); ac++;
  5499.     XtSetArg(av[ac], XmNtopWidget,      top_bottom_text);    ac++;
  5500.     kids[i++] = solid_border_label = XmCreateLabelGadget(space_form, 
  5501.                                                          "solidBorderLabel",
  5502.                                                          av, ac);
  5503.     ac = 0;
  5504.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM);   ac++;
  5505.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  5506.     XtSetArg(av[ac], XmNtopWidget,       left_right_text);   ac++;
  5507.     kids[i++] = top_bottom_pixels = XmCreateLabelGadget(space_form, 
  5508.                                                         "pixels",
  5509.                                                         av, ac);
  5510.     ac = 0;
  5511.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM);   ac++;
  5512.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  5513.     XtSetArg(av[ac], XmNtopWidget,       top_bottom_text);    ac++;
  5514.     kids[i++] = solid_pixels = XmCreateLabelGadget(space_form, 
  5515.                                                    "pixels",
  5516.                                                    av, ac);
  5517.     ac = 0;
  5518.     XtSetArg(av[ac], XmNtopAttachment,   XmATTACH_WIDGET); ac++;
  5519.     XtSetArg(av[ac], XmNtopWidget,       top_bottom_text);    ac++;
  5520.     XtSetArg(av[ac], XmNleftAttachment,  XmATTACH_WIDGET); ac++;
  5521.     XtSetArg(av[ac], XmNleftWidget,      top_bottom_label);  ac++;
  5522.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  5523.     XtSetArg(av[ac], XmNrightWidget,     left_right_pixels);      ac++;
  5524.     XtSetArg(av[ac], XmNcolumns,     3);    ac++;
  5525.     kids[i++] = solid_text = fe_CreateTextField(space_form,
  5526.                                                 "spaceBorder",
  5527.                                                 av, ac);
  5528.     w_data->margin_solid = solid_text;
  5529.     XtAddCallback(solid_text, XmNvalueChangedCallback,
  5530.                   fe_image_margin_cb, (XtPointer)w_data);
  5531.     /*
  5532.      *    Note border is dependent on link href, as it effects the
  5533.      *    default value.
  5534.      */
  5535.     fe_register_dependent(w_data->properties, solid_text,
  5536.                   FE_MAKE_DEPENDENCY(PROP_LINK_HREF|PROP_IMAGE_MARGIN_BORDER),
  5537.                           fe_image_margin_border_update_cb, (XtPointer)w_data);
  5538.  
  5539.     XtManageChildren(kids, i);
  5540.  
  5541.     /*
  5542.      *    Add this last, as other update methoda are dependent on it
  5543.      *    having run during init.
  5544.      */
  5545.     fe_register_dependent(w_data->properties, main_image_text,
  5546.                           FE_MAKE_DEPENDENCY(PROP_IMAGE_MAIN_IMAGE),
  5547.                           fe_image_main_image_update_cb, (XtPointer)w_data);
  5548.  
  5549.     /**********************************************************************/
  5550.     /*  Display form by managing all of the Manager widgets 6MAR96RCJ    */
  5551.     /**********************************************************************/
  5552.     XtManageChild(space_form);
  5553.     XtManageChild(space_frame);
  5554.     XtManageChild(main_image_form);
  5555.     XtManageChild(main_image_frame);
  5556.     XtManageChild(align_form);
  5557.     XtManageChild(align_frame);
  5558.     XtManageChild(dimensions_form);
  5559.     XtManageChild(dimensions_frame);
  5560.     XtManageChild(form);
  5561. } /* end fe_make_image_page */
  5562.  
  5563. Widget
  5564. fe_EditorPropertiesDialogCreate(
  5565.                                 MWContext *context, 
  5566.                                 fe_EditorPropertiesWidgets* p_data,
  5567.                                 Boolean is_image
  5568. )
  5569. {
  5570.     Widget   dialog;
  5571.     Widget   form;
  5572.     Widget   tab_form;
  5573.     char*    name = (is_image)?    "imagePropertiesDialog":
  5574.                                 "textPropertiesDialog";
  5575.     
  5576.     /*
  5577.      *    Make prompt with ok, apply, cancel, no separator.
  5578.      */
  5579.     dialog = fe_CreatePromptDialog(context, name,
  5580.                                    TRUE, TRUE, TRUE, FALSE, TRUE);
  5581.  
  5582.     form = XtVaCreateManagedWidget(
  5583.                                    "folder",
  5584.                                    xmlFolderWidgetClass, dialog,
  5585.                                    XmNshadowThickness, 2,
  5586.                                    XmNtopAttachment, XmATTACH_FORM,
  5587.                                    XmNleftAttachment, XmATTACH_FORM,
  5588.                                    XmNrightAttachment, XmATTACH_FORM,
  5589.                                    XmNbottomAttachment, XmATTACH_FORM,
  5590. #ifdef ALLOW_TAB_ROTATE
  5591.                                    XmNtabPlacement, XmFOLDER_LEFT,
  5592.                                    XmNrotateWhenLeftRight, FALSE,
  5593. #endif /* ALLOW_TAB_ROTATE */
  5594.                                    XmNbottomOffset, 3,
  5595.                                    XmNspacing, 1,
  5596.                                    NULL);
  5597.  
  5598.     if (is_image) {
  5599.         tab_form = fe_CreateTabForm(form, "imageProperties", NULL, 0);
  5600.         fe_make_image_page(context, tab_form, p_data->image);
  5601.     } else {
  5602.         tab_form = fe_CreateTabForm(form, "characterProperties", NULL, 0);
  5603.         fe_make_character_page(context, tab_form, p_data->character);
  5604.     }
  5605.  
  5606.     tab_form = fe_CreateTabForm(form, "linkProperties", NULL, 0);
  5607.     fe_make_link_page(context, tab_form, p_data->link);
  5608.  
  5609.     tab_form = fe_CreateTabForm(form, "paragraphProperties", NULL, 0);
  5610.     fe_make_paragraph_page(context, tab_form, p_data->paragraph);
  5611.  
  5612.     XtManageChild(dialog);
  5613.  
  5614.     return form;
  5615. }
  5616.  
  5617. void
  5618. fe_EditorPropertiesDialogDo(MWContext* context, fe_EditorPropertiesDialogType tab_type)
  5619. {
  5620.     fe_EditorPropertiesWidgets          properties;
  5621.     fe_EditorParagraphPropertiesWidgets paragraph;
  5622.     fe_EditorLinkPropertiesWidgets      link;
  5623.     fe_EditorCharacterPropertiesWidgets character;
  5624.     fe_EditorImagePropertiesWidgets     image;
  5625.     int done;
  5626.     Widget dialog;
  5627.     Widget form;
  5628.     Widget apply_button;
  5629.     Boolean apply_sensitized;
  5630.     unsigned tab_number;
  5631.     Boolean is_image;
  5632.  
  5633.     is_image = fe_EditorPropertiesDialogCanDo(context, XFE_EDITOR_PROPERTIES_IMAGE);
  5634.  
  5635.     /*
  5636.      *    Pick the tab.
  5637.      */
  5638.     switch (tab_type) {
  5639.     case XFE_EDITOR_PROPERTIES_TARGET:
  5640.         fe_EditorTargetPropertiesDialogDo(context);
  5641.         return;
  5642.     case XFE_EDITOR_PROPERTIES_HTML_TAG:
  5643.         fe_EditorHtmlPropertiesDialogDo(context);
  5644.         return;
  5645.     case XFE_EDITOR_PROPERTIES_TABLE:
  5646.         fe_EditorTablePropertiesDialogDo(context, XFE_EDITOR_PROPERTIES_TABLE);
  5647.         return;
  5648.     case XFE_EDITOR_PROPERTIES_IMAGE:
  5649.         if (!is_image)
  5650.             return;
  5651.         /*FALLTHRU*/
  5652.     case XFE_EDITOR_PROPERTIES_IMAGE_INSERT:
  5653.         is_image = TRUE;
  5654.         tab_number = 0;
  5655.         break;
  5656.     case XFE_EDITOR_PROPERTIES_CHARACTER:
  5657.         is_image = FALSE;
  5658.         tab_number = 0;
  5659.         break;
  5660.     case XFE_EDITOR_PROPERTIES_LINK_INSERT:
  5661.     case XFE_EDITOR_PROPERTIES_LINK:     
  5662.         tab_number = 1;
  5663.         break;
  5664.     case XFE_EDITOR_PROPERTIES_PARAGRAPH:
  5665.         tab_number = 2;
  5666.         break;
  5667.     case XFE_EDITOR_PROPERTIES_HRULE:
  5668.         fe_EditorHorizontalRulePropertiesDialogDo(context);
  5669.         return;
  5670.     default:
  5671.         return;
  5672.     }
  5673.  
  5674.     memset(&properties, 0, sizeof(fe_EditorPropertiesWidgets));
  5675.     memset(¶graph, 0, sizeof(fe_EditorParagraphPropertiesWidgets));
  5676.     memset(&link, 0, sizeof(fe_EditorLinkPropertiesWidgets));
  5677.     memset(&character, 0, sizeof(fe_EditorCharacterPropertiesWidgets));
  5678.     memset(&image, 0, sizeof(fe_EditorImagePropertiesWidgets));
  5679.  
  5680.     /*
  5681.      *    I'll show you mine if you show me yours.
  5682.      */
  5683.     link.properties = &properties;
  5684.     paragraph.properties = &properties;
  5685.     image.properties = &properties;
  5686.     character.properties = &properties;
  5687.  
  5688.     properties.link = &link;
  5689.     properties.paragraph = ¶graph;
  5690.     if (is_image)
  5691.         properties.image = ℑ
  5692.     else 
  5693.         properties.character = &character;
  5694.  
  5695.     properties.context = context;
  5696.     form = fe_EditorPropertiesDialogCreate(context, &properties, is_image);
  5697.     dialog = XtParent(form);
  5698.  
  5699.     /*
  5700.      *   Add a bunch of callbacks to the buttons.
  5701.      */
  5702.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  5703.     XtAddCallback(dialog, XmNapplyCallback, fe_hrule_apply_cb, &done);
  5704.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  5705.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  5706.  
  5707.     /*
  5708.      *    Load values.
  5709.      */
  5710.     if (is_image)
  5711.         fe_EditorImagePropertiesDialogDataGet(context, &image);
  5712.     else
  5713.         fe_EditorCharacterPropertiesDialogDataGet(context, &character);
  5714.     fe_editor_link_properties_dialog_data_init(context, &link);
  5715.     fe_EditorParagraphPropertiesDialogDataGet(context, ¶graph);
  5716.  
  5717.     /*
  5718.      *    We toggle the sensitivity of the apply button on/off
  5719.      *    depending if there are changes to apply. It would be
  5720.      *    nice to use the depdency meahcnism, but it might get
  5721.      *    very busy.
  5722.      */
  5723.     apply_button = XmSelectionBoxGetChild(dialog, XmDIALOG_APPLY_BUTTON);
  5724.     XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  5725.     apply_sensitized = FALSE;
  5726.     properties.changed = 0;
  5727.  
  5728.     /*
  5729.      *    Popup.
  5730.      */
  5731.     XtManageChild(form);
  5732.  
  5733.     XmLFolderSetActiveTab(form, tab_number, True);
  5734.  
  5735.     /*
  5736.      *    Wait.
  5737.      */
  5738.     fe_NukeBackingStore(dialog); /* what does this do? */
  5739.  
  5740.     done = XmDIALOG_NONE;
  5741.     EDT_BeginBatchChanges(context);
  5742.     while (done == XmDIALOG_NONE) {
  5743.  
  5744.         Boolean new_image_override = FALSE;
  5745.  
  5746.         fe_EventLoop();
  5747.         
  5748.         if (done == XFE_DIALOG_DESTROY_BUTTON||done == XmDIALOG_CANCEL_BUTTON)
  5749.             break;
  5750.  
  5751.         /*
  5752.          *    This is a horrible crock to get around the fact
  5753.          *    that imageinsert() moves the context away from
  5754.          *    the image. Better solutions???
  5755.          */
  5756.         new_image_override = (properties.image && image.new_image);
  5757.         
  5758.         if (new_image_override) {
  5759.             if (apply_sensitized == TRUE) {
  5760.                 XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  5761.                 apply_sensitized = TRUE;
  5762.             }
  5763.         } else {
  5764.             if (apply_sensitized == FALSE && properties.changed != 0) {
  5765.                 XtVaSetValues(apply_button, XmNsensitive, TRUE, 0);
  5766.                 apply_sensitized = TRUE;
  5767.             }
  5768.         }
  5769.  
  5770.         if (done == XmDIALOG_APPLY_BUTTON || done == XmDIALOG_OK_BUTTON) {
  5771.             /* apply */
  5772.  
  5773.             if ((properties.changed & PROP_IMAGE_ALL) != 0
  5774.                 &&
  5775.                 !fe_editor_image_properties_validate(context, &image)) {
  5776.                 done = XmDIALOG_NONE;
  5777.                 continue;
  5778.             }
  5779.  
  5780.             if (properties.changed != 0) {
  5781.                 if ((properties.changed & PROP_CHAR_ALL) != 0) 
  5782.                     fe_EditorCharacterPropertiesDialogSet(context, &character);
  5783.                 if ((properties.changed & PROP_IMAGE_ALL) != 0)
  5784.                     fe_editor_image_properties_set(context, &image);
  5785.                 if ((properties.changed & PROP_LINK_ALL) != 0)
  5786.                     fe_editor_link_properties_dialog_set(context, &link);
  5787.                 if ((properties.changed & PROP_PARA_ALL) != 0) 
  5788.                     fe_EditorParagraphPropertiesDialogSet(context, ¶graph);
  5789.             }
  5790.  
  5791.             if (done == XmDIALOG_APPLY_BUTTON) {
  5792.                 properties.changed = 0;
  5793.                 XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  5794.                 apply_sensitized = FALSE;
  5795.                 done = XmDIALOG_NONE; /* keep looping */
  5796.             }
  5797.         }
  5798.     }
  5799.     EDT_EndBatchChanges(context);
  5800.  
  5801.     /*
  5802.      *    Unload data.
  5803.      */
  5804.     fe_DependentListDestroy(properties.dependents);
  5805.  
  5806.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  5807.         XtDestroyWidget(dialog);
  5808. }
  5809.  
  5810. void
  5811. fe_EditorSetColorsDialogDo(MWContext* context)
  5812. {
  5813.     LO_Color color;
  5814.     
  5815.     fe_EditorColorGet(context, &color);
  5816.  
  5817.     if (fe_ColorPicker(context, &color))
  5818.         fe_EditorColorSet(context, &color);
  5819. }
  5820.  
  5821. Widget
  5822. fe_CreateCombo(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  5823. {
  5824.   Widget pulldown;
  5825.   Arg args[8];
  5826.   Cardinal n;
  5827.   Widget button;
  5828.   char buf[64];
  5829.  
  5830.   sprintf(buf, "%sMenu", name);
  5831.  
  5832.   n = 0;
  5833.   pulldown = fe_CreatePulldownMenu(parent, buf, args, n);
  5834.  
  5835.   n = 0;
  5836.   button = XmCreatePushButtonGadget(pulldown, "emptyList", args, n);
  5837.   XtManageChild(button);
  5838.  
  5839.   n = 0;
  5840.   XtSetArg(args[n], XmNsubMenuId, pulldown); n++;
  5841.  
  5842.   return fe_CreateOptionMenuNoLabel(parent, name, args, n);
  5843. }
  5844.  
  5845. struct fe_EditorDocumentPropertiesStruct;
  5846.  
  5847. typedef struct fe_EditorDocumentGeneralPropertiesStruct
  5848. {
  5849.     struct fe_EditorDocumentPropertiesStruct* properties;
  5850.     
  5851.     Widget location;
  5852.     Widget title;
  5853.     Widget author;
  5854.     Widget description;
  5855. #ifdef EDITOR_SHOW_CREATE_DATE
  5856.     Widget created;
  5857.     Widget updated;
  5858. #endif /*EDITOR_SHOW_CREATE_DATE*/
  5859.     Widget keywords;
  5860.     Widget classification;
  5861.  
  5862.     unsigned changed;
  5863.     
  5864. } fe_EditorDocumentGeneralPropertiesStruct;
  5865.  
  5866. #if 0
  5867. static LO_Color**
  5868. fe_document_appearance_color_configure(
  5869.                fe_EditorDocumentAppearancePropertiesStruct* w_data,
  5870.                ED_EColor  c_type,
  5871.                LO_Color** def_color_r)
  5872. {
  5873.     LO_Color** result_addr;
  5874.  
  5875.     *def_color_r = &w_data->colors[c_type];
  5876.  
  5877.     switch (c_type) {
  5878.     case DOCUMENT_BACKGROUND_COLOR:
  5879.       result_addr = &w_data->page_data.pColorBackground;
  5880.       break;
  5881.     case DOCUMENT_LINK_TEXT_COLOR:
  5882.       result_addr = &w_data->page_data.pColorLink;
  5883.       break;
  5884.     case DOCUMENT_NORMAL_TEXT_COLOR:
  5885.       result_addr = &w_data->page_data.pColorText;
  5886.       break;
  5887.     case DOCUMENT_FOLLOWED_TEXT_COLOR:
  5888.       result_addr = &w_data->page_data.pColorFollowedLink;
  5889.       break;
  5890.     default:
  5891.       result_addr = &w_data->page_data.pColorActiveLink;
  5892.       break;
  5893.     }
  5894.  
  5895.     return result_addr;
  5896. }
  5897. #endif
  5898.  
  5899. #if 0
  5900.  
  5901. static void
  5902. fe_PreviewPanelSetColors(Widget widget,
  5903.                          MWContext* context,
  5904.                          unsigned mask,
  5905.                          Pixmap bg_pixmap,
  5906.                          LO_Color* colors)
  5907. {
  5908.     LO_Color* color;
  5909.     Pixel pixel;
  5910.     Pixel bg_pixel;
  5911.     WidgetList children;
  5912.     Cardinal num_children;
  5913.     Arg args[2];
  5914.     Cardinal n;
  5915.     int color_n;
  5916.     Boolean set_bg = FALSE;
  5917.     Boolean set_fg;
  5918.  
  5919.     XtVaGetValues(widget,
  5920.                   XmNchildren, &children,
  5921.                   XmNnumChildren, &num_children,
  5922.                   0);
  5923.  
  5924.     if ((mask & DOCUMENT_USE_CUSTOM_MASK) != 0)
  5925.         mask = ~0; /* do everything */
  5926.  
  5927.     if ((mask & DOCUMENT_BACKGROUND_COLOR_MASK) != 0) {
  5928.         color = &colors[DOCUMENT_BACKGROUND_COLOR];
  5929.  
  5930.         bg_pixel = fe_GetPixel(context,
  5931.                             color->red,
  5932.                             color->green,
  5933.                             color->blue);
  5934.  
  5935.         XtVaSetValues(widget, XmNbackground, bg_pixel, 0);
  5936.         set_bg = TRUE;
  5937.     }
  5938.  
  5939.     for (color_n = 0; color_n < 4; color_n++) {
  5940.           n = 0;
  5941.         set_fg = FALSE;
  5942.         if ((mask & (1<<color_n)) != 0) {
  5943.             color = &colors[color_n];
  5944.             pixel = fe_GetPixel(context,color->red,color->green,color->blue);
  5945.             XtSetArg(args[n], XmNforeground, pixel); n++;
  5946.             set_fg = TRUE;
  5947.         }
  5948.         if (set_bg || set_fg) {
  5949.             if (set_bg)
  5950.                 XtSetArg(args[n], XmNbackground, bg_pixel); n++;
  5951.             XtSetValues(children[color_n], args, n);
  5952.         }
  5953.     }
  5954. }
  5955.  
  5956. static char* fe_PreviewPanelCreate_names[] =
  5957. { "normal", "link", "active", "followed", 0 };
  5958.  
  5959. static Widget
  5960. fe_PreviewPanelCreate(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  5961. {
  5962.     Widget rc;
  5963.     Widget children[4];
  5964.     Cardinal nchildren;
  5965.     Arg args[8];
  5966.     Cardinal n;
  5967.     
  5968.     XtSetArg(p_args[p_n], XmNorientation, XmVERTICAL); n++;
  5969.     rc = XmCreateRowColumn(parent, name, p_args, p_n);
  5970.  
  5971.     for (nchildren = 0; nchildren < 4; nchildren++) {
  5972.       name = fe_PreviewPanelCreate_names[nchildren];
  5973.       n = 0;
  5974.       children[nchildren] = XmCreateLabel(rc, name, args, n);
  5975.     }
  5976.  
  5977.     XtManageChildren(children, nchildren);
  5978.  
  5979.     return rc;
  5980. }
  5981.  
  5982. #else
  5983.  
  5984. typedef struct fe_PreviewPanelStruct
  5985. {
  5986.     Pixmap     bg_pixmap;
  5987.     Pixel      bg_pixel;
  5988.     Pixel      string_pixels[4];
  5989.     XmString   strings[4];
  5990.     XmFontList fontList;
  5991.     Dimension  margin_height;
  5992.     Dimension  margin_width;
  5993.     Dimension  height;
  5994.     Dimension  width;
  5995.     Dimension  shadow_thickness;
  5996.     Dimension  highlight_thickness;
  5997.     Dimension  spacing;
  5998. } fe_PreviewPanelStruct;
  5999.  
  6000. static void
  6001. fe_preview_draw_string(Display* display, Drawable window,
  6002.                        Pixel bg, Pixel fg,
  6003.                        XmFontList fontList, XmString string,
  6004.                        Position x, Position y,
  6005.                        Dimension width,    Dimension height,
  6006.                        Boolean underline)
  6007. {
  6008.     XGCValues    gc_values;
  6009.     XtGCMask     gc_mask;
  6010.     GC           gc;
  6011.     XRectangle   clip_rect;
  6012.     XFontStruct* font = NULL;
  6013.  
  6014.     memset (&gc_values, ~0, sizeof (gc_values));
  6015.     gc_values.foreground = fg;
  6016.     gc_values.background = bg;
  6017.  
  6018.     _XmFontListGetDefaultFont(fontList, &font); /* must include XmP.h */
  6019.  
  6020.     gc_mask = GCForeground|GCBackground;
  6021.  
  6022.     if (font != NULL) {
  6023.         gc_values.font = font->fid;
  6024.         gc_mask |= GCFont;
  6025.     }
  6026.  
  6027.     gc = fe_GetGCfromDW(display, window, gc_mask, &gc_values, NULL);
  6028.  
  6029.     clip_rect.x = x;
  6030.     clip_rect.y = y;
  6031.     clip_rect.width = width;
  6032.     clip_rect.height = height;
  6033.  
  6034.     if (underline) {
  6035.       XmStringDrawUnderline(display, window, fontList,
  6036.                             string,
  6037.                             gc,
  6038.                             x, y, width,
  6039.                             XmALIGNMENT_BEGINNING, 0, /* layout direction */
  6040.                             &clip_rect, /*clip_rectangle*/
  6041.                             string);
  6042.     } else {
  6043.       XmStringDraw(display, window, fontList,
  6044.                    string,
  6045.                    gc,
  6046.                    x, y, width,
  6047.                    XmALIGNMENT_BEGINNING, 0, /* layout direction */
  6048.                    &clip_rect /*clip_rectangle*/);
  6049.     }
  6050. }
  6051.                        
  6052. static void
  6053. fe_preview_panel_paint(Display* display, Drawable window, 
  6054.                        fe_PreviewPanelStruct* stuff)
  6055. {
  6056.     Position  x;
  6057.     Position  y;
  6058.     Dimension height;
  6059.     Dimension width;
  6060.     Dimension height_delta;
  6061.     Dimension margin_height;
  6062.     XmString  string;
  6063.     Pixel     fg_pixel;
  6064.     int i;
  6065.  
  6066.     /* use background color instead */
  6067.     XClearArea(display, window, 0, 0, 0, 0, FALSE); /* no expose */
  6068.  
  6069.     for (height = stuff->height; (height % 4) != 0; height++)
  6070.         ;
  6071.     height_delta = height/4;
  6072.  
  6073.     margin_height = stuff->highlight_thickness +
  6074.                     stuff->shadow_thickness +
  6075.                     stuff->margin_height;
  6076.     x = stuff->highlight_thickness +
  6077.         stuff->shadow_thickness +
  6078.         stuff->margin_width;
  6079.     y = margin_height;
  6080.  
  6081.     for (i = DOCUMENT_NORMAL_TEXT_COLOR;
  6082.          i <= DOCUMENT_FOLLOWED_TEXT_COLOR;
  6083.          i++) {
  6084.  
  6085.         fg_pixel = stuff->string_pixels[i];
  6086.         string = stuff->strings[i];
  6087.  
  6088.         XmStringExtent(stuff->fontList, string, &width, &height);
  6089.  
  6090.         fe_preview_draw_string(display, window,
  6091.                                stuff->bg_pixel, fg_pixel,
  6092.                                stuff->fontList, string,
  6093.                                x, y, width, height,
  6094.                                (i != DOCUMENT_NORMAL_TEXT_COLOR));
  6095.         y += height + (2*margin_height) + stuff->spacing; /* note: spacing */
  6096.     }
  6097. }
  6098.  
  6099. static void
  6100. fe_preview_panel_expose_cb(Widget widget, XtPointer closure, XtPointer cb)
  6101. {
  6102.     XmDrawingAreaCallbackStruct* cb_data = (XmDrawingAreaCallbackStruct*)cb;
  6103.     fe_PreviewPanelStruct* stuff = 
  6104.       (fe_PreviewPanelStruct*)fe_GetUserData(widget);
  6105.  
  6106.     fe_preview_panel_paint(XtDisplay(widget), cb_data->window, stuff);
  6107. }
  6108.  
  6109. static void
  6110. fe_PreviewPanelSetColors(Widget widget,
  6111.                          MWContext* context,
  6112.                          unsigned mask,
  6113.                          Pixmap bg_pixmap,
  6114.                          LO_Color* colors)
  6115. {
  6116.     fe_PreviewPanelStruct* stuff = 
  6117.       (fe_PreviewPanelStruct*)fe_GetUserData(widget);
  6118.     LO_Color* color;
  6119.     Pixel pixel;
  6120.     int color_n;
  6121.     Boolean set_bg = FALSE;
  6122.     Boolean set_fg;
  6123.  
  6124.     set_fg = FALSE;
  6125.  
  6126.     if ((mask & DOCUMENT_BACKGROUND_COLOR_MASK) != 0) {
  6127.         color = &colors[DOCUMENT_BACKGROUND_COLOR];
  6128.  
  6129.         pixel = fe_GetPixel(context,
  6130.                             color->red,
  6131.                             color->green,
  6132.                             color->blue);
  6133.         if (pixel != stuff->bg_pixel) {
  6134.             stuff->bg_pixel = pixel;
  6135.             /* this will generate an expose event -> cb */
  6136.             XtVaSetValues(widget, XmNbackground, stuff->bg_pixel, 0);
  6137.             set_bg = TRUE;
  6138.         }
  6139.     }
  6140.  
  6141.     for (color_n = 0; color_n < 4; color_n++) {
  6142.         if ((mask & (1<<color_n)) != 0) {
  6143.             color = &colors[color_n];
  6144.             pixel = fe_GetPixel(context,color->red,color->green,color->blue);
  6145.             stuff->string_pixels[color_n] = pixel;
  6146.             set_fg = TRUE;
  6147.         }
  6148.     }
  6149.  
  6150.     if (set_fg && !set_bg) /* if we set bg, we'll get an expose anyway */
  6151.       fe_preview_panel_paint(XtDisplay(widget), XtWindow(widget), stuff);
  6152. }
  6153.  
  6154. /* static */ char* fe_PreviewPanelCreate_names[] =
  6155. { "normal", "link", "active", "followed", "background", 0 };
  6156.  
  6157. static XtResource fe_PreviewPanelResources [] =
  6158. {
  6159.   {
  6160.     "normalLabelString", XmCXmString, XmRXmString, sizeof(XmString),
  6161.     XtOffset(fe_PreviewPanelStruct*, strings[DOCUMENT_NORMAL_TEXT_COLOR]),
  6162.     XmRImmediate,  (XtPointer)NULL
  6163.   },
  6164.   {
  6165.     "linkLabelString", XmCXmString, XmRXmString, sizeof(XmString),
  6166.     XtOffset(fe_PreviewPanelStruct*, strings[DOCUMENT_LINK_TEXT_COLOR]),
  6167.     XmRImmediate,  (XtPointer)NULL
  6168.   },
  6169.   {
  6170.     "activeLabelString", XmCXmString, XmRXmString, sizeof(XmString),
  6171.     XtOffset(fe_PreviewPanelStruct*, strings[DOCUMENT_ACTIVE_TEXT_COLOR]),
  6172.     XmRImmediate,  (XtPointer)NULL
  6173.   },
  6174.   {
  6175.     "followedLabelString", XmCXmString, XmRXmString, sizeof(XmString),
  6176.     XtOffset(fe_PreviewPanelStruct*, strings[DOCUMENT_FOLLOWED_TEXT_COLOR]),
  6177.     XmRImmediate,  (XtPointer)NULL
  6178.   },
  6179.   {
  6180.     XmNfontList, XmCFontList, XmRFontList, sizeof(XmFontList),
  6181.     XtOffset(fe_PreviewPanelStruct*, fontList),
  6182.     XmRImmediate, (XtPointer)NULL
  6183.   },
  6184.   {
  6185.     XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension, sizeof(Dimension),
  6186.     XtOffset(fe_PreviewPanelStruct*, margin_height),
  6187.     XmRImmediate, (XtPointer)2
  6188.   },
  6189.   {
  6190.     XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension, sizeof(Dimension),
  6191.     XtOffset(fe_PreviewPanelStruct*, margin_width),
  6192.     XmRImmediate, (XtPointer)2
  6193.   },
  6194.   {
  6195.      XmNhighlightThickness, XmCHighlightThickness, XmRHorizontalDimension,
  6196.      sizeof (Dimension),
  6197.      XtOffset(fe_PreviewPanelStruct*, highlight_thickness),
  6198.      XmRImmediate, (XtPointer) 0 /* makes up for frame around us */
  6199.   },
  6200.   {
  6201.      XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,
  6202.      sizeof (Dimension), 
  6203.      XtOffset(fe_PreviewPanelStruct*, shadow_thickness),
  6204.      XmRImmediate, (XtPointer) 0
  6205.   },
  6206.   {
  6207.      XmNspacing, XmCSpacing, XmRVerticalDimension,
  6208.      sizeof (Dimension), 
  6209.      XtOffset(fe_PreviewPanelStruct*, spacing),
  6210.      XmRImmediate, (XtPointer)4
  6211.   }
  6212. };
  6213.  
  6214. /* static */ Widget
  6215. fe_PreviewPanelCreate(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  6216. {
  6217.     Widget drawing_area;
  6218.     XmString xm_string;
  6219.     char* resource_name;
  6220.     Pixel bg;
  6221.     XtResource copy_resources[XtNumber(fe_PreviewPanelResources)];
  6222.     Dimension height;
  6223.     Dimension width;
  6224.     Dimension total_height;
  6225.     Dimension max_width;
  6226.     fe_PreviewPanelStruct* stuff = XtNew(fe_PreviewPanelStruct);
  6227.     int i;
  6228.     
  6229.     XtSetArg(p_args[p_n], XmNuserData, stuff); p_n++;
  6230.     drawing_area = XmCreateDrawingArea(parent, name, p_args, p_n);
  6231.  
  6232.     XtVaGetValues(drawing_area,
  6233.                   XmNbackground, &bg,
  6234.                   XmNheight, &stuff->height,
  6235.                   XmNwidth, &stuff->width,
  6236.                   0);
  6237.  
  6238.     stuff->bg_pixel = bg;
  6239.  
  6240.     /*
  6241.      *    Get resources.
  6242.      */
  6243.     memcpy(copy_resources, fe_PreviewPanelResources,
  6244.            sizeof(fe_PreviewPanelResources));
  6245.     XtGetSubresources(drawing_area, (XtPointer)stuff,
  6246.                       name, "NsPreviewPanel",
  6247.                       copy_resources,
  6248.                       XtNumber(fe_PreviewPanelResources),
  6249.                       NULL, 0);
  6250.  
  6251.     max_width = 0;
  6252.     total_height = 0;
  6253.  
  6254.     for (i = 0; i < 4; i++) {
  6255.  
  6256.       if (stuff->strings[i] == NULL) { /* not set in resources */
  6257.           resource_name = fe_PreviewPanelResources[i].resource_name;
  6258.           xm_string = XmStringCreateLocalized(resource_name);
  6259.           stuff->strings[i] = xm_string;
  6260.       }
  6261.  
  6262.       XmStringExtent(stuff->fontList, stuff->strings[i], &width, &height);
  6263.       if (width > max_width)
  6264.           max_width = width;
  6265.       total_height += height;
  6266.  
  6267.       stuff->string_pixels[i] = bg;
  6268.     }
  6269.  
  6270.     max_width += 2 * (stuff->highlight_thickness +
  6271.                       stuff->shadow_thickness + stuff->margin_width);
  6272.     if (stuff->width < max_width) {
  6273.         stuff->width = max_width;
  6274.         XtVaSetValues(drawing_area, XmNwidth, stuff->width, 0);
  6275.     }
  6276.  
  6277.     total_height += (2 * stuff->highlight_thickness) +
  6278.                     (8 * (stuff->shadow_thickness + stuff->margin_height)) +
  6279.                     (3 * stuff->spacing);
  6280.     if (stuff->height < total_height) {
  6281.         stuff->height = total_height;
  6282.         XtVaSetValues(drawing_area, XmNheight, stuff->height, 0);
  6283.     }
  6284.  
  6285.     XtAddCallback(drawing_area, XmNexposeCallback, fe_preview_panel_expose_cb,
  6286.                   (XtPointer)stuff);
  6287.     XtAddCallback(drawing_area, XmNdestroyCallback, fe_destroy_cleanup_cb,
  6288.                   (XtPointer)stuff);
  6289.  
  6290.     return drawing_area;
  6291. }
  6292. #endif
  6293.  
  6294. /* static */ void
  6295. fe_document_appearance_preview_update_cb(Widget widget, XtPointer closure,
  6296.                                 XtPointer cb_data)
  6297. {
  6298.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6299.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6300.     fe_DependentListCallbackStruct* cb = 
  6301.       (fe_DependentListCallbackStruct*)cb_data;
  6302.     fe_Dependency mask = cb->mask;
  6303.     LO_Color* colors;
  6304.  
  6305.     if (w_data->use_custom)
  6306.         colors = w_data->colors;
  6307.     else
  6308.         colors = w_data->default_colors;
  6309.  
  6310.     if ((mask & DOCUMENT_USE_CUSTOM_MASK) != 0)
  6311.         mask = ~0; /* do all colors */
  6312.  
  6313.     fe_PreviewPanelSetColors(widget,
  6314.                              w_data->context,
  6315.                              mask,
  6316.                              0, /*Pixmap bg_pixmap*/
  6317.                              colors);
  6318. }
  6319.  
  6320. /* static */ void
  6321. fe_document_appearance_swatch_update_cb(Widget widget, XtPointer closure,
  6322.                                 XtPointer cb_data)
  6323. {
  6324.     ED_EColor c_type = (ED_EColor)fe_GetUserData(widget);
  6325.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6326.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6327.     LO_Color* default_color;
  6328.     LO_Color* colors;
  6329.     Boolean sensitive;
  6330.  
  6331.     if (w_data->use_custom)
  6332.         colors = w_data->colors;
  6333.     else
  6334.         colors = w_data->default_colors;
  6335.  
  6336.     default_color = &colors[c_type];
  6337.  
  6338.     sensitive = w_data->use_custom;
  6339.  
  6340.     fe_SwatchSetColor(widget, default_color);
  6341.     fe_SwatchSetSensitive(widget, sensitive);
  6342. }
  6343.  
  6344. static void
  6345. fe_document_appearance_color_picker_do(
  6346.                        MWContext* context,
  6347.                        Widget widget,
  6348.                        fe_EditorDocumentAppearancePropertiesStruct* w_data,
  6349.                        unsigned which)
  6350. {
  6351.     LO_Color default_color;
  6352.     LO_Color* colors;
  6353.     fe_Dependency mask;
  6354.  
  6355.     if (w_data->use_custom)
  6356.         colors = w_data->colors;
  6357.     else
  6358.         colors = w_data->default_colors;
  6359.  
  6360.     default_color = colors[which];
  6361.  
  6362.     mask = (1 << which);
  6363.  
  6364.     if (fe_ColorPicker(w_data->context, &default_color)) {
  6365.         w_data->colors[which] = default_color;
  6366.         w_data->changed |= mask;
  6367.         fe_DependentListCallDependents(widget,
  6368.                                        w_data->dependents,
  6369.                                        mask,
  6370.                                        (XtPointer)w_data);
  6371.     }
  6372. }
  6373.  
  6374. /* static */ void
  6375. fe_document_appearance_color_cb(Widget widget, XtPointer closure,
  6376.                                 XtPointer cb_data)
  6377. {
  6378.     fe_Dependency mask;
  6379.     ED_EColor c_type = (ED_EColor)fe_GetUserData(widget);
  6380.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6381.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6382.     LO_Color default_color;
  6383.     LO_Color* colors;
  6384.  
  6385.     if (w_data->use_custom)
  6386.         colors = w_data->colors;
  6387.     else
  6388.         colors = w_data->default_colors;
  6389.  
  6390.     default_color = colors[c_type];
  6391.  
  6392.     mask = (1 << ((unsigned)c_type));
  6393.  
  6394.     if (fe_ColorPicker(w_data->context, &default_color)) {
  6395.         w_data->colors[c_type] = default_color;
  6396.         w_data->changed |= mask;
  6397.         fe_DependentListCallDependents(widget,
  6398.                                        w_data->dependents,
  6399.                                        mask,
  6400.                                        closure);
  6401.     }
  6402. }
  6403.  
  6404. /* static */void
  6405. fe_preview_panel_click_cb(Widget widget, XtPointer closure, XtPointer cb)
  6406. {
  6407.     XmDrawingAreaCallbackStruct* cb_data = (XmDrawingAreaCallbackStruct*)cb;
  6408.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6409.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6410.     Dimension height;
  6411.     Dimension height_delta;
  6412.     int i;
  6413.  
  6414.     if (!w_data->use_custom) /* hack, hack, hack */
  6415.         return;
  6416.  
  6417.     if (cb_data->event->type == ButtonRelease) {
  6418.  
  6419.         unsigned y = cb_data->event->xbutton.y;
  6420.  
  6421.         XtVaGetValues(widget, XmNheight, &height, 0);
  6422.  
  6423.         for (; (height % 4) != 0; height++)
  6424.             ;
  6425.         height_delta = height/4;
  6426.  
  6427.         for (i = 0 ; i < 3; i++) {
  6428.             if (y < ((i+1)*height_delta))
  6429.                 break;
  6430.         }
  6431.         fe_document_appearance_color_picker_do(w_data->context,
  6432.                                                widget, w_data, i);
  6433.     }
  6434. }
  6435.  
  6436.  
  6437. /* static */ void
  6438. fe_document_appearance_use_custom_update_cb(Widget widget, XtPointer closure,
  6439.                                      XtPointer cb_data)
  6440. {
  6441.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6442.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6443.     Boolean is_custom_button = (fe_GetUserData(widget) != NULL);
  6444.     Boolean set = (is_custom_button == w_data->use_custom);
  6445.  
  6446.     XmToggleButtonGadgetSetState(widget, set, FALSE);
  6447. }
  6448.  
  6449. /* static */ void
  6450. fe_document_appearance_use_custom_cb(Widget widget, XtPointer closure,
  6451.                                      XtPointer cb_data)
  6452. {
  6453.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6454.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6455.     Boolean is_custom_button = (fe_GetUserData(widget) != NULL);
  6456.     Boolean set = XmToggleButtonGadgetGetState(widget);
  6457.  
  6458.     w_data->use_custom = (set == is_custom_button);
  6459.     w_data->changed |= DOCUMENT_USE_CUSTOM_MASK;
  6460.  
  6461.     fe_DependentListCallDependents(widget,
  6462.                                    w_data->dependents,
  6463.                                    DOCUMENT_USE_CUSTOM_MASK,
  6464.                                    closure);
  6465. }
  6466.  
  6467. /* static */ void
  6468. fe_document_appearance_use_image_update_cb(Widget widget, XtPointer closure,
  6469.                                      XtPointer cb_data)
  6470. {
  6471.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6472.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6473.     
  6474.     XmToggleButtonGadgetSetState(widget, w_data->use_image, FALSE);
  6475. }
  6476.  
  6477. /* static */ void
  6478. fe_document_appearance_use_image_cb(Widget widget, XtPointer closure,
  6479.                                      XtPointer cb_data)
  6480. {
  6481.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6482.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6483.     Boolean set = XmToggleButtonGadgetGetState(widget);
  6484.  
  6485.     w_data->use_image = set;
  6486.     w_data->changed |= DOCUMENT_USE_IMAGE_MASK;
  6487.  
  6488.     fe_DependentListCallDependents(widget,
  6489.                                    w_data->dependents,
  6490.                                    DOCUMENT_USE_IMAGE_MASK,
  6491.                                    closure);
  6492. }
  6493.  
  6494. static void
  6495. fe_document_appearance_leave_image_cb(Widget widget, XtPointer closure,
  6496.                                       XtPointer cbs)
  6497. {
  6498.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6499.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6500.     XmToggleButtonCallbackStruct* cb
  6501.         = (XmToggleButtonCallbackStruct*)cbs;
  6502.  
  6503.     w_data->leave_image = cb->set;
  6504.     w_data->changed |= DOCUMENT_USE_IMAGE_MASK;
  6505. }
  6506.  
  6507. static void
  6508. fe_document_appearance_leave_image_update_cb(Widget widget, XtPointer closure,
  6509.                                      XtPointer cb_data)
  6510. {
  6511.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6512.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6513.     
  6514.     XmToggleButtonGadgetSetState(widget, w_data->leave_image, FALSE);
  6515. }
  6516.  
  6517. /* static */ void
  6518. fe_document_appearance_sensitized_update_cb(Widget widget, XtPointer closure,
  6519.                                      XtPointer cb_data)
  6520. {
  6521.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6522.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6523.     Boolean sensitive;
  6524.     
  6525.     sensitive = w_data->use_custom;
  6526.  
  6527.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  6528. }
  6529.  
  6530. /* static */ void
  6531. fe_document_appearance_image_text_cb(Widget widget, XtPointer closure,
  6532.                                      XtPointer cb_data)
  6533. {
  6534.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6535.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6536.  
  6537.     w_data->changed |= DOCUMENT_BACKGROUND_IMAGE_MASK;
  6538. }
  6539.  
  6540. /* static */ void
  6541. fe_document_appearance_image_text_update_cb(Widget widget, XtPointer closure,
  6542.                                      XtPointer cb_data)
  6543. {
  6544.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6545.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6546.     fe_DependentListCallbackStruct* info = 
  6547.         (fe_DependentListCallbackStruct*)cb_data;
  6548.     Boolean sensitive = w_data->use_image;
  6549.  
  6550.     if (info->caller == widget)
  6551.         return; /* don't call ourselves */
  6552.     
  6553.     if ((info->mask & DOCUMENT_BACKGROUND_IMAGE_MASK) != 0)
  6554.       fe_set_text_field(widget, w_data->image_path,
  6555.                         fe_document_appearance_image_text_cb, (XtPointer)w_data);
  6556.  
  6557.     fe_TextFieldSetEditable(w_data->context, widget, sensitive);
  6558. }
  6559.  
  6560. /* static */ void
  6561. fe_document_appearance_image_text_browse_cb(Widget widget, XtPointer closure,
  6562.                                      XtPointer cb_data)
  6563. {
  6564.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6565.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6566.     Widget image_text = (Widget)fe_GetUserData(widget);
  6567.  
  6568.     fe_editor_browse_file_of_text(w_data->context, image_text);
  6569. }
  6570.  
  6571. /* static */ void
  6572. fe_document_appearance_use_image_button_update_cb(Widget widget,
  6573.                                                    XtPointer closure,
  6574.                                                    XtPointer cb_data)
  6575. {
  6576.     fe_EditorDocumentAppearancePropertiesStruct* w_data
  6577.       = (fe_EditorDocumentAppearancePropertiesStruct*)closure;
  6578.     Boolean sensitive = w_data->use_image;
  6579.  
  6580.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  6581. }
  6582.  
  6583. /* static */ void
  6584. fe_document_appearance_set(
  6585.                           MWContext* context,
  6586.                           fe_EditorDocumentAppearancePropertiesStruct* w_data)
  6587. {
  6588.     LO_Color* bg_color;
  6589.     LO_Color* normal_color;
  6590.     LO_Color* link_color;
  6591.     LO_Color* active_color;
  6592.     LO_Color* followed_color;
  6593.     char*     bg_image;
  6594.     char*     p;
  6595.     char      buf[MAXPATHLEN];
  6596.     char      docname[MAXPATHLEN];
  6597.     XP_Bool   leave_image = FALSE;
  6598.  
  6599.     if (w_data->use_custom) {
  6600.         bg_color = &w_data->colors[DOCUMENT_BACKGROUND_COLOR];
  6601.         normal_color = &w_data->colors[DOCUMENT_NORMAL_TEXT_COLOR];
  6602.         link_color = &w_data->colors[DOCUMENT_LINK_TEXT_COLOR];
  6603.         active_color = &w_data->colors[DOCUMENT_ACTIVE_TEXT_COLOR];
  6604.         followed_color = &w_data->colors[DOCUMENT_FOLLOWED_TEXT_COLOR];
  6605.     } else {
  6606.         bg_color = NULL;
  6607.         normal_color = link_color = active_color = followed_color = NULL;
  6608.     }
  6609.  
  6610.     if (w_data->use_image) {
  6611.         bg_image = fe_TextFieldGetString(w_data->image_text);
  6612.  
  6613.         /*
  6614.          *    Make sure bg image is fully qualified URL.
  6615.          */
  6616.         if (bg_image != NULL) {
  6617.             fe_StringTrim(bg_image);
  6618.  
  6619.             if ((p = strchr(bg_image, ':')) == NULL) {
  6620.                 if (bg_image[0] != '/' && !w_data->is_editor_preferences) {
  6621.                     strcpy(buf, "file:");
  6622.                     fe_EditorMakeName(context, docname, sizeof(buf) - 5);
  6623.                     fe_dirname(&buf[5], docname);
  6624.                     strcat(buf, "/");
  6625.                     strcat(buf, bg_image);
  6626.                 } else {
  6627.                     sprintf(buf, "file:%s", bg_image);
  6628.                 }
  6629.                 XtFree(bg_image);
  6630.                 bg_image = XtNewString(buf);
  6631.             }
  6632.         }
  6633.  
  6634.         leave_image = w_data->leave_image;
  6635.  
  6636.     } else {
  6637.         bg_image = NULL;
  6638.     }
  6639.  
  6640.     if (w_data->is_editor_preferences)
  6641.         fe_EditorPreferencesSetColors(context,
  6642.                                       bg_image,
  6643.                                       bg_color,
  6644.                                       normal_color,
  6645.                                       link_color,
  6646.                                       active_color,
  6647.                                       followed_color);
  6648.     else
  6649.         fe_EditorDocumentSetColors(context,
  6650.                                    bg_image,
  6651.                                    leave_image,
  6652.                                    bg_color,
  6653.                                    normal_color,
  6654.                                    link_color,
  6655.                                    active_color,
  6656.                                    followed_color);
  6657.  
  6658.     if (bg_image)
  6659.         XtFree(bg_image);
  6660. }
  6661.  
  6662. /* static */ void
  6663. fe_document_appearance_init(
  6664.                           MWContext* context,
  6665.                           fe_EditorDocumentAppearancePropertiesStruct* w_data)
  6666. {
  6667.     Boolean use_custom;
  6668.     Boolean leave_image = FALSE;
  6669.     char    bg_image[MAXPATHLEN];
  6670.  
  6671.     w_data->context = context;
  6672.  
  6673.     fe_EditorDefaultGetColors(
  6674.                       &w_data->default_colors[DOCUMENT_BACKGROUND_COLOR],
  6675.                       &w_data->default_colors[DOCUMENT_NORMAL_TEXT_COLOR],
  6676.                       &w_data->default_colors[DOCUMENT_LINK_TEXT_COLOR],
  6677.                       &w_data->default_colors[DOCUMENT_ACTIVE_TEXT_COLOR],
  6678.                       &w_data->default_colors[DOCUMENT_FOLLOWED_TEXT_COLOR]);
  6679.  
  6680.     if (w_data->is_editor_preferences)
  6681.           use_custom = fe_EditorPreferencesGetColors(context,
  6682.                         bg_image,
  6683.                         &w_data->colors[DOCUMENT_BACKGROUND_COLOR],
  6684.                         &w_data->colors[DOCUMENT_NORMAL_TEXT_COLOR],
  6685.                         &w_data->colors[DOCUMENT_LINK_TEXT_COLOR],
  6686.                         &w_data->colors[DOCUMENT_ACTIVE_TEXT_COLOR],
  6687.                         &w_data->colors[DOCUMENT_FOLLOWED_TEXT_COLOR]);
  6688.     else
  6689.         use_custom = fe_EditorDocumentGetColors(context,
  6690.                         bg_image,
  6691.                         &leave_image,
  6692.                         &w_data->colors[DOCUMENT_BACKGROUND_COLOR],
  6693.                         &w_data->colors[DOCUMENT_NORMAL_TEXT_COLOR],
  6694.                         &w_data->colors[DOCUMENT_LINK_TEXT_COLOR],
  6695.                         &w_data->colors[DOCUMENT_ACTIVE_TEXT_COLOR],
  6696.                         &w_data->colors[DOCUMENT_FOLLOWED_TEXT_COLOR]);
  6697.  
  6698.     w_data->use_custom = use_custom;
  6699.  
  6700.     if (bg_image[0] != '\0') {
  6701.       w_data->use_image = TRUE;
  6702.       w_data->leave_image = leave_image;
  6703.       w_data->image_path = bg_image;
  6704.     } else {
  6705.       w_data->use_image = FALSE;
  6706.       w_data->leave_image = FALSE;
  6707.       w_data->image_path = NULL;
  6708.     }
  6709.  
  6710.     fe_DependentListCallDependents(NULL,
  6711.                                    w_data->dependents,
  6712.                                    ~0,
  6713.                                    (XtPointer)w_data);
  6714.     w_data->image_path = NULL; /* held in TextField */
  6715. }
  6716.  
  6717. static Dimension
  6718. fe_get_offset_from_widest(Widget* children, Cardinal nchildren)
  6719. {
  6720.     Dimension width;
  6721.     Dimension margin_width;
  6722.  
  6723.     Widget fat_guy = XfeBiggestWidget(TRUE, children, nchildren);
  6724.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  6725.     XtVaGetValues(XtParent(fat_guy), XmNmarginWidth, &margin_width, 0);
  6726.  
  6727.     return width + margin_width;
  6728. }
  6729.  
  6730. static Widget
  6731. fe_document_appearance_create(
  6732.                           MWContext* context,
  6733.                           Widget parent,
  6734.                           fe_EditorDocumentAppearancePropertiesStruct* w_data)
  6735. {
  6736.     Arg args[16];
  6737.     Cardinal n;
  6738.     Widget main_rc;
  6739.  
  6740.     Widget colors_frame;
  6741.     Widget colors_rc;
  6742.  
  6743.     Widget strategy_rc;
  6744.     Widget strategy_custom;
  6745.     Widget strategy_browser;
  6746.  
  6747. #ifdef DOCUMENT_COLOR_SCHEMES
  6748.     Widget schemes_frame;
  6749.     Widget schemes_form;
  6750.     Widget schemes_combo;
  6751.     Widget schemes_save;
  6752.     Widget schemes_remove;
  6753. #endif
  6754.  
  6755.     Widget custom_form;
  6756.     Widget custom_frame;
  6757.     Widget custom_preview_rc;
  6758.     Widget background_info;
  6759.     Widget fat_guy;
  6760.     Widget top_guy;
  6761.     Widget bottom_guy;
  6762.     Widget children[6];
  6763.     Widget swatches[6];
  6764.     Cardinal nchildren;
  6765.     Cardinal nswatch;
  6766.     Dimension width;
  6767.     int i;
  6768.  
  6769.     Widget background_frame;
  6770.     Widget background_form;
  6771.     Widget background_image_toggle;
  6772.     Widget background_image_text;
  6773.     Widget background_image_leave;
  6774.     Widget background_image_button;
  6775.  
  6776.     Widget info_label;
  6777.  
  6778.     n = 0;
  6779.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
  6780.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  6781.     main_rc = XmCreateRowColumn(parent, "appearance", args, n);
  6782.     XtManageChild(main_rc);
  6783.  
  6784.     /*
  6785.      *    Custom colors.
  6786.      */
  6787.     n = 0;
  6788.     colors_frame = fe_CreateFrame(main_rc, "documentColors", args, n);
  6789.     XtManageChild(colors_frame);
  6790.  
  6791.     n = 0;
  6792.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
  6793.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  6794.     colors_rc = XmCreateRowColumn(colors_frame, "colors", args, n);
  6795.     XtManageChild(colors_rc);
  6796.  
  6797.     /*
  6798.      *    Top row.
  6799.      */
  6800.     n = 0;
  6801.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  6802.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  6803.     XtSetArg(args[n], XmNentryVerticalAlignment, XmALIGNMENT_BASELINE_TOP); n++;
  6804.     strategy_rc = XmCreateRowColumn(colors_rc, "strategy", args, n);
  6805.     XtManageChild(strategy_rc);
  6806.  
  6807.     n = 0;
  6808.     XtSetArg(args[n], XmNuserData, TRUE); n++;
  6809.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  6810.     strategy_custom = XmCreateToggleButtonGadget(strategy_rc,
  6811.                                                  "custom", args, n);
  6812.     XtManageChild(strategy_custom);
  6813.  
  6814.     XtAddCallback(strategy_custom, XmNvalueChangedCallback,
  6815.                   fe_document_appearance_use_custom_cb, (XtPointer)w_data);
  6816.  
  6817.     fe_DependentListAddDependent(&w_data->dependents,
  6818.                                  strategy_custom,
  6819.                                  DOCUMENT_USE_CUSTOM_MASK,
  6820.                                  fe_document_appearance_use_custom_update_cb,
  6821.                                  (XtPointer)w_data);
  6822.  
  6823.     n = 0;
  6824.     XtSetArg(args[n], XmNuserData, FALSE); n++;
  6825.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  6826.     strategy_browser = XmCreateToggleButtonGadget(strategy_rc,
  6827.                                                  "browser", args, n);
  6828.     XtManageChild(strategy_browser);
  6829.     
  6830.     XtAddCallback(strategy_browser, XmNvalueChangedCallback,
  6831.                   fe_document_appearance_use_custom_cb, (XtPointer)w_data);
  6832.  
  6833.     fe_DependentListAddDependent(&w_data->dependents,
  6834.                                  strategy_browser,
  6835.                                  DOCUMENT_USE_CUSTOM_MASK,
  6836.                                  fe_document_appearance_use_custom_update_cb,
  6837.                                  (XtPointer)w_data);
  6838.  
  6839. #ifdef DOCUMENT_COLOR_SCHEMES
  6840.     /*
  6841.      *    Color Schemes.
  6842.      */
  6843.     n = 0;
  6844.     schemes_frame = fe_CreateFrame(colors_rc, "schemes", args, n);
  6845.     XtManageChild(schemes_frame);
  6846.  
  6847.     n = 0;
  6848.     schemes_form = XmCreateForm(schemes_frame, "schemes", args, n);
  6849.     XtManageChild(schemes_form);
  6850.  
  6851.     n = 0;
  6852.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  6853.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  6854.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  6855.     schemes_remove = XmCreatePushButtonGadget(schemes_form, "remove", args, n);
  6856.     XtManageChild(schemes_remove);
  6857.  
  6858.     n = 0;
  6859.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  6860.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  6861.     XtSetArg(args[n], XmNrightWidget, schemes_remove); n++;
  6862.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  6863.     schemes_save = XmCreatePushButtonGadget(schemes_form, "save", args, n);
  6864.     XtManageChild(schemes_save);
  6865.  
  6866.     n = 0;
  6867.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  6868.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  6869.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  6870.     XtSetArg(args[n], XmNrightWidget, schemes_save); n++;
  6871.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  6872.     schemes_combo = fe_CreateCombo(schemes_form, "combo", args, n);
  6873.     XtManageChild(schemes_combo);
  6874. #else
  6875. #if 0
  6876.     /*
  6877.      *    make something to break up the top row from the colro buttons.
  6878.      */
  6879.     n = 0;
  6880.     custom_form = XmCreateSeparatorGadget(colors_rc, "separator", args, n);
  6881.     XtManageChild(custom_form);
  6882. #endif
  6883. #endif
  6884.  
  6885.     n = 0;
  6886.     custom_form = XmCreateForm(colors_rc, "custom", args, n);
  6887.     XtManageChild(custom_form);
  6888.  
  6889.     for (nchildren = DOCUMENT_NORMAL_TEXT_COLOR;
  6890.          nchildren <= DOCUMENT_BACKGROUND_COLOR;
  6891.          nchildren++) {
  6892.         Widget button;
  6893.         char*  name = fe_PreviewPanelCreate_names[nchildren];
  6894.         unsigned flags;
  6895.  
  6896.         n = 0;
  6897.         XtSetArg(args[n], XmNuserData, nchildren); n++;
  6898.         button = XmCreatePushButtonGadget(custom_form, name, args, n);
  6899.         XtAddCallback(button, XmNactivateCallback,
  6900.                       fe_document_appearance_color_cb, (XtPointer)w_data);
  6901.         flags = DOCUMENT_USE_CUSTOM_MASK;
  6902.         if (nchildren == DOCUMENT_BACKGROUND_COLOR)
  6903.             flags |= DOCUMENT_USE_IMAGE_MASK;
  6904.         fe_DependentListAddDependent(&w_data->dependents,
  6905.                                  button,
  6906.                                  flags,
  6907.                                  fe_document_appearance_sensitized_update_cb,
  6908.                                  (XtPointer)w_data);
  6909.         children[nchildren] = button;
  6910.     }
  6911.     XtManageChildren(children, nchildren);
  6912.  
  6913.     fat_guy = XfeBiggestWidget(TRUE, children, nchildren);
  6914.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  6915.  
  6916.     /* swatches */
  6917.     for (nswatch = DOCUMENT_NORMAL_TEXT_COLOR;
  6918.          nswatch <= DOCUMENT_BACKGROUND_COLOR;
  6919.          nswatch++) {
  6920.         Widget foo;
  6921.         char   name[32];
  6922.         unsigned flags;
  6923.  
  6924.         sprintf(name, "%sSwatch", fe_PreviewPanelCreate_names[nswatch]);
  6925.         n = 0;
  6926.         XtSetArg(args[n], XmNuserData, nswatch); n++;
  6927.         XtSetArg(args[n], XmNwidth, SWATCH_SIZE); n++;
  6928.         foo = fe_CreateSwatch(custom_form, name, args, n);
  6929.         XtAddCallback(foo, XmNactivateCallback,
  6930.                       fe_document_appearance_color_cb, (XtPointer)w_data);
  6931.  
  6932.         flags = DOCUMENT_USE_CUSTOM_MASK|(1<<nswatch);
  6933.         if (nswatch == DOCUMENT_BACKGROUND_COLOR)
  6934.             flags |= DOCUMENT_USE_IMAGE_MASK;
  6935.         fe_DependentListAddDependent(&w_data->dependents,
  6936.                                      foo,
  6937.                                      flags,
  6938.                                      fe_document_appearance_swatch_update_cb,
  6939.                                      (XtPointer)w_data);
  6940.         swatches[nswatch] = foo;
  6941.     }
  6942.     XtManageChildren(swatches, nswatch);
  6943.  
  6944.     /*
  6945.      *    Do attachments.
  6946.      */
  6947.     for (top_guy = NULL, i = 0; i < nchildren; i++) {
  6948.  
  6949.         n = 0;
  6950.         if (top_guy) {
  6951.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  6952.             XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  6953.         } else {
  6954.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  6955.         }
  6956.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  6957.  
  6958.         top_guy = children[i];
  6959.  
  6960.         if (top_guy != fat_guy) {
  6961.             /*
  6962.              *    Have to do this to avoid circular dependency in
  6963.              *    losing XmForm.
  6964.              */
  6965.             XtSetArg(args[n], XmNwidth, width); n++;
  6966. #if 0
  6967.             XtSetArg(args[n], XmNrightAttachment,
  6968.                    XmATTACH_OPPOSITE_WIDGET); n++;
  6969.             XtSetArg(args[n],XmNrightWidget, fat_guy); n++;
  6970. #endif
  6971.         }
  6972.         XtSetValues(top_guy, args, n);
  6973.  
  6974.         /* Do swatch. */
  6975.         n = 0;
  6976.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  6977.         XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  6978.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  6979.         XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  6980.         XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  6981.         XtSetArg(args[n], XmNbottomWidget, top_guy); n++;
  6982.         XtSetValues(swatches[i], args, n);
  6983.     }
  6984.  
  6985.     top_guy = swatches[DOCUMENT_NORMAL_TEXT_COLOR];
  6986.     bottom_guy = swatches[DOCUMENT_FOLLOWED_TEXT_COLOR];
  6987.  
  6988.     n = 0;
  6989.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  6990.     XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  6991.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  6992.     XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  6993.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  6994.     XtSetArg(args[n], XmNbottomWidget, bottom_guy); n++;
  6995.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  6996. #if 1
  6997.     custom_frame = /*fe_*/XmCreateFrame(custom_form, "previewFrame", args, n);
  6998.     XtManageChild(custom_frame);
  6999.     n = 0; /* I'm tired of changing resources to get this right */
  7000.     XtSetArg(args[n], XmNmarginWidth, 0); n++;
  7001.     XtSetArg(args[n], XmNmarginHeight, 0); n++;
  7002.     XtSetValues(custom_frame, args, n);
  7003. #else
  7004.     n = 0;
  7005.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  7006.     XtSetArg(args[n], XmNborderWidth, 1); n++;
  7007.     XtSetArg(args[n], XmNborderColor,
  7008.              CONTEXT_DATA(w_data->context)->default_fg_pixel); n++;
  7009. #endif
  7010.     custom_preview_rc = fe_PreviewPanelCreate(custom_frame, "preview",
  7011.                                               args, n);
  7012.     XtManageChild(custom_preview_rc);
  7013.  
  7014.     XtAddCallback(custom_preview_rc, XmNinputCallback,
  7015.                   fe_preview_panel_click_cb, (XtPointer)w_data);
  7016.  
  7017.     fe_DependentListAddDependent(&w_data->dependents,
  7018.                          custom_preview_rc,
  7019.                          (DOCUMENT_USE_CUSTOM_MASK|DOCUMENT_ALL_APPEARANCE),
  7020.                          fe_document_appearance_preview_update_cb,
  7021.                          (XtPointer)w_data);
  7022. #if 1
  7023.     fe_DependentListAddDependent(&w_data->dependents,
  7024.                                  custom_preview_rc,
  7025.                                  DOCUMENT_USE_CUSTOM_MASK,
  7026.                                  fe_document_appearance_sensitized_update_cb,
  7027.                                  (XtPointer)w_data);
  7028. #endif
  7029.     top_guy = swatches[DOCUMENT_BACKGROUND_COLOR];
  7030.  
  7031.     n = 0;
  7032.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  7033.     XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  7034.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7035.     XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  7036.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7037.     XtSetArg(args[n], XmNbottomWidget, top_guy); n++;
  7038.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7039.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  7040.     background_info = XmCreateLabelGadget(custom_form, "backgroundInfo", args, n);
  7041.     XtManageChild(background_info);
  7042.  
  7043.     /*
  7044.      *    Background.
  7045.      */
  7046.     n = 0;
  7047.     background_frame = fe_CreateFrame(main_rc, "backgroundImage", args, n);
  7048.     XtManageChild(background_frame);
  7049.  
  7050.     n = 0;
  7051.     background_form = XmCreateForm(background_frame, "backgroundImage", args, n);
  7052.     XtManageChild(background_form);
  7053.  
  7054.     nchildren = 0;
  7055.     n = 0;
  7056.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  7057.     background_image_toggle = XmCreateToggleButtonGadget(background_form,
  7058.                                                         "useImage", args, n);
  7059.     children[nchildren++] = background_image_toggle;
  7060.  
  7061.     XtAddCallback(background_image_toggle, XmNvalueChangedCallback,
  7062.                   fe_document_appearance_use_image_cb, (XtPointer)w_data);
  7063.     fe_DependentListAddDependent(&w_data->dependents,
  7064.                          background_image_toggle,
  7065.                          (DOCUMENT_USE_IMAGE_MASK|DOCUMENT_USE_CUSTOM_MASK),
  7066.                          fe_document_appearance_use_image_update_cb,
  7067.                          (XtPointer)w_data);
  7068.  
  7069.     n = 0;
  7070.     background_image_text = fe_CreateTextField(background_form,
  7071.                                               "imageText", args, n);
  7072.     XtAddCallback(background_image_text, XmNvalueChangedCallback,
  7073.                   fe_document_appearance_image_text_cb,
  7074.                   (XtPointer)w_data);
  7075.     fe_DependentListAddDependent(&w_data->dependents,
  7076.                                  background_image_text,
  7077.                                  (DOCUMENT_BACKGROUND_IMAGE_MASK|
  7078.                                   DOCUMENT_USE_IMAGE_MASK|
  7079.                                   DOCUMENT_USE_CUSTOM_MASK),
  7080.                                  fe_document_appearance_image_text_update_cb,
  7081.                                  (XtPointer)w_data);
  7082.     w_data->image_text = background_image_text;
  7083.     children[nchildren++] = background_image_text;
  7084.  
  7085.     n = 0;
  7086.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  7087.     background_image_leave = XmCreateToggleButtonGadget(background_form,
  7088.                                                         "leaveImage",
  7089.                                                         args, n);
  7090.     children[nchildren++] = background_image_leave;
  7091.     XtAddCallback(background_image_leave, XmNvalueChangedCallback,
  7092.                   fe_document_appearance_leave_image_cb, (XtPointer)w_data);
  7093.     fe_DependentListAddDependent(&w_data->dependents,
  7094.                          background_image_leave,
  7095.                          (DOCUMENT_USE_IMAGE_MASK|DOCUMENT_USE_CUSTOM_MASK),
  7096.                          fe_document_appearance_leave_image_update_cb,
  7097.                          (XtPointer)w_data);
  7098.  
  7099.     n = 0;
  7100.     XtSetArg(args[n], XmNuserData, background_image_text); n++;
  7101.     background_image_button = XmCreatePushButtonGadget(background_form,
  7102.                                                        "browseImageFile",
  7103.                                                        args, n);
  7104.     XtAddCallback(background_image_button, XmNactivateCallback,
  7105.                   fe_document_appearance_image_text_browse_cb,
  7106.                   (XtPointer)w_data);
  7107.     fe_DependentListAddDependent(&w_data->dependents,
  7108.                          background_image_button,
  7109.                          (DOCUMENT_USE_IMAGE_MASK|DOCUMENT_USE_CUSTOM_MASK),
  7110.                          fe_document_appearance_use_image_button_update_cb,
  7111.                          (XtPointer)w_data);
  7112.     children[nchildren++] = background_image_button;
  7113.  
  7114.     /*
  7115.      *    Do background image group attachments.
  7116.      */
  7117.     n = 0;
  7118.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7119.     XtSetValues(background_image_toggle, args, n);
  7120.  
  7121.     n = 0;
  7122.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  7123.     XtSetArg(args[n], XmNleftWidget, background_image_toggle); n++;
  7124.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7125.     XtSetValues(background_image_text, args, n);
  7126.  
  7127.     n = 0;
  7128.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7129.     XtSetArg(args[n], XmNtopWidget, background_image_text); n++;
  7130.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7131.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  7132.     XtSetArg(args[n], XmNrightWidget, background_image_button); n++;
  7133.     XtSetValues(background_image_leave, args, n);
  7134.  
  7135.     n = 0;
  7136.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7137.     XtSetArg(args[n], XmNtopWidget, background_image_text); n++;
  7138.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  7139.     XtSetValues(background_image_button, args, n);
  7140.  
  7141.     XtManageChildren(children, nchildren);
  7142.  
  7143.     /*
  7144.      *    Bottom line info text.
  7145.      */
  7146.     n = 0;
  7147.     info_label = XmCreateLabelGadget(main_rc, "infoLabel", args, n);
  7148.     XtManageChild(info_label);
  7149.  
  7150.     return main_rc;
  7151. }
  7152.  
  7153. #define DOCUMENT_GENERAL_TITLE           (0x1<<0)
  7154. #define DOCUMENT_GENERAL_AUTHOR          (0x1<<1)
  7155. #define DOCUMENT_GENERAL_DESCRIPTION     (0x1<<2)
  7156. #define DOCUMENT_GENERAL_KEYWORDS        (0x1<<3)
  7157. #define DOCUMENT_GENERAL_CLASSIFICATION  (0x1<<4)
  7158.  
  7159. static void
  7160. fe_document_general_changed_cb(Widget widget,
  7161.                                XtPointer closure, XtPointer call_data)
  7162. {
  7163.     fe_EditorDocumentGeneralPropertiesStruct* w_data
  7164.         = (fe_EditorDocumentGeneralPropertiesStruct*)closure;
  7165.     unsigned mask = (unsigned)fe_GetUserData(widget);
  7166.  
  7167.     w_data->changed |= mask;
  7168. }
  7169.  
  7170. /*
  7171.  *    Purpose:    Condense a URL to a given length.
  7172.  *              Lifted the algorithm from winfe/popup.cpp/WFE_CondenseURL()
  7173.  */
  7174. char*
  7175. FE_CondenseURL(char* target, char* source, unsigned target_len)
  7176. {
  7177.     unsigned source_len = strlen(source);
  7178.     unsigned first_half_len;
  7179.     unsigned second_half_len;
  7180.  
  7181.     if (source_len < target_len) {
  7182.         strcpy(target, source);
  7183.     } else {
  7184.         first_half_len = (target_len - 3)/2;
  7185.         second_half_len = target_len - first_half_len - 4; /* -1 for NUL */
  7186.  
  7187.         strncpy(target, source, first_half_len);
  7188.         strcpy(&target[first_half_len], "...");
  7189.         strcat(target, &source[source_len - second_half_len]);
  7190.     }
  7191.     return target;
  7192. }
  7193.  
  7194. static void
  7195. fe_document_general_init(MWContext* context,
  7196.                          fe_EditorDocumentGeneralPropertiesStruct* w_data)
  7197. {
  7198.     XmString xm_string;
  7199.     char buf[40]; /* will specifiy size of maximum location text length */
  7200.     char* value;
  7201.  
  7202.     /* set defaults */ /* <unknown> */
  7203.     xm_string = XmStringCreateLocalized(XP_GetString(XFE_UNKNOWN));
  7204. #ifdef EDITOR_SHOW_CREATE_DATE
  7205.     XtVaSetValues(w_data->created, XmNlabelString, xm_string, 0);
  7206.     XtVaSetValues(w_data->updated, XmNlabelString, xm_string, 0);
  7207. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7208.     XtVaSetValues(w_data->location, XmNlabelString, xm_string, 0);
  7209.     XmStringFree(xm_string);
  7210.  
  7211.     /* get the location */
  7212.     fe_EditorMakeName(context, buf, sizeof(buf));
  7213.     xm_string = XmStringCreateLocalized(buf);
  7214.     XtVaSetValues(w_data->location, XmNlabelString, xm_string, 0);
  7215.     XmStringFree(xm_string);
  7216.  
  7217.     /* get the title */
  7218.     if ((value = fe_EditorDocumentGetTitle(context)) != NULL) {
  7219.         fe_SetTextFieldAndCallBack(w_data->title, value);
  7220.         XP_FREE(value);
  7221.     }
  7222.  
  7223.     /* get the author */
  7224.     if ((value = fe_EditorDocumentGetMetaData(context, "Author")) != NULL)
  7225.         fe_SetTextFieldAndCallBack(w_data->author, value);
  7226.  
  7227.     /* get the description */
  7228.     if ((value = fe_EditorDocumentGetMetaData(context, "Description")))
  7229.         fe_SetTextFieldAndCallBack(w_data->description, value);
  7230.  
  7231.     /* get the keywords */
  7232.     if ((value = fe_EditorDocumentGetMetaData(context, "Keywords")))
  7233.         fe_SetTextFieldAndCallBack(w_data->keywords, value);
  7234.  
  7235.     /* get the classification */
  7236.     if ((value = fe_EditorDocumentGetMetaData(context, "Classification")))
  7237.         fe_SetTextFieldAndCallBack(w_data->classification, value);
  7238.  
  7239. #ifdef EDITOR_SHOW_CREATE_DATE
  7240.     /* get the created */
  7241.     if ((value = fe_EditorDocumentGetMetaData(context, "Created"))) {
  7242.         xm_string = XmStringCreateLocalized(value);
  7243.         XtVaSetValues(w_data->created, XmNlabelString, xm_string, 0);
  7244.         XmStringFree(xm_string);
  7245.     }
  7246.  
  7247.     /* get the updated */
  7248.     if ((value = fe_EditorDocumentGetMetaData(context, "Last-Modified"))) {
  7249.         xm_string = XmStringCreateLocalized(value);
  7250.         XtVaSetValues(w_data->updated, XmNlabelString, xm_string, 0);
  7251.         XmStringFree(xm_string);
  7252.     }
  7253. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7254.  
  7255.     w_data->changed = 0;
  7256. }
  7257.  
  7258. static void
  7259. fe_document_general_set(MWContext* context,
  7260.                         fe_EditorDocumentGeneralPropertiesStruct* w_data)
  7261. {
  7262.     char* value;
  7263.  
  7264.     /* set the title */
  7265.     if ((w_data->changed & DOCUMENT_GENERAL_TITLE) != 0) {
  7266.         value = fe_TextFieldGetString(w_data->title);
  7267.         fe_EditorDocumentSetTitle(context, value);
  7268.         XtFree(value);
  7269.     }
  7270.  
  7271.     /* author */
  7272.     if ((w_data->changed & DOCUMENT_GENERAL_AUTHOR) != 0) {
  7273.         value = fe_TextFieldGetString(w_data->author);
  7274.         fe_EditorDocumentSetMetaData(context, "Author", value);
  7275.         XtFree(value);
  7276.     }
  7277.     
  7278.     /* description */
  7279.     if ((w_data->changed & DOCUMENT_GENERAL_DESCRIPTION) != 0) {
  7280.         value = fe_TextFieldGetString(w_data->description);
  7281.         fe_EditorDocumentSetMetaData(context, "Description", value);
  7282.         XtFree(value);
  7283.     }
  7284.     
  7285.     /* keywords */
  7286.     if ((w_data->changed & DOCUMENT_GENERAL_KEYWORDS) != 0) {
  7287.         value = fe_TextFieldGetString(w_data->keywords);
  7288.         fe_EditorDocumentSetMetaData(context, "Keywords", value);
  7289.         XtFree(value);
  7290.     }
  7291.     
  7292.     /* classification */
  7293.     if ((w_data->changed & DOCUMENT_GENERAL_CLASSIFICATION) != 0) {
  7294.         value = fe_TextFieldGetString(w_data->classification);
  7295.         fe_EditorDocumentSetMetaData(context, "Classification", value);
  7296.         XtFree(value);
  7297.     }
  7298.     
  7299.     w_data->changed = 0;
  7300. }
  7301.  
  7302. static Widget
  7303. fe_document_general_create(
  7304.                           MWContext* context,
  7305.                           Widget parent,
  7306.                           fe_EditorDocumentGeneralPropertiesStruct* w_data)
  7307. {
  7308.     Widget form;
  7309.     Widget location_label;
  7310.     Widget location_text;
  7311.     Widget title_label;
  7312.     Widget title_text;
  7313.     Widget author_label;
  7314.     Widget author_text;
  7315.     Widget description_label;
  7316.     Widget description_text;
  7317. #ifdef EDITOR_SHOW_CREATE_DATE
  7318.     Widget created_label;
  7319.     Widget created_text;
  7320.     Widget updated_label;
  7321.     Widget updated_text;
  7322.     Widget fat_guy;
  7323. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7324.     Widget other_frame;
  7325.     Widget other_form;
  7326.     Widget info_label;
  7327.     Widget keywords_label;
  7328.     Widget keywords_text;
  7329.     Widget classification_label;
  7330.     Widget classification_text;
  7331.     Widget children[16];
  7332.     Cardinal nchildren;
  7333.     Dimension left_offset;
  7334.     Arg    args[8];
  7335.     Cardinal n;
  7336.     Cardinal i;
  7337.  
  7338.     n = 0;
  7339.     form = XmCreateForm(parent, "general", args, n);
  7340.  
  7341.     nchildren = 0;
  7342.     n = 0;
  7343.     location_label = XmCreateLabelGadget(form, "locationLabel", args, n);
  7344.     children[nchildren++] = location_label;
  7345.     
  7346.     n = 0;
  7347.     title_label = XmCreateLabelGadget(form, "titleLabel", args, n);
  7348.     children[nchildren++] = title_label;
  7349.     
  7350.     n = 0;
  7351.     author_label = XmCreateLabelGadget(form, "authorLabel", args, n);
  7352.     children[nchildren++] = author_label;
  7353.     
  7354.     n = 0;
  7355.     description_label = XmCreateLabelGadget(form, "descriptionLabel", args, n);
  7356.     children[nchildren++] = description_label;
  7357.  
  7358.     left_offset = fe_get_offset_from_widest(children, nchildren);
  7359.  
  7360.     n = 0;
  7361.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  7362.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7363.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  7364.     location_text = XmCreateLabelGadget(form, "locationText", args, n);
  7365.     children[nchildren++] = location_text;
  7366.     
  7367.     n = 0;
  7368.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7369.     XtSetArg(args[n], XmNtopWidget, children[nchildren-1]); n++;
  7370.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7371.     XtSetArg(args[n], XmNleftWidget, location_text); n++;
  7372.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7373.     XtSetArg(args[n], XmNuserData, DOCUMENT_GENERAL_TITLE); n++;
  7374.     title_text = fe_CreateTextField(form, "titleText", args, n);
  7375.     children[nchildren++] = title_text;
  7376.  
  7377.     XtAddCallback(title_text, XmNvalueChangedCallback,
  7378.                   fe_document_general_changed_cb, (XtPointer)w_data);
  7379.     
  7380.     n = 0;
  7381.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7382.     XtSetArg(args[n], XmNtopWidget, children[nchildren-1]); n++;
  7383.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7384.     XtSetArg(args[n], XmNleftWidget, location_text); n++;
  7385.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7386.     XtSetArg(args[n], XmNuserData, DOCUMENT_GENERAL_AUTHOR); n++;
  7387.     author_text = fe_CreateTextField(form, "authorText", args, n);
  7388.     children[nchildren++] = author_text;
  7389.     
  7390.     XtAddCallback(author_text, XmNvalueChangedCallback,
  7391.                   fe_document_general_changed_cb, (XtPointer)w_data);
  7392.     
  7393.     n = 0;
  7394.     XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  7395.     XtSetArg(args[n], XmNrows, 2); n++;
  7396.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7397.     XtSetArg(args[n], XmNtopWidget, children[nchildren-1]); n++;
  7398.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7399.     XtSetArg(args[n], XmNleftWidget, location_text); n++;
  7400.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7401.     XtSetArg(args[n], XmNuserData, DOCUMENT_GENERAL_DESCRIPTION); n++;
  7402.     description_text = fe_CreateText(form, "descriptionText", args, n);
  7403.     children[nchildren++] = description_text;
  7404.  
  7405.     XtAddCallback(description_text, XmNvalueChangedCallback,
  7406.                   fe_document_general_changed_cb, (XtPointer)w_data);
  7407.     
  7408.     /* go back and do label attachments */
  7409.     for (i = 0; i < 4; i++) {
  7410.         n = 0;
  7411.         if (i == 0) {
  7412.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  7413.         } else {
  7414.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7415.             XtSetArg(args[n], XmNtopWidget, children[i+3]); n++;
  7416.         }
  7417.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7418.         XtSetValues(children[i], args, n);
  7419.     }
  7420.  
  7421.     XtManageChildren(children, nchildren);
  7422.  
  7423.     nchildren = 0;
  7424. #ifdef EDITOR_SHOW_CREATE_DATE
  7425.     n = 0;
  7426.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7427.     XtSetArg(args[n], XmNtopWidget, description_text); n++;
  7428.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7429.     created_label = XmCreateLabelGadget(form, "createdLabel", args, n);
  7430.     children[nchildren++] = created_label;
  7431.  
  7432.     n = 0;
  7433.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7434.     XtSetArg(args[n], XmNtopWidget, created_label); n++;
  7435.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7436.     updated_label = XmCreateLabelGadget(form, "updatedLabel", args, n);
  7437.     children[nchildren++] = updated_label;
  7438.  
  7439.     fat_guy = XfeBiggestWidget(TRUE, children, nchildren);
  7440.  
  7441.     n = 0;
  7442.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7443.     XtSetArg(args[n], XmNtopWidget, description_text); n++;
  7444.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  7445.     XtSetArg(args[n], XmNleftWidget, fat_guy); n++;
  7446.     created_text = XmCreateLabelGadget(form, "createdText", args, n);
  7447.     children[nchildren++] = created_text;
  7448.  
  7449.     n = 0;
  7450.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7451.     XtSetArg(args[n], XmNtopWidget, created_text); n++;
  7452.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  7453.     XtSetArg(args[n], XmNleftWidget, fat_guy); n++;
  7454.     updated_text = XmCreateLabelGadget(form, "updatedText", args, n);
  7455.     children[nchildren++] = updated_text;
  7456. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7457.  
  7458.     n = 0;
  7459.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7460. #ifdef EDITOR_SHOW_CREATE_DATE
  7461.     XtSetArg(args[n], XmNtopWidget, updated_text); n++;
  7462. #else
  7463.     XtSetArg(args[n], XmNtopWidget, description_text); n++;
  7464. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7465.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7466.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7467.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  7468.     other_frame = fe_CreateFrame(form, "otherAttributes", args, n);
  7469.     children[nchildren++] = other_frame;
  7470.  
  7471.     XtManageChildren(children, nchildren);
  7472. #if 1
  7473.  
  7474.     n = 0;
  7475.     other_form = XmCreateForm(other_frame, "form", args, n);
  7476.     XtManageChild(other_form);
  7477.  
  7478.     nchildren = 0;
  7479.     n = 0;
  7480.     keywords_label = XmCreateLabelGadget(other_form, "keywordsLabel", args, n);
  7481.     children[nchildren++] = keywords_label;
  7482.  
  7483.     n = 0;
  7484.     classification_label = XmCreateLabelGadget(other_form,
  7485.                                                "classificationLabel",
  7486.                                                args, n);
  7487.     children[nchildren++] = classification_label;
  7488.  
  7489.     left_offset = fe_get_offset_from_widest(children, nchildren);
  7490.  
  7491.     n = 0;
  7492.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  7493.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7494.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  7495.     info_label = XmCreateLabelGadget(other_form, "infoLabel", args, n);
  7496.     children[nchildren++] = info_label;
  7497.  
  7498.     n = 0;
  7499.     XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  7500.     XtSetArg(args[n], XmNrows, 2); n++;
  7501.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7502.     XtSetArg(args[n], XmNtopWidget, info_label); n++;
  7503.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7504.     XtSetArg(args[n], XmNleftWidget, info_label); n++;
  7505.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7506.     XtSetArg(args[n], XmNuserData, DOCUMENT_GENERAL_KEYWORDS); n++;
  7507.     keywords_text = fe_CreateText(other_form, "keywordsText", args, n);
  7508.     children[nchildren++] = keywords_text;
  7509.  
  7510.     XtAddCallback(keywords_text, XmNvalueChangedCallback,
  7511.                   fe_document_general_changed_cb, (XtPointer)w_data);
  7512.     
  7513.     n = 0;
  7514.     XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  7515.     XtSetArg(args[n], XmNrows, 2); n++;
  7516.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7517.     XtSetArg(args[n], XmNtopWidget, keywords_text); n++;
  7518.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  7519.     XtSetArg(args[n], XmNleftWidget, info_label); n++;
  7520.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  7521.     XtSetArg(args[n], XmNuserData, DOCUMENT_GENERAL_CLASSIFICATION); n++;
  7522.     classification_text = fe_CreateText(other_form, "classificationText",
  7523.                                        args, n);
  7524.     children[nchildren++] = classification_text;
  7525.  
  7526.     XtAddCallback(classification_text, XmNvalueChangedCallback,
  7527.                   fe_document_general_changed_cb, (XtPointer)w_data);
  7528.     
  7529.     /* go back set attachments for labels */
  7530.     n = 0;
  7531.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7532.     XtSetArg(args[n], XmNtopWidget, info_label); n++;
  7533.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7534.     XtSetValues(keywords_label, args, n);
  7535.     
  7536.     n = 0;
  7537.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  7538.     XtSetArg(args[n], XmNtopWidget, keywords_text); n++;
  7539.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  7540.     XtSetValues(classification_label, args, n);
  7541.  
  7542.     XtManageChildren(children, nchildren);
  7543. #endif
  7544.     XtManageChild(form);
  7545.  
  7546.     w_data->location = location_text;
  7547.     w_data->title = title_text;
  7548.     w_data->author = author_text;
  7549.     w_data->description = description_text;
  7550. #ifdef EDITOR_SHOW_CREATE_DATE
  7551.     w_data->created = created_text;
  7552.     w_data->updated = updated_text;
  7553. #endif /*EDITOR_SHOW_CREATE_DATE*/
  7554.     w_data->keywords = keywords_text;
  7555.     w_data->classification = classification_text;
  7556.  
  7557.     return form;
  7558. }
  7559.  
  7560. typedef enum
  7561. {
  7562.   XFE_USERMETA_VIEW,
  7563.   XFE_USERMETA_MODIFY,
  7564.   XFE_USERMETA_NEW
  7565. } fe_AdvancedUserState;
  7566.  
  7567. typedef struct fe_NameValueItemList
  7568. {
  7569.     fe_NameValueItem* items;
  7570.     unsigned          nitems;    /* logical number of items */
  7571.     unsigned          size; /* size of vector */
  7572.     Widget            widget;
  7573.     Boolean           is_dirty;
  7574.     int               selected_item;
  7575.     unsigned          mask;
  7576. } fe_NameValueItemList;
  7577.  
  7578. #define NOTHING_SELECTED (-1)
  7579.  
  7580. typedef struct fe_EditorDocumentAdvancedPropertiesStruct
  7581. {
  7582.     MWContext* context;
  7583.     fe_NameValueItemList  system_list;
  7584.     fe_NameValueItemList  user_list;
  7585.     fe_NameValueItemList* active_list;
  7586.     Boolean  item_is_new;
  7587.     Boolean  item_is_dirty;
  7588.     Widget   name_text;
  7589.     Widget   value_text;
  7590.     unsigned changed;
  7591.     fe_DependentList* dependents;
  7592. } fe_EditorDocumentAdvancedPropertiesStruct;
  7593.  
  7594. #define DOCUMENT_ADVANCED_HTTP_LIST (0x1<<0)
  7595. #define DOCUMENT_ADVANCED_META_LIST (0x1<<1)
  7596. #define DOCUMENT_ADVANCED_ITEM      (0x1<<2)
  7597. #define DOCUMENT_ADVANCED_SELECTION (0x1<<3)
  7598.  
  7599. static void
  7600. fe_document_advanced_tell_me_eh(Widget widget, XtPointer closure,
  7601.                                 XEvent* event, Boolean* keep_going)
  7602. {
  7603.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7604.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7605.     fe_NameValueItemList* my_list;
  7606.  
  7607.     *keep_going = TRUE;
  7608.  
  7609.     XmProcessTraversal(widget, XmTRAVERSE_CURRENT);
  7610.  
  7611.     /*
  7612.      *    We may get called after the callback (next), so..
  7613.      */
  7614.     if (w_data->active_list != NULL && w_data->active_list->widget == widget)
  7615.         return;
  7616.  
  7617.     if (w_data->user_list.widget == widget)
  7618.         my_list = &w_data->user_list;
  7619.     else
  7620.         my_list = &w_data->system_list;
  7621.         
  7622.     w_data->active_list = my_list;
  7623.     my_list->selected_item = NOTHING_SELECTED;
  7624.     my_list->is_dirty = FALSE;
  7625.     if (my_list->nitems == 0)
  7626.         w_data->item_is_new = TRUE;
  7627.     else
  7628.         w_data->item_is_new = FALSE;
  7629.     w_data->item_is_dirty = FALSE;
  7630.  
  7631.     fe_DependentListCallDependents(widget,
  7632.                                    w_data->dependents,
  7633.                                    DOCUMENT_ADVANCED_SELECTION,
  7634.                                    closure);
  7635. }
  7636.  
  7637. static void
  7638. fe_document_advanced_list_cb(Widget widget, XtPointer closure,
  7639.                                     XtPointer foo)
  7640. {
  7641.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7642.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7643.     XmListCallbackStruct* cb_data = (XmListCallbackStruct*)foo;
  7644.     fe_NameValueItemList* my_list;
  7645.     
  7646.     if (cb_data->reason != XmCR_SINGLE_SELECT)
  7647.           return;
  7648.  
  7649.     if (w_data->user_list.widget == widget)
  7650.         my_list = &w_data->user_list;
  7651.     else
  7652.         my_list = &w_data->system_list;
  7653.  
  7654.     /*
  7655.      *    For some strange and unknown reason this callback
  7656.      *    adds one to the list position it provides.
  7657.      */
  7658.     if (cb_data->item_position > 0 && cb_data->selected_item_count > 0) {
  7659.         my_list->selected_item = cb_data->item_position - 1;
  7660.     } else {
  7661.         my_list->selected_item = NOTHING_SELECTED;
  7662.     }
  7663.  
  7664.     if (my_list->nitems == 0)
  7665.         w_data->item_is_new = TRUE;
  7666.     else
  7667.         w_data->item_is_new = FALSE;
  7668.  
  7669.     w_data->active_list = my_list;
  7670.     my_list->is_dirty = FALSE;
  7671.     w_data->item_is_dirty = FALSE;
  7672.  
  7673.     fe_DependentListCallDependents(widget,
  7674.                                    w_data->dependents,
  7675.                                    DOCUMENT_ADVANCED_SELECTION,
  7676.                                    closure);
  7677. }
  7678.  
  7679. static void
  7680. fe_copy_name_value_to_xm_list(Widget widget, fe_NameValueItem* list)
  7681. {
  7682.     unsigned i;
  7683.     char buf[512];
  7684.     XmString xm_string;
  7685.  
  7686.     XmListDeleteAllItems(widget);
  7687.  
  7688.     for (i = 0; list[i].name != NULL; i++) {
  7689.         strcpy(buf, list[i].name);
  7690.         strcat(buf, "=");
  7691.         strcat(buf, list[i].value);
  7692.  
  7693.         xm_string = XmStringCreateLocalized(buf);
  7694.         XmListAddItem(widget, xm_string, i + 1); /* MOTIFism */
  7695.         XmStringFree(xm_string);
  7696.     }
  7697. }
  7698.  
  7699. static void
  7700. fe_document_advanced_list_update_cb(Widget widget, XtPointer closure,
  7701.                                     XtPointer cb_data)
  7702. {
  7703.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7704.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7705.     fe_NameValueItemList* my_list;
  7706.     Pixel    parent_bg;
  7707.     Pixel    select_bg;
  7708.  
  7709.     XtVaGetValues(XtParent(widget), XmNbackground, &parent_bg, 0);
  7710.  
  7711.     XmGetColors(XtScreen(widget), fe_cmap(w_data->context),
  7712.                 parent_bg, NULL, NULL, NULL, &select_bg);
  7713.  
  7714.     if (w_data->user_list.widget == widget)
  7715.         my_list = &w_data->user_list;
  7716.     else
  7717.         my_list = &w_data->system_list;
  7718.  
  7719.     if (my_list->is_dirty) {
  7720.         fe_copy_name_value_to_xm_list(widget, my_list->items);
  7721.         my_list->is_dirty = FALSE;
  7722.     }
  7723.  
  7724.     if (w_data->active_list == my_list &&
  7725.         my_list->selected_item != NOTHING_SELECTED) {
  7726.         XmListSelectPos(widget, my_list->selected_item + 1, FALSE);
  7727.     } else {
  7728.         XmListDeselectAllItems(widget);
  7729.     }
  7730.  
  7731.     if (w_data->active_list == my_list)
  7732.         XtVaSetValues(widget, XmNbackground, select_bg, 0);
  7733.     else
  7734.         XtVaSetValues(widget, XmNbackground, parent_bg, 0);
  7735. }
  7736.  
  7737. static void
  7738. fe_document_advanced_value_cb(Widget widget, XtPointer closure,
  7739.                                     XtPointer cb_data)
  7740. {
  7741.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7742.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7743.  
  7744.     if (w_data->item_is_dirty == FALSE) {
  7745.         w_data->item_is_dirty = TRUE;
  7746.  
  7747.         fe_DependentListCallDependents(widget,
  7748.                                        w_data->dependents,
  7749.                                        DOCUMENT_ADVANCED_ITEM,
  7750.                                        closure);
  7751.     }
  7752. }
  7753.  
  7754. static void
  7755. fe_document_advanced_name_update_cb(Widget widget, XtPointer closure,
  7756.                                     XtPointer cb_data)
  7757. {
  7758.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7759.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7760.     fe_DependentListCallbackStruct* info = 
  7761.         (fe_DependentListCallbackStruct*)cb_data;
  7762.     char* name;
  7763.     
  7764.     if (info->caller == widget)
  7765.       return;
  7766.     
  7767.     if (w_data->item_is_new) {
  7768.         fe_TextFieldSetString(widget, "", FALSE);
  7769.         fe_TextFieldSetEditable(w_data->context, widget, TRUE);
  7770.         XtVaSetValues(XtParent(widget), XmNinitialFocus, widget, 0);
  7771.     } else {
  7772.         fe_NameValueItemList* active_list = w_data->active_list;
  7773.           if (active_list != NULL &&
  7774.             active_list->selected_item != NOTHING_SELECTED) {
  7775.             name = active_list->items[active_list->selected_item].name;
  7776.             
  7777.             fe_TextFieldSetString(widget, name, FALSE);
  7778.         } else {
  7779.             fe_TextFieldSetString(widget, "", FALSE);
  7780.         }
  7781.         fe_TextFieldSetEditable(w_data->context, widget, FALSE);
  7782.     }
  7783. }
  7784.  
  7785. static void
  7786. fe_document_advanced_value_update_cb(Widget widget, XtPointer closure,
  7787.                                     XtPointer cb_data)
  7788. {
  7789.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7790.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7791.     fe_DependentListCallbackStruct* info = 
  7792.         (fe_DependentListCallbackStruct*)cb_data;
  7793.     char* value;
  7794.     
  7795.     if (info->caller == widget)
  7796.       return;
  7797.     
  7798.     if (w_data->item_is_new) {
  7799.         fe_TextFieldSetString(widget, "", FALSE);
  7800.         fe_TextFieldSetEditable(w_data->context, widget, TRUE);
  7801.     } else {
  7802.         fe_NameValueItemList* active_list = w_data->active_list;
  7803.           if (active_list != NULL &&
  7804.             active_list->selected_item != NOTHING_SELECTED) {
  7805.             value = active_list->items[active_list->selected_item].value;
  7806.             
  7807.             if (value == NULL)
  7808.               value = "";
  7809.  
  7810.             fe_TextFieldSetString(widget, value, FALSE);
  7811.             fe_TextFieldSetEditable(w_data->context, widget, TRUE);
  7812. #if 0
  7813.             XmProcessTraversal(widget, XmTRAVERSE_CURRENT);
  7814. #endif
  7815.         }    else { /* nothing selected */
  7816.             fe_TextFieldSetString(widget, "", FALSE);
  7817.             fe_TextFieldSetEditable(w_data->context, widget, FALSE);
  7818.         }
  7819.     }
  7820. }
  7821.  
  7822. static void
  7823. fe_document_advanced_new_cb(Widget widget, XtPointer closure,
  7824.                                     XtPointer cb_data)
  7825. {
  7826.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7827.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7828.     w_data->item_is_new = TRUE;
  7829.     w_data->item_is_dirty = FALSE;
  7830.  
  7831.     fe_DependentListCallDependents(widget,
  7832.                                    w_data->dependents,
  7833.                                    DOCUMENT_ADVANCED_SELECTION,
  7834.                                    closure);
  7835. }
  7836.  
  7837. #if 0
  7838. static void
  7839. fe_document_advanced_new_update_cb(Widget widget, XtPointer closure,
  7840.                                     XtPointer cb_data)
  7841. {
  7842.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7843.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7844.     Boolean sensitive = (w_data->item_is_new == FALSE);
  7845.     
  7846.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  7847. }
  7848. #endif
  7849.  
  7850. static void
  7851. list_set_item(fe_NameValueItemList* active_list, unsigned index,
  7852.                 char* name, char* value)
  7853. {
  7854.     unsigned size;
  7855.  
  7856.     if (active_list == NULL) /* this should be error */
  7857.         return;
  7858.  
  7859.     if (index == active_list->nitems)
  7860.         active_list->nitems++;
  7861.  
  7862.     if (active_list->nitems > active_list->size) {
  7863.  
  7864.         active_list->size = active_list->nitems;
  7865.         size = sizeof(fe_NameValueItem) * (active_list->size+1);
  7866.         if (active_list->size == 0)
  7867.             active_list->items = (fe_NameValueItem*)XtMalloc(size);
  7868.         else
  7869.             active_list->items = (fe_NameValueItem*)XtRealloc((void*)active_list->items,
  7870.                                                      size);
  7871.  
  7872.         active_list->items[active_list->nitems].name = NULL;
  7873.         active_list->items[active_list->nitems].value = NULL;
  7874.     }
  7875.  
  7876.     if (active_list->items[index].name != NULL)
  7877.         XtFree(active_list->items[index].name);
  7878.     if (active_list->items[index].value != NULL)
  7879.         XtFree(active_list->items[index].value);
  7880.  
  7881.     active_list->items[index].name = XtNewString(name);
  7882.     if (value)
  7883.         active_list->items[index].value = XtNewString(value);
  7884.     else
  7885.         active_list->items[index].value = NULL;
  7886.     active_list->is_dirty = TRUE;
  7887. }
  7888.  
  7889. static void
  7890. list_delete_item(fe_NameValueItemList* active_list, unsigned index)
  7891. {
  7892.  
  7893.     if (active_list == NULL) /* this should be error */
  7894.         return;
  7895.  
  7896.     if (active_list->items[index].name)
  7897.         XtFree(active_list->items[index].name);
  7898.     if (active_list->items[index].value)
  7899.         XtFree(active_list->items[index].value);
  7900.     
  7901.     active_list->nitems--;
  7902.     if (index < active_list->nitems) {
  7903.         memcpy(&active_list->items[index], &active_list->items[index+1],
  7904.                (sizeof(fe_NameValueItem) * (active_list->nitems - index)));
  7905.     }
  7906.     active_list->items[active_list->nitems].name = NULL;
  7907.     active_list->items[active_list->nitems].value = NULL;
  7908.     active_list->is_dirty = TRUE;
  7909. }
  7910.  
  7911. static void
  7912. fe_document_advanced_delete_cb(Widget widget, XtPointer closure,
  7913.                                     XtPointer cb_data)
  7914. {
  7915.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7916.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7917.     fe_NameValueItemList* active_list = w_data->active_list;
  7918.  
  7919.     if (active_list == NULL || active_list->selected_item == NOTHING_SELECTED)
  7920.         return;
  7921.  
  7922.     list_delete_item(active_list, active_list->selected_item);
  7923.     if (active_list->selected_item > 0)
  7924.         active_list->selected_item--;
  7925.     
  7926.     w_data->item_is_dirty = w_data->item_is_new = FALSE;
  7927.       
  7928.     fe_DependentListCallDependents(widget,
  7929.                                    w_data->dependents,
  7930.                                    w_data->active_list->mask,
  7931.                                    closure);
  7932.     w_data->changed |= w_data->active_list->mask;
  7933. }
  7934.  
  7935. static void
  7936. fe_document_advanced_delete_update_cb(Widget widget, XtPointer closure,
  7937.                                     XtPointer cb_data)
  7938. {
  7939.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7940.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7941.     Boolean sensitive =
  7942.         (w_data->item_is_new == FALSE) &&
  7943.         (w_data->active_list != NULL) &&
  7944.         (w_data->active_list->selected_item != NOTHING_SELECTED);
  7945.     
  7946.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  7947. }
  7948.  
  7949. static void
  7950. fe_document_advanced_set_cb(Widget widget, XtPointer closure,
  7951.                                     XtPointer cb_data)
  7952. {
  7953.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7954.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7955.     char* name;
  7956.     char* value;
  7957.  
  7958.     if (w_data->active_list == NULL)
  7959.         return;
  7960.  
  7961.     name = fe_TextFieldGetString(w_data->name_text);
  7962.     value = fe_TextFieldGetString(w_data->value_text);
  7963.  
  7964.     if (w_data->item_is_new)
  7965.         w_data->active_list->selected_item = w_data->active_list->nitems;
  7966.  
  7967.     list_set_item(w_data->active_list, w_data->active_list->selected_item,
  7968.                   name, value);
  7969.  
  7970.     XtFree(name);
  7971.     XtFree(value);
  7972.  
  7973.     w_data->item_is_new = FALSE;
  7974.     w_data->item_is_dirty = FALSE;
  7975.  
  7976.     fe_DependentListCallDependents(widget,
  7977.                                    w_data->dependents,
  7978.                                    w_data->active_list->mask,
  7979.                                    closure);
  7980.     w_data->changed |= w_data->active_list->mask;
  7981. }
  7982.  
  7983. static void
  7984. fe_document_advanced_set_update_cb(Widget widget, XtPointer closure,
  7985.                                     XtPointer cb_data)
  7986. {
  7987.     fe_EditorDocumentAdvancedPropertiesStruct* w_data = 
  7988.       (fe_EditorDocumentAdvancedPropertiesStruct*)closure;
  7989.     Boolean sensitive = (w_data->item_is_dirty);
  7990.     
  7991.     XtVaSetValues(widget, XmNsensitive, sensitive, 0);
  7992. }
  7993.  
  7994. static void
  7995. fe_document_advanced_init(MWContext* context,
  7996.                           fe_EditorDocumentAdvancedPropertiesStruct* w_data)
  7997. {
  7998.     int i;
  7999.     fe_NameValueItem* list;
  8000.  
  8001.     list = fe_EditorDocumentGetHttpEquivMetaDataList(context);
  8002.     w_data->system_list.items = list;
  8003.     for (i = 0; list[i].name != NULL; i++)
  8004.         ;
  8005.     w_data->system_list.nitems = i;
  8006.     w_data->system_list.size = i;
  8007.     w_data->system_list.is_dirty = TRUE;
  8008.     w_data->system_list.selected_item = NOTHING_SELECTED;
  8009.     w_data->system_list.mask = DOCUMENT_ADVANCED_HTTP_LIST;
  8010.     
  8011.     list = fe_EditorDocumentGetAdvancedMetaDataList(context);
  8012.     w_data->user_list.items = list;
  8013.     for (i = 0; list[i].name != NULL; i++)
  8014.         ;
  8015.     w_data->user_list.nitems = i;
  8016.     w_data->user_list.size = i;
  8017.     w_data->user_list.is_dirty = TRUE;
  8018.     w_data->user_list.selected_item = NOTHING_SELECTED;
  8019.     w_data->user_list.mask = DOCUMENT_ADVANCED_META_LIST;
  8020.  
  8021.     fe_DependentListCallDependents(NULL,
  8022.                                    w_data->dependents,
  8023.                                    ~0,
  8024.                                    (XtPointer)w_data);
  8025. }
  8026.  
  8027. static void
  8028. fe_document_advanced_set(MWContext* context,
  8029.                           fe_EditorDocumentAdvancedPropertiesStruct* w_data)
  8030. {
  8031.     if ((w_data->changed & DOCUMENT_ADVANCED_HTTP_LIST) != 0) {
  8032.         fe_EditorDocumentSetHttpEquivMetaDataList(context,
  8033.                                                   w_data->system_list.items);
  8034.     }
  8035.  
  8036.     if ((w_data->changed & DOCUMENT_ADVANCED_META_LIST) != 0) {
  8037.         fe_EditorDocumentSetAdvancedMetaDataList(context,
  8038.                                                  w_data->user_list.items);
  8039.     }
  8040. }
  8041.  
  8042. static Widget
  8043. fe_document_advanced_create(
  8044.                           MWContext* context,
  8045.                           Widget parent,
  8046.                           fe_EditorDocumentAdvancedPropertiesStruct* w_data)
  8047. {
  8048.     Widget form;
  8049.     Widget system_label;
  8050.     Widget system_list;
  8051.     Widget user_label;
  8052.     Widget user_list;
  8053.     Widget name_label;
  8054.     Widget name_text;
  8055.     Widget name_new;
  8056.     Widget name_set;
  8057.     Widget value_label;
  8058.     Widget value_text;
  8059.     Widget name_delete;
  8060.     Widget list_parent;
  8061.     Widget fat_guy;
  8062.     Dimension left_offset;
  8063.     Arg args[16];
  8064.     Cardinal n;
  8065.     Widget children[12];
  8066.     Cardinal nchildren;
  8067.     Dimension width;
  8068.  
  8069. #if 1
  8070.     form = parent;
  8071. #else
  8072.     n = 0;
  8073.     form = XmCreateForm(parent, "advanced", args, n);
  8074.     XtManageChild(form);
  8075. #endif
  8076.  
  8077.     nchildren = 0;
  8078.     n = 0;
  8079.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8080.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8081.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  8082.     system_label = XmCreateLabelGadget(form, "systemLabel", args, n);
  8083.     children[nchildren++] = system_label;
  8084.  
  8085. #define SCROLLED_LIST_SIZE 5
  8086.     n = 0;
  8087.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8088.     XtSetArg(args[n], XmNtopWidget, system_label); n++;
  8089.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8090.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8091.     XtSetArg(args[n], XmNvisibleItemCount, SCROLLED_LIST_SIZE); n++;
  8092.     XtSetArg(args[n], XmNselectionPolicy, XmSINGLE_SELECT); n++;
  8093.     XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); n++;
  8094.     system_list = XmCreateScrolledList(form, "systemList", args, n);
  8095.     XtManageChild(system_list);
  8096.     children[nchildren++] = list_parent = XtParent(system_list);
  8097.     
  8098.     n = 0;
  8099.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8100.     XtSetArg(args[n], XmNtopWidget, list_parent); n++;
  8101.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8102.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  8103.     user_label = XmCreateLabelGadget(form, "userLabel", args, n);
  8104.     children[nchildren++] = user_label;
  8105.  
  8106.     n = 0;
  8107.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8108.     XtSetArg(args[n], XmNtopWidget, user_label); n++;
  8109.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8110.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8111.     XtSetArg(args[n], XmNvisibleItemCount, SCROLLED_LIST_SIZE); n++;
  8112.     XtSetArg(args[n], XmNselectionPolicy, XmSINGLE_SELECT); n++;
  8113.     XtSetArg(args[n], XmNlistSizePolicy, XmCONSTANT); n++;
  8114.     user_list = XmCreateScrolledList(form, "userList", args, n);
  8115.     XtManageChild(user_list);
  8116.     children[nchildren++] = list_parent = XtParent(user_list);
  8117.  
  8118.     n = 0;
  8119.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8120.     XtSetArg(args[n], XmNtopWidget, list_parent); n++;
  8121.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8122.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  8123.     name_label = XmCreateLabelGadget(form, "nameLabel", args, n);
  8124.     children[nchildren++] = name_label;
  8125.  
  8126.     n = 0;
  8127.     value_label = XmCreateLabelGadget(form, "valueLabel", args, n);
  8128.     children[nchildren++] = value_label;
  8129.  
  8130.     left_offset = fe_get_offset_from_widest(&children[nchildren-2], 2);
  8131.  
  8132.     n = 0;
  8133.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8134.     XtSetArg(args[n], XmNtopWidget, list_parent); n++;
  8135.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8136.     name_new = XmCreatePushButtonGadget(form, "new", args, n);
  8137.     children[nchildren++] = name_new;
  8138.  
  8139.     n = 0;
  8140.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8141.     XtSetArg(args[n], XmNtopWidget, list_parent); n++;
  8142.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  8143.     XtSetArg(args[n], XmNrightWidget, name_new); n++;
  8144.     name_delete = XmCreatePushButtonGadget(form, "delete", args, n);
  8145.     children[nchildren++] = name_delete;
  8146.  
  8147.     n = 0;
  8148.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8149.     XtSetArg(args[n], XmNtopWidget, list_parent); n++;
  8150.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8151.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  8152.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  8153.     XtSetArg(args[n], XmNrightWidget, name_delete); n++;
  8154.     name_text = fe_CreateTextField(form, "nameText", args, n);
  8155.     children[nchildren++] = name_text;
  8156.  
  8157.     n = 0;
  8158.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8159.     XtSetArg(args[n], XmNtopWidget, name_text); n++;
  8160.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8161.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  8162.     XtSetValues(value_label, args, n);
  8163.  
  8164.     n = 0;
  8165.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8166.     XtSetArg(args[n], XmNtopWidget, name_text); n++;
  8167.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8168.     name_set = XmCreatePushButtonGadget(form, "set", args, n);
  8169.     children[nchildren++] = name_set;
  8170.  
  8171.     n = 0;
  8172.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8173.     XtSetArg(args[n], XmNtopWidget, name_text); n++;
  8174.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8175.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  8176.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  8177.     XtSetArg(args[n], XmNrightWidget, name_set); n++;
  8178.     value_text = fe_CreateTextField(form, "valueText", args, n);
  8179.     children[nchildren++] = value_text;
  8180.  
  8181.     XtManageChildren(children, nchildren);
  8182.  
  8183.     nchildren = 0;
  8184.     children[nchildren++] = name_new;
  8185.     children[nchildren++] = name_delete;
  8186.     children[nchildren++] = name_set;
  8187.     fat_guy = XfeBiggestWidget(TRUE, children, nchildren);
  8188.  
  8189.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  8190.     for (n = 0; n < nchildren; n++) {
  8191.         XtVaSetValues(children[n], XmNwidth, width, 0);
  8192.     }
  8193.  
  8194.     XtAddCallback(system_list, XmNsingleSelectionCallback,
  8195.                   fe_document_advanced_list_cb, (XtPointer)w_data);
  8196.     fe_DependentListAddDependent(&w_data->dependents,
  8197.                                  system_list,
  8198.                                  (DOCUMENT_ADVANCED_SELECTION|DOCUMENT_ADVANCED_HTTP_LIST),
  8199.                                  fe_document_advanced_list_update_cb,
  8200.                                  (XtPointer)w_data);
  8201.     XtInsertEventHandler(system_list, ButtonPressMask, False, 
  8202.                          fe_document_advanced_tell_me_eh, (XtPointer)w_data,
  8203.                          XtListTail);
  8204.  
  8205.     XtAddCallback(user_list, XmNsingleSelectionCallback,
  8206.                   fe_document_advanced_list_cb, (XtPointer)w_data);
  8207.     fe_DependentListAddDependent(&w_data->dependents,
  8208.                                  user_list,
  8209.                                  (DOCUMENT_ADVANCED_SELECTION|DOCUMENT_ADVANCED_META_LIST),
  8210.                                  fe_document_advanced_list_update_cb,
  8211.                                  (XtPointer)w_data);
  8212.     XtInsertEventHandler(user_list, ButtonPressMask, False, 
  8213.                          fe_document_advanced_tell_me_eh, (XtPointer)w_data,
  8214.                          XtListTail);
  8215.  
  8216.     XtAddCallback(name_text, XmNvalueChangedCallback,
  8217.                   fe_document_advanced_value_cb, (XtPointer)w_data);
  8218.     fe_DependentListAddDependent(&w_data->dependents,
  8219.                          name_text,
  8220.                          (DOCUMENT_ADVANCED_HTTP_LIST|DOCUMENT_ADVANCED_META_LIST|DOCUMENT_ADVANCED_SELECTION),
  8221.                          fe_document_advanced_name_update_cb,
  8222.                          (XtPointer)w_data);
  8223.  
  8224.     XtAddCallback(value_text, XmNvalueChangedCallback,
  8225.                   fe_document_advanced_value_cb, (XtPointer)w_data);
  8226.     fe_DependentListAddDependent(&w_data->dependents,
  8227.                          value_text,
  8228.                          (DOCUMENT_ADVANCED_HTTP_LIST|DOCUMENT_ADVANCED_META_LIST|DOCUMENT_ADVANCED_SELECTION),
  8229.                          fe_document_advanced_value_update_cb,
  8230.                          (XtPointer)w_data);
  8231.  
  8232.     XtAddCallback(name_new, XmNactivateCallback,
  8233.                   fe_document_advanced_new_cb,(XtPointer)w_data);
  8234. #if 0
  8235.     fe_DependentListAddDependent(&w_data->dependents,
  8236.                          name_new,
  8237.                          (DOCUMENT_ADVANCED_HTTP_LIST|DOCUMENT_ADVANCED_META_LIST|DOCUMENT_ADVANCED_SELECTION),
  8238.                          fe_document_advanced_new_update_cb,
  8239.                          (XtPointer)w_data);
  8240. #endif
  8241.  
  8242.     XtAddCallback(name_delete, XmNactivateCallback,
  8243.                   fe_document_advanced_delete_cb,(XtPointer)w_data);
  8244.     fe_DependentListAddDependent(&w_data->dependents,
  8245.                          name_delete,
  8246.                          (DOCUMENT_ADVANCED_HTTP_LIST|DOCUMENT_ADVANCED_META_LIST|DOCUMENT_ADVANCED_SELECTION),
  8247.                          fe_document_advanced_delete_update_cb,
  8248.                          (XtPointer)w_data);
  8249.  
  8250.     XtAddCallback(name_set, XmNactivateCallback,
  8251.                   fe_document_advanced_set_cb,(XtPointer)w_data);
  8252.     fe_DependentListAddDependent(&w_data->dependents,
  8253.                          name_set,
  8254.                          (DOCUMENT_ADVANCED_HTTP_LIST|DOCUMENT_ADVANCED_META_LIST|DOCUMENT_ADVANCED_ITEM
  8255.                           |DOCUMENT_ADVANCED_SELECTION),
  8256.                          fe_document_advanced_set_update_cb,
  8257.                          (XtPointer)w_data);
  8258.     w_data->name_text = name_text;
  8259.     w_data->value_text = value_text;
  8260.     w_data->system_list.widget = system_list;
  8261.     w_data->user_list.widget = user_list;
  8262.     w_data->context = context;
  8263.  
  8264.     return form;
  8265. }
  8266.  
  8267. typedef struct fe_EditorDocumentPropertiesStruct
  8268. {
  8269.   MWContext* context;
  8270.   fe_EditorDocumentAppearancePropertiesStruct* appearance;
  8271.   fe_EditorDocumentGeneralPropertiesStruct*    general;
  8272.   fe_EditorDocumentAdvancedPropertiesStruct*   advanced;
  8273. } fe_EditorDocumentPropertiesStruct;
  8274.  
  8275. static Widget
  8276. fe_EditorDocumentPropertiesCreate(MWContext* context,
  8277.                                   fe_EditorDocumentPropertiesStruct* p_data)
  8278. {
  8279.     Widget   dialog;
  8280.     Widget   form;
  8281.     Widget   tab_form;
  8282.     char*    name = "documentPropertiesDialog";
  8283.     Arg      args[8];
  8284.     Cardinal n;
  8285.     
  8286.     /*
  8287.      *    Make prompt with ok, apply, cancel, no separator.
  8288.      */
  8289.     dialog = fe_CreatePromptDialog(context, name,
  8290.                                    TRUE, TRUE, TRUE, FALSE, TRUE);
  8291.  
  8292.     form = XtVaCreateManagedWidget(
  8293.                                    "folder",
  8294.                                    xmlFolderWidgetClass, dialog,
  8295.                                    XmNshadowThickness, 2,
  8296.                                    XmNtopAttachment, XmATTACH_FORM,
  8297.                                    XmNleftAttachment, XmATTACH_FORM,
  8298.                                    XmNrightAttachment, XmATTACH_FORM,
  8299.                                    XmNbottomAttachment, XmATTACH_FORM,
  8300. #ifdef ALLOW_TAB_ROTATE
  8301.                                    XmNtabPlacement, XmFOLDER_LEFT,
  8302.                                    XmNrotateWhenLeftRight, FALSE,
  8303. #endif /* ALLOW_TAB_ROTATE */
  8304.                                    XmNbottomOffset, 3,
  8305.                                    XmNspacing, 1,
  8306.                                    NULL);
  8307.  
  8308.     n = 0;
  8309.     tab_form = fe_CreateTabForm(form, "appearanceProperties", args, n);
  8310.     fe_document_appearance_create(context, tab_form, p_data->appearance);
  8311.     
  8312.     tab_form = fe_CreateTabForm(form, "generalProperties", args, n);
  8313.     fe_document_general_create(context, tab_form, p_data->general);
  8314.  
  8315.     tab_form = fe_CreateTabForm(form, "advanced", args, n);
  8316.     fe_document_advanced_create(context, tab_form, p_data->advanced);
  8317.  
  8318.     XtManageChild(dialog);
  8319.  
  8320.     return form;
  8321. }
  8322.  
  8323. void
  8324. fe_EditorDocumentPropertiesDialogDo(MWContext* context, 
  8325.                               fe_EditorDocumentPropertiesDialogType tab_type)
  8326. {
  8327.     fe_EditorDocumentPropertiesStruct properties;
  8328.     fe_EditorDocumentAppearancePropertiesStruct appearance;
  8329.     fe_EditorDocumentGeneralPropertiesStruct general;
  8330.     fe_EditorDocumentAdvancedPropertiesStruct advanced;
  8331.     int done;
  8332.     Widget dialog;
  8333.     Widget form;
  8334.     Widget apply_button;
  8335.     Boolean apply_sensitized;
  8336.     unsigned tab_number;
  8337.     Boolean  three_tabs = (context->type == MWContextEditor); /* hack */
  8338.  
  8339.     /*
  8340.      *    Pick the tab.
  8341.      */
  8342.     tab_number = tab_type - 1;
  8343.  
  8344.     memset(&properties, 0, sizeof(fe_EditorDocumentPropertiesStruct));
  8345.     memset(&appearance, 0,
  8346.            sizeof(fe_EditorDocumentAppearancePropertiesStruct));
  8347.     memset(&general, 0, sizeof(fe_EditorDocumentGeneralPropertiesStruct));
  8348.     memset(&advanced, 0, sizeof(fe_EditorDocumentAdvancedPropertiesStruct));
  8349.  
  8350.     properties.appearance = &appearance;
  8351.     properties.general = &general;
  8352.     properties.advanced = &advanced;
  8353.  
  8354.     properties.context = context;
  8355.     if (three_tabs) {
  8356.         form = fe_EditorDocumentPropertiesCreate(context, &properties);
  8357.         fe_document_appearance_init(context, &appearance);
  8358.         fe_document_general_init(context, &general);
  8359.         fe_document_advanced_init(context, &advanced);
  8360.         XmLFolderSetActiveTab(form, tab_number, True);
  8361.         dialog = XtParent(form);
  8362.     } else {
  8363.         /*
  8364.          *    Make prompt with ok, apply, cancel, no separator.
  8365.          */
  8366.         dialog = fe_CreatePromptDialog(context, "documentPropertiesDialog",
  8367.                                        TRUE, TRUE, TRUE, TRUE, TRUE);
  8368.  
  8369.         form = XmCreateForm(dialog, "appearanceProperties", NULL, 0);
  8370.         XtManageChild(form);
  8371.         fe_document_appearance_create(context, form,  &appearance);
  8372.         XtManageChild(dialog);
  8373.         fe_document_appearance_init(context, &appearance);
  8374.         form = dialog;
  8375.     }
  8376.  
  8377.     /*
  8378.      *    Initialize.
  8379.      */
  8380. #if 0
  8381.     fe_DependentListCallDependents(NULL, properties.dependents,
  8382.                                    ~0, (XtPointer)&properties);
  8383. #endif
  8384.  
  8385.     /*
  8386.      *   Add a bunch of callbacks to the buttons.
  8387.      */
  8388.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  8389.     XtAddCallback(dialog, XmNapplyCallback, fe_hrule_apply_cb, &done);
  8390.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  8391.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  8392.  
  8393.     /*
  8394.      *    We toggle the sensitivity of the apply button on/off
  8395.      *    depending if there are changes to apply. It would be
  8396.      *    nice to use the depdency meahcnism, but it might get
  8397.      *    very busy.
  8398.      */
  8399.     apply_button = XmSelectionBoxGetChild(dialog, XmDIALOG_APPLY_BUTTON);
  8400.     XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  8401.     apply_sensitized = FALSE;
  8402.  
  8403.     /*
  8404.      *    Popup.
  8405.      */
  8406.     XtManageChild(form);
  8407.  
  8408.     /*
  8409.      *    Wait.
  8410.      */
  8411.     fe_NukeBackingStore(dialog); /* what does this do? */
  8412.  
  8413.     done = XmDIALOG_NONE;
  8414.     while (done == XmDIALOG_NONE) {
  8415.  
  8416.         fe_EventLoop();
  8417.  
  8418.         if (done == XFE_DIALOG_DESTROY_BUTTON||done == XmDIALOG_CANCEL_BUTTON)
  8419.             break;
  8420.  
  8421. #define SOMETHING_CHANGED() \
  8422. (appearance.changed != 0 || general.changed != 0 || advanced.changed != 0)
  8423.  
  8424.         if (SOMETHING_CHANGED() && apply_sensitized == FALSE) {
  8425.             XtVaSetValues(apply_button, XmNsensitive, TRUE, 0);
  8426.             apply_sensitized = TRUE;
  8427.         }
  8428.  
  8429.         if (done == XmDIALOG_APPLY_BUTTON || done == XmDIALOG_OK_BUTTON) {
  8430.             /* apply */
  8431.  
  8432.             if (SOMETHING_CHANGED()) {
  8433.  
  8434.                 EDT_BeginBatchChanges(context);
  8435.  
  8436.                 if (appearance.changed != 0) {
  8437.                     fe_document_appearance_set(context, &appearance);
  8438.                     appearance.changed = 0;
  8439.                 }
  8440.                 if (general.changed != 0) {
  8441.                     fe_document_general_set(context, &general);
  8442.                     general.changed = 0;
  8443.                 }
  8444.                 if (advanced.changed != 0) {
  8445.                     fe_document_advanced_set(context, &advanced);
  8446.                     advanced.changed = 0;
  8447.                 }
  8448.  
  8449.                 EDT_EndBatchChanges(context);
  8450.             }
  8451.  
  8452.             if (done == XmDIALOG_APPLY_BUTTON) {
  8453.                 done = XmDIALOG_NONE; /* keep looping */
  8454.  
  8455.                 XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  8456.                 apply_sensitized = FALSE;
  8457.             }
  8458.         }
  8459.     }
  8460. #undef SOMETHING_CHANGED
  8461.  
  8462.     /*
  8463.      *    Unload data.
  8464.      */
  8465.     fe_DependentListDestroy(appearance.dependents);
  8466.  
  8467.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  8468.         XtDestroyWidget(dialog);
  8469. }
  8470.  
  8471. typedef struct fe_EditorGeneralPreferencesStruct
  8472. {
  8473.     MWContext* context;
  8474.  
  8475.     Widget author;
  8476.     Widget html_editor;
  8477.     Widget image_editor;
  8478.     Widget template;
  8479.     Widget autosave_toggle;
  8480.     Widget autosave_text;
  8481.  
  8482.     unsigned changed;
  8483.     
  8484. } fe_EditorGeneralPreferencesStruct;
  8485.  
  8486. #define EDITOR_GENERAL_AUTHOR          (0x1<<0)
  8487. #define EDITOR_GENERAL_HTML_EDITOR     (0x1<<1)
  8488. #define EDITOR_GENERAL_IMAGE_EDITOR    (0x1<<2)
  8489. #define EDITOR_GENERAL_TEMPLATE        (0x1<<3)
  8490. #define EDITOR_GENERAL_AUTOSAVE        (0x1<<4)
  8491.  
  8492. static void
  8493. fe_general_preferences_restore_template_cb(Widget widget,
  8494.                                XtPointer closure, XtPointer call_data)
  8495. {
  8496.     char* value;
  8497.     fe_EditorGeneralPreferencesStruct* w_data
  8498.         = (fe_EditorGeneralPreferencesStruct*)closure;
  8499.  
  8500.     /* get the template */
  8501.     if ((value = fe_EditorDefaultGetTemplate()) == NULL)
  8502.         value = "";
  8503.  
  8504.     fe_SetTextFieldAndCallBack(w_data->template, value);
  8505.  
  8506.     w_data->changed |= EDITOR_GENERAL_TEMPLATE;
  8507. }
  8508.  
  8509. static void
  8510. fe_general_preferences_changed_cb(Widget widget,
  8511.                                XtPointer closure, XtPointer call_data)
  8512. {
  8513.     fe_EditorGeneralPreferencesStruct* w_data
  8514.         = (fe_EditorGeneralPreferencesStruct*)closure;
  8515.     unsigned mask = (unsigned)fe_GetUserData(widget);
  8516.  
  8517.     w_data->changed |= mask;
  8518. }
  8519.  
  8520. static void
  8521. fe_general_preferences_autosave_toggle_cb(Widget widget,
  8522.                                XtPointer closure, XtPointer call_data)
  8523. {
  8524.     fe_EditorGeneralPreferencesStruct* w_data
  8525.         = (fe_EditorGeneralPreferencesStruct*)closure;
  8526.     XmToggleButtonCallbackStruct* cb
  8527.         = (XmToggleButtonCallbackStruct*)call_data;
  8528.  
  8529.     fe_TextFieldSetEditable(w_data->context, w_data->autosave_text, cb->set);
  8530.     w_data->changed |= EDITOR_GENERAL_AUTOSAVE;
  8531. }
  8532.  
  8533. static void
  8534. fe_general_preferences_init(MWContext* context,
  8535.                          fe_EditorGeneralPreferencesStruct* w_data)
  8536. {
  8537.     char* value;
  8538.     char* value2;
  8539.     Boolean as_enable;
  8540.     unsigned as_time;
  8541.  
  8542.     /* get the author */
  8543.     if ((value = fe_EditorPreferencesGetAuthor(context)) != NULL)
  8544.         fe_SetTextFieldAndCallBack(w_data->author, value);
  8545.  
  8546.     /* get the editors */
  8547.     fe_EditorPreferencesGetEditors(context, &value, &value2);
  8548.     if (value != NULL)
  8549.         fe_SetTextFieldAndCallBack(w_data->html_editor, value);
  8550.  
  8551.     if (value2 != NULL)
  8552.         fe_SetTextFieldAndCallBack(w_data->image_editor, value2);
  8553.  
  8554.     /* get the template */
  8555.     if ((value = fe_EditorPreferencesGetTemplate(context)))
  8556.         fe_SetTextFieldAndCallBack(w_data->template, value);
  8557.  
  8558.     /* get the autosave state */
  8559.     fe_EditorPreferencesGetAutoSave(context, &as_enable, &as_time);
  8560.     if (!as_enable)
  8561.         as_time = 10;
  8562.     
  8563.     fe_set_numeric_text_field(w_data->autosave_text, as_time);
  8564.     fe_TextFieldSetEditable(context, w_data->autosave_text, as_enable);
  8565.     XmToggleButtonGadgetSetState(w_data->autosave_toggle, as_enable, FALSE);
  8566.  
  8567.     w_data->context = context;
  8568.     w_data->changed = 0;
  8569. }
  8570.  
  8571. static Boolean
  8572. fe_general_preferences_validate(MWContext* context,
  8573.                         fe_EditorGeneralPreferencesStruct* w_data)
  8574. {
  8575.     Boolean as_enable;
  8576.     int as_time;
  8577.  
  8578.     /* autosave */
  8579.     if ((w_data->changed & EDITOR_GENERAL_AUTOSAVE) != 0) {
  8580.         as_time = fe_get_numeric_text_field(w_data->autosave_text);
  8581.         as_enable = XmToggleButtonGadgetGetState(w_data->autosave_toggle);
  8582.         
  8583.         if (as_time == 0)
  8584.             as_enable = FALSE;
  8585.         
  8586.         if (as_enable) {
  8587.             if (RANGE_CHECK(as_time,AUTOSAVE_MIN_PERIOD,AUTOSAVE_MAX_PERIOD)) {
  8588.                 char* msg = XP_GetString(XFE_EDITOR_AUTOSAVE_PERIOD_RANGE);
  8589.                 fe_error_dialog(context, w_data->autosave_text, msg);
  8590.                 return FALSE;
  8591.             }
  8592.         }
  8593.     }
  8594.     return TRUE;
  8595. }
  8596.  
  8597. static void
  8598. fe_general_preferences_set(MWContext* context,
  8599.                         fe_EditorGeneralPreferencesStruct* w_data)
  8600. {
  8601.     char* value;
  8602.     Boolean as_enable;
  8603.     unsigned as_time;
  8604.  
  8605.     /* author */
  8606.     if ((w_data->changed & EDITOR_GENERAL_AUTHOR) != 0) {
  8607.         value = fe_TextFieldGetString(w_data->author);
  8608.         fe_EditorPreferencesSetAuthor(context, value);
  8609.         XtFree(value);
  8610.     }
  8611.     
  8612.     /* editors */
  8613.     value = NULL;
  8614.     if ((w_data->changed & EDITOR_GENERAL_HTML_EDITOR) != 0) {
  8615.         value = fe_TextFieldGetString(w_data->html_editor);
  8616.         fe_EditorPreferencesSetEditors(context, value, NULL);
  8617.         XtFree(value);
  8618.     }
  8619.  
  8620.     if ((w_data->changed & EDITOR_GENERAL_IMAGE_EDITOR) != 0) {
  8621.         value = fe_TextFieldGetString(w_data->image_editor);
  8622.         fe_EditorPreferencesSetEditors(context, NULL, value);
  8623.         XtFree(value);
  8624.     }
  8625.  
  8626.     /* template */
  8627.     if ((w_data->changed & EDITOR_GENERAL_TEMPLATE) != 0) {
  8628.         value = fe_TextFieldGetString(w_data->template);
  8629.         fe_EditorPreferencesSetTemplate(context, value);
  8630.         XtFree(value);
  8631.     }
  8632.  
  8633.     /* autosave */
  8634.     if ((w_data->changed & EDITOR_GENERAL_AUTOSAVE) != 0) {
  8635.         as_time = fe_get_numeric_text_field(w_data->autosave_text);
  8636.         as_enable = XmToggleButtonGadgetGetState(w_data->autosave_toggle);
  8637.         fe_EditorPreferencesSetAutoSave(context, as_enable, as_time);
  8638.     }
  8639.  
  8640.     w_data->changed = 0;
  8641. }
  8642.  
  8643. static Widget
  8644. fe_general_preferences_create(MWContext* context, Widget parent,
  8645.                              fe_EditorGeneralPreferencesStruct* w_data)
  8646. {
  8647.     Widget main_rc;
  8648.     Widget author_frame;
  8649.     Widget author_text;
  8650.     Widget external_frame;
  8651.     Widget external_form;
  8652.     Widget html_label;
  8653.     Widget html_text;
  8654.     Widget html_browse;
  8655.     Widget image_label;
  8656.     Widget image_text;
  8657.     Widget image_browse;
  8658.     Widget template_frame;
  8659.     Widget template_form;
  8660.     Widget template_label;
  8661.     Widget template_text;
  8662.     Widget template_info_label;
  8663.     Widget template_restore;
  8664.     Widget autosave_frame;
  8665.     Widget autosave_form;
  8666.     Widget autosave_toggle;
  8667.     Widget autosave_text;
  8668.     Widget autosave_label;
  8669.     Widget children[8];
  8670.     Cardinal nchildren;
  8671.     Dimension left_offset;
  8672.     Dimension right_offset;
  8673.     Arg    args[8];
  8674.     Cardinal n;
  8675.     Cardinal i;
  8676.  
  8677.     n = 0;
  8678.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  8679.     main_rc = XmCreateRowColumn(parent, "general", args, n);
  8680.     XtManageChild(main_rc);
  8681.  
  8682.     n = 0;
  8683.     author_frame = fe_CreateFrame(main_rc, "author", args, n);
  8684.     XtManageChild(author_frame);
  8685.  
  8686.     n = 0;
  8687.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_AUTHOR); n++;
  8688.     author_text = fe_CreateTextField(author_frame, "authorText", args, n);
  8689.     XtManageChild(author_text);
  8690.     w_data->author = author_text;
  8691.  
  8692.     XtAddCallback(author_text, XmNvalueChangedCallback,
  8693.                   fe_general_preferences_changed_cb, (XtPointer)w_data);
  8694.  
  8695.     n = 0;
  8696.     external_frame = fe_CreateFrame(main_rc, "external", args, n);
  8697.     XtManageChild(external_frame);
  8698.  
  8699.     n = 0;
  8700.     external_form = XmCreateForm(external_frame, "external", args, n);
  8701.     XtManageChild(external_form);
  8702.  
  8703.     nchildren = 0;
  8704.     n = 0;
  8705.     html_label = XmCreateLabelGadget(external_form, "htmlLabel", args, n);
  8706.     children[nchildren++] = html_label;
  8707.  
  8708.     n = 0;
  8709.     image_label = XmCreateLabelGadget(external_form, "imageLabel", args, n);
  8710.     children[nchildren++] = image_label;
  8711.  
  8712.     left_offset = fe_get_offset_from_widest(children, nchildren);
  8713.  
  8714.     n = 0;
  8715.     html_browse = XmCreatePushButtonGadget(external_form, "browse", args, n);
  8716.     children[nchildren++] = html_browse;
  8717.  
  8718.     n = 0;
  8719.     image_browse = XmCreatePushButtonGadget(external_form, "browse", args, n);
  8720.     children[nchildren++] = image_browse;
  8721.  
  8722.     right_offset = fe_get_offset_from_widest(&children[2], 2);
  8723.  
  8724.     n = 0;
  8725.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8726.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8727.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  8728.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8729.     XtSetArg(args[n], XmNrightOffset, right_offset); n++;
  8730.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_HTML_EDITOR); n++;
  8731.     html_text = fe_CreateTextField(external_form, "htmlText", args, n);
  8732.     children[nchildren++] = html_text;
  8733.     w_data->html_editor = html_text;
  8734.  
  8735.     XtAddCallback(html_text, XmNvalueChangedCallback,
  8736.                   fe_general_preferences_changed_cb, (XtPointer)w_data);
  8737.  
  8738.     n = 0;
  8739.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8740.     XtSetArg(args[n], XmNtopWidget, html_text); n++;
  8741.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8742.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  8743.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8744.     XtSetArg(args[n], XmNrightOffset, right_offset); n++;
  8745.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_IMAGE_EDITOR); n++;
  8746.     image_text = fe_CreateTextField(external_form, "imageText", args, n);
  8747.     children[nchildren++] = image_text;
  8748.     w_data->image_editor = image_text;
  8749.  
  8750.     XtAddCallback(image_text, XmNvalueChangedCallback,
  8751.                   fe_general_preferences_changed_cb, (XtPointer)w_data);
  8752.  
  8753.     /*
  8754.      *    Go back for browse callbacks
  8755.      */
  8756.     XtVaSetValues(image_browse, XmNuserData, image_text, 0);
  8757.     XtAddCallback(image_browse, XmNactivateCallback,
  8758.                   fe_browse_to_text_field_cb, (XtPointer)context);
  8759.  
  8760.     XtVaSetValues(html_browse, XmNuserData, html_text, 0);
  8761.     XtAddCallback(html_browse, XmNactivateCallback,
  8762.                   fe_browse_to_text_field_cb, (XtPointer)context);
  8763.  
  8764.  
  8765.     /*
  8766.      *    Go back and attach the labels and browse buttons.
  8767.      */
  8768.     for (i = 0; i < 4; i++) {
  8769.       n = 0;
  8770.       if ((i & 0x1) == 0) { /* even, therefore topmost of pair */
  8771.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8772.       } else {
  8773.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8774.         XtSetArg(args[n], XmNtopWidget, html_text); n++;
  8775.       }
  8776.  
  8777.       if (i < 2) { /* label, attach to left */
  8778.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8779.       } else { /* button, attach to right */
  8780.         XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8781.       }
  8782.       XtSetValues(children[i], args, n);
  8783.     }
  8784.  
  8785.     XtManageChildren(children, nchildren);
  8786.  
  8787.     n = 0;
  8788.     template_frame = fe_CreateFrame(main_rc, "template", args, n);
  8789.     XtManageChild(template_frame);
  8790.  
  8791.     n = 0;
  8792.     template_form = XmCreateForm(template_frame, "template", args, n);
  8793.     XtManageChild(template_form);
  8794.  
  8795.     nchildren = 0;
  8796.     n = 0;
  8797.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8798.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8799.     template_label = XmCreateLabelGadget(template_form, "locationLabel",
  8800.                                          args, n);
  8801.     children[nchildren++] = template_label;
  8802.  
  8803.     n = 0;
  8804.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8805.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  8806.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8807.     XtSetArg(args[n], XmNleftWidget, template_label); n++;
  8808.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_TEMPLATE); n++;
  8809.     template_text = fe_CreateTextField(template_form, "templateText", args, n);
  8810.     children[nchildren++] = template_text;
  8811.     w_data->template = template_text;
  8812.  
  8813.     XtAddCallback(template_text, XmNvalueChangedCallback,
  8814.                   fe_general_preferences_changed_cb, (XtPointer)w_data);
  8815.  
  8816.     n = 0;
  8817.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8818.     XtSetArg(args[n], XmNtopWidget, template_text); n++;
  8819.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  8820.     template_restore = XmCreatePushButtonGadget(template_form,
  8821.                                                 "restoreDefault", args, n);
  8822.     children[nchildren++] = template_restore;
  8823.  
  8824.     n = 0;
  8825.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  8826.     XtSetArg(args[n], XmNtopWidget, template_text); n++;
  8827.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8828.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  8829.     XtSetArg(args[n], XmNrightWidget, template_restore); n++;
  8830.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  8831.     template_info_label = XmCreateLabelGadget(template_form, "templateInfo",
  8832.                                          args, n);
  8833.     children[nchildren++] = template_info_label;
  8834.  
  8835.     XtAddCallback(template_restore, XmNactivateCallback,
  8836.                   fe_general_preferences_restore_template_cb,
  8837.                   (XtPointer)w_data);
  8838.  
  8839.     XtManageChildren(children, nchildren);
  8840.  
  8841.     /*
  8842.      *    Auto Save.
  8843.      */
  8844.     n = 0;
  8845.     autosave_frame = fe_CreateFrame(main_rc, "autosave", args, n);
  8846.     XtManageChild(autosave_frame);
  8847.  
  8848.     n = 0;
  8849.     autosave_form = XmCreateForm(autosave_frame, "autosave", args, n);
  8850.     XtManageChild(autosave_form);
  8851.  
  8852.     nchildren = 0;
  8853.     n = 0;
  8854.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8855.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  8856.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  8857.     autosave_toggle = XmCreateToggleButtonGadget(autosave_form, 
  8858.                                                  "autosaveEnable", args, n);
  8859.     children[nchildren++] = autosave_toggle;
  8860.  
  8861.     XtAddCallback(autosave_toggle, XmNvalueChangedCallback,
  8862.                   fe_general_preferences_autosave_toggle_cb,
  8863.                   (XtPointer)w_data);
  8864.     w_data->autosave_toggle = autosave_toggle;
  8865.  
  8866.     n = 0;
  8867.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8868.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  8869.     XtSetArg(args[n], XmNleftWidget, autosave_toggle); n++;
  8870.     XtSetArg(args[n], XmNcolumns, 4); n++;
  8871.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_AUTOSAVE); n++;
  8872.     autosave_text = fe_CreateTextField(autosave_form, "autosaveText", args, n);
  8873.     children[nchildren++] = autosave_text;
  8874.  
  8875.     XtAddCallback(autosave_text, XmNvalueChangedCallback,
  8876.                   fe_general_preferences_changed_cb,
  8877.                   (XtPointer)w_data);
  8878.     w_data->autosave_text = autosave_text;
  8879.  
  8880.     n = 0;
  8881.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  8882.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  8883.     XtSetArg(args[n], XmNleftWidget, autosave_text); n++;
  8884.     autosave_label = XmCreateLabelGadget(autosave_form,    "minutes", args, n);
  8885.     children[nchildren++] = autosave_label;
  8886.  
  8887.     XtManageChildren(children, nchildren);
  8888.     
  8889.     return main_rc;
  8890. }
  8891.  
  8892. typedef struct fe_EditorPublishPreferencesStruct
  8893. {
  8894.     Widget maintain_links;
  8895.     Widget keep_images;
  8896.     Widget publish_text;
  8897.     Widget browse_text;
  8898.     Widget username_text;
  8899.     Widget password_text;
  8900.     Widget save_password;
  8901.     unsigned changed;
  8902. } fe_EditorPublishPreferencesStruct;
  8903.  
  8904. #define EDITOR_PUBLISH_LINKS           (0x1<<0)
  8905. #define EDITOR_PUBLISH_IMAGES          (0x1<<1)
  8906. #define EDITOR_PUBLISH_PUBLISH         (0x1<<2)
  8907. #define EDITOR_PUBLISH_BROWSE          (0x1<<3)
  8908. #define EDITOR_PUBLISH_USERNAME        (0x1<<4)
  8909. #define EDITOR_PUBLISH_PASSWORD        (0x1<<5)
  8910. #define EDITOR_PUBLISH_PASSWORD_SAVE   (0x1<<6)
  8911.  
  8912. static void
  8913. fe_publish_page_changed(Widget widget, XtPointer closure, XtPointer cb)
  8914. {
  8915.     fe_EditorPublishPreferencesStruct* w_data = 
  8916.         (fe_EditorPublishPreferencesStruct*)closure;
  8917.  
  8918.     w_data->changed |= (unsigned)fe_GetUserData(widget);
  8919. }
  8920.  
  8921. static void
  8922. fe_publish_password_changed(Widget widget, XtPointer closure, XtPointer cb)
  8923. {
  8924.     fe_EditorPublishPreferencesStruct* w_data = 
  8925.         (fe_EditorPublishPreferencesStruct*)closure;
  8926.  
  8927.     w_data->changed |= EDITOR_PUBLISH_PASSWORD;
  8928. }
  8929.  
  8930. static void
  8931. fe_publish_preferences_set(MWContext* context,
  8932.                            fe_EditorPublishPreferencesStruct* w_data)
  8933. {
  8934.     char* location = NULL;
  8935.     char* browse_location = NULL;
  8936.     char* username = NULL;
  8937.     char* password = NULL;
  8938.     Boolean new_links;
  8939.     Boolean new_images;
  8940.     Boolean old_links;
  8941.     Boolean old_images;
  8942.  
  8943.     new_links = XmToggleButtonGetState(w_data->maintain_links);
  8944.     new_images = XmToggleButtonGetState(w_data->keep_images);
  8945.  
  8946.     fe_EditorPreferencesGetLinksAndImages(context, &old_links, &old_images);
  8947.  
  8948.     if (new_links != old_links || new_images != old_images) {
  8949.         fe_EditorPreferencesSetLinksAndImages(context, new_links, new_images);
  8950.     }
  8951.  
  8952. #ifdef _SECURITY_BTN_ON_PREFS
  8953.  
  8954.     /* don't need save password in prefs anymore - benjie */
  8955.     new_save_password = XmToggleButtonGetState(w_data->save_password); 
  8956.  
  8957.     old_save_password = fe_EditorPreferencesGetPublishLocation(context, 
  8958.                                                                NULL, NULL, 
  8959.                                                                NULL);
  8960. #endif
  8961.  
  8962. #define PUBLISH_MASK (EDITOR_PUBLISH_PUBLISH|  \
  8963.                       EDITOR_PUBLISH_BROWSE| \
  8964.                       EDITOR_PUBLISH_USERNAME| \
  8965.                       EDITOR_PUBLISH_PASSWORD|EDITOR_PUBLISH_PASSWORD_SAVE)
  8966.  
  8967. #ifdef _SECURITY_BTN_ON_PREFS        
  8968.     if (new_save_password != old_save_password || 
  8969.         (w_data->changed & PUBLISH_MASK) != 0) { 
  8970. #else
  8971.     if ((w_data->changed & PUBLISH_MASK) != 0) { 
  8972. #endif
  8973.         location = fe_TextFieldGetString(w_data->publish_text);
  8974.         browse_location = fe_TextFieldGetString(w_data->browse_text);
  8975.         username = fe_TextFieldGetString(w_data->username_text);
  8976.         password = fe_GetPasswdText(w_data->password_text);
  8977.         
  8978.         fe_EditorPreferencesSetPublishLocation(context,
  8979.                                                location,
  8980.                                                username,
  8981.                                                password);
  8982. /*
  8983.                                                new_save_password? password: 0);
  8984. */
  8985.         fe_EditorPreferencesSetBrowseLocation(context, browse_location);
  8986.     }
  8987. #undef PUBLISH_MASK
  8988.     if (browse_location) {
  8989.         XtFree(browse_location);
  8990.     }
  8991.     if (location) {
  8992.         XtFree(location);
  8993.     }
  8994.     if (username) {
  8995.         XtFree(username);
  8996.     }
  8997.     if (password) {
  8998.         memset(password, 0, strlen(password));
  8999.         XtFree(password);
  9000.     }
  9001. }
  9002.  
  9003.  
  9004. static void
  9005. fe_publish_preferences_init(MWContext* context,
  9006.                             fe_EditorPublishPreferencesStruct* w_data)
  9007. {
  9008.     char* location;
  9009.     char* browse_location;
  9010.     char* username;
  9011.     char* password;
  9012.     Boolean links;
  9013.     Boolean images;
  9014.     Boolean save_password;
  9015.  
  9016.     fe_EditorPreferencesGetLinksAndImages(context, &links, &images);
  9017.  
  9018.     save_password = fe_EditorPreferencesGetPublishLocation(context,
  9019.                                                            &location,
  9020.                                                            &username,
  9021.                                                            &password);
  9022.  
  9023.     browse_location = fe_EditorPreferencesGetBrowseLocation(context);
  9024.  
  9025.     XmToggleButtonSetState(w_data->maintain_links, links, FALSE);
  9026.     XmToggleButtonSetState(w_data->keep_images, images, FALSE);
  9027.     /*XmToggleButtonSetState(w_data->save_password, save_password, FALSE);*/
  9028.  
  9029.     if (location) {
  9030.         fe_TextFieldSetString(w_data->publish_text, location, FALSE);
  9031.  
  9032.         if (username)
  9033.             fe_TextFieldSetString(w_data->username_text, username, FALSE);
  9034.         else
  9035.             fe_TextFieldSetString(w_data->username_text, "", FALSE);
  9036.  
  9037.         if (password)
  9038.             fe_TextFieldSetString(w_data->password_text, password, FALSE);
  9039.         else
  9040.             fe_TextFieldSetString(w_data->password_text, "", FALSE);
  9041.  
  9042.     }
  9043.  
  9044.     if (browse_location)
  9045.         fe_TextFieldSetString(w_data->browse_text, browse_location, FALSE);
  9046.     else
  9047.         fe_TextFieldSetString(w_data->browse_text, "", FALSE);
  9048.  
  9049.     if (browse_location) {
  9050.         XtFree(browse_location);
  9051.     }
  9052.     if (location) {
  9053.         XtFree(location);
  9054.     }
  9055.     if (username) {
  9056.         XtFree(username);
  9057.     }
  9058.     if (password) {
  9059.         memset(password, 0, strlen(password));
  9060.         XtFree(password);
  9061.     }
  9062. }
  9063.  
  9064. static Widget
  9065. fe_publish_preferences_create(MWContext* context, Widget parent,
  9066.                               fe_EditorPublishPreferencesStruct* w_data)
  9067. {
  9068.     Widget main_rc;
  9069.  
  9070.     Widget links_frame;
  9071.     Widget links_main_rc;
  9072.     Widget links_main_info;
  9073.     Widget links_sub_rc;
  9074.     Widget links_toggle;
  9075.     Widget links_info;
  9076.     Widget images_toggle;
  9077.     Widget images_info;
  9078.     Widget links_main_tip;
  9079.  
  9080.     Widget publish_frame;
  9081.     Widget publish_form;
  9082.     Widget publish_label;
  9083.     Widget publish_text;
  9084.     Widget browse_label;
  9085.     Widget browse_text;
  9086.     Widget username_label;
  9087.     Widget username_text;
  9088.     Widget password_label;
  9089.     Widget password_text;
  9090.     Widget children[16];
  9091.     Cardinal nchildren;
  9092.     Dimension left_offset;
  9093.     Arg    args[16];
  9094.     Cardinal n;
  9095.  
  9096.     n = 0;
  9097.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  9098.     main_rc = XmCreateRowColumn(parent, "publish", args, n);
  9099.     XtManageChild(main_rc);
  9100.  
  9101.     n = 0;
  9102.     links_frame = fe_CreateFrame(main_rc, "linksAndImages", args, n);
  9103.     XtManageChild(links_frame);
  9104.  
  9105.     n = 0;
  9106.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  9107.     links_main_rc = XmCreateRowColumn(links_frame, "linksAndImages", args, n);
  9108.     XtManageChild(links_main_rc);
  9109.  
  9110.     nchildren = 0;
  9111.     n = 0;
  9112.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9113.     links_main_info = XmCreateLabelGadget(links_main_rc, "linksAndImagesLabel",
  9114.                                           args, n);
  9115.     children[nchildren++] = links_main_info;
  9116.  
  9117.     n = 0;
  9118.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  9119.     XtSetArg(args[n], XmNisAligned, TRUE); n++;
  9120.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  9121.     links_sub_rc = XmCreateRowColumn(links_main_rc, "linksAndImagesToggles",
  9122.                                      args, n);
  9123.     children[nchildren++] = links_sub_rc;
  9124.  
  9125.     n = 0;
  9126.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9127.     links_main_tip = XmCreateLabelGadget(links_main_rc, "linksAndImagesTip",
  9128.                                           args, n);
  9129.     children[nchildren++] = links_main_tip;
  9130.  
  9131.     XtManageChildren(children, nchildren);
  9132.  
  9133.     nchildren = 0;
  9134.     n = 0;
  9135.     links_toggle = XmCreateToggleButtonGadget(links_sub_rc, "linksToggle",
  9136.                                           args, n);
  9137.     children[nchildren++] = links_toggle;
  9138.  
  9139.     n = 0;
  9140.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9141.     links_info = XmCreateLabelGadget(links_sub_rc, "linksInfo", args, n);
  9142.     children[nchildren++] = links_info;
  9143.  
  9144.     n = 0;
  9145.     images_toggle = XmCreateToggleButtonGadget(links_sub_rc, "imagesToggle",
  9146.                                           args, n);
  9147.     children[nchildren++] = images_toggle;
  9148.  
  9149.     n = 0;
  9150.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9151.     images_info = XmCreateLabelGadget(links_sub_rc, "imagesInfo", args, n);
  9152.     children[nchildren++] = images_info;
  9153.  
  9154.     XtManageChildren(children, nchildren);
  9155.  
  9156.     n = 0;
  9157.     publish_frame = fe_CreateFrame(main_rc, "publish", args, n);
  9158.     XtManageChild(publish_frame);
  9159.  
  9160.     n = 0;
  9161.     publish_form = XmCreateForm(publish_frame, "publish", args, n);
  9162.     XtManageChild(publish_form);
  9163.  
  9164.     nchildren = 0;
  9165.     n = 0;
  9166.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  9167.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9168.     publish_label = XmCreateLabelGadget(publish_form, "publishLabel", args, n);
  9169.     children[nchildren++] = publish_label;
  9170.  
  9171.     n = 0;
  9172.     browse_label = XmCreateLabelGadget(publish_form, "browseLabel", args, n);
  9173.     children[nchildren++] = browse_label;
  9174.  
  9175.     left_offset = fe_get_offset_from_widest(children, 2);
  9176.  
  9177.     n = 0;
  9178.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  9179.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9180.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  9181.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  9182.     XtSetArg(args[n], XmNuserData, EDITOR_PUBLISH_PUBLISH); n++;
  9183.     publish_text = fe_CreateTextField(publish_form, "publishText", args, n);
  9184.     children[nchildren++] = publish_text;
  9185.     
  9186.     n = 0;
  9187.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9188.     XtSetArg(args[n], XmNtopWidget, publish_text); n++;
  9189.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9190.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  9191.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  9192.     XtSetArg(args[n], XmNuserData, EDITOR_PUBLISH_BROWSE); n++;
  9193.     browse_text = fe_CreateTextField(publish_form, "browseText", args, n);
  9194.     children[nchildren++] = browse_text;
  9195.  
  9196.     /*
  9197.      *    Go back for browse label attachments.
  9198.      */
  9199.     n = 0;
  9200.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9201.     XtSetArg(args[n], XmNtopWidget, publish_text); n++;
  9202.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9203.     XtSetValues(browse_label, args, n);
  9204.  
  9205.     n = 0;
  9206.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9207.     XtSetArg(args[n], XmNtopWidget, browse_text); n++;
  9208.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9209.     username_label = XmCreateLabelGadget(publish_form, "usernameLabel",
  9210.                                          args, n);
  9211.     children[nchildren++] = username_label;
  9212.  
  9213.     n = 0;
  9214.     password_label = XmCreateLabelGadget(publish_form, "passwordLabel",
  9215.                                          args, n);
  9216.     children[nchildren++] = password_label;
  9217.  
  9218.     left_offset = fe_get_offset_from_widest(&children[4], 2);
  9219.  
  9220.     n = 0;
  9221.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9222.     XtSetArg(args[n], XmNtopWidget, browse_text); n++;
  9223.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9224.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  9225.     XtSetArg(args[n], XmNuserData, EDITOR_PUBLISH_USERNAME); n++;
  9226.     username_text = fe_CreateTextField(publish_form, "usernameText", args, n);
  9227.     children[nchildren++] = username_text;
  9228.     
  9229.     n = 0;
  9230.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9231.     XtSetArg(args[n], XmNtopWidget, username_text); n++;
  9232.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9233.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  9234.     XtSetArg(args[n], XmNmaxLength, 1024); n++;
  9235.     password_text = fe_CreatePasswordField(publish_form, "passwordText",
  9236.                                            args, n);
  9237.     children[nchildren++] = password_text;
  9238.  
  9239.     n = 0;
  9240.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9241.     XtSetArg(args[n], XmNtopWidget, username_text); n++;
  9242.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  9243.     XtSetValues(password_label, args, n);
  9244.  
  9245.     /* we don't need this anymore - benjie */
  9246.     /* according to the bugsplat */
  9247. #ifdef _SECURITY_BTN_ON_PREFS
  9248.     n = 0;
  9249.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  9250.     XtSetArg(args[n], XmNtopWidget, username_text); n++;
  9251.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  9252.     XtSetArg(args[n], XmNleftWidget, password_text); n++;
  9253.     password_save = XmCreateToggleButtonGadget(publish_form, "savePassword",
  9254.                                           args, n);
  9255.     children[nchildren++] = password_save;
  9256. #endif
  9257.  
  9258.     XtManageChildren(children, nchildren);
  9259.  
  9260.     w_data->maintain_links = links_toggle;
  9261.     w_data->keep_images = images_toggle;
  9262.     w_data->publish_text = publish_text;
  9263.     w_data->browse_text = browse_text;
  9264.     w_data->username_text = username_text;
  9265.     w_data->password_text = password_text;
  9266. #ifdef _SECURITY_BTN_ON_PREFS
  9267.     w_data->save_password = password_save; 
  9268. #endif
  9269.  
  9270.     XtVaSetValues(links_toggle, XmNuserData, EDITOR_PUBLISH_LINKS, 0);
  9271.     XtAddCallback(links_toggle, XmNvalueChangedCallback,
  9272.                   fe_publish_page_changed, (XtPointer)w_data);
  9273.     XtVaSetValues(images_toggle, XmNuserData, EDITOR_PUBLISH_IMAGES, 0);
  9274.     XtAddCallback(images_toggle, XmNvalueChangedCallback,
  9275.                   fe_publish_page_changed, (XtPointer)w_data);
  9276.     XtVaSetValues(publish_text, XmNuserData, EDITOR_PUBLISH_PUBLISH, 0);
  9277.     XtAddCallback(publish_text, XmNvalueChangedCallback,
  9278.                   fe_publish_page_changed, (XtPointer)w_data);
  9279.     XtVaSetValues(browse_text, XmNuserData, EDITOR_PUBLISH_BROWSE, 0);
  9280.     XtAddCallback(browse_text, XmNvalueChangedCallback,
  9281.                   fe_publish_page_changed, (XtPointer)w_data);
  9282.     XtVaSetValues(username_text, XmNuserData, EDITOR_PUBLISH_USERNAME, 0);
  9283.     XtAddCallback(username_text, XmNvalueChangedCallback,
  9284.                   fe_publish_page_changed, (XtPointer)w_data);
  9285.  
  9286.     XtAddCallback(password_text, XmNvalueChangedCallback,
  9287.                   fe_publish_password_changed, (XtPointer)w_data);
  9288. #ifdef _SECURITY_BTN_ON_PREFS
  9289.     XtVaSetValues(password_save, XmNuserData, EDITOR_PUBLISH_PASSWORD_SAVE, 0);
  9290.     XtAddCallback(password_save, XmNvalueChangedCallback,
  9291.                   fe_publish_page_changed, (XtPointer)w_data);
  9292. #endif
  9293.  
  9294.     return main_rc;
  9295. }
  9296.  
  9297. typedef struct fe_EditorPreferencesStruct
  9298. {
  9299.   fe_EditorGeneralPreferencesStruct*           general;
  9300.   fe_EditorDocumentAppearancePropertiesStruct* appearance;
  9301.   fe_EditorPublishPreferencesStruct*           publish;
  9302. } fe_EditorPreferencesStruct;
  9303.  
  9304.  
  9305. static Widget
  9306. fe_editor_preferences_dialog_create(MWContext* context,
  9307.                                   fe_EditorPreferencesStruct* p_data)
  9308. {
  9309.     Widget   dialog;
  9310.     Widget   form;
  9311.     Widget   tab_form;
  9312.     char*    name = "editorPreferencesDialog";
  9313.     
  9314.     /*
  9315.      *    Make prompt with ok, apply, cancel, no separator.
  9316.      */
  9317.     dialog = fe_CreatePromptDialog(context, name,
  9318.                                    TRUE, TRUE, TRUE, FALSE, TRUE);
  9319.  
  9320.     form = XtVaCreateManagedWidget(
  9321.                                    "folder",
  9322.                                    xmlFolderWidgetClass, dialog,
  9323.                                    XmNshadowThickness, 2,
  9324.                                    XmNtopAttachment, XmATTACH_FORM,
  9325.                                    XmNleftAttachment, XmATTACH_FORM,
  9326.                                    XmNrightAttachment, XmATTACH_FORM,
  9327.                                    XmNbottomAttachment, XmATTACH_FORM,
  9328. #ifdef ALLOW_TAB_ROTATE
  9329.                                    XmNtabPlacement, XmFOLDER_LEFT,
  9330.                                    XmNrotateWhenLeftRight, FALSE,
  9331. #endif /* ALLOW_TAB_ROTATE */
  9332.                                    XmNbottomOffset, 3,
  9333.                                    XmNspacing, 1,
  9334.                                    NULL);
  9335.  
  9336.     tab_form = fe_CreateTabForm(form, "appearanceProperties", NULL, 0);
  9337.     fe_document_appearance_create(context, tab_form, p_data->appearance);
  9338.     
  9339.     tab_form = fe_CreateTabForm(form, "generalPreferences", NULL, 0);
  9340.     fe_general_preferences_create(context, tab_form, p_data->general);
  9341.  
  9342.     tab_form = fe_CreateTabForm(form, "publishPreferences", NULL, 0);
  9343.     fe_publish_preferences_create(context, tab_form, p_data->publish);
  9344.  
  9345.     XtManageChild(dialog);
  9346.  
  9347.     return form;
  9348. }
  9349.  
  9350. void
  9351. fe_EditorPreferencesDialogDo(MWContext* context, unsigned tab_type)
  9352. {
  9353.     fe_EditorPreferencesStruct properties;
  9354.     fe_EditorDocumentAppearancePropertiesStruct appearance;
  9355.     fe_EditorGeneralPreferencesStruct general;
  9356.     fe_EditorPublishPreferencesStruct publish;
  9357.     int done;
  9358.     Widget dialog;
  9359.     Widget form;
  9360.     Widget apply_button;
  9361.     Boolean apply_sensitized;
  9362.     unsigned tab_number;
  9363.  
  9364.     /*
  9365.      *    Pick the tab.
  9366.      */
  9367.     tab_number = tab_type - 1;
  9368.  
  9369.     memset(&properties, 0, sizeof(fe_EditorPreferencesStruct));
  9370.     memset(&appearance, 0,
  9371.            sizeof(fe_EditorDocumentAppearancePropertiesStruct));
  9372.     memset(&general, 0, sizeof(fe_EditorGeneralPreferencesStruct));
  9373.     memset(&publish, 0, sizeof(fe_EditorPublishPreferencesStruct));
  9374.  
  9375.     properties.appearance = &appearance;
  9376.     properties.general = &general;
  9377.     properties.publish = &publish;
  9378.  
  9379.     form = fe_editor_preferences_dialog_create(context, &properties);
  9380.     dialog = XtParent(form);
  9381.  
  9382.     appearance.is_editor_preferences = TRUE;
  9383.     fe_document_appearance_init(context, &appearance);
  9384.     fe_general_preferences_init(context, &general);
  9385.     fe_publish_preferences_init(context, &publish);
  9386.  
  9387.     /*
  9388.      *   Add a bunch of callbacks to the buttons.
  9389.      */
  9390.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  9391.     XtAddCallback(dialog, XmNapplyCallback, fe_hrule_apply_cb, &done);
  9392.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  9393.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  9394.  
  9395.     /*
  9396.      *    We toggle the sensitivity of the apply button on/off
  9397.      *    depending if there are changes to apply. It would be
  9398.      *    nice to use the depdency meahcnism, but it might get
  9399.      *    very busy.
  9400.      */
  9401.     apply_button = XmSelectionBoxGetChild(dialog, XmDIALOG_APPLY_BUTTON);
  9402.     XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  9403.     apply_sensitized = FALSE;
  9404.  
  9405.     /*
  9406.      *    Popup.
  9407.      */
  9408.     XtManageChild(form);
  9409.  
  9410.     XmLFolderSetActiveTab(form, tab_number, True);
  9411.  
  9412.     /*
  9413.      *    Wait.
  9414.      */
  9415.     fe_NukeBackingStore(dialog); /* what does this do? */
  9416.  
  9417.     done = XmDIALOG_NONE;
  9418.     while (done == XmDIALOG_NONE) {
  9419.  
  9420.         fe_EventLoop();
  9421.  
  9422.         if (done == XFE_DIALOG_DESTROY_BUTTON||done == XmDIALOG_CANCEL_BUTTON)
  9423.             break;
  9424.  
  9425. #define SOMETHING_CHANGED() \
  9426. (appearance.changed != 0 || general.changed != 0 || publish.changed != 0)
  9427.  
  9428.         if (SOMETHING_CHANGED() && apply_sensitized == FALSE) {
  9429.             XtVaSetValues(apply_button, XmNsensitive, TRUE, 0);
  9430.             apply_sensitized = TRUE;
  9431.         }
  9432.  
  9433.         if (done == XmDIALOG_APPLY_BUTTON || done == XmDIALOG_OK_BUTTON) {
  9434.             /* apply */
  9435.  
  9436.             if (SOMETHING_CHANGED()) {
  9437.  
  9438.                 if (!fe_general_preferences_validate(context, &general)) {
  9439.                     done = XmDIALOG_NONE;
  9440.                     continue; /* you are not going anywhere buddy */
  9441.                 }
  9442.                 
  9443.                 EDT_BeginBatchChanges(context);
  9444.  
  9445.                 if (appearance.changed != 0) {
  9446.                     fe_document_appearance_set(context, &appearance);
  9447.                     appearance.changed = 0;
  9448.                 }
  9449.                 if (general.changed != 0) {
  9450.                     fe_general_preferences_set(context, &general);
  9451.                     general.changed = 0;
  9452.                 }
  9453.                 if (publish.changed != 0) {
  9454.                     fe_publish_preferences_set(context, &publish);
  9455.                     publish.changed = 0;
  9456.                 }
  9457.  
  9458.                 EDT_EndBatchChanges(context);
  9459.  
  9460.                 /*
  9461.                  *    Save options.
  9462.                  */
  9463.                 if (!XFE_SavePrefs((char *)fe_globalData.user_prefs_file,
  9464.                                    &fe_globalPrefs)) {
  9465.                     fe_perror(context, XP_GetString(XFE_ERROR_SAVING_OPTIONS));
  9466.                 } else {
  9467.                     appearance.changed = 0;
  9468.                     general.changed = 0;
  9469.                     publish.changed = 0;
  9470.                 }
  9471.             }
  9472.  
  9473.             if (done == XmDIALOG_APPLY_BUTTON) {
  9474.                 done = XmDIALOG_NONE; /* keep looping */
  9475.  
  9476.                 XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  9477.                 apply_sensitized = FALSE;
  9478.             }
  9479.         }
  9480.     }
  9481. #undef SOMETHING_CHANGED
  9482.  
  9483.     /*
  9484.      *    Unload data.
  9485.      */
  9486.     fe_DependentListDestroy(appearance.dependents);
  9487.  
  9488.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  9489.         XtDestroyWidget(dialog);
  9490. }
  9491.  
  9492. typedef struct fe_EditorTargetPropertiesStruct
  9493. {
  9494.     Widget   text;
  9495.     Boolean  inserting;
  9496. } fe_EditorTargetPropertiesStruct;
  9497.  
  9498. static char*
  9499. cleanup_selection(char* target, char* source, unsigned max_size)
  9500. {
  9501.     char* p;
  9502.     char* q;
  9503.     char* end;
  9504.  
  9505.     for (p = source; isspace(*p); p++) /* skip beginning whitespace */
  9506.         ;
  9507.  
  9508.     end = &p[max_size-1];
  9509.     q = target;
  9510.  
  9511.     while (p < end) {
  9512.         /*
  9513.          *    Stop if we detect an unprintable, or newline.
  9514.          */
  9515.         if (!isprint(*p) || *p == '\n' || *p == '\r')
  9516.             break;
  9517.  
  9518.         if (isspace(*p))
  9519.             *q++ = ' ', p++;
  9520.         else
  9521.             *q++ = *p++;
  9522.     }
  9523.     /* strip trailing whitespace */
  9524.     while (q > target && isspace(q[-1]))
  9525.         q--;
  9526.      
  9527.     *q = '\0';
  9528.  
  9529.     return target;
  9530. }
  9531.  
  9532. static void
  9533. fe_target_properties_init(MWContext* context,
  9534.                           fe_EditorTargetPropertiesStruct* w_data)
  9535. {
  9536.     char* value;
  9537.     char buf[64];
  9538.  
  9539.     w_data->inserting = FALSE;
  9540.     
  9541.     if (EDT_GetCurrentElementType(context) == ED_ELEMENT_TARGET) {
  9542.         value = EDT_GetTargetData(context);
  9543.     } else {
  9544.         w_data->inserting = TRUE;
  9545.  
  9546.         /*
  9547.          *    Use current selected text as suggested target name...
  9548.          */
  9549.         if ((value = (char*)LO_GetSelectionText(context))) {
  9550.             cleanup_selection(buf, value, sizeof(buf));
  9551.             XP_FREE(value);
  9552.             value = buf;
  9553.         } else {
  9554.             value = "";
  9555.         }
  9556.     }
  9557.  
  9558.     /*
  9559.      *    Zap text field.
  9560.      */
  9561.     fe_TextFieldSetString(w_data->text, value, FALSE);
  9562. }
  9563.  
  9564. static char*
  9565. cleanup_string(char* target, char* source, unsigned max_size)
  9566. {
  9567.     char* p;
  9568.     char* q;
  9569.     char* end;
  9570.  
  9571.     if (max_size == 0)
  9572.         return NULL;
  9573.  
  9574.     for (p = source; isspace(*p); p++) /* skip beginning whitespace */
  9575.         ;
  9576.  
  9577.     end = &p[max_size-1];
  9578.     q = target;
  9579.  
  9580.     if (strcmp(p,"")==0) return NULL;
  9581.  
  9582.     while (p < end) {
  9583.         /*
  9584.          *    Stop if we detect an unprintable, or newline.
  9585.          */
  9586.         if (*p == '\"')
  9587.             p++;
  9588.         else
  9589.             *q++ = *p++;
  9590.     }
  9591.  
  9592.     /* strip trailing whitespace */
  9593.     while (q > target && isspace(q[-1]))
  9594.         q--;
  9595.      
  9596.     *q = '\0';
  9597.  
  9598.     return target;
  9599. }
  9600.  
  9601. static void
  9602. fe_target_properties_set(MWContext* context,
  9603.                          fe_EditorTargetPropertiesStruct* w_data)
  9604. {
  9605.  
  9606.     char* xm_value;
  9607.     char* value;
  9608.     char* target_list;
  9609.     char buf[512];
  9610.     
  9611.     xm_value = fe_TextFieldGetString(w_data->text);
  9612.  
  9613.     target_list = EDT_GetAllDocumentTargets(context);
  9614.     /*FIXME*/ /* look at this thing */
  9615.  
  9616.     value = cleanup_string(buf, xm_value, sizeof(buf));
  9617.     if (value == NULL) {
  9618.         XtFree(xm_value);
  9619.         return;
  9620.     }
  9621.         
  9622.     EDT_BeginBatchChanges(context);
  9623.     if (value[0] == '#')
  9624.         value++;
  9625.     if (w_data->inserting)
  9626.         EDT_InsertTarget(context, value);
  9627.     else
  9628.         EDT_SetTargetData(context, value);
  9629.     EDT_EndBatchChanges(context);
  9630.     
  9631.     XtFree(xm_value);
  9632. }
  9633.  
  9634. static Widget
  9635. fe_target_properties_create(MWContext* context, Widget form,
  9636.                                    fe_EditorTargetPropertiesStruct* w_data)
  9637. {
  9638.     Widget main_rc;
  9639.     Widget label;
  9640.     Widget text;
  9641.     Arg args[8];
  9642.     Cardinal n;
  9643.  
  9644.     n = 0;
  9645.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  9646.     main_rc = XmCreateRowColumn(form, "targetRC", args, n);
  9647.     XtManageChild(main_rc);
  9648.  
  9649.     n = 0;
  9650.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9651.     label = XmCreateLabelGadget(main_rc, "targetLabel", args, n);
  9652.     XtManageChild(label);
  9653.  
  9654.     n = 0;
  9655.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9656.     XtSetArg(args[n], XmNcolumns, 40); n++; /* room to move dude! */
  9657.     text = fe_CreateTextField(main_rc, "targetText", args, n);
  9658.     XtManageChild(text);
  9659.  
  9660.     w_data->text = text;
  9661.  
  9662.     return main_rc;
  9663. }
  9664.  
  9665. void
  9666. fe_EditorTargetPropertiesDialogDo(MWContext* context)
  9667. {
  9668.     Widget dialog;
  9669.     Widget form;
  9670.     fe_EditorTargetPropertiesStruct data;
  9671.     int done;
  9672.  
  9673.     /*
  9674.      *    Make prompt with ok, no apply, cancel, separator.
  9675.      */
  9676.     form = fe_CreatePromptDialog(context, "targetPropertiesDialog",
  9677.                                  TRUE, TRUE, FALSE, TRUE, TRUE);
  9678.     dialog = XtParent(form);
  9679.  
  9680.     fe_target_properties_create(context, form, &data);
  9681.     fe_target_properties_init(context, &data);
  9682.  
  9683.     /*
  9684.      *   Add a bunch of callbacks to the buttons.
  9685.      */
  9686.     XtAddCallback(form, XmNokCallback, fe_hrule_ok_cb, &done);
  9687.     XtAddCallback(form, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  9688.     XtAddCallback(form, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  9689.  
  9690.     /*
  9691.      *    Popup.
  9692.      */
  9693.     XtManageChild(form);
  9694.  
  9695.     /*
  9696.      *    Wait.
  9697.      */
  9698.     fe_NukeBackingStore(dialog); /* what does this do? */
  9699.  
  9700.     done = XmDIALOG_NONE;
  9701.     while (done == XmDIALOG_NONE)
  9702.         fe_EventLoop();
  9703.     
  9704.     if (done == XmDIALOG_OK_BUTTON)
  9705.         fe_target_properties_set(context, &data);
  9706.  
  9707.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  9708.         XtDestroyWidget(dialog);
  9709. }
  9710.  
  9711. typedef struct fe_EditorHtmlPropertiesStruct
  9712. {
  9713.     Widget   text;
  9714.     unsigned changed;
  9715.     Boolean inserting;
  9716. } fe_EditorHtmlPropertiesStruct;
  9717.  
  9718. static void
  9719. fe_html_properties_init(MWContext* context,
  9720.                           fe_EditorHtmlPropertiesStruct* w_data)
  9721. {
  9722.     char* value;
  9723.     char buf[64];
  9724.  
  9725.     w_data->inserting = FALSE;
  9726.     
  9727.     if (EDT_GetCurrentElementType(context) == ED_ELEMENT_UNKNOWN_TAG) {
  9728.         value = EDT_GetUnknownTagData(context);
  9729.     } else {
  9730.         w_data->inserting = TRUE;
  9731.  
  9732.         /*
  9733.          *    Use current selected text as suggested target name...
  9734.          */
  9735.         if ((value = (char*)LO_GetSelectionText(context))) {
  9736.             cleanup_selection(buf, value, sizeof(buf));
  9737.             XP_FREE(value);
  9738.             value = buf;
  9739.         } else {
  9740.             value = "";
  9741.         }
  9742.     }
  9743.  
  9744.     /*
  9745.      *    Zap text field.
  9746.      */
  9747.     fe_SetTextFieldAndCallBack(w_data->text, value);
  9748.     w_data->changed = 0;
  9749. }
  9750.  
  9751. static void
  9752. fe_html_properties_set(MWContext* context,
  9753.                        fe_EditorHtmlPropertiesStruct* w_data)
  9754. {
  9755.     char* xm_value;
  9756.     
  9757.     xm_value = fe_TextFieldGetString(w_data->text);
  9758.  
  9759.     EDT_BeginBatchChanges(context);
  9760.     if (EDT_GetCurrentElementType(context) == ED_ELEMENT_UNKNOWN_TAG)
  9761.         EDT_SetUnknownTagData(context, xm_value);
  9762.     else
  9763.         EDT_InsertUnknownTag(context, xm_value);
  9764.     EDT_EndBatchChanges(context);
  9765.  
  9766.     XtFree(xm_value);
  9767. }
  9768.  
  9769. Boolean
  9770. fe_html_properties_verify(MWContext* context,
  9771.                          fe_EditorHtmlPropertiesStruct* w_data)
  9772. {
  9773.     char* xm_value;
  9774.     int id = XFE_EDITOR_TAG_UNKNOWN; /* keep -O happy */
  9775.     ED_TagValidateResult e;
  9776.     Widget parent;
  9777.     
  9778.     xm_value = fe_TextFieldGetString(w_data->text);
  9779.     
  9780.     e = EDT_ValidateTag(xm_value, FALSE );
  9781.  
  9782.     switch (e) {
  9783.     case ED_TAG_OK:
  9784.         break;
  9785.     case ED_TAG_UNOPENED:
  9786.         id = XFE_EDITOR_TAG_UNOPENED;
  9787.         /* Unopened Tag: '<' was expected */
  9788.         break;
  9789.     case ED_TAG_UNCLOSED:
  9790.         id = XFE_EDITOR_TAG_UNCLOSED;
  9791.         /* Unopened Tag:  '>' was expected */
  9792.         break;
  9793.     case ED_TAG_UNTERMINATED_STRING:
  9794.         id = XFE_EDITOR_TAG_UNTERMINATED_STRING;
  9795.         /* Unterminated String in tag: closing quote expected */
  9796.         break;
  9797.     case ED_TAG_PREMATURE_CLOSE:
  9798.         id = XFE_EDITOR_TAG_PREMATURE_CLOSE;
  9799.         /* Premature close of tag */
  9800.         break;
  9801.     case ED_TAG_TAGNAME_EXPECTED:
  9802.         id = XFE_EDITOR_TAG_TAGNAME_EXPECTED;
  9803.         /* Tagname was expected */
  9804.         break;
  9805.     default:
  9806.         id = XFE_EDITOR_TAG_UNKNOWN;
  9807.         /* Unknown tag error */
  9808.         break;
  9809.     }
  9810.  
  9811.     XtFree(xm_value);
  9812.  
  9813.     parent = w_data->text;
  9814.         
  9815.     if (e == ED_TAG_OK) {
  9816.         return TRUE;
  9817.     } else {
  9818.         fe_error_dialog(context, w_data->text, XP_GetString(id));
  9819.         return FALSE;
  9820.     }
  9821. }
  9822.  
  9823. static void
  9824. fe_html_text_changed_cb(Widget widget, XtPointer closure, XtPointer cb)
  9825. {
  9826.      fe_EditorHtmlPropertiesStruct* w_data =
  9827.          (fe_EditorHtmlPropertiesStruct*)closure;
  9828.      w_data->changed = 0x1;
  9829. }
  9830.  
  9831. static Widget
  9832. fe_html_properties_create(MWContext* context, Widget form,
  9833.                                    fe_EditorHtmlPropertiesStruct* w_data)
  9834. {
  9835.     Widget main_rc;
  9836.     Widget label;
  9837.     Widget text;
  9838.     Arg args[8];
  9839.     Cardinal n;
  9840.  
  9841.     n = 0;
  9842.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  9843.     main_rc = XmCreateRowColumn(form, "htmlRC", args, n);
  9844.     XtManageChild(main_rc);
  9845.  
  9846.     n = 0;
  9847.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  9848.     label = XmCreateLabelGadget(main_rc, "htmlPropertiesInfo", args, n);
  9849.     XtManageChild(label);
  9850.  
  9851.     n = 0;
  9852.     XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
  9853.     XtSetArg(args[n], XmNcolumns, 70); n++;
  9854.     XtSetArg(args[n], XmNrows, 8); n++;
  9855.     text = XmCreateScrolledText(main_rc, "htmlText", args, n);
  9856.     fe_HackTextTranslations(text);
  9857.     XtAddCallback(text, XmNvalueChangedCallback, fe_html_text_changed_cb,
  9858.                   (XtPointer)w_data);
  9859.     XtManageChild(text);
  9860.  
  9861.     w_data->text = text;
  9862.  
  9863.     return main_rc;
  9864. }
  9865.  
  9866. void
  9867. fe_EditorHtmlPropertiesDialogDo(MWContext* context)
  9868. {
  9869.     Widget dialog;
  9870.     Widget form;
  9871.     Widget ok_button;
  9872.     fe_EditorHtmlPropertiesStruct data;
  9873.     int    done;
  9874.  
  9875.     /*
  9876.      *    Make prompt with ok, no apply, cancel, separator.
  9877.      */
  9878.     form = fe_CreatePromptDialog(context, "htmlPropertiesDialog",
  9879.                                  TRUE, TRUE, TRUE, TRUE, TRUE);
  9880.     dialog = XtParent(form);
  9881.  
  9882.     fe_html_properties_create(context, form, &data);
  9883.     fe_html_properties_init(context, &data);
  9884.  
  9885.     /*
  9886.      *   Add a bunch of callbacks to the buttons.
  9887.      */
  9888.     XtAddCallback(form, XmNokCallback, fe_hrule_ok_cb, &done);
  9889.     XtAddCallback(form, XmNapplyCallback, fe_hrule_apply_cb, &done);
  9890.     XtAddCallback(form, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  9891.     XtAddCallback(form, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  9892.  
  9893.     ok_button = XmSelectionBoxGetChild(form, XmDIALOG_OK_BUTTON);
  9894.  
  9895.     /*
  9896.      *    Popup.
  9897.      */
  9898.     XtManageChild(form);
  9899.  
  9900.     /*
  9901.      *    Wait.
  9902.      */
  9903.     fe_NukeBackingStore(dialog); /* what does this do? */
  9904.  
  9905.     done = XmDIALOG_NONE;
  9906.     while (done == XmDIALOG_NONE) {
  9907.         fe_EventLoop();
  9908.  
  9909.         if (done == XmDIALOG_APPLY_BUTTON || done == XmDIALOG_OK_BUTTON) {
  9910.             if (fe_html_properties_verify(context, &data) == FALSE) {
  9911.                 done = XmDIALOG_NONE;
  9912.             } else if (done == XmDIALOG_APPLY_BUTTON) { /* but verified */
  9913.                 /* Tag seems ok */
  9914.                 fe_message_dialog(context,
  9915.                                   dialog,
  9916.                                   XP_GetString(XFE_EDITOR_TAG_OK));
  9917.                 done = XmDIALOG_NONE;
  9918.             }
  9919.         }
  9920.     }
  9921.     
  9922.     if (done == XmDIALOG_OK_BUTTON && data.changed != 0)
  9923.         fe_html_properties_set(context, &data);
  9924.  
  9925.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  9926.         XtDestroyWidget(dialog);
  9927. }
  9928.  
  9929. char* fe_SimpleTableAlignment[3] = {
  9930.     "left",
  9931.     "center",
  9932.     "right"
  9933. };
  9934.  
  9935. char* fe_SimpleOptionAboveBelow[2] = {
  9936.     "above",
  9937.     "below"
  9938. };
  9939.  
  9940. char* fe_SimpleOptionPixelPercent[2] = {
  9941.     "pixels",
  9942.     "percent"
  9943. };
  9944.  
  9945. char* fe_SimpleOptionHorizontalAlignment[4] = {
  9946.     "default",
  9947.     "left",
  9948.     "center",
  9949.     "right"
  9950. };
  9951.  
  9952. char* fe_SimpleOptionVerticalAlignment[5] = {
  9953.     "default",
  9954.     "top",
  9955.     "center",
  9956.     "bottom",
  9957.     "baselines"
  9958. };
  9959.  
  9960. Widget
  9961. fe_CreateSimpleOptionMenu(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  9962. {
  9963.     Widget pulldown;
  9964.     Widget button;
  9965.     Widget option_menu;
  9966.     Widget history_widget = NULL;
  9967.     char namebuf[64];
  9968.     Arg args[32];
  9969.     Cardinal n;
  9970.     Cardinal i;
  9971.     char** button_names = NULL;
  9972.     unsigned button_count = 0;
  9973.     unsigned button_set = 0;
  9974.     char* button_name;
  9975.     XtCallbackRec* callback = NULL;
  9976.  
  9977.     strcpy(namebuf, name);
  9978.     strcat(namebuf, "Menu");
  9979.  
  9980.     n = 0;
  9981.     pulldown = fe_CreatePulldownMenu(parent, namebuf, args, n);
  9982.  
  9983.     n = 0;
  9984.     for (i = 0; i < p_n; i++) {
  9985.         if (p_args[i].name == XmNsimpleCallback)
  9986.             callback = (XtCallbackRec*)p_args[i].value;
  9987.         else if (p_args[i].name == XmNbuttons)
  9988.             button_names = (char**)p_args[i].value;
  9989.         else if (p_args[i].name == XmNbuttonCount)
  9990.             button_count = (unsigned)p_args[i].value;
  9991.         else if (p_args[i].name == XmNbuttonSet)
  9992.             button_set = (unsigned)p_args[i].value;
  9993.         else
  9994.             args[n++] = p_args[i];
  9995.     }
  9996.  
  9997.     if (button_names == fe_SimpleOptionAboveBelow)
  9998.         button_count = XtNumber(fe_SimpleOptionAboveBelow);
  9999.     else if (button_names == fe_SimpleOptionPixelPercent)
  10000.         button_count = XtNumber(fe_SimpleOptionPixelPercent);
  10001.     else if (button_names == fe_SimpleOptionHorizontalAlignment)
  10002.         button_count = XtNumber(fe_SimpleOptionHorizontalAlignment);
  10003.     else if (button_names == fe_SimpleOptionVerticalAlignment)
  10004.         button_count = XtNumber(fe_SimpleOptionVerticalAlignment);
  10005.  
  10006.     for (i = 0; i < button_count; i++) {
  10007.         if (button_names) {
  10008.             button_name = button_names[i];
  10009.         } else {
  10010.             sprintf(namebuf, "button%d", i);
  10011.             button_name = namebuf;
  10012.         }
  10013.         button = XmCreatePushButtonGadget(pulldown, button_name, NULL, 0);
  10014.         XtManageChild(button);
  10015.         if (i == button_set)
  10016.             history_widget = button;
  10017.  
  10018.         if (callback != NULL) {
  10019.             XtAddCallback(button, XmNactivateCallback,
  10020.                           callback->callback, callback->closure);
  10021.         }
  10022.     }
  10023.  
  10024.     XtSetArg(args[n], XmNsubMenuId, pulldown); n++;
  10025.     option_menu = fe_CreateOptionMenu(parent, name, args, n);
  10026.     fe_UnmanageChild_safe(XmOptionLabelGadget(option_menu));
  10027.  
  10028.     if (history_widget)
  10029.         XtVaSetValues(option_menu, XmNmenuHistory, history_widget, 0);
  10030.  
  10031.     return option_menu;
  10032. }
  10033.  
  10034. #endif  /* EDITOR */
  10035.  
  10036.  
  10037. #ifdef EDITOR
  10038.  
  10039. static Widget
  10040. fe_CreateSimpleRadioGroup(Widget parent, char* name, Arg* p_args, Cardinal p_n)
  10041. {
  10042.     Widget button;
  10043.     Widget option_menu;
  10044.     char namebuf[64];
  10045.     Arg args[32];
  10046.     Cardinal n;
  10047.     Cardinal i;
  10048.     char** button_names = NULL;
  10049.     unsigned button_count = 0;
  10050.     unsigned button_set = 0;
  10051.     char* button_name;
  10052.  
  10053.     strcpy(namebuf, name);
  10054.     strcat(namebuf, "Radio");
  10055.  
  10056.     n = 0;
  10057.     for (i = 0; i < p_n; i++) {
  10058.         if (p_args[i].name == XmNbuttons)
  10059.             button_names = (char**)p_args[i].value;
  10060.         else if (p_args[i].name == XmNbuttonCount)
  10061.             button_count = (unsigned)p_args[i].value;
  10062.         else if (p_args[i].name == XmNbuttonSet)
  10063.             button_set = (unsigned)p_args[i].value;
  10064.         else
  10065.             args[n++] = p_args[i];
  10066.     }
  10067.  
  10068.     XtSetArg(args[n], XmNradioBehavior, TRUE); n++;
  10069.     option_menu = XmCreateRowColumn(parent, name, args, n);
  10070.  
  10071.     if (button_names == fe_SimpleOptionAboveBelow)
  10072.         button_count = XtNumber(fe_SimpleOptionAboveBelow);
  10073.     else if (button_names == fe_SimpleOptionPixelPercent)
  10074.         button_count = XtNumber(fe_SimpleOptionPixelPercent);
  10075.     else if (button_names == fe_SimpleOptionHorizontalAlignment)
  10076.         button_count = XtNumber(fe_SimpleOptionHorizontalAlignment);
  10077.     else if (button_names == fe_SimpleOptionVerticalAlignment)
  10078.         button_count = XtNumber(fe_SimpleOptionVerticalAlignment);
  10079.     else if (button_names == fe_SimpleTableAlignment)
  10080.         button_count = XtNumber(fe_SimpleTableAlignment);
  10081.  
  10082.     for (i = 0; i < button_count; i++) {
  10083.         if (button_names) {
  10084.             button_name = button_names[i];
  10085.         } else {
  10086.             sprintf(namebuf, "button%d", i);
  10087.             button_name = namebuf;
  10088.         }
  10089.         n = 0;
  10090.         XtSetArg(args[n], XmNset, (i == button_set)); n++;
  10091.         XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  10092.         button = XmCreateToggleButtonGadget(option_menu, button_name, args, n);
  10093.         XtManageChild(button);
  10094.     }
  10095.  
  10096.     return option_menu;
  10097. }
  10098.  
  10099. void
  10100. fe_SimpleRadioGroupSetWhich(Widget widget, unsigned which)
  10101. {
  10102.     Widget* children;
  10103.     Cardinal num_children;
  10104.     Cardinal i;
  10105.  
  10106.     XtVaGetValues(widget,
  10107.                   XmNchildren, &children,
  10108.                   XmNnumChildren, &num_children, 0);
  10109.  
  10110.     if (which < num_children) {
  10111.  
  10112.         for (i = 0; i < num_children; i++) {
  10113.             XmToggleButtonGadgetSetState(children[i], (i == which), FALSE);
  10114.         }
  10115.     }
  10116. }
  10117.  
  10118. void
  10119. fe_SimpleRadioGroupSetSensitive(Widget widget, Boolean sensitive)
  10120. {
  10121.     Widget* children;
  10122.     Cardinal num_children;
  10123.     Cardinal i;
  10124.  
  10125.     XtVaGetValues(widget,
  10126.                   XmNchildren, &children,
  10127.                   XmNnumChildren, &num_children, 0);
  10128.  
  10129.     for (i = 0; i < num_children; i++) {
  10130.         XtVaSetValues(children[i], XmNsensitive, sensitive, 0);
  10131.     }
  10132. }
  10133.  
  10134. int
  10135. fe_SimpleRadioGroupGetWhich(Widget widget)
  10136. {
  10137.     Widget* children;
  10138.     Cardinal num_children;
  10139.     Cardinal i;
  10140.  
  10141.     XtVaGetValues(widget,
  10142.                   XmNchildren, &children,
  10143.                   XmNnumChildren, &num_children, 0);
  10144.  
  10145.     for (i = 0; i < num_children; i++) {
  10146.         if (XmToggleButtonGadgetGetState(children[i]) == TRUE)
  10147.             return i;
  10148.     }
  10149.     return -1; /* ?? */
  10150. }
  10151.  
  10152. Widget
  10153. fe_SimpleRadioGroupGetChild(Widget widget, unsigned n)
  10154. {
  10155.     Widget*  children;
  10156.     Cardinal num_children;
  10157.  
  10158.     XtVaGetValues(widget,
  10159.                   XmNchildren, &children,
  10160.                   XmNnumChildren, &num_children, 0);
  10161.  
  10162.     if (n < num_children)
  10163.         return children[n];
  10164.     else
  10165.         return NULL;
  10166. }
  10167.  
  10168.  
  10169. static unsigned
  10170. fe_ED_Alignment_to_index(ED_Alignment type)
  10171. {
  10172.     switch (type) {
  10173.     case ED_ALIGN_LEFT:
  10174.     case ED_ALIGN_ABSTOP:
  10175.     case ED_ALIGN_TOP:       return 1;
  10176.     case ED_ALIGN_CENTER:
  10177.     case ED_ALIGN_ABSCENTER: return 2;
  10178.     case ED_ALIGN_RIGHT:
  10179.     case ED_ALIGN_BOTTOM:
  10180.     case ED_ALIGN_ABSBOTTOM: return 3;
  10181.     case ED_ALIGN_BASELINE:  return 4;
  10182.     case ED_ALIGN_DEFAULT:
  10183.     default:                 return 0;
  10184.   }
  10185. }
  10186.  
  10187. typedef struct fe_EditorTablesTableStruct
  10188. {
  10189.     Widget number_rows_text;
  10190.     Widget number_columns_text;
  10191.     Widget line_width_toggle;
  10192.     Widget line_width_text;
  10193.     Widget spacing_text;
  10194.     Widget padding_text;
  10195.     Widget width_toggle;
  10196.     Widget width_text;
  10197.     Widget width_units;
  10198.     Widget height_toggle;
  10199.     Widget height_text;
  10200.     Widget height_units;
  10201.     Widget bg_group;
  10202.     Widget choose_color;
  10203.     LO_Color color_value;
  10204.     Widget caption_toggle;
  10205.     Widget caption_type;
  10206.     Widget equal_column_toggle;
  10207.     Widget alignBox;
  10208.     Boolean inserting;
  10209. } fe_EditorTablesTableStruct; 
  10210.  
  10211. #if 0
  10212. static void
  10213. check_children(Widget* children, Cardinal nchildren)
  10214. {
  10215.     Widget widget;
  10216.     Widget parent;
  10217.     int i;
  10218.  
  10219.     for (i = 0; i < nchildren; i++) {
  10220.         widget = children[i];
  10221.         parent = XtParent(widget);
  10222.         fprintf(real_stderr, "parent(%s) = %s, ", XtName(widget), 
  10223.                 XtName(parent));
  10224.     }
  10225.     fprintf(real_stderr, "\n");
  10226.     
  10227. }
  10228. #endif
  10229.  
  10230. static void
  10231. fe_table_tbr_set(MWContext* context, Widget toggle, Widget text, Widget radio,
  10232.                  Boolean enabled, unsigned numeric, Boolean second_one)
  10233. {
  10234.     XmToggleButtonGadgetSetState(toggle, enabled, FALSE);
  10235.     if (text != NULL) {
  10236.         char buf[32];
  10237.  
  10238.         sprintf(buf, "%d", numeric);
  10239.  
  10240.         fe_TextFieldSetString(text, buf, FALSE);
  10241.         fe_TextFieldSetEditable(context, text, enabled);
  10242.     }
  10243.     if (radio != NULL) {
  10244.         fe_SimpleRadioGroupSetWhich(radio, second_one);
  10245.         fe_SimpleRadioGroupSetSensitive(radio, enabled);
  10246.     }
  10247. }
  10248.  
  10249. static void
  10250. fe_table_percent_label_set(Widget widget, Boolean nested)
  10251. {
  10252.     char * name = (nested ? "percentOfCell" : "percentOfWindow");
  10253.  
  10254.     XmString xm_string = XfeSubResourceGetXmStringValue(widget,
  10255.                                                         name,
  10256.                                                         XfeClassNameForWidget(widget),
  10257.                                                         XmNlabelString,
  10258.                                                         XmCXmString,
  10259.                                                         NULL);
  10260.  
  10261.     if (!xm_string)
  10262.     {
  10263.         xm_string = XmStringCreateLocalized(name);
  10264.  
  10265.         XtVaSetValues(widget, XmNlabelString, xm_string, 0);
  10266.  
  10267.         XmStringFree(xm_string);
  10268.     }
  10269.     /* No need to free xm_string.  The resource converter dtor will */
  10270.     else
  10271.     {
  10272.         XtVaSetValues(widget, XmNlabelString, xm_string, 0);
  10273.     }
  10274. }
  10275.  
  10276. static void
  10277. fe_table_toggle_cb(Widget widget, XtPointer closure, XtPointer cb_data)
  10278. {
  10279.     fe_EditorTablesTableStruct* w_data = (fe_EditorTablesTableStruct*)closure;
  10280.     Boolean enabled = XmToggleButtonGetState(widget);
  10281.     MWContext* context = fe_WidgetToMWContext(widget);
  10282.     Widget  text = NULL; /* keep -O happy */
  10283.     Widget  radio = NULL; /* keep -O happy */
  10284.  
  10285.     if (widget == w_data->line_width_toggle) {
  10286.         text = w_data->line_width_text;
  10287.         radio = NULL;
  10288.     } else if (widget == w_data->width_toggle) {
  10289.         text = w_data->width_text;
  10290.         radio = w_data->width_units;
  10291.     } else if (widget == w_data->height_toggle) {
  10292.         text = w_data->height_text;
  10293.         radio = w_data->height_units;
  10294.     } else if (widget == w_data->caption_toggle) {
  10295.         fe_SimpleRadioGroupSetSensitive(w_data->caption_type, enabled);
  10296.         return;
  10297.     }
  10298.  
  10299.     if (text != NULL)
  10300.         fe_TextFieldSetEditable(context, text, enabled);
  10301.     if (radio != NULL)
  10302.         fe_SimpleRadioGroupSetSensitive(radio, enabled);
  10303. }
  10304.  
  10305. #define RGB_TO(r,g,b) (((r)<<16)+((g)<<8)+(b))
  10306. #define R_FROM(l)     (((l)>>16)&0xff)
  10307. #define G_FROM(l)     (((l)>>8)&0xff)
  10308. #define B_FROM(l)     ((l)&0xff)
  10309.  
  10310. static void
  10311. fe_NewSwatchSetColor(Widget widget, LO_Color* color)
  10312. {
  10313.     unsigned long pack_color = 0;
  10314.  
  10315.     if (color)
  10316.         pack_color = RGB_TO(color->red, color->green, color->blue);
  10317.  
  10318.     XtVaSetValues(widget,
  10319.                   XmNuserData, pack_color,
  10320.                   0);
  10321.     fe_SwatchSetColor(widget, color);
  10322. }
  10323.  
  10324. static LO_Color*
  10325. fe_NewSwatchGetColor(Widget widget, LO_Color* color)
  10326. {
  10327.     unsigned long pack_color;
  10328.  
  10329.     XtVaGetValues(widget, XmNuserData, &pack_color, 0);
  10330.  
  10331.     color->red = R_FROM(pack_color);
  10332.     color->green = G_FROM(pack_color);
  10333.     color->blue = B_FROM(pack_color);
  10334.  
  10335.     return color;
  10336. }
  10337.  
  10338. static void
  10339. fe_bg_group_use_color_cb(Widget widget, XtPointer closure, XtPointer cbd)
  10340. {
  10341.     XmToggleButtonCallbackStruct* cbs = (XmToggleButtonCallbackStruct*)cbd;
  10342.     Widget swatch = (Widget)closure;
  10343.     
  10344.     fe_WidgetSetSensitive(swatch, cbs->set);
  10345. }
  10346.  
  10347. static void
  10348. fe_bg_group_swatch_cb(Widget widget, XtPointer closure, XtPointer cbd)
  10349. {
  10350.     MWContext* context = fe_WidgetToMWContext(widget);
  10351.     LO_Color   color;
  10352.     Widget     toggle = (Widget)closure;
  10353.  
  10354.     fe_NewSwatchGetColor(widget, &color);
  10355.  
  10356.     if (fe_ColorPicker(context, &color)) {
  10357.         fe_NewSwatchSetColor(widget, &color);
  10358.         XmToggleButtonSetState(toggle, TRUE, FALSE);
  10359.     }
  10360. }
  10361.  
  10362. static void
  10363. fe_bg_use_image_cb(Widget widget, XtPointer closure, XtPointer cbd)
  10364. {
  10365.     XmToggleButtonCallbackStruct* cbs = (XmToggleButtonCallbackStruct*)cbd;
  10366.     MWContext* context = fe_WidgetToMWContext(widget);
  10367.     Widget     text_widget = (Widget)closure;
  10368.  
  10369.     fe_TextFieldSetEditable(context, text_widget, cbs->set);
  10370. }
  10371.  
  10372. static void
  10373. fe_bg_image_browse_cb(Widget widget, XtPointer closure, XtPointer cbd)
  10374. {
  10375.     MWContext* context = fe_WidgetToMWContext(widget);
  10376.     Widget     text_widget = (Widget)closure;
  10377.  
  10378.     fe_url_browse_file_of_text(context, text_widget);
  10379. }
  10380.  
  10381. #define BG_GROUP_USECOLOR_TOGGLE   "useColor"
  10382. #define BG_GROUP_USECOLOR_SWATCH   "useColorSwatch"
  10383. #define BG_GROUP_USEIMAGE_TOGGLE   "useImage"
  10384. #define BG_GROUP_USEIMAGE_TEXT     "useImageText"
  10385. #define BG_GROUP_LEAVEIMAGE_TOGGLE "leaveImage"
  10386.  
  10387. static Widget
  10388. fe_create_background_group(Widget parent, char* name,
  10389.                            Arg* p_args, Cardinal p_n)
  10390. {
  10391.     Widget frame;
  10392.     Widget form;
  10393.     Widget use_color_toggle;
  10394.     Widget use_color_swatch;
  10395.     Widget use_image_toggle;
  10396.     Widget use_image_text;
  10397.     Widget use_image_chooser;
  10398.     Widget leave_image_toggle;
  10399.     Widget children[8];
  10400.     Cardinal nchildren;
  10401.     Arg args[16];
  10402.     Cardinal n;
  10403.     Cardinal offset;
  10404.     Dimension height;
  10405.     
  10406.     frame = fe_CreateFrame(parent, name, p_args, p_n);
  10407.  
  10408.     n = 0;
  10409.     form = XmCreateForm(frame, "backgroundAttributes", args, n);
  10410.     XtManageChild(form);
  10411.  
  10412.     nchildren = 0;
  10413.  
  10414.     n = 0;
  10415.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10416.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10417.     use_color_toggle = XmCreateToggleButtonGadget(form,
  10418.                                                   BG_GROUP_USECOLOR_TOGGLE,
  10419.                                                   args, n);
  10420.     children[nchildren++] = use_color_toggle;
  10421.  
  10422.     n = 0;
  10423.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10424.     XtSetArg(args[n], XmNtopWidget, use_color_toggle); n++;
  10425.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10426.     use_image_toggle = XmCreateToggleButtonGadget(form,
  10427.                                                   BG_GROUP_USEIMAGE_TOGGLE,
  10428.                                                   args, n);
  10429.     children[nchildren++] = use_image_toggle;
  10430.  
  10431.     offset = fe_get_offset_from_widest(children, nchildren);
  10432.  
  10433.     XtVaGetValues(use_color_toggle, XmNheight, &height, 0);
  10434.  
  10435.     n = 0;
  10436.     XtSetArg(args[n], XmNheight, height); n++;
  10437.     XtSetArg(args[n], XmNwidth, SWATCH_SIZE); n++;
  10438.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10439.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10440.     XtSetArg(args[n], XmNleftOffset, offset); n++;
  10441.     use_color_swatch = fe_CreateSwatch(form,
  10442.                                        BG_GROUP_USECOLOR_SWATCH, args, n);
  10443.     children[nchildren++] = use_color_swatch;
  10444.  
  10445.     XtAddCallback(use_color_toggle, XmNvalueChangedCallback,
  10446.                   fe_bg_group_use_color_cb, use_color_swatch);
  10447.     XtAddCallback(use_color_swatch, XmNactivateCallback,
  10448.                   fe_bg_group_swatch_cb, use_color_toggle);
  10449.  
  10450.     n = 0;
  10451.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10452.     XtSetArg(args[n], XmNtopWidget, use_color_toggle); n++;
  10453.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10454.     XtSetArg(args[n], XmNleftOffset, offset); n++;
  10455.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10456.     use_image_text = fe_CreateTextField(form,
  10457.                                         BG_GROUP_USEIMAGE_TEXT, args, n);
  10458.     children[nchildren++] = use_image_text;
  10459.  
  10460.     n = 0;
  10461.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10462.     XtSetArg(args[n], XmNtopWidget, use_image_text); n++;
  10463.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10464.     leave_image_toggle = XmCreateToggleButtonGadget(form,
  10465.                                                     BG_GROUP_LEAVEIMAGE_TOGGLE,
  10466.                                                     args, n);
  10467.     children[nchildren++] = leave_image_toggle;
  10468.  
  10469.     n = 0;
  10470.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10471.     XtSetArg(args[n], XmNtopWidget, use_image_text); n++;
  10472.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10473.     use_image_chooser = XmCreatePushButtonGadget(form, "chooseImage",
  10474.                                                   args, n);
  10475.     children[nchildren++] = use_image_chooser;
  10476.  
  10477.     XtAddCallback(use_image_toggle, XmNvalueChangedCallback,
  10478.                   fe_bg_use_image_cb, use_image_text);
  10479.     XtAddCallback(use_image_chooser, XmNactivateCallback,
  10480.                   fe_bg_image_browse_cb, use_image_text);
  10481.     
  10482.     XtManageChildren(children, nchildren);
  10483.     
  10484.     return frame;
  10485. }
  10486.  
  10487. static void
  10488. fe_bg_group_set(Widget parent,
  10489.                 LO_Color* color, char* bg_image, XP_Bool leave_image)
  10490. {
  10491.     Widget  use_color_toggle;
  10492.     Widget  use_color_swatch;
  10493.     Widget  use_image_toggle;
  10494.     Widget  use_image_text;
  10495.     Widget  leave_image_toggle;
  10496.     
  10497.     use_color_toggle = XtNameToWidget(parent, "*" BG_GROUP_USECOLOR_TOGGLE);
  10498.     use_color_swatch = XtNameToWidget(parent, "*" BG_GROUP_USECOLOR_SWATCH);
  10499.     use_image_toggle = XtNameToWidget(parent, "*" BG_GROUP_USEIMAGE_TOGGLE);
  10500.     use_image_text = XtNameToWidget(parent, "*" BG_GROUP_USEIMAGE_TEXT);
  10501.     leave_image_toggle = XtNameToWidget(parent,"*" BG_GROUP_LEAVEIMAGE_TOGGLE);
  10502.  
  10503.     if (use_color_toggle != NULL)
  10504.         XmToggleButtonGadgetSetState(use_color_toggle, (color != NULL), FALSE);
  10505.  
  10506.     if (use_color_swatch != NULL)
  10507.         fe_NewSwatchSetColor(use_color_swatch, color);
  10508.  
  10509.     if (use_image_toggle != NULL) {
  10510.         XmToggleButtonGadgetSetState(use_image_toggle, (bg_image != NULL),
  10511.                                      FALSE);
  10512.     }
  10513.  
  10514.     if (bg_image == NULL)
  10515.         bg_image = "";
  10516.  
  10517.     if (use_image_text != NULL)
  10518.         fe_TextFieldSetString(use_image_text, bg_image, FALSE);
  10519.  
  10520.     if (leave_image_toggle != NULL)
  10521.         XmToggleButtonGadgetSetState(leave_image_toggle, (leave_image_toggle != NULL),
  10522.                                      FALSE);
  10523. }
  10524.  
  10525. static void
  10526. fe_bg_group_get(Widget   parent,
  10527.                 LO_Color** color_r, char** bg_image_r, XP_Bool* leave_image_r)
  10528. {
  10529.     XP_Bool use_color = FALSE;
  10530.     XP_Bool use_image = FALSE;
  10531.     XP_Bool leave_image = FALSE;
  10532.     Widget  use_color_toggle;
  10533.     Widget  use_color_swatch;
  10534.     Widget  use_image_toggle;
  10535.     Widget  use_image_text;
  10536.     Widget  leave_image_toggle;
  10537.     
  10538.     use_color_toggle = XtNameToWidget(parent, "*" BG_GROUP_USECOLOR_TOGGLE);
  10539.     use_color_swatch = XtNameToWidget(parent, "*" BG_GROUP_USECOLOR_SWATCH);
  10540.     use_image_toggle = XtNameToWidget(parent, "*" BG_GROUP_USEIMAGE_TOGGLE);
  10541.     use_image_text = XtNameToWidget(parent, "*" BG_GROUP_USEIMAGE_TEXT);
  10542.     leave_image_toggle = XtNameToWidget(parent,"*" BG_GROUP_LEAVEIMAGE_TOGGLE);
  10543.     
  10544.     if (use_color_toggle != NULL)
  10545.         use_color = (XP_Bool)XmToggleButtonGadgetGetState(use_color_toggle);
  10546.  
  10547.     if (use_image_toggle != NULL)
  10548.         use_image = (XP_Bool)XmToggleButtonGadgetGetState(use_image_toggle);
  10549.  
  10550.     if (leave_image_toggle != NULL)
  10551.         leave_image=(XP_Bool)XmToggleButtonGadgetGetState(leave_image_toggle);
  10552.  
  10553.     if (color_r != NULL) {
  10554.         LO_Color* foo = NULL;
  10555.         if (use_color && use_color_swatch != NULL) {
  10556.             foo = XP_NEW(LO_Color);
  10557.             fe_NewSwatchGetColor(use_color_swatch, foo);
  10558.         }
  10559.         *color_r = foo;
  10560.     }
  10561.  
  10562.     if (bg_image_r != NULL) {
  10563.         char* tmp = NULL;
  10564.         if (use_image && use_image_text != NULL) {
  10565.             tmp = fe_TextFieldGetString(use_image_text);
  10566.             if (tmp != NULL) {
  10567.                 fe_StringTrim(tmp);
  10568.                 if (tmp[0] == '\0') {
  10569.                     XP_FREE(tmp);
  10570.                     tmp = NULL;
  10571.                 }
  10572.             }
  10573.         }
  10574.             
  10575.         *bg_image_r = tmp;
  10576.     }
  10577.  
  10578.     if (leave_image_r != NULL)
  10579.         *leave_image_r = leave_image;
  10580. }
  10581.  
  10582.  
  10583. static Widget
  10584. fe_tables_table_properties_create(MWContext* context, Widget parent,
  10585.                                   fe_EditorTablesTableStruct* w_data)
  10586. {
  10587.     Widget frame;
  10588.     Widget form;
  10589.     Widget line_width_toggle;
  10590.     Widget line_width_text;
  10591.     Widget line_width_units;
  10592.     Widget spacing_label;
  10593.     Widget spacing_text;
  10594.     Widget spacing_units;
  10595.     Widget padding_label;
  10596.     Widget padding_text;
  10597.     Widget padding_units;
  10598.     Widget width_toggle;
  10599.     Widget width_text;
  10600.     Widget width_units;
  10601.     Widget height_toggle;
  10602.     Widget height_text;
  10603.     Widget height_units;
  10604.     Widget caption_toggle;
  10605.     Widget caption_type;
  10606.     Widget alignframe;
  10607.     Widget alignBox;
  10608.     Widget equal_column_toggle;
  10609.     Widget bg_group;
  10610.     Arg args[16];
  10611.     Cardinal n;
  10612.     Cardinal nchildren;
  10613.     Widget children[32];
  10614.     Cardinal i;
  10615.     Dimension left_offset;
  10616.     Dimension height;
  10617.     Cardinal ncolumn_one;
  10618.     Cardinal ncolumn_two;
  10619.     Cardinal ncolumn_three;
  10620.     Widget top_guy;
  10621.  
  10622.     /*
  10623.      *    Alignment frame.
  10624.      */
  10625.     n = 0;
  10626.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10627.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10628.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10629.     alignframe = fe_CreateFrame(parent, "tableAlignment", args, n);
  10630.     XtManageChild(alignframe);
  10631.  
  10632.     n = 0;
  10633.     XtSetArg(args[n], XmNbuttons, fe_SimpleTableAlignment); n++;
  10634.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  10635.     alignBox = fe_CreateSimpleRadioGroup(alignframe, "tableAlignmentBox", 
  10636.                                          args, n);
  10637.     XtManageChild(alignBox);
  10638.     fe_SimpleRadioGroupSetWhich(alignBox, 0);
  10639.  
  10640.     n = 0;
  10641.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10642.     XtSetArg(args[n], XmNtopWidget, alignframe); n++;
  10643.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10644.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10645.     frame = fe_CreateFrame(parent, "attributes", args, n);
  10646.     XtManageChild(frame);
  10647.  
  10648.     n = 0;
  10649.     form = XmCreateForm(frame, "attributes", args, n);
  10650.     XtManageChild(form);
  10651.  
  10652.     nchildren = 0;
  10653.     n = 0;
  10654.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;    
  10655.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10656.     caption_toggle = XmCreateToggleButtonGadget(form, "captionToggle",
  10657.                                                 args, n);
  10658.     children[nchildren++] = caption_toggle;
  10659.     XtAddCallback(caption_toggle, XmNvalueChangedCallback, 
  10660.                   fe_table_toggle_cb, (XtPointer)w_data);
  10661.  
  10662.     n = 0;
  10663.     XtSetArg(args[n], XmNmarginWidth, 0); n++;
  10664.     XtSetArg(args[n], XmNmarginHeight, 0); n++;
  10665.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10666.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10667.     XtSetArg(args[n], XmNleftWidget, caption_toggle); n++;
  10668.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionAboveBelow); n++;
  10669. #ifdef TABLES_USE_OPTION_MENU    
  10670.     caption_type = fe_CreateSimpleOptionMenu(form, "captionType", args, n);
  10671. #else
  10672.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  10673.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  10674.     caption_type = fe_CreateSimpleRadioGroup(form, "captionType", args, n);
  10675. #endif
  10676.     children[nchildren++] = caption_type;
  10677.  
  10678.     XtManageChildren(children, nchildren);
  10679.     
  10680.     nchildren = 0;
  10681.     n = 0;
  10682.     line_width_toggle = XmCreateToggleButtonGadget(form,
  10683.                                                    "borderLineWidth",
  10684.                                                    args, n);
  10685.     children[nchildren++] = line_width_toggle;
  10686.     XtAddCallback(line_width_toggle, XmNvalueChangedCallback, 
  10687.                   fe_table_toggle_cb, (XtPointer)w_data);
  10688.  
  10689.     n = 0;
  10690.     spacing_label = XmCreateLabelGadget(form, "cellSpacingLabel", args, n);
  10691.     children[nchildren++] = spacing_label;
  10692.  
  10693.     n = 0;
  10694.     padding_label = XmCreateLabelGadget(form, "cellPaddingLabel", args, n);
  10695.     children[nchildren++] = padding_label;
  10696.  
  10697.     n = 0;
  10698.     width_toggle = XmCreateToggleButtonGadget(form, "tableWidthToggle",
  10699.                                               args, n);
  10700.     children[nchildren++] = width_toggle;
  10701.     XtAddCallback(width_toggle, XmNvalueChangedCallback, 
  10702.                   fe_table_toggle_cb, (XtPointer)w_data);
  10703.  
  10704.     n = 0;
  10705.     height_toggle = XmCreateToggleButtonGadget(form, "tableHeightToggle",
  10706.                                                args, n);
  10707.     children[nchildren++] = height_toggle;
  10708.     XtAddCallback(height_toggle, XmNvalueChangedCallback, 
  10709.                   fe_table_toggle_cb, (XtPointer)w_data);
  10710.  
  10711.     n = 0;
  10712.     equal_column_toggle = XmCreateToggleButtonGadget(form, "equalColumnWidth",
  10713.                                                      args, n);
  10714.     children[nchildren++] = equal_column_toggle;
  10715.  
  10716.     ncolumn_one = nchildren;
  10717.  
  10718.     left_offset = fe_get_offset_from_widest(children, nchildren);
  10719.  
  10720.     /*
  10721.      *    Make all the text dudes + swatch
  10722.      */
  10723.     n = 0;
  10724.     XtSetArg(args[n], XmNcolumns, 4); n++;
  10725.     line_width_text = fe_CreateTextField(form, "borderLineWidthText",
  10726.                                           args, n);
  10727.     children[nchildren++] = line_width_text;
  10728.     
  10729.     n = 0;
  10730.     spacing_text = fe_CreateTextField(form, "cellSpacingText", args, n);
  10731.     children[nchildren++] = spacing_text;
  10732.     
  10733.     n = 0;
  10734.     padding_text = fe_CreateTextField(form, "cellPaddingText", args, n);
  10735.     children[nchildren++] = padding_text;
  10736.     
  10737.     n = 0;
  10738.     width_text = fe_CreateTextField(form, "tableWidthText", args, n);
  10739.     children[nchildren++] = width_text;
  10740.     
  10741.     n = 0;
  10742.     height_text = fe_CreateTextField(form, "tableHeightText", args, n);
  10743.     children[nchildren++] = height_text;
  10744.  
  10745.     XtVaGetValues(line_width_text, XmNheight, &height, 0);
  10746.     
  10747.     ncolumn_two = nchildren - ncolumn_one;
  10748.  
  10749.     n = 0;
  10750.     line_width_units = XmCreateLabelGadget(form, "borderLineWidthUnits",
  10751.                                            args, n);
  10752.     children[nchildren++] = line_width_units;
  10753.  
  10754.     n = 0;
  10755.     spacing_units = XmCreateLabelGadget(form, "cellSpacingUnits", args, n);
  10756.     children[nchildren++] = spacing_units;
  10757.  
  10758.     n = 0;
  10759.     padding_units = XmCreateLabelGadget(form, "cellPaddingUnits", args, n);
  10760.     children[nchildren++] = padding_units;
  10761.  
  10762.     n = 0;
  10763.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionPixelPercent); n++;
  10764. #ifdef TABLES_USE_OPTION_MENU    
  10765.     width_units = fe_CreateSimpleOptionMenu(form, "tableWidthUnits", args, n);
  10766. #else
  10767.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  10768.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  10769.     width_units = fe_CreateSimpleRadioGroup(form, "tableWidthUnits", args, n);
  10770. #endif
  10771.     children[nchildren++] = width_units;
  10772.  
  10773.     n = 0;
  10774.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionPixelPercent); n++;
  10775. #ifdef TABLES_USE_OPTION_MENU    
  10776.     height_units = fe_CreateSimpleOptionMenu(form, "tableHeightUnits",args, n);
  10777. #else
  10778.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  10779.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  10780.     height_units = fe_CreateSimpleRadioGroup(form, "tableHeightUnits",args, n);
  10781. #endif
  10782.     children[nchildren++] = height_units;
  10783.  
  10784.     ncolumn_three = nchildren - (ncolumn_two + ncolumn_one);
  10785.  
  10786.     /*
  10787.      *    Go back and do attachments.
  10788.      */
  10789.     n = 0;
  10790.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10791.     XtSetArg(args[n], XmNtopWidget, caption_type); n++;
  10792.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10793.     XtSetValues(line_width_toggle, args, n);
  10794.     
  10795.     n = 0;
  10796.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10797.     XtSetArg(args[n], XmNtopWidget, caption_type); n++;
  10798.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10799.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  10800.     XtSetValues(line_width_text, args, n);
  10801.     
  10802.     n = 0;
  10803.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10804.     XtSetArg(args[n], XmNtopWidget, caption_type); n++;
  10805.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10806.     XtSetArg(args[n], XmNleftWidget, line_width_text); n++;
  10807.     XtSetValues(line_width_units, args, n);
  10808.  
  10809.     top_guy = line_width_text;
  10810.     /* column 1 */
  10811.     for (i = 1; i < ncolumn_one; i++) {
  10812.         Widget label_guy = children[i];
  10813.         Widget text_guy = NULL;
  10814.         Widget unit_guy = NULL;
  10815.  
  10816.         n = 0;
  10817.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10818.         XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  10819.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10820.         XtSetValues(label_guy, args, n);
  10821.  
  10822.         /* column 2 */
  10823.         if (i < ncolumn_two) {
  10824.             text_guy = children[i+ncolumn_one];
  10825.             n = 0;
  10826.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10827.             XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  10828.             XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET);n++;
  10829.             XtSetArg(args[n], XmNleftWidget, line_width_text); n++;
  10830.             XtSetArg(args[n], XmNrightAttachment,XmATTACH_OPPOSITE_WIDGET);n++;
  10831.             XtSetArg(args[n], XmNrightWidget, line_width_text); n++;
  10832.             XtSetValues(text_guy, args, n);
  10833.         }
  10834.  
  10835.         /* column 3 */
  10836.         if (i < ncolumn_three) {
  10837.             unit_guy = children[i+ncolumn_one+ncolumn_two];
  10838.             n = 0;
  10839.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10840.             XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  10841.             XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10842.             XtSetArg(args[n], XmNleftWidget, line_width_text); n++;
  10843.             XtSetValues(unit_guy, args, n);
  10844.         }
  10845.  
  10846.         top_guy = text_guy;
  10847.     }
  10848. #if 0
  10849.     check_children(children, nchildren);
  10850. #endif
  10851.     XtManageChildren(children, nchildren);
  10852.  
  10853.     /*
  10854.      *    Background..
  10855.      */
  10856.     n = 0;
  10857.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10858.     XtSetArg(args[n], XmNtopWidget, frame); n++;
  10859.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10860.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10861.     bg_group = fe_create_background_group(parent, "background", args, n);
  10862.     XtManageChild(bg_group);
  10863.  
  10864.     w_data->line_width_toggle = line_width_toggle;
  10865.     w_data->line_width_text = line_width_text;
  10866.     w_data->spacing_text = spacing_text;
  10867.     w_data->padding_text = padding_text;
  10868.     w_data->width_toggle = width_toggle;
  10869.     w_data->width_text = width_text;
  10870.     w_data->width_units = width_units;
  10871.     w_data->height_toggle = height_toggle;
  10872.     w_data->height_text = height_text;
  10873.     w_data->height_units = height_units;
  10874.     w_data->caption_toggle = caption_toggle;
  10875.     w_data->caption_type = caption_type;
  10876.     w_data->alignBox = alignBox;
  10877.     w_data->equal_column_toggle = equal_column_toggle;
  10878.     w_data->bg_group = bg_group;
  10879.  
  10880.     return alignframe;
  10881. }
  10882.  
  10883. static Widget
  10884. fe_tables_table_create_create(MWContext* context, Widget parent,
  10885.                               fe_EditorTablesTableStruct* w_data)
  10886. {
  10887.     Widget form;
  10888.     Widget rows_label;
  10889.     Widget rows_text;
  10890.     Widget columns_label;
  10891.     Widget columns_text;
  10892.     Widget attributes;
  10893.     Arg args[8];
  10894.     Cardinal n;
  10895.     Cardinal nchildren = 0;
  10896.     Widget children[6];
  10897.  
  10898.     n = 0;
  10899.     form = XmCreateForm(parent, "tablesCreate", args, n);
  10900.     XtManageChild(form);
  10901.  
  10902.     n = 0;
  10903.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10904.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10905.     rows_label = XmCreateLabelGadget(form, "tableRowsLabel", args, n);
  10906.     children[nchildren++] = rows_label;
  10907.  
  10908.     n = 0;
  10909.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10910.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10911.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  10912.     XtSetArg(args[n], XmNcolumns, 4); n++;
  10913.     rows_text = fe_CreateTextField(form, "tableRowsText", args, n);
  10914.     children[nchildren++] = rows_text;
  10915.  
  10916.     n = 0;
  10917.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10918.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10919.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  10920.     columns_label = XmCreateLabelGadget(form, "tableColumnsLabel", args, n);
  10921.     children[nchildren++] = columns_label;
  10922.  
  10923.     n = 0;
  10924.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  10925.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  10926.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  10927.     XtSetArg(args[n], XmNcolumns, 4); n++;
  10928.     columns_text = fe_CreateTextField(form, "tableColumnsText", args, n);
  10929.     children[nchildren++] = columns_text;
  10930.  
  10931.     attributes = fe_tables_table_properties_create(context, form, w_data);
  10932.     children[nchildren++] = attributes;
  10933.  
  10934.     /*
  10935.      *    Override attachments on top guy in properties section.
  10936.      */
  10937.     n = 0;
  10938.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  10939.     XtSetArg(args[n], XmNtopWidget, rows_text); n++;
  10940.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  10941.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  10942.     XtSetValues(attributes, args, n);
  10943.  
  10944. #if 0
  10945.     check_children(children, nchildren);
  10946. #endif
  10947.     XtManageChildren(children, nchildren);
  10948.  
  10949.     w_data->number_rows_text = rows_text;
  10950.     w_data->number_columns_text = columns_text;
  10951.  
  10952.     return form;
  10953. }
  10954.  
  10955. static void
  10956. fe_table_properties_common_init(MWContext* context,
  10957.                                 EDT_AllTableData* table_data,
  10958.                                 fe_EditorTablesTableStruct* w_data)
  10959. {
  10960.     Boolean is_nested;
  10961.     Widget  widget;
  10962.  
  10963.     if (w_data->number_rows_text != NULL) /* inserting */
  10964.         is_nested = EDT_IsInsertPointInTable(context);
  10965.     else
  10966.         is_nested = EDT_IsInsertPointInNestedTable(context);
  10967.  
  10968.     /* set the border width parts */
  10969.     fe_table_tbr_set(context, w_data->line_width_toggle,
  10970.                      w_data->line_width_text, NULL,
  10971.                      table_data->td.bBorderWidthDefined,
  10972.                      table_data->td.iBorderWidth,
  10973.                      0);
  10974.     fe_set_numeric_text_field(w_data->spacing_text,
  10975.                               table_data->td.iCellSpacing);
  10976.     fe_set_numeric_text_field(w_data->padding_text,
  10977.                               table_data->td.iCellPadding);
  10978.  
  10979.     fe_table_tbr_set(context, w_data->width_toggle,
  10980.                      w_data->width_text, w_data->width_units,
  10981.                      table_data->td.bWidthDefined,
  10982.                      table_data->td.iWidth,
  10983.                      (table_data->td.bWidthPercent));
  10984.  
  10985.     widget = fe_SimpleRadioGroupGetChild(w_data->width_units, 1);
  10986.     fe_table_percent_label_set(widget, is_nested);
  10987.     
  10988.     fe_table_tbr_set(context, w_data->height_toggle,
  10989.                      w_data->height_text, w_data->height_units,
  10990.                      table_data->td.bHeightDefined,
  10991.                      table_data->td.iHeight,
  10992.                      (table_data->td.bHeightPercent));
  10993.     widget = fe_SimpleRadioGroupGetChild(w_data->height_units, 1);
  10994.     fe_table_percent_label_set(widget, is_nested);
  10995.  
  10996.     /*
  10997.      *    Background stuff
  10998.      */
  10999.     fe_bg_group_set(w_data->bg_group,
  11000.                     table_data->td.pColorBackground,
  11001.                     table_data->td.pBackgroundImage,
  11002.                     table_data->td.bBackgroundNoSave);
  11003.  
  11004.     fe_table_tbr_set(context, w_data->caption_toggle,
  11005.                      NULL, w_data->caption_type,
  11006.                      table_data->has_caption,
  11007.                      0,
  11008.                      (table_data->cd.align != ED_ALIGN_ABSTOP));
  11009.  
  11010.     XmToggleButtonGadgetSetState(w_data->equal_column_toggle,
  11011.                                  table_data->td.bUseCols,
  11012.                                  FALSE);
  11013.  
  11014.     /* we don't have default for alignment yet, so we need to subtract one
  11015.      * from index 
  11016.        */
  11017.     fe_SimpleRadioGroupSetWhich(w_data->alignBox,
  11018.                                 fe_ED_Alignment_to_index(table_data->td.align)-1);
  11019. }
  11020.  
  11021. static void
  11022. fe_tables_table_properties_init(MWContext* context,
  11023.                                 fe_EditorTablesTableStruct* w_data)
  11024. {
  11025.     EDT_AllTableData table_data;
  11026.  
  11027.     memset(&table_data, 0, sizeof(EDT_AllTableData));
  11028.  
  11029.     if (!fe_EditorTableGetData(context, &table_data))
  11030.         return;
  11031.  
  11032.     w_data->number_rows_text = NULL;
  11033.     w_data->number_columns_text = NULL;
  11034.     fe_table_properties_common_init(context, &table_data, w_data);
  11035. }
  11036.  
  11037. static void
  11038. fe_table_properties_common_set(MWContext* context,
  11039.                                EDT_AllTableData* table_data,
  11040.                                fe_EditorTablesTableStruct* w_data)
  11041. {
  11042.     int alignment;
  11043.  
  11044.     /*FIXME*/
  11045.     /*
  11046.      *    Don't know what this slot is, WinFE doesn't use it??
  11047.      */
  11048.     table_data->td.malign = ED_ALIGN_DEFAULT;
  11049.  
  11050.     table_data->td.bBorderWidthDefined =
  11051.         XmToggleButtonGetState(w_data->line_width_toggle);
  11052.     table_data->td.iBorderWidth = 
  11053.         fe_get_numeric_text_field(w_data->line_width_text);
  11054.  
  11055.     table_data->td.iCellSpacing = 
  11056.         fe_get_numeric_text_field(w_data->spacing_text);
  11057.     table_data->td.iCellPadding = 
  11058.         fe_get_numeric_text_field(w_data->padding_text);
  11059.  
  11060.     table_data->td.bWidthDefined =
  11061.         XmToggleButtonGetState(w_data->width_toggle);
  11062.     table_data->td.iWidth =
  11063.         fe_get_numeric_text_field(w_data->width_text);
  11064.     table_data->td.bWidthPercent =
  11065.         (fe_SimpleRadioGroupGetWhich(w_data->width_units) == 1);
  11066.  
  11067.     table_data->td.bHeightDefined =
  11068.         XmToggleButtonGetState(w_data->height_toggle);
  11069.     table_data->td.iHeight =
  11070.         fe_get_numeric_text_field(w_data->height_text);
  11071.     table_data->td.bHeightPercent =
  11072.         (fe_SimpleRadioGroupGetWhich(w_data->height_units) == 1);
  11073.  
  11074.     alignment = fe_SimpleRadioGroupGetWhich(w_data->alignBox);
  11075.  
  11076.     switch(alignment) {
  11077.         case 0:
  11078.             table_data->td.align = ED_ALIGN_LEFT;
  11079.             break;
  11080.         case 1:
  11081.             table_data->td.align = ED_ALIGN_ABSCENTER;
  11082.             break;
  11083.         case 2:
  11084.             table_data->td.align = ED_ALIGN_RIGHT;
  11085.             break;
  11086.         default:
  11087.             XP_ASSERT(0);
  11088.             break;
  11089.     }
  11090.  
  11091.     /*
  11092.      *    Don't get the background stuff here, because none of it gets
  11093.      *    validated, and we don't want to bother when we validate.
  11094.      */
  11095.  
  11096.     table_data->has_caption = XmToggleButtonGetState(w_data->caption_toggle);
  11097.     table_data->td.bUseCols =
  11098.         XmToggleButtonGetState(w_data->equal_column_toggle);
  11099.  
  11100.     if (fe_SimpleRadioGroupGetWhich(w_data->caption_type) == 1)
  11101.         table_data->cd.align = ED_ALIGN_ABSBOTTOM;
  11102.     else
  11103.         table_data->cd.align = ED_ALIGN_ABSTOP;
  11104. }
  11105.  
  11106. static Boolean
  11107. fe_tables_table_properties_validate(MWContext* context,
  11108.                                     fe_EditorTablesTableStruct* w_data)
  11109. {
  11110.     EDT_AllTableData table_data;
  11111.     EDT_TableData*   t = &table_data.td;
  11112.     unsigned         errors[16];
  11113.     unsigned         nerrors = 0;
  11114.     EDT_TableData*   tmp = EDT_NewTableData();
  11115.  
  11116.     memset(&table_data, 0, sizeof(EDT_AllTableData));
  11117.     memcpy(&table_data.td, tmp, sizeof(EDT_TableData));
  11118.  
  11119.     fe_table_properties_common_set(context, &table_data, w_data);
  11120.  
  11121.     if (w_data->number_rows_text != NULL) {
  11122.         t->iRows = fe_get_numeric_text_field(w_data->number_rows_text);
  11123.         t->iColumns = 
  11124.             fe_get_numeric_text_field(w_data->number_columns_text);
  11125.      
  11126.         if (RANGE_CHECK(t->iRows, TABLE_MIN_ROWS, TABLE_MAX_ROWS))
  11127.             errors[nerrors++] = XFE_INVALID_TABLE_NROWS;
  11128.         if (RANGE_CHECK(t->iColumns, TABLE_MIN_COLUMNS, TABLE_MAX_COLUMNS))
  11129.             errors[nerrors++] = XFE_INVALID_TABLE_NCOLUMNS;
  11130.     }
  11131.  
  11132.     if (RANGE_CHECK(t->iBorderWidth, TABLE_MIN_BORDER, TABLE_MAX_BORDER))
  11133.         errors[nerrors++] = XFE_INVALID_TABLE_BORDER;
  11134.         
  11135.     if (RANGE_CHECK(t->iCellSpacing, TABLE_MIN_SPACING, TABLE_MAX_SPACING))
  11136.         errors[nerrors++] = XFE_INVALID_TABLE_SPACING;
  11137.         
  11138.     if (RANGE_CHECK(t->iCellPadding, TABLE_MIN_PADDING, TABLE_MAX_PADDING))
  11139.         errors[nerrors++] = XFE_INVALID_TABLE_PADDING;
  11140.  
  11141.     if (t->bWidthDefined) {
  11142.         if (t->bWidthPercent) {
  11143.             if (RANGE_CHECK(t->iWidth,
  11144.                         TABLE_MIN_PERCENT_WIDTH, TABLE_MAX_PERCENT_WIDTH))
  11145.                 errors[nerrors++] = XFE_INVALID_TABLE_WIDTH;
  11146.         } else {
  11147.             if (RANGE_CHECK(t->iWidth,
  11148.                             TABLE_MIN_PIXEL_WIDTH, TABLE_MAX_PIXEL_WIDTH))
  11149.                 errors[nerrors++] = XFE_INVALID_TABLE_WIDTH;
  11150.         }
  11151.     }
  11152.         
  11153.     if (t->bHeightDefined) {
  11154.         if (t->bHeightPercent) {
  11155.             if (RANGE_CHECK(t->iHeight,
  11156.                         TABLE_MIN_PERCENT_HEIGHT, TABLE_MAX_PERCENT_HEIGHT))
  11157.                 errors[nerrors++] = XFE_INVALID_TABLE_HEIGHT;
  11158.         } else {
  11159.             if (RANGE_CHECK(t->iHeight,
  11160.                             TABLE_MIN_PIXEL_HEIGHT, TABLE_MAX_PIXEL_HEIGHT))
  11161.                 errors[nerrors++] = XFE_INVALID_TABLE_HEIGHT;
  11162.         }
  11163.     }
  11164.  
  11165.     EDT_FreeTableData(tmp);
  11166.  
  11167.     if (nerrors > 0) {
  11168.         fe_editor_range_error_dialog(context, w_data->spacing_text,
  11169.                                      errors, nerrors);
  11170.         return FALSE;
  11171.     }
  11172.  
  11173.     return TRUE;
  11174. }
  11175.  
  11176. static void
  11177. fe_tables_table_properties_set(MWContext* context,
  11178.                                fe_EditorTablesTableStruct* w_data)
  11179. {
  11180.     EDT_AllTableData table_data;
  11181.     EDT_TableData*   tmp = EDT_NewTableData();
  11182.  
  11183.     memset(&table_data, 0, sizeof(EDT_AllTableData));
  11184.     memcpy(&table_data.td, tmp, sizeof(EDT_TableData));
  11185.  
  11186.     if (!fe_EditorTableGetData(context, &table_data))
  11187.         return;
  11188.  
  11189.     fe_table_properties_common_set(context, &table_data, w_data);
  11190.  
  11191.     /* Get the background stuff, because ..common_set() did not. */
  11192.     fe_bg_group_get(w_data->bg_group,
  11193.                     &table_data.td.pColorBackground,
  11194.                     &table_data.td.pBackgroundImage,
  11195.                     &table_data.td.bBackgroundNoSave);
  11196.  
  11197.     fe_EditorTableSetData(context, &table_data);
  11198.  
  11199.     if (table_data.td.pColorBackground)
  11200.         XP_FREE(table_data.td.pColorBackground);
  11201.     if (table_data.td.pBackgroundImage)
  11202.         XP_FREE(table_data.td.pBackgroundImage);
  11203.  
  11204.     EDT_FreeTableData(tmp);
  11205. }
  11206.  
  11207. static void
  11208. fe_tables_table_create_init(MWContext* context,
  11209.                             fe_EditorTablesTableStruct* w_data)
  11210. {
  11211.     EDT_AllTableData table_data;
  11212.     EDT_TableData*   tmp;
  11213.  
  11214.     memset(&table_data, 0, sizeof(EDT_AllTableData));
  11215.  
  11216.     tmp = EDT_NewTableData();
  11217.     memcpy(&table_data.td, tmp, sizeof(EDT_TableData));
  11218.  
  11219.     fe_set_numeric_text_field(w_data->number_rows_text,
  11220.                               table_data.td.iRows);
  11221.     fe_set_numeric_text_field(w_data->number_columns_text,
  11222.                               table_data.td.iColumns);
  11223.  
  11224.     w_data->inserting = TRUE; /* reset after first insert */
  11225.     fe_table_properties_common_init(context, &table_data, w_data);
  11226.  
  11227.     EDT_FreeTableData(tmp);
  11228. }
  11229.  
  11230. static void
  11231. fe_tables_table_create_set(MWContext* context,
  11232.                               fe_EditorTablesTableStruct* w_data)
  11233. {
  11234.     EDT_AllTableData table_data;
  11235.     EDT_TableData*   tmp = EDT_NewTableData();
  11236.  
  11237.     memset(&table_data, 0, sizeof(EDT_AllTableData));
  11238.     memcpy(&table_data.td, tmp, sizeof(EDT_TableData));
  11239.  
  11240.     table_data.td.iRows = 
  11241.         fe_get_numeric_text_field(w_data->number_rows_text);
  11242.     table_data.td.iColumns = 
  11243.         fe_get_numeric_text_field(w_data->number_columns_text);
  11244.      
  11245.     fe_table_properties_common_set(context, &table_data, w_data);
  11246.  
  11247.     /* Get the background stuff, because ..common_set() did not. */
  11248.     fe_bg_group_get(w_data->bg_group,
  11249.                     &table_data.td.pColorBackground,
  11250.                     &table_data.td.pBackgroundImage,
  11251.                     &table_data.td.bBackgroundNoSave);
  11252.  
  11253.     if (w_data->inserting) {
  11254.         fe_EditorTableInsert(context, &table_data);
  11255.         w_data->inserting = FALSE; /* can only insert once */
  11256.     } else {
  11257.         fe_EditorTableSetData(context, &table_data);
  11258.     }
  11259.  
  11260.     if (table_data.td.pColorBackground)
  11261.         XP_FREE(table_data.td.pColorBackground);
  11262.     if (table_data.td.pBackgroundImage)
  11263.         XP_FREE(table_data.td.pBackgroundImage);
  11264.  
  11265.     EDT_FreeTableData(tmp);
  11266. }
  11267.  
  11268. static void
  11269. fe_cancel_button_set_cancel(Widget widget, Boolean can_cancel)
  11270. {
  11271.     char* name;
  11272.     char* string;
  11273.     XmString xm_string;
  11274.  
  11275.     if (can_cancel)
  11276.         name = "cancelLabelString";
  11277.     else
  11278.         name = "closeLabelString";
  11279.  
  11280.     string = XfeSubResourceGetWidgetStringValue(widget, name, XmCXmString);
  11281.     if (!string)
  11282.       string = name;
  11283.     xm_string = XmStringCreateLocalized(string);
  11284.  
  11285.     XtVaSetValues(widget, XmNlabelString, xm_string, 0);
  11286.  
  11287.     XmStringFree(xm_string);
  11288. }
  11289.  
  11290. void
  11291. fe_EditorTableCreateDialogDo(MWContext* context)
  11292. {
  11293.     Widget dialog;
  11294.     Widget form;
  11295.     Widget apply_button;
  11296.     Widget cancel_button;
  11297.     fe_EditorTablesTableStruct data;
  11298.     int done;
  11299.  
  11300.     /*
  11301.      *    Make prompt with ok, cancel, apply, separator.
  11302.      */
  11303.     form = fe_CreatePromptDialog(context, "tableCreateDialog",
  11304.                                  TRUE, TRUE, TRUE, TRUE, TRUE);
  11305.     dialog = XtParent(form);
  11306.  
  11307.     fe_tables_table_create_create(context, form, &data);
  11308.     fe_tables_table_create_init(context, &data);
  11309.  
  11310.     /*
  11311.      *   Add a bunch of callbacks to the buttons.
  11312.      */
  11313.     XtAddCallback(form, XmNokCallback, fe_hrule_ok_cb, &done);
  11314.     XtAddCallback(form, XmNapplyCallback, fe_hrule_apply_cb, &done);
  11315.     XtAddCallback(form, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  11316.     XtAddCallback(form, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  11317.  
  11318.     apply_button = XmSelectionBoxGetChild(form, XmDIALOG_APPLY_BUTTON);
  11319.     XtVaSetValues(apply_button, XmNsensitive, FALSE, 0);
  11320.     cancel_button = XmSelectionBoxGetChild(form, XmDIALOG_CANCEL_BUTTON);
  11321.     fe_cancel_button_set_cancel(cancel_button, TRUE);
  11322.  
  11323.     /*
  11324.      *    Popup.
  11325.      */
  11326.     XtManageChild(form);
  11327.  
  11328.     /*
  11329.      *    Wait.
  11330.      */
  11331.     fe_NukeBackingStore(dialog); /* what does this do? */
  11332.  
  11333.     done = XmDIALOG_NONE;
  11334.     while (done == XmDIALOG_NONE) {
  11335.         fe_EventLoop();
  11336.  
  11337.         if (done == XmDIALOG_OK_BUTTON || done == XmDIALOG_APPLY_BUTTON) {
  11338.             if (fe_tables_table_properties_validate(context, &data)) {
  11339.                 fe_tables_table_create_set(context, &data);
  11340.                 
  11341.                 if (done == XmDIALOG_APPLY_BUTTON) {
  11342.                     fe_cancel_button_set_cancel(cancel_button, FALSE);
  11343.                     done = XmDIALOG_NONE;
  11344.                 }
  11345.             } else {
  11346.                 done = XmDIALOG_NONE;
  11347.             }
  11348.         }
  11349.     }
  11350.  
  11351.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  11352.         XtDestroyWidget(dialog);
  11353. }
  11354.  
  11355. typedef struct fe_EditorTablesRowStruct
  11356. {
  11357.     Widget horizontal_alignment;
  11358.     Widget vertical_alignment;
  11359.     Widget bg_group;
  11360.     LO_Color color_value;
  11361. } fe_EditorTablesRowStruct;
  11362.  
  11363. static ED_Alignment
  11364. fe_index_to_ED_Alignment(unsigned index, Boolean horizontal)
  11365. {
  11366.   switch (index) {
  11367.   case 1: return (horizontal)? ED_ALIGN_LEFT: ED_ALIGN_ABSTOP;
  11368.   case 2: return ED_ALIGN_ABSCENTER;
  11369.   case 3: return (horizontal)? ED_ALIGN_RIGHT: ED_ALIGN_ABSBOTTOM;
  11370.   case 4: if (!horizontal) return ED_ALIGN_BASELINE; /*FALLTHRU*/
  11371.   case 0:
  11372.   default: return ED_ALIGN_DEFAULT;
  11373.   }
  11374. }
  11375.  
  11376. static void
  11377. fe_tables_row_properties_init(MWContext* context,
  11378.                      fe_EditorTablesRowStruct* w_data)
  11379. {
  11380. #if 0
  11381.     EDT_TableRowData row_data;
  11382.     Boolean enabled = TRUE;
  11383.  
  11384.     memset(&row_data, 0, sizeof(EDT_TableRowData));
  11385.  
  11386.     if (!fe_EditorTableRowGetData(context, &row_data)) {
  11387.         row_data.align = ED_ALIGN_DEFAULT;
  11388.         row_data.valign = ED_ALIGN_DEFAULT;
  11389.         row_data.pColorBackground = NULL;
  11390.         enabled = FALSE;
  11391.     }
  11392.  
  11393.     fe_SimpleRadioGroupSetWhich(w_data->horizontal_alignment,
  11394.                                 fe_ED_Alignment_to_index(row_data.align));
  11395.     fe_SimpleRadioGroupSetSensitive(w_data->horizontal_alignment, enabled);
  11396.  
  11397.     fe_SimpleRadioGroupSetWhich(w_data->vertical_alignment,
  11398.                                 fe_ED_Alignment_to_index(row_data.valign));
  11399.     fe_SimpleRadioGroupSetSensitive(w_data->vertical_alignment, enabled);
  11400.  
  11401.     /*
  11402.      *    Background stuff
  11403.      */
  11404.     fe_bg_group_set(w_data->bg_group,
  11405.                     row_data.pColorBackground,
  11406.                     row_data.pBackgroundImage,
  11407.                     row_data.bBackgroundNoSave);
  11408. #else
  11409.     EDT_TableRowData* row_data = EDT_GetTableRowData(context);
  11410.     Boolean enabled = TRUE;
  11411.  
  11412.     if (!row_data) {
  11413.         row_data = EDT_NewTableRowData();
  11414.         enabled = FALSE;
  11415.     }
  11416.  
  11417.     if (!row_data)
  11418.         return; /* oops */
  11419.  
  11420.     fe_SimpleRadioGroupSetWhich(w_data->horizontal_alignment,
  11421.                                 fe_ED_Alignment_to_index(row_data->align));
  11422.     fe_SimpleRadioGroupSetSensitive(w_data->horizontal_alignment, enabled);
  11423.  
  11424.     fe_SimpleRadioGroupSetWhich(w_data->vertical_alignment,
  11425.                                 fe_ED_Alignment_to_index(row_data->valign));
  11426.     fe_SimpleRadioGroupSetSensitive(w_data->vertical_alignment, enabled);
  11427.  
  11428.     /*
  11429.      *    Background stuff
  11430.      */
  11431.     fe_bg_group_set(w_data->bg_group,
  11432.                     row_data->pColorBackground,
  11433.                     row_data->pBackgroundImage,
  11434.                     row_data->bBackgroundNoSave);
  11435.  
  11436.     EDT_FreeTableRowData(row_data);
  11437. #endif
  11438. }
  11439.  
  11440. static void
  11441. fe_tables_row_properties_set(MWContext* context,
  11442.                      fe_EditorTablesRowStruct* w_data)
  11443. {
  11444.     EDT_TableRowData row_data;
  11445.     unsigned index;
  11446.  
  11447.     memset(&row_data, 0, sizeof(EDT_TableRowData));
  11448.  
  11449.     index = fe_SimpleRadioGroupGetWhich(w_data->horizontal_alignment);
  11450.     row_data.align = fe_index_to_ED_Alignment(index, TRUE);
  11451.  
  11452.     index = fe_SimpleRadioGroupGetWhich(w_data->vertical_alignment);
  11453.     row_data.valign = fe_index_to_ED_Alignment(index, FALSE);
  11454.  
  11455.     /*
  11456.      *    Background stuff
  11457.      */
  11458.     fe_bg_group_get(w_data->bg_group,
  11459.                     &row_data.pColorBackground,
  11460.                     &row_data.pBackgroundImage,
  11461.                     &row_data.bBackgroundNoSave);
  11462.  
  11463.     fe_EditorTableRowSetData(context, &row_data);
  11464.  
  11465.     if (row_data.pColorBackground)
  11466.         XP_FREE(row_data.pColorBackground);
  11467.     if (row_data.pBackgroundImage)
  11468.         XP_FREE(row_data.pBackgroundImage);
  11469. }
  11470.  
  11471. static Widget
  11472. fe_create_table_text_alignment_group(Widget parent, char* name,
  11473.                                      Arg* p_args, Cardinal p_n,
  11474.                                      Widget* h, Widget* v)
  11475. {
  11476.     Widget frame;
  11477.     Widget rc;
  11478.     Widget sub_rc;
  11479.     Widget horizontal_label;
  11480.     Widget horizontal_alignment;
  11481.     Widget vertical_label;
  11482.     Widget vertical_alignment;
  11483.     Arg args[16];
  11484.     Cardinal n;
  11485.     Widget children[8];
  11486.     Cardinal nchildren;
  11487.  
  11488.     frame = fe_CreateFrame(parent, name, p_args, p_n);
  11489.     XtManageChild(frame);
  11490.  
  11491.     n = 0;
  11492.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  11493.     rc = XmCreateRowColumn(frame, "textAlignment", args, n);
  11494.     XtManageChild(rc);
  11495.  
  11496.     n = 0;
  11497.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  11498.     sub_rc = XmCreateRowColumn(rc, "horizontal", args, n);
  11499.     XtManageChild(sub_rc);
  11500.  
  11501.     nchildren = 0;
  11502.     n = 0;
  11503.     horizontal_label = XmCreateLabelGadget(sub_rc, "horizontalLabel", args, n);
  11504.     children[nchildren++] = horizontal_label;
  11505.  
  11506.     n = 0;
  11507.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  11508.     XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
  11509.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  11510.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionHorizontalAlignment); n++;
  11511.     horizontal_alignment = fe_CreateSimpleRadioGroup(sub_rc,
  11512.                                              "horizontalAlignment", args, n);
  11513.     children[nchildren++] = horizontal_alignment;
  11514.  
  11515.     XtManageChildren(children, nchildren);
  11516.  
  11517.     n = 0;
  11518.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  11519.     sub_rc = XmCreateRowColumn(rc, "vertical", args, n);
  11520.     XtManageChild(sub_rc);
  11521.  
  11522.     nchildren = 0;
  11523.     n = 0;
  11524.     vertical_label = XmCreateLabelGadget(sub_rc, "verticalLabel", args, n);
  11525.     children[nchildren++] = vertical_label;
  11526.  
  11527.     n = 0;
  11528.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  11529.     XtSetArg(args[n], XmNpacking, XmPACK_COLUMN); n++;
  11530.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  11531.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionVerticalAlignment); n++;
  11532.     vertical_alignment = fe_CreateSimpleRadioGroup(sub_rc,
  11533.                                              "verticalAlignment", args, n);
  11534.     children[nchildren++] = vertical_alignment;
  11535.  
  11536.     XtManageChildren(children, nchildren);
  11537.  
  11538.     *v = vertical_alignment;
  11539.     *h = horizontal_alignment;
  11540.  
  11541.     return frame;
  11542. }
  11543.  
  11544. static Widget
  11545. fe_tables_row_properties_create(MWContext* context, Widget parent,
  11546.                      fe_EditorTablesRowStruct* w_data)
  11547. {
  11548.     Widget outside_form;
  11549.     Widget frame;
  11550.     Widget horizontal_alignment;
  11551.     Widget vertical_alignment;
  11552.     Widget bg_group;
  11553.     Arg args[16];
  11554.     Cardinal n;
  11555.     Widget children[8];
  11556.     Cardinal nchildren;
  11557.  
  11558.     outside_form = parent;
  11559.  
  11560.     nchildren = 0;
  11561.     n = 0;
  11562.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11563.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11564.     frame = fe_create_table_text_alignment_group(outside_form,
  11565.                                                  "textAlignment", args, n,
  11566.                                                  &horizontal_alignment,
  11567.                                                  &vertical_alignment);
  11568.     children[nchildren++] = frame;
  11569.  
  11570.     /*
  11571.      *    Background..
  11572.      */
  11573.     n = 0;
  11574.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11575.     XtSetArg(args[n], XmNtopWidget, frame); n++;
  11576.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11577.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  11578.     bg_group = fe_create_background_group(outside_form, "background", args, n);
  11579.     children[nchildren++] = bg_group;
  11580.  
  11581.     XtManageChildren(children, nchildren);
  11582.  
  11583.     w_data->horizontal_alignment = horizontal_alignment;
  11584.     w_data->vertical_alignment = vertical_alignment;
  11585.     w_data->bg_group = bg_group;
  11586.  
  11587.     return outside_form;
  11588. }
  11589.  
  11590. typedef struct fe_EditorTablesCellStruct
  11591. {
  11592.     Widget number_rows_text;
  11593.     Widget number_columns_text;
  11594.     Widget line_width_text;
  11595.     Widget horizontal_alignment;
  11596.     Widget vertical_alignment;
  11597.     Widget header_style;
  11598.     Widget wrap_text;
  11599.     Widget width_toggle;
  11600.     Widget width_text;
  11601.     Widget width_units;
  11602.     Widget height_toggle;
  11603.     Widget height_text;
  11604.     Widget height_units;
  11605.     Widget bg_group;
  11606.     LO_Color color_value;
  11607. } fe_EditorTablesCellStruct;
  11608.  
  11609. #if 1
  11610. static void
  11611. fe_cell_toggle_cb(Widget widget, XtPointer closure, XtPointer cb_data)
  11612. {
  11613.     fe_EditorTablesCellStruct* w_data = (fe_EditorTablesCellStruct*)closure;
  11614.     Boolean enabled = XmToggleButtonGetState(widget);
  11615.     MWContext* context = fe_WidgetToMWContext(widget);
  11616.     Widget  text = NULL;
  11617.     Widget  radio = NULL;
  11618.  
  11619.     if (widget == w_data->width_toggle) {
  11620.         text = w_data->width_text;
  11621.         radio = w_data->width_units;
  11622.     } else if (widget == w_data->height_toggle) {
  11623.         text = w_data->height_text;
  11624.         radio = w_data->height_units;
  11625.     }
  11626.  
  11627.     if (text != NULL)
  11628.         fe_TextFieldSetEditable(context, text, enabled);
  11629.     if (radio != NULL)
  11630.         fe_SimpleRadioGroupSetSensitive(radio, enabled);
  11631. }
  11632. #else
  11633. static void
  11634. fe_cell_toggle_cb(Widget widget, XtPointer closure, XtPointer cb_data)
  11635. {
  11636.     Widget  first = (Widget)closure;
  11637.     Boolean enabled = XmToggleButtonGetState(widget);
  11638.     MWContext* context = fe_WidgetToMWContext(widget);
  11639.     Widget*  children;
  11640.     Cardinal num_children;
  11641.     Cardinal i;
  11642.     Widget*  group = NULL;
  11643.  
  11644.     XtVaGetValues(XtParent(widget),
  11645.                   XmNchildren, &children,
  11646.                   XmNnumChildren, &num_children, 0);
  11647.  
  11648.     for (i = 0; i < num_children; i++) {
  11649.         if (children[i] == first) {
  11650.             group = &children[i];
  11651.             break;
  11652.         }
  11653.     }
  11654.  
  11655.     if (!group)
  11656.           return;
  11657.  
  11658.     for (i = 0; i < 3; i++) {
  11659.         if (group[i] == widget)
  11660.             break;
  11661.     }
  11662.  
  11663.     if (i == 0 || i == 1) { /* width & height */
  11664.         fe_TextFieldSetEditable(context, group[i+3], enabled);
  11665.         fe_SimpleRadioGroupSetSensitive(group[i+6], enabled);
  11666.     } else if (i == 2) { /* color */
  11667.         XtVaSetValues(group[i+3], XmNsensitive, enabled, 0);
  11668.     }
  11669. }
  11670.  
  11671. #endif
  11672.  
  11673. static Widget
  11674. fe_tables_cell_properties_create(MWContext* context, Widget parent,
  11675.                      fe_EditorTablesCellStruct* w_data)
  11676. {
  11677.     Widget form;
  11678.     Widget rows_label;
  11679.     Widget rows_text;
  11680.     Widget columns_label;
  11681.     Widget columns_text;
  11682.     Widget columns_units;
  11683.     Widget horizontal_alignment;
  11684.     Widget vertical_alignment;
  11685.     Widget align_frame;
  11686.     Widget other_frame;
  11687.     Widget rc;
  11688.     Widget header_style;
  11689.     Widget wrap_text;
  11690.     Widget width_toggle;
  11691.     Widget width_text;
  11692.     Widget width_units;
  11693.     Widget height_toggle;
  11694.     Widget height_text;
  11695.     Widget height_units;
  11696.     Widget bg_group;
  11697.     Arg args[16];
  11698.     Cardinal n;
  11699.     Cardinal nchildren = 0;
  11700.     Widget children[20];
  11701.     Dimension left_offset;
  11702.  
  11703.     form = parent;
  11704.  
  11705.     n = 0;
  11706.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11707.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11708.     rows_label = XmCreateLabelGadget(form, "cellRowsLabel", args, n);
  11709.     children[nchildren++] = rows_label;
  11710.  
  11711.     n = 0;
  11712.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11713.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11714.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  11715.     XtSetArg(args[n], XmNcolumns, 4); n++;
  11716.     rows_text = fe_CreateTextField(form, "cellRowsText", args, n);
  11717.     children[nchildren++] = rows_text;
  11718.  
  11719.     n = 0;
  11720.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11721.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11722.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  11723.     columns_label = XmCreateLabelGadget(form, "cellColumnsLabel", args, n);
  11724.     children[nchildren++] = columns_label;
  11725.  
  11726.     n = 0;
  11727.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11728.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11729.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  11730.     XtSetArg(args[n], XmNcolumns, 4); n++;
  11731.     columns_text = fe_CreateTextField(form, "cellColumnsText", args, n);
  11732.     children[nchildren++] = columns_text;
  11733.  
  11734.     n = 0;
  11735.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  11736.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11737.     XtSetArg(args[n], XmNleftWidget, children[nchildren-1]); n++;
  11738.     columns_units = XmCreateLabelGadget(form, "cellColumnsUnits", args, n);
  11739.     children[nchildren++] = columns_units;
  11740.  
  11741.     n = 0;
  11742.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11743.     XtSetArg(args[n], XmNtopWidget, rows_text); n++;
  11744.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11745.     align_frame = fe_create_table_text_alignment_group(form, "textAlignment",
  11746.                                                       args, n,
  11747.                                                       &horizontal_alignment,
  11748.                                                       &vertical_alignment);
  11749.     children[nchildren++] = align_frame;
  11750.  
  11751.     n = 0;
  11752.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11753.     XtSetArg(args[n], XmNtopWidget, rows_text); n++;
  11754.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11755.     XtSetArg(args[n], XmNleftWidget, align_frame); n++;
  11756.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  11757.     XtSetArg(args[n], XmNbottomWidget, align_frame); n++;
  11758.     other_frame = fe_CreateFrame(form, "textOther", args, n);
  11759.     children[nchildren++] = other_frame;
  11760.  
  11761.     n = 0;
  11762.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  11763.     rc = XmCreateRowColumn(other_frame, "textOther", args, n);
  11764.     XtManageChild(rc);
  11765.  
  11766.     n = 0;
  11767.     header_style = XmCreateToggleButtonGadget(rc, "headerStyle", args, n);
  11768.     XtManageChild(header_style);
  11769.  
  11770.     n = 0;
  11771.     wrap_text = XmCreateToggleButtonGadget(rc, "nonBreaking", args, n);
  11772.     XtManageChild(wrap_text);
  11773.  
  11774.     XtManageChildren(children, nchildren); nchildren = 0;
  11775.  
  11776.     n = 0;
  11777.     width_toggle = XmCreateToggleButtonGadget(form, "cellWidthToggle",
  11778.                                               args, n);
  11779.     children[nchildren++] = width_toggle;
  11780.  
  11781.     n = 0;
  11782.     height_toggle = XmCreateToggleButtonGadget(form, "cellHeightToggle",
  11783.                                               args, n);
  11784.     children[nchildren++] = height_toggle;
  11785.  
  11786.     left_offset = fe_get_offset_from_widest(children, nchildren);
  11787.  
  11788.     n = 0;
  11789.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11790.     XtSetArg(args[n], XmNtopWidget, align_frame); n++;
  11791.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11792.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  11793.     XtSetArg(args[n], XmNcolumns, 4); n++;
  11794.     width_text = fe_CreateTextField(form, "cellWidthText", args, n);
  11795.     children[nchildren++] = width_text;
  11796.  
  11797.     n = 0;
  11798.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11799.     XtSetArg(args[n], XmNtopWidget, width_text); n++;
  11800.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  11801.     XtSetArg(args[n], XmNleftWidget, width_text); n++;
  11802.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  11803.     XtSetArg(args[n], XmNrightWidget, width_text); n++;
  11804.     height_text = fe_CreateTextField(form, "cellHeightText", args, n);
  11805.     children[nchildren++] = height_text;
  11806.  
  11807.     XtVaSetValues(width_toggle,
  11808.                   XmNleftAttachment, XmATTACH_FORM,
  11809.                   XmNtopAttachment, XmATTACH_WIDGET,
  11810.                   XmNtopWidget, align_frame,
  11811.                   0);
  11812.     XtAddCallback(width_toggle, XmNvalueChangedCallback, 
  11813.                   fe_cell_toggle_cb, (XtPointer)w_data);
  11814.  
  11815.     XtVaSetValues(height_toggle,
  11816.                   XmNleftAttachment, XmATTACH_FORM,
  11817.                   XmNtopAttachment, XmATTACH_WIDGET,
  11818.                   XmNtopWidget, width_text,
  11819.                   0);
  11820.     XtAddCallback(height_toggle, XmNvalueChangedCallback, 
  11821.                   fe_cell_toggle_cb, (XtPointer)w_data);
  11822.  
  11823.     n = 0;
  11824.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11825.     XtSetArg(args[n], XmNtopWidget, align_frame); n++;
  11826.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11827.     XtSetArg(args[n], XmNleftWidget, width_text); n++;
  11828.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  11829.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  11830.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  11831.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionPixelPercent); n++;
  11832.     width_units = fe_CreateSimpleRadioGroup(form, "widthUnits", args, n);
  11833.     children[nchildren++] = width_units;
  11834.  
  11835.     n = 0;
  11836.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  11837.     XtSetArg(args[n], XmNtopWidget, height_text); n++;
  11838.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  11839.     XtSetArg(args[n], XmNbottomWidget, height_text); n++;
  11840.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  11841.     XtSetArg(args[n], XmNleftWidget, width_text); n++;
  11842.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  11843.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  11844.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  11845.     XtSetArg(args[n], XmNbuttons, fe_SimpleOptionPixelPercent); n++;
  11846.     height_units = fe_CreateSimpleRadioGroup(form, "heightUnits", args, n);
  11847.     children[nchildren++] = height_units;
  11848.  
  11849.     /*
  11850.      *    Background..
  11851.      */
  11852.     n = 0;
  11853.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  11854.     XtSetArg(args[n], XmNtopWidget, height_text); n++;
  11855.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  11856.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  11857.     bg_group = fe_create_background_group(form, "background", args, n);
  11858.     children[nchildren++] = bg_group;
  11859.  
  11860.     XtManageChildren(children, nchildren);
  11861.  
  11862.     w_data->number_rows_text = rows_text;
  11863.     w_data->number_columns_text = columns_text;
  11864.     w_data->horizontal_alignment = horizontal_alignment;
  11865.     w_data->vertical_alignment = vertical_alignment;
  11866.     w_data->header_style = header_style;
  11867.     w_data->wrap_text = wrap_text;
  11868.     w_data->width_toggle = width_toggle;
  11869.     w_data->width_text = width_text;
  11870.     w_data->width_units = width_units;
  11871.     w_data->height_toggle = height_toggle;
  11872.     w_data->height_text = height_text;
  11873.     w_data->height_units = height_units;
  11874.     w_data->bg_group = bg_group;
  11875.  
  11876.     return form;
  11877. }
  11878.  
  11879. static void
  11880. fe_tables_cell_properties_init(MWContext* context,
  11881.                      fe_EditorTablesCellStruct* w_data)
  11882. {
  11883. #if 0
  11884.     Boolean is_nested = EDT_IsInsertPointInNestedTable(context);
  11885.     EDT_TableCellData cell_data;
  11886.     Boolean enabled = TRUE;
  11887.     Widget  widget;
  11888.  
  11889.     memset(&cell_data, 0, sizeof(EDT_TableCellData));
  11890.  
  11891.     if (!fe_EditorTableCellGetData(context, &cell_data)) {
  11892.         memset(&cell_data, 0, sizeof(EDT_TableCellData));
  11893.         cell_data.iColSpan = 1;
  11894.         cell_data.iRowSpan = 1;
  11895.         cell_data.align = ED_ALIGN_DEFAULT;
  11896.         cell_data.valign = ED_ALIGN_DEFAULT;
  11897.         cell_data.pColorBackground = NULL;
  11898.         enabled = FALSE;
  11899.     }
  11900.  
  11901.     fe_set_numeric_text_field(w_data->number_rows_text,
  11902.                               cell_data.iRowSpan);
  11903.     fe_TextFieldSetEditable(context, w_data->number_rows_text, enabled);
  11904.     fe_set_numeric_text_field(w_data->number_columns_text,
  11905.                               cell_data.iColSpan);
  11906.     fe_TextFieldSetEditable(context, w_data->number_columns_text, enabled);
  11907.  
  11908.     fe_SimpleRadioGroupSetWhich(w_data->horizontal_alignment,
  11909.                                 fe_ED_Alignment_to_index(cell_data.align));
  11910.     fe_SimpleRadioGroupSetSensitive(w_data->horizontal_alignment, enabled);
  11911.  
  11912.     fe_SimpleRadioGroupSetWhich(w_data->vertical_alignment,
  11913.                                 fe_ED_Alignment_to_index(cell_data.valign));
  11914.     fe_SimpleRadioGroupSetSensitive(w_data->vertical_alignment, enabled);
  11915.  
  11916.     XmToggleButtonGadgetSetState(w_data->header_style, cell_data.bHeader,
  11917.                                  FALSE);
  11918.     XtVaSetValues(w_data->header_style, XmNsensitive, enabled, 0);
  11919.     XmToggleButtonGadgetSetState(w_data->wrap_text, cell_data.bNoWrap, FALSE);
  11920.     XtVaSetValues(w_data->wrap_text, XmNsensitive, enabled, 0);
  11921.  
  11922.     fe_table_tbr_set(context, w_data->width_toggle,
  11923.                      w_data->width_text, w_data->width_units,
  11924.                      cell_data.bWidthDefined,
  11925.                      cell_data.iWidth,
  11926.                      (cell_data.bWidthPercent));
  11927.     XtVaSetValues(w_data->width_toggle, XmNsensitive, enabled, 0);
  11928.  
  11929.     widget = fe_SimpleRadioGroupGetChild(w_data->width_units, 1);
  11930.     fe_table_percent_label_set(widget, is_nested);
  11931.  
  11932.     fe_table_tbr_set(context, w_data->height_toggle,
  11933.                      w_data->height_text, w_data->height_units,
  11934.                      cell_data.bHeightDefined,
  11935.                      cell_data.iHeight,
  11936.                      (cell_data.bHeightPercent));
  11937.     XtVaSetValues(w_data->height_toggle, XmNsensitive, enabled, 0);
  11938.  
  11939.     widget = fe_SimpleRadioGroupGetChild(w_data->height_units, 1);
  11940.     fe_table_percent_label_set(widget, is_nested);
  11941.     
  11942.     /*
  11943.      *    Background stuff
  11944.      */
  11945.     fe_bg_group_set(w_data->bg_group,
  11946.                     cell_data.pColorBackground,
  11947.                     cell_data.pBackgroundImage,
  11948.                     cell_data.bBackgroundNoSave);
  11949. #else
  11950.     Boolean is_nested = EDT_IsInsertPointInNestedTable(context);
  11951.     EDT_TableCellData* cell_data = EDT_GetTableCellData(context);
  11952.     Boolean enabled = TRUE;
  11953.     Widget  widget;
  11954.  
  11955.     if (!cell_data) {
  11956.         cell_data = EDT_NewTableCellData();
  11957.         enabled = FALSE;
  11958.     }
  11959.  
  11960.     fe_set_numeric_text_field(w_data->number_rows_text,
  11961.                               cell_data->iRowSpan);
  11962.     fe_TextFieldSetEditable(context, w_data->number_rows_text, enabled);
  11963.     fe_set_numeric_text_field(w_data->number_columns_text,
  11964.                               cell_data->iColSpan);
  11965.     fe_TextFieldSetEditable(context, w_data->number_columns_text, enabled);
  11966.  
  11967.     fe_SimpleRadioGroupSetWhich(w_data->horizontal_alignment,
  11968.                                 fe_ED_Alignment_to_index(cell_data->align));
  11969.     fe_SimpleRadioGroupSetSensitive(w_data->horizontal_alignment, enabled);
  11970.  
  11971.     fe_SimpleRadioGroupSetWhich(w_data->vertical_alignment,
  11972.                                 fe_ED_Alignment_to_index(cell_data->valign));
  11973.     fe_SimpleRadioGroupSetSensitive(w_data->vertical_alignment, enabled);
  11974.  
  11975.     XmToggleButtonGadgetSetState(w_data->header_style, cell_data->bHeader,
  11976.                                  FALSE);
  11977.     XtVaSetValues(w_data->header_style, XmNsensitive, enabled, 0);
  11978.     XmToggleButtonGadgetSetState(w_data->wrap_text, cell_data->bNoWrap, FALSE);
  11979.     XtVaSetValues(w_data->wrap_text, XmNsensitive, enabled, 0);
  11980.  
  11981.     fe_table_tbr_set(context, w_data->width_toggle,
  11982.                      w_data->width_text, w_data->width_units,
  11983.                      cell_data->bWidthDefined,
  11984.                      cell_data->iWidth,
  11985.                      (cell_data->bWidthPercent));
  11986.     XtVaSetValues(w_data->width_toggle, XmNsensitive, enabled, 0);
  11987.  
  11988.     widget = fe_SimpleRadioGroupGetChild(w_data->width_units, 1);
  11989.     fe_table_percent_label_set(widget, is_nested);
  11990.  
  11991.     fe_table_tbr_set(context, w_data->height_toggle,
  11992.                      w_data->height_text, w_data->height_units,
  11993.                      cell_data->bHeightDefined,
  11994.                      cell_data->iHeight,
  11995.                      (cell_data->bHeightPercent));
  11996.     XtVaSetValues(w_data->height_toggle, XmNsensitive, enabled, 0);
  11997.  
  11998.     widget = fe_SimpleRadioGroupGetChild(w_data->height_units, 1);
  11999.     fe_table_percent_label_set(widget, is_nested);
  12000.     
  12001.     /*
  12002.      *    Background stuff
  12003.      */
  12004.     fe_bg_group_set(w_data->bg_group,
  12005.                     cell_data->pColorBackground,
  12006.                     cell_data->pBackgroundImage,
  12007.                     cell_data->bBackgroundNoSave);
  12008.  
  12009.     EDT_FreeTableCellData(cell_data);
  12010. #endif
  12011. }
  12012.  
  12013. static void
  12014. fe_tables_cell_properties_set_validate_common(MWContext* context,
  12015.                                           EDT_TableCellData* cell_data,
  12016.                                           fe_EditorTablesCellStruct* w_data)
  12017. {
  12018.     unsigned index;
  12019.  
  12020.     cell_data->iRowSpan = 
  12021.         fe_get_numeric_text_field(w_data->number_rows_text);
  12022.     cell_data->iColSpan = 
  12023.         fe_get_numeric_text_field(w_data->number_columns_text);
  12024.      
  12025.     index = fe_SimpleRadioGroupGetWhich(w_data->horizontal_alignment);
  12026.     cell_data->align = fe_index_to_ED_Alignment(index, TRUE);
  12027.  
  12028.     index = fe_SimpleRadioGroupGetWhich(w_data->vertical_alignment);
  12029.     cell_data->valign = fe_index_to_ED_Alignment(index, FALSE);
  12030.  
  12031.     cell_data->bHeader = XmToggleButtonGadgetGetState(w_data->header_style);
  12032.     cell_data->bNoWrap = XmToggleButtonGadgetGetState(w_data->wrap_text);
  12033.  
  12034.     cell_data->bWidthDefined = XmToggleButtonGetState(w_data->width_toggle);
  12035.     cell_data->iWidth = fe_get_numeric_text_field(w_data->width_text);
  12036.     cell_data->bWidthPercent =
  12037.       (fe_SimpleRadioGroupGetWhich(w_data->width_units) == 1);
  12038.  
  12039.     cell_data->bHeightDefined =
  12040.         XmToggleButtonGetState(w_data->height_toggle);
  12041.     cell_data->iHeight =
  12042.         fe_get_numeric_text_field(w_data->height_text);
  12043.     cell_data->bHeightPercent =
  12044.         (fe_SimpleRadioGroupGetWhich(w_data->height_units) == 1);
  12045.  
  12046. }
  12047.  
  12048. static Boolean
  12049. fe_tables_cell_properties_validate(MWContext* context,
  12050.                                    fe_EditorTablesCellStruct* w_data)
  12051. {
  12052.     EDT_TableCellData cell_data;
  12053.     EDT_TableCellData* c = &cell_data;
  12054.     unsigned         errors[16];
  12055.     unsigned         nerrors = 0;
  12056.     
  12057.     memset(&cell_data, 0, sizeof(EDT_TableCellData));
  12058.  
  12059.     fe_tables_cell_properties_set_validate_common(context,
  12060.                                                   &cell_data,
  12061.                                                   w_data);
  12062.  
  12063.     if (RANGE_CHECK(c->iRowSpan, TABLE_MIN_ROWS, TABLE_MAX_ROWS))
  12064.         errors[nerrors++] = XFE_INVALID_CELL_NROWS;
  12065.     if (RANGE_CHECK(c->iColSpan, TABLE_MIN_COLUMNS, TABLE_MAX_COLUMNS))
  12066.         errors[nerrors++] = XFE_INVALID_CELL_NCOLUMNS;
  12067.  
  12068.     if (c->bWidthDefined) {
  12069.         if (c->bWidthPercent) {
  12070.             if (RANGE_CHECK(c->iWidth,
  12071.                         TABLE_MIN_PERCENT_WIDTH, TABLE_MAX_PERCENT_WIDTH))
  12072.                 errors[nerrors++] = XFE_INVALID_CELL_WIDTH;
  12073.         } else {
  12074.             if (RANGE_CHECK(c->iWidth,
  12075.                             TABLE_MIN_PIXEL_WIDTH, TABLE_MAX_PIXEL_WIDTH))
  12076.                 errors[nerrors++] = XFE_INVALID_CELL_WIDTH;
  12077.         }
  12078.     }
  12079.         
  12080.     if (c->bHeightDefined) {
  12081.         if (c->bHeightPercent) {
  12082.             if (RANGE_CHECK(c->iHeight,
  12083.                         TABLE_MIN_PERCENT_HEIGHT, TABLE_MAX_PERCENT_HEIGHT))
  12084.                 errors[nerrors++] = XFE_INVALID_CELL_HEIGHT;
  12085.         } else {
  12086.             if (RANGE_CHECK(c->iHeight,
  12087.                             TABLE_MIN_PIXEL_HEIGHT, TABLE_MAX_PIXEL_HEIGHT))
  12088.                 errors[nerrors++] = XFE_INVALID_CELL_HEIGHT;
  12089.         }
  12090.     }
  12091.  
  12092.     if (nerrors > 0) {
  12093.         fe_editor_range_error_dialog(context, w_data->number_rows_text,
  12094.                                      errors, nerrors);
  12095.         return FALSE;
  12096.     }
  12097.  
  12098.     return TRUE;
  12099. }
  12100.  
  12101. static void
  12102. fe_tables_cell_properties_set(MWContext* context,
  12103.                               fe_EditorTablesCellStruct* w_data)
  12104. {
  12105.     EDT_TableCellData cell_data;
  12106.  
  12107.     memset(&cell_data, 0, sizeof(EDT_TableCellData));
  12108.  
  12109.     fe_tables_cell_properties_set_validate_common(context,
  12110.                                                   &cell_data,
  12111.                                                   w_data);
  12112.  
  12113.     /*
  12114.      *    Background stuff
  12115.      */
  12116.     fe_bg_group_get(w_data->bg_group,
  12117.                     &cell_data.pColorBackground,
  12118.                     &cell_data.pBackgroundImage,
  12119.                     &cell_data.bBackgroundNoSave);
  12120.  
  12121.     fe_EditorTableCellSetData(context, &cell_data);
  12122.  
  12123.     if (cell_data.pColorBackground)
  12124.         XP_FREE(cell_data.pColorBackground);
  12125.     if (cell_data.pBackgroundImage)
  12126.         XP_FREE(cell_data.pBackgroundImage);
  12127. }
  12128.  
  12129. static Widget
  12130. fe_CreateFolder(Widget parent, char* name, Arg* args, Cardinal n)
  12131. {
  12132.     Widget folder;
  12133.  
  12134.     folder = XtVaCreateWidget(name, xmlFolderWidgetClass, parent,
  12135.                               XmNshadowThickness, 2,
  12136.                               XmNtopAttachment, XmATTACH_FORM,
  12137.                               XmNleftAttachment, XmATTACH_FORM,
  12138.                               XmNrightAttachment, XmATTACH_FORM,
  12139.                               XmNbottomAttachment, XmATTACH_FORM,
  12140. #ifdef ALLOW_TAB_ROTATE
  12141.                               XmNtabPlacement, XmFOLDER_LEFT,
  12142.                               XmNrotateWhenLeftRight, FALSE,
  12143. #endif /* ALLOW_TAB_ROTATE */
  12144.                               XmNbottomOffset, 3,
  12145.                               XmNspacing, 1,
  12146.                               NULL);
  12147.  
  12148.     return folder;
  12149. }
  12150.  
  12151. void
  12152. fe_EditorTablePropertiesDialogDo(MWContext* context,
  12153.                                  fe_EditorPropertiesDialogType type)
  12154. {
  12155.     Widget dialog;
  12156.     Widget folder;
  12157.     Widget tab_form;
  12158.     int done;
  12159.     fe_EditorTablesTableStruct table;
  12160.     fe_EditorTablesRowStruct   row;
  12161.     fe_EditorTablesCellStruct  cell;
  12162.     Arg args[4];
  12163.     Cardinal n;
  12164.     unsigned tab_number;
  12165.  
  12166.     if (type == XFE_EDITOR_PROPERTIES_TABLE_ROW)
  12167.         tab_number = 1;
  12168.     else if (type == XFE_EDITOR_PROPERTIES_TABLE_CELL)
  12169.         tab_number = 2;
  12170.     else
  12171.         tab_number = 0;
  12172.  
  12173.     /*
  12174.      *    Make prompt with ok, cancel, no apply, separator.
  12175.      */
  12176.     dialog = fe_CreatePromptDialog(context, "tablePropertiesDialog",
  12177.                                  TRUE, TRUE, TRUE, FALSE, TRUE);
  12178.  
  12179.     n = 0;
  12180.     folder = fe_CreateFolder(dialog, "folder", args, n);
  12181.     XtManageChild(folder);
  12182.  
  12183.     n = 0;
  12184.     tab_form = fe_CreateTabForm(folder, "table", args, n);
  12185.     XtManageChild(tab_form);
  12186.     fe_tables_table_properties_create(context, tab_form, &table);
  12187.     fe_tables_table_properties_init(context, &table);
  12188.     
  12189.     n = 0;
  12190.     tab_form = fe_CreateTabForm(folder, "row", args, n);
  12191.     XtManageChild(tab_form);
  12192.     fe_tables_row_properties_create(context, tab_form, &row);
  12193.     fe_tables_row_properties_init(context, &row);
  12194.  
  12195.     n = 0;
  12196.     tab_form = fe_CreateTabForm(folder, "cell", args, n);
  12197.     XtManageChild(tab_form);
  12198.     fe_tables_cell_properties_create(context, tab_form, &cell);
  12199.     fe_tables_cell_properties_init(context, &cell);
  12200.  
  12201.     XmLFolderSetActiveTab(folder, tab_number, True);
  12202.  
  12203.     /*
  12204.      *   Add a bunch of callbacks to the buttons.
  12205.      */
  12206.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  12207.     XtAddCallback(dialog, XmNapplyCallback, fe_hrule_apply_cb, &done);
  12208.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  12209.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  12210.  
  12211.     /*
  12212.      *    Popup.
  12213.      */
  12214.     XtManageChild(dialog);
  12215.  
  12216.     /*
  12217.      *    Wait.
  12218.      */
  12219.     fe_NukeBackingStore(dialog); /* what does this do? */
  12220.  
  12221.     done = XmDIALOG_NONE;
  12222.     EDT_BeginBatchChanges(context);
  12223.     while (done == XmDIALOG_NONE) {
  12224.         fe_EventLoop();
  12225.  
  12226.         if (done == XmDIALOG_OK_BUTTON || done == XmDIALOG_APPLY_BUTTON) {
  12227.             /*
  12228.              *    We can only handle one lot of errors at a time.
  12229.              *    This a little dumb, but it shouldn't happen often.
  12230.              */
  12231.             if (fe_tables_table_properties_validate(context, &table)) {
  12232.                 fe_tables_table_properties_set(context, &table);
  12233.             } else {
  12234.                 done = XmDIALOG_NONE;
  12235.                 continue;
  12236.             }
  12237.  
  12238.             if (fe_tables_cell_properties_validate(context, &cell)) {
  12239.                 fe_tables_cell_properties_set(context, &cell);
  12240.             } else {
  12241.                 done = XmDIALOG_NONE;
  12242.                 continue;
  12243.             }
  12244.  
  12245.             fe_tables_row_properties_set(context, &row);
  12246.  
  12247.             if (done == XmDIALOG_APPLY_BUTTON)
  12248.                 done = XmDIALOG_NONE;
  12249.         }
  12250.     }
  12251.     EDT_EndBatchChanges(context);
  12252.  
  12253.     if (done != XFE_DIALOG_DESTROY_BUTTON)
  12254.         XtDestroyWidget(dialog);
  12255. }
  12256.  
  12257. typedef struct fe_PublishDialogStruct
  12258. {
  12259.     MWContext* context;
  12260.     Widget local_publish_info;
  12261.     Widget local_include_images;
  12262.     Widget local_include_files;
  12263.     Widget local_list;
  12264.     Widget local_select_all;
  12265.     Widget local_select_none;
  12266.     Widget publish_combo;
  12267.     Widget publish_location_text;
  12268.     Widget publish_username_text;
  12269.     Widget publish_password_text;
  12270.     Widget publish_save_password;
  12271.     Widget publish_use_default;
  12272.     Widget title_text;
  12273.     char*  url_pathname;
  12274.     char** files;
  12275. } fe_PublishDialogStruct;
  12276.  
  12277. static void
  12278. fe_publish_set_xmlist_from_data(fe_PublishDialogStruct* w_data)
  12279. {
  12280.     unsigned n;
  12281.     XmString xm_string;
  12282.     char*    s;
  12283.     char*    tmp;
  12284.  
  12285.     XmListDeleteAllItems(w_data->local_list);
  12286.  
  12287.     if (w_data->files == NULL)
  12288.         return;
  12289.  
  12290.     for (n = 0; w_data->files[n] != NULL; n++) {
  12291.  
  12292.         s = w_data->files[n];
  12293.         tmp = NULL;
  12294.  
  12295. #if 0
  12296.         dirlen = strlen(w_data->directory);
  12297.  
  12298.         /* windows does not clean this up, let's see how we go */
  12299.         if (strncmp(s, w_data->directory, dirlen) == 0 && s[dirlen] == '/') {
  12300.             tmp = XP_STRDUP(&s[dirlen+1]);
  12301.             s = tmp;
  12302.         }
  12303. #endif
  12304.  
  12305.         xm_string = XmStringCreateLocalized(s);
  12306.         XmListAddItem(w_data->local_list, xm_string, n+1);
  12307.         XmStringFree(xm_string);
  12308.         if (tmp != NULL)
  12309.             XP_FREE(tmp);
  12310.     }
  12311. }
  12312.  
  12313. static void
  12314. fe_publish_include_select_all(fe_PublishDialogStruct* w_data)
  12315. {
  12316.     unsigned n;
  12317.     unsigned nitems;
  12318.  
  12319.     XtVaGetValues(w_data->local_list, XmNitemCount, &nitems, 0);
  12320.  
  12321.     for (n = 0; n < nitems; n++)
  12322.         XmListSelectPos(w_data->local_list, n+1, FALSE);
  12323. }
  12324.  
  12325. static void
  12326. free_string_array(char** vector)
  12327. {
  12328.     unsigned n;
  12329.     if (vector) {
  12330.         for (n = 0; vector[n] != NULL; n++)
  12331.             XP_FREE(vector[n]);
  12332.         XP_FREE(vector);
  12333.     }
  12334. }
  12335.  
  12336. static void
  12337. fe_publish_set_include_all_files(fe_PublishDialogStruct* w_data)
  12338. {
  12339.     MWContext* context = w_data->context;
  12340.     char**     all_files;
  12341.     unsigned   nfiles;
  12342.     char* local_filename;
  12343.     char* p;
  12344.  
  12345.     free_string_array(w_data->files);
  12346.  
  12347.     XP_ConvertUrlToLocalFile(w_data->url_pathname, &local_filename);
  12348.  
  12349.     if (!local_filename) /* oops */
  12350.         return;
  12351.  
  12352.     /* get the directory name */
  12353.     p = XP_STRRCHR(local_filename, '/');
  12354.     if (p != NULL && p != local_filename)
  12355.         *p = '\0';
  12356.      
  12357.     all_files = NET_AssembleAllFilesInDirectory(context, local_filename);
  12358.  
  12359.     nfiles = 0;
  12360.     if (all_files != NULL) {
  12361.         for (; all_files[nfiles] != NULL; nfiles++) {
  12362.             p = all_files[nfiles];
  12363.             if (*p == '/') { /* absolute */
  12364.                 p = (char*)XP_ALLOC(XP_STRLEN(p) + 6);
  12365.                 XP_STRCPY(p, "file:");
  12366.                 XP_STRCAT(p, all_files[nfiles]);
  12367.                 XP_FREE(all_files[nfiles]);
  12368.                 all_files[nfiles] = p;
  12369.             }
  12370.         }
  12371.     }
  12372.  
  12373.     if (nfiles > 0) {
  12374.         w_data->files = all_files;
  12375.     } else {
  12376.         w_data->files = NULL;
  12377.     }
  12378.  
  12379.     fe_publish_set_xmlist_from_data(w_data);
  12380.     fe_publish_include_select_all(w_data);
  12381.  
  12382.     XmToggleButtonGadgetSetState(w_data->local_include_images, FALSE, FALSE);
  12383.     XmToggleButtonGadgetSetState(w_data->local_include_files, TRUE, FALSE);
  12384.  
  12385.     XP_FREE(local_filename);
  12386. }
  12387.  
  12388. static void
  12389. fe_publish_set_include_image_files(fe_PublishDialogStruct* w_data)
  12390. {
  12391.     MWContext* context = w_data->context;
  12392.     unsigned   len;
  12393.     char*      s;
  12394.     unsigned   n;
  12395.     unsigned   nfiles;
  12396.     char*      filenames;
  12397.     XP_Bool*   selected = NULL;
  12398.     Boolean    links_p;
  12399.  
  12400.     free_string_array(w_data->files);
  12401.  
  12402.     fe_EditorPreferencesGetLinksAndImages(context, NULL, &links_p);
  12403.  
  12404.     filenames = EDT_GetAllDocumentFilesSelected(context, &selected, links_p);
  12405.  
  12406.     nfiles = 0;
  12407.     if (filenames != NULL && selected != NULL) {
  12408.         for (s = filenames; (len = XP_STRLEN(s)) != 0; s += len + 1)
  12409.             nfiles++;
  12410.     }
  12411.     
  12412.     if (nfiles > 0) {
  12413.         w_data->files = (char**)XP_ALLOC((nfiles+1)*sizeof(char*));
  12414.  
  12415.         for (n = 0, s = filenames; *s != '\0'; n++, s += XP_STRLEN(s) + 1) {
  12416.             w_data->files[n] = XP_STRDUP(s);
  12417.         }
  12418.         w_data->files[n] = NULL;
  12419.  
  12420.     } else {
  12421.         w_data->files = NULL;
  12422.     }
  12423.     XP_FREEIF(filenames);
  12424.  
  12425.     fe_publish_set_xmlist_from_data(w_data);
  12426.  
  12427.     /* Files that are selected by default. */
  12428.     for (n = 0; n < nfiles; n++) {
  12429.       if (selected[n]) {
  12430.         XmListSelectPos(w_data->local_list, n+1, FALSE);
  12431.       }
  12432.     }
  12433.     XP_FREEIF(selected);
  12434.  
  12435.     /*
  12436.      *    Gray out if there are no images in doc.
  12437.      */
  12438. #if 0
  12439.     XtVaSetValues(w_data->local_include_images, XmNsensitive, (nfiles > 0), 0);
  12440. #endif
  12441.     XmToggleButtonGadgetSetState(w_data->local_include_images, TRUE, FALSE);
  12442.     XmToggleButtonGadgetSetState(w_data->local_include_files, FALSE, FALSE);
  12443. }
  12444.  
  12445. static void
  12446. fe_publish_include_image_files_cb(Widget widget, XtPointer closure,
  12447.                                   XtPointer cb_data)
  12448. {
  12449.     XmToggleButtonCallbackStruct* info = 
  12450.         (XmToggleButtonCallbackStruct*)cb_data;
  12451.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12452.  
  12453.     if (!info->set)
  12454.         return;
  12455.  
  12456.     fe_publish_set_include_image_files(w_data);
  12457. }
  12458.  
  12459. static void
  12460. fe_publish_include_all_files_cb(Widget widget, XtPointer closure,
  12461.                                   XtPointer cb_data)
  12462. {
  12463.     XmToggleButtonCallbackStruct* info = 
  12464.         (XmToggleButtonCallbackStruct*)cb_data;
  12465.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12466.  
  12467.     if (!info->set)
  12468.         return;
  12469.  
  12470.     fe_publish_set_include_all_files(w_data);
  12471. }
  12472.  
  12473. static void
  12474. fe_publish_include_select_none_cb(Widget widget, XtPointer closure,
  12475.                                   XtPointer cb_data)
  12476. {
  12477.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12478.  
  12479.     XmListDeselectAllItems(w_data->local_list);
  12480. }
  12481.  
  12482. static void
  12483. fe_publish_include_select_all_cb(Widget widget, XtPointer closure,
  12484.                                   XtPointer cb_data)
  12485. {
  12486.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12487.     fe_publish_include_select_all(w_data);
  12488. }
  12489.  
  12490. static void
  12491. fe_publish_set_lup(fe_PublishDialogStruct* w_data,
  12492.                    char* location, char* username, char* password)
  12493. {
  12494.     if (location) {
  12495.         fe_TextFieldSetString(w_data->publish_location_text, location, FALSE);
  12496.         
  12497.         if (username) {
  12498.             fe_TextFieldSetString(w_data->publish_username_text,
  12499.                                   username, FALSE);
  12500.         } else {
  12501.             fe_TextFieldSetString(w_data->publish_username_text, "", FALSE);
  12502.         }
  12503.         
  12504.         if (password) {
  12505.             fe_TextFieldSetString(w_data->publish_password_text, password,
  12506.                                   FALSE);
  12507.             XtVaSetValues(w_data->publish_save_password, XmNset, TRUE, 0);
  12508.         } else {
  12509.             fe_TextFieldSetString(w_data->publish_password_text, "", FALSE);
  12510.             XtVaSetValues(w_data->publish_save_password, XmNset, FALSE, 0);
  12511.         }
  12512.     }
  12513. }
  12514.  
  12515. static void
  12516. fe_publish_combo_selection_cb(Widget w, XtPointer closure, XtPointer cb_data)
  12517. {
  12518.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12519.     DtComboBoxCallbackStruct* info = (DtComboBoxCallbackStruct*)cb_data;
  12520.     char* location;
  12521.     char* username;
  12522.     char* password;
  12523.  
  12524.     if (EDT_GetPublishingHistory(info->item_position,
  12525.                                  &location, &username, &password)) {
  12526. #if 0
  12527.         /* combo callback has already screwed us */
  12528.         char* target_file;
  12529.         char* last;
  12530.         int   len;
  12531.  
  12532.         /*
  12533.          *    If the new location is a directory, try to append the
  12534.          *    basename of the existing target onto the new location.
  12535.          */
  12536.         target_file = fe_TextFieldGetString(w_data->publish_location_text);
  12537.         if ((last = XP_STRRCHR(target_file, '/')) != NULL)
  12538.             last++;
  12539.         else
  12540.             last = target_file;
  12541.  
  12542.         len = XP_STRLEN(location);
  12543.         if (last != NULL && len > 0 && location[len-1] == '/') {
  12544.             char* tmp;
  12545.             len = len + XP_STRLEN(location) + 1;
  12546.             tmp = (char*)XP_ALLOC(len);
  12547.             XP_STRCPY(tmp, location);
  12548.             XP_STRCAT(tmp, last);
  12549.             XP_FREE(location);
  12550.             location = tmp;
  12551.         }
  12552.         XtFree(target_file);
  12553. #endif
  12554.  
  12555.         fe_publish_set_lup(w_data, location, username, password);
  12556.         if (location != NULL)
  12557.             XP_FREE(location);
  12558.         if (username != NULL)
  12559.             XP_FREE(username);
  12560.         if (password != NULL) {
  12561.             memset(password, 0, strlen(password));
  12562.             XP_FREE(password);
  12563.         }
  12564.     }
  12565. }
  12566.  
  12567. static void
  12568. fe_publish_use_default_cb(Widget widget, XtPointer closure,
  12569.                                   XtPointer cb_data)
  12570. {
  12571.     fe_PublishDialogStruct* w_data = (fe_PublishDialogStruct*)closure;
  12572.     char* location;
  12573.     char* username;
  12574.     char* password;
  12575.  
  12576.     fe_EditorPreferencesGetPublishLocation(w_data->context,
  12577.                                            &location,
  12578.                                            &username,
  12579.                                            &password);
  12580.  
  12581.     if (location) {
  12582.         fe_publish_set_lup(w_data, location, username, password);
  12583.         if (location != NULL)
  12584.             XP_FREE(location);
  12585.         if (username != NULL)
  12586.             XP_FREE(username);
  12587.         if (password != NULL) {
  12588.             memset(password, 0, strlen(password));
  12589.             XP_FREE(password);
  12590.         }
  12591.     }
  12592. }
  12593.  
  12594. static void
  12595. fe_publish_dialog_init(MWContext* context, fe_PublishDialogStruct* w_data)
  12596. {
  12597.     XmString xm_string;
  12598.     History_entry* hist_ent;
  12599.     char  buf[MAXPATHLEN];
  12600.     char* location_dir;
  12601.     char* location_file;
  12602.     char* location;
  12603.     char* username;
  12604.     char* password;
  12605.     char* title;
  12606.     Boolean has_default;
  12607.     Boolean save_password;
  12608.     int n;
  12609.  
  12610.     w_data->url_pathname = NULL;
  12611.  
  12612.     /* get the location */
  12613.     hist_ent = SHIST_GetCurrent(&context->hist);
  12614.     if(hist_ent && hist_ent->address) {
  12615.  
  12616.         w_data->url_pathname = XP_STRDUP(hist_ent->address);
  12617.  
  12618.         FE_CondenseURL(buf, w_data->url_pathname, 40);
  12619.  
  12620.         xm_string = XmStringCreateLtoR(buf,XmFONTLIST_DEFAULT_TAG);
  12621.         XtVaSetValues(w_data->local_publish_info,
  12622.                       XmNlabelString, xm_string, 0);
  12623.         XmStringFree(xm_string);
  12624.     }
  12625.  
  12626.     fe_publish_set_include_image_files(w_data);
  12627.  
  12628.     location_file = username = password = NULL; /* settle over-zealous BE */
  12629.     location_dir = EDT_GetDefaultPublishURL(context,
  12630.                                             &location_file,
  12631.                                             &username,
  12632.                                             &password);
  12633.  
  12634.     /*
  12635.      *    Set the title
  12636.      */
  12637.     if (!(title = fe_EditorDocumentGetTitle(context)))
  12638.         title = EDT_GetPageTitleFromFilename(location_file);
  12639.  
  12640.     if (title != NULL) {
  12641.         fe_TextFieldSetString(w_data->title_text, title, False);
  12642.         XP_FREE(title);
  12643.     } else {
  12644.         fe_TextFieldSetString(w_data->title_text, "", False);
  12645.     }
  12646.     
  12647.     XtVaSetValues(w_data->local_include_files, XmNsensitive,
  12648.                   (NET_IsLocalFileURL(w_data->url_pathname)), 0);
  12649.  
  12650.     /*
  12651.      *    Set the history list first, as comobo will always callback
  12652.      *    on text field and set the location - we don't always want that.
  12653.      */
  12654.     for (n = 0; EDT_GetPublishingHistory(n, &location, 0, 0); n++) {
  12655.         xm_string = XmStringCreateLocalized(location);
  12656.         DtComboBoxAddItem(w_data->publish_combo, xm_string, n + 1, FALSE);
  12657.         XmStringFree(xm_string);
  12658.         XP_FREE(location);
  12659.     }
  12660.  
  12661.     if (n > 0) {
  12662.         XtVaSetValues(w_data->publish_combo,
  12663.                       XmNvisibleItemCount, (XtPointer)n,
  12664.                       0);
  12665.     } else {
  12666.         Widget arrow = XtNameToWidget(w_data->publish_combo, "ComboBoxArrow");
  12667.         XtVaSetValues(arrow, XmNsensitive, False, 0);
  12668.     }
  12669.  
  12670.     /*
  12671.      *    Setup lower half of dialog.
  12672.      */
  12673.     if (location_dir != NULL) {
  12674.         n = XP_STRLEN(location_dir) + 1;
  12675.         if (location_file != NULL)
  12676.             n += XP_STRLEN(location_file) + 1;
  12677.  
  12678.         location = (char*)XP_ALLOC(n);
  12679.         XP_STRCPY(location, location_dir);
  12680.         
  12681.         if (location_file != NULL)
  12682.             XP_STRCAT(location, location_file);
  12683.     } else {
  12684.         location = NULL;
  12685.     }
  12686.  
  12687.     save_password = (password != NULL);
  12688.     
  12689.     if (location) {
  12690.         fe_TextFieldSetString(w_data->publish_location_text, location, FALSE);
  12691.         XP_FREE(location);
  12692.     }
  12693.     
  12694.     if (username) {
  12695.         fe_TextFieldSetString(w_data->publish_username_text, username, FALSE);
  12696.         XP_FREE(username);
  12697.     }
  12698.     
  12699.     if (password) {
  12700.         fe_TextFieldSetString(w_data->publish_password_text, password, FALSE);
  12701.         memset(password, 0, strlen(password));
  12702.         XP_FREE(password);
  12703.     }
  12704.  
  12705.     /*
  12706.      *    Enable "Use Default Location"?
  12707.      */
  12708.     fe_EditorPreferencesGetPublishLocation(context, &location, NULL, NULL);
  12709.     if (location) {
  12710.         has_default = TRUE;
  12711.         XP_FREE(location);
  12712.     } else {
  12713.         has_default = FALSE;
  12714.     }
  12715.  
  12716.     XtVaSetValues(w_data->publish_use_default, XmNsensitive, has_default, 0);
  12717.     XtVaSetValues(w_data->publish_save_password, XmNset, save_password, 0);
  12718.     
  12719. }
  12720.  
  12721. Boolean
  12722. fe_EditorPublishFiles(MWContext* context,
  12723.                       char*      target_file,
  12724.                       char**     source_files,
  12725.                       char*      username,
  12726.                       char*      password)
  12727. {
  12728.     char*          full_location = NULL; /* MUST set to NULL */
  12729.     Boolean        rv;
  12730.     Boolean        links;
  12731.     Boolean        images;
  12732.     char*          primary_url = NULL;
  12733.     History_entry* hist_entry;
  12734.  
  12735.     rv = NET_MakeUploadURL(&full_location, target_file,
  12736.                            username, password);
  12737.  
  12738.     if (rv && full_location != NULL) {
  12739.  
  12740.         /* Get current history entry for source location */
  12741.         hist_entry = SHIST_GetCurrent(&context->hist);
  12742.         if (hist_entry != NULL
  12743.             && hist_entry->address != NULL
  12744.             && hist_entry->address[0] != '\0') {
  12745.             primary_url = hist_entry->address;
  12746.         } else {
  12747.             /* no source name. */
  12748.             /* Is there a define for file:///Untitled somewhere? */
  12749.             primary_url = "file:///Untitled";
  12750.         }
  12751.  
  12752.         fe_EditorPreferencesGetLinksAndImages(context, &links, &images);
  12753.  
  12754.         /*
  12755.          *    NOTE: we must donate source_files to the back-end,
  12756.          *    it will be freed there. All other arguments we own.
  12757.          */
  12758.         EDT_PublishFile(context, ED_FINISHED_REVERT_BUFFER,
  12759.                         primary_url,
  12760.                         source_files, full_location,
  12761.                         images, links, FALSE);
  12762.  
  12763.         XP_FREE(full_location);
  12764.  
  12765.         return TRUE;
  12766.     } else {
  12767.         return FALSE;
  12768.     }
  12769. }
  12770.  
  12771. static Boolean
  12772. fe_publish_dialog_validate(MWContext* context, fe_PublishDialogStruct* w_data)
  12773. {
  12774.     char* target_file;
  12775.     Boolean rv  = TRUE;
  12776.  
  12777.     target_file = fe_TextFieldGetString(w_data->publish_location_text);
  12778.  
  12779.     fe_StringTrim(target_file);
  12780.  
  12781.     /*
  12782.      *    Use new call in BE. This guy also posts the alert (via FE_Confirm).
  12783.      *    So we don't need to do a dialog ourselves. But, we don't get to
  12784.      *    place it either, sigh.
  12785.      */
  12786.     if (!EDT_CheckPublishURL(context, target_file))
  12787.         rv = FALSE;
  12788.  
  12789.     XtFree(target_file);
  12790.     return rv;
  12791. }
  12792.  
  12793. static void
  12794. fe_publish_dialog_set(MWContext* context, fe_PublishDialogStruct* w_data)
  12795. {
  12796.     int* items;
  12797.     int  nitems;
  12798.     int n;
  12799.     int item;
  12800.     char* target_file;
  12801.     char* username;
  12802.     char* password;
  12803.     char** source_files;
  12804.     Boolean  save_password;
  12805.     char* title;
  12806.  
  12807.     XmListGetSelectedPos(w_data->local_list, &items, &nitems);
  12808.  
  12809.     source_files = (char**)XP_ALLOC(sizeof(char*) * (nitems + 2));
  12810.  
  12811.     for (n = 0; n < nitems; n++) {
  12812.         item = items[n] - 1; /* XmList offset */
  12813.         source_files[n] = XP_STRDUP(w_data->files[item]); /* must do this */
  12814.     }
  12815.     source_files[n] = NULL;
  12816.  
  12817.     if (nitems > 0 && items != NULL) /* sometimes get non-zero items */
  12818.         XtFree((void*)items);
  12819.  
  12820.     target_file = fe_TextFieldGetString(w_data->publish_location_text);
  12821.     username = fe_TextFieldGetString(w_data->publish_username_text);
  12822.     password = fe_GetPasswdText(w_data->publish_password_text);
  12823.  
  12824.     fe_StringTrim(target_file);
  12825.     fe_StringTrim(username);
  12826.     fe_StringTrim(password);
  12827.  
  12828.     /*
  12829.      *    Save the location for next time.
  12830.      *
  12831.      *    Ok, this is totally wierd (but totally Motif). We were
  12832.      *    doing a GetValues() here, and we were doing it after the
  12833.      *    call to PublishFiles(). We would die in Xt event dispatch,
  12834.      *    with looked like a bogus mapnotify event. I suspect that
  12835.      *    this had something to do with the GetValues. PushBG's
  12836.      *    GetValues() does seem someone complicated, so 1) let's use
  12837.      *    a GetState() call (which just reads the boolean value in
  12838.      *    the widget), and do this before the call to publish,
  12839.      *    which we should probably do anyway.
  12840.      */
  12841.     save_password =
  12842.         XmToggleButtonGadgetGetState(w_data->publish_save_password);
  12843.  
  12844.     fe_EditorDefaultSetLastPublishLocation(context,
  12845.                                            target_file,
  12846.                                            username,
  12847.                                            save_password? password: NULL);
  12848.  
  12849.     /* title */
  12850.     title = fe_TextFieldGetString(w_data->title_text);
  12851.  
  12852.     if (title != NULL) {
  12853.         fe_EditorDocumentSetTitle(context, title);
  12854.         XtFree(title);
  12855.     }
  12856.  
  12857.     fe_EditorPublishFiles(context, target_file,
  12858.                           source_files, username, password);
  12859.  
  12860.     XtFree(target_file);
  12861.     XtFree(username);
  12862.     memset(password, 0, strlen(password));
  12863.     XtFree(password);
  12864. }
  12865.  
  12866. static void
  12867. fe_publish_dialog_delete(MWContext* context, fe_PublishDialogStruct* w_data)
  12868. {
  12869.     if (w_data->url_pathname)
  12870.         XtFree(w_data->url_pathname);
  12871.     free_string_array(w_data->files);
  12872. }
  12873.  
  12874. static void
  12875. fe_publish_dialog_create(MWContext* context, Widget parent,
  12876.                          fe_PublishDialogStruct* w_data)
  12877. {
  12878.     Widget form;
  12879.     Widget local_frame;
  12880.     Widget local_form;
  12881.     Widget local_publish_label;
  12882.     Widget local_publish_info;
  12883.     Widget local_include_label;
  12884.     Widget local_include_radio;
  12885.     Widget local_include_files;
  12886.     Widget local_include_images;
  12887.     Widget local_select_none;
  12888.     Widget local_select_all;
  12889.     Widget local_list;
  12890.     Widget list_parent;
  12891.  
  12892.     Widget publish_frame;
  12893.     Widget publish_form;
  12894.     Widget publish_label;
  12895.     Widget publish_drop;
  12896.     Widget publish_username_label;
  12897.     Widget publish_username_text;
  12898.     Widget publish_use_default;
  12899.     Widget publish_password_label;
  12900.     Widget publish_password_text;
  12901.     Widget publish_password_save;
  12902.  
  12903.     Widget title_frame;
  12904.     Widget title_text;
  12905.  
  12906.     Widget children[16];
  12907.     Cardinal nchildren;
  12908.     Cardinal n;
  12909.     Arg args[16];
  12910.     Dimension left_offset;
  12911.     Pixel parent_bg;
  12912.     Pixel select_bg;
  12913.     Dimension width;
  12914.     Widget fat_guy;
  12915.  
  12916.     Visual *v = 0;
  12917.     Colormap cmap = 0;
  12918.     Cardinal depth = 0;
  12919.  
  12920.     n = 0;
  12921.     form = XmCreateForm(parent, "publish", args, n);
  12922.     XtManageChild(form);
  12923.  
  12924.     n = 0;
  12925.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  12926.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  12927.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  12928.     local_frame = fe_CreateFrame(form, "localFiles", args, n);
  12929.     XtManageChild(local_frame);
  12930.  
  12931.     n = 0;
  12932.     local_form = XmCreateForm(local_frame, "localFiles", args, n);
  12933.     XtManageChild(local_form);
  12934.  
  12935.     nchildren = 0;
  12936.     n = 0;
  12937.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  12938.     local_publish_label = XmCreateLabelGadget(local_form, "publishLabel",
  12939.                                               args, n);
  12940.     children[nchildren++] = local_publish_label;
  12941.  
  12942.     n = 0;
  12943.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  12944.     local_include_label = XmCreateLabelGadget(local_form, "includeLabel",
  12945.                                               args, n);
  12946.     children[nchildren++] = local_include_label;
  12947.  
  12948.     n = 0;
  12949.     local_select_none = XmCreatePushButtonGadget(local_form, "selectNone",
  12950.                                               args, n);
  12951.     children[nchildren++] = local_select_none;
  12952.  
  12953.     n = 0;
  12954.     local_select_all = XmCreatePushButtonGadget(local_form, "selectAll",
  12955.                                               args, n);
  12956.     children[nchildren++] = local_select_all;
  12957.  
  12958.     left_offset = fe_get_offset_from_widest(children, nchildren);
  12959.  
  12960.     fat_guy = XfeBiggestWidget(TRUE, &children[nchildren-2], 2);
  12961.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  12962.  
  12963.     n = 0;
  12964.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  12965.     local_publish_info = XmCreateLabelGadget(local_form, "publishInfo",
  12966.                                              args, n);
  12967.     children[nchildren++] = local_publish_info;
  12968.  
  12969.     n = 0;
  12970.     XtSetArg(args[n], XmNradioBehavior, TRUE); n++;
  12971.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  12972.     local_include_radio = XmCreateRowColumn(local_form, "includeRadio",
  12973.                                             args, n);
  12974.     children[nchildren++] = local_include_radio;
  12975.  
  12976.     n = 0;
  12977.     XtSetArg(args[n], XmNbackground, &parent_bg); n++;
  12978.     XtGetValues(local_form, args, n);
  12979.     
  12980.     XmGetColors(XtScreen(parent), fe_cmap(context),
  12981.                 parent_bg, NULL, NULL, NULL, &select_bg);
  12982.  
  12983.     n = 0;
  12984.     XtSetArg(args[n], XmNvisibleItemCount, 5); n++;
  12985.     XtSetArg(args[n], XmNselectionPolicy, XmMULTIPLE_SELECT); n++;
  12986.     XtSetArg(args[n], XmNbackground, select_bg); n++;
  12987.     local_list = XmCreateScrolledList(local_form, "includeList",
  12988.                                               args, n);
  12989.     children[nchildren++] = list_parent = XtParent(local_list);
  12990.  
  12991.     /*
  12992.      *    Now do attachments.
  12993.      */
  12994.     n = 0;
  12995.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  12996.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  12997.     XtSetValues(local_publish_label, args, n);
  12998.  
  12999.     n = 0;
  13000.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13001.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13002.     XtSetArg(args[n], XmNtopWidget, local_publish_info); n++;
  13003.     XtSetValues(local_include_label, args, n);
  13004.  
  13005. #if 0
  13006.     n = 0;
  13007.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13008.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13009.     XtSetArg(args[n], XmNtopWidget, local_include_label); n++;
  13010.     XtSetArg(args[n], XmNwidth, width); n++;
  13011.     XtSetValues(local_select_none, args, n);
  13012.     
  13013.     n = 0;
  13014.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13015.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13016.     XtSetArg(args[n], XmNtopWidget, local_select_none); n++;
  13017.     XtSetArg(args[n], XmNwidth, width); n++;
  13018.     XtSetValues(local_select_all, args, n);
  13019.  
  13020. #else
  13021.     n = 0;
  13022.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13023.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
  13024.     XtSetArg(args[n], XmNbottomWidget, local_select_all); n++;
  13025.     XtSetArg(args[n], XmNwidth, width); n++;
  13026.     XtSetValues(local_select_none, args, n);
  13027.     
  13028.     n = 0;
  13029.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13030. #if 0
  13031.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  13032. #else
  13033.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13034.     XtSetArg(args[n], XmNbottomWidget, list_parent); n++;
  13035. #endif
  13036.     XtSetArg(args[n], XmNwidth, width); n++;
  13037.     XtSetValues(local_select_all, args, n);
  13038. #endif
  13039.  
  13040.     n = 0;
  13041.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  13042.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13043.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  13044.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13045.     XtSetValues(local_publish_info, args, n);
  13046.     
  13047.     n = 0;
  13048.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13049.     XtSetArg(args[n], XmNtopWidget, local_publish_info); n++;
  13050.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13051.     XtSetArg(args[n], XmNleftWidget, local_publish_info); n++;
  13052.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13053.     XtSetValues(local_include_radio, args, n);
  13054.     
  13055.     n = 0;
  13056.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13057.     XtSetArg(args[n], XmNtopWidget, local_include_radio); n++;
  13058.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13059.     XtSetArg(args[n], XmNleftWidget, local_publish_info); n++;
  13060.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13061. #if 0
  13062.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  13063. #endif
  13064.     XtSetValues(list_parent, args, n);
  13065.     
  13066.     XtManageChildren(children, nchildren);
  13067.  
  13068.     nchildren = 0;
  13069.     n = 0;
  13070.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  13071.     local_include_images = XmCreateToggleButtonGadget(local_include_radio,
  13072.                                                       "includeImages",
  13073.                                                       args, n);
  13074.     children[nchildren++] = local_include_images;
  13075.  
  13076.     n = 0;
  13077.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  13078.     local_include_files = XmCreateToggleButtonGadget(local_include_radio,
  13079.                                                       "includeAll",
  13080.                                                       args, n);
  13081.     children[nchildren++] = local_include_files;
  13082.  
  13083.     XtManageChildren(children, nchildren);
  13084.  
  13085.     XtManageChild(local_list);
  13086.  
  13087.     XtAddCallback(local_select_none, XmNactivateCallback,
  13088.                   fe_publish_include_select_none_cb, (XtPointer)w_data);
  13089.  
  13090.     XtAddCallback(local_select_all, XmNactivateCallback,
  13091.                   fe_publish_include_select_all_cb, (XtPointer)w_data);
  13092.  
  13093.     XtAddCallback(local_include_images, XmNvalueChangedCallback,
  13094.                   fe_publish_include_image_files_cb, (XtPointer)w_data);
  13095.  
  13096.     XtAddCallback(local_include_files, XmNvalueChangedCallback,
  13097.                   fe_publish_include_all_files_cb, (XtPointer)w_data);
  13098.  
  13099.     /*
  13100.      *    Title group.
  13101.      */
  13102.     n = 0;
  13103.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13104.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13105.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13106.     XtSetArg(args[n], XmNtopWidget, local_frame); n++;
  13107.     title_frame = fe_CreateFrame(form, "titleFrame", args, n);
  13108.     XtManageChild(title_frame);
  13109.  
  13110.     n = 0;
  13111.     title_text = fe_CreateTextField(title_frame, "titleText", args, n);
  13112.     XtManageChild(title_text);
  13113.     
  13114.     /*
  13115.      *    Publish group.
  13116.      */
  13117.     n = 0;
  13118.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13119.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13120.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13121.     XtSetArg(args[n], XmNtopWidget, title_frame); n++;
  13122.     publish_frame = fe_CreateFrame(form, "publishLocation", args, n);
  13123.     XtManageChild(publish_frame);
  13124.  
  13125.     n = 0;
  13126.     publish_form = XmCreateForm(publish_frame, "publishLocation", args, n);
  13127.     XtManageChild(publish_form);
  13128.  
  13129.     nchildren = 0;
  13130.     n = 0;
  13131.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  13132.     publish_label = XmCreateLabelGadget(publish_form, "publishLabel", args, n);
  13133.     children[nchildren++] = publish_label;
  13134.  
  13135.     n = 0;
  13136. #if 0
  13137.     publish_drop = fe_CreateTextField(publish_form, "publishDrop", args, n);
  13138. #else
  13139.     XtVaGetValues(CONTEXT_WIDGET(context), XtNvisual, &v, XtNcolormap, &cmap,
  13140.                   XtNdepth, &depth, 0);
  13141.  
  13142.     n = 0;
  13143.     XtSetArg(args[n], XmNvisual, v); n++;
  13144.     XtSetArg(args[n], XmNdepth, depth); n++;
  13145.     XtSetArg(args[n], XmNcolormap, cmap); n++;
  13146.     XtSetArg(args[n], XmNtype, XmDROP_DOWN_COMBO_BOX); n++;
  13147.     XtSetArg(args[n], XmNshadowThickness, 1); n++;
  13148.     XtSetArg(args[n], XmNmarginWidth, 0); n++;
  13149.     XtSetArg(args[n], XmNmarginHeight, 0); n++;
  13150.     XtSetArg(args[n], XmNarrowType, XmMOTIF); n++;
  13151.     XtSetArg(args[n], XmNupdateLabel, False); n++;
  13152.     publish_drop = DtCreateComboBox(publish_form,
  13153.                                     "publishDrop",
  13154.                                     args, n);
  13155.     XtAddCallback(publish_drop, XmNselectionCallback,
  13156.                   fe_publish_combo_selection_cb, w_data);
  13157. #endif
  13158.     children[nchildren++] = publish_drop;
  13159.  
  13160.     n = 0;
  13161.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  13162.     publish_username_label = XmCreateLabelGadget(publish_form, "usernameLabel",
  13163.                                                  args, n);
  13164.     children[nchildren++] = publish_username_label;
  13165.  
  13166.     n = 0;
  13167.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  13168.     publish_password_label = XmCreateLabelGadget(publish_form, "passwordLabel",
  13169.                                                  args, n);
  13170.     children[nchildren++] = publish_password_label;
  13171.  
  13172.     left_offset = fe_get_offset_from_widest(&children[nchildren-2], 2);
  13173.  
  13174.     n = 0;
  13175.     publish_username_text = fe_CreateTextField(publish_form, "usernameText",
  13176.                                                args, n);
  13177.     children[nchildren++] = publish_username_text;
  13178.  
  13179.     n = 0;
  13180.     publish_use_default = XmCreatePushButtonGadget(publish_form,
  13181.                                                    "useDefault",
  13182.                                                    args, n);
  13183.     children[nchildren++] = publish_use_default;
  13184.  
  13185.     XtAddCallback(publish_use_default, XmNactivateCallback,
  13186.                   fe_publish_use_default_cb, (XtPointer)w_data);
  13187.  
  13188.     n = 0;
  13189.     XtSetArg(args[n], XmNmaxLength, 1024); n++;
  13190.     publish_password_text = fe_CreatePasswordField(publish_form,
  13191.                                                    "passwordText",
  13192.                                                    args, n);
  13193.     children[nchildren++] = publish_password_text;
  13194.  
  13195.     n = 0;
  13196.     publish_password_save = XmCreateToggleButtonGadget(publish_form,
  13197.                                                        "savePassword",
  13198.                                                        args, n);
  13199.     children[nchildren++] = publish_password_save;
  13200.     
  13201.     /*
  13202.      *    Attachments.
  13203.      */
  13204.     n = 0;
  13205.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13206.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  13207.     XtSetValues(publish_label, args, n);
  13208.     
  13209.     n = 0;
  13210.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13211.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  13212.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13213.     XtSetArg(args[n], XmNtopWidget, publish_label); n++;
  13214.     XtSetValues(publish_drop, args, n);
  13215.     
  13216.     n = 0;
  13217.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13218.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13219.     XtSetArg(args[n], XmNtopWidget, publish_drop); n++;
  13220.     XtSetValues(publish_username_label, args, n);
  13221.     
  13222.     n = 0;
  13223.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13224.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13225.     XtSetArg(args[n], XmNtopWidget, publish_username_text); n++;
  13226.     XtSetValues(publish_password_label, args, n);
  13227.     
  13228.     n = 0;
  13229.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13230.     XtSetArg(args[n], XmNtopWidget, publish_drop); n++;
  13231.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  13232.     XtSetArg(args[n], XmNleftOffset, left_offset); n++;
  13233.     XtSetValues(publish_username_text, args, n);
  13234.     
  13235.     n = 0;
  13236.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13237.     XtSetArg(args[n], XmNtopWidget, publish_username_text); n++;
  13238.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13239.     XtSetArg(args[n], XmNleftWidget, publish_username_text); n++;
  13240.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13241.     XtSetArg(args[n], XmNrightWidget, publish_username_text); n++;
  13242.     XtSetValues(publish_password_text, args, n);
  13243.     
  13244.     n = 0;
  13245.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  13246.     XtSetArg(args[n], XmNleftWidget, publish_username_text); n++;
  13247.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13248.     XtSetArg(args[n], XmNtopWidget, publish_drop); n++;
  13249.     XtSetValues(publish_use_default, args, n);
  13250.     
  13251.     n = 0;
  13252.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  13253.     XtSetArg(args[n], XmNleftWidget, publish_use_default); n++;
  13254.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  13255.     XtSetArg(args[n], XmNtopWidget, publish_username_text); n++;
  13256.     XtSetValues(publish_password_save, args, n);
  13257.     
  13258.     XtManageChildren(children, nchildren);
  13259.  
  13260.     w_data->local_publish_info = local_publish_info;
  13261.     w_data->local_include_images = local_include_images;
  13262.     w_data->local_include_files = local_include_files;
  13263.     w_data->local_list = local_list;
  13264.     w_data->local_select_all = local_select_all;
  13265.     w_data->local_select_none = local_select_none;
  13266.     w_data->publish_combo = publish_drop;
  13267.     XtVaGetValues(publish_drop,
  13268.                   XmNtextField, &w_data->publish_location_text,
  13269.                   0);
  13270.  
  13271.     w_data->title_text = title_text;
  13272.  
  13273.     w_data->publish_username_text = publish_username_text;
  13274.     w_data->publish_password_text = publish_password_text;
  13275.     w_data->publish_save_password = publish_password_save;
  13276.     w_data->publish_use_default = publish_use_default;
  13277.     w_data->context = context;
  13278.     w_data->url_pathname = NULL;
  13279.     w_data->files = NULL;
  13280. }
  13281.  
  13282. Boolean
  13283. fe_EditorPublishDialogDo(MWContext* context)
  13284. {
  13285.     fe_PublishDialogStruct publish;
  13286.     Widget  dialog;
  13287.     int     done;
  13288.     Boolean rv;
  13289.  
  13290.     /*
  13291.      *    Make prompt with ok, cancel, no apply, separator.
  13292.      */
  13293.     dialog = fe_CreatePromptDialog(context, "publishFilesDialog",
  13294.                                    TRUE, TRUE, FALSE, FALSE, TRUE);
  13295.  
  13296.     fe_publish_dialog_create(context, dialog, &publish);
  13297.     fe_publish_dialog_init(context, &publish);
  13298.  
  13299.     /*
  13300.      *   Add a bunch of callbacks to the buttons.
  13301.      */
  13302.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  13303.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  13304.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  13305.  
  13306.     /*
  13307.      *    Popup.
  13308.      */
  13309.     XtManageChild(dialog);
  13310.  
  13311.     /*
  13312.      *    Wait.
  13313.      */
  13314.     fe_NukeBackingStore(dialog); /* what does this do? */
  13315.  
  13316.     done = XmDIALOG_NONE;
  13317.     while (done == XmDIALOG_NONE) {
  13318.         fe_EventLoop();
  13319.  
  13320.         if (done == XmDIALOG_OK_BUTTON) {
  13321.             if (!fe_publish_dialog_validate(context, &publish)) {
  13322.                 done = XmDIALOG_NONE;
  13323.             }
  13324.         }
  13325.     }
  13326.  
  13327.     /* something is wrong here - benjie */
  13328.     /* if you put in a wrong domain, but with http:// and ftp:// 
  13329.      * the following call will fail, and then we loose btn callback 
  13330.      * action and hangs, the problem traces to the exit routine
  13331.      * we send in to NET_GetURL. For the editor, the exit routine,
  13332.      * after poping up the error message, calls fe_EditorGetURLExitRoutine,
  13333.      * which calls fe_EventLoop, and the code loops in there, but don't
  13334.        * pick up click actions on the buttons in this dialog
  13335.      */
  13336.  
  13337.     /* ok, so the following line temporarilly fix the above problem 
  13338.      * by poping down the modal dialog.
  13339.      * this fixes 26903. - benjie
  13340.      */
  13341.     XtUnmanageChild(dialog); 
  13342.  
  13343.     if (done == XmDIALOG_OK_BUTTON) {
  13344.         fe_publish_dialog_set(context, &publish);
  13345.         rv = TRUE;
  13346.      } else {
  13347.         rv = FALSE;
  13348.     }
  13349.  
  13350.     fe_publish_dialog_delete(context, &publish);
  13351.  
  13352.     if (done != XFE_DIALOG_DESTROY_BUTTON) 
  13353.         XtDestroyWidget(dialog); 
  13354.  
  13355.     return rv;
  13356. }
  13357.  
  13358. int
  13359. fe_YesNoCancelDialog(MWContext* context, char* name, char* message)
  13360. {
  13361.     Widget dialog;
  13362.     Widget mainw = CONTEXT_WIDGET(context);
  13363.     Widget yes_button;
  13364.     Widget no_button;
  13365.     Arg    args[8];
  13366.     Cardinal n;
  13367.     Visual*  v;
  13368.     Colormap cmap;
  13369.     Cardinal depth;
  13370.     int done;
  13371.     XmString xm_message;
  13372.  
  13373.     /*
  13374.      *    Popup the shell first, so that we gurantee its realized 
  13375.      */
  13376.     XtPopup(mainw, XtGrabNone);
  13377.     
  13378.     /*
  13379.      *    Force the window to the front and de-iconify if needed 
  13380.      */
  13381.     XMapRaised(XtDisplay(mainw), XtWindow(mainw));
  13382.     
  13383.     XtVaGetValues(mainw, XtNvisual, &v, XtNcolormap, &cmap,
  13384.                   XtNdepth, &depth, 0);
  13385.  
  13386.     xm_message = XmStringCreateLtoR(message,XmFONTLIST_DEFAULT_TAG);
  13387.     n = 0;
  13388.     XtSetArg(args[n], XmNvisual, v); n++;
  13389.     XtSetArg(args[n], XmNdepth, depth); n++;
  13390.     XtSetArg(args[n], XmNcolormap, cmap); n++;
  13391.     XtSetArg(args[n], XmNtransientFor, mainw); n++;
  13392.       XtSetArg(args[n], XmNdialogStyle, XmDIALOG_PRIMARY_APPLICATION_MODAL); n++;
  13393.     XtSetArg(args[n], XmNdefaultButtonType, XmDIALOG_OK_BUTTON); n++;
  13394.     XtSetArg(args[n], XmNmessageString, xm_message); n++;
  13395.     dialog = XmCreateMessageDialog(mainw, name, args, n);
  13396.     XmStringFree(xm_message);
  13397.  
  13398.     /* Doesn't work as a create argument :-) */
  13399.     n = 0;
  13400.     XtSetArg(args[n], XmNdialogType, XmDIALOG_QUESTION); n++;
  13401.     XtSetValues(dialog, args, n);
  13402.  
  13403. #ifdef NO_HELP
  13404.     fe_UnmanageChild_safe(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  13405. #endif
  13406.  
  13407.     n = 0;
  13408.     yes_button = XmCreatePushButtonGadget(dialog, "yes", args, n);
  13409.     XtManageChild(yes_button);
  13410.  
  13411.     n = 0;
  13412.     no_button = XmCreatePushButtonGadget(dialog, "no", args, n);
  13413.     XtManageChild(no_button);
  13414.  
  13415.     fe_UnmanageChild_safe(XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON));
  13416.  
  13417.     XtAddCallback(dialog, XmNcancelCallback, fe_hrule_cancel_cb, &done);
  13418.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  13419.     XtAddCallback(yes_button, XmNactivateCallback, fe_hrule_ok_cb, &done);
  13420.     XtAddCallback(no_button, XmNactivateCallback, fe_hrule_apply_cb, &done);
  13421.  
  13422.     XtManageChild(dialog);
  13423.  
  13424.     done = XmDIALOG_NONE;
  13425.     while (done == XmDIALOG_NONE) {
  13426.         fe_EventLoop();
  13427.     }
  13428.     return done;
  13429. }
  13430.  
  13431. Boolean
  13432. fe_HintDialog(MWContext* context, char* message)
  13433. {
  13434.     Widget dialog;
  13435.     Widget mainw = CONTEXT_WIDGET(context);
  13436.     Arg    args[8];
  13437.     Cardinal n;
  13438.     Visual*  v;
  13439.     Colormap cmap;
  13440.     Cardinal depth;
  13441.     int done;
  13442.     Widget toggle_button;
  13443.     Widget toggle_row;
  13444.     XmString xm_message;
  13445.     Boolean  return_value;
  13446.  
  13447.     XtVaGetValues(mainw, XtNvisual, &v, XtNcolormap, &cmap,
  13448.                   XtNdepth, &depth, 0);
  13449.  
  13450.     xm_message = XmStringCreateLocalized(message);
  13451.  
  13452.     n = 0;
  13453.     XtSetArg(args[n], XmNvisual, v); n++;
  13454.     XtSetArg(args[n], XmNdepth, depth); n++;
  13455.     XtSetArg(args[n], XmNcolormap, cmap); n++;
  13456.     XtSetArg(args[n], XmNtransientFor, mainw); n++;
  13457.     XtSetArg(args[n], XmNdefaultButtonType, XmDIALOG_OK_BUTTON); n++;
  13458.     XtSetArg(args[n], XmNmessageString, xm_message); n++;
  13459.     dialog = XmCreateInformationDialog(mainw, "hintDialog", args, n);
  13460.     XmStringFree(xm_message);
  13461.  
  13462.     /*
  13463.      *    This is sooooooo lame. Dispite what the manual says, an
  13464.      *    additonal toggle button child is not placed above the push
  13465.      *    buttons, but rather along aside the. Stick the toggle in
  13466.      *    a row, just to get the thing to do what we want.
  13467.      */
  13468.     n = 0;
  13469.     toggle_row = XmCreateRowColumn(dialog, "dontDisplayAgainRow", args, n);
  13470.     XtManageChild(toggle_row);
  13471.     n = 0;
  13472.     XtSetArg(args [n], XmNindicatorType, XmN_OF_MANY); n++;
  13473.     toggle_button = XmCreateToggleButtonGadget(toggle_row, "dontDisplayAgain",
  13474.                                                args, n);
  13475.     XtManageChild(toggle_button);
  13476.  
  13477.     fe_UnmanageChild_safe(XmMessageBoxGetChild(dialog,XmDIALOG_CANCEL_BUTTON));
  13478. #ifdef NO_HELP
  13479.     fe_UnmanageChild_safe(XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON));
  13480. #endif
  13481.  
  13482.     XtAddCallback(dialog, XmNokCallback, fe_hrule_ok_cb, &done);
  13483.     XtAddCallback(dialog, XmNdestroyCallback, fe_hrule_destroy_cb, &done);
  13484.     
  13485.     XtManageChild(dialog);
  13486.  
  13487.     done = XmDIALOG_NONE;
  13488.     while (done == XmDIALOG_NONE) {
  13489.         fe_EventLoop();
  13490.     }
  13491.  
  13492.     if (done != XFE_DIALOG_DESTROY_BUTTON) {
  13493.         return_value = XmToggleButtonGetState(toggle_button);
  13494.         XtDestroyWidget(dialog);
  13495.         return return_value;
  13496.     }
  13497.  
  13498.     return FALSE;
  13499. }
  13500. #endif
  13501.