create lib\...\setup.h from setup.h, not setup0.h which is not meant to be edited

[wxWidgets.git] / src / motif / xmcombo / xmcombo.c

/*
 * ComboBox.c - Das schon lange schmerzlich vermisste Combo-Box-
 *              Widget -- nun endlich auf fuer Motif!
 * 
 * Version 1.32a -- 04.10.95
 *
 * Letzte Modifikation:
 * 04.10.1995    Layoutfehler behoben, der bei angezeigter horizontaler Liste
 *               dazu fuehrt, dass das Listenfeld schrumpft. Daneben wird
 *               jetzt auch der Fall beruecksichtigt, dass das Listenfeld am
 *               unteren Bildschirmrand abgeschnitten wuerde. In diesem Fall
 *               erscheint das Listenfeld oberhalb des Eingabefeldes.
 * 20.03.1995    XmNscrollbarDisplayPolicy,... koennen nun immer vom Pro-
 *               grammierer gesetzt werden, statische Liste hin und her.
 * 21.10.1994    Fehler in SetValues behoben, der auftritt, wenn man versucht,
 *               XmNitems und XmNitemCount zu setzen.
 * 01.10.1994    Externe Sortierung wird nun unterstuetzt sowie seitenweises
 *               Rollen in der Liste mittels PgUp und PgDn.
 * 25.09.1994    Unterstuetzung fuer XmNautomaticSelection implementiert.
 *               Damit wird die Sache noch ein bischen runder in der Bedienung.
 *               Des weiteren sind etliche Callbacks neu hinzugekommen.
 * 04.09.1994    Erweiterungen fuer XmSINGLE_SELECT eingebaut. Ausserdem
 *               kann die Liste jetzt auch statisch unterhalb des Eingabe-
 *               felds erscheinen. Damit sind wir nun noch kompatibler ge-
 *               worden -- fragt sich nur, zu was?!
 * 29.08.1994    Alle Mirror-Ressourcen tauchen nun auch in der Ressourcen-
 *               liste der ComboBox-Klasse auf. Allerdings stehen keine
 *               sinnvollen Werte fuer die Initialisierung 'drin. Weiterhin
 *               den GeometryManager so veraendert, dass ab sofort das
 *               Label in der Breite wachsen oder schrumpfen darf.
 * 07.06.1994    XmNmnemonic und XmNmnemonicCharSet implementiert.
 * 29.05.1994    XmNsensitive angepasst. XmNcursorPositionVisible ist nun
 *               False, falls die ComboBox nicht editierbar ist.
 * 07.05.1994    Drag'n'Drop funktioniert endlich!!! Zudem Anpassung an
 *               den fvwm ausgefuehrt ('st vom Focus-Verhalten ja ein halber
 *               twm). Hach', so'ne Linux-Box mit Motif 1.2 macht doch
 *               einfach Spass... vor allem geht hier so richtig die Post ab.
 *               Das kann man ja von M$ Windoze (Windoze for Mondays) nicht
 *               behaupten!
 * 14.04.1994    Ein paar Speicherlecks korrigiert.
 * 21.02.1994    Die Resourcen XmNitems und XmNitemCount lassen sich nun 
 *               auch von einer Resourcendatei aus initialisieren. ACHTUNG: 
 *               diese beiden Resourcen mussen immer beide beim Aufruf von 
 *               XtSetValues zugleich angegeben werden, ansonsten werden
 *               diese Angaben ignoriert.
 * 03.02.1994    Convenience-Funktionen auf Vordermann gebracht und noch
 *               einen Callback eingebaut, der immer dann aufgerufen wird, 
 *               wenn die List angezeigt oder wieder versteckt wird.
 * 01.02.1994    Motif 1.2-fest!!! Das wird aber heute abend gefeiert!!
 *               Endlich EIN Alptraum weniger! Naja, Drag'n'Drop bleibt
 *               noch zu loesen. Spaeter...
 * 31.01.1994    VAX-fest (mit Hilfe von Vincenct Li)
 *               owlm sollte man abschaffen! Aber es scheint so, als ob
 *               ich jetzt doch noch das FocusOut-Problem geknackt habe.
 *               Ebenso die OSF...mit viel Arbeit habe ich nun auch noch
 *               eine anstaendige Initialisierung der Fontliste des Label-
 *               Kinds erreicht.
 * 12.01.1994    Revisionsstand: 1.10a
 *               nun wirklich voll ANSI-faehiger C-Code
 *               Pixmaps werden ggf. aufgeraeumt; Druckrichtung
 *               wird vom Vater erfragt und an das Label weiter-
 *               gegeben.
 *               ESC-Behandlung implementiert.
 *               Spiegel-Ressourcen-Initialisierung aus Ressourcen-Daten-
 *               bank implementiert.
 *               Weitergabe von neu gesetzten Farben an die Kinder
 *               implementiert.
 *               Combo-Box kann jetzt wahlweise auch links neben dem
 *               Eingabefeld ein Label anzeigen.
 * 09.12.1993    Revisionsstand: 1.00
 *               erste oeffentlich zugaengliche Version der Combo-Box
 * 
 * (c) 1993, 1994, 1995 Harald Albrecht
 * Institut fuer Geometrie und Praktische Mathematik
 * RWTH Aachen, Germany
 * albrecht@igpm.rwth-aachen.de
 *
 * 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 (see the file COPYING for more details);
 * if not, write to the Free Software Foundation, Inc., 675 Mass Ave, 
 * Cambridge, MA 02139, USA.
 *
 */
#ifdef __VMS
#include <wx/vms_x_fix.h>
#endif

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/cursorfont.h>
#include <X11/Shell.h>
#ifdef VMS /* Huch, wo gibt's denn noch sowas ... ?! */
           /* Bitte keine Mail bzgl. dieser Bemerkung schicken...
            * Ich weiss, das ist ein Vorurteil...aber es gibt
            * ja auch wahre Vorurteile....
            */
#include <Xmu/Converters.h>
#else
#include <X11/Xmu/Converters.h>
#endif
#include <Xm/ArrowB.h>
#include <Xm/TextF.h>
#include <Xm/List.h>
#include <Xm/LabelP.h>
#include <string.h>
#include <ctype.h> /* define toupper */
#include "combop.h"

#include <stdio.h>

/* --- Systemspezifische Definitionen */
#if defined(VMS)
#define strcasecmp(s1, s2) strcmp(s1, s2)
#elif defined(__EMX__)
#define strcasecmp stricmp
#endif

/* --- sonstiger Quark */
/* #ifdef DEBUG */
#if 0
#define LOG(p1)          fprintf(stderr, p1);
#define LOG2(p1, p2)     fprintf(stderr, p1, p2);
#define LOG3(p1, p2, p3) fprintf(stderr, p1, p2, p3);
#else
#define LOG(p1)
#define LOG2(p1, p2)
#define LOG3(p1, p2, p3)
#endif

/* ---------------------------------------------------------------------------
 * Resourcen-Liste...
 * Hier werden diejenigen Resourcen definiert, die von "aussen" - also  fuer
 * den Programmierer oder Anwender - benutzbar und veraenderbar sind.
 * 
 * Der Aufbau der einzelnen Eintraege ist immer wieder gleich:
 * Resourcen-Name       XmN... oder XtN
 * Resourcen-Klasse     XmC... oder XtC
 * Resourcen-Type       XmR... oder XtR (Datentyp der Variable in der
 *                      struct der jeweiligen Widgetinstanz)
 * Resourcen-Groesse    aktuelle Groesse dieses Datentyps
 * Resourcen-Offset     Lage der Variable innerhalb der struct der
 *                      Widgetinstanz
 * Defaultwert-Type     Typ des Defaultwertes
 * Defaultwert          (normalerweise) Zeiger auf den Defaultwert
 */
#define offset(field) XtOffsetOf(XmComboBoxRec, field)
static XtResource resources[] = {
    { /* Eingabefeld kann veraendert werden, oder aber es sind nur
       * die Vorgaben aus der Liste auswaehlbar.
       */
        XmNeditable, XmCEditable, XmRBoolean, sizeof(Boolean), 
        offset(combobox.Editable), XmRString, "False"
    }, 
    { /* Liste wird automatisch sortiert -- wie konnten die bei
       * der OSF denn SOETWAS nur vergessen ??
       */
        XmNsorted, XmCSorted, XmRBoolean, sizeof(Boolean),
        offset(combobox.Sorted), XmRString, "False"
    }, 
    { /* externe Sortierreihenfolge */
        XmNsortingCallback, XmCSortingCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.SortingCBL), XmRCallback, NULL
    }, 
    { /* Anzahl auf einmal sichtbarer Eintraege in der Liste (ent-
       * spricht damit der Listenhoehe.
       */
        XmNvisibleItemCount, XmCVisibleItemCount, XmRInt, sizeof(int), 
        offset(combobox.VisibleItemCount), XmRImmediate, (caddr_t) 8
    }, 
    { /* Fuer das Eingabefeld sowie die Liste verwandte Fonts */
        XmNfontList, XmCFontList, XmRFontList, sizeof(XmFontList), 
        offset(combobox.Font), XmRImmediate, NULL
    }, 
    { /* Rueckruf bei Anwahl */
        XmNselectionCallback, XmCSelectionCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.SelectionCBL), XmRCallback, NULL
    }, 
    { /* Gegenteil zum vorherigen Callback! */
        XmNunselectionCallback, XmCUnselectionCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.UnselectionCBL), XmRCallback, NULL
    }, 
    { /* Doppelklick in der Liste */
        XmNdefaultActionCallback, XmCCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.DefaultActionCBL), XmRCallback, NULL
    }, 
    { /* Rueckruf bei Liste ausklappen/verstecken */
        XmNdropDownCallback, XmCDropDownCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.DropDownCBL), XmRCallback, NULL
    }, 
    { /* Eingabe abchecken... */
        XmNmodifyVerifyCallback, XmCCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.ModifyVerifyCBL), XmRCallback, NULL
    }, 
    {
        XmNvalueChangedCallback, XmCCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.ValueChangedCBL), XmRCallback, NULL
    }, 
    {
        XmNactivateCallback, XmCCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.ActivateCBL), XmRCallback, NULL
    }, 
    {
        XmNmotionVerifyCallback, XmCCallback, XmRCallback, 
        sizeof(XtCallbackList), 
        offset(combobox.MotionVerifyCBL), XmRCallback, NULL
    }, 
    { /* Verhalten der ausgeklappten Liste bei Focus-Out */
        XmNpersistentDropDown, XmCPersistentDropDown, XmRBoolean, 
        sizeof(Boolean), 
        offset(combobox.Persistent), XmRString, "False"
    }, 
    { /* Wie verhaelt sich der Window-Manager? */
        XmNtwmHandlingOn, XmCTwmHandlingOn, XmRBoolean, sizeof(Boolean), 
        offset(combobox.TwmHandlingOn), XmRString, "False"
    }, 
    { /* Label anzeigen oder nicht? */
        XmNshowLabel, XmCShowLabel, XmRBoolean, sizeof(Boolean), 
        offset(combobox.ShowLabel), XmRString, "False"
    }, 
    { /* Abstand zw. linkem Rand Eingabefeld und linkem Rand Liste */
        XmNdropDownOffset, XmCDropDownOffset, XmRPosition, 
        sizeof(Position), offset(combobox.DropDownOffset), 
        XmRImmediate, (caddr_t) -1
    }, 
    { /* Neue Voreinstellung bzgl. des Randes */
        XmNborderWidth, XmCBorderWidth, XmRDimension, sizeof(Dimension), 
        offset(core.border_width), XmRImmediate, (caddr_t) 0
    },
    { /* welcher Cursor soll in der Dropdown-Liste benutzt werden? */
        XmNdropDownCursor, XmCDropDownCursor, XmRCursor, sizeof(Cursor),
        offset(combobox.ArrowCursor), XmRString, "center_ptr"
    }, 
    { /* wie lassen sich Eintraege auswaehlen? */
        XmNselectionPolicy, XmCSelectionPolicy, XmRSelectionPolicy, sizeof(unsigned char), 
        offset(combobox.SelectionPolicy), XmRImmediate, (caddr_t) XmBROWSE_SELECT
    }, 
    { /* Wann werden die Callbacks aufgerufen? */
        XmNautomaticSelection, XmCAutomaticSelection, XmRBoolean, sizeof(Boolean), 
        offset(combobox.AutomaticSelection), XmRString, "False"
    }, 
    { /* erscheint die Liste staendig? */
        XmNstaticList, XmCStaticList, XmRBoolean, sizeof(Boolean), 
        offset(combobox.StaticList), XmRString, "False"
    }, 
    {
        XmNscrollBarDisplayPolicy, XmCScrollBarDisplayPolicy, XmRScrollBarDisplayPolicy, sizeof(unsigned char),
        offset(combobox.ScrollBarDisplayPolicy), XmRImmediate, (caddr_t) XmAS_NEEDED
    },
    {
        XmNlistSizePolicy, XmCListSizePolicy, XmRListSizePolicy, sizeof(unsigned char),
        offset(combobox.ListSizePolicy), XmRImmediate, (caddr_t) XmVARIABLE
    },
    {
        XmNsquareArrow, XmCSquareArrow, XmRBoolean, sizeof(Boolean),
        offset(combobox.SquareArrow), XmRString, "False"
    },
    {
        XmNarrowSpacingOn, XmCArrowSpacingOn, XmRBoolean, sizeof(Boolean),
        offset(combobox.ArrowSpacingOn), XmRString, "True"
    },
#ifndef DONT_LOOK_IN_THE_MIRROR
    /* Mirror-Ressourcen, Adressen sind ungueltig!!!! */
    {
        XmNalignment, XmCAlignment, XmRAlignment, sizeof(unsigned char), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNblinkRate, XmCBlinkRate, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNcolumns, XmCColumns, XmRShort, sizeof(short), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNcursorPosition, XmCCursorPosition, XmRTextPosition, sizeof(XmTextPosition),
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNitemCount, XmCItemCount, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNitems, XmCItems, XmRXmStringTable, sizeof(XmStringTable), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelFontList, XmCLabelFontList, XmRFontList, sizeof(XmFontList), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelInsensitivePixmap, XmCLabelInsensitivePixmap, XmRPixmap, sizeof(Pixmap), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginBottom, XmCLabelMarginBottom, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginHeight, XmCLabelMarginHeight, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginLeft, XmCLabelMarginLeft, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginRight, XmCLabelMarginRight, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginTop, XmCLabelMarginTop, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelMarginWidth, XmCLabelMarginWidth, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelPixmap, XmCLabelPixmap, XmRPixmap, sizeof(Pixmap), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelString, XmCLabelString, XmRString, sizeof(XmString), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlabelType, XmCLabelType, XmRLabelType, sizeof(unsigned char), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlistMarginHeight, XmCListMarginHeight, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlistMarginWidth, XmCListMarginWidth, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNlistSpacing, XmCListSpacing, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNmarginHeight, XmCMarginHeight, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNmarginWidth, XmCMarginWidth, XmRDimension, sizeof(Dimension), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNmaxLength, XmCMaxLength, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNselectThreshold, XmCSelectThreshold, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNstringDirection, XmCStringDirection, XmRStringDirection, sizeof(XmStringDirection), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNtopItemPosition, XmCTopItemPosition, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNvalue, XmCValue, XmRString, sizeof(String), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
    {
        XmNvalue, XmCValue, XmRInt, sizeof(int), 
        offset(combobox.Dummy), XmRImmediate, (caddr_t) 0
    }, 
#endif
}; /* resources[] */

/* ---------------------------------------------------------------------------
 * Funktions-Prototypen fuer die 'Methoden' des ComboBox-Widgets. Diese
 * 'Methoden' werden vom Xt-Toolkit aufgerufen und sorgen dafuer, dass eine
 * ComboBox sich wie ein anstaendiges Widget verhaelt.
 */
static void             Initialize     (Widget, XmComboBoxWidget, ArgList, 
                                        Cardinal *);
static void             Destroy        (XmComboBoxWidget);
static void             Resize         (XmComboBoxWidget);
static Boolean          SetValues      (XmComboBoxWidget, XmComboBoxWidget, 
                                        XmComboBoxWidget, ArgList, Cardinal *);
static void             GetValuesAlmost(XmComboBoxWidget, ArgList, Cardinal *);
static XtGeometryResult QueryGeometry  (XmComboBoxWidget, XtWidgetGeometry *, 
                                        XtWidgetGeometry *); 
static XtGeometryResult GeometryManager(Widget, XtWidgetGeometry *, 
                                        XtWidgetGeometry *);
static void             ClassInit      ();
static void             Realize        (XmComboBoxWidget, Mask *, 
                                        XSetWindowAttributes *);
/* ---------------------------------------------------------------------------
 * diverse restliche Prototypen... naja, hier halt etwas mager! Hierbei
 */
static void ShowHideDropDownList       (XmComboBoxWidget w, XEvent *event, 
                                        Boolean Show);
static void ShellCallback              (Widget w, XtPointer cbw, 
                                        XEvent *event, Boolean *ContDispatch);
static void DoLayout                   (XmComboBoxWidget w);
/* --------------------------------------------------------------------
 * Klassen-Definition
 */
XmComboBoxClassRec xmComboBoxClassRec = {
    { /*** core-Klasse ***/
    /* superclass                   */  (WidgetClass) &xmManagerClassRec, 
    /* class_name                   */  "XmComboBox",
    /* widget_size                  */  sizeof(XmComboBoxRec),
    /* class_initialize             */  (XtProc) ClassInit,
    /* class_part_initialize        */  NULL,
    /* class_inited                 */  False, /* IMMER mit FALSE initialisieren !! */
    /* initialize                   */  (XtInitProc) Initialize,
    /* initialize_hook              */  NULL,
    /* realize                      */  (XtRealizeProc) Realize,
    /* actions                      */  NULL,
    /* num_actions                  */  0,
    /* resources                    */  resources,
    /* num_resources                */  XtNumber(resources),
    /* xrm_class                    */  NULLQUARK,
    /* compress_motion              */  True,
    /* compress_exposure            */  XtExposeCompressMultiple,
    /* compress_enterleave          */  True,
    /* visible_interest             */  False,
    /* destroy                      */  (XtWidgetProc) Destroy,
    /* resize                       */  (XtWidgetProc) Resize,
    /* expose                       */  NULL,
    /* set_values                   */  (XtSetValuesFunc) SetValues,
    /* set_values_hook              */  NULL,
    /* set_values_almost            */  XtInheritSetValuesAlmost,
    /* get_values_hook              */  (XtArgsProc) GetValuesAlmost,
    /* accept_focus                 */  NULL,
    /* version                      */  XtVersion,
    /* callback_private             */  NULL,
    /* tm_table                     */  XtInheritTranslations, /* Changed from NULL: Bug #406153 */
    /* query_geometry               */  (XtGeometryHandler) QueryGeometry,
    /* display_accelerator          */  XtInheritDisplayAccelerator,
    /* extension                    */  NULL
    }, 
    { /*** composite-Klasse ***/
    /* geometry_manager             */  (XtGeometryHandler) GeometryManager,
    /* change_managed               */  XtInheritChangeManaged,
    /* insert_child                 */  XtInheritInsertChild,
    /* delete_child                 */  XtInheritDeleteChild,
    /* extension                    */  NULL
    }, 
    { /*** constraint-Klasse ***/
    /* resources                    */  NULL,
    /* num_resources                */  0,
    /* constraint_size              */  sizeof(XmManagerConstraintPart),
    /* initialize                   */  NULL,
    /* destroy                      */  NULL,
    /* set_values                   */  NULL,
    /* extension                    */  NULL
    }, 
    { /*** xmManager-Klasse ***/
    /* translations                 */  XtInheritTranslations,
    /* syn_resources                */  NULL,
    /* num_syn_resources            */  0,
    /* syn_constraint_resources     */  NULL,
    /* num_syn_constraint_resources */  0,
    /* parent_process               */  XmInheritParentProcess,
    /* extension                    */  NULL
    }, 
    { /*** combobox-Klasse ***/
    /*                              */  0
    }
}; /* xmComboBoxClassRec */
WidgetClass xmComboBoxWidgetClass = (WidgetClass) &xmComboBoxClassRec;

/* --------------------------------------------------------------------
 * --------------------------------------------------------------------
 * Translation-Tabelle (hier allerdings fuer das Eingabefeld!)
 * Tjaja....mit der Reihenfolge von Translations ist das schon so eine
 * ziemlich boese Sache!
 */
static char newEditTranslations[] =
    "Alt<Key>osfDown:       ComboBox-Manager(show-hide-list)    \n\
     Meta<Key>osfDown:      ComboBox-Manager(show-hide-list)    \n\
     Alt<Key>osfUp:         ComboBox-Manager(hide-list)         \n\
     Meta<Key>osfUp:        ComboBox-Manager(hide-list)         \n\
     <Key>osfUp:            ComboBox-Manager(up)                \n\
     <Key>osfDown:          ComboBox-Manager(down)              \n\
     <Key>osfPageUp:        ComboBox-Manager(page-up)           \n\
     <Key>osfPageDown:      ComboBox-Manager(page-down)         \n\
     <Key>osfCancel:        ComboBox-Manager(cancel)            \n\
     <Key>Return:           ComboBox-Manager(activate) activate()"
    ;
/* speziell bei der nicht editierbaren Combo-Box sind noch einige
 * andere Tasten belegt, die sonst dem Eingabefeld alleine gehoeren.
 * Die dazugehoerigen neuen Translations befinden sich in dieser
 * zusaetzlichen Tabelle, das Anhaengsel ...NE ist dabei die Ab-
 * kuerzung fuer "non editable".
 */
static char newEditTranslationsNE[] = 
    "<Key>osfDelete:        ComboBox-Manager(wipe-out)          \n\
     <Key>osfBeginLine:     ComboBox-Manager(top)               \n\
     <Key>osfEndLine:       ComboBox-Manager(bottom)              "
    ;
/* Momentan gibt es noch Aerger mit dem Drag'n'Drop-Mechanismus
 * von Motif 1.2. Legen wir ihn deshalb erst einmal still, solange
 * bis ich weiss, warum, und eine Loesung parat habe. NEU: Nur wenn
 * Sie mit einer libXm geschlagen sind, die partout nicht funktionieren
 * will, muessen Sie Drag'n'Drop stillegen, ansonsten klappts doch!
 */
#ifdef NODRAGNDROP
static char newListTranslations[] =
    "<Btn2Down>:            ComboBox-Manager(no-operation)      ";
#endif
static char newListTranslationsE[] =
    "<Key>osfPageUp:        ComboBox-Manager(page-up)           \n\
     <Key>osfPageDown:      ComboBox-Manager(page-down)         ";
   
/* ---------------------------------------------------------------------------
 * ---------------------------------------------------------------------------
 * Aktionen-Tabelle: Hierdurch werden den einzelnen Translations die dazuge-
 * hoerigen C-Routinen zugeordnet. Da wir hier ein anstaendiges ANSI-C be-
 * nutzen, werden hier zuerst einmal die Prototypen faellig... Ach ja, noch
 * ein Hinweis in eigener Sache... der ComboBox-Manager muss applikationsweit
 * registriert werden, da er auch von Translationen in den Kindern der Combo-
 * Box aktiviert wird. Bei diesem Namen der 'Aktion' steht aber nicht zu be-
 * fuerchten, dass er anderweitig bereits in Anwendung ist.
 */
static void CBoxManager(Widget w, XEvent *event, String *params, 
                        Cardinal *num_params);

static XtActionsRec actions[] = {
    { "ComboBox-Manager", CBoxManager },
    { NULL, NULL }
}; /* actions */

    
/* --------------------------------------------------------------------
 * Eine Instanz dieser Widget-Klasse wird erstmalig in Betrieb ge-
 * nommen, daher sind noch Vorbereitungen notwendig, die nun hier
 * durchgefuehrt werden.
 */
static XtTranslations NewEditTranslations, NewEditTranslationsNE, 
                      NewListTranslations, NewListTranslationsE;

static XtConvertArgRec ConverterScreenConvertArg[] = {
    { XtBaseOffset, (XtPointer) XtOffset(Widget, core.screen), 
      sizeof(Screen *) }
};

static void ClassInit()
{
    NewEditTranslations =
            XtParseTranslationTable(newEditTranslations);
    NewEditTranslationsNE =
            XtParseTranslationTable(newEditTranslationsNE);
#ifdef NODRAGNDROP
    NewListTranslations =
            XtParseTranslationTable(newListTranslations);
#endif
    NewListTranslationsE =
            XtParseTranslationTable(newListTranslationsE);
    XtAddConverter(XtRString, XtRBitmap, 
                   XmuCvtStringToBitmap, 
                   ConverterScreenConvertArg, 
                   XtNumber(ConverterScreenConvertArg));
} /* ClassInit */

/* ---------------------------------------------------------------------------
 * Weil es sich bei diesem Widget um ein etwas komplizierteres zusammengesetz-
 * tes Widget handelt, muessen wir hier - wo eigentlich nur das die Combobox
 * bildende Fenster auf dem X-Server erzeugt wird - noch einmal das Layout
 * auf Vordermann bringen. Den Aerger loest dabei das Listenfeld der OSF aus,
 * das einfach keine Geometrie-Nachfragen verschickt, solange es nicht 
 * 'realized' ist!!! Nicht, dass ich mich ueber so einen Sauhaufen aufregen 
 * wuerde...ich doch nicht! ABER MACHT IHR DENN NUR SO'N MIST...? WARUM KOENNT
 * IHR DENN NICHT EINMAL DIESES ****(BIEP)**** MOTIF TOOLKIT ANSTAENDIG
 * DOKUMENTIEREN! Ich glaub', ich kann mich nach dem Chaos eigentlich nur noch
 * hemmungslos besaufen... Die Suche nach der Ursache (bzw. Urheber = OSF) hat
 * mich doch einige Tage gekostet (jaja...die Mannstunden!).
 */
static void Realize(XmComboBoxWidget w, Mask *ValueMask, 
                    XSetWindowAttributes *Attributes)
{
    /* 
     * Also: wenn die Liste staendig sichtbar ist, dann zuerst noch einmal
     * das Layout berechnen. Sonst wird vorne und hinten 'was abgeschnitten.
     */
    if ( w->combobox.StaticList )
        DoLayout(w);
    (*w->core.widget_class->core_class.superclass->core_class.realize)
        ((Widget) w, ValueMask, Attributes);
} /* Realize */

/* ---------------------------------------------------------------------------
 * Suche dasjenige Fenster, in dem unsere Shell liegt, in der wiederum die 
 * Combo-Box steckt. Diese Information wird benoetigt, um die Drop-Down-Liste
 * innerhalb des Fensterstacks immer direkt oberhalb der Shell mit der Combo-
 * Box zu halten. Jajaja -- ich muss halt davon ausgehen, dass der Fenster-
 * manager ein sog. "reparenting wm" ist; also die Dekorationen in einem
 * Fenster dargestellt werden und unsere Shell in dieses Fenster hineingepackt
 * ist. Die Dekoration ist damit ein Kind des 'root window' - wie die Shell,
 * in der die Drop-Down-Liste steckt. Und da nur Geschwisterfenster (sibling
 * windows) im gleichen Stapel stecken, reicht das Shellfenster nicht aus.
 * Alle gaengigen Fenstermanager sind solche "reparenting wm's", so dass ich
 * hier zu diesem Trick greifen kann, um die Drop-Down-Liste immer ueber der
 * ComboBox zu halten.
 *
 * Parameter:
 *   w                  Diejenige Combo-Box, fuer die wir dasjenige
 *                      Fenster des Window-Managers ermitteln sollen,
 *                      dass direkt unterhalb des Root-Fensters liegt.
 * Ergebnis:
 *   besagtes zu suchendes Fenster, dass die Dekoration enthaelt (hoffentlich
 *   nur echte Bruesseler Spitze!)
 */
static Window GetDecorationWindow(XmComboBoxWidget w)
{
    Window       Root, Parent, AWindow;
    Window       *Children;
    unsigned int NumChildren;
    
    Parent = XtWindow((Widget) w);
    /* Suche nach dem Dekorationsfenster des Window-Managers */
    do {
        AWindow = Parent;
        XQueryTree(XtDisplay((Widget) w), AWindow, 
                   &Root, &Parent, &Children, &NumChildren);
        XFree((char *) Children);
    } while ( Parent != Root );
    return AWindow;
} /* GetDecorationWindow */

/* --------------------------------------------------------------------
 * Eine Combo-Box aus dem Wege raeumen...
 * Momentan muessen wir hier nur den Cursor wieder los werden sowie
 * eventuell reservierte Pixmaps.
 * Ups -- natuerlich muss auch wieder der Callback entfernt werden, 
 * der noch an der Shell haengt.
 */
static void Destroy(XmComboBoxWidget w)
{
/*    fprintf(stderr, "Destroy: %08X\n", w->core.window);*/
    if ( w->combobox.ConvertBitmapToPixmap )
        XFreePixmap(XtDisplay((Widget) w), 
                    w->combobox.LabelPixmap);
    if ( w->combobox.ConvertBitmapToPixmapInsensitive )
        XFreePixmap(XtDisplay((Widget) w), 
                    w->combobox.LabelInsensitivePixmap);
    if ( w->combobox.PendingFocusOut )
        XtRemoveWorkProc(w->combobox.WorkProcID);
    XtRemoveEventHandler(w->combobox.MyNextShell, 
                      StructureNotifyMask | FocusChangeMask, 
                      True, (XtEventHandler) ShellCallback, 
                      (XtPointer) w);
} /* Destroy */

/* ---------------------------------------------------------------------------
 * Ueberpruefe, ob fuer die Ressource "DropDownOffset" ein gueltiger Wert vom
 * Benutzer angegeben wurde. Diese Ressource gibt an, wie weit die Drop-Down-
 * Liste nach rechts gegenueber dem Eingabefeld eingerueckt sein soll. Wenn
 * hierfuer ein negativer Wert angegeben ist, so berechne statt dessen einen
 * Standardwert: dieser entspricht der Breite der Pfeilschaltflaeche, was 
 * optisch ganz gut wirkt (jedenfall nach meinem Dafuerhalten).
 */
static void CheckDropDownOffset(XmComboBoxWidget w)
{
    if ( w->combobox.DropDownOffset < 0 ) {
        XtWidgetGeometry ArrowGeom;
        
        XtQueryGeometry(w->combobox.ArrowCtrl, NULL, &ArrowGeom);
        w->combobox.DropDownOffset = ArrowGeom.width;
    }
} /* CheckDropDownOffset */

/* --------------------------------------------------------------------
 * Berechne die voreinzustellende Groesse, die diese Combo-Box be-
 * sitzen muss, um ausreichenden Raum fuer das Eingabefeld und den
 * Pfeil rechts daneben zur Verfuegung zu stellen. Bei einer
 * editierbaren Combo-Box ist zwischen dem Eingabefeld und dem Pfeil
 * noch ein Angst-Rasen von der halben Breite eines Pfeiles vorhanden.
 * Wird das Listenfeld staendig dargestellt, so entfallen sowohl Pfeil
 * als auch der Angstrasen, dafuer muss aber die Hoehe des Listenfelds
 * beruecksichtigt werden.
 */
static void DefaultGeometry(XmComboBoxWidget w, 
                            Dimension *TotalWidth, 
                            Dimension *TotalHeight, 
                            Dimension *EditCtrlWidth, 
                            Dimension *LabelCtrlWidth)
{
    XtWidgetGeometry EditGeom, ArrowGeom, LabelGeom, ListGeom;
    
    XtQueryGeometry(w->combobox.EditCtrl,  NULL, &EditGeom);
    XtQueryGeometry(w->combobox.ArrowCtrl, NULL, &ArrowGeom);
    XtQueryGeometry(w->combobox.LabelCtrl, NULL, &LabelGeom);

    /*
     * Soll die Pfeilschaltflaeche quadratisch, praktisch, gut sein?
     */
    if ( w->combobox.SquareArrow )
        ArrowGeom.width = ArrowGeom.height;
    else
        ArrowGeom.width = (ArrowGeom.height * 4) / 5;

    /*
     * Zuerst einmal ein paar einfache Werte ermitteln und zurueckgeben...
     */    
    *TotalHeight    = EditGeom.height;
    *EditCtrlWidth  = EditGeom.width;
    *LabelCtrlWidth = LabelGeom.width;

    /*
     * Ermittele nun die Breite, welche die Combobox benoetigt. Je nach-
     * dem, ob das Eingabefeld oder die Liste breiter sind, wird der
     * entsprechende Wert genommen. Diese Auswahl zwischen der Breite von
     * Eingabefeld und Liste findet aber nur statt, wenn die Liste auch
     * wirklich staendig sichtbar ist. Waehrend der Initialisierung hat
     * allerdings XmNcolumns, so dass in diesem Moment die List nicht
     * mehr die Breite kontrollieren kann!
     */
    if ( w->combobox.StaticList ) {
        /*
         * Beachte: Frage nicht die Listbox, sondern das ScrolledWindow, 
         * in welchem die Liste eingebettet ist.
         */
        CheckDropDownOffset(w);
        XtQueryGeometry(XtParent(w->combobox.ListCtrl), NULL, &ListGeom);
        if ( w->combobox.InInit ) {
            *TotalWidth = EditGeom.width;
        } else {
            if ( EditGeom.width < (Dimension)
                                   (ListGeom.width + w->combobox.DropDownOffset) )
                *TotalWidth = ListGeom.width + w->combobox.DropDownOffset;
            else
                *TotalWidth = EditGeom.width;
        }
        *TotalHeight += ListGeom.height;
    } else {
        /*
         * Das Listenfeld interessiert uns hier nicht. Degegen sollte noch
         * die Breite fuer den Pfeil und ein evtl. Angstrasen beachtet
         * werden.
         */
        *TotalWidth  = EditGeom.width + ArrowGeom.width;
        if ( w->combobox.Editable && w->combobox.ArrowSpacingOn )
            *TotalWidth += ArrowGeom.width/2;
    }
    
    /*
     * Vergiss nicht, auch noch ein evtl. sichtbares Schriftfeld zu berueck-
     * sichtigen!
     */
    if ( w->combobox.ShowLabel )
        *TotalWidth += LabelGeom.width;
    
} /* DefaultGeometry */

/* --------------------------------------------------------------------
 * Anhand eines Widgets ermittele darueber die Screennummer desjenigen
 * Screens, auf dem das Widget erscheint.
 * Parameter:
 *   w                  betroffenes Widget.
 * Ergebnis:
 *   Nummer desjenigen Screens, auf dem das Widget angezeigt wird.
 */
static int WidgetToScreen(Widget w)
{
    Screen  *screen;
    Display *display;
    int     NumScreens, i;
    
    screen = XtScreen(w); NumScreens = ScreenCount(XtDisplay(w));
    display = DisplayOfScreen(screen);
    for ( i = 0; i < NumScreens; ++i )
        if ( ScreenOfDisplay(display, i) == screen )
            return i;
    XtError("WidgetToScreen: data structures are destroyed.");
    return 0; /* to avoid a compiler warning */
} /* WidgetToScreen */

/* --------------------------------------------------------------------
 * Positioniere die DropDown-Liste (soweit sie natuerlich auch momentan
 * sichtbar ist) so auf dem Bildschirm, dass sie sich unterhalb des
 * Eingabefeldes anschliesst.
 */
static void DoDropDownLayout(XmComboBoxWidget w)
{
    Position       abs_x, abs_y;
    Dimension      ArrowWidth, ListWidth, ListHeight;
    Dimension      ScreenHeight, LabelWidth;
    XWindowChanges WindowChanges;

    /* 
     * etwa nicht sichtbar ?!! Oder etwa immer sichtbar ?!!
     * Dann sind wir jetzt sofort fertig. 
     */
    if ( !w->combobox.ListVisible || w->combobox.StaticList ) return;
    /*
     * Finde zuerst einmal heraus, wo wir uns denn auf dem Bildschirm be-
     * finden sollen... Beachte dabei auch, dass eventuell die Liste zu schmal
     * werden koennte und gib' ihr dann ggf. eine Mindestbreite, damit es
     * keinen core-Dump gibt.
     */
    XtVaGetValues(w->combobox.ArrowCtrl, XmNwidth,  &ArrowWidth, NULL);
    XtTranslateCoords((Widget) w, 0, w->core.height, &abs_x, &abs_y);
    CheckDropDownOffset(w);
    ListWidth  = w->core.width - w->combobox.DropDownOffset - 2;
    abs_x     += w->combobox.DropDownOffset;
    if ( w->combobox.ShowLabel ) {
        XtVaGetValues(w->combobox.LabelCtrl, XmNwidth, &LabelWidth, NULL);
        ListWidth -= LabelWidth;
        abs_x     += LabelWidth;
    }
    if ( ListWidth < 20 ) ListWidth = 20;
    XtVaGetValues(XtParent(w->combobox.ListCtrl), XmNheight, &ListHeight, NULL);
    /*
     * Hier ueberpruefen wir noch, ob die Liste unten aus dem Bildschirm 
     * herausfallen wuerde. In dem Fall klappen wir die Liste oberhalb des
     * Eingabefeldes auf.
     */
    ScreenHeight = DisplayHeight(XtDisplay((Widget) w), 
                                 WidgetToScreen((Widget) w));
    if ( abs_y + ListHeight + 2 > ScreenHeight ) {
        int y;
        
        y = ((int) abs_y) - ListHeight - w->core.height - 1;
        if ( y < 0 ) y = 0;
        abs_y = (Position) y;
    }
    XtConfigureWidget(w->combobox.PopupShell, 
                      abs_x, abs_y, ListWidth, ListHeight, 1);
    /*
     * So...das hier dient der Kosmetik: hier sorgen wir dafuer, dass die
     * Liste auch wirklich immer direkt ueber der ComboBox innerhalb des
     * Fensterstapels schwebt. Siehe dazu auch die Erlaeuterungen und An-
     * merkungen in GetDecorationWindow().
     */
    if ( XtIsRealized((Widget) w) ) {
        WindowChanges.sibling    = GetDecorationWindow(w);
        WindowChanges.stack_mode = Above;
        XReconfigureWMWindow(XtDisplay((Widget) w), 
            XtWindow(w->combobox.PopupShell), 
            WidgetToScreen(w->combobox.PopupShell), 
            CWSibling | CWStackMode, &WindowChanges);
    }
} /* DoDropDownLayout */

/* --------------------------------------------------------------------
 * Naja... diese Routine scheint ja bereits zu einer Institution beim
 * Schreiben von Composite-Widgets geworden zu sein.
 * 
 * Hier beim ComboBox-Widget ist die Aufgabe ziemlich einfach: es
 * genuegt, die Eingabezeile und den Pfeil-Button entsprechend inner-
 * halb des ComboBox-Widgets zu plazieren. Seit allerdings noch das
 * Textlabel hinzukommt, wird's langsam aufwendiger. Nun ja - da sich
 * das Listenfeld wahlweise auch statisch einblenden laesst, ist nun
 * noch mehr zu beruecksichtigen, wenn die Kinder-Widgets an ihre
 * Plaetze geschoben werden.
 */
static void DoLayout(XmComboBoxWidget w)
{
    Dimension        EditCtrlWidth, ArrowCtrlWidth, LabelCtrlWidth;
    Dimension        ComboBoxHeight;
    Dimension        BorderWidth;
    Dimension        HighlightThickness;
    Position         EditX;
    
    XtVaGetValues(w->combobox.ArrowCtrl,
                  XmNheight, &ArrowCtrlWidth, NULL);
    if ( !w->combobox.SquareArrow )
        ArrowCtrlWidth = (ArrowCtrlWidth * 4) / 5;
    XtVaGetValues(w->combobox.LabelCtrl, 
                  XmNwidth, &LabelCtrlWidth, NULL);
    
    /* 
     * In Abhaengigkeit davon, ob die ComboBox editierbar ist und ob das
     * Listenfeld staendig sichtbar sein soll, hier die Breite einzelner
     * Widgets bestimmen.
     */
    if ( w->combobox.StaticList ) {
        ComboBoxHeight = w->combobox.EditCtrl->core.height;
        EditCtrlWidth  = w->core.width;
    } else {
        ComboBoxHeight = w->core.height;
        EditCtrlWidth  = w->core.width - ArrowCtrlWidth;
        if ( w->combobox.Editable && w->combobox.ArrowSpacingOn )
            EditCtrlWidth -= ArrowCtrlWidth/2;
    }
    /* Beruecksichtige noch ein evtl. ebenfalls anzuzeigendes Schriftfeld
     * neben dem Eingabefeld.
     */
    if ( w->combobox.ShowLabel ) {
        EditX          = LabelCtrlWidth;
        EditCtrlWidth -= LabelCtrlWidth;
    } else
        EditX = 0;
    if ( EditCtrlWidth < 20 ) EditCtrlWidth = 20;
/* Plaziere nun das Eingabefeld... */
    XtVaGetValues(w->combobox.EditCtrl, 
                  XmNborderWidth,        &BorderWidth, 
                  XmNhighlightThickness, &HighlightThickness, 
                  NULL);
    XtConfigureWidget(w->combobox.EditCtrl, 
                      EditX, 0, 
                      EditCtrlWidth, ComboBoxHeight, BorderWidth);
/* ...und nun den Pfeil... */
    XtVaGetValues(w->combobox.ArrowCtrl, 
                  XtNborderWidth, &BorderWidth, NULL);
    XtConfigureWidget(w->combobox.ArrowCtrl, 
                      w->core.width-ArrowCtrlWidth, HighlightThickness, 
                      ArrowCtrlWidth, 
                      ComboBoxHeight - 2 * HighlightThickness, 
                      BorderWidth);
/* ...und ggf. das Textlabel. */
    if ( w->combobox.ShowLabel ) {
        XtVaGetValues(w->combobox.LabelCtrl, 
                      XmNborderWidth, &BorderWidth, 
                      NULL);
        XtConfigureWidget(w->combobox.LabelCtrl, 
                          0, 0, 
                          LabelCtrlWidth, ComboBoxHeight, 
                          BorderWidth);
    }
/* Falls da noch die Liste herumgurkt... */
    if ( w->combobox.StaticList ) {
        Dimension Width, Height;
        
        if ( w->core.height > ComboBoxHeight ) 
            Height = w->core.height - ComboBoxHeight;
        else
            Height = 10;
            
        if ( w->core.width > (Dimension)(ArrowCtrlWidth + EditX) )
            Width = w->core.width - ArrowCtrlWidth - EditX;
        else
            Width = 10;
        
        XtConfigureWidget(XtParent(w->combobox.ListCtrl),
            EditX + ArrowCtrlWidth, ComboBoxHeight, Width, Height, 0);
    } else if ( w->combobox.ListVisible )
        DoDropDownLayout(w); 
} /* DoLayout */

/* --------------------------------------------------------------------
 * Pappi fragt nach, wie gross wir denn sein wollen.
 * Die hier benutzte Vorgehensweise zur Ermittlung der Groesse:
 *   Sobald der Vater uns eine Breite (oder aber Hoehe) vorschlaegt, 
 *   die fuer uns eigentlich zu klein ist, meckern wir und schlagen
 *   die von uns benoetigte Breite (Hoehe) vor.
 * Soweit also zur Theorie... leider sieht es beispielsweise das
 * Motif Form-Widget ueberhaupt nicht ein, uns auch nur ein einziges
 * Mal nach unseren Wuenschen zu fragen! Damit es bei derart unum-
 * gaenglichen Widgets dann doch noch geht, muss ChangedManaged die
 * Kohlen wieder aus dem Feuer holen mit einer Sondertour.
 * Parameter:
 *   *Request       Vom Vater vorgeschlagene Geometrie
 * Ergebnis:
 *   *Reply         Unsere Antwort auf die vorgeschlagene Geometrie
 *   sowie XtGeometryYes oder XtGeometryAlmost, je nachdem, wie gut
 *   uns Pappis Vorschlag in den Kram passt.
 */
static XtGeometryResult QueryGeometry(XmComboBoxWidget w, 
                                      XtWidgetGeometry *Request, 
                                      XtWidgetGeometry *Reply)
{
    XtGeometryResult result = XtGeometryYes;
    Dimension        minW, minH, editW, labelW;
    
/* Elternteil will nichts weiter aendern, also ist uns das
 * recht so.
 */
    Request->request_mode &= CWWidth | CWHeight;
    if ( Request->request_mode == 0 ) return result;

    DefaultGeometry(w, &minW, &minH, &editW, &labelW);

/* Ueberpruefe, ob uns das in der Breite passt, was Pappi moechte... */
    if ( Request->request_mode & CWWidth ) {
        if ( Request->width < minW ) {
/* Wenn Pappi uns etwas vorschlaegt, was im wahrsten Sinne des Wortes 
 * vorn und hinten nicht reicht, dann versuchen wir ihn entsprechend
 * zu korrigieren. ("Versuchen" deshalb, weil er diesen Vorschlag auch
 * voellig ignorieren kann.)
 */
            result               = XtGeometryAlmost;
            Reply->width         = minW;
            Reply->request_mode |= CWWidth;
        }
    }
/* Die ganze Chose nun noch vertikal */
    if ( Request->request_mode & CWHeight ) {
        if ( Request->height < minH ) {
            result               = XtGeometryAlmost;
            Reply->height        = minH;
            Reply->request_mode |= CWHeight;
        }
    }
    return result;
} /* QueryGeometry */

/* --------------------------------------------------------------------
 * Die Groesse des ComboBox-Widgets hat sich veraendert und deshalb
 * mussen alle Kinder neu positioniert werden.
 * Letzten Endes laeuft hier alles auf ein ordinaeres DoLayout()
 * hinaus, um die Kinder umher zu schieben.
 * Parameter:
 *   w              Die bereits hinlaenglich bekannte Instanz dieses
 *                  Widgets
 */
static void Resize(XmComboBoxWidget w)
{
    DoLayout(w);
} /* Resize */

/* --------------------------------------------------------------------
 * Dieses Widget hat sich in irgendeiner Form bewegt (und das nicht
 * nur relativ zum Vater, sondern moeglicherweise auch der Vater
 * selbst!) bzw. die Shell, in der sich irgendwo unsere Combo-Box
 * befindet, hat soeben den Fokus verschusselt und kann ihn nicht
 * mehr wiederfinden. Daneben kann es auch sein, dass die Shell
 * ikonisiert wurde. (Welch' Vielfalt! Dieses ist hier halt eine
 * multifunktionale Routine.)
 * 
 * Parameter:
 *   w              Die naechste Shell in Reichweite ueber unserer
 *                  Combo-Box.
 *   cbw            Diese Combo-Box.
 *   event          ^ auf den Event, enthaelt genauerere Informationen
 *                  (naja... sieht so aus, als ob Motif hier auch 
 *                  schon 'mal Schrott 'reinpackt...)
 *   ContDispatch   Auf True setzen, damit dieser Event noch weiter-
 *                  gereicht wird an all' die anderen, die auch noch
 *                  mithoeren.
 */
static void ShellCallback(Widget w, XtPointer pClientData, 
                          XEvent *event, Boolean *ContDispatch)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;
    
    switch ( event->type ) {
        case ConfigureNotify:
        case CirculateNotify:
            DoDropDownLayout((XmComboBoxWidget) cbw);
            break;
        case FocusOut:
            LOG3("ShellCallback: FocusOut, mode: %i, detail: %i\n",
                 (int)event->xfocus.mode, (int)event->xfocus.detail);
            if ( cbw->combobox.Persistent )
                cbw->combobox.IgnoreFocusOut = True;
            else if ( (event->xfocus.mode == NotifyGrab) &&
                      cbw->combobox.ListVisible )
                cbw->combobox.IgnoreFocusOut = True;
            break;
        case UnmapNotify:
            ShowHideDropDownList((XmComboBoxWidget) cbw, 
                                 event, False);
            break;
    }
    *ContDispatch = True;
} /* ShellCallback */

/* --------------------------------------------------------------------
 * Diese Routine sorgt dafuer, dass die Liste nicht irrtuemlich bei
 * manchen Window Managern vom Bildschirm genommen wird, bloss weil
 * diese der OverrideShell den Tastaturfocus schenken bzw. diesen
 * dem Combo-Box-Widget wegnehmen, sobald der Mauszeiger in die Liste
 * bewegt wird.
 */
static void OverrideShellCallback(Widget w, XtPointer pClientData,
                                  XEvent *event, Boolean *ContDispatch)

{
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;
    switch ( event->type ) {
        case EnterNotify:
            LOG2("OverrideShellCallback: EnterNotify, PendingFO: %s\n", 
                 cbw->combobox.PendingFocusOut ? "True" : "False");
            if ( cbw->combobox.PendingFocusOut )
                cbw->combobox.IgnoreFocusOut = True;
            if ( cbw->combobox.TwmHandlingOn )
                cbw->combobox.PendingOverrideInOut = True;
            break;
        case LeaveNotify:
            LOG("OverrideShellCallback: LeaveNotify\n");
            if ( cbw->combobox.TwmHandlingOn )
              cbw->combobox.PendingOverrideInOut = True;
            break;
    }
} /* OverrideShellCallback */

/* --------------------------------------------------------------------
 * Ha! Anscheinend kann man das Problem mit der einklappenden Liste,
 * sobald man den Arrow-Button anklickt, doch loesen! Allerdings geht
 * das auch nur von hinten durch die Brust in's Auge. Hier war die
 * Reihenfolge der Events bislang das Problem: Klickt man den Arrow-
 * Button an, so verliert das Eingabefeld den Focus, dann wird leider
 * schon die WorkProc aktiviert und laesst die Liste verschwinden.
 * Danach erst kommt der Arrow-Button-Callback an die Reihe. Um dieses
 * Dilemma doch noch zu loesen, wird hier darauf gelauert, wann und
 * welcher LeaveNotify kommt. Klickt der Benutzer den Pfeil an, so
 * kommt hier noch rechtzeitig ein LeaveNotify vorbei, der aber durch
 * einen Grab ausgeloest wurde. Und das ist eben nur beim Anklicken
 * der Fall. Damit wissen wir, das der FocusOut getrost ignoriert
 * werden darf.
 * Puhhh -- ist das ein kompliziertes Chaos.
 * Uebrigends...auch wenn manche Befehle zuerst ueberfluessig er-
 * scheinen...sie sind erforderlich, damit die ComboBox auch mit unter-
 * schiedlichen Window Managern zurechtkommt!
 */
static void ArrowCrossingCallback(Widget w, XtPointer pClientData,
                               XEvent *event, Boolean *ContDispatch)

{
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;
    switch ( event->type ) {
        case LeaveNotify:
            LOG2("ArrowCrossingCallback: LeaveNotify, mode: %i\n", 
                 event->xcrossing.mode);
            if ( event->xcrossing.mode == NotifyGrab )
                cbw->combobox.IgnoreFocusOut = True;
            else
                cbw->combobox.IgnoreFocusOut = False;
            break;
    }
} /* ArrowCrossingCallback */

/* --------------------------------------------------------------------
 * Alle Hilfeaufrufe innerhalb der Kinder gehen an das eigentliche
 * Combo-Box-Widget weiter, so dass auch hier nach aussen hin die
 * Kinder-Widgets nicht in Erscheinung treten.
 */
static void HelpCallback(Widget w, XtPointer cbw, XtPointer CallData)
{
    XtCallCallbacks((Widget) cbw, XmNhelpCallback, CallData);
} /* HelpCallback */

/* --------------------------------------------------------------------
 * Wenn der Benutzer im Eingabefeld osfActivate drueckt, dann dieses
 * Ereignis offiziell bekanntgeben.
 */
static void ActivateCallback(Widget w, XtPointer cbw, XtPointer CallData)
{
    XtCallCallbacks((Widget) cbw, XmNactivateCallback, CallData);
} /* ActivateCallback */

/* --------------------------------------------------------------------
 * Ein Kind moechte sein Groesse veraendern und fragt deshalb hier bei
 * uns an.
 * Parameter:
 *   w              Naja...
 *   *Request       Vorschlag des Kindes
 * Ergebnis:
 *   *Reply         Unsere Antwort darauf
 *   XtGeometryNo, da es uns bislang grundsaetzlich nie passt, es sei
 *   denn, es ist das Label... Naja, jetzt darf auch schon einmal das
 *   Listenfeld quengeln (aber nur, wenn es staendig sichtbar ist, 
 *   ansonsten wird es nicht beruecksichtigt!).
 */
static XtGeometryResult GeometryManager(Widget w, 
                                        XtWidgetGeometry *Request, 
                                        XtWidgetGeometry *Reply)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);
    XtGeometryResult Result = XtGeometryNo;
    
    /*
     * Falls das Listenfeld statisch dargestellt wird, muessen wir seine
     * Wuensche doch beruecksichtigen. Was fuer ein Aufwand...
     */
    if ( (w == XtParent(cbw->combobox.ListCtrl)) && cbw->combobox.StaticList ) {
        Dimension TotalWidth, TotalHeight, EditWidth, LabelWidth;
        XtWidgetGeometry MyRequest, YourReply, EditGeom;
        
        XtQueryGeometry(cbw->combobox.EditCtrl, NULL, &EditGeom);
        DefaultGeometry(cbw, &TotalWidth, &TotalHeight,
                             &EditWidth, &LabelWidth);
        CheckDropDownOffset(cbw);
        
        if ( Request->request_mode && CWWidth )
            if ( (Dimension)(LabelWidth + cbw->combobox.DropDownOffset + 
                             Request->width) > TotalWidth )
                TotalWidth = LabelWidth + cbw->combobox.DropDownOffset + 
                             Request->width;
        
        if ( Request->request_mode && CWHeight )
            TotalHeight = EditGeom.height + Request->height;
    /*
     * Bastele nun eine Anfrage an Pappi zusammen und geh' ihm damit auf den
     * Keks. Wenn er zustimmt, ist sofort alles gut, wir muessen dann nur
     * noch das Layout aufpolieren, damit das Listenfeld die neue Groesse
     * bekommt. Wenn Pappi nur halb zustimmt, akzeptieren wir das und fragen
     * ihn damit noch einmal....
     */
        MyRequest.request_mode = CWWidth | CWHeight;
        MyRequest.width        = TotalWidth;
        MyRequest.height       = TotalHeight;
        Result = XtMakeGeometryRequest((Widget) cbw, &MyRequest, &YourReply);
        if ( Result == XtGeometryAlmost ) {
            MyRequest.width  = YourReply.width;
            MyRequest.height = YourReply.height;
            Result = XtMakeGeometryRequest((Widget) cbw, &MyRequest, &YourReply);
        }
        if ( Result == XtGeometryYes )
            DoLayout(cbw);
    } else 
    /*
     * Ansonsten darf nur noch das Schriftfeld Ansprueche anmelden.
     */
    if ( w != cbw->combobox.LabelCtrl )
        return XtGeometryNo; /* Was ICH hier vorgegeben habe, gilt! */
    else if ( cbw->combobox.ShowLabel ) { /* Naja, 'mal schauen! */
        Dimension TotalWidth, TotalHeight, EditWidth, LabelWidth;
        XtWidgetGeometry MyRequest;
        
        if ( Request->request_mode & CWWidth ) {
            DefaultGeometry(cbw, &TotalWidth, &TotalHeight,
                                 &EditWidth, &LabelWidth);
            TotalWidth = TotalWidth - LabelWidth + 
                         Request->width;
            
            MyRequest.request_mode = CWWidth;
            MyRequest.width        = TotalWidth;
            Result = XtMakeGeometryRequest((Widget) cbw, &MyRequest, NULL);

            if ( Result == XtGeometryYes )
                DoLayout(cbw);
        }
    }
    return Result;
} /* GeometryManager */

/* --------------------------------------------------------------------
 * Hier werden auf Wunsch diejenigen Farben, die bei der Combo-Box neu
 * gesetzt wurden, an alle Kinder weitergegeben.
 */
#define BOTTOMSHADOWCOLOR   0x0001
#define TOPSHADOWCOLOR      0x0002
#define FOREGROUND          0x0004
#define BACKGROUND          0x0008

static struct { String Resource; int Flag; }
       ColorResources[] = {
           { XmNbottomShadowColor, BOTTOMSHADOWCOLOR }, 
           { XmNtopShadowColor,    TOPSHADOWCOLOR    }, 
           { XmNforeground,        FOREGROUND        }, 
           { XmNbackground,        BACKGROUND        }
       };

static int UpdateColors(XmComboBoxWidget w, int flags)
{
    Pixel  Color;
    int    i, size = XtNumber(ColorResources);
    Widget ScrolledWin, ScrollBar;
    
    ScrolledWin = XtParent(w->combobox.ListCtrl);
    XtVaGetValues(ScrolledWin, XmNverticalScrollBar, &ScrollBar, NULL);
    for ( i=0; i<size; i++ )
        if ( flags & ColorResources[i].Flag ) {
            XtVaGetValues((Widget) w, ColorResources[i].Resource, &Color,
                          NULL);
            XtVaSetValues(w->combobox.ListCtrl, 
                          ColorResources[i].Resource, Color, NULL);
            XtVaSetValues(ScrolledWin, 
                          ColorResources[i].Resource, Color, NULL);
            XtVaSetValues(ScrollBar, 
                          ColorResources[i].Resource, Color, NULL);
            XtVaSetValues(w->combobox.EditCtrl, 
                          ColorResources[i].Resource, Color, NULL);
            XtVaSetValues(w->combobox.LabelCtrl, 
                          ColorResources[i].Resource, Color, NULL);
            XtVaSetValues(w->combobox.ArrowCtrl, 
                          ColorResources[i].Resource, Color, NULL);
            if ( ColorResources[i].Flag & BACKGROUND )
                XtVaSetValues(ScrollBar, XmNtroughColor, Color, NULL);
        }

        return 1;
} /* UpdateColors */

/* --------------------------------------------------------------------
 * Liste aller vorgespiegelten Resourcen, die automatisch verarbeitet
 * werden koennen, ohne weiter darueber nachdenken zu muessen...
 */
typedef enum  { EDITCTRL, LISTCTRL, LABELCTRL } CHILDCTRL;
typedef enum { RO, RW, RWS, RWL, RWI, RWIGNORE } aUniqueName;
typedef struct {
    String                    rsc;
    CHILDCTRL                 ctrl;
/*    enum { RO, RW, RWS, RWL, RWI, RWIGNORE } dir; */
    aUniqueName dir;
    /* nur lesen, lesen&schreiben, lesen&schreiben spezial,
       lesen&schreiben label, lesen&schreiben items */
} MIRROR;

/* Alle mit !!! gekennzeichneten Eintraege werden auf die richtigen
 * Namen des entsprechenden Widgets umgesetzt.
 */
static MIRROR MirroredResources[] = {
    { XmNitems,                     LISTCTRL,  RWI }, /* Urgs! */
    { XmNitemCount,                 LISTCTRL,  RWIGNORE  }, /* dto.  */
    { XmNlistMarginHeight,          LISTCTRL,  RW  }, 
    { XmNlistMarginWidth,           LISTCTRL,  RW  }, 
    { XmNlistSpacing,               LISTCTRL,  RW  }, 
    { XmNstringDirection,           LISTCTRL,  RO  }, /* Naja? */
    { XmNtopItemPosition,           LISTCTRL,  RO  }, 
    
    { XmNblinkRate,                 EDITCTRL,  RW  }, 
    { XmNcolumns,                   EDITCTRL,  RW  }, 
    { XmNcursorPosition,            EDITCTRL,  RW  }, 
    { XmNcursorPositionVisible,     EDITCTRL,  RW  }, 
    { XmNmarginHeight,              EDITCTRL,  RW  }, 
    { XmNmarginWidth,               EDITCTRL,  RW  }, 
    { XmNmaxLength,                 EDITCTRL,  RW  }, 
    { XmNselectThreshold,           EDITCTRL,  RW  }, 
    { XmNvalue,                     EDITCTRL,  RWS }, 
    
    { XmNalignment,                 LABELCTRL, RW  }, 
    { XmNmnemonic,                  LABELCTRL, RW  }, 
    { XmNmnemonicCharSet,           LABELCTRL, RW  }, 
    { XmNlabelPixmap,               LABELCTRL, RW  }, 
    { XmNlabelInsensitivePixmap,    LABELCTRL, RW  }, 
    { XmNlabelString,               LABELCTRL, RW  }, 
    { XmNlabelType,                 LABELCTRL, RW  }, 
    { XmNlabelMarginBottom,         LABELCTRL, RWL }, /* !!! */
    { XmNlabelMarginHeight,         LABELCTRL, RWL }, /* !!! */
    { XmNlabelMarginLeft,           LABELCTRL, RWL }, /* !!! */
    { XmNlabelMarginRight,          LABELCTRL, RWL }, /* !!! */
    { XmNlabelMarginTop,            LABELCTRL, RWL }, /* !!! */
    { XmNlabelMarginWidth,          LABELCTRL, RWL }, /* !!! */
    { XmNlabelFontList,             LABELCTRL, RWL }, /* !!! */
};

typedef struct {
    char *from, *to;
} TRANSFORMATION;
static TRANSFORMATION Transformations[] = {
    { XmNlabelMarginBottom, XmNmarginBottom }, 
    { XmNlabelMarginHeight, XmNmarginHeight }, 
    { XmNlabelMarginLeft,   XmNmarginLeft   }, 
    { XmNlabelMarginRight,  XmNmarginRight  }, 
    { XmNlabelMarginTop,    XmNmarginTop    }, 
    { XmNlabelMarginWidth,  XmNmarginWidth  }, 
    { XmNlabelFontList,     XmNfontList     },
};

/* --------------------------------------------------------------------
 * Sobald irgendeine Resource veraendert wird, erfolgt der Aufruf
 * hierin als Benachrichtigung, einmal nach dem rechten zu sehen.
 * Parameter:
 *   current        Kopie der Widget-Instanz, bevor irgendwelche
 *                  Resourcen veraendert oder set_values()-Methoden
 *                  aufgerufen wurden.
 *   req            Kopie der Widget-Instanz, aber bereits mit den
 *                  durch XtSetValues veraenderten Werten
 *   new            aktuellster Zustand der Widget-Instanz mit
 *                  veraenderten Werten (entweder durch XtSetValues
 *                  oder set_values()-Methoden der Superklasse)
 *   args           Argumentenliste beim Aufruf von XtSetValues()
 *   NumArgs        Anzahl der Argumente in der Liste
 * Ergebnis:
 *   True, falls Widget neu gezeichnet werden soll.
 */
static Boolean SetValues(XmComboBoxWidget current, XmComboBoxWidget req, 
                         XmComboBoxWidget newW, 
                         ArgList args, Cardinal *NumArgs)
{
    Boolean Update = False;
    int i, j, MirrorSize = XtNumber(MirroredResources);
    int k, TransformationSize = XtNumber(Transformations);
    Arg arg;
    int Flags;
    
/* 
 * Alle Resourcen, die nicht mehr nach dem Erstellen der Widget-Instanz
 * veraendert werden koennen.
 */
    newW->combobox.Editable        = current->combobox.Editable;
    newW->combobox.ListCtrl        = current->combobox.ListCtrl;
    newW->combobox.EditCtrl        = current->combobox.EditCtrl;
    newW->combobox.LabelCtrl       = current->combobox.LabelCtrl;
    newW->combobox.SelectionPolicy = current->combobox.SelectionPolicy;
    newW->combobox.ListSizePolicy  = current->combobox.ListSizePolicy;
    newW->combobox.StaticList      = current->combobox.StaticList;
    
/* 
 * Kontrolliere nun alle Resourcen, die sich veraendert haben koennten
 * und gebe die neuen Einstellungen entsprechend weiter...
 *
 * Hat sich der Sensitive-Zustand veraendert? Dann muessen wir hier dafuer
 * sorgen, dass alle Kinder ebenfalls den neuen Zustand annehmen.
 */
    if ( current->core.sensitive != newW->core.sensitive ) {
        XtSetSensitive(newW->combobox.ListCtrl, newW->core.sensitive);
        XtSetSensitive(newW->combobox.EditCtrl, newW->core.sensitive);
        XtSetSensitive(newW->combobox.ArrowCtrl, newW->core.sensitive);
        XtSetSensitive(newW->combobox.ListCtrl, newW->core.sensitive);
        if ( !newW->core.sensitive )
            ShowHideDropDownList(newW, NULL, False);
    }
/* 
 * Die ScrollBarPolicy kann nur dann geaendert werden, wenn das Listenfeld
 * dauerhaft dargestellt wird.
 */
    if ( newW->combobox.ScrollBarDisplayPolicy != 
         current->combobox.ScrollBarDisplayPolicy ) {
        if ( newW->combobox.StaticList )
            XtVaSetValues(newW->combobox.ListCtrl,
                          XmNscrollBarDisplayPolicy, newW->combobox.ScrollBarDisplayPolicy,
                          NULL);
        else
            XtWarning(
"XmComboBox: ScrollBarDisplayPolicy can not be changed when StaticList == False."
);
    }
/* Anzahl der in der Liste gleichzeitig darstellbaren Eintraege */
    if ( current->combobox.VisibleItemCount != 
           newW->combobox.VisibleItemCount ) {
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNvisibleItemCount, newW->combobox.VisibleItemCount, 
                      NULL);
        Update = True;
    }
    if ( current->combobox.AutomaticSelection != 
         newW->combobox.AutomaticSelection ) {
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNautomaticSelection, newW->combobox.AutomaticSelection, 
                      NULL);
    }
/* 
 * benutzter Font: hier erhalten Liste und Eingabefeld jeweils die
 * gleiche Fontliste, wohingegen das Label getrennt behandelt wird.
 * Das macht auch Sinn, denn Liste und Eingabefeld beinhalten gleich-
 * artigen Text, so dass hier auch tunlichst der gleiche Font zu
 * benutzen ist.
 */
    if ( current->combobox.Font != newW->combobox.Font ) {
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNfontList, newW->combobox.Font, NULL);
        XtVaSetValues(newW->combobox.EditCtrl, 
                      XmNfontList, newW->combobox.Font, NULL);
        Update = True;
    }
    
    Flags = 0;
    if ( newW->manager.top_shadow_color != 
         current->manager.top_shadow_color    ) Flags |= TOPSHADOWCOLOR;
    if ( newW->manager.bottom_shadow_color != 
         current->manager.bottom_shadow_color ) Flags |= BOTTOMSHADOWCOLOR;
    if ( newW->manager.foreground != 
         current->manager.foreground          ) Flags |= FOREGROUND;
    if ( newW->core.background_pixel != 
         current->core.background_pixel       ) Flags |= BACKGROUND;
    if ( Flags ) { UpdateColors(newW, Flags); Update = True; }
    
    
    if ( newW->combobox.ArrowCursor != current->combobox.ArrowCursor ) {
        if ( newW->combobox.ListVisible )
            XDefineCursor(XtDisplay(newW->combobox.PopupShell), 
                            XtWindow(newW->combobox.PopupShell), 
                            newW->combobox.ArrowCursor); 
   }
/* Hier werden die vorgespiegelten Resourcen verwaltet, die in
 * Wirklichkeit zu einem unserer Kinder gehoeren.
 */
     for ( i = 0; i < *NumArgs; i++ ) {
/* Ist es eine vorgespiegelte Resource ? Wenn ja, dann leite die
 * Anfrage an das entsprechende Kind-Widget weiter.
 */
        for ( j = 0; j < MirrorSize; j++ ) {
            if ( (strcmp(args[i].name, MirroredResources[j].rsc) == 0) ) {
                switch ( MirroredResources[j].dir ) {
                case RW:   /* schreibender Zugriff erlaubt */
                    XtSetValues(MirroredResources[j].ctrl == LISTCTRL ?
                                  newW->combobox.ListCtrl :  
                                (MirroredResources[j].ctrl == EDITCTRL ?
                                  newW->combobox.EditCtrl :
                                  newW->combobox.LabelCtrl), 
                        &(args[i]), 1);
                    break;
                case RWS:  /* schreibender Zugriff unter Kontrolle */
                    if ( strcmp(args[i].name, XmNvalue) == 0 ) {
                        if ( newW->combobox.Editable )
                            XtSetValues(newW->combobox.EditCtrl, 
                                        &(args[i]), 1);
                    }
                    break;
                case RWL: /* Transformation in andere Resource beim
                             Label-Widget */
                    for ( k = 0; k < TransformationSize; k++ )
                        if ( strcmp(args[i].name, Transformations[k].from) == 0 ) {
                            arg.value = args[i].value;
                            arg.name = Transformations[k].to;
                            XtSetValues(newW->combobox.LabelCtrl, 
                                        &arg, 1);
                            break;
                        }
                    break;
                case RWIGNORE: /* Zugriff auf XmNitemCount */
                               /* Wird von XmNitems erledigt! */
                    break;
                case RWI: /* Zugriff auf XmNitems */
                    for ( k = 0; k < *NumArgs; k++ )
                        if ( strcmp(args[k].name, XmNitemCount) == 0 ) {
                            Arg MyArgs[2];
                            
                            MyArgs[0].name  = XmNitems;
                            MyArgs[0].value = args[i].value;
                            MyArgs[1].name  = XmNitemCount;
                            MyArgs[1].value = args[k].value;
                            XtSetValues(newW->combobox.ListCtrl,
                                        args, 2);
                            /*XtVaSetValues(newW->combobox.ListCtrl, 
                                          XmNitems,     args[i].value, 
                                          XmNitemCount, args[k].value, 
                                          NULL);*/
                            break;
                        }
                    break;
                case RO:
                    break;
                } /* case write mode */
                goto ScanForNextResource;
            } /* if entry found */
        } /* for every mirrored entry */
        ScanForNextResource: ;
    } /* for every Arg */
    
    if ( (newW->combobox.SquareArrow != current->combobox.SquareArrow) ||
         (newW->combobox.ArrowSpacingOn != current->combobox.ArrowSpacingOn) ) {
        Update = False;
        DoLayout(newW);
    }
    
    return Update;
} /* SetValues */

/* --------------------------------------------------------------------
 * Werden irgendwelche Resourcen abgefragt, so muessen wir hier erst
 * noch vor der Rueckkehr zum Frager klaeren, ob davon eine Resource
 * betroffen ist, die nur vorgespiegelt ist, da sie eigentlich einem
 * der Widgets gehoert, die von uns hier verwaltet werden, um daraus
 * eine ordentliche Combo-Box zu machen.
 * Parameter:
 *   w              Widget-Instanz
 *   args           Abgefragte Resourcen
 *   NumArgs        Anzahl der abgefragten Resourcen
 */
static void GetValuesAlmost(XmComboBoxWidget w, ArgList args, 
                            Cardinal *NumArgs)
{
    int i, j, MirrorSize = XtNumber(MirroredResources);
    int k, TransformationSize = XtNumber(Transformations);
    Arg arg;
    
    for ( i = 0; i < *NumArgs; i++ ) {
/* Ist es eine vorgespiegelte Resource ? Wenn ja, dann leite die
 * Anfrage an das entsprechende Kind-Widget weiter.
 */
        for ( j = 0; j < MirrorSize; j++ ) {
            if ( strcmp(args[i].name, MirroredResources[j].rsc) == 0 ) {
                switch ( MirroredResources[j].dir ) {
                case RO:
                case RW:
                case RWS:
                case RWI:
                    XtGetValues(MirroredResources[j].ctrl == LISTCTRL ?
                                  w->combobox.ListCtrl : 
                                MirroredResources[j].ctrl == EDITCTRL ?
                                  w->combobox.EditCtrl :
                                  w->combobox.LabelCtrl, 
                        &(args[i]), 1);
                    break;
                case RWL: /* Umzuleitende Resource bei Label-Widget */
                    for ( k = 0; k < TransformationSize; k++ )
                        if ( strcmp(args[i].name, Transformations[k].from) == 0 ) {
                            arg.value = args[i].value;
                            arg.name = Transformations[k].to;
                            XtGetValues(w->combobox.LabelCtrl, 
                                        (ArgList) &arg, 1);
                            break;
                        }
                    break;
                } /* case read mode */
            } /* if entry found */
        } /* for every mirrored entry */
    } /* for every Arg */
} /* GetValuesAlmost */

/* --------------------------------------------------------------------
 * Zeige beziehungsweise verstecke die Drop-Down-Liste der Combo-Box.
 * Falls die Liste bereits den entsprechenden Zustand hat, geht's
 * sofort zum Aufrufer zurueck.
 * Parameter:
 *   w              Her Royal Majesty ComboBox
 *   Show           True, falls anzuzeigen, andernfalls False
 */
static void ShowHideDropDownList(XmComboBoxWidget w, XEvent *event, 
                                 Boolean Show)
{
    XmComboBoxDropDownCallbackStruct info;
    
    if ( w->combobox.StaticList || 
         (Show == w->combobox.ListVisible) ) return;
    w->combobox.ListVisible = Show;
    if ( Show ) { /* Klapp' die Liste aus! */
        DoDropDownLayout(w);
        info.reason = XmCR_SHOW_LIST;
        info.event  = event;
        XtCallCallbacks((Widget) w, XmNdropDownCallback, 
                        (XtPointer) &info);
        XDefineCursor(XtDisplay(w->combobox.PopupShell), 
                        XtWindow(w->combobox.PopupShell), 
                        w->combobox.ArrowCursor); 
        XtPopup(w->combobox.PopupShell, XtGrabNone);
        XtVaSetValues(w->combobox.ArrowCtrl, 
                      XmNarrowDirection, XmARROW_UP, NULL);
    } else {      /* Klapp' die Liste wieder ein... */
        XtPopdown(w->combobox.PopupShell);
        XtVaSetValues(w->combobox.ArrowCtrl, 
                      XmNarrowDirection, XmARROW_DOWN, NULL);
        info.reason = XmCR_HIDE_LIST;
        info.event  = event;
        XtCallCallbacks((Widget) w, XmNdropDownCallback, 
                        (XtPointer) &info);
    }
} /* ShowHideDropDownList */

/* --------------------------------------------------------------------
 * Hier laeuft die Nachricht auf, dass der Pfeil ausgeloest wurde...
 * (Daraufhin sollte die Liste aus- oder eingeklappt werden)
 * ...oder dass der Benutzer da draussen auf der anderen Seite der
 * Mattscheibe den Pfeil bereits anklickte ohne aber bereits losge-
 * gelassen zu haben. Bereits hier bekommt das Eingabefeld den Fokus
 * vor den Latz geknallt, denn sonst kann es passieren, dass zwar die
 * Liste ausgeklappt ist, aber das Eingabefeld noch keinen Tastatur-
 * fokus erhalten hat. Das sollte aber nicht so sein, denn es ist dann
 * keine konsequente Tastaturbedienung.
 */
static void ArrowCallback(Widget w, XtPointer pClientData, 
                          XmAnyCallbackStruct *info)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);
    
    switch ( info->reason ) {
        case XmCR_ARM:
            LOG("ArrowCallback: XmCR_ARM\n");
            XmProcessTraversal(cbw->combobox.EditCtrl, XmTRAVERSE_CURRENT);
            if ( cbw->combobox.TwmHandlingOn && cbw->combobox.ListVisible )
                cbw->combobox.IgnoreFocusOut = True;
            break;
        case XmCR_ACTIVATE:
            XmProcessTraversal(cbw->combobox.EditCtrl, XmTRAVERSE_CURRENT);
            ShowHideDropDownList(cbw, info->event, 
                                 (Boolean)(!cbw->combobox.ListVisible));
            break;
    }
} /* ArrowCallback */

/* --------------------------------------------------------------------
 * Diese Benachrichtigung moechte uns nur mitteilen, dass wir soeben
 * den Fokus verloren haben (Ohhhh!) Sollte allerdings der Fokus nur
 * aus dem Grunde perdue sein, dass der Anwender den Mauszeiger ausser-
 * halb des Applikationsfensters plaziert hat, so koennen wir diese
 * Nachricht uebergehen. Erst wenn der Fokus an ein anderes Widget in
 * unserer Applikation verlorenging, muessen wir auf diese Information
 * reagieren.
 * Und jetzt zu noch einem total beknackten Problem - alles nur wegen
 * Motif und den diversen Window-Managern (bspw. olwm)... Leider kommt
 * beim FocusOut kein richtiger Hinweis auf den tatsaechlichen Event,
 * der dieses Callback ausloeste -- warum liefert denn dann Motif ueber-
 * haupt noch den Event???? Und ueberhauupt, die Geschichte mit dem
 * Fokus ist schon der reinste Horror. Aktueller Ausweg: wenn wir die
 * Benachrichtigung ueber den Focusabgang bekommen, registrieren wir
 * eine Work-Prozedur, die, sobald der Rechner wieder Luft hat, auf-
 * gerufen wird. Sie kann dann nachschauen, ob nicht inzwischen die
 * OverrideShell den Focus bekahm. Wenn ja, koennen wir den FocusOut
 * uebergehen, ansonsten muessen wir ihn beruecksichtigen.
 * -- Ist das eine ^@#$^*(#$^&! (Meine gute Erziehung hindert mich
 * daran, diesen Begriff hier zu nennen.)
 */
static Boolean DelayedFocusOutWorkProc(XtPointer pClientData)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;
    LOG2("DelayedFocusOutWorkProc: IgnoreFocusOut: %s\n", 
         cbw->combobox.IgnoreFocusOut ? "True" : "False");
    if ( !cbw->combobox.IgnoreFocusOut )
        ShowHideDropDownList(cbw, &(cbw->combobox.xevent), False);
    cbw->combobox.IgnoreFocusOut  = False;
    cbw->combobox.PendingFocusOut = False;
    return True; /* diese Routine wird nicht mehr benoetigt. */
} /* DelayedFocusOutWorkProc */

static void EditFocusCallback(Widget w, XtPointer pClientData, 
                              XmAnyCallbackStruct *info)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);

    if ( cbw->combobox.StaticList ) return;
        
    if ( info->reason == XmCR_LOSING_FOCUS ) {
        LOG2("EditFocusCallback: PendingFocusOut: %s, ", 
             cbw->combobox.PendingFocusOut ? "True" : "False");
        LOG3("mode: %i, detail: %i, ", (int)info->event->xcrossing.mode,
                                       (int)info->event->xcrossing.detail);
        LOG2("PendingOverrideInOut: %s\n",
             cbw->combobox.PendingOverrideInOut ? "True" : "False");
        if ( !cbw->combobox.PendingFocusOut &&
             !cbw->combobox.PendingOverrideInOut ) {
            /* Normalerweise duerfen aber keine NULL-Events hier
             * vorbeikommen...aber man weiss ja nie so genau und
             * sicher ist sicher. Defensiv programmieren!
             */
            if ( info->event )
                cbw->combobox.xevent = *info->event;
            cbw->combobox.WorkProcID = XtAppAddWorkProc(
                             XtWidgetToApplicationContext((Widget) cbw),
                             (XtWorkProc) DelayedFocusOutWorkProc,
                             (XtPointer) cbw);
            cbw->combobox.PendingFocusOut = True;
        }
        cbw->combobox.PendingOverrideInOut = False;
    }
} /* EditFocusCallback */

/* --------------------------------------------------------------------
 * Hier wird der angegebene Eintrag in der Listbox der Combo-Box
 * markiert und zudem in den sichtbaren Bereich gerollt, sollte er
 * sich ausserhalb des dargestellten Bereichs der Liste befinden.
 * Parameter:
 *   w              Die Combo-Box (ueblicher Parameter)
 *   Index          Index des neu zu markierenden Eintrages.
 *   Notify         Schickt Mitteilung via Callback
 * Ergebnis:
 *   Index des markierten Eintrages oder 0, falls die Listbox leer
 *   war und deshalb auch kein Eintrag markiert werden konnte.
 */
static int SetSelectionPos(XmComboBoxWidget w, int Index, Boolean Notify)
{
    Widget ListBox = w->combobox.ListCtrl;
    int            ItemCount;      /* Anzahl Eintraege in Listbox   */
    int            TopItem, VisibleItems;
     
    XtVaGetValues(ListBox, XmNitemCount,        &ItemCount, 
                           XmNtopItemPosition,  &TopItem, 
                           XmNvisibleItemCount, &VisibleItems,
                           NULL);
    if ( Index < 1         ) Index = 1;
    if ( Index > ItemCount ) Index = ItemCount;
    if ( Index != 0 && ItemCount != 0 ) {
        if ( Index < TopItem )
            XmListSetPos(ListBox, Index);
        if ( Index >= TopItem + VisibleItems )
            XmListSetBottomPos(ListBox, Index);
        XmListSelectPos(ListBox, Index, Notify);
        return Index;
    } else
        return 0;
} /* SetSelectionPos */

/* --------------------------------------------------------------------
 * Diese Routine kuemmert sich darum, denjenigen Eintrag aus der List-
 * box mit der angegebenen Nummer herauszufischen und an die Eingabe-
 * zeile zu uebergeben. Dabei wird der Index auf den Eintrag auto-
 * matisch auf den zulaessigen Bereich begrenzt. Zugleich wird auch
 * noch der angegebene Eintrag in der Listbox markiert.
 */
static void TransferToEditCtrl(XmComboBoxWidget w, int SelectionIndex, 
                               Boolean MayWipeOut)
{
    Widget ListBox = w->combobox.ListCtrl;
    XmStringTable  Items;
    char           *pItemText;
    
    XtVaGetValues(ListBox, XmNitems, &Items, NULL);
    
    if ( MayWipeOut &&
         (SelectionIndex == w->combobox.LastSelection) &&
         (w->combobox.SelectionPolicy == XmSINGLE_SELECT) ) {
        SelectionIndex = 0;
    }
    
    if ( (SelectionIndex == 0) && 
         (w->combobox.SelectionPolicy == XmSINGLE_SELECT) ) {
        XmListDeselectAllItems(w->combobox.ListCtrl);
        w->combobox.PassVerification = True;
        XmTextFieldSetString(w->combobox.EditCtrl, "");
    } else {
        SelectionIndex = SetSelectionPos(w, SelectionIndex, False);
        if ( SelectionIndex > 0 ) {
            XmStringGetLtoR(Items[SelectionIndex-1], 
                            XmSTRING_DEFAULT_CHARSET, &pItemText);
            w->combobox.PassVerification = True;
            XmTextFieldSetString(w->combobox.EditCtrl, pItemText);
            XtFree(pItemText);
        }
    }
    w->combobox.LastSelection = SelectionIndex;
} /* TransferToEditCtrl */

/* --------------------------------------------------------------------
 * Alle registrierten Callbacks bei Anwahl eines neuen Eintrages in
 * der Listbox aktivieren.
 */
static void CallSelectionCBL(XmComboBoxWidget w, XEvent *Event)
{
    int index;
    
    index  = XmComboBoxGetSelectedPos((Widget) w);
    /*
     * Wenn momentan KEIN Eintrag selektiert ist, dann rufe den neuen
     * XmNunselectionCallback auf!
     */
    if ( index == 0 ) {
        XmComboBoxUnselectionCallbackStruct info;
        
        info.reason = XmCR_UNSELECT;
        info.event  = Event;
        XtCallCallbacks((Widget) w, XmNunselectionCallback, (XtPointer) &info);
    } else {
    /*
     * Ansonsten den ueblichen SelectionCallback!
     */
        XmComboBoxSelectionCallbackStruct info;
        XmStringTable                     Items;

        info.reason = w->combobox.SelectionPolicy == XmSINGLE_SELECT ? 
                            XmCR_SINGLE_SELECT : XmCR_BROWSE_SELECT;
        info.event  = Event;
        info.index  = index;
        XtVaGetValues(w->combobox.ListCtrl, XmNitems, &Items, NULL);
        info.value  = Items[info.index-1];
        XtCallCallbacks((Widget) w, XmNselectionCallback, (XtPointer) &info);
    }
} /* CallSelectionCBL */

/* --------------------------------------------------------------------
 * Hier laeuft das Tastatur-Management fuer die ComboBox zusammen.
 * ACHTUNG: Der 'w'-Parameter wird nur benoetigt, um das eigentliche
 * ComboBox-Widget zu ermitteln. Er muss daher die ID eines direkten
 * Kinds der ComboBox enthalten!
 */
static void CBoxManager(Widget w, XEvent *Event, String *params, 
                        Cardinal *num_params)
{
    XmComboBoxWidget cbw;
    Widget           ListBox;
    int              *SelectionList;
    int              SelectionCount;
    int              SelectionIndex; /* Wer denn nun markiert wird... */
    int              ItemCount;      /* Anzahl Eintraege in Listbox   */
    int              VisibleItems;   /* Hoehe der Liste in Eintraegen */
    char             opt;
    
    /*
     * Nur wenn eine der Translationen page-up und page-down direkt im
     * Listenfeld ausgeloest wurden, wird auch als "w" die Liste ueber-
     * geben. Bei allen anderen Faellen ist dieses zumeist das TextField.
     */
    if ( XtClass(w) == xmListWidgetClass )
        cbw = (XmComboBoxWidget) XtParent(XtParent(w));
    else
        cbw = (XmComboBoxWidget) XtParent(w);
    ListBox = cbw->combobox.ListCtrl;
    
    switch ( *(params[0]) ) {
/* --------------------------------------------------------------------
 * Klappe die Liste auf Wunsch des Benutzers aus oder wieder ein.
 */
    case 's': /* show-hide-list */
        ShowHideDropDownList(cbw, Event, 
                             (Boolean)(!cbw->combobox.ListVisible));
        break;
    case 'h': /* hide-list */
        ShowHideDropDownList(cbw, Event, False);
        break;
/* --------------------------------------------------------------------
 * Hier werden die Bewegungen in der Listbox behandelt.
 */
    case 'u': /* up                */
    case 'd': /* down              */
    case 't': /* top               */
    case 'b': /* bottom            */
    case 'p': /* page-up/page-down */
        opt = *(params[0]);
        XtVaGetValues(ListBox, XmNitemCount,        &ItemCount, 
                               XmNvisibleItemCount, &VisibleItems, NULL);
        if ( XmListGetSelectedPos(ListBox,
                                  &SelectionList, &SelectionCount) ) {
            SelectionIndex = *SelectionList;
            XtFree((char *)SelectionList);
            switch ( opt ) {
                case 'u': SelectionIndex--;               break;
                case 'd': SelectionIndex++;               break;
                case 't': SelectionIndex = 1;             break;
                case 'b': SelectionIndex = ItemCount;     break;
                case 'p': if ( *(params[0]+5) == 'u' )
                              SelectionIndex -= VisibleItems;
                          else
                              SelectionIndex += VisibleItems;
                          break;
            }
        } else { /* momentan noch kein Eintrag in der Liste ausgewaehlt */
            if ( opt == 'b' ) SelectionIndex = ItemCount;
            else              SelectionIndex = 1; /* nun ersten Eintrag nehmen */
        }
        TransferToEditCtrl(cbw, SelectionIndex, False);
        CallSelectionCBL(cbw, Event);
        break;
/* --------------------------------------------------------------------
 * Der Benutzer hat die Eingabetaste gedrueckt oder einen Eintrag in
 * der Listbox angeklickt.
 */
    case 'a': /* Return = activate */
    case 'S': /* Selection */
        if ( !cbw->combobox.StaticList && !cbw->combobox.ListVisible ) break;
        XtVaGetValues(ListBox, XmNitemCount, &ItemCount, NULL);
        if ( ItemCount == 0 ) break;
        if ( XmListGetSelectedPos(ListBox,
                                  &SelectionList, &SelectionCount) ) {
            SelectionIndex = *SelectionList;
            XtFree((char *)SelectionList);
        } else {
            if ( cbw->combobox.SelectionPolicy != XmSINGLE_SELECT )
                SelectionIndex = 1;
            else
                SelectionIndex = 0;
        }
        
        TransferToEditCtrl(cbw, SelectionIndex, 
            *(params[0]) == 'S');
        CallSelectionCBL(cbw, Event);
        ShowHideDropDownList(cbw, Event, (Boolean)
                              (*(params[0]) == 'S' ? True : False));
        break;
/* --------------------------------------------------------------------
 * Der Benutzer hat die ESC-Taste gedrueckt. Ist die Liste zu diesem
 * Zeitpunkt noch ausgeklappt, so wird sie einfach nur eingeklappt und
 * weiter passiert nichts. Ist die Liste jedoch eingeklappt, so wird
 * das ESC an die normale Action-Routine des Eingabefeldes weiter-
 * gegeben, damit damit bspw. Dialog u.a. abgebrochen werden koennen.
 */
    case 'c': /* Cancel */
        if ( cbw->combobox.ListVisible )
            ShowHideDropDownList(cbw, Event, False);
        else
            XtCallActionProc(cbw->combobox.EditCtrl, 
                             "process-cancel", Event, NULL, 0);
        break;
/* --------------------------------------------------------------------
 * Wenn es erlaubt ist, dass auch einmal kein Eintrag in einer ComboBox
 * mit nicht editierbarem Eingabefeld ausgewaehlt ist, dann darf der
 * Anwender mittels osfDelete den aktuellen Eintrag deselektieren.
 */
    case 'w': /* wipe */
        if ( cbw->combobox.SelectionPolicy == XmSINGLE_SELECT ) {
            TransferToEditCtrl(cbw, 0, True);
            CallSelectionCBL(cbw, Event);
        }
        break;
/* --------------------------------------------------------------------
 * Dummy-Operation
 */
    case 'n': /* no-operation */
        break;
    }
} /* CBoxManager */

/* --------------------------------------------------------------------
 * Der Benutzer hat einen Eintrag in der Listbox angeklickt. Der Ein-
 * fachkeit halber wird einfach nur ein Druecken der Eingabetaste
 * simuliert.
 */
static void ListSelectionCallback(Widget w, XtPointer pClientData, 
                                  XmAnyCallbackStruct *info)
{
    String           paramsMouse[1] = { "a" }, paramsKeyboard[1] = { "S" };
    Cardinal         NumParams = 1;
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;
/* 
 * Wurde der Event durch die Tastatur oder einen Mausklick
 * ausgeloest? Wenn es ein Mausklick auf das Listenfeld war und es
 * sich um ein staendig angezeigtes Listenfeld einer nicht editierbaren
 * ComboBox handelt, dann gib' dem Eingabefeld den Tastaturfokus.
 */
    if ( info->event == NULL )
        CBoxManager(cbw->combobox.EditCtrl, info->event, 
                    paramsKeyboard, &NumParams);
    else {
        CBoxManager(cbw->combobox.EditCtrl, info->event, 
                    paramsMouse, &NumParams);
        if ( !cbw->combobox.StaticList ||
             (cbw->combobox.StaticList && !cbw->combobox.Editable) )
            XmProcessTraversal(cbw->combobox.EditCtrl, 
                               XmTRAVERSE_CURRENT);
    }
} /* ListSelectionCallback */

/* --------------------------------------------------------------------
 * Nach einem Doppelklick innerhalb des Listenfelds wird diese Routine
 * aufgerufen. Zunaechst einmal wird ganz normal wie bei einem ein-
 * fachen Anklicken vorgegangen, danach aber noch der ein spezieller
 * Callback aufgerufen.
 */
static void ListDefaultActionCallback(Widget w, XtPointer pClientData, 
                                      XmAnyCallbackStruct *OldInfo)
{
    XmComboBoxWidget                      cbw = (XmComboBoxWidget) pClientData;
    XmComboBoxDefaultActionCallbackStruct info;
    XmStringTable                         Items;
    
    ListSelectionCallback(w, pClientData, OldInfo);
    info.reason = XmCR_DEFAULT_ACTION;
    info.event  = OldInfo->event;
    info.index  = XmComboBoxGetSelectedPos((Widget) cbw);
    XtVaGetValues(cbw->combobox.ListCtrl, XmNitems, &Items, NULL);
    info.value  = Items[info.index-1];
    XtCallCallbacks((Widget) cbw, XmNdefaultActionCallback, (XtPointer) &info);
} /* ListDefaultActionCallback */


/* --------------------------------------------------------------------
 * Ohweh!! Diese Routine wurde erforderlich, um XmNautomaticSelection
 * zu unterstuetzen. Denn wenn der Benutzer in der Liste herumsucht und
 * automaticSelection 'True' ist, kommt kein Callback-Aufruf mehr, wenn
 * die Maustaste losgelassen wird. Und damit wuessten wir sonst nicht, 
 * wann die Liste einzuklappen ist! Irgendwie wird das alles mit der
 * Zeit immer konfuser und aufwendiger. Wenn das Chaos gequantelt
 * sein sollte, dann muss das Chaos-Quant (sog. 'Chaotonen') aber jede
 * Menge Chaos transportieren!!!
 */
static void Button1UpInList(Widget w, XtPointer pClientData, 
                           XEvent *Event, Boolean *ContDispatch)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) pClientData;

    if ( Event->xbutton.button == Button1 ) {
        if ( cbw->combobox.AutomaticSelection )
            ShowHideDropDownList(cbw, Event, False);
    }
} /* Button1UpInList */

/* --------------------------------------------------------------------
 * Sobald sich irgendetwas im Eingabefeld veraenderte, kommt das
 * TextField-Widget zuerst zu uns gelaufen, um sich unser Okay zu
 * holen. Bei einer nicht editierbaren Combo-Box wird hierueber die
 * Schnellsuche realisiert.
 */
static void EditVerifyCallback(Widget w, XtPointer pClientData, 
                               XmTextVerifyCallbackStruct *info)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);

/* 
 * Sollte gerade dem Eingabefeld Text aus der Listbox einverleibt
 * werden, so duerfen wir hier darueber natuerlich nicht meckern, 
 * sondern unser <<ok>> dazu geben. (D.h. in diesem Fall haben wir
 * kein Recht, zu intervenieren.)
 */
    if ( cbw->combobox.PassVerification ) {
        cbw->combobox.PassVerification = False;
        info->doit = True;
        return;
    }
/* 
 * Ist es eine Combo-Box, in die kein Text vom Benutzer eingegeben
 * werden kann, so wird bei der Eingabe von Zeichen die Schnellsuche
 * ausgeloest.
 */
    if ( !cbw->combobox.Editable ) {
        Widget         ListBox = cbw->combobox.ListCtrl;
        char           WarpCharLow, WarpCharHigh;
        XmString       Item;
        XmStringTable  Items;
        int            *SelectionList;
        int            SelectionCount;
        int            i, ItemCount, Start;
        char           *pItem;
        Boolean        Ignore;
        
        info->doit = False;
        if ( (info->text         == NULL ) ||
             (info->text->length == 0    ) ) return; /* Hoppala! */
/* 
 * Nun aus dem Zeichen einen String (Motif-like) basteln und
 * in der Listbox danach auf die Suche gehen.
 */
        if ( info->text->length > 1 ) {
            /* Das ist nun endweder ein normaler Paste, oder aber
             * das Ergebnis einer Drag'n'Drop-Operation.
             */
            Item = XmStringCreateSimple(info->text->ptr);
            XmComboBoxSelectItem((Widget) cbw, Item, True);
            XmStringFree(Item);
        } else {
            /* Ansonsten soll nur eine Schnellsuche ausgefuehrt
             * werden, der entsprechende Buchstabe ist das einzige 
             * Zeichen im dem Callback uebergebenen Text.
             */
            WarpCharLow  = tolower(*(info->text->ptr));
            WarpCharHigh = toupper(WarpCharLow);

            XtVaGetValues(ListBox, XmNitemCount, &ItemCount, 
                                   XmNitems,     &Items,  
                                   NULL);
            if ( ItemCount < 1 ) return;
            /* Ermittele, wo's los geht mit der Suche... */
            if ( XmListGetSelectedPos(ListBox, 
                                      &SelectionList, &SelectionCount) ) {
                Start = *SelectionList; i = Start + 1;
                XtFree((char *)SelectionList);
            } else i = Start = 1;
        
            if ( i > ItemCount ) i = 1;
            Ignore = True;
            while ( i != Start || Ignore ) {
                Ignore = False;
                XmStringGetLtoR(Items[i-1], XmSTRING_DEFAULT_CHARSET, 
                                &pItem);
                if ( (strchr(pItem, WarpCharLow ) == pItem) ||
                     (strchr(pItem, WarpCharHigh) == pItem) ) { 
                    XtFree(pItem);
                    TransferToEditCtrl(cbw, i, False);
                    CallSelectionCBL(cbw, info->event);
                    break;
                }
                XtFree(pItem);
                if ( ++i > ItemCount ) i = 1;
            }
        }
    } else {
/*
 * Wenn das Eingabefeld editierbar ist, dann fragen wir ueber die Callbacks
 * nach, ob es genehm ist, den neuen Text einzufuegen.
 */
        XtCallCallbacks((Widget) cbw, XmNmodifyVerifyCallback, 
                        (XtPointer) info);
    }
} /* EditVerifyCallback */

/* --------------------------------------------------------------------
 * Dieser Callback wird immer dann aufgerufen, wenn in einer ComboBox
 * mit einem veraenderlichem Eingabefeld der Eingabetext veraendert
 * wurde. In diesem Fall suchen wir hier nach einem passenden gleich-
 * lautenden Eintrag. Wenn wir einen finden, heben wir ihn in der Liste
 * sogleich hervor, ansonsten ist kein Eintrag hervorgehoben.
 */
static void EditChangedCallback(Widget w, XtPointer pClientDate, 
                                XmAnyCallbackStruct *info)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);
    XmStringTable    Items;
    int              ItemCount, i;
    XmString         EditStr;
    String           EditLine;
    
    /*
     * Zuerst nach einem passenden Eintrag zum Eingabefeld in der Liste
     * suchen...
     */
    XtVaGetValues(cbw->combobox.EditCtrl, XmNvalue, &EditLine, NULL);
    XtVaGetValues(cbw->combobox.ListCtrl, 
                  XmNitemCount, &ItemCount, 
                  XmNitems,     &Items, 
                  NULL);
    EditStr = XmStringCreateSimple(EditLine);
    XtVaSetValues(cbw->combobox.ListCtrl, XmNselectedItemCount, 0, NULL);
    if ( ItemCount < 1 ) return;
    for ( i = 0; i < ItemCount; i++ )
        if ( XmStringCompare(Items[i], EditStr) ) {
            SetSelectionPos(cbw, i+1, False);
            break;
        }
    XmStringFree(EditStr);
    /*
     * Zum Abschluss noch den Callback aufrufen...
     */
    XtCallCallbacks((Widget) cbw, XmNvalueChangedCallback, (XtPointer) info);
} /* EditChangedCallback */

/* --------------------------------------------------------------------
 * Dieser Callback wird immer dann aufgerufen, wenn in einer ComboBox
 * mit einem veraenderlichem Eingabefeld der Cursor bewegt wurde.
 * Dieser Callback ist nur fuer echte Fans von Callbacks da...
 */
static void MotionVerifyCallback(Widget w, XtPointer pClientDate, 
                                 XmTextVerifyCallbackStruct *info)
{
    XmComboBoxWidget cbw = (XmComboBoxWidget) XtParent(w);

    XtCallCallbacks((Widget) cbw, XmNmotionVerifyCallback, (XtPointer) info);
} /* MotionVerifyCallback */

/* --------------------------------------------------------------------
 * Bastele einen vollstaendigen Namens- und Klassenbezeichner anhand
 * des angegebenen Widgets zusammen.
 */
static void MakeNameAndClass(Widget w, char *NameBuff, char *ClassBuff)
{
    Widget Parent = XtParent(w);
    
    if ( Parent ) MakeNameAndClass(Parent, NameBuff, ClassBuff);
    if ( XtIsSubclass(w, applicationShellWidgetClass) ) {
        /* Wenn wir ganz oben angekommen sind, holen wir uns den
         * Namen und die Klasse der Applikation selbst und nicht die
         * des Widgets.
         */
        String AppName, AppClass;
        XtGetApplicationNameAndClass(
            XtDisplayOfObject(w), &AppName, &AppClass);
        strcpy(NameBuff, AppName);
        strcpy(ClassBuff, AppClass);
    } else {
        /* Ansonsten sind wir noch mitten irgendwo in der Hierarchie
         * und besorgen uns den Namen und die Klasse dieses Widgets
         */
        strcat(NameBuff,  "."); 
        strcat(NameBuff,  XtName(w));
        strcat(ClassBuff, "."); 
        strcat(ClassBuff, ((CoreClassRec *) XtClass(w))->core_class.class_name);
    }
} /* MakeNameAndClass */

/* --------------------------------------------------------------------
 * Eine einzelne Resource aus der Datenbank herausholen. Diese Resource
 * kommt im Allgemeinen immer als String zurueck und muss daher erst
 * noch in das gewuenschte Zielformat konvertiert werden.
 */
static Boolean FetchResource(Widget w, 
                             char *FullName, char *FullClass, 
                             char *RscName, char *RscClass, 
                             XrmValue *RscValue, 
                             String   *RepresentationType)
{
    Boolean ok;
    char *EndOfName  = FullName  + strlen(FullName);
    char *EndOfClass = FullClass + strlen(FullClass);
    
    strcat(FullName,  "."); strcat(FullName,  RscName);
    strcat(FullClass, "."); strcat(FullClass, RscClass);
    ok = XrmGetResource(
        XtDatabase(XtDisplayOfObject(w)), 
        FullName, FullClass, RepresentationType, RscValue);
    /* Wieder den alten Namens- und Klassenrumpf herstellen */
    *EndOfName = 0; *EndOfClass = 0;
    return ok;
} /* FetchResource */

/* --------------------------------------------------------------------
 * Nun folgen diejenigen Routinen, mit denen die Konvertierung in das
 * gewuenschte Zielformat einer Resource moeglich ist.
 * Verfuegbar:
 *   String --> Int
 *   String --> Short
 *   String XmPIXMAP / XmSTRING --> unsigned char
 *   String --> Dimension
 *   String --> XmString
 *   String --> XmStringTable
 *   String --> XmFontList
 *   String --> Pixmap (genauer: Bitmap)
 *   String --> String
 *   String --> KeySym
 */
static Boolean FetchIntResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                int *pInt)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(int);
        RscDest.addr = (caddr_t) pInt;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XtRInt, &RscDest) )
            return True;
    }
    return False;
} /* FetchIntResource */

static Boolean FetchShortResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                short *pShort)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(short);
        RscDest.addr = (caddr_t) pShort;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XtRShort, &RscDest) )
            return True;
    }
    return False;
} /* FetchShortResource */

static Boolean FetchLabelTypeResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                unsigned char *pUChar)
{
    XrmValue RscValue;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        if ( strcasecmp((char *) RscValue.addr, "XmPIXMAP") == 0 )
            *pUChar = XmPIXMAP;
        else
            *pUChar = XmSTRING;
        return True;
   }
    return False;
} /* FetchLabelTypeResource */

static Boolean FetchDimensionResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                Dimension *pDimension)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(Dimension);
        RscDest.addr = (caddr_t) pDimension;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XtRDimension, &RscDest) )
            return True;
    }
    return False;
} /* FetchDimensionResource */

static Boolean FetchStringResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                String *pString)
{
    XrmValue RscValue;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        *pString = (char *) RscValue.addr;
        return True;
    }
    return False;
} /* FetchStringResource */

static Boolean FetchKeySymResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                KeySym *pKeySym)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(KeySym);
        RscDest.addr = (caddr_t) pKeySym;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XmRKeySym, &RscDest) )
            return True;
    }
    return False;
} /* FetchKeySymResource */

static Boolean FetchXmStringResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                XmString *pString)
{
    XrmValue RscValue;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        *pString = XmCvtCTToXmString((char *) RscValue.addr);
        return True;
    }
    return False;
} /* FetchXmStringResource */

static Boolean FetchXmStringTableResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                XmStringTable *pStringTable, 
                                int *pTableSize)
{
    XrmValue RscValue;
    String   RepresentationType;
    String   TmpList, p, pStart;
    int      Entries, Entry;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        /* 
         * Zuerst eine Kopie erzeugen und dann daraus die Liste
         * zusammenbasteln.
         */
        TmpList = XtNewString((String)RscValue.addr);
        if ( TmpList == NULL ) return False;
        if ( *TmpList == 0 ) { XtFree(TmpList); return False; }
        /* Ermittele, wieviele Eintrage in der Liste sind und
         * erstelle dann daraus die Liste.
         */
        Entries = 1; p = TmpList;
        while ( *p )
            if ( *p++ == ',' ) ++Entries;
        *pStringTable = (XmStringTable) 
            XtMalloc(Entries * sizeof(XmString));
        
        p = TmpList;
        for ( Entry = 0; Entry < Entries; ++Entry ) {
            pStart = p;
            while ( (*p != 0) && (*p != ',') ) ++p;
            *p++ = 0;
            (*pStringTable)[Entry] = (XmString)
                XmStringCreateSimple(pStart);
        }
        /* Hier geht ausnahmsweise einmal Rueckgabe vor
         * Entschaedigung... hey, das war doch nur ein
         * (wenn auch ziemlich miserabler) Scherz
         */
        XtFree(TmpList);
        *pTableSize = Entries;
        return True;
    }
    return False;
} /* FetchXmStringTableResource */

static Boolean FetchXmFontListResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass, 
                                XmFontList *pFontList)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(XmFontList);
        RscDest.addr = (caddr_t) pFontList;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XmRFontList, &RscDest) )
            return True;
    }
    return False;
} /* FetchXmFontListResource */

static Boolean FetchPixmapResource(Widget w, 
                                char *FullName, char *FullClass, 
                                char *RscName, char *RscClass,
                                Pixmap *pPixmap)
{
    XrmValue RscValue, RscDest;
    String   RepresentationType;
    
    if ( FetchResource(w, FullName, FullClass, 
                       RscName, RscClass, 
                       &RscValue, &RepresentationType) ) {
        RscDest.size = sizeof(Pixmap);
        RscDest.addr = (caddr_t) pPixmap;
        if ( XtConvertAndStore(w, RepresentationType, &RscValue, 
                               XtRBitmap, &RscDest) )
            return True;
    }
    return False;
} /* FetchPixmapResource */

/* --------------------------------------------------------------------
 * Waehrend der Initialisierung alle gespiegelten Resourcen, fuer die
 * Eintraege in der Resourcen-Datenbank existieren an die passenden
 * Kinder-Widgets weiterleiten. Der Trick an der Sache: wir setzen
 * die betroffenen Resourcen vie XtSetValues mit uns selbst als Ziel.
 * Dadurch bekommt SetValues die Arbeit aufgehalst, die Resourcen den
 * richtigen Kindern zuzuordnen...
 */

#define RInt            0
#define RShort          1
#define RLType          2
#define RDimension      3       
#define RXmString       4
#define RPixmap         5
#define RXmFontList     6
#define RKeySym         7
#define RString         8
#define RXmStringTable  9
#define RXmItemCount    10


typedef struct
{
    String Name, Class;

    int Converter;
    
} RESOURCEMIRROR;

static RESOURCEMIRROR ResourceMirror[] = {
    { XmNblinkRate,              XmCBlinkRate,              RInt,          }, 
    { XmNcolumns,                XmCColumns,                RShort,        }, 
    { XmNmaxLength,              XmCMaxLength,              RInt,          }, 
    { XmNmarginHeight,           XmCMarginHeight,           RDimension     }, 
    { XmNmarginWidth,            XmCMarginWidth,            RDimension     },
    { XmNselectThreshold,        XmCSelectThreshold,        RInt           }, 
     
    { XmNlistMarginHeight,       XmCListMarginHeight,       RDimension     }, 
    { XmNlistMarginWidth,        XmCListMarginWidth,        RDimension     }, 
    { XmNlistSpacing,            XmCListSpacing,            RDimension     },
    { XmNitems,                  XmCItems,                  RXmStringTable },
    { XmNitemCount,              XmCItemCount,              RXmItemCount   },
    
    { XmNmnemonic,               XmCMnemonic,               RKeySym        }, 
    { XmNmnemonicCharSet,        XmCMnemonicCharSet,        RString        }, 
    { XmNlabelString,            XmCLabelString,            RXmString      }, 
    { XmNlabelMarginBottom,      XmCLabelMarginBottom,      RDimension     }, 
    { XmNlabelMarginHeight,      XmCLabelMarginHeight,      RDimension     }, 
    { XmNlabelMarginLeft,        XmCLabelMarginLeft,        RDimension     }, 
    { XmNlabelMarginRight,       XmCLabelMarginRight,       RDimension     }, 
    { XmNlabelMarginTop,         XmCLabelMarginTop,         RDimension     }, 
    { XmNlabelMarginWidth,       XmCLabelMarginWidth,       RDimension     }, 
    { XmNlabelPixmap,            XmCLabelPixmap,            RPixmap        },
    { XmNlabelInsensitivePixmap, XmCLabelInsensitivePixmap, RPixmap        }, 
    { XmNlabelType,              XmCLabelType,              RLType         }, 
    { XmNlabelFontList,          XmCLabelFontList,          RXmFontList    }, 
};

static void InitMirrorResources(XmComboBoxWidget w)
{
    char          FullName[1024], FullClass[1024];
    int           AInt, TableSize;
    short         AShort;
    unsigned char AUChar;
    Dimension     ADimension;
    XmString      AXmString;
    XmStringTable AStringTable;
    Pixmap        APixmap;
    XmFontList    AFontList;
    String        AString;
    KeySym        AKeySym;
    int           i, size = XtNumber(ResourceMirror);
    
    FullName[0] = 0; FullClass[0] = 0;
    MakeNameAndClass((Widget) w, FullName, FullClass);

    for ( i=0; i < size; i++ ) {
        switch ( ResourceMirror[i].Converter ) {
            case RInt:
                if ( FetchIntResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AInt) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AInt, NULL);
                break;
            case RXmItemCount:
                if ( FetchIntResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AInt) && ( AInt != 0) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AInt, NULL);
                break;
            case RShort:
                if ( FetchShortResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AShort) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AShort, NULL);
                break;
            case RLType:
                if ( FetchLabelTypeResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AUChar) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AUChar, NULL);
                break;
            case RDimension:
                if ( FetchDimensionResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &ADimension) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  ADimension, NULL);
                break;
            case RXmString:
                if ( FetchXmStringResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AXmString) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AXmString, NULL);
                break;
            case RXmStringTable:
                if ( FetchXmStringTableResource((Widget) w,
                         FullName, FullClass,
                         ResourceMirror[i].Name, ResourceMirror[i].Class,
                         &AStringTable, &TableSize) ) {
                    XtVaSetValues((Widget) w, 
                         XmNitems, (XtPointer) AStringTable, 
                         XmNitemCount, TableSize, NULL);
                }
                break;
            case RKeySym:
                if ( FetchKeySymResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AKeySym) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AKeySym, NULL);
                break;
            case RString:
                if ( FetchStringResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &AString) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  AString, NULL);
                break;
            case RPixmap:
                if ( FetchPixmapResource((Widget) w, 
                        FullName, FullClass, 
                        ResourceMirror[i].Name, ResourceMirror[i].Class, 
                        &APixmap) ) {
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name, 
                                  APixmap, NULL);
                    if ( strcmp(ResourceMirror[i].Name, XmNlabelPixmap) == 0 )
                        w->combobox.ConvertBitmapToPixmap = True;
                    else
                        w->combobox.ConvertBitmapToPixmapInsensitive = True;
                }
                break;
            case RXmFontList:
                if ( FetchXmFontListResource((Widget) w,
                       FullName, FullClass,
                       ResourceMirror[i].Name, ResourceMirror[i].Class,
                       &AFontList) )
                    XtVaSetValues((Widget) w, ResourceMirror[i].Name,
                                  AFontList, NULL);
                break;
        }
    }
} /* InitMirrorResources */

/* --------------------------------------------------------------------
 * Wandelt ein 1-Bit tiefes Bitmap in ein n-Bit tiefes Pixmap um, dass
 * die gleiche Tiefe besitzt, wie der Bildschirm, auf dem das Pixmap
 * spaeter erscheinen soll.
 */
static Pixmap BitmapToPixmap(XmComboBoxWidget w, 
                           String Resource, GC ColorGC)
{
    Pixmap       LabelPixmap, LabelBitmap;
    Display      *display = XtDisplay(w);
    Window       root;
    int          PixX, PixY;
    unsigned int PixW, PixH, PixBW, PixDepth;

    XtVaGetValues(w->combobox.LabelCtrl, Resource, &LabelBitmap, NULL);
    XGetGeometry(display, LabelBitmap, &root, 
                 &PixX, &PixY, &PixW, &PixH, &PixBW, &PixDepth);
    LabelPixmap = XCreatePixmap(
                        display, RootWindowOfScreen(XtScreen(w)), 
                        PixW, PixH, 
                        (w->combobox.LabelCtrl)->core.depth);
    XCopyPlane(display, LabelBitmap, LabelPixmap, 
               ColorGC, 0, 0, PixW, PixH, 0, 0, 1);
    XtVaSetValues(w->combobox.LabelCtrl, Resource, LabelPixmap, NULL);
    XFreePixmap(display, LabelBitmap);
    return LabelPixmap;
} /* BitmapToPixmap */

/* --------------------------------------------------------------------
 * Alles initialisieren, sobald das Widget eingerichtet wird. Das sagt
 * sich hier so einfach, ist es aber *definitiv* nicht!!!!
 */
static void Initialize(Widget request, XmComboBoxWidget newW, 
                       ArgList wargs, Cardinal *ArgCount)
{
    Dimension    width, height, dummy;
    Widget       w;
    Arg          args[10];
    int          n = 0;
    
/* 
 * Da zu allem Ueberfluss die einzelnen Instanzen einer XmComboBox
 * auf verschiedenen Displays auftauchen koennen, wird hier:
 * 1. pro Widget ein eigener Cursor erzeugt (benoetigt fuer die Liste)
 * 2. pro Widget (hier = pro Applikation) die benoetigte Action-Routine
 * registiert. Doppelte Registrierung macht dem Toolkit nichts aus, da es
 * dann eine evtl. aeltere Definition loescht.
 */
    XtAppAddActions(XtWidgetToApplicationContext((Widget) newW), 
                        actions, XtNumber(actions));
    
/* Allgemeine Initialisierungen... */
    newW->combobox.ConvertBitmapToPixmap            = False;
    newW->combobox.ConvertBitmapToPixmapInsensitive = False;
    
    newW->combobox.LastSelection                    = 0;
    
    newW->combobox.InInit                           = True;
    
/* 
 * Das folgende Problem mit der Kontrolle, ob sich das Widget absolut auf
 * dem Bildschirm verschoben hat, trifft uns nur, wenn die Liste nicht
 * dauernd auf dem Bildschirm erscheint:
 * Lass' dich benachrichtigen, sobald dieses Widget in irgendeiner
 * Form bewegt wird -- und sei es nur, dass das gesamte Applikations-
 * fenster umhergeschoben wurde. Um die Benachrichtigung ueberhaupt
 * zu erreichen, ist es erforderlich, sich benachrichtigen zu lassen, 
 * sobald die naechste Shell (oder ein Nachkomme) im Widget-Instanzen-
 * Baum verschoben wurde.
 */
    if ( !newW->combobox.StaticList ) {
        w = (Widget) newW;
        while ( !XtIsSubclass(w, shellWidgetClass) )
            w = XtParent(w);
        newW->combobox.MyNextShell = w;
        XtAddEventHandler(w, 
                          StructureNotifyMask | FocusChangeMask, 
                          False, (XtEventHandler) ShellCallback, 
                          (XtPointer) newW);
    }
 
/* Richte nun alle zu diesem Widget gehoerenden Kinder ein, als da
 * waeren:
 * 1 x editierbares Eingabefeld
 * 1 x ein Pfeil nach unten
 * 1 x ein Schriftfeld
 */
    newW->combobox.EditCtrl = XtVaCreateManagedWidget(
        "edit", xmTextFieldWidgetClass, (Widget) newW,
        XmNverifyBell, False, 
        NULL);
    XtAddCallback(newW->combobox.EditCtrl, 
                  XmNlosingFocusCallback, 
                  (XtCallbackProc) EditFocusCallback, NULL);
    XtAddCallback(newW->combobox.EditCtrl, 
                  XmNmodifyVerifyCallback, 
                  (XtCallbackProc) EditVerifyCallback, NULL);
    XtAddCallback(newW->combobox.EditCtrl, 
                  XmNvalueChangedCallback, 
                  (XtCallbackProc) EditChangedCallback, NULL);
    XtAddCallback(newW->combobox.EditCtrl, 
                  XmNhelpCallback, 
                  (XtCallbackProc) HelpCallback, 
                  (XtPointer) newW);
    XtAddCallback(newW->combobox.EditCtrl, 
                  XmNactivateCallback, 
                  (XtCallbackProc) ActivateCallback, 
                  (XtPointer) newW);
    if ( newW->combobox.Editable )
        XtAddCallback(newW->combobox.EditCtrl, 
                      XmNmotionVerifyCallback, 
                      (XtCallbackProc) MotionVerifyCallback, 
                      (XtPointer) newW);
/* Neue Translations fuer das Eingabefeld aufnehmen */
    XtOverrideTranslations(newW->combobox.EditCtrl, 
                           NewEditTranslations);
    if ( !newW->combobox.Editable ) {
        XtOverrideTranslations(newW->combobox.EditCtrl, 
                               NewEditTranslationsNE);
        XtVaSetValues(newW->combobox.EditCtrl, 
                      XmNcursorPositionVisible, False, NULL);
    }
#ifdef NODRAGNDROP
    XtOverrideTranslations(newW->combobox.EditCtrl, 
                           NewListTranslations); /* Btn2Dwn aus! */
#endif

/* --- */
    newW->combobox.ArrowCtrl = XtVaCreateManagedWidget(
        "arrow", xmArrowButtonWidgetClass, (Widget) newW, 
        XmNarrowDirection,     XmARROW_DOWN, 
        XmNtraversalOn,        False, 
        XmNnavigationType,     XmNONE,
        XmNborderWidth,        0, 
        XmNhighlightThickness, 0, 
        NULL);
    XmRemoveTabGroup(newW->combobox.ArrowCtrl);
    if ( newW->combobox.StaticList ) {
        XtVaSetValues(newW->combobox.ArrowCtrl, 
            XmNmappedWhenManaged, False, NULL);
    } else {
        XtAddEventHandler(newW->combobox.ArrowCtrl, 
                          EnterWindowMask | LeaveWindowMask,
                          False, (XtEventHandler) ArrowCrossingCallback,
                          (XtPointer) newW);
        XtAddCallback(newW->combobox.ArrowCtrl, 
                      XmNactivateCallback, 
                      (XtCallbackProc) ArrowCallback, NULL);
        XtAddCallback(newW->combobox.ArrowCtrl, 
                      XmNarmCallback, 
                      (XtCallbackProc) ArrowCallback, NULL);
        XtAddCallback(newW->combobox.ArrowCtrl, 
                      XmNhelpCallback, 
                      (XtCallbackProc) HelpCallback, 
                      (XtPointer) newW);
    }

/* --- */
    newW->combobox.LabelCtrl = XtVaCreateWidget(
        "label", xmLabelWidgetClass, (Widget) newW, 
        XmNstringDirection, newW->manager.string_direction, 
        NULL);
    if ( newW->combobox.ShowLabel ) {
        XtManageChild((Widget) newW->combobox.LabelCtrl);
        XtAddCallback(newW->combobox.LabelCtrl, 
                      XmNhelpCallback, 
                      (XtCallbackProc) HelpCallback, 
                      (XtPointer) newW);
    }

/* 
 * Zuerst noch die Shell erzeugen, die so einfach mir nichts dir nichts
 * frei auf dem Bildschirm herumschweben kann und damit das Ausklappen
 * der Liste erst ermoeglicht -- und uns allerhand Scherereien bereitet!
 * War das ein bloeder Fehler in Motif 1.2! Diese Version vertraegt ab-
 * solut keine ShellWidgetClass noch overrideShellWidgetClass!!!! Naja,
 * mit einer vendorShellWidgetClass laesst sich aber exakt der gleiche
 * Effekt erreichen. NEU: vor allem funktioniert dann endlich auch
 * Drag'n'Drop!!!
 * Noch neuer: Wenn die Liste dauerhaft angezeigt werden muss, entfaellt
 * diese Shell zwangslaeufig. Dann ist das Listenfeld ein direktes Kind
 * der ComboBox.
 */
    if ( !newW->combobox.StaticList ) {
        newW->combobox.PopupShell = XtVaCreateWidget(
            "combobox_shell", vendorShellWidgetClass, (Widget) newW, 
            XmNoverrideRedirect, True,
            XmNsaveUnder,        False,
            XmNallowShellResize, True, 
            NULL);
        XtAddEventHandler(newW->combobox.PopupShell, 
                          EnterWindowMask | LeaveWindowMask, 
                          False, (XtEventHandler) OverrideShellCallback, 
                          (XtPointer) newW);
    } else {
    /*
     * Sieht ja pervers nach einer Rekursion aus...daher: OBACHT!
     */
        newW->combobox.PopupShell = (Widget) newW;
    }

/*
 * Nun kommt die Drop-Down-Liste an die Reihe. Die Liste muss dabei
 * mit einer Convenience-Funktion erstellt werden, damit ein Rollbalken
 * 'dran ist und das Ganze wird dann in eine Override-Shell gepackt.
 * Nicht zu vergessen ist der XtManageChild-Aufruf, damit die Liste
 * sofort nach dem Aufklappen der Shell sichtbar wird.
 */
    XtSetArg(args[n], XmNselectionPolicy, newW->combobox.SelectionPolicy); n++;
    
    if ( !newW->combobox.StaticList ) {
    /*
     * Es gibt halt so eine ganze Reihe von Einstellungen, die koennen nicht
     * veraendert werden, wenn das Listenfeld nur bei Bedarf ausgeklappt wird.
     */
        XtSetArg(args[n], XmNhighlightThickness, 0); n++;
    }
    XtSetArg(args[n], XmNlistSizePolicy, 
                      newW->combobox.ListSizePolicy); n++;
    XtSetArg(args[n], XmNscrollBarDisplayPolicy, 
                      newW->combobox.ScrollBarDisplayPolicy); n++;
    
    XtSetArg(args[n], XmNautomaticSelection, 
                      newW->combobox.AutomaticSelection); n++;
    XtSetArg(args[n], XmNvisibleItemCount, 
                      newW->combobox.VisibleItemCount); n++;
    newW->combobox.ListCtrl = XmCreateScrolledList(
        newW->combobox.PopupShell, "list",  
        args, n);

/*
 * Fuer den Fall, dass die Liste in einer eigenen Shell steckt und daher frei
 * auf dem Bildschirm herumschweben kann, sollten wir sicherheitshalber die
 * Tastaturbedienung (Fokus) abschalten, um Probleme zu vermeiden (jedenfalls
 * hoffentlich...!)
 */
    if ( !newW->combobox.StaticList ) {
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNtraversalOn,  False,  NULL);
        XtVaSetValues(XtParent(newW->combobox.ListCtrl), 
                      XmNtraversalOn, False, NULL);
    } else {
        if ( !newW->combobox.Editable ) {
            XtVaSetValues(XtParent(newW->combobox.ListCtrl), 
                      XmNtraversalOn, False, NULL);
            XmRemoveTabGroup(newW->combobox.ListCtrl);
        }
    }
    
    XtManageChild(newW->combobox.ListCtrl);
    XtAddCallback(newW->combobox.ListCtrl, 
                  XmNsingleSelectionCallback, 
                  (XtCallbackProc) ListSelectionCallback, 
                  (XtPointer) newW);
    XtAddCallback(newW->combobox.ListCtrl, 
                  XmNbrowseSelectionCallback, 
                  (XtCallbackProc) ListSelectionCallback, 
                  (XtPointer) newW);
    XtAddCallback(newW->combobox.ListCtrl, 
                  XmNdefaultActionCallback, 
                  (XtCallbackProc) ListDefaultActionCallback, 
                  (XtPointer) newW);
    XtAddCallback(newW->combobox.ListCtrl, 
                  XmNhelpCallback, 
                  (XtCallbackProc) HelpCallback, 
                  (XtPointer) newW);
    
    XtAddEventHandler(newW->combobox.ListCtrl, 
                      ButtonReleaseMask, 
                      False, (XtEventHandler) Button1UpInList, 
                      (XtPointer) newW);

#ifdef NODRAGNDROP
    XtOverrideTranslations(newW->combobox.ListCtrl, 
                           NewListTranslations);
#endif
    if ( newW->combobox.StaticList && newW->combobox.Editable )
        XtOverrideTranslations(newW->combobox.ListCtrl, 
                               NewListTranslationsE);

/* Jetzt wird es dann erst richtig spannend... Zuerst alle evtl.
 * in der Resource-Datenbank abgelegten Resourcen an die Kinder
 * weitergeben. Danach die uebergebenen Parameter ebenfalls an
 * die Kinder weiterreichen und schliesslich das Layout ermitteln.
 */
    InitMirrorResources(newW);
    UpdateColors(newW, -1);
    SetValues(newW, newW, newW, wargs, ArgCount);
    
    if ( newW->combobox.ConvertBitmapToPixmap ) 
        newW->combobox.LabelPixmap = 
            BitmapToPixmap(newW, XmNlabelPixmap, 
                       ((XmLabelRec *) newW->combobox.LabelCtrl)->
                         label.normal_GC);
    if ( newW->combobox.ConvertBitmapToPixmapInsensitive ) 
        newW->combobox.LabelInsensitivePixmap = 
            BitmapToPixmap(newW, XmNlabelInsensitivePixmap, 
                       ((XmLabelRec *) newW->combobox.LabelCtrl)->
                         label.insensitive_GC);
    
    DefaultGeometry(newW, &width, &height, &dummy, &dummy);
    if ( newW->core.width == 0 )
        newW->core.width  = width;
    if ( newW->core.height == 0 )
        newW->core.height = height;

/*
 * Falls wir keine Fontliste besitzen, dann nehmen wir die von
 * dem Eingabefeld...
 */
    if ( newW->combobox.Font == NULL ) {
        XtVaGetValues(newW->combobox.EditCtrl, 
                      XmNfontList, &newW->combobox.Font, NULL);
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNfontList, newW->combobox.Font, NULL);
    } else {
        XtVaSetValues(newW->combobox.ListCtrl, 
                      XmNfontList, newW->combobox.Font, NULL);
        XtVaSetValues(newW->combobox.EditCtrl, 
                      XmNfontList, newW->combobox.Font, NULL);
    }
    
/* 
 * Initialisiere alle Statusflaggen, die mit diesem unseligen Focus-
 * problem zu tun haben...
 */
    newW->combobox.ListVisible          = False;
    newW->combobox.IgnoreFocusOut       = False;
    newW->combobox.PendingFocusOut      = False;
    newW->combobox.PendingOverrideInOut = False;
    
    newW->combobox.PassVerification = False;

/* 
 * Jooa... bei der OSF pennen die wohl komplett?! Zusammen mit Form-
 * Widgets gibt das wohl immer Aerger...daher hier ein DoLayout()
 * aufrufen, damit Eingabefeld und Pfeil sowie das Listenfeld an der 
 * richtigen Stelle sitzen!
 */
    DoLayout(newW);
/* 
 * Endlich fertig mit der Initialisierung. Das hier ist aber auch
 * wirklich viel Arbeit fuer so ein Widget!
 */    
    newW->combobox.InInit = False;
} /* Initialize */

/* --------------------------------------------------------------------
 * Diese Funktionen bitte nur im aeussersten Notfall benutzen, da sie
 * die Abstraktion dieser neuen Klasse umgehen und Informationen ueber
 * den internen Aufbau voraussetzen.
 */
Widget XmComboBoxGetEditWidget(Widget w)
{
    return ((XmComboBoxWidget) w)->combobox.EditCtrl;
} /* XmComboBoxGetEditWidget */

Widget XmComboBoxGetListWidget(Widget w)
{
    return ((XmComboBoxWidget) w)->combobox.ListCtrl;
} /* XmComboBoxGetListWidget */

Widget XmComboBoxGetLabelWidget(Widget w)
{
    return ((XmComboBoxWidget) w)->combobox.LabelCtrl;
} /* XmComboBoxGetLabelWidget */


/* --------------------------------------------------------------------
 * Sobald sich im Listenfeld Eintraege veraenderten, sei es, dass sie
 * geloescht wurden, sei es, dass sie veraendert wurden, so muss hier
 * gegebenenfalls auch der Text im Eingabefeld angepasst werden.
 * Letzteres betrifft aber nur Combo-Boxen mit nicht editierbarem
 * Eingabefeld. In jedem Fall wird aber bei jeder Combo-Box-Type in
 * dem Fall, dass ein Eintrag geloescht wird, der darauffolgende
 * Eintrag markiert. Eigentlich ist dieses nur eine nette Geste
 * gegenueber dem Benutzer...
 * 
 * Parameter:
 *   w              Combo-Box-Widget
 *   Index          Index auf denjenigen Eintrag der sich geaendert
 *                  hat, oder der geloescht wurde.
 *   Deleted        Zeigt an, ob der Eintrag geloescht wurde (True)
 *                  oder sich nur veraenderte (False)
 */
static int UpdateComboBox(XmComboBoxWidget w, int Index, Boolean Deleted)
{
    int OldIndex, ItemCount;
    
    OldIndex = XmComboBoxGetSelectedPos((Widget) w);
    if ( OldIndex == Index ) {
/* Es betrifft den Eintrag, der auch momentan ausgewaehlt ist.
 * Sollte er geloescht werden, so nimm' (soweit vorhanden) den
 * naechsten Eintrag, wurde er ausgetauscht, so lass ihn ausge-
 * waehlt.
 */
        if ( Deleted ) {
            XtVaGetValues(w->combobox.ListCtrl, 
                          XmNitemCount, &ItemCount, NULL);
            if ( ItemCount != 0 ) {
                if ( Index >= ItemCount ) Index = ItemCount;
                /* Markieren des Eintrags, ohne jedoch jetzt schon
                 * den Eintrag in die Eingabezeile zu kopieren.
                 */
                SetSelectionPos(w, Index, False);
            }
        }
    }
/* Das Problem betrifft uns nur bei nicht editierbaren Combo-Boxen
 * im vollen Umfang. Denn dann muss auch der Text im Eingabefeld
 * veraendert werden.
 */
    if ( !w->combobox.Editable ) {
        TransferToEditCtrl(w, Index, False);
    }

    return 1;
} /* UpdateComboBox */


/* --------------------------------------------------------------------
 * Die Eintragsposition finden, an der der Eintrag sortiert stehen
 * muesste. Naja, es wurde ja 'mal langsam Zeit, diese Routine etwas
 * aufzupolieren, damit sie schneller wird.
 */
static int FindSortedItemPos(XmComboBoxWidget w, XmString item)
{
    Widget                          ListBox = w->combobox.ListCtrl;
    XmStringTable                   Items;
    int                             ItemCount, index, Left, Right, Result;
    char                            *pItemText, *pCompareText;
    Boolean                         ExternSort;
    XmComboBoxSortingCallbackStruct data;
    
    XtVaGetValues(ListBox, XmNitems,     &Items, 
                           XmNitemCount, &ItemCount, NULL);
    if ( ItemCount == 0 ) return 1;
    
    /*
     * Moechte das Programm die Kontrolle ueber den Sortiervorgang
     * uebernehmen? Dann bereite alles vor...
     */
    ExternSort = XtHasCallbacks((Widget) w, XmNsortingCallback) == 
                     XtCallbackHasSome;
    if ( ExternSort ) {
        data.reason    = XmCR_SORTING;
        data.event     = NULL;
        data.operation = XmOP_INIT;
        data.item      = item;
        XtCallCallbacks((Widget) w, XmNsortingCallback, (XtPointer) &data);
    } else
        XmStringGetLtoR(item, XmSTRING_DEFAULT_CHARSET, &pCompareText);

    Left = 0; Right = ItemCount - 1;    
    do {
        index = (Left + Right) / 2;
        if ( ExternSort ) {
            data.operation = XmOP_COMPARE;
            data.item      = Items[index];
            data.result    = 1;
            XtCallCallbacks((Widget) w, XmNsortingCallback, (XtPointer) &data);
            Result = data.result;
        } else {
            XmStringGetLtoR(Items[index], XmSTRING_DEFAULT_CHARSET, &pItemText);
            Result = strcmp(pCompareText, pItemText);
            XtFree(pItemText);
        }
        if      ( Result < 0 ) Right = index - 1;
        else if ( Result > 0 ) Left  = index + 1;
    } while ( (Result != 0) && (Left <= Right) );

    /*
     * Nach Gebrauch wieder alles aufraeumen (bei einer externen Sortierung
     * muss das das Programm uebernehmen!)
     */
    if ( ExternSort ) {
        data.operation = XmOP_DONE;
        XtCallCallbacks((Widget) w, XmNsortingCallback, (XtPointer) &data);
    } else
        XtFree(pCompareText);
        
    if ( Result < 0 )
        return index + 1; /* Beachte, dass Indizes mit 1 beginnen! */
    else
        return index + 2; /* Beachte, dass Indizes mit 1 beginnen! */
} /* FindSortedItemPos */

/* --------------------------------------------------------------------
 * Kontrolliere, ob es sich ueberhaupt um eine Combo-Box (bzw. einen
 * hypothetischen Nachkommen) handelt -- ansonsten mecker kraeftig
 * herum!
 * Ergebnis:
 *   True, falls wir hier ein falsches Widget untergejubelt bekommen!
 */
static Boolean CheckComboBox(Widget w, char *pFuncName)
{
    char buff[256];
    char *pWName;

#if (XmVersion >= 2000)
    return False; /* temporary workaround */
#else    
    if ( XmIsComboBox(w) ) return False;
    pWName = XrmQuarkToString(w->core.xrm_name);
    sprintf(buff, 
"Warning: %s called on widget named %s beeing \
not a descendant of class XmComboBox!", 
                  pFuncName, pWName);
    XtWarning(buff);
    return True;
#endif
} /* CheckComboBox */

/* --------------------------------------------------------------------
 * Saemtliche Interface-Routinen zur Combo-Box
 */
/* Zunaechst alles fuer die Listbox */
#define ListBox (((XmComboBoxWidget) w)->combobox.ListCtrl)
#define EditBox (((XmComboBoxWidget) w)->combobox.EditCtrl)
#define ComboBox ((XmComboBoxWidget) w)

/* !!!
 * So angepasst, dass bei doppelt auftretenden Eintraegen, der
 * alte Eintrag weiterhin markiert bleibt. Diese Massnahme soll
 * eigentlich nur verhindern, dass zufaellig zwei Eintraege
 * markiert sind, falls nach der Anwahl eines Eintrages ein zweiter
 * gleichlautender Eintrag hinzugefuegt wurde.
 * Was hier die reine Lehre (oder war das die Leere?) anbetrifft:
 * in einer Combo-Box sollten sich sowieso nie gleichlautende
 * Eintraege befinden, da sie dort unsinnig sind und den Benutzer
 * nur verwirren...
 */
void    XmComboBoxAddItem(Widget w, XmString item, int pos)
{
    int OldIndex = XmComboBoxGetSelectedPos(w);
    
    if ( CheckComboBox(w, "XmComboBoxAddItem") ) return;
    if ( ComboBox->combobox.Sorted )
        pos = FindSortedItemPos(ComboBox, item);
    XmListAddItem(ListBox, item, pos);
    if ( OldIndex != XmComboBoxGetSelectedPos(w) )
        /* Hier SetSelectionPos() statt XmComboBoxSelectPos(),
         * da der Text nicht in das Eingabefeld uebertragen werden
         * soll!
         */
        SetSelectionPos(ComboBox, OldIndex, False);
} /* XmComboBoxAddItem */
/* !!!
 * Hier gilt das bereits oben gesagte (siehe XmComboBoxAddItem).
 * Bei sortierten Listboxen wird die Sortierung beim Gebrauch dieser
 * Funktion zerstoert!
 */
void    XmComboBoxAddItems(Widget w, XmString *items, int item_count, int pos)
{
    int OldIndex = XmComboBoxGetSelectedPos(w);

    if ( CheckComboBox(w, "XmComboBoxAddItems") ) return;
    XmListAddItems(ListBox, items, item_count, pos);
    if ( OldIndex != XmComboBoxGetSelectedPos(w) )
        /* Siehe Anmerkung in XmComboBoxAddItem */
        SetSelectionPos(ComboBox, OldIndex, False);
} /* XmComboBoxAddItems */

void    XmComboBoxAddItemUnselected(Widget w, XmString item, int pos)
{ XmListAddItemUnselected(ListBox, item, pos); }

/* !!!
 * Da bei den folgenden Routinen jeweils ein oder mehrere Eintraege
 * geloescht oder veraendert werden, muss gegebenefalls das Eingabe-
 * feld bei nicht editierbaren Combo-Boxen auf Vordermann gebracht
 * werden.
 */
void    XmComboBoxDeleteItem(Widget w, XmString item)
{
    int Index = XmListItemPos(ListBox, item);

    if ( CheckComboBox(w, "XmComboBoxDeleteItem") ) return;
    if ( Index ) XmComboBoxDeletePos(w, Index);
} /* XmComboBoxDeleteItem */

void    XmComboBoxDeleteItems(Widget w, XmString *items, int item_count)
{
    int i;

    if ( CheckComboBox(w, "XmComboBoxDeleteItems") ) return;
    for ( i = 0; i < item_count; i++ )
        XmListDeleteItem(w, items[i]);
} /* XmComboBoxDeleteItems */

void    XmComboBoxDeletePos(Widget w, int pos)
{
    int OldIndex = XmComboBoxGetSelectedPos(w);
    
    if ( CheckComboBox(w, "XmComboBoxDeletePos") ) return;
    XmListDeletePos(ListBox, pos);
    if ( pos == OldIndex ) UpdateComboBox(ComboBox, pos, True);
} /* XmComboBoxDeletePos */

void    XmComboBoxDeleteItemsPos(Widget w, int item_count, int pos)
{
    int i;

    if ( CheckComboBox(w, "XmComboBoxDeleteItemsPos") ) return;
    for ( i = 0; i < item_count; i++ )
        XmComboBoxDeletePos(w, pos++);
} /* XmComboBoxDeleteItemsPos */

void    XmComboBoxDeleteAllItems(Widget w)
{
    if ( CheckComboBox(w, "XmComboBoxAllDeleteItems") ) return;
    XmListDeleteAllItems(ListBox);
    UpdateComboBox(ComboBox, 0, True);
} /* XmComboBoxDeleteAllItems */

/* !!!
 * Werden Eintraege ausgetauscht, so heisst es fuer uns, auch hierbei
 * auf der Hut zu sein.
 */
void    XmComboBoxReplaceItems(Widget w, XmString *old_items, int item_count, XmString *new_items)
{
    if ( CheckComboBox(w, "XmComboBoxReplaceItems") ) return;
    XmListReplaceItems(ListBox, old_items, item_count, new_items);
    UpdateComboBox(ComboBox, XmComboBoxGetSelectedPos(w), False);
} /* XmComboBoxReplaceItems */

void    XmComboBoxReplaceItemsPos(Widget w, XmString *new_items, int item_count, int position)
{
    int OldIndex = XmComboBoxGetSelectedPos(w);

    if ( CheckComboBox(w, "XmComboBoxReplaceItemsPos") ) return;
    XmListReplaceItemsPos(ListBox, new_items, item_count, position);
    if ( (OldIndex >= position) && (OldIndex < position + item_count) )
        UpdateComboBox(ComboBox, OldIndex, False);
} /* XmComboBoxReplaceItemsPos */

Boolean XmComboBoxItemExists(Widget w, XmString item)
{
    if ( CheckComboBox(w, "XmComboBoxItemExists") ) return False;
    return XmListItemExists(ListBox, item);
} /* XmComboBoxItemExists */

int     XmComboBoxItemPos(Widget w, XmString item)
{
    if ( CheckComboBox(w, "XmComboBoxItemPos") ) return 0;
    return XmListItemPos(ListBox, item);
} /* XmComboBoxItemPos */

Boolean XmComboBoxGetMatchPos(Widget w, XmString item, int **pos_list, int *pos_count)
{
    if ( CheckComboBox(w, "XmComboBoxGetMatchPos") ) return False;
    return XmListGetMatchPos(ListBox, item, pos_list, pos_count);
} /* XmComboBoxGetMatchPos */

/* !!!
 * Sobald ein anderer Eintrag in der Listbox ausgewaehlt werden soll,
 * muessen wir hier helfend eingreifen.
 */
void    XmComboBoxSelectPos(Widget w, int pos, Boolean notify)
{
    int index;
    
    if ( CheckComboBox(w, "XmComboBoxSelectPos") ) return;
    index = SetSelectionPos(ComboBox, pos, notify);
    if ( index ) TransferToEditCtrl(ComboBox, index, False);
} /* XmComboBoxSelectPos */

/* !!!
 * dto. analog zu XmComboBoxSelectPos, nur statt des Index wird der
 * Eintragstext angegeben, um einen Eintrag in der Listbox zu
 * markieren.
 */
void    XmComboBoxSelectItem(Widget w, XmString item, Boolean notify)
{
    int index;
    
    if ( CheckComboBox(w, "XmComboBoxSelectItem") ) return;
    XmListSelectItem(ListBox, item, notify);
    index = SetSelectionPos(ComboBox, XmComboBoxGetSelectedPos(w), False);
    if ( index ) TransferToEditCtrl(ComboBox, index, False);
} /* XmComboBoxSelectItem */

/* !!!
 * Geaendert gegenueber dem ListBox-Pendant! Da in einer Combo-Box die
 * Liste nur maximal einen ausgewaehlten Eintrag besitzt, macht die
 * 'alte' Funktionalitaet von XmListGetSelectedPos ziemlich wenig Sinn.
 * Die neue Routine liefert statt dessen direkt den Index des aus-
 * gewaehlten Eintrages oder 0 zurueck.
 */
int     XmComboBoxGetSelectedPos(Widget w)
{
    int *SelectionList, SelectionCount, SelectionIndex;
    
    if ( CheckComboBox(w, "XmComboBoxGetSelectedPos") ) return 0;
    if ( XmListGetSelectedPos(ListBox,
                              &SelectionList, &SelectionCount) ) {
        SelectionIndex = *SelectionList;
        XtFree((char *)SelectionList);
    } else SelectionIndex = 0;
    return SelectionIndex;
} /* XmComboBoxGetSelectedPos */



void    XmComboBoxClearSelection(Widget w, Time time)
{
    XmTextFieldClearSelection(EditBox, time);
} /* XmComboBoxClearSelection */

Boolean XmComboBoxCopy(Widget w, Time time)
{
    return XmTextFieldCopy(EditBox, time);
} /* XmComboBoxCopy */

Boolean XmComboBoxCut(Widget w, Time time)
{
    return XmTextFieldCut(EditBox, time);
} /* XmComboBoxCut */

XmTextPosition XmComboBoxGetInsertionPosition(Widget w)
{
    return XmTextFieldGetInsertionPosition(EditBox);
} /* XmComboBoxGetInsertionPosition */

XmTextPosition XmComboBoxGetLastPosition(Widget w)
{
    return XmTextFieldGetLastPosition(EditBox);
} /* XmComboBoxGetLastPosition */

int     XmComboBoxGetMaxLength(Widget w)
{
    return XmTextFieldGetMaxLength(EditBox);
} /* XmComboBoxGetMaxLength */

char *  XmComboBoxGetSelection(Widget w)
{
    return XmTextFieldGetSelection(EditBox);
} /* XmComboBoxGetSelection */

Boolean XmComboBoxGetSelectionPosition(Widget w, XmTextPosition *left, 
                                       XmTextPosition *right)
{
    return XmTextFieldGetSelectionPosition(EditBox, left, right);
} /* XmComboBoxGetSelectionPosition */

char *  XmComboBoxGetString(Widget w)
{
    return XmTextFieldGetString(EditBox);
} /* XmComboBoxGetString */

void    XmComboBoxInsert(Widget w, XmTextPosition position, char *value)
{
    XmTextFieldInsert(EditBox, position, value);
} /* XmComboBoxInsert */

Boolean XmComboBoxPaste(Widget w)
{
    return XmTextFieldPaste(EditBox);
} /* XmComboBoxPaste */

Boolean XmComboBoxRemove(Widget w)
{
    return XmTextFieldRemove(EditBox);
} /* XmComboBoxRemove */

void    XmComboBoxReplace(Widget w, XmTextPosition from_pos, 
                          XmTextPosition to_pos, char *value)
{
    XmTextFieldReplace(EditBox, from_pos, to_pos, value);
} /* XmComboBoxReplace */

void    XmComboBoxSetAddMode(Widget w, Boolean state)
{
    XmTextFieldSetAddMode(EditBox, state);
} /* XmComboBoxSetAddMode */

void    XmComboBoxSetHighlight(Widget w, XmTextPosition left, 
                               XmTextPosition right, XmHighlightMode mode)
{
    XmTextFieldSetHighlight(EditBox, left, right, mode);
} /* XmComboBoxSetHighlight */

void    XmComboBoxSetInsertionPosition(Widget w, XmTextPosition position)
{
    XmTextFieldSetInsertionPosition(EditBox, position);
} /* XmComboBoxSetInsertionPosition */

void    XmComboBoxSetMaxLength(Widget w, int max_length)
{
    XmTextFieldSetMaxLength(EditBox, max_length);
} /* XmComboBoxSetMaxLength */

void    XmComboBoxSetSelection(Widget w, XmTextPosition first, 
                               XmTextPosition last, Time time)
{
    XmTextFieldSetSelection(EditBox, first, last, time);
} /* XmComboBoxSetSelection */

void    XmComboBoxSetString(Widget w, char *value)
{
/* Liebe OSF...ihr ^&*#%$*&)*(@$(*^(*&%# habt doch einen ziemlich gemeinen
 * Fehler in XmTextFieldSetString() drin... wenn man einen leeren String
 * (also "") angiebt, gibt's nur noch Aerger, wenn man spaeter wieder an
 * den Inhalt des Eingabefeldes heranwill.
 */
    if ( (value == NULL) || (*value == 0) )
        XtVaSetValues(w, XmNvalue, "", NULL);
    else
        XmTextFieldSetString(EditBox, value);
} /* XmComboBoxSetString */

void    XmComboBoxShowPosition(Widget w, XmTextPosition position)
{
    XmTextFieldShowPosition(EditBox, position);
} /* XmComboBoxShowPosition */

/*
 * Loescht einen evtl. noch ausgewaehlten Eintrag in einer Combo Box, 
 * wenn diese eine SelectionPolicy von XmSINGLE_SELECT hat.
 */
void XmComboBoxClearItemSelection(Widget w)
{
    int index;

    if ( CheckComboBox(w, "XmComboBoxClearItemSelection") ) return;
    
    /*
     * Wenn bereits kein Eintrag markiert ist, dann loeschen wir nur noch
     * eben das Eingabefeld.
     */
    index = XmComboBoxGetSelectedPos(w);
    if ( index == 0 ) {
        XmComboBoxSetString(w, "");
    } else {
    /*
     * Ansonsten aktuellen Eintrag entsorgen (wie bei der Methode wipe-out)
     */
        TransferToEditCtrl(ComboBox, 0, True);
        CallSelectionCBL(ComboBox, NULL);
    }
} /* XmComboBoxClearItemSelection */

/* Die Drop-Down-Liste ein oder ausklappen */
void    XmComboBoxShowList(Widget w)
{
    if ( CheckComboBox(w, "XmComboBoxShowList") ) return;
    ShowHideDropDownList((XmComboBoxWidget) w, NULL, False);
} /* XmComboBoxShowList */

void    XmComboBoxHideList(Widget w)
{
    if ( CheckComboBox(w, "XmComboBoxHideList") ) return;
    ShowHideDropDownList((XmComboBoxWidget) w, NULL, True);
} /* XmComboBoxShowList */

/*
 * Naja, ich komm' ja doch nicht um diese olle Funktion herum...
 */
Widget XmCreateComboBox(Widget parent, String name, ArgList arglist,
                           Cardinal argcount)
{
    return XtCreateWidget(name, xmComboBoxWidgetClass, parent,
                          arglist, argcount);
} /* XmCreateComboBox */

/* Ende von ComboBox.c */