home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / src / PrefsDialogEditor.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  53.8 KB  |  1,840 lines
  1. /* -*- Mode: C++; tab-width: 4; 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.    PrefsDialogEditor.cpp -- the Editor page in XFE preferences dialogs
  20.    Created: Linda Wei <lwei@netscape.com>, 20-Nov-96.
  21.  */
  22.  
  23. #include "felocale.h"
  24. #include "structs.h"
  25. #include "fonts.h"
  26. #include "xpassert.h"
  27. #include "xfe.h"
  28. #include "e_kit.h"
  29. #include "prefapi.h"
  30. #include "PrefsDialog.h"
  31. #include "edttypes.h"
  32. #include "edt.h"
  33.  
  34. #include <Xm/Label.h>
  35. #include <Xm/LabelG.h>
  36. #include <Xm/CascadeBG.h>
  37. #include <Xm/PushB.h>
  38. #include <Xm/PushBG.h>
  39. #include <Xm/ToggleB.h>
  40. #include <Xm/ArrowBG.h>
  41. #include <Xm/Form.h>
  42. #include <Xm/Frame.h>
  43. #include <Xm/RowColumn.h>
  44. #include <Xm/LabelG.h> 
  45. #include <Xm/TextF.h> 
  46. #include <Xm/ToggleBG.h> 
  47. #include <Xfe/Xfe.h>
  48.  
  49. #define SWATCH_SIZE 60
  50.  
  51. #define RANGE_CHECK(o, a, b) ((o) < (a) || (o) > (b))
  52.  
  53. #define AUTOSAVE_MIN_PERIOD 0
  54. #define AUTOSAVE_MAX_PERIOD 600
  55.  
  56. extern int XFE_EDITOR_AUTOSAVE_PERIOD_RANGE;
  57. extern int XFE_EDITOR_PUBLISH_LOCATION_INVALID;
  58.  
  59. #define EDITOR_GENERAL_AUTHOR          (0x1<<0)
  60. #define EDITOR_GENERAL_HTML_EDITOR     (0x1<<1)
  61. #define EDITOR_GENERAL_IMAGE_EDITOR    (0x1<<2)
  62. #define EDITOR_GENERAL_TEMPLATE        (0x1<<3)
  63. #define EDITOR_GENERAL_AUTOSAVE        (0x1<<4)
  64.  
  65. #define EDITOR_PUBLISH_LINKS           (0x1<<0)
  66. #define EDITOR_PUBLISH_IMAGES          (0x1<<1)
  67. #define EDITOR_PUBLISH_PUBLISH         (0x1<<2)
  68. #define EDITOR_PUBLISH_BROWSE          (0x1<<3)
  69. #define EDITOR_PUBLISH_USERNAME        (0x1<<4)
  70. #define EDITOR_PUBLISH_PASSWORD        (0x1<<5)
  71. #define EDITOR_PUBLISH_PASSWORD_SAVE   (0x1<<6)
  72.  
  73. extern char* fe_PreviewPanelCreate_names[];
  74.  
  75. extern "C"
  76. {
  77.     char     *XP_GetString(int i);
  78.     Widget    fe_CreateFrame(Widget parent, char* name,  Arg* p_args, Cardinal p_n);
  79.     char*     fe_EditorDefaultGetTemplate();
  80.     XtPointer fe_GetUserData(Widget);
  81.     void      fe_TextFieldSetEditable(MWContext* context, Widget widget, Boolean editable);
  82.     void      fe_browse_file_of_text(MWContext *context, Widget text_field, Boolean dirp);
  83.     void      fe_browse_file_of_text_in_url(MWContext *context, Widget text_field, Boolean dirp);
  84.     void      fe_TextFieldSetString(Widget widget, char* value, Boolean notify);
  85.     void      fe_document_appearance_use_image_button_update_cb(Widget w, XtPointer closure,
  86.                                                                 XtPointer callData);
  87.     void      fe_document_appearance_use_image_cb(Widget w, XtPointer closure, XtPointer callData);
  88.     void      fe_document_appearance_use_image_update_cb(Widget w, XtPointer closure, XtPointer callData);
  89.     void      fe_document_appearance_image_text_cb(Widget w, XtPointer closure, XtPointer callData);
  90.     void      fe_document_appearance_image_text_update_cb(Widget w, XtPointer closure, XtPointer callData);
  91.     void      fe_document_appearance_image_text_browse_cb(Widget w, XtPointer closure, XtPointer callData);
  92.     void      fe_document_appearance_use_custom_cb(Widget w, XtPointer closure, XtPointer callData);
  93.     void      fe_document_appearance_use_custom_update_cb(Widget w, XtPointer closure,
  94.                                                           XtPointer callData);
  95.     void      fe_document_appearance_sensitized_update_cb(Widget w, XtPointer closure,
  96.                                                           XtPointer callData);
  97.     void      fe_document_appearance_swatch_update_cb(Widget w, XtPointer closure,
  98.                                                       XtPointer callData);
  99.     void      fe_document_appearance_preview_update_cb(Widget w, XtPointer closure,
  100.                                                        XtPointer callData);
  101.     void      fe_document_appearance_color_cb(Widget w, XtPointer closure, XtPointer callData);
  102.     void      fe_preview_panel_click_cb(Widget w, XtPointer closure, XtPointer callData);
  103.     void      fe_document_appearance_init(MWContext* context,
  104.                                           fe_EditorDocumentAppearancePropertiesStruct* w_data);
  105.     void      fe_document_appearance_set(MWContext* context,
  106.                                          fe_EditorDocumentAppearancePropertiesStruct* w_data);
  107.     void      fe_DependentListAddDependent(fe_DependentList** list_a,
  108.                                            Widget widget, fe_Dependency mask,
  109.                                            XtCallbackProc proc, XtPointer closure);
  110.     Widget    fe_CreateSwatch(Widget parent, char* name, Arg* p_args, Cardinal p_n);
  111.     Widget    fe_PreviewPanelCreate(Widget parent, char* name, Arg* p_args, Cardinal p_n);
  112.     Widget    fe_CreatePasswordField(Widget parent, char* name, Arg* args, Cardinal n);
  113.  
  114.     static void      fe_set_numeric_text_field(Widget widget, unsigned value);
  115.     static Widget    fe_GetBiggestWidget(Boolean horizontal, Widget* widgets, Cardinal n);
  116.     static int       fe_get_numeric_text_field(Widget widget);
  117.     static void      fe_error_dialog(MWContext* context, Widget parent, char* s);
  118. }
  119.  
  120. // ************************************************************************
  121. // *************************       Editor        *************************
  122. // ************************************************************************
  123.  
  124. // Member:       XFE_PrefsPageEditor
  125. // Description:  Constructor
  126. // Inputs:
  127. // Side effects: 
  128.  
  129. XFE_PrefsPageEditor::XFE_PrefsPageEditor(XFE_PrefsDialog *dialog)
  130.     : XFE_PrefsPage(dialog),
  131.       m_prefsDataEditor(0)
  132. {
  133. }
  134.  
  135. // Member:       ~XFE_PrefsPageEditor
  136. // Description:  Destructor
  137. // Inputs:
  138. // Side effects: 
  139.  
  140. XFE_PrefsPageEditor::~XFE_PrefsPageEditor()
  141. {
  142.     delete m_prefsDataEditor;
  143. }
  144.  
  145. // Member:       create
  146. // Description:  Creates page for Editor
  147. // Inputs:
  148. // Side effects: 
  149.  
  150. void XFE_PrefsPageEditor::create()
  151. {
  152.     Arg               av[50];
  153.     int               ac;
  154.  
  155.     PrefsDataEditor *fep = NULL;
  156.  
  157.     fep = new PrefsDataEditor;
  158.     memset(fep, 0, sizeof(PrefsDataEditor));
  159.     m_prefsDataEditor = fep;
  160.  
  161.     fep->context = getContext();
  162.     fep->prompt_dialog = getPrefsDialog()->getDialogChrome();
  163.  
  164.     MWContext *context = fep->context;
  165.     Widget     form;
  166.  
  167.     ac = 0;
  168.     XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  169.     XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  170.     XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  171.     XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  172.     form = XmCreateForm (m_wPageForm, "editor", av, ac);
  173.     XtManageChild (form);
  174.     m_wPage = fep->page = form;
  175.  
  176.     Widget frame1;
  177.     Widget form1;
  178.     Widget author_label;
  179.     Widget author_text;
  180.     Widget external_frame;
  181.     Widget external_form;
  182.     Widget html_label;
  183.     Widget html_text;
  184.     Widget html_browse;
  185.     Widget image_label;
  186.     Widget image_text;
  187.     Widget image_browse;
  188.     Widget template_label;
  189.     Widget template_text;
  190.     Widget template_restore;
  191.     Widget autosave_toggle;
  192.     Widget autosave_text;
  193.     Widget autosave_label;
  194.     Widget template_browse;
  195.     Widget children[16];
  196.     Cardinal  nchildren;
  197.     Arg       args[8];
  198.     Cardinal  n;
  199.     int labels_height;
  200.     int labels_width;
  201.  
  202.     n = 0;
  203.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  204.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  205.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  206.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
  207.     frame1 = XmCreateFrame(form, "frame1", args, n);
  208.     XtManageChild(frame1);
  209.  
  210.     n = 0;
  211.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  212.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  213.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  214.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
  215.     form1 = XmCreateForm(frame1, "form1", args, n);
  216.     XtManageChild(form1);
  217.  
  218.     nchildren = 0;
  219.  
  220.     n = 0;
  221.     author_label = XmCreateLabelGadget(form1, "authorLabel", args, n);
  222.     children[nchildren++] = author_label;
  223.  
  224.     n = 0;
  225.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_AUTHOR); n++;
  226.     author_text = fe_CreateTextField(form1, "authorText", args, n);
  227.     fep->author = author_text;
  228.     children[nchildren++] = author_text;
  229.     XtAddCallback(author_text, XmNvalueChangedCallback,
  230.                   cb_changed, (XtPointer)fep);
  231.  
  232.  
  233.     n = 0;
  234.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  235.     autosave_toggle = XmCreateToggleButtonGadget(form1,
  236.                  "autosaveEnable", args, n);
  237.     fep->autosave_toggle = autosave_toggle;
  238.     children[nchildren++] = autosave_toggle;
  239.     XtAddCallback(autosave_toggle, XmNvalueChangedCallback,
  240.                   cb_autosaveToggle, (XtPointer)fep);
  241.  
  242.  
  243.     n = 0;
  244.     XtSetArg(args[n], XmNcolumns, 4); n++;
  245.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_AUTOSAVE); n++;
  246.     autosave_text = fe_CreateTextField(form1, "autosaveText", args, n);
  247.     fep->autosave_text = autosave_text;
  248.     children[nchildren++] = autosave_text;
  249.     XtAddCallback(autosave_text, XmNvalueChangedCallback,
  250.                   cb_changed, (XtPointer)fep);
  251.  
  252.     n = 0;
  253.     autosave_label = XmCreateLabelGadget(form1,    "minutes", args, n);
  254.     children[nchildren++] = autosave_label;
  255.  
  256.  
  257.     n = 0;
  258.     template_label = XmCreateLabelGadget(form1, "locationLabel", args, n);
  259.     children[nchildren++] = template_label;
  260.  
  261.     n = 0;
  262.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_TEMPLATE); n++;
  263.     template_text = fe_CreateTextField(form1, "templateText", args, n);
  264.     children[nchildren++] = template_text;
  265.     fep->tmplate = template_text;
  266.     XtAddCallback(template_text, XmNvalueChangedCallback,
  267.                   cb_changed, (XtPointer)fep);
  268.  
  269.     n = 0;
  270.     template_restore = XmCreatePushButtonGadget(form1,
  271.                     "restoreDefault", args, n);
  272.     children[nchildren++] = template_restore;
  273.     fep->template_restore = template_restore;
  274.     XtAddCallback(template_restore, XmNactivateCallback,
  275.                   cb_restoreTemplate, (XtPointer)fep);
  276.  
  277.     n = 0;
  278.     template_browse = XmCreatePushButtonGadget(form1,
  279.                    "browseTemplate", args, n);
  280.     children[nchildren++] = template_browse;
  281.  
  282.     XtVaSetValues(template_browse, XmNuserData, template_text, 0);
  283.     XtAddCallback(template_browse, XmNactivateCallback,
  284.                   cb_browseTemplate, (XtPointer)fep);
  285.  
  286.     XtManageChildren(children, nchildren);
  287.  
  288.     labels_height = XfeVaGetTallestWidget(author_label,
  289.                       author_text,
  290.                       autosave_toggle,
  291.                       NULL);
  292.     
  293.     XtVaSetValues(author_label,
  294.                   XmNheight, labels_height,
  295.                   XmNtopAttachment, XmATTACH_FORM,
  296.                   XmNbottomAttachment, XmATTACH_NONE,
  297.                   XmNleftAttachment, XmATTACH_FORM,
  298.                   XmNrightAttachment, XmATTACH_NONE,
  299.                   NULL);
  300.  
  301.     XtVaSetValues(author_text,
  302.                   XmNheight, labels_height,
  303.                   XmNtopAttachment, XmATTACH_FORM,
  304.                   XmNbottomAttachment, XmATTACH_NONE,
  305.                   XmNleftAttachment, XmATTACH_WIDGET,
  306.                   XmNleftWidget, author_label,
  307.                   XmNrightAttachment, XmATTACH_NONE,
  308.                   NULL);
  309.  
  310.     XtVaSetValues(autosave_toggle,
  311.                   XmNheight, labels_height,
  312.                   XmNtopAttachment, XmATTACH_WIDGET,
  313.                   XmNtopWidget, author_label,
  314.                   XmNbottomAttachment, XmATTACH_NONE,
  315.                   XmNleftAttachment, XmATTACH_FORM,
  316.                   XmNrightAttachment, XmATTACH_NONE,
  317.                   NULL);
  318.  
  319.     XtVaSetValues(autosave_text,
  320.                   XmNheight, labels_height,
  321.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  322.                   XmNtopWidget, autosave_toggle,
  323.                   XmNbottomAttachment, XmATTACH_NONE,
  324.                   XmNleftAttachment, XmATTACH_WIDGET,
  325.                   XmNleftWidget, autosave_toggle,
  326.                   XmNrightAttachment, XmATTACH_NONE,
  327.                   NULL);
  328.  
  329.     XtVaSetValues(autosave_label,
  330.                   XmNheight, labels_height,
  331.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  332.                   XmNtopWidget, autosave_toggle,
  333.                   XmNbottomAttachment, XmATTACH_NONE,
  334.                   XmNleftAttachment, XmATTACH_WIDGET,
  335.                   XmNleftWidget, autosave_text,
  336.                   XmNrightAttachment, XmATTACH_NONE,
  337.                   NULL);
  338.  
  339.     XtVaSetValues(template_label,
  340.                   XmNheight, labels_height,
  341.                   XmNtopAttachment, XmATTACH_WIDGET,
  342.                   XmNtopWidget, autosave_toggle,
  343.                   XmNbottomAttachment, XmATTACH_NONE,
  344.                   XmNleftAttachment, XmATTACH_FORM,
  345.                   XmNrightAttachment, XmATTACH_NONE,
  346.                   NULL);
  347.  
  348.     XtVaSetValues(template_text,
  349.                   XmNheight, labels_height,
  350.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  351.                   XmNtopWidget, template_label,
  352.                   XmNbottomAttachment, XmATTACH_NONE,
  353.                   XmNleftAttachment, XmATTACH_WIDGET,
  354.                   XmNleftWidget, template_label,
  355.                   XmNrightAttachment, XmATTACH_FORM,
  356.                   NULL);
  357.  
  358.     XtVaSetValues(template_browse,
  359.                   XmNtopAttachment, XmATTACH_WIDGET,
  360.                   XmNtopWidget, template_text,
  361.                   XmNbottomAttachment, XmATTACH_NONE,
  362.                   XmNleftAttachment, XmATTACH_NONE,
  363.                   XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET,
  364.                   XmNrightWidget, template_text,
  365.                   NULL);
  366.  
  367.     XtVaSetValues(template_restore,
  368.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  369.                   XmNtopWidget, template_browse,
  370.                   XmNbottomAttachment, XmATTACH_NONE,
  371.                   XmNleftAttachment, XmATTACH_NONE,
  372.                   XmNrightAttachment, XmATTACH_WIDGET,
  373.                   XmNrightWidget, template_browse,
  374.                   XmNrightOffset, 8,
  375.                   NULL);
  376.  
  377.     n = 0;
  378.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  379.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  380.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  381.     XtSetArg(args[n], XmNtopWidget, frame1); n++;
  382.     XtSetArg(args[n], XmNtopOffset, 8); n++;
  383.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
  384.     external_frame = fe_CreateFrame(form, "externalFrame", args, n);
  385.     XtManageChild(external_frame);
  386.  
  387.     n = 0;
  388.     external_form = XmCreateForm(external_frame, "external", args, n);
  389.     XtManageChild(external_form);
  390.  
  391.     nchildren = 0;
  392.     n = 0;
  393.     html_label = XmCreateLabelGadget(external_form, "htmlLabel", args, n);
  394.     children[nchildren++] = html_label;
  395.  
  396.     n = 0;
  397.     image_label = XmCreateLabelGadget(external_form, "imageLabel", args, n);
  398.     children[nchildren++] = image_label;
  399.  
  400.     n = 0;
  401.     html_browse = XmCreatePushButtonGadget(external_form, "browse", args, n);
  402.     children[nchildren++] = html_browse;
  403.     fep->html_browse = html_browse;
  404.  
  405.     n = 0;
  406.     image_browse = XmCreatePushButtonGadget(external_form, "browse", args, n);
  407.     children[nchildren++] = image_browse;
  408.     fep->image_browse = image_browse;
  409.  
  410.     n = 0;
  411.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_HTML_EDITOR); n++;
  412.     html_text = fe_CreateTextField(external_form, "htmlText", args, n);
  413.     children[nchildren++] = html_text;
  414.     fep->html_editor = html_text;
  415.     XtAddCallback(html_text, XmNvalueChangedCallback,
  416.                   cb_changed, (XtPointer)fep);
  417.  
  418.     n = 0;
  419.     XtSetArg(args[n], XmNuserData, EDITOR_GENERAL_IMAGE_EDITOR); n++;
  420.     image_text = fe_CreateTextField(external_form, "imageText", args, n);
  421.     children[nchildren++] = image_text;
  422.     fep->image_editor = image_text;
  423.     XtAddCallback(image_text, XmNvalueChangedCallback,
  424.                   cb_changed, (XtPointer)fep);
  425.  
  426.     /*
  427.      *    Go back for browse callbacks
  428.      */
  429.     XtVaSetValues(image_browse, XmNuserData, image_text, 0);
  430.  
  431.     XtAddCallback(image_browse, XmNactivateCallback,
  432.                   cb_browseToTextField, (XtPointer)context);
  433.  
  434.     XtVaSetValues(html_browse, XmNuserData, html_text, 0);
  435.  
  436.     XtAddCallback(html_browse, XmNactivateCallback,
  437.                   cb_browseToTextField, (XtPointer)context);
  438.  
  439.     XtManageChildren(children, nchildren);
  440.  
  441.     /*
  442.      *    Attachments
  443.      */
  444.  
  445.     labels_width = XfeVaGetWidestWidget(html_label,
  446.                     image_label,
  447.                     NULL);
  448.  
  449.     labels_height = XfeVaGetTallestWidget(html_label,
  450.                       html_text,
  451.                       html_browse,
  452.                       NULL);
  453.     
  454.     XtVaSetValues(html_label,
  455.                   XmNheight, labels_height,
  456.                   RIGHT_JUSTIFY_VA_ARGS(html_label,labels_width),
  457.                   XmNtopAttachment, XmATTACH_FORM,
  458.                   XmNbottomAttachment, XmATTACH_NONE,
  459.                   NULL);
  460.  
  461.     XtVaSetValues(html_browse,
  462.                   XmNheight, labels_height,
  463.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  464.                   XmNtopWidget, html_label,
  465.                   XmNbottomAttachment, XmATTACH_NONE,
  466.                   XmNleftAttachment, XmATTACH_NONE,
  467.                   XmNrightAttachment, XmATTACH_FORM,
  468.                   NULL);
  469.  
  470.     XtVaSetValues(html_text,
  471.                   XmNheight, labels_height,
  472.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  473.                   XmNtopWidget, html_label,
  474.                   XmNbottomAttachment, XmATTACH_NONE,
  475.                   XmNleftAttachment, XmATTACH_WIDGET,
  476.                   XmNleftWidget, html_label,
  477.                   XmNrightAttachment, XmATTACH_WIDGET,
  478.                   XmNrightWidget, html_browse,
  479.                   NULL);
  480.  
  481.     XtVaSetValues(image_label,
  482.                   XmNheight, labels_height,
  483.                   RIGHT_JUSTIFY_VA_ARGS(image_label,labels_width),
  484.                   XmNtopAttachment, XmATTACH_WIDGET,
  485.                   XmNtopWidget, html_label,
  486.                   XmNbottomAttachment, XmATTACH_NONE,
  487.                   NULL);
  488.  
  489.     XtVaSetValues(image_browse,
  490.                   XmNheight, labels_height,
  491.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  492.                   XmNtopWidget, image_label,
  493.                   XmNbottomAttachment, XmATTACH_NONE,
  494.                   XmNleftAttachment, XmATTACH_NONE,
  495.                   XmNrightAttachment, XmATTACH_FORM,
  496.                   NULL);
  497.  
  498.     XtVaSetValues(image_text,
  499.                   XmNheight, labels_height,
  500.                   XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  501.                   XmNtopWidget, image_label,
  502.                   XmNbottomAttachment, XmATTACH_NONE,
  503.                   XmNleftAttachment, XmATTACH_WIDGET,
  504.                   XmNleftWidget, image_label,
  505.                   XmNrightAttachment, XmATTACH_WIDGET,
  506.                   XmNrightWidget, image_browse,
  507.                   NULL);
  508.  
  509.     setCreated(TRUE);
  510. }
  511.  
  512. // Member:       init
  513. // Description:  Initializes page for Editor
  514. // Inputs:
  515. // Side effects: 
  516.  
  517. void XFE_PrefsPageEditor::init()
  518. {
  519.     XP_ASSERT(m_prefsDataEditor);
  520.     PrefsDataEditor    *w_data = m_prefsDataEditor;
  521.     
  522.     char     *value;
  523.     char     *value2;
  524.     Boolean   as_enable;
  525.     unsigned  as_time;
  526.     MWContext *context = w_data->context;
  527.     Boolean sensitive;
  528.  
  529.     /* get the author */
  530.     if ((value = fe_EditorPreferencesGetAuthor(context)) != NULL)
  531.         fe_SetTextFieldAndCallBack(w_data->author, value);
  532.     sensitive = !PREF_PrefIsLocked("editor.author");
  533.     XtSetSensitive(w_data->author, sensitive);
  534.  
  535.     /* get the editors */
  536.     fe_EditorPreferencesGetEditors(context, &value, &value2);
  537.     if (value != NULL)
  538.         fe_SetTextFieldAndCallBack(w_data->html_editor, value);
  539.     sensitive = !PREF_PrefIsLocked("editor.html_editor");
  540.     XtSetSensitive(w_data->html_editor, sensitive);
  541.     XtSetSensitive(w_data->html_browse, sensitive);
  542.  
  543.     if (value2 != NULL)
  544.         fe_SetTextFieldAndCallBack(w_data->image_editor, value2);
  545.     sensitive = !PREF_PrefIsLocked("editor.image_editor");
  546.     XtSetSensitive(w_data->image_editor, sensitive);
  547.     XtSetSensitive(w_data->image_browse, sensitive);
  548.  
  549.     /* get the template */
  550.     if ((value = fe_EditorPreferencesGetTemplate(context)))
  551.         fe_SetTextFieldAndCallBack(w_data->tmplate, value);
  552.     sensitive = !PREF_PrefIsLocked("editor.template_location");
  553.     XtSetSensitive(w_data->tmplate, sensitive);
  554.     XtSetSensitive(w_data->template_restore, sensitive);
  555.  
  556.     /* get the autosave state */
  557.     fe_EditorPreferencesGetAutoSave(context, &as_enable, &as_time);
  558.     if (!as_enable)
  559.         as_time = 10;
  560.     
  561.     fe_set_numeric_text_field(w_data->autosave_text, as_time);
  562.     fe_TextFieldSetEditable(context, w_data->autosave_text, as_enable);
  563.     XmToggleButtonGadgetSetState(w_data->autosave_toggle, as_enable, FALSE);
  564.  
  565.     XtSetSensitive(w_data->autosave_text, !PREF_PrefIsLocked("editor.auto_save_delay"));
  566.     XtSetSensitive(w_data->autosave_toggle, !PREF_PrefIsLocked("editor.auto_save"));
  567.  
  568.     w_data->context = context;
  569.     w_data->changed = 0;
  570.  
  571.     setInitialized(TRUE);
  572. }
  573.  
  574. // Member:       verify
  575. // Description:  
  576. // Inputs:
  577. // Side effects: 
  578.  
  579. Boolean XFE_PrefsPageEditor::verify()
  580. {
  581.     PrefsDataEditor  *w_data = m_prefsDataEditor;
  582.     MWContext        *context = getContext();
  583.     Boolean           as_enable;
  584.     int               as_time;
  585.  
  586.     /* autosave */
  587.     if ((w_data->changed & EDITOR_GENERAL_AUTOSAVE) != 0) {
  588.         as_time = fe_get_numeric_text_field(w_data->autosave_text);
  589.         as_enable = XmToggleButtonGadgetGetState(w_data->autosave_toggle);
  590.         
  591.         if (as_time == 0)
  592.             as_enable = FALSE;
  593.         
  594.         if (as_enable) {
  595.             if (RANGE_CHECK(as_time,AUTOSAVE_MIN_PERIOD,AUTOSAVE_MAX_PERIOD)) {
  596.                 char* msg = XP_GetString(XFE_EDITOR_AUTOSAVE_PERIOD_RANGE);
  597.                 fe_error_dialog(context, w_data->autosave_text, msg);
  598.                 return FALSE;
  599.             }
  600.         }
  601.     }
  602.     return TRUE;
  603. }
  604.  
  605. // Member:       install
  606. // Description:  
  607. // Inputs:
  608. // Side effects: 
  609.  
  610. void XFE_PrefsPageEditor::install()
  611. {
  612.     PrefsDataEditor  *w_data = m_prefsDataEditor;
  613.     MWContext        *context = getContext();
  614.     char             *value;
  615.     Boolean           as_enable;
  616.     unsigned          as_time;
  617.  
  618.     EDT_BeginBatchChanges(context);
  619.  
  620.     if (w_data->changed != 0) {
  621.  
  622.         /* author */
  623.         if ((w_data->changed & EDITOR_GENERAL_AUTHOR) != 0) {
  624.             value = fe_GetTextField(w_data->author);
  625.             fe_EditorPreferencesSetAuthor(context, value);
  626.             XtFree(value);
  627.         }
  628.     
  629.         /* editors */
  630.         value = NULL;
  631.         if ((w_data->changed & EDITOR_GENERAL_HTML_EDITOR) != 0) {
  632.             value = fe_GetTextField(w_data->html_editor);
  633.             fe_EditorPreferencesSetEditors(context, value, NULL);
  634.             XtFree(value);
  635.         }
  636.  
  637.         if ((w_data->changed & EDITOR_GENERAL_IMAGE_EDITOR) != 0) {
  638.             value = fe_GetTextField(w_data->image_editor);
  639.             fe_EditorPreferencesSetEditors(context, NULL, value);
  640.             XtFree(value);
  641.         }
  642.  
  643.         /* template */
  644.         if ((w_data->changed & EDITOR_GENERAL_TEMPLATE) != 0) {
  645.             value = fe_GetTextField(w_data->tmplate);
  646.             fe_EditorPreferencesSetTemplate(context, value);
  647.             XtFree(value);
  648.         }
  649.  
  650.         /* autosave */
  651.         if ((w_data->changed & EDITOR_GENERAL_AUTOSAVE) != 0) {
  652.             as_time = fe_get_numeric_text_field(w_data->autosave_text);
  653.             as_enable = XmToggleButtonGadgetGetState(w_data->autosave_toggle);
  654.             fe_EditorPreferencesSetAutoSave(context, as_enable, as_time);
  655.         }
  656.         w_data->changed = 0;
  657.     }
  658.  
  659.     EDT_EndBatchChanges(context);
  660. }
  661.  
  662. // Member:       save
  663. // Description:  
  664. // Inputs:
  665. // Side effects: 
  666.  
  667. void XFE_PrefsPageEditor::save()
  668. {
  669.      // XFE_PrefsDialog   *theDialog = getPrefsDialog();
  670.     PrefsDataEditor   *fep = m_prefsDataEditor;
  671.     // MWContext         *context = theDialog->getContext();
  672.  
  673.     XP_ASSERT(fep);
  674.  
  675. #define SOMETHING_CHANGED() (fep->changed != 0)
  676.  
  677.     if (SOMETHING_CHANGED()) {
  678.  
  679.         // Install preferences
  680.  
  681.         install();
  682.     }
  683.  
  684. #undef SOMETHING_CHANGED
  685.  
  686.     fep->changed = 0;
  687. }
  688.  
  689. // Member:       getData
  690. // Description:  
  691. // Inputs:
  692. // Side effects: 
  693.  
  694. PrefsDataEditor *XFE_PrefsPageEditor::getData()
  695. {
  696.     return m_prefsDataEditor;
  697. }
  698.  
  699. // Member:       cb_restoreTemplate
  700. // Description:  
  701. // Inputs:
  702. // Side effects: 
  703.  
  704. void XFE_PrefsPageEditor::cb_restoreTemplate(Widget    /* widget */,
  705.                          XtPointer closure, 
  706.                          XtPointer /* call_data */)
  707. {
  708.     char* value;
  709.     PrefsDataEditor *w_data    = (PrefsDataEditor *)closure;
  710.  
  711.     /* get the template */
  712.     if ((value = fe_EditorDefaultGetTemplate()) == NULL)
  713.         value = "";
  714.  
  715.     fe_SetTextFieldAndCallBack(w_data->tmplate, value);
  716.  
  717.     w_data->changed |= EDITOR_GENERAL_TEMPLATE;
  718. }
  719.  
  720. // Member:       cb_changed
  721. // Description:  
  722. // Inputs:
  723. // Side effects: 
  724.  
  725. void XFE_PrefsPageEditor::cb_changed(Widget    widget,
  726.                      XtPointer closure, 
  727.                      XtPointer /* call_data */)
  728. {
  729.     PrefsDataEditor *w_data    = (PrefsDataEditor *)closure;
  730.     unsigned mask = (unsigned)fe_GetUserData(widget);
  731.  
  732.     w_data->changed |= mask;
  733. }
  734.  
  735. // Member:       cb_autosaveToggle
  736. // Description:  
  737. // Inputs:
  738. // Side effects: 
  739.  
  740. void XFE_PrefsPageEditor::cb_autosaveToggle(Widget    /* widget */,
  741.                         XtPointer closure,
  742.                         XtPointer call_data)
  743. {
  744.     PrefsDataEditor              *w_data = (PrefsDataEditor *)closure;
  745.     XmToggleButtonCallbackStruct *cb = (XmToggleButtonCallbackStruct*)call_data;
  746.  
  747.     fe_TextFieldSetEditable(w_data->context, w_data->autosave_text, cb->set);
  748.     w_data->changed |= EDITOR_GENERAL_AUTOSAVE;
  749. }
  750.  
  751. // Member:       cb_browseToTextField
  752. // Description:  
  753. // Inputs:
  754. // Side effects: 
  755.  
  756. void XFE_PrefsPageEditor::cb_browseToTextField(Widget    widget,
  757.                                                XtPointer closure, 
  758.                                                XtPointer /* call_data */)
  759. {
  760.     MWContext* context = (MWContext*)closure;
  761.     Widget     text_field = (Widget)fe_GetUserData(widget);
  762.  
  763.     fe_browse_file_of_text(context, text_field, FALSE);
  764. }
  765.  
  766. // Member:       cb_browseTemplate
  767. // Description:  
  768. // Inputs:
  769. // Side effects: 
  770.  
  771. void XFE_PrefsPageEditor::cb_browseTemplate(Widget    widget,
  772.                                             XtPointer closure, 
  773.                                             XtPointer /* call_data */)
  774. {
  775.     MWContext* context = (MWContext*)closure;
  776.     Widget     text_field = (Widget)fe_GetUserData(widget);
  777.  
  778.     fe_browse_file_of_text_in_url(context, text_field, FALSE);
  779. }
  780.  
  781. // ************************************************************************
  782. // *************************   Editor/Appearance  *************************
  783. // ************************************************************************
  784.  
  785. // Member:       XFE_PrefsPageEditorAppearance
  786. // Description:  Constructor
  787. // Inputs:
  788. // Side effects: 
  789.  
  790. XFE_PrefsPageEditorAppearance::XFE_PrefsPageEditorAppearance(XFE_PrefsDialog *dialog)
  791.     : XFE_PrefsPage(dialog),
  792.       m_prefsDataEditorAppearance(0)
  793. {
  794. }
  795.  
  796. // Member:       ~XFE_PrefsPageEditorAppearance
  797. // Description:  Destructor
  798. // Inputs:
  799. // Side effects: 
  800.  
  801. XFE_PrefsPageEditorAppearance::~XFE_PrefsPageEditorAppearance()
  802. {
  803.     delete m_prefsDataEditorAppearance;
  804. }
  805.  
  806. // Member:       create
  807. // Description:  Creates page for EditorAppearance
  808. // Inputs:
  809. // Side effects: 
  810.  
  811. void XFE_PrefsPageEditorAppearance::create()
  812. {
  813.     Arg               av[50];
  814.     int               ac;
  815.  
  816.     PrefsDataEditorAppearance *fep = NULL;
  817.  
  818.     fep = new PrefsDataEditorAppearance;
  819.     memset(fep, 0, sizeof(PrefsDataEditorAppearance));
  820.     m_prefsDataEditorAppearance = fep;
  821.  
  822.     fep->context = getContext();
  823.     fep->prompt_dialog = getPrefsDialog()->getDialogChrome();
  824.  
  825.     MWContext *context = fep->context;
  826.     Widget     form;
  827.  
  828.     ac = 0;
  829.     XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  830.     XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  831.     XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  832.     XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  833.     form = XmCreateForm (m_wPageForm, "editorAppearance", av, ac);
  834.     XtManageChild (form);
  835.     m_wPage = fep->page = form;
  836.  
  837.     fe_EditorDocumentAppearancePropertiesStruct *w_data = &fep->appearance_data;
  838.     w_data->context = context;
  839.  
  840.     Arg args[16];
  841.     Cardinal n;
  842.     Widget main_rc;
  843.  
  844.     Widget colors_frame;
  845.     Widget colors_rc;
  846.  
  847.     Widget strategy_rc;
  848.     Widget strategy_custom;
  849.     Widget strategy_browser;
  850.  
  851. #ifdef DOCUMENT_COLOR_SCHEMES
  852.     Widget schemes_frame;
  853.     Widget schemes_form;
  854.     Widget schemes_combo;
  855.     Widget schemes_save;
  856.     Widget schemes_remove;
  857. #endif
  858.  
  859.     Widget custom_form;
  860.     Widget custom_frame;
  861.     Widget custom_preview_rc;
  862.     Widget background_info;
  863.     Widget fat_guy;
  864.     Widget top_guy;
  865.     Widget bottom_guy;
  866.     Widget children[6];
  867.     Widget swatches[6];
  868.     int      nchildren;
  869.     Cardinal nswatch;
  870.     Dimension width;
  871.     int i;
  872.  
  873.     Widget background_frame;
  874.     Widget background_form;
  875.     Widget background_image_toggle;
  876.     Widget background_image_text;
  877.     Widget background_image_button;
  878.  
  879.     Widget info_label;
  880.  
  881.     n = 0;
  882.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
  883.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  884.     main_rc = XmCreateRowColumn(form, "appearance", args, n);
  885.     XtManageChild(main_rc);
  886.  
  887.     /*
  888.      *    Custom colors.
  889.      */
  890.     n = 0;
  891.     colors_frame = fe_CreateFrame(main_rc, "documentColors", args, n);
  892.     XtManageChild(colors_frame);
  893.  
  894.     n = 0;
  895.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_CENTER); n++;
  896.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  897.     colors_rc = XmCreateRowColumn(colors_frame, "colors", args, n);
  898.     XtManageChild(colors_rc);
  899.  
  900.     /*
  901.      *    Top row.
  902.      */
  903.     n = 0;
  904.     XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
  905.     XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
  906.     XtSetArg(args[n], XmNentryVerticalAlignment, XmALIGNMENT_BASELINE_TOP); n++;
  907.     strategy_rc = XmCreateRowColumn(colors_rc, "strategy", args, n);
  908.     XtManageChild(strategy_rc);
  909.  
  910.     n = 0;
  911.     XtSetArg(args[n], XmNuserData, TRUE); n++;
  912.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  913.     strategy_custom = XmCreateToggleButtonGadget(strategy_rc,
  914.                                                  "custom", args, n);
  915.     XtManageChild(strategy_custom);
  916.  
  917.     XtAddCallback(strategy_custom, XmNvalueChangedCallback,
  918.                   fe_document_appearance_use_custom_cb, 
  919.                   (XtPointer)w_data);
  920.  
  921.     fe_DependentListAddDependent(&w_data->dependents,
  922.                      strategy_custom,
  923.                      DOCUMENT_USE_CUSTOM_MASK,
  924.                      fe_document_appearance_use_custom_update_cb,
  925.                      (XtPointer)w_data);
  926.  
  927.     n = 0;
  928.     XtSetArg(args[n], XmNuserData, FALSE); n++;
  929.     XtSetArg(args[n], XmNindicatorType, XmONE_OF_MANY); n++;
  930.     strategy_browser = XmCreateToggleButtonGadget(strategy_rc,
  931.                                                  "browser", args, n);
  932.     XtManageChild(strategy_browser);
  933.     
  934.     XtAddCallback(strategy_browser, XmNvalueChangedCallback,
  935.                   fe_document_appearance_use_custom_cb, 
  936.                   (XtPointer)w_data);
  937.  
  938.     fe_DependentListAddDependent(&w_data->dependents,
  939.                  strategy_browser,
  940.                  DOCUMENT_USE_CUSTOM_MASK,
  941.                  fe_document_appearance_use_custom_update_cb,
  942.                  (XtPointer)w_data);
  943.  
  944. #ifdef DOCUMENT_COLOR_SCHEMES
  945.     /*
  946.      *    Color Schemes.
  947.      */
  948.     n = 0;
  949.     schemes_frame = fe_CreateFrame(colors_rc, "schemes", args, n);
  950.     XtManageChild(schemes_frame);
  951.  
  952.     n = 0;
  953.     schemes_form = XmCreateForm(schemes_frame, "schemes", args, n);
  954.     XtManageChild(schemes_form);
  955.  
  956.     n = 0;
  957.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  958.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  959.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  960.     schemes_remove = XmCreatePushButtonGadget(schemes_form, "remove", args, n);
  961.     XtManageChild(schemes_remove);
  962.  
  963.     n = 0;
  964.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  965.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  966.     XtSetArg(args[n], XmNrightWidget, schemes_remove); n++;
  967.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  968.     schemes_save = XmCreatePushButtonGadget(schemes_form, "save", args, n);
  969.     XtManageChild(schemes_save);
  970.  
  971.     n = 0;
  972.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  973.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  974.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  975.     XtSetArg(args[n], XmNrightWidget, schemes_save); n++;
  976.     XtSetArg(args[n], XmNsensitive, FALSE); n++;
  977.     schemes_combo = fe_CreateCombo(schemes_form, "combo", args, n);
  978.     XtManageChild(schemes_combo);
  979. #endif
  980.  
  981.     n = 0;
  982.     custom_form = XmCreateForm(colors_rc, "custom", args, n);
  983.     XtManageChild(custom_form);
  984.  
  985.     for (nchildren = DOCUMENT_NORMAL_TEXT_COLOR;
  986.          nchildren <= DOCUMENT_BACKGROUND_COLOR;
  987.          nchildren++) {
  988.         Widget button;
  989.         char*  name = fe_PreviewPanelCreate_names[nchildren];
  990.         unsigned flags;
  991.  
  992.         n = 0;
  993.         XtSetArg(args[n], XmNuserData, nchildren); n++;
  994.         button = XmCreatePushButtonGadget(custom_form, name, args, n);
  995.         XtAddCallback(button, XmNactivateCallback,
  996.                     fe_document_appearance_color_cb, 
  997.                     (XtPointer)w_data);
  998.         flags = DOCUMENT_USE_CUSTOM_MASK;
  999.         if (nchildren == DOCUMENT_BACKGROUND_COLOR)
  1000.             flags |= DOCUMENT_USE_IMAGE_MASK;
  1001.         fe_DependentListAddDependent(&w_data->dependents,
  1002.                  button,
  1003.                  flags,
  1004.                  fe_document_appearance_sensitized_update_cb,
  1005.                  (XtPointer)w_data);
  1006.         children[nchildren] = button;
  1007.     }
  1008.     XtManageChildren(children, nchildren);
  1009.  
  1010.     fat_guy = fe_GetBiggestWidget(TRUE, children, nchildren);
  1011.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  1012.  
  1013.     /* swatches */
  1014.     for (nswatch = DOCUMENT_NORMAL_TEXT_COLOR;
  1015.          nswatch <= DOCUMENT_BACKGROUND_COLOR;
  1016.          nswatch++) {
  1017.         Widget foo;
  1018.         char   name[32];
  1019.         unsigned flags;
  1020.  
  1021.         sprintf(name, "%sSwatch", fe_PreviewPanelCreate_names[nswatch]);
  1022.         n = 0;
  1023.         XtSetArg(args[n], XmNuserData, nswatch); n++;
  1024.         XtSetArg(args[n], XmNwidth, SWATCH_SIZE); n++;
  1025.         foo = fe_CreateSwatch(custom_form, name, args, n);
  1026.         XtAddCallback(foo, XmNactivateCallback,
  1027.                     fe_document_appearance_color_cb, 
  1028.                     (XtPointer)w_data);
  1029.  
  1030.         flags = DOCUMENT_USE_CUSTOM_MASK|(1<<nswatch);
  1031.         if (nswatch == DOCUMENT_BACKGROUND_COLOR)
  1032.             flags |= DOCUMENT_USE_IMAGE_MASK;
  1033.         fe_DependentListAddDependent(&w_data->dependents,
  1034.                  foo,
  1035.                  flags,
  1036.                  fe_document_appearance_swatch_update_cb,
  1037.                  (XtPointer)w_data);
  1038.         swatches[nswatch] = foo;
  1039.     }
  1040.     XtManageChildren(swatches, nswatch);
  1041.  
  1042.     /*
  1043.      *    Do attachments.
  1044.      */
  1045.     for (top_guy = NULL, i = 0; i < nchildren; i++) {
  1046.  
  1047.         n = 0;
  1048.         if (top_guy) {
  1049.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  1050.             XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  1051.         } else {
  1052.             XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  1053.         }
  1054.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  1055.  
  1056.         top_guy = children[i];
  1057.  
  1058.         if (top_guy != fat_guy) {
  1059.                 /*
  1060.              *    Have to do this to avoid circular dependency in
  1061.              *    losing XmForm.
  1062.              */
  1063.             XtSetArg(args[n], XmNwidth, width); n++;
  1064. #if 0
  1065.             XtSetArg(args[n], XmNrightAttachment,
  1066.                    XmATTACH_OPPOSITE_WIDGET); n++;
  1067.             XtSetArg(args[n],XmNrightWidget, fat_guy); n++;
  1068. #endif
  1069.         }
  1070.         XtSetValues(top_guy, args, n);
  1071.  
  1072.         /* Do swatch. */
  1073.         n = 0;
  1074.         XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  1075.         XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  1076.         XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1077.         XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  1078.         XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1079.         XtSetArg(args[n], XmNbottomWidget, top_guy); n++;
  1080.         XtSetValues(swatches[i], args, n);
  1081.     }
  1082.  
  1083.     top_guy = swatches[DOCUMENT_NORMAL_TEXT_COLOR];
  1084.     bottom_guy = swatches[DOCUMENT_FOLLOWED_TEXT_COLOR];
  1085.  
  1086.     n = 0;
  1087.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  1088.     XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  1089.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1090.     XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  1091.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1092.     XtSetArg(args[n], XmNbottomWidget, bottom_guy); n++;
  1093.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1094. #if 1
  1095.     custom_frame = /*fe_*/XmCreateFrame(custom_form, "previewFrame", args, n);
  1096.     XtManageChild(custom_frame);
  1097.     n = 0; 
  1098.     XtSetArg(args[n], XmNmarginWidth, 0); n++;
  1099.     XtSetArg(args[n], XmNmarginHeight, 0); n++;
  1100.     XtSetValues(custom_frame, args, n);
  1101. #else
  1102.     n = 0;
  1103.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  1104.     XtSetArg(args[n], XmNborderWidth, 1); n++;
  1105.     XtSetArg(args[n], XmNborderColor,
  1106.              CONTEXT_DATA(w_data->context)->default_fg_pixel); n++;
  1107. #endif
  1108.     custom_preview_rc = fe_PreviewPanelCreate(custom_frame, "preview",
  1109.                                               args, n);
  1110.     XtManageChild(custom_preview_rc);
  1111.  
  1112.     XtAddCallback(custom_preview_rc, XmNinputCallback,
  1113.                   fe_preview_panel_click_cb, (XtPointer)w_data);
  1114.  
  1115.     fe_DependentListAddDependent(&w_data->dependents,
  1116.                  custom_preview_rc,
  1117.                  (DOCUMENT_USE_CUSTOM_MASK|DOCUMENT_ALL_APPEARANCE),
  1118.                  fe_document_appearance_preview_update_cb,
  1119.                  (XtPointer)w_data);
  1120.     fe_DependentListAddDependent(&w_data->dependents,
  1121.                  custom_preview_rc,
  1122.                  DOCUMENT_USE_CUSTOM_MASK,
  1123.                  fe_document_appearance_sensitized_update_cb,
  1124.                  (XtPointer)w_data);
  1125.     top_guy = swatches[DOCUMENT_BACKGROUND_COLOR];
  1126.  
  1127.     n = 0;
  1128.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  1129.     XtSetArg(args[n], XmNleftWidget, top_guy); n++;
  1130.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1131.     XtSetArg(args[n], XmNtopWidget, top_guy); n++;
  1132.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); n++;
  1133.     XtSetArg(args[n], XmNbottomWidget, top_guy); n++;
  1134.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1135.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  1136.     background_info = XmCreateLabelGadget(custom_form, "backgroundInfo", args, n);
  1137.     XtManageChild(background_info);
  1138.  
  1139.     /*
  1140.      *    Background.
  1141.      */
  1142.     n = 0;
  1143.     background_frame = fe_CreateFrame(main_rc, "backgroundImage", args, n);
  1144.     XtManageChild(background_frame);
  1145.  
  1146.     n = 0;
  1147.     background_form = XmCreateForm(background_frame, "backgroundImage", args, n);
  1148.     XtManageChild(background_form);
  1149.  
  1150.     nchildren = 0;
  1151.     n = 0;
  1152.     XtSetArg(args[n], XmNindicatorType, XmN_OF_MANY); n++;
  1153.     background_image_toggle = XmCreateToggleButtonGadget(background_form,
  1154.                             "useImage", args, n);
  1155.     children[nchildren++] = background_image_toggle;
  1156.  
  1157.     XtAddCallback(background_image_toggle, XmNvalueChangedCallback,
  1158.                   fe_document_appearance_use_image_cb, 
  1159.                   (XtPointer)w_data);
  1160.     fe_DependentListAddDependent(&w_data->dependents,
  1161.              background_image_toggle,
  1162.              (DOCUMENT_USE_IMAGE_MASK|DOCUMENT_USE_CUSTOM_MASK),
  1163.              fe_document_appearance_use_image_update_cb,
  1164.              (XtPointer)w_data);
  1165.  
  1166.     n = 0;
  1167.     background_image_text = fe_CreateTextField(background_form,
  1168.                       "imageText", args, n);
  1169.     XtAddCallback(background_image_text, XmNvalueChangedCallback,
  1170.                   fe_document_appearance_image_text_cb,
  1171.                   (XtPointer)w_data);
  1172.     fe_DependentListAddDependent(&w_data->dependents,
  1173.                  background_image_text,
  1174.                  (DOCUMENT_BACKGROUND_IMAGE_MASK|
  1175.                   DOCUMENT_USE_IMAGE_MASK|
  1176.                   DOCUMENT_USE_CUSTOM_MASK),
  1177.                  fe_document_appearance_image_text_update_cb,
  1178.                  (XtPointer)w_data);
  1179.     w_data->image_text = background_image_text;
  1180.     children[nchildren++] = background_image_text;
  1181.  
  1182.     n = 0;
  1183.     XtSetArg(args[n], XmNuserData, background_image_text); n++;
  1184.     background_image_button = XmCreatePushButtonGadget(background_form,
  1185.                            "browseImageFile", args, n);
  1186.     XtAddCallback(background_image_button, XmNactivateCallback,
  1187.                   fe_document_appearance_image_text_browse_cb,
  1188.                   (XtPointer)w_data);
  1189.     fe_DependentListAddDependent(&w_data->dependents,
  1190.              background_image_button,
  1191.              (DOCUMENT_USE_IMAGE_MASK|DOCUMENT_USE_CUSTOM_MASK),
  1192.              fe_document_appearance_use_image_button_update_cb,
  1193.              (XtPointer)w_data);
  1194.     children[nchildren++] = background_image_button;
  1195.  
  1196.     /*
  1197.      *    Do background image group attachments.
  1198.      */
  1199.     n = 0;
  1200.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  1201.     XtSetValues(background_image_toggle, args, n);
  1202.  
  1203.     n = 0;
  1204.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_WIDGET); n++;
  1205.     XtSetArg(args[n], XmNleftWidget, background_image_toggle); n++;
  1206.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_WIDGET); n++;
  1207.     XtSetArg(args[n], XmNrightWidget, background_image_button); n++;
  1208.     XtSetValues(background_image_text, args, n);
  1209.  
  1210.     n = 0;
  1211.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1212.     XtSetValues(background_image_button, args, n);
  1213.  
  1214.     XtManageChildren(children, nchildren);
  1215.  
  1216.     /*
  1217.      *    Bottom line info text.
  1218.      */
  1219.     n = 0;
  1220.     info_label = XmCreateLabelGadget(main_rc, "infoLabel", args, n);
  1221.     XtManageChild(info_label);
  1222.  
  1223.     w_data->is_editor_preferences = TRUE;
  1224.  
  1225.     setCreated(TRUE);
  1226. }
  1227.  
  1228. // Member:       init
  1229. // Description:  Initializes page for EditorAppearance
  1230. // Inputs:
  1231. // Side effects: 
  1232.  
  1233. void XFE_PrefsPageEditorAppearance::init()
  1234. {
  1235.     XP_ASSERT(m_prefsDataEditorAppearance);
  1236.     PrefsDataEditorAppearance    *fep = m_prefsDataEditorAppearance;
  1237.     MWContext                    *context = fep->context;
  1238.     
  1239.     fe_document_appearance_init(context, &fep->appearance_data);
  1240.  
  1241.     setInitialized(TRUE);
  1242. }
  1243.  
  1244. // Member:       install
  1245. // Description:  
  1246. // Inputs:
  1247. // Side effects: 
  1248.  
  1249. void XFE_PrefsPageEditorAppearance::install()
  1250. {
  1251.     PrefsDataEditorAppearance  *fep = m_prefsDataEditorAppearance;
  1252.     MWContext                  *context = getContext();
  1253.     fe_EditorDocumentAppearancePropertiesStruct *w_data = &fep->appearance_data;
  1254.  
  1255.     EDT_BeginBatchChanges(context);
  1256.  
  1257.     if (w_data->changed != 0) {
  1258.         fe_document_appearance_set(context, w_data);
  1259.         w_data->changed = 0;
  1260.     }
  1261.  
  1262.     EDT_EndBatchChanges(context);
  1263. }
  1264.  
  1265. // Member:       save
  1266. // Description:  
  1267. // Inputs:
  1268. // Side effects: 
  1269.  
  1270. void XFE_PrefsPageEditorAppearance::save()
  1271. {
  1272.     // XFE_PrefsDialog            *theDialog = getPrefsDialog();
  1273.     PrefsDataEditorAppearance  *fep = m_prefsDataEditorAppearance;
  1274.     // MWContext                  *context = theDialog->getContext();
  1275.     fe_EditorDocumentAppearancePropertiesStruct *w_data = &fep->appearance_data;
  1276.  
  1277.     XP_ASSERT(fep);
  1278.  
  1279. #define SOMETHING_CHANGED() (w_data->changed != 0)
  1280.  
  1281.     if (SOMETHING_CHANGED()) {
  1282.  
  1283.         // Install preferences
  1284.  
  1285.         install();
  1286.     }
  1287.  
  1288. #undef SOMETHING_CHANGED
  1289.  
  1290.     w_data->changed = 0;
  1291. }
  1292.  
  1293. // Member:       getData
  1294. // Description:  
  1295. // Inputs:
  1296. // Side effects: 
  1297.  
  1298. PrefsDataEditorAppearance *XFE_PrefsPageEditorAppearance::getData()
  1299. {
  1300.     return m_prefsDataEditorAppearance;
  1301. }
  1302.  
  1303. // ************************************************************************
  1304. // *************************     Editor/Publish   *************************
  1305. // ************************************************************************
  1306.  
  1307. // Member:       XFE_PrefsPageEditorPublish
  1308. // Description:  Constructor
  1309. // Inputs:
  1310. // Side effects: 
  1311.  
  1312. XFE_PrefsPageEditorPublish::XFE_PrefsPageEditorPublish(XFE_PrefsDialog *dialog)
  1313.     : XFE_PrefsPage(dialog),
  1314.       m_prefsDataEditorPublish(0)
  1315. {
  1316. }
  1317.  
  1318. // Member:       ~XFE_PrefsPageEditorPublish
  1319. // Description:  Destructor
  1320. // Inputs:
  1321. // Side effects: 
  1322.  
  1323. XFE_PrefsPageEditorPublish::~XFE_PrefsPageEditorPublish()
  1324. {
  1325.     delete m_prefsDataEditorPublish;
  1326. }
  1327.  
  1328. // Member:       create
  1329. // Description:  Creates page for EditorPublish
  1330. // Inputs:
  1331. // Side effects: 
  1332.  
  1333. void XFE_PrefsPageEditorPublish::create()
  1334. {
  1335.     Arg               av[50];
  1336.     int               ac;
  1337.  
  1338.     PrefsDataEditorPublish *w_data = NULL;
  1339.  
  1340.     w_data = new PrefsDataEditorPublish;
  1341.     memset(w_data, 0, sizeof(PrefsDataEditorPublish));
  1342.     m_prefsDataEditorPublish = w_data;
  1343.  
  1344.     w_data->context = getContext();
  1345.     w_data->prompt_dialog = getPrefsDialog()->getDialogChrome();
  1346.  
  1347.     Widget     form;
  1348.  
  1349.     ac = 0;
  1350.     XtSetArg (av [ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  1351.     XtSetArg (av [ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  1352.     XtSetArg (av [ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  1353.     XtSetArg (av [ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  1354.     form = XmCreateForm (m_wPageForm, "editorPublish", av, ac);
  1355.     XtManageChild (form);
  1356.     m_wPage = w_data->page = form;
  1357.  
  1358.     Widget links_frame;
  1359.     Widget links_main_rc;
  1360.     Widget links_main_info;
  1361.     Widget links_sub_rc;
  1362.     Widget links_toggle;
  1363.     Widget links_info;
  1364.     Widget images_toggle;
  1365.     Widget images_info;
  1366.     Widget links_main_tip;
  1367.  
  1368.     Widget publish_frame;
  1369.     Widget publish_form;
  1370.     Widget publish_label;
  1371.     Widget publish_text;
  1372.     Widget browse_label;
  1373.     Widget browse_text;
  1374.     Widget children[16];
  1375.     Cardinal nchildren;
  1376.     Arg    args[16];
  1377.     Cardinal n;
  1378.  
  1379.     n = 0;
  1380.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  1381.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1382.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
  1383.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
  1384.     links_frame = fe_CreateFrame(form, "linksAndImages", args, n);
  1385.     XtManageChild(links_frame);
  1386.  
  1387.     n = 0;
  1388.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  1389.     links_main_rc = XmCreateRowColumn(links_frame, "linksAndImages", args, n);
  1390.     XtManageChild(links_main_rc);
  1391.  
  1392.     nchildren = 0;
  1393.     n = 0;
  1394.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  1395.     links_main_info = XmCreateLabelGadget(links_main_rc, "linksAndImagesLabel",
  1396.                                           args, n);
  1397.     children[nchildren++] = links_main_info;
  1398.  
  1399.     n = 0;
  1400.     XtSetArg(args[n], XmNorientation, XmVERTICAL); n++;
  1401.     XtSetArg(args[n], XmNisAligned, TRUE); n++;
  1402.     XtSetArg(args[n], XmNentryAlignment, XmALIGNMENT_BEGINNING); n++;
  1403.     links_sub_rc = XmCreateRowColumn(links_main_rc, 
  1404.                     "linksAndImagesToggles",
  1405.                      args, n);
  1406.     children[nchildren++] = links_sub_rc;
  1407.  
  1408.     n = 0;
  1409.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  1410.     links_main_tip = XmCreateLabelGadget(links_main_rc, 
  1411.                     "linksAndImagesTip",
  1412.                       args, n);
  1413.     children[nchildren++] = links_main_tip;
  1414.  
  1415.     XtManageChildren(children, nchildren);
  1416.  
  1417.     nchildren = 0;
  1418.     n = 0;
  1419.     links_toggle = XmCreateToggleButtonGadget(links_sub_rc, 
  1420.                         "linksToggle",
  1421.                           args, n);
  1422.     children[nchildren++] = links_toggle;
  1423.  
  1424.     n = 0;
  1425.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  1426.     links_info = XmCreateLabelGadget(links_sub_rc, "linksInfo", args, n);
  1427.     children[nchildren++] = links_info;
  1428.  
  1429.     n = 0;
  1430.     images_toggle = XmCreateToggleButtonGadget(links_sub_rc, 
  1431.                         "imagesToggle",
  1432.                           args, n);
  1433.     children[nchildren++] = images_toggle;
  1434.  
  1435.     n = 0;
  1436.     XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
  1437.     images_info = XmCreateLabelGadget(links_sub_rc, "imagesInfo", args, n);
  1438.     children[nchildren++] = images_info;
  1439.  
  1440.     XtManageChildren(children, nchildren);
  1441.  
  1442.     n = 0;
  1443.     XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
  1444.     XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
  1445.     XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
  1446.     XtSetArg(args[n], XmNtopWidget, links_frame); n++;
  1447.     XtSetArg(args[n], XmNtopOffset, 8); n++;
  1448.     XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
  1449.     publish_frame = fe_CreateFrame(form, "publish", args, n);
  1450.     XtManageChild(publish_frame);
  1451.  
  1452.     n = 0;
  1453.     publish_form = XmCreateForm(publish_frame, "publish", args, n);
  1454.     XtManageChild(publish_form);
  1455.  
  1456.     nchildren = 0;
  1457.     n = 0;
  1458.     publish_label = XmCreateLabelGadget(publish_form, "publishLabel", args, n);
  1459.     children[nchildren++] = publish_label;
  1460.  
  1461.     n = 0;
  1462.     browse_label = XmCreateLabelGadget(publish_form, "browseLabel", args, n);
  1463.     children[nchildren++] = browse_label;
  1464.  
  1465.     n = 0;
  1466.     XtSetArg(args[n], XmNuserData, EDITOR_PUBLISH_PUBLISH); n++;
  1467.     publish_text = fe_CreateTextField(publish_form, "publishText", args, n);
  1468.     children[nchildren++] = publish_text;
  1469.     
  1470.     n = 0;
  1471.     XtSetArg(args[n], XmNuserData, EDITOR_PUBLISH_BROWSE); n++;
  1472.     browse_text = fe_CreateTextField(publish_form, "browseText", args, n);
  1473.     children[nchildren++] = browse_text;
  1474.  
  1475.     /*
  1476.      *    Go back for attachments
  1477.      */
  1478.  
  1479.     int labels_width;
  1480.     labels_width = XfeVaGetWidestWidget(publish_label,
  1481.                     browse_label,
  1482.                     NULL);
  1483.  
  1484.     int labels_height;
  1485.     labels_height = XfeVaGetTallestWidget(publish_label,
  1486.                       publish_text,
  1487.                       NULL);
  1488.  
  1489.     XtVaSetValues(publish_label,
  1490.           XmNheight, labels_height,
  1491.           RIGHT_JUSTIFY_VA_ARGS(publish_label,labels_width),
  1492.           XmNtopAttachment, XmATTACH_FORM,
  1493.           XmNbottomAttachment, XmATTACH_NONE,
  1494.           NULL);
  1495.  
  1496.     XtVaSetValues(browse_label,
  1497.           XmNheight, labels_height,
  1498.           RIGHT_JUSTIFY_VA_ARGS(browse_label,labels_width),
  1499.           XmNtopAttachment, XmATTACH_WIDGET,
  1500.           XmNtopWidget, publish_label,
  1501.           XmNbottomAttachment, XmATTACH_NONE,
  1502.           NULL);
  1503.  
  1504.     XtVaSetValues(publish_text,
  1505.           XmNheight, labels_height,
  1506.           XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  1507.           XmNtopWidget, publish_label,
  1508.           XmNleftAttachment, XmATTACH_WIDGET,
  1509.           XmNleftWidget, publish_label,
  1510.           XmNrightAttachment, XmATTACH_NONE,
  1511.           XmNbottomAttachment, XmATTACH_NONE,
  1512.           NULL);
  1513.  
  1514.     XtVaSetValues(browse_text,
  1515.           XmNheight, labels_height,
  1516.           XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
  1517.           XmNtopWidget, browse_label,
  1518.           XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
  1519.           XmNleftWidget, publish_text,
  1520.           XmNrightAttachment, XmATTACH_NONE,
  1521.           XmNbottomAttachment, XmATTACH_NONE,
  1522.           NULL);
  1523.  
  1524.     XtManageChildren(children, nchildren);
  1525.  
  1526.     w_data->maintain_links = links_toggle;
  1527.     w_data->keep_images = images_toggle;
  1528.     w_data->publish_text = publish_text;
  1529.     w_data->browse_text = browse_text;
  1530.  
  1531.     XtVaSetValues(links_toggle, XmNuserData, EDITOR_PUBLISH_LINKS, 0);
  1532.     XtAddCallback(links_toggle, XmNvalueChangedCallback,
  1533.                   cb_changed, (XtPointer)w_data);
  1534.     XtVaSetValues(images_toggle, XmNuserData, EDITOR_PUBLISH_IMAGES, 0);
  1535.     XtAddCallback(images_toggle, XmNvalueChangedCallback,
  1536.                   cb_changed, (XtPointer)w_data);
  1537.     XtVaSetValues(publish_text, XmNuserData, EDITOR_PUBLISH_PUBLISH, 0);
  1538.     XtAddCallback(publish_text, XmNvalueChangedCallback,
  1539.                   cb_changed, (XtPointer)w_data);
  1540.     XtVaSetValues(browse_text, XmNuserData, EDITOR_PUBLISH_BROWSE, 0);
  1541.     XtAddCallback(browse_text, XmNvalueChangedCallback,
  1542.                   cb_changed, (XtPointer)w_data);
  1543.     setCreated(TRUE);
  1544. }
  1545.  
  1546. // Member:       init
  1547. // Description:  Initializes page for EditorPublish
  1548. // Inputs:
  1549. // Side effects: 
  1550.  
  1551. void XFE_PrefsPageEditorPublish::init()
  1552. {
  1553.     XP_ASSERT(m_prefsDataEditorPublish);
  1554.  
  1555.     PrefsDataEditorPublish *w_data = m_prefsDataEditorPublish;
  1556.     MWContext              *context = w_data->context;
  1557.  
  1558.     char* location;
  1559.     char* browse_location;
  1560.     char* username;
  1561.     char* password;
  1562.     Boolean links;
  1563.     Boolean images;
  1564.     Boolean save_password;
  1565.     Boolean sensitive;
  1566.  
  1567.     fe_EditorPreferencesGetLinksAndImages(context, &links, &images);
  1568.  
  1569.     save_password = fe_EditorPreferencesGetPublishLocation(context,
  1570.                                                            &location,
  1571.                                                            &username,
  1572.                                                            &password);
  1573.  
  1574.     browse_location = fe_EditorPreferencesGetBrowseLocation(context);
  1575.  
  1576.     XmToggleButtonSetState(w_data->maintain_links, links, FALSE);
  1577.     XmToggleButtonSetState(w_data->keep_images, images, FALSE);
  1578.     /*XmToggleButtonSetState(w_data->save_password, save_password, FALSE);*/
  1579.  
  1580.     sensitive = !PREF_PrefIsLocked("editor.publish_keep_links");
  1581.     XtSetSensitive(w_data->maintain_links, sensitive);
  1582.     sensitive = !PREF_PrefIsLocked("editor.publish_keep_images");
  1583.     XtSetSensitive(w_data->keep_images, sensitive);
  1584.  
  1585.     if (location) {
  1586.         fe_TextFieldSetString(w_data->publish_text, location, FALSE);
  1587.  
  1588.     }
  1589.  
  1590.     if (browse_location)
  1591.         fe_TextFieldSetString(w_data->browse_text, browse_location, FALSE);
  1592.     else
  1593.         fe_TextFieldSetString(w_data->browse_text, "", FALSE);
  1594.  
  1595.     sensitive = !PREF_PrefIsLocked("editor.publish_location");
  1596.     XtSetSensitive(w_data->publish_text, sensitive);
  1597.     sensitive = !PREF_PrefIsLocked("editor.publish_browse_location");
  1598.     XtSetSensitive(w_data->browse_text, sensitive);
  1599.  
  1600.     if (browse_location) {
  1601.         free(browse_location);
  1602.     }
  1603.     if (location) {
  1604.         free(location);
  1605.     }
  1606.  
  1607.     setInitialized(TRUE);
  1608. }
  1609.  
  1610. // Member:       install
  1611. // Description:  
  1612. // Inputs:
  1613. // Side effects: 
  1614.  
  1615. void XFE_PrefsPageEditorPublish::install()
  1616. {
  1617.     PrefsDataEditorPublish  *w_data = m_prefsDataEditorPublish;
  1618.     MWContext               *context = getContext();
  1619.  
  1620.     char* location = NULL;
  1621.     char* browse_location = NULL;
  1622.     char* username = NULL;
  1623.     char* password = NULL;
  1624.     Boolean new_links;
  1625.     Boolean new_images;
  1626.     Boolean old_links;
  1627.     Boolean old_images;
  1628.  
  1629.     EDT_BeginBatchChanges(context);
  1630.  
  1631.     if (w_data->changed != 0) {
  1632.  
  1633.         new_links = XmToggleButtonGetState(w_data->maintain_links);
  1634.         new_images = XmToggleButtonGetState(w_data->keep_images);
  1635.  
  1636.         fe_EditorPreferencesGetLinksAndImages(context, &old_links, &old_images);
  1637.  
  1638.         if (new_links != old_links || new_images != old_images) {
  1639.             fe_EditorPreferencesSetLinksAndImages(context, new_links, new_images);
  1640.         }
  1641.  
  1642. #define PUBLISH_MASK (EDITOR_PUBLISH_PUBLISH|  \
  1643.                       EDITOR_PUBLISH_BROWSE| \
  1644.                       EDITOR_PUBLISH_USERNAME| \
  1645.                       EDITOR_PUBLISH_PASSWORD|EDITOR_PUBLISH_PASSWORD_SAVE)
  1646.  
  1647.  
  1648.             if ((w_data->changed & PUBLISH_MASK) != 0) { 
  1649.  
  1650.                 location = fe_GetTextField(w_data->publish_text);
  1651.                 browse_location = fe_GetTextField(w_data->browse_text);
  1652.         
  1653.                 fe_EditorPreferencesSetPublishLocation(context,
  1654.                                    location,
  1655.                                    username,
  1656.                                    password);
  1657.                 /*
  1658.                   new_save_password? password: 0);
  1659.                   */
  1660.                 fe_EditorPreferencesSetBrowseLocation(context,
  1661.                              browse_location);
  1662.             }
  1663. #undef PUBLISH_MASK
  1664.             if (browse_location) {
  1665.                 XtFree(browse_location);
  1666.             }
  1667.             if (location) {
  1668.                 XtFree(location);
  1669.             }
  1670.             w_data->changed = 0;
  1671.     }
  1672.     
  1673.     EDT_EndBatchChanges(context);
  1674. }
  1675.  
  1676. // Member:       save
  1677. // Description:  
  1678. // Inputs:
  1679. // Side effects: 
  1680.  
  1681. void XFE_PrefsPageEditorPublish::save()
  1682. {
  1683.     // XFE_PrefsDialog         *theDialog = getPrefsDialog();
  1684.     PrefsDataEditorPublish  *fep = m_prefsDataEditorPublish;
  1685.     // MWContext               *context = theDialog->getContext();
  1686.  
  1687.     XP_ASSERT(fep);
  1688.  
  1689. #define SOMETHING_CHANGED() (fep->changed != 0)
  1690.  
  1691.     if (SOMETHING_CHANGED()) {
  1692.  
  1693.         // Install preferences
  1694.  
  1695.         install();
  1696.     }
  1697.  
  1698. #undef SOMETHING_CHANGED
  1699.  
  1700.     fep->changed = 0;
  1701. }
  1702.  
  1703. // Member:       getData
  1704. // Description:  
  1705. // Inputs:
  1706. // Side effects: 
  1707.  
  1708. PrefsDataEditorPublish *XFE_PrefsPageEditorPublish::getData()
  1709. {
  1710.     return m_prefsDataEditorPublish;
  1711. }
  1712.  
  1713. // Member:       cb_changed
  1714. // Description:  
  1715. // Inputs:
  1716. // Side effects: 
  1717.  
  1718. void XFE_PrefsPageEditorPublish::cb_changed(Widget    widget,
  1719.                                             XtPointer closure, 
  1720.                                             XtPointer /* call_data */)
  1721. {
  1722.     PrefsDataEditorPublish *w_data    = (PrefsDataEditorPublish *)closure;
  1723.  
  1724.     w_data->changed |= (unsigned)fe_GetUserData(widget);
  1725. }
  1726.  
  1727. // Member:       cb_changed
  1728. // Description:  
  1729. // Inputs:
  1730. // Side effects: 
  1731.  
  1732. void XFE_PrefsPageEditorPublish::cb_passwordChanged(Widget    /* widget */,
  1733.                         XtPointer closure, 
  1734.                         XtPointer /* call_data */)
  1735. {
  1736.     PrefsDataEditorPublish *w_data    = (PrefsDataEditorPublish *)closure;
  1737.  
  1738.     w_data->changed |= EDITOR_PUBLISH_PASSWORD;
  1739. }
  1740.  
  1741. // ************************************************************************
  1742. // *************************        Misc.         *************************
  1743. // ************************************************************************
  1744.  
  1745. static Widget
  1746. fe_GetBiggestWidget(Boolean horizontal, Widget* widgets, Cardinal n)
  1747. {
  1748.     Dimension max_width = 0;
  1749.     Dimension width;
  1750.     Widget max_widget = NULL;
  1751.     Widget widget;
  1752.     Cardinal i;
  1753.     
  1754.     if (!widgets)
  1755.         return NULL;
  1756.  
  1757.     for (i = 0; i < n; i++) {
  1758.  
  1759.         widget = widgets[i];
  1760.  
  1761.         if (horizontal) {
  1762.             XtVaGetValues(widget, XmNwidth, &width, 0);
  1763.         } else {
  1764.             XtVaGetValues(widget, XmNheight, &width, 0);
  1765.         }
  1766.         if (width > max_width) {
  1767.             max_width = width;
  1768.             max_widget = widget;
  1769.         }
  1770.     }
  1771.     
  1772.     return max_widget;
  1773. }
  1774.  
  1775. #if 0
  1776. static Dimension
  1777. fe_get_offset_from_widest(Widget* children, Cardinal nchildren)
  1778. {
  1779.     Dimension width;
  1780.     Dimension margin_width;
  1781.  
  1782.     Widget fat_guy = fe_GetBiggestWidget(TRUE, children, nchildren);
  1783.     XtVaGetValues(fat_guy, XmNwidth, &width, 0);
  1784.     XtVaGetValues(XtParent(fat_guy), XmNmarginWidth, &margin_width, 0);
  1785.  
  1786.     return width + margin_width;
  1787. }
  1788. #endif
  1789.  
  1790. static void
  1791. fe_set_numeric_text_field(Widget widget, unsigned value)
  1792. {
  1793.     char buf[32];
  1794.  
  1795.     sprintf(buf, "%d", value);
  1796.  
  1797.     fe_TextFieldSetString(widget, buf, FALSE);
  1798. }
  1799.  
  1800. static int
  1801. fe_get_numeric_text_field(Widget widget)
  1802. {
  1803.     char* p = fe_GetTextField(widget);
  1804.     char* q;
  1805.     int result = 0;
  1806.  
  1807.     if (!p)
  1808.         return -1;
  1809.  
  1810.     char* orig_p = p;
  1811.     while (isspace(*p))
  1812.         p++;
  1813.     if (*p == '\0') {
  1814.         XP_FREEIF(orig_p);
  1815.         return -1;
  1816.     }
  1817.     for (q = p; *q != '\0'; q++) {
  1818.         if (!(isdigit(*q) || isspace(*q))) {
  1819.             XP_FREEIF(orig_p);
  1820.             return -1; /* force error */
  1821.         }
  1822.     }
  1823.  
  1824.     result = atoi(p);
  1825.     
  1826.     XP_FREEIF(orig_p);
  1827.  
  1828.     return result;
  1829. }
  1830.  
  1831. static void
  1832. fe_error_dialog(MWContext* /* context */, Widget parent, char* s)
  1833. {
  1834.     while (!XtIsWMShell(parent) && (XtParent(parent)!=0))
  1835.         parent = XtParent(parent);
  1836.  
  1837.     fe_dialog(parent, "error", s, FALSE, 0, FALSE, FALSE, 0);
  1838. }
  1839.  
  1840.