home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / xfe / src / ABSearchView.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  33.2 KB  |  1,246 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.    ABSearchView.cpp -- class definition for XFE_ABSearchView
  20.    Created: Tao Cheng <tao@netscape.com>, 23-oct-97
  21.  */
  22.  
  23. #include "ABSearchView.h"
  24. #include "ViewDialog.h"
  25.  
  26. #include <Xm/Form.h>
  27. #include <Xm/LabelG.h>
  28. #include <Xm/Label.h>
  29. #include <Xm/PushB.h>
  30. #include <Xm/TextF.h>
  31. #include <Xm/Frame.h>
  32. #include <Xm/RowColumn.h>
  33. #include <Xfe/Xfe.h>
  34.  
  35. #include "xpgetstr.h"
  36. #include "xfe.h"
  37. #include "felocale.h"
  38.  
  39. extern int XFE_SEARCH_DLG_PROMPT;
  40.  
  41. extern int XFE_SEARCH_ATTRIB_NAME;
  42. extern int XFE_SEARCH_ATTRIB_EMAIL;
  43. extern int XFE_SEARCH_ATTRIB_ORGAN;
  44. extern int XFE_SEARCH_ATTRIB_ORGANU;
  45. extern int XFE_SEARCH_RESULT_PROMPT;
  46.  
  47. extern int XFE_AB_SEARCH;
  48. extern int XFE_SEARCH_BASIC;
  49. extern int XFE_SEARCH_ADVANCED;
  50. extern int XFE_SEARCH_MORE;
  51. extern int XFE_SEARCH_FEWER;
  52.  
  53. extern int XFE_DLG_CANCEL;
  54. extern int XFE_DLG_CLEAR;
  55.  
  56. extern int XFE_SEARCH_BOOL_PROMPT;
  57. extern int XFE_SEARCH_BOOL_AND_PROMPT;
  58. extern int XFE_SEARCH_BOOL_OR_PROMPT;
  59. extern int XFE_SEARCH_BOOL_WHERE;
  60. extern int XFE_SEARCH_BOOL_THE;
  61. extern int XFE_SEARCH_BOOL_AND_THE;
  62. extern int XFE_SEARCH_BOOL_OR_THE;
  63.  
  64. extern "C" Widget 
  65. fe_make_option_menu(Widget toplevel, Widget parent, char* widgetName, 
  66.                     Widget *popup);
  67.  
  68. //
  69. const char *XFE_ABSearchView::dlgClose = 
  70.                              "XFE_ABSearchView::dlgClose";
  71.  
  72. XFE_ABSearchView::XFE_ABSearchView(XFE_Component      *toplevel_component,
  73.                                    Widget              parent,
  74.                                    MWContext          *context,
  75.                                    ABSearchInfo_t *info):
  76.     XFE_MNView(toplevel_component, 
  77.                NULL, 
  78.                context,
  79.                (MSG_Pane *)NULL),
  80.     m_mode(AB_SEARCH_NONE),
  81.     m_searchInfo(info),
  82.     m_params(NULL),
  83.     m_nRules(0),
  84.     m_nAllocted(0),
  85.     m_attrItems(NULL),
  86.     m_nAttribItems(0),
  87.     m_ruleCmdGroupForm(0),
  88.     m_andOrForm(0)
  89. {
  90.     XP_ASSERT(info && info->m_dir);
  91.     m_dir = info->m_dir;
  92.  
  93.     setBaseWidget(parent);
  94.  
  95.     Arg av [20];
  96.     int ac = 0;
  97.  
  98.  
  99.     /* 2 sub forms
  100.      */
  101.     Widget subForms[2],
  102.            workForm;
  103.  
  104.     /* search rules
  105.      */
  106.     ac = 0;
  107.     subForms[0] = XmCreateForm(parent, "searchRulesForm", av, ac);
  108.     XtManageChild(subForms[0]);
  109.  
  110.     /* Frame
  111.      */
  112.     ac = 0;
  113.     XtSetArg (av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  114.     XtSetArg (av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  115.     XtSetArg (av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  116.     XtSetArg (av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  117.     XtSetArg (av[ac], 
  118.               XmNchildHorizontalAlignment, XmALIGNMENT_BEGINNING);ac++; 
  119.     Widget frame = XmCreateFrame(subForms[0], "viewFrame", av, ac);
  120.     XtManageChild(frame);
  121.  
  122.     /* frame title
  123.      */
  124.     Widget title;
  125.  
  126.     /* to satisfy gcc
  127.      */
  128.     char tmp[256];
  129.     sprintf(tmp,
  130.             "%s %s", 
  131.             XP_GetString(XFE_SEARCH_DLG_PROMPT),
  132.             m_dir->description?m_dir->description:"");
  133.     
  134.     title = XtVaCreateManagedWidget(tmp,
  135.                                     xmLabelGadgetClass, frame,
  136.                                     XmNchildType, XmFRAME_TITLE_CHILD,
  137.                                     NULL);
  138.     m_dirPrompt = title;
  139.  
  140.     ac = 0;
  141.     XtSetArg (av[ac], XmNchildType, XmFRAME_WORKAREA_CHILD); ac++;
  142.     workForm = XmCreateForm(frame, "workAreaForm", av, ac);
  143.     XtManageChild(workForm);
  144.     m_workForm = workForm;
  145.  
  146.     /* row Col
  147.      */
  148.     ac = 0;
  149.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  150.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  151.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  152.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
  153.     m_rulesRowCol = XmCreateRowColumn(workForm, "rulesRowCol", av, ac);
  154.  
  155.     /* result prompt
  156.      */
  157.     m_searchRulesPrompt =
  158.         XtVaCreateManagedWidget(XP_GetString(XFE_SEARCH_RESULT_PROMPT),
  159.                                 xmLabelGadgetClass, workForm,
  160.                                 XmNleftAttachment, XmATTACH_FORM,
  161.                                 XmNtopAttachment, XmATTACH_WIDGET,
  162.                                 XmNtopWidget, m_rulesRowCol,
  163.                                 XmNtopOffset, 5,
  164.                                 XmNrightAttachment, XmATTACH_FORM,
  165.                                 XmNbottomAttachment, XmATTACH_FORM,
  166.                                 NULL);
  167.  
  168.     /* cmdButtonForm
  169.      */
  170.     ac = 0;
  171.     subForms[1] = XmCreateForm (parent, "cmdButtonForm", av, ac);
  172.     XtManageChild(subForms[1]);
  173.  
  174.     /* cmdRowCol1
  175.      */
  176.     ac = 0;
  177.     XtSetArg(av[ac], XmNorientation, XmVERTICAL); ac++;    
  178.     XtSetArg(av[ac], XmNentryAlignment, XmALIGNMENT_CENTER); ac++;    
  179.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  180.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  181.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  182.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
  183.     Widget rowCol1 = XmCreateRowColumn(subForms[1] , "cmdRowCol1", av, ac);
  184.     XtManageChild(rowCol1);
  185.  
  186.     /* Search button
  187.      */
  188.     ac = 0;
  189.     Widget dummy = XmCreatePushButton(rowCol1, 
  190.                                       XP_GetString(XFE_AB_SEARCH), 
  191.                                       av, ac);
  192.     XtVaSetValues(dummy,
  193.                   XmNalignment, XmALIGNMENT_CENTER,
  194.                   NULL);
  195.     fe_SetString(dummy, XmNlabelString, XP_GetString(XFE_AB_SEARCH));
  196.     XtManageChild(dummy);
  197.  
  198.     XtAddCallback(dummy, XmNactivateCallback, 
  199.                   XFE_ABSearchView::okCallback, 
  200.                   this);
  201.  
  202.     /* Cancel button
  203.      */
  204.     ac = 0;
  205.     dummy = XmCreatePushButton(rowCol1, 
  206.                                XP_GetString(XFE_DLG_CANCEL), 
  207.                                av, ac);
  208.     XtVaSetValues(dummy,
  209.                   XmNalignment, XmALIGNMENT_CENTER,
  210.                   NULL);
  211.     fe_SetString(dummy, XmNlabelString, XP_GetString(XFE_DLG_CANCEL));
  212.     XtManageChild(dummy);
  213.  
  214.     XtAddCallback(dummy, XmNactivateCallback, 
  215.                   XFE_ABSearchView::cancelCallback, 
  216.                   this);
  217.  
  218.     ac = 0;
  219.     XtSetArg(av[ac], XmNorientation, XmVERTICAL); ac++;
  220.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  221.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
  222.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  223.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  224.     Widget rowCol2 = XmCreateRowColumn(subForms[1] , "cmdRowCol2", av, ac);
  225.     XtManageChild(rowCol2);
  226.  
  227.     ac = 0;
  228.     XtSetArg(av[ac], XmNalignment, XmALIGNMENT_CENTER);ac++;
  229.     dummy = m_modeToggle = 
  230.         XmCreatePushButton(rowCol2, 
  231.                            ((info->m_mode == AB_SEARCH_BASIC)?
  232.                             XP_GetString(XFE_SEARCH_ADVANCED):
  233.                             XP_GetString(XFE_SEARCH_BASIC)),
  234.                            av, ac);
  235.     XtManageChild(dummy);
  236.  
  237.     /* attachment 
  238.      */
  239.     XtVaSetValues(subForms[1],
  240.                   // XmNheight, 300,
  241.                   XmNleftAttachment, XmATTACH_NONE,
  242.                   XmNtopAttachment, XmATTACH_FORM,
  243.                   XmNrightAttachment, XmATTACH_FORM,
  244.                   XmNbottomAttachment, XmATTACH_FORM,
  245.                   NULL);
  246.  
  247.     XtVaSetValues(subForms[0],
  248.                   // XmNheight, 300,
  249.                   XmNleftAttachment, XmATTACH_FORM,
  250.                   XmNtopAttachment, XmATTACH_FORM,
  251.                   XmNrightAttachment, XmATTACH_WIDGET,
  252.                   XmNrightWidget, subForms[1],
  253.                   XmNbottomAttachment, XmATTACH_FORM,
  254.                   NULL);
  255.     
  256.     /* pre-alloc
  257.      */
  258.     if (!m_params ||
  259.         !m_nAllocted) {
  260.         m_nAllocted = 4;
  261.         m_params = (ABSearchUIParam_t *) XP_CALLOC(m_nAllocted, 
  262.                                                    sizeof(ABSearchUIParam_t));
  263.     }/* if */
  264.  
  265.     XtManageChild(m_rulesRowCol);
  266.     toggleSearchMode(info);
  267.  
  268.     //callbacks
  269.     XtAddCallback(m_modeToggle, XmNactivateCallback, 
  270.                   XFE_ABSearchView::toggleSearchModeCallback, 
  271.                   this);
  272. }
  273.  
  274. XFE_ABSearchView::~XFE_ABSearchView()
  275. {
  276. }
  277.  
  278. Widget 
  279. XFE_ABSearchView::rebuildOptChildren(Widget            popupParent, 
  280.                                      int               num, 
  281.                                      ABSearchUIHint_t *hint,
  282.                                      XtCallbackProc    cb)
  283. {
  284.     XP_ASSERT(num && hint);
  285.  
  286.     WidgetList childrenList;
  287.     int        numChildren;
  288.     
  289.     /* Clean up first 
  290.      */
  291.     XtVaGetValues(popupParent, 
  292.                   XmNchildren, &childrenList,
  293.                   XmNnumChildren, &numChildren,
  294.                   NULL);
  295.  
  296.     for (int i = 0; i < numChildren; i++) {
  297.         /* free user data
  298.          */
  299.  
  300.         /* destroy widget
  301.          */
  302.         XtDestroyWidget(childrenList[i]);
  303.     }/* for i */
  304.  
  305.     /* Create new ones... 
  306.      */
  307.     Arg av[20];
  308.     int ac = 0;
  309.     
  310.     XmString xmStr;
  311.     Widget btn, 
  312.            btn1 = NULL;
  313.     for (i = 0; i < num; i++) {
  314.         xmStr = XmStringCreateSimple(hint[i].m_menuItem->name);
  315.         
  316.         ac = 0;
  317.         XtSetArg(av[ac], XmNlabelString, xmStr); ac++;
  318.         XtSetArg(av[ac], XmNuserData, &(hint[i])); ac++;
  319.         btn = XmCreatePushButtonGadget(popupParent, "optBtn", av, ac);
  320.         if (!btn1)
  321.             btn1 = btn;
  322.  
  323.         hint[i].m_obj = (void *) this;
  324.         XtAddCallback(btn, XmNactivateCallback, cb, this);
  325.  
  326.         XtManageChild(btn);
  327.         XmStringFree(xmStr);
  328.     }/* for i */
  329.  
  330.     return btn1;
  331. }
  332.  
  333. Widget 
  334. XFE_ABSearchView::makeOptMenu(Widget            parent, 
  335.                               int               num, 
  336.                               ABSearchUIHint_t *hint,
  337.                               XtCallbackProc    cb,
  338.                               Widget           *popUp)
  339. {
  340.     char tmp[32];
  341.     sprintf(tmp, "optMenu_%d", hint[0].m_type);
  342.     Widget popup = NULL, /* to build pull down */
  343.            optMenu = fe_make_option_menu(getToplevel()->getBaseWidget(),
  344.                                          parent, tmp, &popup);
  345.     *popUp = popup;
  346.  
  347.     /* rebuild popup children
  348.      */
  349.     Widget btn1 = rebuildOptChildren(popup,
  350.                                      num, 
  351.                                      hint,
  352.                                      cb);
  353.     XtVaSetValues(optMenu, 
  354.                   XmNmenuHistory, btn1, 
  355.                   XmNtraversalOn, False, 
  356.                   NULL);
  357.     XtManageChild(optMenu);
  358.     return optMenu;
  359. }
  360.  
  361. void XFE_ABSearchView::cleanupUI(uint16 i, XP_Bool clearRule)
  362. {
  363.     if (m_params[i].m_ruleForm) {
  364.         if (clearRule) {
  365.             m_params[i].m_op = opContains;
  366.             m_params[i].m_attribNval.attribute = attribCommonName;
  367.             XP_FREEIF(m_params[i].m_attribNval.u.string);
  368.         }/* if */
  369.  
  370.         XtUnmanageChild(m_params[i].m_ruleForm);
  371.         
  372.         if (m_params[i].m_attribOptMenu) {
  373.             XtUnmanageChild(m_params[i].m_attribOptMenu);
  374.             
  375.             /* TODO: need to free heap here
  376.              */
  377.             
  378.             /*
  379.              */
  380.             XtDestroyWidget(m_params[i].m_attribOptMenu);
  381.             m_params[i].m_attribOptMenu = NULL;
  382.         }/* if */
  383.         
  384.         if (m_params[i].m_opOptMenu) {
  385.             XtUnmanageChild(m_params[i].m_opOptMenu);
  386.             XtDestroyWidget(m_params[i].m_opOptMenu);
  387.             m_params[i].m_opOptMenu = NULL;
  388.         }/* if */
  389.     
  390.         if (m_params[i].m_label) {
  391.             XtUnmanageChild(m_params[i].m_label);
  392.             XtDestroyWidget(m_params[i].m_label);
  393.             m_params[i].m_label = NULL;
  394.         }/* if */
  395.         
  396.         if (m_params[i].m_textF) {
  397.             XtUnmanageChild(m_params[i].m_textF);
  398.             XtDestroyWidget(m_params[i].m_textF);
  399.             m_params[i].m_textF = NULL;
  400.         }/* if */
  401.         XtDestroyWidget(m_params[i].m_ruleForm);
  402.         m_params[i].m_ruleForm = NULL;
  403.     }/* if form */
  404. }
  405.  
  406. void XFE_ABSearchView::remove1Rule()
  407. {
  408.     XP_ASSERT(m_nRules > 1);
  409.     m_nRules--;
  410.     cleanupUI(m_nRules, True);
  411. }
  412.  
  413. void XFE_ABSearchView::setOptMenu(Widget w, int16 attrib)
  414. {
  415.     if (!w ||
  416.         !XmIsRowColumn(w))
  417.         XP_ASSERT(0);
  418.  
  419.     Widget popup = NULL;
  420.     XtVaGetValues(w, 
  421.                   XmNsubMenuId, &popup, 
  422.                   NULL);
  423.  
  424.     if (!popup ||
  425.         !XmIsRowColumn(popup))
  426.         XP_ASSERT(0);
  427.  
  428.     int        numChildren = 0;
  429.     WidgetList childrenList;
  430.  
  431.     XtVaGetValues(popup, 
  432.                   XmNchildren,    &childrenList,
  433.                   XmNnumChildren, &numChildren, 
  434.                   NULL);
  435.     XP_ASSERT(childrenList && numChildren);
  436.     void *userData = NULL;
  437.     for (int i=0; i < numChildren; i++) {
  438.         XtVaGetValues(childrenList[i], XmNuserData, &userData, NULL);
  439.         if (!XfeIsAlive(childrenList[i])) {
  440.             continue;
  441.         }/* if */
  442.  
  443.         if (attrib == 
  444.             ((ABSearchUIHint_t *)userData)->m_menuItem->attrib) {
  445.             XtVaSetValues(w, 
  446.                           XmNmenuHistory, childrenList[i], 
  447.                           NULL);
  448.             break;
  449.         }/* if */
  450.     }/* for i */
  451. }
  452.  
  453. void XFE_ABSearchView::getAttribNames()
  454. {
  455.     m_attrItems = 
  456.         (MSG_SearchMenuItem *)XP_CALLOC(kNumAttributes,     
  457.                                         sizeof(MSG_SearchMenuItem));
  458.     m_nAttribItems = kNumAttributes;
  459.     
  460.     DIR_Server *dirs[1];
  461.     dirs[0]= (DIR_Server*) m_dir;
  462.     
  463.     MSG_SearchError err;
  464.     err = MSG_GetAttributesForSearchScopes(fe_getMNMaster(), 
  465.                                            scopeLdapDirectory,
  466.                                            (void **) dirs, 
  467.                                            1, 
  468.                                            m_attrItems,
  469.                                            &m_nAttribItems);
  470. }
  471.  
  472. void XFE_ABSearchView::add1Rule(MSG_SearchAttribute  attrib,
  473.                                 MSG_SearchOperator   op,
  474.                                 char                *stringVal)
  475. {
  476.     Arg av [20];
  477.     int ac = 0;
  478.  
  479.     /* the form 
  480.      */
  481.     if (m_nAllocted <= m_nRules) {
  482.         m_nAllocted = m_nRules+1;
  483.         m_params = (ABSearchUIParam_t *) 
  484.             XP_REALLOC(m_params,
  485.                        m_nAllocted*sizeof(ABSearchUIParam_t));
  486.         memset(&(m_params[m_nRules]), 0, sizeof(ABSearchUIParam_t));
  487.     }/* else if */
  488.  
  489.     if (!m_params[m_nRules].m_ruleForm) {
  490.         ac = 0;
  491.         m_params[m_nRules].m_ruleForm = 
  492.             XmCreateForm(m_rulesRowCol, "advancedRuleForm", av, ac);
  493.     }/* if */
  494.     // 0: andOr
  495.     XtVaSetValues(m_params[m_nRules].m_ruleForm, 
  496.                   XmNpositionIndex, m_nRules+1,
  497.                   0);
  498.  
  499.     /* label: and/or the
  500.      */
  501.     /* compute
  502.      */
  503.     Dimension wid = 0, max_with = 0;
  504.     char tmp[256];
  505.     Widget dummy =
  506.         XtVaCreateManagedWidget(tmp,
  507.                                 xmLabelWidgetClass, 
  508.                                 m_params[m_nRules].m_ruleForm,
  509.                                 XmNalignment, XmALIGNMENT_END, 
  510.                                 XmNleftAttachment, XmATTACH_FORM,
  511.                                 XmNtopAttachment, XmATTACH_FORM,
  512.                                 XmNrightAttachment, XmATTACH_NONE,
  513.                                 XmNbottomAttachment, XmATTACH_FORM,
  514.                                 NULL);
  515.     for (int j=0; j < 3; j++) {
  516.         sprintf(tmp,
  517.                 "%s", 
  518.                 XP_GetString(XFE_SEARCH_BOOL_THE+j));
  519.         fe_SetString(dummy, XmNlabelString, tmp);
  520.  
  521.         XtVaGetValues(dummy, 
  522.                       XmNwidth, &wid,
  523.                       NULL);
  524.         if (wid > max_with)
  525.             max_with = wid;
  526.     }/* for i */
  527.     XtDestroyWidget(dummy);
  528.  
  529.     /* real
  530.      */
  531.     sprintf(tmp,
  532.             "%s", 
  533.             (m_nRules==0)?
  534.             (XP_GetString(XFE_SEARCH_BOOL_THE)):
  535.             (m_searchInfo->m_logicOp?
  536.              XP_GetString(XFE_SEARCH_BOOL_AND_THE):
  537.              XP_GetString(XFE_SEARCH_BOOL_OR_THE)));
  538.  
  539.     m_params[m_nRules].m_label = 
  540.         XtVaCreateManagedWidget(tmp,
  541.                                 xmLabelWidgetClass, 
  542.                                 m_params[m_nRules].m_ruleForm,
  543.                                 XmNwidth, max_with,
  544.                                 XmNrecomputeSize, False,
  545.                                 XmNalignment, XmALIGNMENT_END, 
  546.                                 XmNleftAttachment, XmATTACH_FORM,
  547.                                 XmNtopAttachment, XmATTACH_FORM,
  548.                                 XmNrightAttachment, XmATTACH_NONE,
  549.                                 XmNbottomAttachment, XmATTACH_FORM,
  550.                                 NULL);
  551.  
  552.     /* Attrib
  553.      */
  554.     if (!m_nAttribItems ||
  555.         !m_attrItems)
  556.         getAttribNames();
  557.  
  558.     /* attrib menu
  559.      */
  560.     ABSearchUIHint_t *hint = 
  561.         (ABSearchUIHint_t *) XP_CALLOC(m_nAttribItems, 
  562.                                        sizeof(ABSearchUIHint_t));
  563.     XP_Bool validAttrib = False;
  564.     for (int i=0; i < m_nAttribItems; i++) {
  565.         hint[i].m_th = m_nRules;
  566.         hint[i].m_type = AB_SEARCH_ATTRIB;
  567.         hint[i].m_menuItem = &(m_attrItems[i]);
  568.         hint[i].m_obj = this;    
  569.         if (attrib != kNumAttributes &&
  570.             !validAttrib)
  571.             if (hint[i].m_menuItem->attrib == (MSG_SearchAttribute) attrib)
  572.                 validAttrib = True;
  573.     }/* for i */
  574.  
  575.     m_params[m_nRules].m_attribOptMenu = 
  576.         makeOptMenu(m_params[m_nRules].m_ruleForm,
  577.                     m_nAttribItems, 
  578.                     hint,
  579.                     &(XFE_ABSearchView::optValChgCallback),
  580.                     &m_params[m_nRules].m_attribPopup);
  581.  
  582.     /* use whatever is there */
  583.     if (!validAttrib) {
  584.         /* correct 
  585.          */
  586.         attrib = (MSG_SearchAttribute) m_attrItems[m_nRules].attrib;
  587.     }/* if */
  588.     m_params[m_nRules].m_attribNval.attribute = attrib;
  589.  
  590.     setOptMenu(m_params[m_nRules].m_attribOptMenu, 
  591.                (uint16) attrib);
  592.  
  593.     XtVaSetValues(m_params[m_nRules].m_attribOptMenu,
  594.                   XmNleftAttachment, XmATTACH_WIDGET,
  595.                   XmNleftWidget, m_params[m_nRules].m_label,
  596.                   XmNtopAttachment, XmATTACH_FORM,
  597.                   XmNrightAttachment, XmATTACH_NONE,
  598.                   XmNbottomAttachment, XmATTACH_FORM,
  599.                   NULL);
  600.     /* op menu
  601.      */
  602.     uint16 opNum = 0;
  603.     hint = getOptMenuHint(m_nRules, &opNum);
  604.     m_params[m_nRules].m_opOptMenu = 
  605.         makeOptMenu(m_params[m_nRules].m_ruleForm,
  606.                     opNum,
  607.                     hint,
  608.                     &(XFE_ABSearchView::optValChgCallback),
  609.                     &m_params[m_nRules].m_opPopup);
  610.  
  611.     /* compute op
  612.      */
  613.     XP_Bool opValid = False;
  614.     for (i=0; (op != kNumOperators) && (i < opNum); i++) {
  615.         if (op == (MSG_SearchOperator) hint[i].m_menuItem->attrib) {
  616.             opValid = True;
  617.             break;
  618.         }/* if */
  619.     }/* for i */
  620.     if (!opValid) {
  621.         op = (MSG_SearchOperator) hint[0].m_menuItem->attrib;
  622.     }/* if */
  623.     m_params[m_nRules].m_op = op;
  624.     setOptMenu(m_params[m_nRules].m_opOptMenu, op);
  625.  
  626.     XtVaSetValues(m_params[m_nRules].m_opOptMenu,
  627.                   XmNleftAttachment, XmATTACH_WIDGET,
  628.                   XmNleftWidget, m_params[m_nRules].m_attribOptMenu,
  629.                   XmNtopAttachment, XmATTACH_FORM,
  630.                   XmNrightAttachment, XmATTACH_NONE,
  631.                   XmNbottomAttachment, XmATTACH_FORM,
  632.                   NULL);
  633.     /* TextF
  634.      */
  635.     ac = 0;
  636.     XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  637.     XtSetArg(av[ac], XmNleftWidget, m_params[m_nRules].m_opOptMenu); ac++;
  638.     XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  639.     XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  640.     XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  641.     //XtSetArg(av[ac], XmNwidth, 150); ac++;
  642.     m_params[m_nRules].m_textF = fe_CreateTextField(m_params[m_nRules].m_ruleForm,
  643.                                                     "ruleTextVal",
  644.                                                     av, ac);
  645.     XtAddCallback(m_params[m_nRules].m_textF, XmNactivateCallback, 
  646.                   XFE_ABSearchView::textFActivateCallback, 
  647.                   this);
  648.     /* set def
  649.      */
  650.     fe_SetTextField(m_params[m_nRules].m_textF, 
  651.                     stringVal?stringVal:"");
  652.     m_params[i].m_attribNval.u.string = stringVal;
  653.  
  654.     XtManageChild(m_params[m_nRules].m_textF);
  655.     XtManageChild(m_params[m_nRules].m_ruleForm);
  656.     m_nRules++;
  657.  
  658.     XtVaSetValues(m_ruleCmdGroupForm, 
  659.                   XmNpositionIndex, XmLAST_POSITION,
  660.                   NULL);
  661.  
  662. }
  663.  
  664. char*
  665. XFE_ABSearchView::getValByAttrib(ABSearchUIParam_t *params, 
  666.                                  int nParams, MSG_SearchAttribute attrib)
  667. {
  668.     for (int i=0; i < nParams; i++) {
  669.         if (params[i].m_attribNval.attribute == attrib)
  670.             return params[i].m_attribNval.u.string;
  671.     }/* for i */
  672.     return NULL;
  673. }
  674.  
  675. void XFE_ABSearchView::toggleSearchMode(ABSearchInfo_t *info)
  676. {
  677.     XP_ASSERT(info && info->m_dir && m_rulesRowCol);
  678.     XtUnmanageChild(m_workForm);
  679.  
  680.     /* pass params
  681.      */
  682.     m_searchInfo = info;
  683.     if (info->m_nRules &&
  684.         info->m_params) {
  685.         m_nRules = info->m_nRules;
  686.         m_params = info->m_params;
  687.     }/* if */
  688.  
  689.     m_dir = info->m_dir;
  690.  
  691.     /* to satisfy gcc
  692.      */
  693.     char tmp[256];
  694.  
  695.     /* set title
  696.      */
  697.     sprintf(tmp,
  698.             "%s %s", 
  699.             XP_GetString(XFE_SEARCH_DLG_PROMPT),
  700.             m_dir->description?m_dir->description:"");
  701.     
  702.     fe_SetString(m_dirPrompt,
  703.                  XmNlabelString, tmp);
  704.     
  705.     Arg av [20];
  706.     int ac = 0;
  707.     int i = 0;
  708.  
  709.     /* Buffer up
  710.      */
  711.     int nVal = m_nRules;
  712.     ABSearchUIParam_t *buffer =
  713.         (ABSearchUIParam_t *) XP_CALLOC(m_nRules, 
  714.                                         sizeof(ABSearchUIParam_t));
  715.     buffer = 
  716.         (ABSearchUIParam_t *) memcpy(buffer, m_params, 
  717.                                      m_nRules*sizeof(ABSearchUIParam_t));
  718.  
  719.     if (info->m_mode == AB_SEARCH_BASIC) {
  720.         /* clean up residue
  721.          */
  722.         fe_SetString(m_modeToggle, 
  723.                      XmNlabelString, XP_GetString(XFE_SEARCH_ADVANCED));
  724.  
  725.         if (m_andOrForm)
  726.             XtUnmanageChild(m_andOrForm);
  727.         if (m_ruleCmdGroupForm)
  728.             XtUnmanageChild(m_ruleCmdGroupForm);
  729.  
  730.         /* un map widgets
  731.          */
  732.         for (i=0; i < m_nRules; i++)
  733.             cleanupUI(i, False);
  734.  
  735.         XtVaSetValues(m_rulesRowCol,
  736.                       XmNorientation, XmVERTICAL,
  737.                       XmNnumColumns, 2,
  738.                       XmNpacking, XmPACK_COLUMN,
  739.                       NULL);
  740.  
  741.         /* get new attribs
  742.          */
  743.         m_searchInfo->m_logicOp = True; //and
  744.         m_nRules = kNumAttributes;
  745.         MSG_SearchMenuItem *attrItems = 
  746.             (MSG_SearchMenuItem *)XP_CALLOC(m_nRules,     
  747.                                             sizeof(MSG_SearchMenuItem));
  748. #if 0
  749.         /* Tao: do not take out this ....
  750.          */
  751.         MSG_SearchError err = 
  752.             MSG_GetBasicLdapSearchAttributes(m_dir, 
  753.                                              attrItems,
  754.                                              (int *) &m_nRules);
  755. #endif
  756.         if (!m_nRules ||
  757.             !attrItems[0].name ||
  758.             !XP_STRLEN(attrItems[0].name)) {
  759.             m_nRules = 4;
  760.  
  761.             attrItems[0].attrib = attribCommonName;
  762.             attrItems[1].attrib = attribOrganization;
  763.             attrItems[2].attrib = attrib822Address;
  764.             attrItems[3].attrib = attribOrgUnit;
  765.             for (i=0; i < m_nRules; i++) {
  766.                 DIR_AttributeId id;
  767.                 MSG_SearchAttribToDirAttrib((MSG_SearchAttribute)attrItems[i].attrib, 
  768.                                             &id);
  769.                 XP_STRCPY(attrItems[i].name, DIR_GetAttributeName(m_dir, id));
  770.             }/* for i */
  771.         }/* if */
  772.  
  773.         /* realloc if needed
  774.          */
  775.         if (m_nRules > m_nAllocted) {
  776.             m_params = (ABSearchUIParam_t *) 
  777.                 XP_REALLOC(m_params,
  778.                            m_nRules*sizeof(ABSearchUIParam_t));
  779.  
  780.             int delta = m_nRules-m_nAllocted;
  781.             memset(&(m_params[m_nAllocted]), 
  782.                    0, 
  783.                    delta*sizeof(ABSearchUIParam_t));
  784.             m_nAllocted = m_nRules;
  785.         }/* if */
  786.  
  787.         for (i=0; i < m_nRules; i++) {
  788.  
  789.             // set defaults
  790.             m_params[i].m_op = opContains;
  791.             m_params[i].m_attribNval.attribute = 
  792.                 (MSG_SearchAttribute) attrItems[i].attrib;
  793.             m_params[i].m_attribNval.u.string = 
  794.                 getValByAttrib(buffer, nVal, 
  795.                                m_params[i].m_attribNval.attribute);
  796.             /* attrib name
  797.              */
  798.             const char *text = attrItems[i].name;
  799.             ac = 0;
  800.             if (!m_params[i].m_ruleForm)
  801.                 m_params[i].m_ruleForm = XmCreateForm(m_rulesRowCol, 
  802.                                                       "basicRulesForm", av, ac);
  803.             /* Create labels
  804.              */
  805.             m_params[i].m_label = 
  806.                 XtVaCreateManagedWidget(text,
  807.                                         xmLabelGadgetClass, m_params[i].m_ruleForm,
  808.                                         XmNalignment, XmALIGNMENT_BEGINNING, 
  809.                                         XmNleftAttachment, XmATTACH_FORM,
  810.                                         XmNtopAttachment, XmATTACH_FORM,
  811.                                         XmNrightAttachment, XmATTACH_NONE,
  812.                                         XmNbottomAttachment, XmATTACH_NONE,
  813.                                         NULL);
  814.             /* TextF
  815.              */
  816.             ac = 0;
  817.             XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  818.             XtSetArg(av[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
  819.             XtSetArg(av[ac], XmNtopWidget, m_params[i].m_label); ac++;
  820.             XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  821.             XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  822.             //XtSetArg(av[ac], XmNwidth, 180); ac++;
  823.             m_params[i].m_textF = fe_CreateTextField(m_params[i].m_ruleForm, 
  824.                                                      text,
  825.                                                      av, ac);
  826.             /* set default
  827.              */
  828.             if (m_params[i].m_attribNval.u.string)
  829.                 fe_SetTextField(m_params[i].m_textF, 
  830.                                 m_params[i].m_attribNval.u.string);    
  831.             else
  832.                 fe_SetTextField(m_params[i].m_textF, 
  833.                                 "");    
  834.  
  835.             XtAddCallback(m_params[i].m_textF, XmNactivateCallback, 
  836.                           XFE_ABSearchView::textFActivateCallback, 
  837.                           this);
  838.             XtManageChild(m_params[i].m_textF);
  839.             XtManageChild(m_params[i].m_ruleForm);
  840.         }/* for i */
  841.         XP_FREEIF(attrItems);
  842.     }/* if */
  843.     else {
  844.  
  845.         /* AB_SEARCH_ADVANCED
  846.          * clean up residue
  847.          */
  848.         fe_SetString(m_modeToggle, 
  849.                      XmNlabelString, XP_GetString(XFE_SEARCH_BASIC));
  850.         /* un map
  851.          */
  852.         for (i=0; i < m_nRules; i++)
  853.             cleanupUI(i, False);
  854.  
  855.         XtVaSetValues(m_rulesRowCol,
  856.                       XmNorientation, XmVERTICAL,
  857.                       XmNnumColumns, 1,
  858.                       XmNpacking, XmPACK_COLUMN,
  859.                       NULL);
  860.  
  861.         /* free heap & basic widget .....
  862.          */
  863.  
  864.  
  865.         /* get attribs for this scope
  866.          */
  867.         if (!m_andOrForm) {
  868.             ac = 0;
  869.             XtSetArg(av[ac], XmNpositionIndex, 0); ac++;
  870.             m_andOrForm =
  871.                 XmCreateForm(m_rulesRowCol, "andOrForm", av, ac);
  872.  
  873.             ABSearchUIHint_t *hint = 
  874.                 (ABSearchUIHint_t *) XP_CALLOC(2,
  875.                                                sizeof(ABSearchUIHint_t));
  876.             /* and, or
  877.              */
  878.             for (int i=0; i < 2; i++) {
  879.                 hint[i].m_th = -1;
  880.                 hint[i].m_type = AB_SEARCH_CONNECTOR;
  881.                 hint[i].m_menuItem = 
  882.                     (MSG_SearchMenuItem *) XP_CALLOC(1, sizeof(MSG_SearchMenuItem));
  883.                 hint[i].m_menuItem->attrib = (int16) ((i==0)?True:False);
  884.                 XP_SAFE_SPRINTF(hint[i].m_menuItem->name,  
  885.                                  sizeof(hint[i].m_menuItem->name),
  886.                                  "%s",
  887.                                 XP_GetString(XFE_SEARCH_BOOL_AND_PROMPT+i));
  888.                 hint[i].m_menuItem->isEnabled = True;
  889.                 hint[i].m_obj = this;        
  890.             }/* for i */
  891.  
  892.             m_andOrOptMenu =
  893.                 makeOptMenu(m_andOrForm,
  894.                             2,
  895.                             hint,
  896.                             &(XFE_ABSearchView::optValChgCallback),
  897.                             &m_andOrPopup);
  898.             
  899.             
  900.             XtVaSetValues(m_andOrOptMenu,
  901.                           XmNleftAttachment, XmATTACH_FORM,
  902.                           XmNtopAttachment, XmATTACH_FORM,
  903.                           XmNrightAttachment, XmATTACH_NONE,
  904.                           XmNbottomAttachment, XmATTACH_FORM,
  905.                           NULL);
  906.             /* where
  907.              */
  908.             Widget label = XtVaCreateManagedWidget(XP_GetString(XFE_SEARCH_BOOL_WHERE),
  909.                                                    xmLabelGadgetClass, m_andOrForm,
  910.                                                    XmNleftAttachment, XmATTACH_WIDGET,
  911.                                                    XmNleftWidget, m_andOrOptMenu,
  912.                                                    XmNtopAttachment, XmATTACH_FORM,
  913.                                                    XmNrightAttachment, XmATTACH_NONE,
  914.                                                    XmNbottomAttachment, XmATTACH_FORM,
  915.                                                    NULL);
  916.  
  917.  
  918.         }/* if */
  919.         /* use whatever is there */
  920.         MSG_SearchAttribute attrib = 
  921.             (MSG_SearchAttribute) info->m_logicOp;            
  922.         setOptMenu(m_andOrOptMenu, (uint16) attrib);
  923.         XtManageChild(m_andOrForm);
  924.  
  925.         /* get attribs for this scope
  926.          */
  927.         if (!m_ruleCmdGroupForm) {
  928.             /*  cmd group:form,  more/fewer/clear
  929.              */
  930.             ac = 0;
  931.             XtSetArg(av[ac], XmNpositionIndex, XmLAST_POSITION); ac++;
  932.             m_ruleCmdGroupForm = 
  933.                 XmCreateForm(m_rulesRowCol, "ruleCmdGroupForm", av, ac);
  934.  
  935.             ac = 0;
  936.             XtSetArg(av[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
  937.             XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  938.             XtSetArg(av[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
  939.             XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  940.             m_moreBtn = XmCreatePushButton(m_ruleCmdGroupForm,
  941.                                            XP_GetString(XFE_SEARCH_MORE), 
  942.                                            av, ac);
  943.             ac = 0;
  944.             XtSetArg(av[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
  945.             XtSetArg(av[ac], XmNleftWidget, m_moreBtn); ac++;
  946.             XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  947.             XtSetArg(av[ac], XmNrightAttachment, XmATTACH_NONE); ac++;
  948.             XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  949.             m_fewerBtn = XmCreatePushButton(m_ruleCmdGroupForm,
  950.                                             XP_GetString(XFE_SEARCH_FEWER), 
  951.                                             av, ac);
  952.             ac = 0;
  953.             XtSetArg(av[ac], XmNleftAttachment, XmATTACH_NONE); ac++;
  954.             XtSetArg(av[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
  955.             XtSetArg(av[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
  956.             XtSetArg(av[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
  957.             m_clearBtn = XmCreatePushButton(m_ruleCmdGroupForm,
  958.                                             XP_GetString(XFE_DLG_CLEAR), 
  959.                                             av, ac);
  960.             XtManageChild(m_moreBtn);
  961.             XtManageChild(m_fewerBtn);
  962.             XtManageChild(m_clearBtn);
  963.             XtManageChild(m_ruleCmdGroupForm);
  964.             //
  965.             XtAddCallback(m_moreBtn, XmNactivateCallback, 
  966.                           XFE_ABSearchView::moreCallback, 
  967.                           this);
  968.             XtAddCallback(m_fewerBtn, XmNactivateCallback, 
  969.                           XFE_ABSearchView::fewerCallback, 
  970.                           this);
  971.             XtAddCallback(m_clearBtn, XmNactivateCallback, 
  972.                           XFE_ABSearchView::clearCallback, 
  973.                           this);
  974.             
  975.  
  976.         }/* if !m_ruleCmdGroupForm */        
  977.  
  978.         uint16 existing = m_nRules;
  979.         m_nRules = 0;
  980.         for (i=0; i < existing; i++) {
  981.             if (!m_params[i].m_attribNval.u.string ||
  982.                 !XP_STRLEN(m_params[i].m_attribNval.u.string))
  983.                 continue;
  984.             add1Rule(m_params[i].m_attribNval.attribute,
  985.                      m_params[i].m_op,
  986.                      m_params[i].m_attribNval.u.string);
  987.         }/* for i */
  988.         if (!m_nRules)
  989.             add1Rule();
  990.  
  991.         XtSetSensitive(m_fewerBtn, (m_nRules <= 1)?False:True);
  992.  
  993.         XtVaSetValues(m_ruleCmdGroupForm, 
  994.                       XmNpositionIndex, XmLAST_POSITION,
  995.                       NULL);
  996.         XtManageChild(m_ruleCmdGroupForm);
  997.             
  998.     }/* else */
  999.     XP_FREEIF(buffer);
  1000.     XtManageChild(m_workForm);
  1001. }
  1002.  
  1003. void XFE_ABSearchView::getParams()
  1004. {
  1005.     for (int i=0; i < m_nRules; i++) {
  1006.         if (!m_params[i].m_textF)
  1007.             /* meaningless
  1008.              */
  1009.             break;
  1010.  
  1011.         m_params[i].m_attribNval.u.string = 
  1012.             fe_GetTextField(m_params[i].m_textF);        
  1013.     }/* for i */
  1014.     m_searchInfo->m_nRules = m_nRules;
  1015.     m_searchInfo->m_params = m_params;
  1016. }
  1017.  
  1018. ABSearchUIHint_t*
  1019. XFE_ABSearchView::getOptMenuHint(uint16 th, uint16 *num)
  1020. {
  1021.     /* op
  1022.      */
  1023.     DIR_Server *dirs[1];
  1024.     dirs[0] = (DIR_Server*) m_dir;
  1025.  
  1026.     MSG_SearchMenuItem *opItems = 
  1027.         (MSG_SearchMenuItem *) XP_CALLOC(kNumOperators, 
  1028.                                          sizeof(MSG_SearchMenuItem));        
  1029.     uint16 opNum = kNumOperators;
  1030.  
  1031.     MSG_SearchAttribute attrib = 
  1032.         m_params[th].m_attribNval.attribute;
  1033.     
  1034.     MSG_SearchError err;
  1035.       err = MSG_GetOperatorsForSearchScopes(fe_getMNMaster(), 
  1036.                                           scopeLdapDirectory, 
  1037.                                           (void**)dirs, 
  1038.                                           1,
  1039.                                           attrib,
  1040.                                           opItems, 
  1041.                                           &opNum);
  1042.     *num = opNum;
  1043.     
  1044.     /* op menu
  1045.      */
  1046.     ABSearchUIHint_t *hint = 
  1047.         (ABSearchUIHint_t *) XP_CALLOC(opNum, 
  1048.                                        sizeof(ABSearchUIHint_t));
  1049.     for (int i=0; i < opNum; i++) {
  1050.         hint[i].m_th = th;
  1051.         hint[i].m_type = AB_SEARCH_OP;
  1052.         hint[i].m_menuItem = & opItems[i];
  1053.         hint[i].m_obj = this;        
  1054.     }/* for i */
  1055.     return hint;
  1056. }
  1057.  
  1058. void XFE_ABSearchView::setParams(ABSearchInfo_t *info)
  1059. {
  1060.     toggleSearchMode(info);    
  1061. }
  1062.  
  1063. // CBs
  1064. void XFE_ABSearchView::optValChgCallback(Widget w, 
  1065.                                          XtPointer clientData, 
  1066.                                          XtPointer callData)
  1067. {
  1068.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1069.     obj->optValChgCB(w, callData);
  1070. }
  1071.  
  1072. void XFE_ABSearchView::optValChgCB(Widget w, 
  1073.                                    XtPointer /* callData */)
  1074. {
  1075.     ABSearchUIHint_t *hint = NULL;
  1076.     XtVaGetValues(w, 
  1077.                   XmNuserData, &hint,
  1078.                   NULL);
  1079.     XP_ASSERT(hint);
  1080.  
  1081.     if (hint->m_type == AB_SEARCH_ATTRIB) {
  1082.         m_params[hint->m_th].m_attribNval.attribute = 
  1083.             (MSG_SearchAttribute) hint->m_menuItem->attrib;
  1084.  
  1085.         /* rebuild op
  1086.          */
  1087.         uint16 opNum = 0;
  1088.         ABSearchUIHint_t *Hint = getOptMenuHint(hint->m_th, &opNum);
  1089.         Widget btn1 = 
  1090.             rebuildOptChildren(m_params[hint->m_th].m_opPopup, 
  1091.                                opNum, 
  1092.                                Hint,
  1093.                                &(XFE_ABSearchView::optValChgCallback));
  1094.         XtVaSetValues(m_params[hint->m_th].m_opOptMenu, 
  1095.                       XmNmenuHistory, btn1, 
  1096.                       NULL);
  1097.         m_params[hint->m_th].m_op = 
  1098.             (MSG_SearchOperator) Hint[0].m_menuItem->attrib;
  1099.     }/* if */
  1100.     else if (hint->m_type == AB_SEARCH_OP)
  1101.         m_params[hint->m_th].m_op = 
  1102.             (MSG_SearchOperator) hint->m_menuItem->attrib;
  1103.     else if (hint->m_type == AB_SEARCH_CONNECTOR) {
  1104.         m_searchInfo->m_logicOp = (XP_Bool) hint->m_menuItem->attrib;
  1105.         if (m_nRules > 1) {
  1106.             char tmp[256];
  1107.             sprintf(tmp,
  1108.                     "%s", 
  1109.                     (m_searchInfo->m_logicOp?
  1110.                      XP_GetString(XFE_SEARCH_BOOL_AND_THE):
  1111.                      XP_GetString(XFE_SEARCH_BOOL_OR_THE)));
  1112.             for (int i=1; i < m_nRules; i++) {
  1113.                 fe_SetString(m_params[i].m_label, 
  1114.                              XmNlabelString, tmp);
  1115.             }/* for i */
  1116.         }/* if */
  1117.     }/* else if */
  1118.  
  1119. }
  1120.  
  1121. void XFE_ABSearchView::toggleSearchModeCallback(Widget w, 
  1122.                                          XtPointer clientData, 
  1123.                                          XtPointer callData)
  1124. {
  1125.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1126.     obj->toggleSearchModeCB(w, callData);
  1127. }
  1128.  
  1129. void XFE_ABSearchView::toggleSearchModeCB(Widget /* w */, 
  1130.                                           XtPointer /* callData */)
  1131. {
  1132.     m_searchInfo->m_mode = 
  1133.         (m_searchInfo->m_mode==AB_SEARCH_ADVANCED)
  1134.         ?AB_SEARCH_BASIC
  1135.         :AB_SEARCH_ADVANCED;
  1136.  
  1137.     /* get input
  1138.      */
  1139.     getParams();
  1140.     toggleSearchMode(m_searchInfo); 
  1141. }
  1142.  
  1143. void XFE_ABSearchView::okCallback(Widget w, 
  1144.                                          XtPointer clientData, 
  1145.                                          XtPointer callData)
  1146. {
  1147.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1148.     obj->okCB(w, callData);
  1149. }
  1150.  
  1151. void XFE_ABSearchView::okCB(Widget /* w */, 
  1152.                             XtPointer /* callData */)
  1153. {
  1154.     cancelCB(NULL, NULL);
  1155.     ((ABSearchCBProc) m_searchInfo->m_cbProc)(m_searchInfo, NULL);    
  1156. }
  1157.  
  1158. void XFE_ABSearchView::cancelCallback(Widget w, 
  1159.                                          XtPointer clientData, 
  1160.                                          XtPointer callData)
  1161. {
  1162.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1163.     obj->cancelCB(w, callData);
  1164. }
  1165.  
  1166. void XFE_ABSearchView::cancelCB(Widget /* w */, 
  1167.                                 XtPointer /* callData */)
  1168. {
  1169.     getParams();
  1170.     for (int i=0; i < m_nRules; i++) {
  1171.         m_params[i].m_ruleForm = NULL;
  1172.         m_params[i].m_attribOptMenu = NULL;
  1173.         m_params[i].m_attribPopup = NULL;
  1174.         m_params[i].m_opOptMenu = NULL;
  1175.         m_params[i].m_opPopup = NULL;
  1176.         m_params[i].m_label = NULL;
  1177.         m_params[i].m_textF = NULL;
  1178.     }/* for i */
  1179.     notifyInterested(XFE_ABSearchView::dlgClose);
  1180. }
  1181.  
  1182. void XFE_ABSearchView::moreCallback(Widget w, 
  1183.                                          XtPointer clientData, 
  1184.                                          XtPointer callData)
  1185. {
  1186.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1187.     obj->moreCB(w, callData);
  1188. }
  1189.  
  1190. void XFE_ABSearchView::moreCB(Widget /* w */, 
  1191.                                           XtPointer /* callData */)
  1192. {
  1193.     add1Rule();
  1194.     XtSetSensitive(m_fewerBtn, (m_nRules <= 1)?False:True);
  1195. }
  1196.  
  1197. void XFE_ABSearchView::fewerCallback(Widget w, 
  1198.                                          XtPointer clientData, 
  1199.                                          XtPointer callData)
  1200. {
  1201.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1202.     obj->fewerCB(w, callData);
  1203. }
  1204.  
  1205. void XFE_ABSearchView::fewerCB(Widget /* w */, 
  1206.                                           XtPointer /* callData */)
  1207. {
  1208.     remove1Rule();
  1209.     XtSetSensitive(m_fewerBtn, (m_nRules <= 1)?False:True);
  1210. }
  1211.  
  1212. void XFE_ABSearchView::clearCallback(Widget w, 
  1213.                                          XtPointer clientData, 
  1214.                                          XtPointer callData)
  1215. {
  1216.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1217.     obj->clearCB(w, callData);
  1218. }
  1219.  
  1220. void XFE_ABSearchView::clearCB(Widget /* w */, 
  1221.                                           XtPointer /* callData */)
  1222. {
  1223.     /* simply clear textF
  1224.      */
  1225.     for (int i=0; i < m_nRules; i++) {
  1226.         XP_FREEIF(m_params[i].m_attribNval.u.string);
  1227.         fe_SetTextField(m_params[i].m_textF, 
  1228.                         "");        
  1229.     }/* for i */
  1230. }
  1231.  
  1232. void XFE_ABSearchView::textFActivateCallback(Widget w, 
  1233.                                          XtPointer clientData, 
  1234.                                          XtPointer callData)
  1235. {
  1236.     XFE_ABSearchView *obj = (XFE_ABSearchView *) clientData;
  1237.     obj->textFActivateCB(w, callData);
  1238. }
  1239.  
  1240. void XFE_ABSearchView::textFActivateCB(Widget /* w */, 
  1241.                                        XtPointer /* clientData */)
  1242. {
  1243.     okCB(NULL, NULL);
  1244. }
  1245.  
  1246.