home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / mailcompose.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  16.2 KB  |  608 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. #include "mozilla.h"
  20. #include "xfe.h"
  21. #include "fonts.h"
  22.  
  23. #include <Xm/LabelG.h>
  24. #include <Xm/Label.h>
  25. #include <XmL/Folder.h>
  26.  
  27. #include <Xfe/Xfe.h>            /* for xfe widgets and utilities */
  28.  
  29. extern void*
  30. fe_compose_getData(MWContext* context);
  31. extern void*
  32. fe_compose_setData(MWContext* context, void* data);
  33.  
  34. extern void
  35. fe_mc_field_lostfocus(Widget widget, XtPointer closure, XtPointer call_data);
  36.  
  37. extern void
  38. fe_mc_field_changed(Widget widget, XtPointer closure, XtPointer call_data);
  39.  
  40. extern WidgetList
  41. fe_create_composition_widgets(MWContext* context, Widget pane, int *numkids);
  42.  
  43.  
  44. typedef enum {
  45.  
  46.   MailComposeLayoutAddress,
  47.   MailComposeLayoutAttach,
  48.   MailComposeLayoutCompose
  49.  
  50. } MailComposeLayoutType;
  51.  
  52.  
  53. /* fe_MailComposeContextData *mailcomposer = 0;*/ /*Temporary*/
  54.  
  55. #define MAILCOMPOSE_CONTEXT_DATA(context) ((fe_MailComposeContextData*)(fe_compose_getData(context)))
  56.  
  57. #include <xpgetstr.h>  /* for XP_GetString() */
  58. extern int XFE_PRI_URGENT;
  59. extern int XFE_PRI_IMPORTANT;
  60. extern int XFE_PRI_NORMAL;
  61. extern int XFE_PRI_FYI;
  62. extern int XFE_PRI_JUNK;
  63. extern int XFE_PRI_PRIORITY;
  64. extern int XFE_COMPOSE_LABEL;
  65. extern int XFE_COMPOSE_ADDRESSING;
  66. extern int XFE_COMPOSE_ATTACHMENT;
  67. extern int XFE_COMPOSE_COMPOSE;
  68.  
  69. static void createDummy(Widget parent, char *name)
  70. {
  71.     XtVaCreateManagedWidget(name,
  72.         xmLabelWidgetClass, parent,
  73.         XmNtopAttachment, XmATTACH_FORM,
  74.         XmNbottomAttachment, XmATTACH_FORM,
  75.         XmNleftAttachment, XmATTACH_FORM,
  76.         XmNrightAttachment, XmATTACH_FORM,
  77.         XmNmarginWidth, 80,
  78.         XmNmarginHeight, 60,
  79.         NULL);
  80. }
  81.  
  82. static Widget
  83. createOptionMenu(MWContext *context,
  84.                  Widget parent, 
  85.          char* widgetName,
  86.          char* labelName,
  87.                  Widget *popup)
  88. {
  89.   Cardinal ac;
  90.   Arg      av[10];
  91.   Visual   *v = 0;
  92.   Colormap cmap = 0;
  93.   Cardinal depth =0;
  94.   Widget option_menu;
  95.   XmString xmStr = 0;
  96.  
  97.   Widget shell = parent;
  98.  
  99.  
  100.   while (shell && !XtIsShell(shell)) shell = XtParent(shell);
  101.   XtVaGetValues(shell,
  102.          XtNvisual, &v, XtNcolormap, &cmap, XtNdepth, &depth, 0);
  103.  
  104.   ac = 0;
  105.   XtSetArg(av[ac], XmNvisual, v); ac++;
  106.   XtSetArg(av[ac], XmNdepth, depth); ac++;
  107.   XtSetArg(av[ac], XmNcolormap, cmap); ac ++;
  108.   *popup= XmCreatePulldownMenu(parent, widgetName, av, ac);
  109.  
  110.   ac = 0;
  111.   XtSetArg(av[ac], XmNsubMenuId, *popup); ac++;
  112.   XtSetArg(av[ac], XmNmarginWidth, 0); ac++;
  113.   if (labelName && *labelName)
  114.   {
  115.    xmStr = XmStringCreateSimple(labelName);
  116.    XtSetArg(av[ac], XmNlabelString, xmStr); ac++;
  117.   }
  118.   option_menu = XmCreateOptionMenu(parent, widgetName, av, ac);
  119.   if (xmStr) XmStringFree(xmStr);
  120.  
  121.   return option_menu;
  122. }
  123.  
  124. Widget 
  125. makeOptionMenu(MWContext *context, Widget parent)
  126. {
  127.    int i;
  128.    int ac = 0;
  129.    Arg av[20];
  130.    Widget optionW = 0;
  131.    Widget popUpW = 0;
  132.    XmString xmStr;
  133.    Widget btn;
  134.  
  135.    int priorityCnt= 5; /* May need to get from somewhere */
  136.    optionW = createOptionMenu(context, parent, "priorityOption", 
  137.         XP_GetString(XFE_PRI_PRIORITY), &popUpW);
  138.  
  139.    for ( i = 0; i < priorityCnt; i++ )
  140.    {
  141.     xmStr = XmStringCreateSimple(XP_GetString(XFE_PRI_URGENT+i));
  142.         ac = 0;
  143.       XtSetArg(av[ac], XmNuserData, i); ac++;
  144.        XtSetArg(av[ac], XmNlabelString, xmStr); ac++;
  145.      btn = XmCreatePushButtonGadget(popUpW, "attrBtn", av, ac);
  146.       XtManageChild(btn);
  147.         if ( i == 2  ) /* Normal */
  148.     XtVaSetValues(optionW, XmNmenuHistory, btn, 0);
  149.     XmStringFree(xmStr);
  150.    }
  151.  
  152.  
  153.    XtManageChild(optionW);
  154.  
  155.    return optionW;
  156. }
  157.  
  158.  
  159.  
  160. static Widget
  161. createManagedCompose(MWContext *context, Widget pane)
  162. {
  163.  
  164.   int ac = 0;
  165.   char  name[30];
  166.   char  buf[100]; 
  167.   fe_ContextData* data = CONTEXT_DATA(context);
  168.   Widget form;
  169.   Widget secureW;
  170.   Widget optionW;
  171.   Widget subjectTextW;
  172.   Widget subjectLabelW;
  173.   XmFontList fontList;
  174.   Arg av[20];
  175.   Widget composeform;
  176.   
  177.   ac = 0;
  178.   XtSetArg(av[ac], XmNresizePolicy, XmRESIZE_GROW); ac++;
  179.   composeform = XmCreateForm(pane, "mailto_field", av, ac);
  180.  
  181.   ac = 0;
  182.   XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  183.   XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  184.   XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  185.   XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
  186.   form = XmCreateForm(composeform, "mailto_field", av, ac);
  187.   XtManageChild(form);
  188.  
  189.   /* Create a secure button */
  190.   ac = 0;
  191.   XtSetArg(av[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
  192.   XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  193.   XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  194.   XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  195.   secureW = XmCreateToggleButtonGadget(form, "secureToggle", av, ac);
  196.   XtManageChild(secureW);
  197.  
  198.   /* Create a priority option */
  199.   optionW = makeOptionMenu(context, form);
  200.  
  201.   XtVaSetValues( optionW, 
  202.       XmNleftAttachment, XmATTACH_NONE,
  203.       XmNrightAttachment, XmATTACH_WIDGET,
  204.       XmNrightWidget, secureW,
  205.     XmNrightOffset, 5,
  206.       XmNtopAttachment, XmATTACH_FORM,
  207.       XmNbottomAttachment, XmATTACH_FORM,
  208.       NULL);
  209.   
  210.   /* Create the text field */
  211.  
  212.   PR_snprintf(name, sizeof (name), "%s", "subject");
  213.   ac = 0;
  214.   XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  215.   XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  216.   XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  217.   XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  218.   XtSetArg(av[ac], XmNrightOffset, 5); ac++;
  219.   XtSetArg(av[ac], XmNrightWidget, optionW); ac++;
  220.   subjectTextW = fe_CreateTextField(form, name, av, ac);
  221.   if (fe_globalData.nonterminal_text_translations) {
  222.     XtOverrideTranslations(subjectTextW,
  223.                fe_globalData.nonterminal_text_translations);
  224.   }
  225.   XtAddCallback(subjectTextW, XmNvalueChangedCallback, fe_mc_field_changed,
  226.         (XtPointer)MSG_SUBJECT_HEADER_MASK);
  227.   XtAddCallback(subjectTextW, XmNlosingFocusCallback, fe_mc_field_lostfocus,
  228.         (XtPointer)MSG_SUBJECT_HEADER_MASK );
  229.  
  230.   ac = 0;
  231.   XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  232.   XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  233.   XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  234.   XtSetArg(av[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
  235.   XtSetArg(av[ac], XmNrightWidget, subjectTextW); ac++;
  236.   PR_snprintf(buf, sizeof (buf), XP_GetString(XFE_COMPOSE_LABEL), name);
  237.   subjectLabelW = XmCreateLabelGadget(form, buf, av, ac);
  238.  
  239.   data->mcSubject = subjectTextW;
  240.  
  241.  
  242.   /* Subject is not a drop site */
  243.  
  244.   XtVaSetValues(subjectTextW, XmNleftOffset, XfeWidth(subjectLabelW), 0);
  245.  
  246.   /* Manage All children here */
  247.  
  248.   XtManageChild(subjectTextW);
  249.   XtManageChild(subjectLabelW);
  250.  
  251.  
  252.   ac = 0;
  253.   XtSetArg (av[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
  254.   XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  255.   XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  256.   XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  257.   XtSetArg(av[ac], XmNtopWidget, form); ac++;
  258.   XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  259.   XtSetArg(av[ac], XmNtopOffset, 5); ac++;
  260.   data->mcBodyText = 
  261.     XmCreateScrolledText(composeform, "mailto_bodyText", av, ac);
  262.   XtManageChild(data->mcBodyText);
  263.  
  264.   XtVaSetValues(XtParent(data->mcBodyText),
  265.     XmNtopAttachment, XmATTACH_WIDGET,
  266.     XmNtopWidget, form,
  267.     XmNleftAttachment, XmATTACH_FORM,
  268.     XmNbottomAttachment, XmATTACH_FORM,
  269.     XmNrightAttachment, XmATTACH_FORM, NULL);
  270.  
  271.   XtManageChild(composeform);
  272.   return composeform;
  273. }
  274.  
  275.  
  276. extern Widget
  277. fe_MailComposeAddress_CreateManaged(MWContext* context, Widget parent)
  278. {
  279.   Widget frame;
  280.   WidgetList formList;
  281.   int k = 0;
  282.   Arg av[10];
  283.   int ac = 0;
  284.   Widget pane;
  285.  
  286.   pane = XmCreatePanedWindow(parent, "pane2", av, ac);
  287.   XtVaSetValues(pane, XmNseparatorOn, True, 0);
  288.  
  289.   ac =0;
  290.   frame = XmCreateFrame(pane, "frame1", av, ac);
  291.   XtVaSetValues(frame, XmNtopAttachment, XmATTACH_FORM, 
  292.         XmNbottomAttachment, XmATTACH_NONE,
  293.         XmNleftAttachment, XmATTACH_FORM,
  294.         XmNrightAttachment, XmATTACH_FORM,
  295.         0);
  296.  
  297.   XtManageChild(frame);
  298.  
  299.   formList = fe_create_composition_widgets(context, frame, &k);
  300.   XtManageChildren(formList, k);
  301.   XtManageChild(frame);
  302.  
  303.   return pane; 
  304. }
  305.  
  306. extern Widget fe_make_managed_attach_form(MWContext* context, Widget parent);
  307. extern Widget
  308. fe_MailComposeAttach_CreateManaged(MWContext* context, Widget parent)
  309. {
  310.   Widget messb;
  311.  
  312.   messb = fe_make_managed_attach_form(context, parent);
  313.  
  314.   return messb;
  315. }
  316.  
  317. static Widget
  318. fe_MailCompose_CreateManaged(MWContext* context, Widget parent)
  319. {
  320.   Widget compose;
  321.  
  322.   compose = 
  323.   createManagedCompose(context, parent);
  324.  
  325.   return compose;
  326. }
  327.  
  328. static Widget
  329. fe_MailComposeContainer_CreateManaged(MWContext* context)
  330. {
  331.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  332.   Widget container;
  333.   Widget address;
  334.   Widget attach;
  335.   Arg av[10];
  336.   int ac = 0;
  337.  
  338.   data->container = container = 
  339.         XtVaCreateManagedWidget("mailcompose_container",
  340.         xmFormWidgetClass, data->parentFolder,
  341.         XmNtopAttachment, XmATTACH_FORM,
  342.         XmNbottomAttachment,XmATTACH_FORM,
  343.         XmNleftAttachment, XmATTACH_FORM,
  344.         XmNrightAttachment, XmATTACH_FORM,
  345.         XmNresizePolicy, XmRESIZE_GROW,
  346.         0);
  347.  
  348.   data->address = fe_MailComposeAddress_CreateManaged(context, container);
  349.   data->attach = fe_MailComposeAttach_CreateManaged(context, container);
  350.   data->compose  = fe_MailCompose_CreateManaged(context, container);
  351.   return container;
  352. }
  353.  
  354.  
  355. static Widget
  356. fe_MailComposeWin_AddTab( MWContext* context, char *tabName)
  357. {
  358.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  359.   Widget parentFolder;
  360.   Widget tab;
  361.   XmString xmstr = 0;
  362.  
  363.   if (!data) return NULL;
  364.   parentFolder = data->parentFolder;
  365.  
  366.   xmstr = XmStringCreateSimple(tabName);
  367.   tab = XmLFolderAddTabForm(parentFolder, xmstr);
  368.   XtVaSetValues(tab, XmNtopAttachment, XmATTACH_FORM,
  369.         XmNbottomAttachment, XmATTACH_FORM,
  370.         XmNleftAttachment, XmATTACH_FORM,
  371.         XmNrightAttachment, XmATTACH_FORM, 
  372.         XmNresizePolicy, XmRESIZE_GROW,
  373.         NULL);
  374.  
  375.  
  376.   XmStringFree(xmstr);
  377.   return tab;
  378. }
  379.  
  380.  
  381. static Widget
  382. fe_MailComposeWin_CreateFolders(MWContext* context)
  383. {
  384.  
  385.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  386.  
  387.   Widget folder;
  388.   Widget parent;
  389.  
  390.  
  391.   if (!data) return NULL;
  392.  
  393.   parent = data->parent;
  394.  
  395.   folder = XtVaCreateManagedWidget("composeFolder",
  396.             xmlFolderWidgetClass, parent,
  397.         NULL);
  398.  
  399.   return folder;
  400. }
  401.  
  402. static fe_MailComposeContextData *
  403. fe_MailComposeWin_CreateContext(MWContext *context)
  404. {
  405.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  406.  
  407.   if ( !data )
  408.     data = (fe_MailComposeContextData*)
  409.         malloc(sizeof(fe_MailComposeContextData));
  410.  
  411.   data->tab_number = 0;
  412.  
  413.   data->parent = 0;
  414.   data->container = 0;
  415.   data->parentFolder = 0;
  416.  
  417.   data->address = 0;
  418.   data->attach = 0;
  419.   data->compose = 0;
  420.  
  421.   data->address_tab = 0;
  422.   data->attach_tab = 0;
  423.   data->compose_tab = 0;
  424.  
  425.   return data;
  426. }
  427.  
  428. static void
  429. fe_MailComposeWin_DestroyContext(MWContext *context)
  430. {
  431.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  432.  
  433.   if ( !data ) 
  434.      return;
  435.  
  436.   XtDestroyWidget(data->parentFolder);
  437.  
  438.   /* Remember to destroy mad from the context */
  439. }
  440.  
  441.  
  442. static void
  443. mailcompose_layout(fe_MailComposeContextData *data, 
  444.         MailComposeLayoutType type)
  445. {
  446.    Widget manage= 0, unmanage = 0;
  447.    
  448.    switch (type) 
  449.    {
  450.      case MailComposeLayoutAddress:
  451.         manage = data->address;    
  452.         unmanage = data->attach;
  453.     break;
  454.     case MailComposeLayoutAttach:
  455.         manage = data->attach;    
  456.         unmanage = data->address;
  457.     break;
  458.     case MailComposeLayoutCompose:
  459.     default: 
  460.         /* Do nothing */
  461.     break;
  462.    }
  463.  
  464.    if ( manage && unmanage )
  465.    {
  466.        XtUnmanageChild(unmanage);
  467.  
  468.        XtVaSetValues(manage,
  469.      XmNtopAttachment, XmATTACH_FORM,
  470.      XmNbottomAttachment, XmATTACH_NONE,
  471.      XmNleftAttachment, XmATTACH_FORM,
  472.      XmNrightAttachment, XmATTACH_FORM,
  473.     0);
  474.  
  475.        XtVaSetValues(data->compose,
  476.      XmNtopAttachment, XmATTACH_WIDGET,
  477.      XmNtopWidget, manage,
  478.      XmNtopOffset, 6,
  479.      XmNbottomAttachment, XmATTACH_FORM,
  480.      XmNleftAttachment, XmATTACH_FORM,
  481.      XmNrightAttachment, XmATTACH_FORM,
  482.     0);
  483.        XtManageChild(manage);
  484.    }
  485.    else if (type ==MailComposeLayoutCompose )
  486.    {
  487.     XtUnmanageChild(data->address);
  488.     XtUnmanageChild(data->attach);
  489.        XtVaSetValues(data->compose,
  490.      XmNtopAttachment, XmATTACH_FORM,
  491.      XmNbottomAttachment, XmATTACH_FORM,
  492.      XmNleftAttachment, XmATTACH_FORM,
  493.      XmNrightAttachment, XmATTACH_FORM,
  494.     0);
  495.    }
  496. }
  497.  
  498. extern void 
  499. fe_make_new_attach_list(MWContext *context);
  500.  
  501. static void
  502. activateTab(Widget w, XtPointer clientData, XtPointer callData)
  503. {
  504.   XmLFolderCallbackStruct *cb = (XmLFolderCallbackStruct *)callData;
  505.  
  506.   MWContext *context = (MWContext *)clientData;
  507.   fe_ContextData* data = CONTEXT_DATA(context);
  508.   String text;
  509.   XmTextPosition pos;
  510.   fe_MailComposeContextData *maildata = MAILCOMPOSE_CONTEXT_DATA(context);
  511.  
  512.   XtVaSetValues(maildata->address_tab, XmNtabManagedWidget, NULL, 0);
  513.   XtVaSetValues(maildata->attach_tab, XmNtabManagedWidget, NULL, 0);
  514.   XtVaSetValues(maildata->compose_tab, XmNtabManagedWidget, NULL, 0);
  515.   XmProcessTraversal(w, XmTRAVERSE_DOWN);
  516.  
  517.   if ( cb->pos == 0 )
  518.   {
  519.      mailcompose_layout(maildata, MailComposeLayoutAddress);
  520.      XtVaSetValues(maildata->address_tab, XmNtabManagedWidget, maildata->container,0);
  521.      XmProcessTraversal (data->mcSubject, XmTRAVERSE_CURRENT);
  522.   }
  523.   else if (cb->pos == 1 )
  524.   {
  525.      mailcompose_layout(maildata, MailComposeLayoutAttach);
  526.      fe_make_new_attach_list(context);
  527.      XtVaSetValues(maildata->attach_tab, XmNtabManagedWidget, maildata->container,0);
  528.      XmProcessTraversal (data->mcSubject, XmTRAVERSE_CURRENT);
  529.   }
  530.   else 
  531.   {
  532.      mailcompose_layout(maildata, MailComposeLayoutCompose);
  533.      XtVaSetValues(maildata->compose_tab, XmNtabManagedWidget, maildata->container,0);
  534.      XmProcessTraversal (data->mcSubject, XmTRAVERSE_CURRENT);
  535.   }
  536. }
  537.  
  538.  
  539. Widget
  540. fe_MailComposeWin_Create(MWContext* context, Widget parent)
  541. {
  542.  
  543.   XmFontList fontList;
  544.   Widget mainForm = 0;
  545.   fe_MailComposeContextData *data = MAILCOMPOSE_CONTEXT_DATA(context);
  546.   WidgetList formList2;
  547.   int j;
  548.  
  549.  
  550.   if ( !data ) 
  551.     /* Create a new one */
  552.         data = fe_MailComposeWin_CreateContext(context);
  553.   fe_compose_setData(context, (void *)data);
  554.   data->parent = parent;
  555.  
  556.   mainForm = fe_MailComposeWin_CreateFolders(context);
  557.   data->parentFolder = mainForm;
  558.   /* Create the Container */
  559.   {
  560.      data->container = 
  561.        fe_MailComposeContainer_CreateManaged(context);
  562.   }
  563.   /* Create Addressing */
  564.   {
  565.     XmString xmStr;
  566.  
  567.     xmStr = XmStringCreateSimple(XP_GetString(XFE_COMPOSE_ADDRESSING));
  568.     data->address_tab = XmLFolderAddTab(data->parentFolder, xmStr);
  569.     XmStringFree(xmStr);
  570.   }
  571.  
  572.   /* Create Attachment */
  573.   {
  574.     XmString xmStr;
  575.  
  576.     xmStr = XmStringCreateSimple(XP_GetString(XFE_COMPOSE_ATTACHMENT));
  577.     data->attach_tab = XmLFolderAddTab(data->parentFolder, xmStr);
  578.     XmStringFree(xmStr);
  579.   }
  580.  
  581.   /* Create Compose */
  582.   {
  583.     XmString xmStr;
  584.  
  585.     xmStr = XmStringCreateSimple(XP_GetString(XFE_COMPOSE_COMPOSE));
  586.     data->compose_tab = XmLFolderAddTab(data->parentFolder, xmStr);
  587.     XmStringFree(xmStr);
  588.   }
  589.  
  590.   XtAddCallback(data->parentFolder, XmNactivateCallback, 
  591.         activateTab, context);
  592.  
  593.   return (mainForm);
  594. }
  595.  
  596. void
  597. fe_MailComposeWin_Activate(MWContext *context)
  598. {
  599.   XmLFolderSetActiveTab(MAILCOMPOSE_CONTEXT_DATA(context)->parentFolder, 0, True);
  600. }
  601.  
  602. void
  603. fe_MailComposeWin_ActivateFolder(MWContext *context, int pos)
  604. {
  605.   XmLFolderSetActiveTab(MAILCOMPOSE_CONTEXT_DATA(context)->parentFolder, pos, True);
  606. }
  607.  
  608.