xenocara/xserver/hw/xfree86/utils/xorgcfg/interface.c

/*
 * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *  
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
 * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * Except as contained in this notice, the name of Conectiva Linux shall
 * not be used in advertising or otherwise to promote the sale, use or other
 * dealings in this Software without prior written authorization from
 * Conectiva Linux.
 *
 * Author: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
 *
 */

#include <X11/IntrinsicP.h>
#include <X11/StringDefs.h>
#include <X11/Composite.h>
#include <X11/Shell.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/Simple.h>
#include <X11/Xaw/Paned.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/SmeBSB.h>
#include <X11/Xaw/SmeLine.h>
#include <X11/Xaw/SimpleMenP.h>
#include <X11/Xaw/Dialog.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include "xf86config.h"
#include "mouse-cfg.h"
#include "keyboard-cfg.h"
#include "card-cfg.h"
#include "monitor-cfg.h"
#include "screen-cfg.h"
#include "screen.h"
#include "cards.h"
#include "options.h"
#include "vidmode.h"
#include "help.h"
#include "stubs.h"

#define randomize()		srand((unsigned)time((time_t*)NULL))
#ifdef PROJECT_ROOT
#define DefaultXFree86Dir	PROJECT_ROOT
#else
#define DefaultXFree86Dir	"/usr"
#endif

#define IS_KBDDRIV(S) ((strcasecmp((S),"kbd") == 0))

/*
 * Prototypes
 */
void DrawCables(void);
static void DrawCable(Display*, Window, int, int, int, int);
static void ComputerEventHandler(Widget, XtPointer, XEvent*, Boolean*);
void SelectDeviceAction(Widget, XEvent*, String*, Cardinal*);
void MoveDeviceAction(Widget, XEvent*, String*, Cardinal*);
void UnselectDeviceAction(Widget, XEvent*, String*, Cardinal*);
void RenameLayoutAction(Widget, XEvent*, String*, Cardinal*);
void DevicePopupMenu(Widget, XEvent*, String*, Cardinal*);
void DevicePopdownMenu(Widget, XEvent*, String*, Cardinal*);
void AddDeviceCallback(Widget, XtPointer, XtPointer);
void QuitCallback(Widget, XtPointer, XtPointer);
void SmeConfigureDeviceCallback(Widget, XtPointer, XtPointer);
void ConfigureDeviceCallback(Widget, XtPointer, XtPointer);
void EnableDeviceCallback(Widget, XtPointer, XtPointer);
void DisableDeviceCallback(Widget, XtPointer, XtPointer);
void RemoveDeviceCallback(Widget, XtPointer, XtPointer);
void InitializeDevices(void);
void SetConfigModeCallback(Widget, XtPointer, XtPointer);
void SelectLayoutCallback(Widget, XtPointer, XtPointer);
void DefaultLayoutCallback(Widget, XtPointer, XtPointer);
void RemoveLayoutCallback(Widget, XtPointer, XtPointer);
void OptionsCallback(Widget, XtPointer, XtPointer);
xf86cfgDevice *AddDevice(int, XtPointer, int, int);
static Bool AskConfig(void);
void WriteConfigAction(Widget, XEvent*, String*, Cardinal*);
static void ScreenSetup(Bool);
void QuitAction(Widget, XEvent*, String*, Cardinal*);
void PopdownErrorCallback(Widget, XtPointer, XtPointer);
static void ErrorCancelAction(Widget, XEvent*, String*, Cardinal*);
static void QuitCancelAction(Widget, XEvent*, String*, Cardinal*);
static void HelpCallback(Widget, XtPointer, XtPointer);
void UpdateMenuDeviceList(int);

extern void AccessXConfigureStart(void);
extern void AccessXConfigureEnd(void);
extern void CloseAccessXAction(Widget, XEvent*, String*, Cardinal*);

#ifdef HAS_NCURSES
extern void TextMode(void);
#endif

static void Usage(void);

/*
 * Initialization
 */
Widget toplevel, work, config, layout, layoutsme, layoutp, topMenu;
XtAppContext appcon;

Pixmap menuPixmap;

char *XF86Config_path = NULL;
char *XF86Module_path = NULL;
char *XFree86_path = NULL;
char *XF86Font_path = NULL;
char *XF86RGB_path = NULL;
char *XkbConfig_path = NULL;
char *XFree86Dir;
static char XF86Config_path_static[1024];
static char XkbConfig_path_static[1024];
Bool xf86config_set = False;

int textmode = False;
#ifdef USE_MODULES
int nomodules = False;
#endif
int  noverify = False;

xf86cfgComputer computer;
xf86cfgDevice cpu_device;
Cursor no_cursor;
static Widget device, layoutm, popup, commands;
static int xpos, ypos;
int sxpos, sypos;
static char no_cursor_data[] = { 0,0,0,0, 0,0,0,0 };
static GC cablegc, cablegcshadow;
Atom wm_delete_window;
static Bool config_set = False;
static Widget mouseSme, mouseMenu, keyboardSme, keyboardMenu,
       cardSme, cardMenu, monitorSme, monitorMenu;

int config_mode = CONFIG_LAYOUT;

static XtActionsRec actions[] = {
    {"filter-card", CardFilterAction},
    {"select-device", SelectDeviceAction},
    {"move-device", MoveDeviceAction},
    {"unselect-device", UnselectDeviceAction},
    {"device-popup", DevicePopupMenu},
    {"device-popdown", DevicePopdownMenu},
    {"rename-layout", RenameLayoutAction},
    {"write-config", WriteConfigAction},
    {"quit", QuitAction},
    {"vidmode-restore", VidmodeRestoreAction},
    {"config-cancel", ConfigCancelAction},
    {"options-cancel", OptionsCancelAction},
    {"error-cancel", ErrorCancelAction},
    {"quit-cancel", QuitCancelAction},
    {"addmode-cancel", CancelAddModeAction},
    {"accessx-close", CloseAccessXAction},
    {"testmode-cancel", CancelTestModeAction},
    {"help-close", HelpCancelAction},
    {"expert-close", ExpertCloseAction},
#ifdef USE_MODULES
    {"module-options-close", ModuleOptionsCancelAction},
#endif
};

static char *device_names[] = {
/* MOUSE	*/
    "mouse",
/* KEYBOARD	*/
    "keyboard",
/* CARD		*/
    "card",
/* MONITOR	*/
    "monitor",
/* SCREEN	*/
    "screen",
};

static XtResource appResources[] = {
#if 0
    {"config",  __XCONFIGFILE__,  XtRString, sizeof(char*),
      0, XtRString, "/etc/X11/"__XCONFIGFILE__},
#endif
    {"menuBitmap",  "MenuBitmap",  XtRString, sizeof(char*),
      0, XtRString, "menu10"},
};

static void
Usage(void)
{
    fprintf(stderr,
"Usage:\n"
"   xorgcfg [-option ...]\n"
"\n"
"Options:\n"
"   -config <"__XCONFIGFILE__">   Alternate configuration file.\n"
"   -modulepath <module-path>  "__XSERVERNAME__" modules location.\n"
"   -serverpath <server-path>  X server to start (if $DISPLAY is not defined).\n"
"   -fontpath   <font-path>    Font path for fonts.\n"
"   -rgbpath    <rgb-path>     Where the rgb.txt file is located.\n"
#ifdef HAS_NCURSES
"   -textmode                  Use this option for the text only interface.\n"
#endif
#ifdef USE_MODULES
"   -nomodules                 Use this option if xorgcfg is slow to start.\n"
"   -verbose <number>          Verbosity used in the loader (default 1).\n"
#endif
"   -verify                    Verify modules/options integrity.\n"
);

    exit(1);
}

/*
 * Implementation
 */
int
main(int argc, char *argv[])
{
    Widget pane, hpane, expert, popup, mouse, keyboard, card, monitor;
    Widget bottom, sme, smemodeline, help, quit, layopt;
    XColor color, tmp;
    Pixmap pixmap;
    XGCValues values;
    XF86ConfLayoutPtr lay;
    int i, startedx;
    char *menuPixmapPath = NULL;
    XrmValue from, to;

    if ((XFree86Dir = getenv("XWINHOME")) == NULL)
	XFree86Dir = DefaultXFree86Dir;

    chdir(XFree86Dir);

#ifdef USE_MODULES
    xf86Verbose = 1;
#endif
    noverify = True;

    for (i = 1; i < argc; i++) {
	if (strcmp(argv[i], "-config") == 0 ||
	    strcmp(argv[i], "-xorgconfig") == 0 ||
	    strcmp(argv[i], "-xf86config") == 0) {
	    if (i + 1 < argc) {
		XF86Config_path = argv[++i];
		config_set = True;
	    }
	} else if (strcmp(argv[i], "-modulepath") == 0) {
	    if (i + 1 < argc)
		XF86Module_path = argv[++i];
	} else if (strcmp(argv[i], "-serverpath") == 0) {
	    if (i + 1 < argc)
		XFree86_path = argv[++i];
	} else if (strcmp(argv[i], "-fontpath") == 0) {
	    if (i + 1 < argc)
		XF86Font_path = argv[++i];
	} else if (strcmp(argv[i], "-rgbpath") == 0) {
	    if (i + 1 < argc)
		XF86RGB_path = argv[++i];
	}
#ifdef HAS_NCURSES
	else if (strcmp(argv[i], "-textmode") == 0)
	    textmode = True;
#endif
#ifdef USE_MODULES
	else if (strcmp(argv[i], "-nomodules") == 0)
	    nomodules = True;
	else if (strcmp(argv[i], "-verbose") == 0) {
	    if (i + 1 < argc)
		xf86Verbose = atoi(argv[++i]);
	}
#endif
	else if (strcmp(argv[i], "-verify") == 0)
	    noverify = False;
	else
	    Usage();
    }

#ifdef HAS_NCURSES
    if (textmode) {
	TextMode();
	exit(0);
    }
#endif
    
    startedx = startx();
    if (XF86Config_path == NULL)
	XF86Config_path = XtNewString(__XCONFIGFILE__);
    if (XkbConfig_path == NULL) {
	XmuSnprintf(XkbConfig_path_static, sizeof(XkbConfig_path_static),
		    "%s/%s%s", XFree86Dir, XkbConfigDir, XkbConfigFile);
	XkbConfig_path = XkbConfig_path_static;
    }
    toplevel = XtAppInitialize(&appcon, "XOrgCfg",
		    	       NULL, 0,
			       &argc, argv,
			       NULL, NULL, 0);
    if (DPY == NULL)
	DPY = XtDisplay(toplevel);

    XtGetApplicationResources(toplevel, (XtPointer)&menuPixmapPath,
			      appResources, XtNumber(appResources), NULL, 0);
    if (menuPixmapPath && strlen(menuPixmapPath)) {
	from.size = strlen(menuPixmapPath);
	from.addr = menuPixmapPath;
	to.size = sizeof(Pixmap);
	to.addr = (XtPointer)&(menuPixmap);
	XtConvertAndStore(toplevel, XtRString, &from, XtRBitmap, &to);
    }

    XtAppAddActions(appcon, actions, XtNumber(actions));

    XawSimpleMenuAddGlobalActions(appcon);
    XtRegisterGrabAction(DevicePopupMenu, True,
			 ButtonPressMask | ButtonReleaseMask,
			 GrabModeAsync, GrabModeAsync);

    pane = XtCreateManagedWidget("pane", panedWidgetClass,
				 toplevel, NULL, 0);
    hpane = XtVaCreateManagedWidget("hpane", panedWidgetClass, pane,
				    XtNorientation, XtorientHorizontal, NULL);
    topMenu = XtCreateManagedWidget("topM", menuButtonWidgetClass,
				 hpane, NULL, 0);
    expert = XtCreateManagedWidget("expert", commandWidgetClass, hpane, NULL, 0);
    XtAddCallback(expert, XtNcallback, ExpertCallback, NULL);
    popup = XtCreatePopupShell("menu", simpleMenuWidgetClass,
			       topMenu, NULL, 0);
    sme = XtCreateManagedWidget("layout", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, SetConfigModeCallback,
		  (XtPointer)CONFIG_LAYOUT);
    sme = XtCreateManagedWidget("screen", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, SetConfigModeCallback,
		  (XtPointer)CONFIG_SCREEN);
    smemodeline = XtCreateManagedWidget("modeline", smeBSBObjectClass,
					popup, NULL, 0);
    XtAddCallback(smemodeline, XtNcallback, SetConfigModeCallback,
		  (XtPointer)CONFIG_MODELINE);
    sme = XtCreateManagedWidget("accessx", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, SetConfigModeCallback,
		  (XtPointer)CONFIG_ACCESSX);

    commands = XtCreateManagedWidget("commands", formWidgetClass,
				     pane, NULL, 0);

    mouse = XtVaCreateManagedWidget("mouse", menuButtonWidgetClass,
				    commands, XtNmenuName, "mouseP", NULL);
    popup = XtCreatePopupShell("mouseP", simpleMenuWidgetClass,
			       mouse, NULL, 0);
    sme = XtCreateManagedWidget("new", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, AddDeviceCallback, (XtPointer)MOUSE);
    mouseSme = XtCreateManagedWidget("configure", smeBSBObjectClass,
				     popup, NULL, 0);
    XtAddCallback(mouseSme, XtNcallback, SmeConfigureDeviceCallback,
		  (XtPointer)MOUSE);

    keyboard = XtVaCreateManagedWidget("keyboard", menuButtonWidgetClass,
				       commands, XtNmenuName, "keyboardP", NULL);
    popup = XtCreatePopupShell("keyboardP", simpleMenuWidgetClass,
			       keyboard, NULL, 0);
    sme = XtCreateManagedWidget("new", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, AddDeviceCallback, (XtPointer)KEYBOARD);
    keyboardSme = XtCreateManagedWidget("configure", smeBSBObjectClass,
					popup, NULL, 0);
    XtAddCallback(keyboardSme, XtNcallback, SmeConfigureDeviceCallback,
		  (XtPointer)KEYBOARD);

    card = XtVaCreateManagedWidget("card", menuButtonWidgetClass,
				   commands, XtNmenuName, "cardP", NULL);
    popup = XtCreatePopupShell("cardP", simpleMenuWidgetClass,
			       card, NULL, 0);
    sme = XtCreateManagedWidget("new", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, AddDeviceCallback, (XtPointer)CARD);
    cardSme = XtCreateManagedWidget("configure", smeBSBObjectClass,
				    popup, NULL, 0);
    XtAddCallback(cardSme, XtNcallback, SmeConfigureDeviceCallback,
		  (XtPointer)CARD);

    monitor = XtVaCreateManagedWidget("monitor", menuButtonWidgetClass,
				      commands, XtNmenuName, "monitorP", NULL);
    popup = XtCreatePopupShell("monitorP", simpleMenuWidgetClass,
			       monitor, NULL, 0);
    sme = XtCreateManagedWidget("new", smeBSBObjectClass,
				popup, NULL, 0);
    XtAddCallback(sme, XtNcallback, AddDeviceCallback, (XtPointer)MONITOR);
    monitorSme = XtCreateManagedWidget("configure", smeBSBObjectClass,
				       popup, NULL, 0);
    XtAddCallback(monitorSme, XtNcallback, SmeConfigureDeviceCallback,
		  (XtPointer)MONITOR);

    work = XtCreateManagedWidget("work", compositeWidgetClass,
				 pane, NULL, 0);

    bottom = XtCreateManagedWidget("bottom", formWidgetClass,
				   pane, NULL, 0);
    layoutm = XtCreateManagedWidget("select", menuButtonWidgetClass,
				    bottom, NULL, 0);
    layout = XtVaCreateManagedWidget("layout", asciiTextWidgetClass,
				     bottom,
				     XtNeditType, XawtextEdit,
				     NULL);
    layoutp = XtCreatePopupShell("menu", simpleMenuWidgetClass,
				 bottom, NULL, 0);
    sme = XtCreateManagedWidget("new", smeBSBObjectClass, layoutp,
				NULL, 0);
    XtAddCallback(sme, XtNcallback, SelectLayoutCallback, NULL);
    help = XtCreateManagedWidget("help", commandWidgetClass,
				 bottom, NULL, 0);
    XtAddCallback(help, XtNcallback, HelpCallback, NULL);
    quit = XtCreateManagedWidget("quit", commandWidgetClass,
				 bottom, NULL, 0);
    XtAddCallback(quit, XtNcallback, QuitCallback, NULL);

    XtRealizeWidget(toplevel);
    XtRealizeWidget(topMenu);

    pixmap = XCreateBitmapFromData(XtDisplay(toplevel), XtWindow(toplevel),
				   no_cursor_data, 8, 8);
    XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "black",
		     &color, &tmp);
    no_cursor = XCreatePixmapCursor(XtDisplay(toplevel), pixmap, pixmap,
				    &color, &color, 0, 0);

    XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray55",
		     &color, &tmp);
    values.line_width = 3;
    values.foreground = color.pixel;
    cablegcshadow = XCreateGC(XtDisplay(toplevel), XtWindow(toplevel),
			GCForeground | GCLineWidth, &values);
    XAllocNamedColor(XtDisplay(toplevel), toplevel->core.colormap, "gray85",
		     &color, &tmp);
    values.line_width = 1;
    values.foreground = color.pixel;
    cablegc = XCreateGC(XtDisplay(toplevel), XtWindow(toplevel),
			GCForeground | GCLineWidth, &values);

    computer.cpu = XtCreateManagedWidget("cpu", simpleWidgetClass,
					 work, NULL, 0);
    cpu_device.widget = computer.cpu;
    cpu_device.type = SERVER;

    XtAddEventHandler(work, ExposureMask, False,
		      ComputerEventHandler, (XtPointer)NULL);

    wm_delete_window = XInternAtom(DPY, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(DPY, XtWindow(toplevel), &wm_delete_window, 1);

    StartConfig();
    InitializeDevices();
    UpdateMenuDeviceList(MOUSE);
    UpdateMenuDeviceList(KEYBOARD);
    UpdateMenuDeviceList(CARD);
    UpdateMenuDeviceList(MONITOR);
    XtSetSensitive(smemodeline, VideoModeInitialize());

    lay = XF86Config->conf_layout_lst;
    while (lay != NULL) {
	sme = XtVaCreateManagedWidget("sme", smeBSBObjectClass,
				      layoutp,
				      XtNlabel, lay->lay_identifier,
				      XtNmenuName, lay->lay_identifier,
				      XtNleftBitmap, menuPixmap,
				      NULL);
	XtAddCallback(sme, XtNcallback, SelectLayoutCallback, (XtPointer)lay);
	if (layoutsme == NULL)
	    layoutsme = sme;
	layopt = XtCreatePopupShell(lay->lay_identifier, simpleMenuWidgetClass,
				    layoutp, NULL, 0);
	sme = XtCreateManagedWidget("default", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, DefaultLayoutCallback, NULL);
	sme = XtCreateManagedWidget("remove", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, RemoveLayoutCallback, NULL);
	XtRealizeWidget(layopt);

	lay = (XF86ConfLayoutPtr)(lay->list.next);
    }
    SelectLayoutCallback(layoutsme,
			 XF86Config->conf_layout_lst, NULL);

    startaccessx();
    if (startedx) {
	switch (fork()) {
	    case 0: {
		char path[PATH_MAX];

		XmuSnprintf(path, sizeof(path), "%s/bin/twm", XFree86Dir);
		execl(path, "twm", (void *)NULL);
		exit(-127);
	    }	break;
	    case -1:
		fprintf(stderr, "Cannot fork.\n");
		exit(1);
		break;
	    default:
		break;
	}
    }

#ifdef USE_MODULES
    if (!nomodules)
	LoaderInitializeOptions();
#endif

    /* ReadCardsDatabase() must be called after LoaderInitializeOptions() */
    ReadCardsDatabase();

    if (!config_set && startedx) {
	XtFree(XF86Config_path);
#ifndef XF86CONFIG
# define XF86CONFIG __XCONFIGFILE__
#endif
#ifdef XF86CONFIGDIR
	XF86Config_path = XtNewString(XF86CONFIGDIR "/" XF86CONFIG);
#else
	XF86Config_path = XtNewString("/etc/X11/" XF86CONFIG);
#endif
    }
    XtAppMainLoop(appcon);
    if (startedx)
	endx();

    return (0);
}

static Widget shell_cf;
static int write_cf, asking_cf;
static int cf_state = 0;
#define	CF_XF86Config	1
#define	CF_XKBConfig	2
#define CF_First	CF_XF86Config
#define CF_Last		CF_XKBConfig

/*ARGSUSED*/
static void
WriteConfig(Widget w, XtPointer user_data, XtPointer call_data)
{
    asking_cf = 0;
    XtPopdown(shell_cf);
    write_cf = (long)user_data;
}

/*ARGSUSED*/
void
QuitCancelAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    WriteConfig(w, (XtPointer)-1, NULL);
}

/*ARGSUSED*/
void
WriteConfigAction(Widget w, XEvent *event,
		  String *params, Cardinal *num_params)
{
    WriteConfig(w, (XtPointer)True, NULL);
}

static Bool
AskConfig(void)
{
    static Widget dialog;

    if (shell_cf == NULL) {
	Arg args[1];
	char *l, *label;
	int len;

	shell_cf = XtCreatePopupShell("quit", transientShellWidgetClass,
				      toplevel, NULL, 0);
	dialog = XtVaCreateManagedWidget("ask", dialogWidgetClass, shell_cf,
					 XtNvalue, XF86Config_path, NULL);
	XawDialogAddButton(dialog, "yes", WriteConfig, (XtPointer)1);
	XawDialogAddButton(dialog, "no", WriteConfig, (XtPointer)0);
	XawDialogAddButton(dialog, "cancel", WriteConfig, (XtPointer)-1);
	XtRealizeWidget(shell_cf);
	XSetWMProtocols(DPY, XtWindow(shell_cf), &wm_delete_window, 1);
	XtSetArg(args[0], XtNlabel, &l);
	XtGetValues(dialog, args, 1);
	label = XtMalloc(len = (strlen(l) + strlen(XF86CONFIG) + 2));
	XmuSnprintf(label, len, "%s\n", XF86CONFIG);
	strcat(label, l);
	XtSetArg(args[0], XtNlabel, label);
	XtSetValues(dialog, args, 1);
	XtFree(label);
    }
    else {
	Arg args[2];
	Cardinal num_args = 0;
	char *l, *label = NULL, *str = "";

	XtSetArg(args[0], XtNlabel, &l);
	XtGetValues(dialog, args, 1);
	switch (cf_state) {
	    case CF_XF86Config:
		str = XF86CONFIG;
		XtSetArg(args[num_args], XtNvalue, XF86Config_path);
		++num_args;
		break;
	    case CF_XKBConfig:
		str = "XKB";
		XtSetArg(args[num_args], XtNvalue, XkbConfig_path);
		++num_args;
		break;
	}
	l = strchr(l, '\n');
	if (l != NULL) {
	    label = XtMalloc(strlen(str) + strlen(l) + 1);
	    strcpy(label, str);
	    strcat(label, l);
	    XtSetArg(args[num_args], XtNlabel, label);
	    ++num_args;
	}
	XtSetValues(dialog, args, num_args);
	if (l != NULL)
	    XtFree(label);
    }

    asking_cf = 1;

    XtPopup(shell_cf, XtGrabExclusive);
    while (asking_cf)
	XtAppProcessEvent(XtWidgetToApplicationContext(shell_cf), XtIMAll);

    if (write_cf > 0) {
	switch (cf_state) {
	    case CF_XF86Config:
		XF86Config_path = XawDialogGetValueString(dialog);
		XmuSnprintf(XF86Config_path_static,
			    sizeof(XF86Config_path_static),
			    "%s", XF86Config_path);
		XF86Config_path = XF86Config_path_static;
		break;
	    case CF_XKBConfig:
		XkbConfig_path = XawDialogGetValueString(dialog);
		XmuSnprintf(XkbConfig_path_static,
			    sizeof(XkbConfig_path_static),
			    "%s", XkbConfig_path);
		XkbConfig_path = XkbConfig_path_static;
		break;
	}
    }

    return (write_cf);
}

/*ARGSUSED*/
void
PopdownErrorCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    XtPopdown((Widget)user_data);
}

/*ARGSUSED*/
void
ErrorCancelAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    XtPopdown((Widget)w);
}

/*ARGSUSED*/
void
QuitAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    QuitCallback(w, NULL, NULL);
}

/*ARGSUSED*/
void
QuitCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    for (cf_state = CF_First; cf_state <= CF_Last; cf_state++) {
	if (cf_state == CF_XKBConfig && xkb_info == NULL)
	    continue;
	
	switch (AskConfig()) {
	    case 0:
		break;
	    case 1:
		if ((cf_state == CF_XF86Config &&
		     !xf86writeConfigFile(XF86Config_path, XF86Config)) ||
		    (cf_state == CF_XKBConfig &&
		     !WriteXKBConfiguration(XkbConfig_path,
					    &xkb_info->config))) {
		    static Widget shell;

		    if (shell == NULL) {
			Widget dialog;

			shell = XtCreatePopupShell("error",
				transientShellWidgetClass,
				toplevel, NULL, 0);
			dialog = XtVaCreateManagedWidget("notice",
				 dialogWidgetClass,
				 shell, XtNvalue, NULL,
				 NULL);
			XawDialogAddButton(dialog, "ok", PopdownErrorCallback,
					   (XtPointer)shell);
			XtRealizeWidget(shell);
			XSetWMProtocols(DPY, XtWindow(shell),
					&wm_delete_window, 1);
		    }
		    XtPopup(shell, XtGrabExclusive);
		    return;
		}
		break;
	    default:
		return;
	}
    }

    endx();
    exit(0);
}

void
InitializeDevices(void)
{
    xf86cfgDevice *device;
    int mouse_x, mouse_y, keyboard_x, keyboard_y,
	card_x, card_y, monitor_x, monitor_y, len;
    XF86ConfInputPtr input = XF86Config->conf_input_lst;
    XF86ConfDevicePtr card = XF86Config->conf_device_lst;
    XF86ConfMonitorPtr monitor = XF86Config->conf_monitor_lst;
    XF86OptionPtr flags = NULL;
    char buffer[4096], *tip;
    Arg args[1];

    if (XF86Config->conf_flags != NULL)
	flags = XF86Config->conf_flags->flg_option_lst;

    len = 0;
    while (flags && len < sizeof(buffer) - 1) {
	len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			   "Option     \"%s\"",
			   flags->opt_name);
	if (flags->opt_val != NULL)
	    len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			       " \"%s\"\n",
			       flags->opt_val);
	else
	    len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			       "%s", "\n");
	flags = (XF86OptionPtr)(flags->list.next);
    }

    if (len) {
	tip = XtNewString(buffer);
	XtSetArg(args[0], XtNtip, tip);
	XtSetValues(computer.cpu, args, 1);
    }

#define DEFAULT_MOUSE_WIDTH	30
#define DEFAULT_MOUSE_HEIGHT	40
#define DEFAULT_KEYBOARD_WIDTH	48
#define DEFAULT_KEYBOARD_HEIGHT	36
    mouse_x = work->core.width - (work->core.width >> 2);
    mouse_y = work->core.height - DEFAULT_MOUSE_HEIGHT;
    keyboard_x = 6;
    keyboard_y = work->core.height - DEFAULT_KEYBOARD_HEIGHT;

    while (input != NULL) {
	if (input->inp_driver) {
	    if (strcasecmp(input->inp_driver, "mouse") == 0) {
		device = AddDevice(MOUSE, (XtPointer)input, mouse_x, mouse_y);
		SetTip(device);
		if ((mouse_x += DEFAULT_MOUSE_WIDTH) > work->core.width) {
		    if ((mouse_y -= DEFAULT_MOUSE_HEIGHT) < (work->core.height >> 1))
			mouse_y = work->core.height >> 1;
		    mouse_x = work->core.width - (work->core.width >> 2);
		}
	    }
	    else if (IS_KBDDRIV(input->inp_driver)) {
		device = AddDevice(KEYBOARD, (XtPointer)input, keyboard_x, keyboard_y);
		SetTip(device);
		if ((keyboard_x += DEFAULT_KEYBOARD_WIDTH) >
		    work->core.width - (work->core.width >> 2))  {
		    if ((keyboard_y -= DEFAULT_KEYBOARD_HEIGHT) < (work->core.height >> 1))
			keyboard_y = work->core.height >> 1;
		    keyboard_x = 6;
		}
	    }
	}
	input = (XF86ConfInputPtr)(input->list.next);
    }

#define DEFAULT_CARD_WIDTH	45
#define DEFAULT_CARD_HEIGHT	46
    card_x = 6;
    card_y = (work->core.height >> 1) - 20 - DEFAULT_CARD_HEIGHT;
    while (card != NULL) {
	device = AddDevice(CARD, (XtPointer)card, card_x, card_y);
	SetTip(device);
	if ((card_x += DEFAULT_CARD_WIDTH) > work->core.width) {
	    if ((card_y -= DEFAULT_CARD_HEIGHT) < (work->core.height >> 2))
		card_y = work->core.height >> 2;
	    card_x = 6;
	}
	card = (XF86ConfDevicePtr)(card->list.next);
    }

#define DEFAULT_MONITOR_WIDTH	48
#define DEFAULT_MONITOR_HEIGHT	48
    monitor_x = 6;
    monitor_y = 6;
    while (monitor != NULL) {
	XF86ConfScreenPtr screen = XF86Config->conf_screen_lst;

	device = AddDevice(MONITOR, (XtPointer)monitor, monitor_x, monitor_y);
	SetTip(device);
	if ((monitor_x += DEFAULT_MONITOR_WIDTH) > work->core.width) {
	    if ((monitor_y += DEFAULT_MONITOR_HEIGHT) >
		(work->core.height >> 2) - DEFAULT_MONITOR_HEIGHT)
		monitor_y = (work->core.height >> 2) - DEFAULT_MONITOR_HEIGHT;
	    monitor_x = 6;
	}

	while (screen != NULL) {
	    if (screen->scrn_monitor == monitor) {
		card = XF86Config->conf_device_lst;
		while (card != NULL) {
		    if (screen->scrn_device == card) {
			xf86cfgScreen *scr = (xf86cfgScreen*)
			    XtCalloc(1, sizeof(xf86cfgScreen));
			int i;

			for (i = 0; i < computer.num_devices; i++)
			    if ((XF86ConfDevicePtr)(computer.devices[i]->config)
				== card)
				break;
			scr->screen = screen;
			scr->card = computer.devices[i];
			scr->monitor = device;
			scr->refcount = 0;
			++scr->card->refcount;
			++scr->monitor->refcount;
			computer.screens = (xf86cfgScreen**)
				XtRealloc((XtPointer)computer.screens,
					  sizeof(xf86cfgScreen*) *
					  (computer.num_screens + 1));
			CreateScreenWidget(scr);
			scr->type = SCREEN;
			computer.screens[computer.num_screens++] = scr;
			SetTip((xf86cfgDevice*)scr);
			break;
		    }
		    card = (XF86ConfDevicePtr)(card->list.next);
		}
		device->state = USED;
	    }
	    screen = (XF86ConfScreenPtr)(screen->list.next);
	}

	monitor = (XF86ConfMonitorPtr)(monitor->list.next);
    }
}

xf86cfgDevice *
AddDevice(int type, XtPointer config, int x, int y)
{
    switch (type) {
	case MOUSE:
	case KEYBOARD:
	case CARD:
	case MONITOR:
	    computer.devices = (xf86cfgDevice**)
		XtRealloc((XtPointer)computer.devices,
			  sizeof(xf86cfgDevice*) * (computer.num_devices + 1));
	    computer.devices[computer.num_devices] = (xf86cfgDevice*)
		XtCalloc(1, sizeof(xf86cfgDevice));
	    computer.devices[computer.num_devices]->config = config;
	    computer.devices[computer.num_devices]->widget =
		XtVaCreateManagedWidget(device_names[type], simpleWidgetClass,
					work,
					XtNx, x,
					XtNy, y,
					XtNtip, NULL,
					NULL);
	    computer.devices[computer.num_devices]->type = type;
	    computer.devices[computer.num_devices]->state = UNUSED;
	    computer.devices[computer.num_devices]->refcount = 0;
	    ++computer.num_devices;
	    break;
	default:
	    fprintf(stderr, "Bad argument to AddDevice.\n");
	    exit(1);
	    return (NULL);
    }

    UpdateMenuDeviceList(type);

    return (computer.devices[computer.num_devices - 1]);
}

/*ARGSUSED*/
static void
HelpCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    char *topic = NULL;

    switch (config_mode) {
	case CONFIG_LAYOUT:
	    topic = HELP_DEVICES;
	    break;
	case CONFIG_SCREEN:
	    topic = HELP_SCREEN;
	    break;
	case CONFIG_MODELINE:
	    topic = HELP_MODELINE;
	    break;
	case CONFIG_ACCESSX:
	    topic = HELP_ACCESSX;
	    break;
    }
    Help(topic);
}

void
SelectLayoutCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i, j;
    XF86ConfLayoutPtr lay = (XF86ConfLayoutPtr)user_data;
    XF86ConfInputrefPtr input;
    XF86ConfAdjacencyPtr adj;
    Widget sme, layopt;
    Arg args[1];
    char *str;

			       /* XXX Needs to check computer.layout,
				* because this function should also create
				* a new layout...
				*/
    if (lay == computer.layout && computer.layout)
	return;

    if (computer.layout != NULL) {
	for (i = 0; i < computer.num_layouts; i++) {
	    if (computer.layouts[i]->layout == computer.layout)
		break;
	}
	if (i < computer.num_layouts) {
	    XtFree((XtPointer)computer.layouts[i]->screen);
	    XtFree((XtPointer)computer.layouts[i]->position);
	}
	else {
	    computer.layouts = (xf86cfgLayout**)
		XtRealloc((XtPointer)computer.layouts, sizeof(xf86cfgLayout*) *
			  (computer.num_layouts + 1));
	    ++computer.num_layouts;
	}
	computer.layouts[i] = (xf86cfgLayout*)XtCalloc(1, sizeof(xf86cfgLayout));
	computer.layouts[i]->layout = computer.layout;
	computer.layouts[i]->num_layouts = computer.num_screens;
	computer.layouts[i]->screen = (xf86cfgScreen**)
	    XtMalloc(sizeof(xf86cfgScreen*) * computer.num_screens);
	computer.layouts[i]->position = (XPoint*)
	    XtMalloc(sizeof(XPoint) * computer.num_screens);
	for (j = 0; j < computer.num_screens; j++) {
	    computer.layouts[i]->screen[j] = computer.screens[j];
	    computer.layouts[i]->position[j].x = computer.screens[j]->widget->core.x;
	    computer.layouts[i]->position[j].y = computer.screens[j]->widget->core.y;
	}
    }

    if (lay != NULL) {
	for (i = 0; i < computer.num_layouts; i++)
	    if (computer.layouts[i]->layout == lay) {
		for (j = 0; j < computer.layouts[i]->num_layouts; j++) {
		    int k;

		    for (k = 0; k < computer.num_screens; k++)
			if (computer.screens[k] == computer.layouts[i]->screen[j]) {
			    XtMoveWidget(computer.screens[k]->widget,
					 computer.layouts[i]->position[j].x,
					 computer.layouts[i]->position[j].y);
			}
		}
		break;
	    }

	layoutsme = w;
	XtSetArg(args[0], XtNlabel, &str);
	XtGetValues(w, args, 1);
	XtSetArg(args[0], XtNstring, str);
	XtSetValues(layout, args, 1);
    }

    computer.layout = lay;

    for (i = 0; i < computer.num_devices; i++)
	computer.devices[i]->state = UNUSED;
    for (i = 0; i < computer.num_screens; i++)
	computer.screens[i]->state = UNUSED;

    if (lay == NULL) {
	char name[64];
	XF86ConfLayoutPtr l;
	int num_layouts = 0;

	l = XF86Config->conf_layout_lst;
	while (l != NULL) {
	    if (l->lay_adjacency_lst == NULL &&
		l->lay_inactive_lst == NULL &&
		l->lay_input_lst == NULL &&
		l->lay_option_lst == NULL &&
		l->lay_comment == NULL) {
		for (i = 0;
		     i < ((CompositeWidget)layout)->composite.num_children; i++)
		    if (strcmp(XtName(((CompositeWidget)layout)->composite.
			       children[i]), l->lay_identifier) == 0) {
			layoutsme = ((CompositeWidget)layout)->composite.children[i];
		    }
		computer.layout = l;
		XtSetArg(args[0], XtNstring, l->lay_identifier);
		XtSetValues(layout, args, 1);
		if (config_mode == CONFIG_LAYOUT)
		    DrawCables();
		if (config_mode == CONFIG_SCREEN)
		    ScreenSetup(True);
		return;
	    }
	    ++num_layouts;
	    l = (XF86ConfLayoutPtr)(l->list.next);
	}
	do {
	    XmuSnprintf(name, sizeof(name), "Layout%d", num_layouts);
	    ++num_layouts;
	} while (xf86findLayout(name,
		 XF86Config->conf_layout_lst) != NULL);
	l = (XF86ConfLayoutPtr)XtCalloc(1, sizeof(XF86ConfLayoutRec));

	l->lay_identifier = XtNewString(name);
	XF86Config->conf_layout_lst =
	    xf86addLayout(XF86Config->conf_layout_lst, l);
	layoutsme = XtVaCreateManagedWidget("sme", smeBSBObjectClass,
					    layoutp,
					    XtNlabel, name,
					    XtNmenuName, l->lay_identifier,
					    XtNleftBitmap, menuPixmap,
					    NULL);
	XtAddCallback(layoutsme, XtNcallback,
		      SelectLayoutCallback, (XtPointer)l);

	layopt = XtCreatePopupShell(l->lay_identifier, simpleMenuWidgetClass,
				    layoutp, NULL, 0);
	sme = XtCreateManagedWidget("default", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, DefaultLayoutCallback, NULL);
	sme = XtCreateManagedWidget("remove", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, RemoveLayoutCallback, NULL);
	XtRealizeWidget(layopt);

	computer.layout = l;
	XtSetArg(args[0], XtNstring, name);
	XtSetValues(layout, args, 1);
	if (config_mode == CONFIG_LAYOUT)
	    DrawCables();
	if (config_mode == CONFIG_SCREEN)
	    ScreenSetup(True);
	return;
    }

    input = lay->lay_input_lst;
    adj = lay->lay_adjacency_lst;

    for (i = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->config != NULL &&
	    (computer.devices[i]->type == MOUSE ||
	     computer.devices[i]->type == KEYBOARD)) {
	    while (input != NULL) {
		if (strcmp(input->iref_inputdev_str, ((XF86ConfInputPtr)
		    (computer.devices[i]->config))->inp_identifier) == 0) {
		    computer.devices[i]->state = USED;
		    break;
		}
		input = (XF86ConfInputrefPtr)(input->list.next);
	    }
	    input = lay->lay_input_lst;
	}

    for (i = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->type == CARD) {
	    while (adj != NULL) {
		XF86ConfScreenPtr screen = adj->adj_screen;

		if (computer.devices[i]->config != NULL &&
		    strcmp(screen->scrn_device_str, ((XF86ConfDevicePtr)
		    (computer.devices[i]->config))->dev_identifier) == 0) {
		    int j;

		    for (j = 0; j < computer.num_screens; j++)
			if (computer.screens[j]->card == computer.devices[i])
			    break;
		    computer.screens[j]->card->state = USED;
		    if (computer.screens[j]->monitor != NULL)
			computer.screens[j]->monitor->state = USED;
		    computer.screens[j]->state = USED;
		}

		adj = (XF86ConfAdjacencyPtr)(adj->list.next);
	    }
	    adj = lay->lay_adjacency_lst;
	}

    if (config_mode == CONFIG_LAYOUT)
	DrawCables();
    else if (config_mode == CONFIG_SCREEN)
	ScreenSetup(True);
}

/*ARGSUSED*/
void
DefaultLayoutCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    Widget layopt, sme;
    int i;
    char *str;
    XF86ConfLayoutPtr prev, tmp, lay;

    str = w && XtParent(w) ? XtName(XtParent(w)) : NULL;
    if (str == NULL)
	return;

    prev = XF86Config->conf_layout_lst;
    lay = xf86findLayout(str, prev);
    if (prev == lay)
	return;

    tmp = prev;
    while (tmp != NULL) {
	if (tmp == lay)
	    break;
	prev = tmp;
	tmp = (XF86ConfLayoutPtr)(tmp->list.next);
    }

    for (i = 1; i < ((CompositeWidget)layoutp)->composite.num_children; i++)
	XtDestroyWidget(((CompositeWidget)layoutp)->composite.children[i]);
    for (i = 0; i < layoutp->core.num_popups; i++)
	XtDestroyWidget(layoutp->core.popup_list[i]);

    prev->list.next = lay->list.next;
    lay->list.next = XF86Config->conf_layout_lst;
    XF86Config->conf_layout_lst = lay;

    layoutsme = NULL;
    lay = XF86Config->conf_layout_lst;
    while (lay != NULL) {
	sme = XtVaCreateManagedWidget("sme", smeBSBObjectClass,
				      layoutp,
				      XtNlabel, lay->lay_identifier,
				      XtNmenuName, lay->lay_identifier,
				      XtNleftBitmap, menuPixmap,
				      NULL);
	XtAddCallback(sme, XtNcallback, SelectLayoutCallback, (XtPointer)lay);
	if (layoutsme == NULL)
	    layoutsme = sme;
	layopt = XtCreatePopupShell(lay->lay_identifier, simpleMenuWidgetClass,
				    layoutp, NULL, 0);
	sme = XtCreateManagedWidget("default", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, DefaultLayoutCallback, NULL);
	sme = XtCreateManagedWidget("remove", smeBSBObjectClass,
				    layopt, NULL, 0);
	XtAddCallback(sme, XtNcallback, RemoveLayoutCallback, NULL);
	XtRealizeWidget(layopt);

	lay = (XF86ConfLayoutPtr)(lay->list.next);
    }
    SelectLayoutCallback(layoutsme,
			 XF86Config->conf_layout_lst, NULL);
}

/*ARGSUSED*/
void
RemoveLayoutCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    XF86ConfLayoutPtr prev, tmp, lay, rem;
    Widget sme = NULL;
    int i;
    char *str;
    Arg args[1];

    str = w && XtParent(w) ? XtName(XtParent(w)) : NULL;
    if (str == NULL)
	return;

    prev = XF86Config->conf_layout_lst;
    lay = xf86findLayout(str, prev);
    tmp = prev;
    while (tmp != NULL) {
	if (tmp == lay)
	    break;
	prev = tmp;
	tmp = (XF86ConfLayoutPtr)(tmp->list.next);
    }

    rem = lay;
    if (tmp != NULL)
	lay = (XF86ConfLayoutPtr)(tmp->list.next);
    if (lay == NULL && prev != tmp)
	lay = prev;

    if (lay != NULL) {
	int i;

	for (i = 0; i < ((CompositeWidget)layoutp)->composite.num_children;
	    i++) {
	    XtSetArg(args[0], XtNlabel, &str);
	    XtGetValues(((CompositeWidget)layoutp)->composite.children[i],
			args, 1);
	    if (strcmp(lay->lay_identifier, str) == 0) {
		layoutsme = ((CompositeWidget)layoutp)->composite.children[i];
		break;
	    }
	}
	SelectLayoutCallback(layoutsme, lay, NULL);
    }
    else {
	computer.layout = NULL;
	XtSetArg(args[0], XtNstring, "");
	XtSetValues(layout, args, 1);

	for (i = 0; i < computer.num_devices; i++)
	    computer.devices[i]->state = UNUSED;
	DrawCables();
    }

    for (i = 0; i < ((CompositeWidget)layoutp)->composite.num_children; i++) {
	XtSetArg(args[0], XtNlabel, &str);
	XtGetValues(((CompositeWidget)layoutp)->composite.children[i], args, 1);
	if (strcmp(rem->lay_identifier, str) == 0) {
	    sme = ((CompositeWidget)layoutp)->composite.children[i];
	    break;
	}
    }

    xf86removeLayout(XF86Config, rem);
    if (sme)
	XtDestroyWidget(sme);
}

void
SetTip(xf86cfgDevice *device)
{
    XF86OptionPtr option = NULL;
    char *tip, buffer[4096];
    Arg args[1];
    int len = 0;

    XtSetArg(args[0], XtNtip, &tip);
    XtGetValues(device->widget, args, 1);

    switch (device->type) {
	case MOUSE: {
	    XF86ConfInputPtr mouse = (XF86ConfInputPtr)device->config;

	    if (mouse == NULL)
		return;
	    len = XmuSnprintf(buffer, sizeof(buffer),
			      "Identifier \"%s\"\n"
			      "Driver     \"mouse\"\n",
			      mouse->inp_identifier);
	    option = mouse->inp_option_lst;
	}   break;
	case KEYBOARD: {
    	    XF86ConfInputPtr keyboard = (XF86ConfInputPtr)device->config;

	    if (keyboard == NULL)
		return;
	    len = XmuSnprintf(buffer, sizeof(buffer),
			      "Identifier \"%s\"\n"
			      "Driver     \"keyboard\"\n",
			      keyboard->inp_identifier);
	    option = keyboard->inp_option_lst;
	}   break;
	case CARD: {
	    XF86ConfDevicePtr card = (XF86ConfDevicePtr)device->config;

	    if (card == NULL)
		return;
	    len = XmuSnprintf(buffer, sizeof(buffer),
			      "Identifier \"%s\"\n"
			      "Driver     \"%s\"\n",
			      card->dev_identifier,
			      card->dev_driver);
	    option = card->dev_option_lst;
	}   break;
	case MONITOR: {
	    XF86ConfMonitorPtr monitor = (XF86ConfMonitorPtr)device->config;

	    if (monitor == NULL)
		return;
	    if (monitor->mon_vendor != NULL)
		len = XmuSnprintf(buffer, sizeof(buffer),
				  "Identifier \"%s\"\n"
				  "Vendor     \"%s\"\n",
				  monitor->mon_identifier,
				  monitor->mon_vendor);
	    else
		len = XmuSnprintf(buffer, sizeof(buffer),
				  "Identifier \"%s\"\n",
				  monitor->mon_identifier);
	    option = monitor->mon_option_lst;
	}   break;
	case SCREEN: {
	    XF86ConfScreenPtr screen = (XF86ConfScreenPtr)device->config;

	    if (screen == NULL)
		return;
	    len = XmuSnprintf(buffer, sizeof(buffer),
			      "Identifier \"%s\"\n",
			      screen->scrn_identifier);
	    if (screen->scrn_device_str != NULL)
		len += XmuSnprintf(buffer + len, sizeof(buffer),
				   "Device     \"%s\"\n",
				   screen->scrn_device_str);
	    if (screen->scrn_monitor_str != NULL)
		len += XmuSnprintf(buffer + len, sizeof(buffer),
				   "Monitor    \"%s\"\n",
				   screen->scrn_monitor_str);
	    option = screen->scrn_option_lst;
	}   break;
	case SERVER: {
	    len = XmuSnprintf(buffer, sizeof(buffer),
			      "%s\n", "Server Flags");
	    option = XF86Config->conf_flags->flg_option_lst;
	}   break;
    }

    while (option && len < sizeof(buffer) - 1) {
	len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			   "Option     \"%s\"",
			   option->opt_name);
	if (option->opt_val != NULL)
	    len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			       " \"%s\"\n",
			       option->opt_val);
	else
	    len += XmuSnprintf(buffer + len, sizeof(buffer) - len,
			       "%s", "\n");
	option = (XF86OptionPtr)(option->list.next);
    }

    tip = buffer;
    XtSetArg(args[0], XtNtip, tip);
    XtSetValues(device->widget, args, 1);
}

/*ARGSUSED*/
void
AddDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    AddDevice((long)user_data, NULL, 6, 6);
}

void
SmeConfigureDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i;

    switch ((long)user_data) {
	case MOUSE:
	case KEYBOARD:
	case CARD:
	case MONITOR:
	    for (i = 0; i < computer.num_devices; i++)
		if (computer.devices[i]->type == (long)user_data) {
		    config = computer.devices[i]->widget;
		    ConfigureDeviceCallback(w, NULL, NULL);
		}
	    break;

	/* hack for newly added devices */
	case -(MOUSE + 100):
	case -(KEYBOARD + 100):
	case -(CARD + 100):
	case -(MONITOR + 100):
	    for (i = 0; i < computer.num_devices; i++)
		if (-(computer.devices[i]->type + 100) == (long)user_data &&
		    computer.devices[i]->config == NULL) {
		    config = computer.devices[i]->widget;
		    ConfigureDeviceCallback(w, NULL, NULL);
		}
	    break;

	default:
	    for (i = 0; i < computer.num_devices; i++)
		if (computer.devices[i]->config == user_data) {
		    config = computer.devices[i]->widget;
		    ConfigureDeviceCallback(w, NULL, NULL);
		}
	    break;
    }
}

void
ConfigureDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i, j;

    if (config_mode == CONFIG_LAYOUT) {
	for (i = 0; i < computer.num_devices; i++) {
	    if (computer.devices[i]->widget == config) {
		switch (computer.devices[i]->type) {
		    case MOUSE: {
			XF86ConfInputPtr mouse =
			    MouseConfig(computer.devices[i]->config);

			if (mouse != NULL && computer.devices[i]->config == NULL) {
			    XF86Config->conf_input_lst =
				xf86addInput(XF86Config->conf_input_lst,
					     mouse);
			    computer.devices[i]->config = (XtPointer)mouse;
			}
			SetTip(computer.devices[i]);
		    }	break;
		    case KEYBOARD: {
			XF86ConfInputPtr keyboard =
			    KeyboardConfig(computer.devices[i]->config);

			if (keyboard != NULL && computer.devices[i]->config == NULL) {
			    XF86Config->conf_input_lst =
				xf86addInput(XF86Config->conf_input_lst,
					     keyboard);
			    computer.devices[i]->config = (XtPointer)keyboard;
			}
			SetTip(computer.devices[i]);
		    }	break;
		    case CARD: {
			XF86ConfDevicePtr card =
			    CardConfig(computer.devices[i]->config);

			if (card != NULL && computer.devices[i]->config == NULL) {
			    XF86Config->conf_device_lst =
				xf86addDevice(XF86Config->conf_device_lst,
					      card);
			    computer.devices[i]->config = (XtPointer)card;
			}
			SetTip(computer.devices[i]);
			for (j = 0; j < computer.num_screens; j++)
			    if (computer.screens[j]->card->widget == config)
				SetTip((xf86cfgDevice*)computer.screens[j]);
		    }	break;
		    case MONITOR: {
			XF86ConfMonitorPtr monitor =
			    MonitorConfig(computer.devices[i]->config);

			if (monitor != NULL && computer.devices[i]->config == NULL) {
			    XF86Config->conf_monitor_lst =
				xf86addMonitor(XF86Config->conf_monitor_lst,
					       monitor);
			    computer.devices[i]->config = (XtPointer)monitor;
			}
			SetTip(computer.devices[i]);
			for (j = 0; j < computer.num_screens; j++)
			    if (computer.screens[j]->monitor->widget == config)
				SetTip((xf86cfgDevice*)computer.screens[j]);
		    }	break;
		}
		/* Need to update because it may have been renamed */
		UpdateMenuDeviceList(computer.devices[i]->type);
		break;
	    }
	}
    }
    else if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    if (computer.screens[i]->widget == config) {
		if (ScreenConfig(computer.screens[i]->screen) != NULL)
		    SetTip((xf86cfgDevice*)computer.screens[i]);
	    }
    }
}

void
OptionsCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i;
    XF86OptionPtr *options = NULL;
#ifdef USE_MODULES
    xf86cfgModuleOptions *drv_opts = NULL;
#endif

    if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    if (computer.screens[i]->widget == config) {
		options = &(computer.screens[i]->screen->scrn_option_lst);
		break;
	    }
    }
    else {
	for (i = 0; i < computer.num_devices; i++)
	    if (computer.devices[i]->widget == config)
		break;

	if (i >= computer.num_devices) {
	    if (XF86Config->conf_flags == NULL)
		XF86Config->conf_flags = (XF86ConfFlagsPtr)
		    XtCalloc(1, sizeof(XF86ConfFlagsRec));
	    options = &(XF86Config->conf_flags->flg_option_lst);
	}
	else {
	    switch (computer.devices[i]->type) {
		case MOUSE:
		case KEYBOARD:
		    options = (XF86OptionPtr*)&(((XF86ConfInputPtr)
			(computer.devices[i]->config))->inp_option_lst);
#ifdef USE_MODULES
		    if (!nomodules) {
			char *drv = ((XF86ConfInputPtr)
				(computer.devices[i]->config))->inp_driver;

			if (drv) {
			    drv_opts = module_options;
			    while (drv_opts) {
				if (drv_opts->type == InputModule &&
				    strcmp(drv_opts->name, drv) == 0)
				    break;
				drv_opts = drv_opts->next;
			    }
			}
		    }
#endif

		    break;
		case CARD:
		    options = (XF86OptionPtr*)&(((XF86ConfDevicePtr)
			(computer.devices[i]->config))->dev_option_lst);
#ifdef USE_MODULES
		    if (!nomodules) {
			char *drv = ((XF86ConfDevicePtr)
				(computer.devices[i]->config))->dev_driver;

			if (drv) {
			    drv_opts = module_options;
			    while (drv_opts) {
				if (drv_opts->type == VideoModule &&
				    strcmp(drv_opts->name, drv) == 0)
				    break;
				drv_opts = drv_opts->next;
			    }
			}
		    }
#endif
		    break;
		case MONITOR:
		    options = (XF86OptionPtr*)&(((XF86ConfMonitorPtr)
			(computer.devices[i]->config))->mon_option_lst);
		    break;
	    }
	}
    }

#ifdef USE_MODULES
    OptionsPopup(options, drv_opts ? drv_opts->name : NULL,
		 drv_opts ? drv_opts->option : NULL);
#else
    OptionsPopup(options);
#endif
    if (config_mode == CONFIG_SCREEN) {
	XF86OptionPtr option, options;
	int rotate = 0;

	options = computer.screens[i]->screen->scrn_option_lst;
	if ((option = xf86findOption(options, "Rotate")) != NULL) {
	    if (option->opt_val != NULL)
		rotate = strcasecmp(option->opt_val, "CW") == 0 ? 1 :
			 strcasecmp(option->opt_val, "CCW") == 0 ? -1 : 0;
	    XtFree(option->opt_val);
	    option->opt_val = XtNewString(rotate > 0 ? "CW" : "CCW");
	    computer.screens[i]->rotate = rotate;
	}
	else
	    computer.screens[i]->rotate = 0;
	UpdateScreenUI();
	AdjustScreenUI();
	SetTip((xf86cfgDevice*)computer.screens[i]);
    }
    else {
	if (i >= computer.num_devices)
	    SetTip(&cpu_device);
	else
	    SetTip(computer.devices[i]);
    }
}

void
EnableDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i;

    if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    if (computer.screens[i]->widget == config) {
		computer.screens[i]->state = USED;
		computer.screens[i]->card->state = USED;
		ScreenSetup(False);
		return;
	    }
    }

    for (i = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->widget == config) {
	    if (computer.devices[i]->state == USED)
		return;
	    computer.devices[i]->state = USED;
	    DrawCables();
	    break;
	}
    if (i >= computer.num_devices || computer.layout == NULL)
	return;
    switch (computer.devices[i]->type) {
	case MOUSE:
	case KEYBOARD: {
	    int nmouses = 0, nkeyboards = 0;
	    XF86ConfInputPtr input = (XF86ConfInputPtr)
		(computer.devices[i]->config);
	    XF86ConfInputrefPtr nex, iref = computer.layout->lay_input_lst;
	    XF86OptionPtr option;

	    nex = iref;
	    while (nex != NULL) {
		if (strcasecmp(nex->iref_inputdev->inp_driver, "mouse") == 0)
		    ++nmouses;
		else if (IS_KBDDRIV(nex->iref_inputdev->inp_driver))
		    ++nkeyboards;
		iref = nex;
		nex = (XF86ConfInputrefPtr)(nex->list.next);
	    }
	    nex = (XF86ConfInputrefPtr)XtCalloc(1, sizeof(XF86ConfInputrefRec));
	    nex->list.next = NULL;
	    nex->iref_inputdev = input;
	    nex->iref_inputdev_str = XtNewString(input->inp_identifier);
	    if (nmouses == 0 && computer.devices[i]->type == MOUSE) 
		option = xf86newOption(XtNewString("CorePointer"), NULL);
	    else if (nkeyboards == 0 && computer.devices[i]->type == KEYBOARD)
		option = xf86newOption(XtNewString("CoreKeyboard"), NULL);
	    else
		option = xf86newOption(XtNewString("SendCoreEvents"), NULL);
	    nex->iref_option_lst = option;
	    computer.layout->lay_input_lst =
		xf86addInputref(computer.layout->lay_input_lst, nex);
	}   break;
	case CARD:
	    for (i = 0; i < computer.num_screens; i++) {
		if (computer.screens[i]->card->widget == config &&
		    computer.screens[i]->state != USED) {
		    XF86ConfAdjacencyPtr adj;

		    adj = (XF86ConfAdjacencyPtr)
			XtCalloc(1, sizeof(XF86ConfAdjacencyRec));
		    adj->adj_screen = computer.screens[i]->screen;
		    adj->adj_screen_str = XtNewString(computer.screens[i]->
			screen->scrn_identifier);
		    computer.layout->lay_adjacency_lst = (XF86ConfAdjacencyPtr)
			xf86addListItem((GenericListPtr)computer.layout->
				    lay_adjacency_lst, (GenericListPtr)adj);
		    computer.screens[i]->state = USED;
		}
	    }
	    break;
	case MONITOR:
	    break;
    }
}

void
DisableDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i;

    if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    if (computer.screens[i]->widget == config) {
		computer.screens[i]->state = UNUSED;
		computer.screens[i]->card->state = UNUSED;
		ScreenSetup(False);
		return;
	    }
    }

    for (i = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->widget == config) {
	    if (computer.devices[i]->state == UNUSED)
		return;
	    computer.devices[i]->state = UNUSED;
	    DrawCables();
	    break;
	}
    if (i >= computer.num_devices || computer.layout == NULL)
	return;
    switch (computer.devices[i]->type) {
	case MOUSE:
	case KEYBOARD:
	    xf86removeInputRef(computer.layout,
		(XF86ConfInputPtr)(computer.devices[i]->config));
	    break;
	case CARD: {
	    XF86ConfAdjacencyPtr adj;
	    int j;

	    if (computer.layout == NULL)
		break;
	    for (j = 0; j < computer.num_screens; j++)
		if (computer.screens[j]->card->widget == config) {
		    adj = computer.layout->lay_adjacency_lst;
		    while (adj != NULL) {
			if (adj->adj_screen == computer.screens[j]->screen) {
			    xf86removeAdjacency(computer.layout, adj);
			    break;
			}
			adj = (XF86ConfAdjacencyPtr)(adj->list.next);
		    }
		    computer.screens[j]->state = UNUSED;
		    break;
		}
	}   break;
	case MONITOR:
	    break;
    }
}

/* ARGSUSED */
void
RemoveDeviceCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i, j;

    for (i = 0; i < computer.num_screens; i++)
	if (computer.screens[i]->widget == config) {
	    RemoveScreen(computer.screens[i]->monitor,
			 computer.screens[i]->card);
	    ScreenSetup(False);
	    return;
	}

    for (i = 0; i < computer.num_devices; i++) {
	if (computer.devices[i]->widget == config) {
	    switch (computer.devices[i]->type) {
		case MOUSE:
		case KEYBOARD:
		    xf86removeInput(XF86Config,
			(XF86ConfInputPtr)(computer.devices[i]->config));
		    break;
		case CARD:
		case MONITOR:
		    break;
	    }

	    if (computer.devices[i]->type == CARD) {
		for (j = 0; j < computer.num_screens; j++)
		    if (computer.screens[j]->card == computer.devices[i]) {
			RemoveScreen(computer.screens[j]->monitor,
				     computer.devices[i]);
			--j;
		    }
		if (computer.devices[i]->refcount <= 0)
		    xf86removeDevice(XF86Config,
			(XF86ConfDevicePtr)(computer.devices[i]->config));
	    }
	    else if (computer.devices[i]->type == MONITOR) {
		for (j = 0; j < computer.num_screens; j++)
		    if (computer.screens[j]->monitor == computer.devices[i]) {
			RemoveScreen(computer.devices[i],
				     computer.screens[j]->card);
			--j;
		    }
		if (computer.devices[i]->refcount <= 0)
		    xf86removeMonitor(XF86Config,
			(XF86ConfMonitorPtr)(computer.devices[i]->config));
	    }

	    if (computer.devices[i]->refcount <= 0) {
		int type = computer.devices[i]->type;

		XtDestroyWidget(computer.devices[i]->widget);
		XtFree((XtPointer)computer.devices[i]);
		if (--computer.num_devices > i)
		    memmove(&computer.devices[i], &computer.devices[i + 1],
			    (computer.num_devices - i) * sizeof(xf86cfgDevice*));

		DrawCables();
		UpdateMenuDeviceList(type);
	    }

	    break;
	}
    }
}

void
UpdateMenuDeviceList(int type)
{
    Widget sme = NULL, menu = NULL;
    int i, count;
    static char *mouseM = "mouseM", *keyboardM = "keyboardM",
		*cardM = "cardM", *monitorM = "monitorM";

    for (i = count = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->type == type)
	    ++count;

    switch (type) {
	case MOUSE:
	    sme = mouseSme;
	    menu = mouseMenu;
	    break;
	case KEYBOARD:
	    sme = keyboardSme;
	    menu = keyboardMenu;
	    break;
	case CARD:
	    sme = cardSme;
	    menu = cardMenu;
	    break;
	case MONITOR:
	    sme = monitorSme;
	    menu = monitorMenu;
	    break;
    }

    if (menu)
	for (i = ((CompositeWidget)menu)->composite.num_children - 1; i >= 0; i--)
	    XtDestroyWidget(((CompositeWidget)menu)->composite.children[i]);

    if (count < 2) {
	XtVaSetValues(sme, XtNmenuName, NULL, XtNleftBitmap, None, NULL);
	return;
    }

    switch (type) {
	case MOUSE:
	    if (mouseMenu == NULL)
		menu = mouseMenu =
		    XtCreatePopupShell(mouseM, simpleMenuWidgetClass,
				       XtParent(mouseSme), NULL, 0);
	    XtVaSetValues(mouseSme, XtNmenuName, mouseM,
			  XtNleftBitmap, menuPixmap, NULL);
	    break;
	case KEYBOARD:
	    if (keyboardMenu == NULL)
		menu = keyboardMenu =
		    XtCreatePopupShell(keyboardM, simpleMenuWidgetClass,
				       XtParent(keyboardSme), NULL, 0);
	    XtVaSetValues(keyboardSme, XtNmenuName, keyboardM,
			  XtNleftBitmap, menuPixmap, NULL);
	    break;
	case CARD:
	    if (cardMenu == NULL)
		menu = cardMenu =
		    XtCreatePopupShell(cardM, simpleMenuWidgetClass,
				       XtParent(cardSme), NULL, 0);
	    XtVaSetValues(cardSme, XtNmenuName, cardM,
			  XtNleftBitmap, menuPixmap, NULL);
	    break;
	case MONITOR:
	    if (monitorMenu == NULL)
		menu = monitorMenu =
		    XtCreatePopupShell(monitorM, simpleMenuWidgetClass,
				       XtParent(monitorSme), NULL, 0);
	    XtVaSetValues(monitorSme, XtNmenuName, monitorM,
			  XtNleftBitmap, menuPixmap, NULL);
	    break;
    }

    for (i = 0; i < computer.num_devices; i++)
	if (computer.devices[i]->type == type) {
	    char *label = NULL;

	    if (computer.devices[i]->config) {
		switch (type) {
		    case MOUSE:
		    case KEYBOARD:
			label = ((XF86ConfInputPtr)computer.devices[i]->config)
			    ->inp_identifier;
			break;
		    case CARD:
			label = ((XF86ConfDevicePtr)computer.devices[i]->config)
			    ->dev_identifier;
			break;
		    case MONITOR:
			label = ((XF86ConfMonitorPtr)computer.devices[i]->config)
			    ->mon_identifier;
			break;
		}
	    }
	    else {
		switch (type) {
		    case MOUSE:
			label = "newMouse";
			break;
		    case KEYBOARD:
			label = "newKeyboard";
			break;
		    case CARD:
			label = "newCard";
			break;
		    case MONITOR:
			label = "newMonitor";
			break;
		}
	    }

	    sme = XtCreateManagedWidget(label, smeBSBObjectClass, menu, NULL, 0);
	    XtAddCallback(sme, XtNcallback, SmeConfigureDeviceCallback,
			  computer.devices[i]->config ?
			  computer.devices[i]->config :
			  (XtPointer) (-((long)type + 100)));
	}
}

/*ARGSUSED*/
void
SelectDeviceAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    device = w;
    xpos = event->xbutton.x_root;
    ypos = event->xbutton.y_root;
    XDefineCursor(XtDisplay(device), XtWindow(device), no_cursor);

    if (config_mode == CONFIG_SCREEN) {
	sxpos = device->core.x;
	sypos = device->core.y;
    }
}

/*ARGSUSED*/
void
MoveDeviceAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    int dx, dy, x, y, oldx, oldy;

    if (device == NULL || device != w)
	return;

    dx = event->xbutton.x_root - xpos;
    dy = event->xbutton.y_root - ypos;

    oldx = device->core.x;
    oldy = device->core.y;
    x = device->core.x + dx;
    y = device->core.y + dy;

    if (x < 0)
	x = 0;
    else if (x + device->core.width > XtParent(device)->core.width)
	x = XtParent(device)->core.width - device->core.width;
    if (y < 0)
	y = 0;
    else if (y + device->core.height > XtParent(device)->core.height)
	y = XtParent(device)->core.height - device->core.height;

    dx = x - oldx;
    dy = y - oldy;

    XRaiseWindow(XtDisplay(device), XtWindow(device));
    XtMoveWidget(device, x, y);

    xpos += dx;
    ypos += dy;
}

/*ARGSUSED*/
void
UnselectDeviceAction(Widget w, XEvent *ev, String *params, Cardinal *num_params)
{
    if (device != NULL) {
	XUndefineCursor(XtDisplay(device), XtWindow(device));

	if (config_mode == CONFIG_SCREEN)
	    ScreenSetup(False);
	device = NULL;
    }
}

/*ARGSUSED*/
void
DevicePopupMenu(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    static Widget configure, options, enable, disable, remove;
    static int first = 1;
    int i;
    xf86cfgDevice *dev;

    if (first) {
	first = 0;

	popup = XtCreatePopupShell("popup", simpleMenuWidgetClass,
				   toplevel, NULL, 0);
	configure = XtCreateManagedWidget("configure", smeBSBObjectClass,
					  popup, NULL, 0);
	XtAddCallback(configure, XtNcallback, ConfigureDeviceCallback, NULL);
	options = XtCreateManagedWidget("options", smeBSBObjectClass,
					popup, NULL, 0);
	XtAddCallback(options, XtNcallback, OptionsCallback, NULL);
	XtCreateManagedWidget("line", smeLineObjectClass,
			      popup, NULL, 0);
	enable = XtCreateManagedWidget("enable", smeBSBObjectClass,
				       popup, NULL, 0);
	XtAddCallback(enable, XtNcallback, EnableDeviceCallback, NULL);
	disable = XtCreateManagedWidget("disable", smeBSBObjectClass,
					popup, NULL, 0);
	XtAddCallback(disable, XtNcallback, DisableDeviceCallback, NULL);
	XtCreateManagedWidget("line", smeLineObjectClass,
			      popup, NULL, 0);
	remove = XtCreateManagedWidget("remove", smeBSBObjectClass,
				       popup, NULL, 0);
	XtAddCallback(remove, XtNcallback, RemoveDeviceCallback, NULL);

	XtRealizeWidget(popup);
    }

    dev = NULL;
    if (config_mode == CONFIG_LAYOUT) {
	for (i = 0; i < computer.num_devices; i++)
	    if (computer.devices[i]->widget == w) {
		dev = computer.devices[i];
		break;
	    }
	if (i >= computer.num_devices && strcmp(XtName(w), "cpu"))
	    return;
	if (dev == NULL)
	    dev = &cpu_device;
    }
    else if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    if (computer.screens[i]->widget == w) {
		dev = (xf86cfgDevice*)computer.screens[i];
		break;
	    }
    }
    if (dev == NULL)
	return;

    config = w;

    if (dev->type != SERVER) {
	XtSetSensitive(configure, True);
	XtSetSensitive(remove, True);
	XtSetSensitive(options, dev->config != NULL);
	if (computer.layout == NULL || dev->config == NULL ||
	    dev->type == MONITOR) {
	    XtSetSensitive(enable, False);
	    XtSetSensitive(disable, False);
	}
	else if (dev->state == USED) {
	    XtSetSensitive(enable, False);
	    XtSetSensitive(disable, True);
	}
	else {
	    XtSetSensitive(enable, True);
	    XtSetSensitive(disable, False);
	}
    }
    else {
	XtSetSensitive(configure, False);
	XtSetSensitive(options, True);
	XtSetSensitive(enable, False);
	XtSetSensitive(disable, False);
	XtSetSensitive(remove, False);
    }

    XtMoveWidget(popup, event->xbutton.x_root, event->xbutton.y_root);
    XtPopup(popup, XtGrabNone);
}

/*ARGSUSED*/
void
DevicePopdownMenu(Widget w, XEvent *event, String *params, Cardinal *num_params)
{
    if (popup && XtIsRealized(popup))
	XtPopdown(popup);
}

void RenameLayoutAction(Widget w, XEvent *event,
			String *params, Cardinal *num_params)
{
    XF86ConfLayoutPtr lay = XF86Config->conf_layout_lst;
    Arg args[1];
    char *name;

    XtSetArg(args[0], XtNstring, &name);
    XtGetValues(layout, args, 1);

    if (computer.layout == NULL || (computer.layout &&
	strcasecmp(name, computer.layout->lay_identifier)) == 0)
	return;

    if (name == NULL && *name == '\0') {
	/* tell user about error */
	return;
    }

    while (lay) {
	if (strcasecmp(name, lay->lay_identifier) == 0)
	    /* tell user about error */
	    return;
	lay = (XF86ConfLayoutPtr)(lay->list.next);
    }

    XtSetArg(args[0], XtNlabel, name);
    XtSetValues(layoutsme, args, 1);
    xf86renameLayout(XF86Config, computer.layout, name);
}

/*ARGSUSED*/
static void
ComputerEventHandler(Widget w, XtPointer closure,
		     XEvent *event, Boolean *continue_to_dispatch)
{
    if (event->xexpose.count > 1)
	return;

    if (config_mode == CONFIG_LAYOUT)
	DrawCables();
}

void
DrawCables(void)
{
    Display *display;
    Window window;
    int ox, oy, i;
    xf86cfgScreen **scr = computer.screens;

    if (config_mode != CONFIG_LAYOUT)
	return;

    ox = computer.cpu->core.x + (computer.cpu->core.width >> 1);
    oy = computer.cpu->core.y + (computer.cpu->core.height >> 1);

    display = XtDisplay(work);
    window = XtWindow(work);
    XClearWindow(display, window);

    for (i = 0; i < computer.num_devices; i++) {
	if (computer.devices[i]->state == USED &&
	    computer.devices[i]->type != MONITOR)
	    DrawCable(display, window, ox, oy,
		      computer.devices[i]->widget->core.x +
			    (computer.devices[i]->widget->core.width>>1),
		      computer.devices[i]->widget->core.y +
			    (computer.devices[i]->widget->core.height>>1));

    }
    for (i = 0; i < computer.num_screens; i++) {
	if (scr[i]->monitor != NULL)
	    DrawCable(display, window,
		      scr[i]->card->widget->core.x +
			    (scr[i]->card->widget->core.width>>1),
		      scr[i]->card->widget->core.y +
			    (scr[i]->card->widget->core.height>>1),
		      scr[i]->monitor->widget->core.x +
			    (scr[i]->monitor->widget->core.width>>1),
		      scr[i]->monitor->widget->core.y +
			    (scr[i]->monitor->widget->core.height>>1));
    }
}

static void
DrawCable(Display *display, Window window, int o_x, int o_y, int d_x, int d_y)
{
    XDrawLine(display, window, cablegcshadow, o_x, o_y, d_x, d_y);
    XDrawLine(display, window, cablegc, o_x, o_y, d_x, d_y);
}

/*ARGSUSED*/
void
SetConfigModeCallback(Widget w, XtPointer user_data, XtPointer call_data)
{
    int i, mode = (long)user_data;
    Arg args[3];
    char *ptr;
    static Dimension height;

    if (mode == config_mode)
	return;
    XtSetArg(args[0], XtNlabel, &ptr);
    XtGetValues(w, args, 1);
    XtSetArg(args[0], XtNlabel, ptr);
    XtSetValues(topMenu, args, 1);

    if (config_mode == CONFIG_LAYOUT) {
	XtSetArg(args[0], XtNheight, &height);
	XtGetValues(commands, args, 1);
	for (i = 0; i < computer.num_devices; i++)
	    XtUnmapWidget(computer.devices[i]->widget);
	XtUnmapWidget(commands);
	XtUnmapWidget(computer.cpu);
	XtSetSensitive(commands, False);
	XtSetArg(args[0], XtNheight, 1);
	XtSetArg(args[1], XtNmin, 1);
	XtSetArg(args[2], XtNmax, 1);
	XtSetValues(commands, args, 3);
    }
    else if (config_mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    XtUnmapWidget(computer.screens[i]->widget);
    }
    else if (config_mode == CONFIG_MODELINE) {
	VideoModeConfigureEnd();
	XtSetSensitive(layout, True);
	XtSetSensitive(layoutm, True);
    }
    else if (config_mode == CONFIG_ACCESSX) {
	AccessXConfigureEnd();
	XtSetSensitive(layout, True);
	XtSetSensitive(layoutm, True);
    }

    config_mode = mode;
    XClearWindow(XtDisplay(work), XtWindow(work));
    if (mode == CONFIG_LAYOUT) {
	for (i = 0; i < computer.num_devices; i++)
	    XtMapWidget(computer.devices[i]->widget);
	XtSetArg(args[0], XtNheight, height);
	XtSetArg(args[1], XtNmin, height);
	XtSetArg(args[2], XtNmax, height);
	XtSetValues(commands, args, 3);
	XtMapWidget(commands);
	XtMapWidget(computer.cpu);
	XtSetSensitive(commands, True);
	DrawCables();
    }
    else if (mode == CONFIG_SCREEN) {
	for (i = 0; i < computer.num_screens; i++)
	    XtMapWidget(computer.screens[i]->widget);
	ScreenSetup(True);
    }
    else if (mode == CONFIG_MODELINE) {
	VideoModeConfigureStart();
	XtSetSensitive(layout, False);
	XtSetSensitive(layoutm, False);
    }
    else if (mode == CONFIG_ACCESSX) {
	AccessXConfigureStart();
	XtSetSensitive(layout, False);
	XtSetSensitive(layoutm, False);
    }
}

static void
ScreenSetup(Bool check)
{
    if (check) {
	int i;

	for (i = 0; i < computer.num_layouts; i++)
	    if (computer.layouts[i]->layout == computer.layout)
		break;

	/* Just to put the screens in the correct positions */
	if (i >= computer.num_layouts)
	    AdjustScreenUI();
    }

    UpdateScreenUI();
    AdjustScreenUI();
}