Logo Search packages:      
Sourcecode: felt version File versions  Download package

elementlist.c

/*
    This file is part of the FElt finite element analysis package.
    Copyright (C) 1993-2000 Jason I. Gobat and Darren C. Atkinson

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/************************************************************************
 * File:    elementlist.c                                   *
 *                                                    *
 * Description: This file contains the private and public function and  *
 *          type definitions for the element list box.            *
 ************************************************************************/

# include <stdio.h>
# include <X11/Intrinsic.h>
# include <X11/StringDefs.h>
# include <X11/Shell.h>
# include <X11/Xaw/AsciiText.h>
# include <X11/Xaw/Command.h>
# include <X11/Xaw/Label.h>
# include <X11/Xaw/List.h>
# include <X11/Xaw/Viewport.h>
# include "Layout.h"
# include "ElementList.h"
# include "TabGroup.h"
# include "util.h"
# include "problem.h"
# include "error.h"
# include "definition.h"

static String     *element_names;
static int  num_types;

struct element_list {
    Widget     shell;         /* transientShell  <specified>      */
    Widget     layout;        /*    Layout  layout          */
    Widget     label;         /*         Label  label */
    Widget     entry;         /*         AsciiText  entry   */
    Widget     viewport;            /*         Viewport  viewport */
    Widget     list;          /*            List  list      */
    Widget     accept;        /*         Command  accept    */
    Widget     dismiss;       /*         Command  dismiss   */
};


/* Resources */

static Pixel highlight;

static String dummy_list [ ] = {
    "                              ", "", "", "", "", "", "", "", "", NULL
};

static char layout_string [ ] =
"vertical { 4 \
 horizontal { 4 label <+inf -100% *> 4 } 4 \
 horizontal { 4 entry <+inf -100% *> 4 } 4 \
 horizontal { 4 viewport <+inf -100% * +inf -100%> 4 } 4 \
 horizontal { 4 accept 4 <+inf -100%> dismiss 4 } 4 }";

static Arg color_args [ ] = {
    {XtNborderColor, (XtArgVal) &highlight},
};

static Arg layout_args [ ] = {
    {XtNlayout, (XtArgVal) NULL},
};

static Arg label_args [ ] = {
    {XtNresize,      (XtArgVal) True},
    {XtNjustify,     (XtArgVal) XtJustifyLeft},
    {XtNborderWidth, (XtArgVal) 0},
};

static Arg entry_args [ ] = {
    {XtNresize,      (XtArgVal) XawtextResizeWidth},
    {XtNeditType,    (XtArgVal) XawtextEdit},
    {XtNborderWidth, (XtArgVal) 0},
};

static Arg viewport_args [ ] = {
    {XtNallowVert,   (XtArgVal) True},
    {XtNuseRight,    (XtArgVal) True},
    {XtNforceBars,   (XtArgVal) True},
    {XtNborderWidth, (XtArgVal) 0},
};

static Arg list_args [ ] = {
    {XtNdefaultColumns, (XtArgVal) 1},
    {XtNforceColumns,   (XtArgVal) 1},
    {XtNresize,         (XtArgVal) True},
    {XtNlist,           (XtArgVal) dummy_list},
};


/* Translation tables */

static String entry_table =
"<Key>Return:   ElementListAccept()\n\
 <Key>Escape:   ElementListDismiss()\n\
 <Btn1Down>:    SetFocus() select-start()";

static XtTranslations entry_translations;

static String viewport_table =
"<Key>Return:   ElementListAccept()\n\
 <Key>Escape:   ElementListDismiss()\n\
 <Btn1Down>:    SetFocus()";

static XtTranslations viewport_translations;

static String list_table =
"<Btn1Up>(2):     Notify() ElementListAccept()\n\
 <Btn2Down>:    Set()\n\
 <Btn2Up>:      Notify() ElementListAccept()";

static XtTranslations list_translations;

static String accept_table =
"<Key>Return:   AutoRepeat(off) set()\n\
 <KeyUp>Return: AutoRepeat(saved) notify() unset()\n\
 <Key>space:    AutoRepeat(off) set()\n\
 <KeyUp>space:  AutoRepeat(saved) notify() unset()\n\
 <Key>Escape:   ElementListDismiss()";

static XtTranslations accept_translations;

static String dismiss_table =
"<Key>Return:   AutoRepeat(off) set()\n\
 <KeyUp>Return: AutoRepeat(saved) notify() unset()\n\
 <Key>space:    AutoRepeat(off) set()\n\
 <KeyUp>space:  AutoRepeat(saved) notify() unset()\n\
 <Key>Escape:   ElementListDismiss()";

static XtTranslations dismiss_translations;


/************************************************************************
 * Function:      CopySelected                                    *
 *                                                    *
 * Description:   A callback for the List widget which copies the current     *
 *          entry to the entry widget.                      *
 ************************************************************************/

static void CopySelected (w, client_data, call_data)
    Widget    w;
    XtPointer client_data;
    XtPointer call_data;
{
    ElementList          elementl;
    XawListReturnStruct *info;


    elementl = (ElementList) client_data;
    info = (XawListReturnStruct *) call_data;
    SetTextString (elementl -> entry, info -> string);
}


/************************************************************************
 * Function:      Accept                                          *
 *                                                    *
 * Description:   A callback for the accept button which forms a name   *
 *          from the current entry.                         *
 ************************************************************************/

static void Accept (w, client_data, call_data)
    Widget    w;
    XtPointer client_data;
    XtPointer call_data;
{
    XawListReturnStruct *item;
    ElementList          elementl;
    Arg                  args [1];
    String         value;
    unsigned             i;
    int                  index;

    elementl = (ElementList) client_data;
    item = XawListShowCurrent (elementl -> list);
 
    XtSetArg (args [0], XtNstring,  &value);
    XtGetValues (elementl -> entry, args, 1);

    index = XAW_LIST_NONE;
    for (i = 0 ; i < num_types ; i++) {
       if (strcmp (element_names [i], value) == 0) {
          index = i;
          break;
       }
    }  

    if (index == XAW_LIST_NONE)
       CopySelected (NULL, (XtPointer) elementl, (XtPointer) item);
    else
       XawListHighlight (elementl -> list, index);
}

/************************************************************************
 * Function:      Dismiss                                         *
 *                                                    *
 * Description:   A callback for the dismiss button which indicates that      *
 *          the user wishes to popdown the element list           *
 ************************************************************************/

static void Dismiss (w, client_data, call_data)
    Widget    w;
    XtPointer client_data;
    XtPointer call_data;
{
    ElementList   elementl;

    elementl = (ElementList) client_data;
    ElementListPopdown (elementl);
}


/************************************************************************
 * Function:      ElementListAccept                         *
 *                                                    *
 * Description:   An action procedure which emulates pressing of the    *
 *          accept button.                                  * 
 ************************************************************************/

static void ElementListAccept (w, event, params, num_params)
    Widget   w;
    XEvent  *event;
    String  *params;
    Cardinal num_params;
{
    if (XtClass (w) == listWidgetClass)
      w = XtParent (w);

    w = XtNameToWidget (XtParent (w), "accept");
    XtCallCallbacks (w, XtNcallback, NULL);
}


/************************************************************************
 * Function:      ElementListDismiss                              *
 *                                                    *
 * Description:   An action procedure which emulates pressing of the    *
 *          dismiss button.                                 *
 ************************************************************************/

static void ElementListDismiss (w, event, params, num_params)
    Widget   w;
    XEvent  *event;
    String  *params;
    Cardinal num_params;
{
    if (event -> type == ClientMessage)
      w = XtNameToWidget (w, "layout.dismiss");
    else
      w = XtNameToWidget (XtParent (w), "dismiss");

    XtCallCallbacks (w, XtNcallback, NULL);
}

/************************************************************************
 * Function:      ElementListUpdate                         *
 *                                                    *
 * Description:   Sets the element names into the list widget           *
 ************************************************************************/
 
static void ElementListUpdate (elementl)
    ElementList   elementl;
{
    XawListChange (elementl -> list, element_names, num_types, 0, True);
    XawViewportSetCoordinates (elementl -> viewport, 0, 0);


    return;
}

/************************************************************************
 * Function:      ElementListCreate                         *
 *                                                    *
 * Description:   Creates and returns a new element list box.           *
 ************************************************************************/

ElementList ElementListCreate (parent, name, title)
    Widget parent;
    String name;
    String title;
{
    Arg                 args[1];
    Widget        group [4];
    ElementList         elementl;
    static XtAppContext app_context = NULL;
    static XtActionsRec actions [ ] =
                  {{"ElementListAccept",   ElementListAccept},
                   {"ElementListDismiss",  ElementListDismiss}};


    /* Perform one time initialization. */

    if (app_context == NULL) {
      app_context = XtWidgetToApplicationContext (parent);
      XtAppAddActions (app_context, actions, XtNumber (actions));
      AddAutoRepeatAction (app_context);

      layout_args [0].value = StringToLayout (parent, layout_string);

      entry_translations    = XtParseTranslationTable (entry_table);
      viewport_translations = XtParseTranslationTable (viewport_table);
      list_translations     = XtParseTranslationTable (list_table);
      accept_translations   = XtParseTranslationTable (accept_table);
      dismiss_translations  = XtParseTranslationTable (dismiss_table);
    }


    /* Create the element list and its widgets. */

    elementl = XtNew (struct element_list);

    elementl -> shell     = XtCreatePopupShell (name,
                   applicationShellWidgetClass, parent,
                   NULL, 0);

    elementl -> layout    = XtCreateManagedWidget ("layout",
                   layoutWidgetClass, elementl -> shell,
                   layout_args, XtNumber (layout_args));

    elementl -> label     = XtCreateManagedWidget ("label",
                   labelWidgetClass, elementl -> layout,
                   label_args, XtNumber (label_args));

    elementl -> entry     = XtCreateManagedWidget ("entry",
                   asciiTextWidgetClass, elementl -> layout,
                   entry_args, XtNumber (entry_args));

    elementl -> viewport  = XtCreateManagedWidget ("viewport",
                   viewportWidgetClass, elementl -> layout, 
                   viewport_args, XtNumber (viewport_args));

    elementl -> list      = XtCreateManagedWidget ("list",
                   listWidgetClass, elementl -> viewport,
                   list_args, XtNumber (list_args));

    elementl -> accept    = XtCreateManagedWidget ("accept",
                   commandWidgetClass, elementl -> layout,
                   NULL, 0);

    elementl -> dismiss   = XtCreateManagedWidget ("dismiss",
                   commandWidgetClass, elementl -> layout,
                   NULL, 0);


    /* Create a tab group for the element list. */

    group [0] = elementl -> entry;
    group [1] = elementl -> viewport;
    group [2] = elementl -> accept;
    group [3] = elementl -> dismiss;

    XtGetValues (elementl -> layout, color_args, XtNumber (color_args));
    CreateTabGroup(elementl -> shell, group, XtNumber (group), highlight,True);
    XtRealizeWidget (elementl -> shell);


    /* Add the translations to each widget. */

    AddDeleteWindowProtocol   (elementl -> shell, "ElementListDismiss()");
    ListAddCursorTranslations (elementl -> viewport);
    ListAddCursorAccelerators (elementl -> viewport, elementl -> entry);

    XtOverrideTranslations (elementl -> entry,    entry_translations);
    XtOverrideTranslations (elementl -> viewport, viewport_translations);
    XtOverrideTranslations (elementl -> list,     list_translations);
    XtOverrideTranslations (elementl -> accept,     accept_translations);
    XtOverrideTranslations (elementl -> dismiss,   dismiss_translations);


    /* Add the necessary callbacks. */

    XtAddCallback(elementl->list,XtNcallback,CopySelected,(XtPointer) elementl);
    XtAddCallback(elementl->dismiss,XtNcallback,Dismiss,(XtPointer) elementl);
    XtAddCallback(elementl->accept,XtNcallback,Accept,(XtPointer) elementl);

    /* set some labels */

    XtSetArg (args [0], XtNtitle, title);
    XtSetValues (elementl -> shell, args, 1);
 
    XtSetArg (args [0], XtNlabel, "Element name:");
    XtSetValues (elementl -> label, args, 1);

    ElementListSetupNames (elementl);

    ElementListUpdate (elementl);

    return elementl;
}

/************************************************************************
 * Function:      ElementListDefinition                           *
 *                                                    *
 * Description: Sets the currently displayed element to the given *
 *          definition;
 ************************************************************************/

void ElementListSet (elementl, definition)
    ElementList   elementl;
    Definition    definition;
{
    unsigned      i;
    int           index;

    if (definition == NULL) {
       XawListUnhighlight (elementl -> list);
       SetTextString (elementl -> entry, "");
       return;
    } 

    index = XAW_LIST_NONE;
    for (i = 0; i < num_types ; i++) {
       if (LookupDefinition (element_names [i]) == definition) {
          index = i;
          break;
       }
    }

    XawListHighlight (elementl -> list, index);
    if (index == XAW_LIST_NONE)
       SetTextString (elementl -> entry, "");
    else
       SetTextString (elementl -> entry, element_names [index]);
}

/************************************************************************
 * Function:      ElementListDefinition                           *
 *                                                    *
 * Description: Returns the currently selected element definition *
 ************************************************************************/

Definition ElementListDefinition (elementl)
    ElementList   elementl;
{
    XawListReturnStruct *item;

    item = XawListShowCurrent (elementl -> list);

    if (item -> list_index != XAW_LIST_NONE)
       return LookupDefinition (element_names [item -> list_index]);
    else
       return NULL;
}

/************************************************************************
 * Function:      ElementListName                                 *
 *                                                    *
 * Description: Returns the currently selected element definition *
 ************************************************************************/

String ElementListName (elementl)
    ElementList   elementl;
{
    XawListReturnStruct *item;

    item = XawListShowCurrent (elementl -> list);

    if (item -> list_index != XAW_LIST_NONE)
       return element_names [item -> list_index];
    else
       return NULL;
}

static int  count;

static int SetName (item)
    Item    item;
{
    element_names [count ++] = XtNewString (((Definition) item) -> name);
    return 0;
}

/************************************************************************
 * Function:      ElementListSetupNames                           *
 *                                                    *
 * Description: Initializes the array of element type names based *
 *          on the definition_tree                          *
 ************************************************************************/

void ElementListSetupNames (elementl)
    ElementList   elementl;
{
    unsigned      i;

    if (num_types > 0) {
        for (i = 0 ; i < num_types ; i++)
           XtFree (element_names [i]);

        XtFree ((char *) element_names);
    }
     
    num_types = TreeSize (problem.definition_tree);
    element_names = (String *) XtMalloc (sizeof(String) * num_types);

    count = 0;
    TreeSetIterator (problem.definition_tree, SetName);
    TreeIterate (problem.definition_tree);

    return;
}

/************************************************************************
 * Function:      ElementListPopup                          *
 *                                                    *
 * Description: Pops up the element list with the specified title.      *
 ************************************************************************/

void ElementListPopup (elementl)
    ElementList      elementl;
{
    SetFocus (elementl -> entry);
    XtPopup (elementl -> shell, XtGrabNone);
}


/************************************************************************
 * Function:      ElementListPopdown                              *
 *                                                    *
 * Descripion:    Pops down the specified element list                  *
 ************************************************************************/

void ElementListPopdown (elementl)
    ElementList elementl;
{
    XtPopdown (elementl -> shell);
}

Generated by  Doxygen 1.6.0   Back to index