andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
42bc198775
xserver-multidpi/hw/dmx/config/xdmxconfig.c
Cyril Brulebois 33dad2b74e hw/dmx: Stop using variables for text widgets. 
They are unused in the sense they're not getting any callback set up, so
there's no point in storing them into variables. Keep the initial
alignment of the parameters to try and reduce the diff noise.

Those warnings go away accordingly:
|   CC     xdmxconfig-xdmxconfig.o
| xdmxconfig.c: In function ‘main’:
| xdmxconfig.c:881:29: warning: variable ‘quittext’ set but not used [-Wunused-but-set-variable]
| xdmxconfig.c:880:53: warning: variable ‘abouttext’ set but not used [-Wunused-but-set-variable]

Reviewed-by: Jeremy Huddleston <jeremyhu@apple.com>
Signed-off-by: Cyril Brulebois <kibi@debian.org>
2011-06-16 00:44:08 +02:00

1192 lines
49 KiB
C
Raw Blame History

/*
* Copyright 2002 Red Hat Inc., Durham, North Carolina.
*
* All Rights Reserved.
*
* 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 on 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 (including the
* next paragraph) 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
* NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
* 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.
*/
/*
* Authors:
* Rickard E. (Rik) Faith <faith@redhat.com>
*
*/
#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Box.h>
/* #include <X11/Xaw/Paned.h> */
#include <X11/Xaw/Command.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Dialog.h>
#include <X11/keysym.h>
#include <X11/Xmu/SysUtil.h>
#include "Canvas.h"
#include "dmxparse.h"
#include "dmxprint.h"
#include "dmxlog.h"
extern int yyparse(void);
extern FILE *yyin;
#define DMX_INFO "xdmxconfig v0.9\nCopyright 2002 Red Hat Inc.\n"
#define DMX_MAIN_WIDTH 800
#define DMX_MAIN_HEIGHT 600
#define DMX_DATA_WIDTH 200
#define DMX_DATA_HEIGHT 200
#define DMX_CANVAS_WIDTH 400
#define DMX_CANVAS_HEIGHT 500
DMXConfigEntryPtr dmxConfigEntry;
static DMXConfigVirtualPtr dmxConfigCurrent, dmxConfigNewVirtual;
static DMXConfigDisplayPtr dmxConfigCurrentDisplay, dmxConfigNewDisplay;
static int dmxConfigGrabbed, dmxConfigGrabbedFine;
static int dmxConfigGrabbedX, dmxConfigGrabbedY;
static char *dmxConfigFilename;
static GC dmxConfigGC, dmxConfigGCRev, dmxConfigGCHL;
static int dmxConfigGCInit = 0;
static Dimension dmxConfigWidgetWidth, dmxConfigWidgetHeight;
static Dimension dmxConfigWallWidth, dmxConfigWallHeight;
static double dmxConfigScaleX, dmxConfigScaleY;
static int dmxConfigNotSaved;
static enum {
dmxConfigStateOpen,
dmxConfigStateSave
} dmxConfigState;
/* Global widgets */
static Widget canvas;
static Widget cnamebox, cdimbox;
static Widget openpopup, opendialog;
static Widget namebox, dimbox, rtbox, origbox;
static Widget okbutton, buttonpopup;
static Widget ecbutton, dcbutton;
static Widget ndbutton0, ndbutton1, edbutton, ddbutton;
static Widget ecpopup, ecdialog0, ecdialog1;
static Widget edpopup, eddialog0, eddialog1, eddialog2;
static Widget aboutpopup, quitpopup;
static void dmxConfigCanvasGCs(void)
{
Display *dpy = XtDisplay(canvas);
Window win = XtWindow(canvas);
XGCValues gcvals;
unsigned long mask;
Colormap colormap;
XColor fg, bg, hl, tmp;
if (dmxConfigGCInit++) return;
XtVaGetValues(canvas, XtNcolormap, &colormap, NULL);
XAllocNamedColor(XtDisplay(canvas), colormap, "black", &bg, &tmp);
XAllocNamedColor(XtDisplay(canvas), colormap, "white", &fg, &tmp);
XAllocNamedColor(XtDisplay(canvas), colormap, "red", &hl, &tmp);
mask = (GCFunction | GCPlaneMask | GCClipMask | GCForeground |
GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
GCFillStyle);
/* FIXME: copy this from widget */
gcvals.function = GXcopy;
gcvals.plane_mask = AllPlanes;
gcvals.clip_mask = None;
gcvals.foreground = fg.pixel;
gcvals.background = bg.pixel;
gcvals.line_width = 0;
gcvals.line_style = LineSolid;
gcvals.cap_style = CapNotLast;
gcvals.fill_style = FillSolid;
dmxConfigGC = XCreateGC(dpy, win, mask, &gcvals);
gcvals.foreground = hl.pixel;
dmxConfigGCHL = XCreateGC(dpy, win, mask, &gcvals);
gcvals.foreground = bg.pixel;
gcvals.background = fg.pixel;
dmxConfigGCRev = XCreateGC(dpy, win, mask, &gcvals);
}
static void dmxConfigGetDims(int *maxWidth, int *maxHeight)
{
DMXConfigSubPtr pt;
DMXConfigEntryPtr e;
*maxWidth = dmxConfigWallWidth = 0;
*maxHeight = dmxConfigWallHeight = 0;
if (!dmxConfigCurrent) return;
dmxConfigWallWidth = dmxConfigCurrent->width;
dmxConfigWallHeight = dmxConfigCurrent->height;
if (!dmxConfigWallWidth || !dmxConfigWallHeight) {
for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
if (pt->type == dmxConfigDisplay) {
int x = pt->display->scrnWidth + pt->display->rootXOrigin;
int y = pt->display->scrnHeight + pt->display->rootYOrigin;
if (x > dmxConfigWallWidth) dmxConfigWallWidth = x;
if (y > dmxConfigWallHeight) dmxConfigWallHeight = y;
}
}
}
/* Compute maximums */
*maxWidth = *maxHeight = 0;
for (e = dmxConfigEntry; e; e = e->next) {
if (e->type != dmxConfigVirtual) continue;
for (pt = e->virtual->subentry; pt; pt = pt->next) {
if (pt->type == dmxConfigDisplay) {
int x = pt->display->scrnWidth + pt->display->rootXOrigin;
int y = pt->display->scrnHeight + pt->display->rootYOrigin;
if (x > *maxWidth) *maxWidth = x;
if (y > *maxHeight) *maxHeight = y;
}
}
}
if (dmxConfigWallWidth > *maxWidth) *maxWidth = dmxConfigWallWidth;
if (dmxConfigWallHeight > *maxHeight) *maxHeight = dmxConfigWallHeight;
}
static int scalex(int x) { return (int)((x * dmxConfigScaleX) + .5); }
static int scaley(int y) { return (int)((y * dmxConfigScaleY) + .5); }
static int unscalex(int x) { return (int)((x / dmxConfigScaleX) + .5); }
static int unscaley(int y) { return (int)((y / dmxConfigScaleY) + .5); }
static void dmxConfigDataUpdate(void)
{
/* FIXME: could result in buffer overflows */
char cnambuf[512];
char cdimbuf[128];
char nambuf[512];
char dimbuf[128];
char rtbuf[128];
char offbuf[128];
const char *name;
if (!dmxConfigCurrent) {
XtVaSetValues(cnamebox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(cdimbox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(ecbutton, XtNsensitive, False, NULL);
XtVaSetValues(dcbutton, XtNsensitive, False, NULL);
XtVaSetValues(ndbutton0, XtNsensitive, False, NULL);
XtVaSetValues(ndbutton1, XtNsensitive, False, NULL);
} else {
name = dmxConfigCurrent->name;
XmuSnprintf(cnambuf, sizeof(cnambuf), "%s", name ? name : "");
XmuSnprintf(cdimbuf, sizeof(cdimbuf), "%dx%d",
dmxConfigWallWidth, dmxConfigWallHeight);
XtVaSetValues(cnamebox, XtNlabel, cnambuf, XtNsensitive, True, NULL);
XtVaSetValues(cdimbox, XtNlabel, cdimbuf, XtNsensitive, True, NULL);
XtVaSetValues(ecbutton, XtNsensitive, True, NULL);
XtVaSetValues(dcbutton, XtNsensitive, True, NULL);
XtVaSetValues(ndbutton0, XtNsensitive, True, NULL);
XtVaSetValues(ndbutton1, XtNsensitive, True, NULL);
}
if (!dmxConfigCurrentDisplay) {
XtVaSetValues(namebox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(dimbox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(rtbox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(origbox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(edbutton, XtNsensitive, False, NULL);
XtVaSetValues(ddbutton, XtNsensitive, False, NULL);
} else {
name = dmxConfigCurrentDisplay->name;
XmuSnprintf(nambuf, sizeof(nambuf), "%s", name ? name : "");
XmuSnprintf(dimbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
dmxConfigCurrentDisplay->scrnWidth,
dmxConfigCurrentDisplay->scrnHeight,
dmxConfigCurrentDisplay->scrnXSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnX,
dmxConfigCurrentDisplay->scrnYSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnY);
XmuSnprintf(rtbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
dmxConfigCurrentDisplay->rootWidth,
dmxConfigCurrentDisplay->rootHeight,
dmxConfigCurrentDisplay->rootXSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->rootX,
dmxConfigCurrentDisplay->rootYSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->rootY);
XmuSnprintf(offbuf, sizeof(offbuf), "@%dx%d",
dmxConfigCurrentDisplay->rootXOrigin,
dmxConfigCurrentDisplay->rootYOrigin);
XtVaSetValues(namebox, XtNlabel, nambuf, XtNsensitive, True, NULL);
XtVaSetValues(dimbox, XtNlabel, dimbuf, XtNsensitive, True, NULL);
XtVaSetValues(rtbox, XtNlabel, rtbuf, XtNsensitive, True, NULL);
XtVaSetValues(origbox, XtNlabel, offbuf, XtNsensitive, True, NULL);
XtVaSetValues(edbutton, XtNsensitive, True, NULL);
XtVaSetValues(ddbutton, XtNsensitive, True, NULL);
}
}
static void dmxConfigCanvasUpdate(void)
{
DMXConfigSubPtr pt;
Display *dpy = XtDisplay(canvas);
Window win = XtWindow(canvas);
GContext gcontext = XGContextFromGC(dmxConfigGC);
XFontStruct *fs;
int w, h;
XFillRectangle(dpy, win, dmxConfigGCRev,
0, 0, dmxConfigWidgetWidth, dmxConfigWidgetHeight);
dmxConfigDataUpdate();
if (!dmxConfigCurrent) return;
w = scalex(dmxConfigWallWidth);
h = scaley(dmxConfigWallHeight);
if (w > dmxConfigWidgetWidth - 1) w = dmxConfigWidgetWidth - 1;
if (h > dmxConfigWidgetHeight - 1) h = dmxConfigWidgetHeight - 1;
XDrawRectangle(dpy, win, dmxConfigGC, 0, 0, w, h);
fs = XQueryFont(dpy, gcontext);
for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
int x, y, len;
int xo = 3, yo = fs->ascent + fs->descent + 2;
GC gc;
if (pt->type != dmxConfigDisplay) continue;
gc = (pt->display == dmxConfigCurrentDisplay
? dmxConfigGCHL
: dmxConfigGC);
x = scalex(pt->display->rootXOrigin);
y = scaley(pt->display->rootYOrigin);
w = scalex(pt->display->scrnWidth);
h = scaley(pt->display->scrnHeight);
len = pt->display->name ? strlen(pt->display->name) : 0;
if (x > dmxConfigWidgetWidth - 1) x = dmxConfigWidgetWidth - 1;
if (y > dmxConfigWidgetHeight - 1) y = dmxConfigWidgetHeight - 1;
XDrawRectangle(dpy, win, gc, x, y, w, h);
if (fs && len) {
while (len && XTextWidth(fs, pt->display->name, len) >= w - 2 * xo)
--len;
if (len)
XDrawString(dpy, win, gc, x+xo, y+yo, pt->display->name, len);
}
}
if (fs) XFreeFontInfo(NULL, fs, 0);
}
static void dmxConfigCanvasDraw(Region region)
{
Display *dpy = XtDisplay(canvas);
int maxWidth, maxHeight;
dmxConfigCanvasGCs();
if (region) {
XSetRegion(dpy, dmxConfigGC, region);
XSetRegion(dpy, dmxConfigGCRev, region);
XSetRegion(dpy, dmxConfigGCHL, region);
}
XtVaGetValues(canvas,
XtNwidth, &dmxConfigWidgetWidth,
XtNheight, &dmxConfigWidgetHeight,
NULL);
dmxConfigGetDims(&maxWidth, &maxHeight);
dmxConfigScaleX = (double)dmxConfigWidgetWidth / maxWidth;
dmxConfigScaleY = (double)dmxConfigWidgetHeight / maxHeight;
if (dmxConfigScaleX > dmxConfigScaleY) dmxConfigScaleX = dmxConfigScaleY;
if (dmxConfigScaleY > dmxConfigScaleX) dmxConfigScaleY = dmxConfigScaleX;
dmxConfigCanvasUpdate();
if (region) {
XSetClipMask(dpy, dmxConfigGC, None);
XSetClipMask(dpy, dmxConfigGCRev, None);
XSetClipMask(dpy, dmxConfigGCHL, None);
}
}
static void dmxConfigSelectCallback(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigCurrent = closure;
dmxConfigVirtualPrint(stdout, dmxConfigCurrent);
dmxConfigCanvasDraw(NULL);
}
static void dmxConfigCopystrings(void)
{
DMXConfigEntryPtr pt;
DMXConfigSubPtr sub;
if (!dmxConfigCurrent) return;
/* FIXME: this is all a per-config file
* memory leak */
for (pt = dmxConfigEntry; pt; pt = pt->next) {
if (pt->type == dmxConfigVirtual) {
pt->virtual->name = XtNewString(pt->virtual->name
? pt->virtual->name
: "");
for (sub = pt->virtual->subentry; sub; sub = sub->next) {
if (sub->type != dmxConfigDisplay) continue;
sub->display->name = XtNewString(sub->display->name
? sub->display->name
: "");
}
}
}
}
static void dmxConfigGetValueString(char **d, Widget w)
{
const char *tmp = XawDialogGetValueString(w);
if (*d) XtFree(*d);
*d = XtNewString(tmp);
}
static void dmxConfigSetupCnamemenu(void)
{
static Widget cnamemenu = NULL;
Widget w;
DMXConfigEntryPtr pt;
if (cnamemenu) XtDestroyWidget(cnamemenu);
cnamemenu = NULL;
if (!dmxConfigCurrent) return;
cnamemenu = XtVaCreatePopupShell("cnamemenu", simpleMenuWidgetClass,
cnamebox,
NULL);
for (pt = dmxConfigEntry; pt; pt = pt->next) {
if (pt->type == dmxConfigVirtual) {
w = XtVaCreateManagedWidget(pt->virtual->name
? pt->virtual->name
: "",
smeBSBObjectClass, cnamemenu,
NULL);
XtAddCallback(w, XtNcallback,
dmxConfigSelectCallback, pt->virtual);
}
}
}
static void dmxConfigReadFile(void)
{
FILE *str;
DMXConfigEntryPtr pt;
if (!(str = fopen(dmxConfigFilename, "r"))) {
dmxLog(dmxWarning, "Unable to read configuration file %s\n",
dmxConfigFilename);
return;
}
yyin = str;
yydebug = 0;
yyparse();
fclose(str);
dmxLog(dmxInfo, "Read configuration file %s\n", dmxConfigFilename);
for (pt = dmxConfigEntry; pt; pt = pt->next) {
if (pt->type == dmxConfigVirtual) {
dmxConfigCurrent = pt->virtual;
break;
}
}
if (XtIsRealized(canvas)) {
dmxConfigCopystrings();
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
}
dmxConfigVirtualPrint(stdout, dmxConfigCurrent);
}
static void dmxConfigWriteFile(void)
{
FILE *str;
if (!(str = fopen(dmxConfigFilename, "w"))) {
dmxLog(dmxWarning, "Unable to write configuration file %s\n",
dmxConfigFilename);
return;
}
dmxConfigPrint(str, dmxConfigEntry);
fclose(str);
}
static DMXConfigDisplayPtr dmxConfigFindDisplay(int x, int y)
{
DMXConfigSubPtr pt;
if (!dmxConfigCurrent) return NULL;
for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
DMXConfigDisplayPtr d = pt->display;
if (pt->type != dmxConfigDisplay) continue;
if (x >= scalex(d->rootXOrigin)
&& x <= scalex(d->rootXOrigin + d->scrnWidth)
&& y >= scaley(d->rootYOrigin)
&& y <= scaley(d->rootYOrigin + d->scrnHeight)) return d;
}
return NULL;
}
static void dmxConfigSetPopupPosition(Widget popup)
{
Position x, y;
Window t1, t2;
int root_x, root_y;
int temp_x, temp_y;
unsigned int temp;
XtRealizeWidget(popup);
if (!XQueryPointer(XtDisplay(popup), XtWindow(popup), &t1, &t2,
&root_x, &root_y, &temp_x, &temp_y, &temp))
root_x = root_y = 0;
x = root_x - 5;
y = root_y - 5;
XtVaSetValues(popup, XtNx, x, XtNy, y, NULL);
}
static void dmxConfigPlaceMenu(Widget w, XEvent *event,
String *params, Cardinal *num_params)
{
dmxConfigSetPopupPosition(buttonpopup);
}
static void dmxConfigMove(int deltaX, int deltaY)
{
dmxConfigCurrentDisplay->rootXOrigin += deltaX;
dmxConfigCurrentDisplay->rootYOrigin += deltaY;
if (dmxConfigCurrentDisplay->rootXOrigin < 0)
dmxConfigCurrentDisplay->rootXOrigin = 0;
if (dmxConfigCurrentDisplay->rootYOrigin < 0)
dmxConfigCurrentDisplay->rootYOrigin = 0;
if (dmxConfigWallWidth && dmxConfigWallHeight) {
if (dmxConfigCurrentDisplay->rootXOrigin >= dmxConfigWallWidth)
dmxConfigCurrentDisplay->rootXOrigin = dmxConfigWallWidth - 1;
if (dmxConfigCurrentDisplay->rootYOrigin >= dmxConfigWallHeight)
dmxConfigCurrentDisplay->rootYOrigin = dmxConfigWallHeight - 1;
}
dmxConfigCanvasUpdate();
dmxConfigNotSaved = 1;
}
static void dmxConfigCanvasInput(Widget w, XtPointer closure,
XtPointer callData)
{
XEvent *e = (XEvent *)callData;
DMXConfigDisplayPtr display = NULL;
switch (e->type) {
case ButtonPress:
if (e->xbutton.button == Button1) {
dmxConfigGrabbed = 1;
dmxConfigGrabbedFine = 0;
dmxConfigGrabbedX = e->xbutton.x;
dmxConfigGrabbedY = e->xbutton.y;
}
if (e->xbutton.button == Button2) {
dmxConfigGrabbed = 1;
dmxConfigGrabbedFine = 1;
dmxConfigGrabbedX = e->xbutton.x;
dmxConfigGrabbedY = e->xbutton.y;
}
break;
case ButtonRelease:
if (e->xbutton.button == Button1) dmxConfigGrabbed = 0;
if (e->xbutton.button == Button2) dmxConfigGrabbed = 0;
break;
case MotionNotify:
if (dmxConfigGrabbed && dmxConfigCurrentDisplay) {
int deltaX = e->xmotion.x - dmxConfigGrabbedX;
int deltaY = e->xmotion.y - dmxConfigGrabbedY;
dmxConfigMove(dmxConfigGrabbedFine ? deltaX : unscalex(deltaX),
dmxConfigGrabbedFine ? deltaY : unscaley(deltaY));
dmxConfigGrabbedX = e->xmotion.x;
dmxConfigGrabbedY = e->xmotion.y;
} else {
display = dmxConfigFindDisplay(e->xmotion.x, e->xmotion.y);
if (display != dmxConfigCurrentDisplay) {
dmxConfigCurrentDisplay = display;
dmxConfigCanvasUpdate();
}
}
break;
case KeyPress:
switch (XLookupKeysym(&e->xkey, 0)) {
case XK_Right: dmxConfigMove(1,0); break;
case XK_Left: dmxConfigMove(-1,0); break;
case XK_Down: dmxConfigMove(0,1); break;
case XK_Up: dmxConfigMove(0,-1); break;
}
break;
}
}
static void dmxConfigCanvasResize(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigCanvasDraw(NULL);
}
static void dmxConfigCanvasExpose(Widget w, XtPointer closure,
XtPointer callData)
{
CanvasExposeDataPtr data = (CanvasExposeDataPtr)callData;
dmxConfigCanvasDraw(data->region);
}
static void dmxConfigOpenCallback(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigState = dmxConfigStateOpen;
XtVaSetValues(okbutton, XtNlabel, "Open", NULL);
dmxConfigSetPopupPosition(openpopup);
XtPopup(openpopup, XtGrabExclusive);
}
static void dmxConfigSaveCallback(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigState = dmxConfigStateSave;
XtVaSetValues(okbutton, XtNlabel, "Save", NULL);
dmxConfigSetPopupPosition(openpopup);
XtPopup(openpopup, XtGrabExclusive);
}
static void dmxConfigOkCallback(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigGetValueString(&dmxConfigFilename, opendialog);
XtPopdown(openpopup);
if (dmxConfigState == dmxConfigStateOpen) dmxConfigReadFile();
else dmxConfigWriteFile();
dmxConfigNotSaved = 0;
}
static void dmxConfigCanCallback(Widget w, XtPointer closure,
XtPointer callData)
{
XtPopdown(openpopup);
}
static void dmxConfigECCallback(Widget w, XtPointer closure,
XtPointer callData)
{
char buf[256]; /* RATS: Only used in XmuSnprintf */
if (!dmxConfigCurrent) return;
dmxConfigSetPopupPosition(ecpopup);
XtVaSetValues(ecdialog0, XtNvalue,
dmxConfigCurrent->name ? dmxConfigCurrent->name : "",
NULL);
XmuSnprintf(buf, sizeof(buf), "%dx%d",
dmxConfigCurrent->width, dmxConfigCurrent->height);
XtVaSetValues(ecdialog1, XtNvalue, buf, NULL);
XtPopup(ecpopup, XtGrabExclusive);
}
static void dmxConfigNCCallback(Widget w, XtPointer closure,
XtPointer callData)
{
int width = 1280*2, height = 1024*2;
if (dmxConfigCurrent) {
width = dmxConfigCurrent->width;
height = dmxConfigCurrent->height;
}
dmxConfigCurrent = dmxConfigCreateVirtual(NULL, NULL, NULL,
NULL, NULL, NULL);
dmxConfigNewVirtual = dmxConfigCurrent;
dmxConfigCurrent->width = width;
dmxConfigCurrent->height = height;
dmxConfigEntry = dmxConfigAddEntry(dmxConfigEntry, dmxConfigVirtual, NULL,
dmxConfigCurrent);
dmxConfigECCallback(w, closure, callData);
}
static void dmxConfigDCCallback(Widget w, XtPointer closure,
XtPointer callData)
{
DMXConfigEntryPtr pt;
if (!dmxConfigEntry) return;
if (dmxConfigEntry
&& dmxConfigEntry->type == dmxConfigVirtual
&& dmxConfigEntry->virtual == dmxConfigCurrent) {
dmxConfigEntry = dmxConfigEntry->next;
} else {
for (pt = dmxConfigEntry; pt && pt->next; pt = pt->next)
if (pt->next->type == dmxConfigVirtual
&& pt->next->virtual == dmxConfigCurrent) {
pt->next = pt->next->next;
break;
}
}
dmxConfigFreeVirtual(dmxConfigCurrent);
dmxConfigCurrent = NULL;
dmxConfigCurrentDisplay = NULL;
/* Make the first entry current */
for (pt = dmxConfigEntry; pt; pt = pt->next) {
if (pt->type == dmxConfigVirtual) {
dmxConfigCurrent = pt->virtual;
break;
}
}
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
}
static void dmxConfigECOkCallback(Widget w, XtPointer closure,
XtPointer callData)
{
const char *value;
char *endpt;
dmxConfigGetValueString((char **)&dmxConfigCurrent->name, ecdialog0);
value = XawDialogGetValueString(ecdialog1);
dmxConfigCurrent->width = strtol(value, &endpt, 10);
dmxConfigCurrent->height = strtol(endpt+1, NULL, 10);
XtPopdown(ecpopup);
dmxConfigCurrentDisplay = NULL;
dmxConfigNewVirtual = NULL;
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
dmxConfigNotSaved = 1;
}
static void dmxConfigECCanCallback(Widget w, XtPointer closure,
XtPointer callData)
{
if (dmxConfigNewVirtual) dmxConfigDCCallback(w, closure, callData);
dmxConfigNewVirtual = NULL;
XtPopdown(ecpopup);
}
static void dmxConfigEDCallback(Widget w, XtPointer closure,
XtPointer callData)
{
char buf[256]; /* RATS: Only used in XmuSnprintf */
if (!dmxConfigCurrent || !dmxConfigCurrentDisplay) return;
dmxConfigSetPopupPosition(edpopup);
XtVaSetValues(eddialog0, XtNvalue,
dmxConfigCurrentDisplay->name
? dmxConfigCurrentDisplay->name
: "",
NULL);
XmuSnprintf(buf, sizeof(buf), "%dx%d%c%d%c%d",
dmxConfigCurrentDisplay->scrnWidth,
dmxConfigCurrentDisplay->scrnHeight,
dmxConfigCurrentDisplay->scrnXSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnY,
dmxConfigCurrentDisplay->scrnYSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnY);
XtVaSetValues(eddialog1, XtNvalue, buf, NULL);
XmuSnprintf(buf, sizeof(buf), "@%dx%d",
dmxConfigCurrentDisplay->rootXOrigin,
dmxConfigCurrentDisplay->rootYOrigin);
XtVaSetValues(eddialog2, XtNvalue, buf, NULL);
XtPopup(edpopup, XtGrabExclusive);
}
static void dmxConfigNDCallback(Widget w, XtPointer closure,
XtPointer callData)
{
int width = 1280, height = 1024;
if (!dmxConfigCurrent) return;
if (dmxConfigCurrentDisplay) {
width = dmxConfigCurrentDisplay->scrnWidth;
height = dmxConfigCurrentDisplay->scrnHeight;
}
dmxConfigCurrentDisplay = dmxConfigCreateDisplay(NULL, NULL, NULL,
NULL, NULL);
dmxConfigNewDisplay = dmxConfigCurrentDisplay;
dmxConfigCurrentDisplay->scrnWidth = width;
dmxConfigCurrentDisplay->scrnHeight = height;
dmxConfigCurrent->subentry
= dmxConfigAddSub(dmxConfigCurrent->subentry,
dmxConfigSubDisplay(dmxConfigCurrentDisplay));
dmxConfigEDCallback(w, closure, callData);
}
static void dmxConfigDDCallback(Widget w, XtPointer closure,
XtPointer callData)
{
DMXConfigSubPtr pt;
if (!dmxConfigCurrent || !dmxConfigCurrentDisplay) return;
/* First */
if (dmxConfigCurrent->subentry
&& dmxConfigCurrent->subentry->type == dmxConfigDisplay
&& dmxConfigCurrent->subentry->display == dmxConfigCurrentDisplay) {
dmxConfigCurrent->subentry = dmxConfigCurrent->subentry->next;
} else {
for (pt = dmxConfigCurrent->subentry; pt && pt->next; pt = pt->next)
if (pt->next->type == dmxConfigDisplay
&& pt->next->display == dmxConfigCurrentDisplay) {
pt->next = pt->next->next;
break;
}
}
dmxConfigFreeDisplay(dmxConfigCurrentDisplay);
dmxConfigCurrentDisplay = NULL;
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
}
static void dmxConfigAboutCallback(Widget w, XtPointer closure,
XtPointer callData)
{
dmxConfigSetPopupPosition(aboutpopup);
XtPopup(aboutpopup, XtGrabExclusive);
}
static void dmxConfigAboutOkCallback(Widget w, XtPointer closure,
XtPointer CallData)
{
XtPopdown(aboutpopup);
}
static void dmxConfigQuitCallback(Widget w, XtPointer closure,
XtPointer callData)
{
if (dmxConfigNotSaved) {
dmxConfigSetPopupPosition(quitpopup);
XtPopup(quitpopup, XtGrabExclusive);
return;
}
exit(0);
}
static void dmxConfigQuitOkCallback(Widget w, XtPointer closure,
XtPointer callData)
{
XtPopdown(quitpopup);
exit(0);
}
static void dmxConfigQuitCanCallback(Widget w, XtPointer closure,
XtPointer callData)
{
XtPopdown(quitpopup);
}
static void dmxConfigEDOkCallback(Widget w, XtPointer closure,
XtPointer callData)
{
char *value;
char *endpt;
dmxConfigNewDisplay = NULL;
dmxConfigGetValueString((char **)&dmxConfigCurrentDisplay->name,
eddialog0);
value = XawDialogGetValueString(eddialog1);
if (*value == '-' || *value == '+') {
dmxConfigCurrentDisplay->scrnWidth = 0;
dmxConfigCurrentDisplay->scrnHeight = 0;
endpt = value;
} else {
dmxConfigCurrentDisplay->scrnWidth = strtol(value, &endpt, 10);
dmxConfigCurrentDisplay->scrnHeight = strtol(endpt+1, &endpt, 10);
}
if (*endpt) {
dmxConfigCurrentDisplay->scrnXSign = (*endpt == '-') ? -1 : 1;
dmxConfigCurrentDisplay->scrnX = strtol(endpt+1, &endpt, 10);
dmxConfigCurrentDisplay->scrnYSign = (*endpt == '-') ? -1 : 1;
dmxConfigCurrentDisplay->scrnY = strtol(endpt+1, NULL, 10);
}
if (dmxConfigCurrentDisplay->scrnX < 0)
dmxConfigCurrentDisplay->scrnX = -dmxConfigCurrentDisplay->scrnX;
if (dmxConfigCurrentDisplay->scrnY < 0)
dmxConfigCurrentDisplay->scrnY = -dmxConfigCurrentDisplay->scrnY;
value = XawDialogGetValueString(eddialog2);
dmxConfigCurrentDisplay->rootXOrigin = strtol(value+1, &endpt, 10);
dmxConfigCurrentDisplay->rootYOrigin = strtol(endpt+1, NULL, 10);
XtPopdown(edpopup);
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
dmxConfigNotSaved = 1;
}
static void dmxConfigEDCanCallback(Widget w, XtPointer closure,
XtPointer callData)
{
if (dmxConfigNewDisplay) dmxConfigDDCallback(w, closure, callData);
dmxConfigNewDisplay = NULL;
XtPopdown(edpopup);
}
static void dmxConfigOkAction(Widget w, XEvent *event,
String *params, Cardinal *num_params)
{
Widget p = XtParent(w);
Widget t;
if (p == opendialog) dmxConfigOkCallback(w, NULL, NULL);
if (p == ecdialog0) {
t = XtNameToWidget(ecdialog1, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == ecdialog1) dmxConfigECOkCallback(w, NULL, NULL);
if (p == eddialog0) {
t = XtNameToWidget(eddialog1, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == eddialog1) {
t = XtNameToWidget(eddialog2, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == eddialog2) dmxConfigEDOkCallback(w, NULL, NULL);
}
int main(int argc, char **argv)
{
XtAppContext appContext;
Widget toplevel;
Widget parent, menubox, bottombox, databox, canvasbox;
Widget filebutton, helpbutton;
Widget filemenu, openbutton, savebutton, quitbutton;
Widget helpmenu, aboutbutton, aboutbox, aboutok;
Widget quitbox, quitok, quitcan;
Widget ncbutton;
Widget canbutton;
Widget ecbox, ecokbutton, eccanbutton;
Widget edbox, edokbutton;
Widget edcanbutton;
/* FIXME: add meta-i, ctrl,meta-z,v? */
const char *opentrans = "<Key>Return: openOk()\n\
<Key>Linefeed: openOk()\n\
Ctrl<Key>M: openOk()\n\
Ctrl<Key>J: openOk()\n\
Ctrl<Key>O: noop()\n\
Ctrl<Key>N: noop()\n\
Ctrl<Key>P: noop()";
const char *canvastrans =
"<Btn3Down>: placeMenu() XtMenuPopup(buttonpopup)";
XtActionsRec actiontable[] = {
{ "openOk", dmxConfigOkAction },
{ "placeMenu", dmxConfigPlaceMenu },
{ "noop", NULL }
};
dmxConfigFilename = XtNewString((argc >= 2) ? argv[1] : "");
toplevel = XtVaAppInitialize(&appContext, "XDmxconfig",
NULL, 0,
&argc, argv,
NULL,
NULL);
/* Main boxes */
parent = XtVaCreateManagedWidget("parent", formWidgetClass, toplevel,
XtNorientation, XtorientVertical,
XtNwidth, DMX_MAIN_WIDTH,
XtNheight, DMX_MAIN_HEIGHT,
NULL);
menubox = XtVaCreateManagedWidget("menubox", boxWidgetClass, parent,
XtNborderWidth, 0,
XtNorientation, XtorientHorizontal,
XtNtop, XtChainTop,
NULL);
bottombox = XtVaCreateManagedWidget("bottombox", formWidgetClass, parent,
XtNborderWidth, 0,
XtNfromVert, menubox,
XtNorientation, XtorientHorizontal,
NULL);
databox = XtVaCreateManagedWidget("databox", formWidgetClass,
bottombox,
XtNborderWidth, 0,
XtNhorizDistance, 0,
XtNwidth, DMX_DATA_WIDTH,
XtNheight, DMX_DATA_HEIGHT,
XtNleft, XtChainLeft,
XtNorientation, XtorientVertical,
NULL);
/* Data */
cnamebox = XtVaCreateManagedWidget("cnamebox", menuButtonWidgetClass,
databox,
XtNtop, XtChainTop,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
XtNmenuName, "cnamemenu",
NULL);
cdimbox = XtVaCreateManagedWidget("cdimbox", labelWidgetClass,
databox,
XtNfromVert, cnamebox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
NULL);
namebox = XtVaCreateManagedWidget("namebox", labelWidgetClass, databox,
XtNfromVert, cdimbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
NULL);
dimbox = XtVaCreateManagedWidget("dimbox", labelWidgetClass,
databox,
XtNfromVert, namebox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
NULL);
rtbox = XtVaCreateManagedWidget("rtbox", labelWidgetClass,
databox,
XtNfromVert, dimbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
NULL);
origbox = XtVaCreateManagedWidget("origbox", labelWidgetClass,
databox,
XtNfromVert, rtbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
NULL);
/* Canvas */
canvasbox = XtVaCreateManagedWidget("canvasbox", boxWidgetClass,
bottombox,
XtNborderWidth, 0,
XtNwidth, DMX_CANVAS_WIDTH,
XtNheight, DMX_CANVAS_HEIGHT,
XtNfromHoriz, databox,
NULL);
canvas = XtVaCreateManagedWidget("canvas", canvasWidgetClass,
canvasbox,
XtNwidth, DMX_CANVAS_WIDTH,
XtNheight, DMX_CANVAS_HEIGHT,
NULL);
/* Main menu buttons */
filebutton = XtVaCreateManagedWidget("File", menuButtonWidgetClass,
menubox,
XtNmenuName, "filemenu",
NULL);
helpbutton = XtVaCreateManagedWidget("Help", menuButtonWidgetClass,
menubox,
XtNmenuName, "helpmenu",
NULL);
/* File submenu buttons */
filemenu = XtVaCreatePopupShell("filemenu", simpleMenuWidgetClass,
filebutton, NULL);
openbutton = XtVaCreateManagedWidget("Open File", smeBSBObjectClass,
filemenu, NULL);
savebutton = XtVaCreateManagedWidget("Save File", smeBSBObjectClass,
filemenu,
NULL);
ncbutton = XtVaCreateManagedWidget("New Global", smeBSBObjectClass,
filemenu, NULL);
ecbutton = XtVaCreateManagedWidget("Edit Global", smeBSBObjectClass,
filemenu,
NULL);
dcbutton = XtVaCreateManagedWidget("Delete Global", smeBSBObjectClass,
filemenu,
NULL);
ndbutton0 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
filemenu,
NULL);
quitbutton = XtVaCreateManagedWidget("Quit", smeBSBObjectClass,
filemenu, NULL);
/* Help submenu button */
helpmenu = XtVaCreatePopupShell("helpmenu", simpleMenuWidgetClass,
helpbutton, NULL);
aboutbutton = XtVaCreateManagedWidget("About", smeBSBObjectClass,
helpmenu, NULL);
/* Open popup */
openpopup = XtVaCreatePopupShell("openpopup", transientShellWidgetClass,
toplevel, NULL);
opendialog = XtVaCreateManagedWidget("opendialog", dialogWidgetClass,
openpopup,
XtNlabel, "Filename: ",
XtNvalue, dmxConfigFilename,
NULL);
okbutton = XtVaCreateManagedWidget("Open", commandWidgetClass,
opendialog, NULL);
canbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
opendialog, NULL);
/* EC popup */
ecpopup = XtVaCreatePopupShell("ecpopup", transientShellWidgetClass,
toplevel, NULL);
ecbox = XtVaCreateManagedWidget("ecbox", boxWidgetClass,
ecpopup, NULL);
ecdialog0 = XtVaCreateManagedWidget("ecdialog0", dialogWidgetClass,
ecbox,
XtNlabel, "Name: ",
XtNvalue, "",
NULL);
ecdialog1 = XtVaCreateManagedWidget("ecdialog1", dialogWidgetClass,
ecbox,
XtNlabel, "Dimension: ",
XtNvalue, "",
NULL);
ecokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass,
ecbox, NULL);
eccanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
ecbox, NULL);
/* ED popup */
edpopup = XtVaCreatePopupShell("edpopup", transientShellWidgetClass,
toplevel, NULL);
edbox = XtVaCreateManagedWidget("edbox", boxWidgetClass,
edpopup, NULL);
eddialog0 = XtVaCreateManagedWidget("eddialog0", dialogWidgetClass,
edbox,
XtNlabel, "Display Name: ",
XtNvalue, "",
NULL);
eddialog1 = XtVaCreateManagedWidget("eddialog1", dialogWidgetClass,
edbox,
XtNlabel, "Geometry: ",
XtNvalue, "",
NULL);
eddialog2 = XtVaCreateManagedWidget("eddialog2", dialogWidgetClass,
edbox,
XtNlabel, "Offset: ",
XtNvalue, "",
NULL);
edokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass,
edbox, NULL);
edcanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
edbox, NULL);
/* About popup */
aboutpopup = XtVaCreatePopupShell("aboutpopup",transientShellWidgetClass,
toplevel, NULL);
aboutbox = XtVaCreateManagedWidget("aboutbox", boxWidgetClass,
aboutpopup, NULL);
XtVaCreateManagedWidget("abouttext", labelWidgetClass,
aboutbox,
XtNlabel, DMX_INFO,
NULL);
aboutok = XtVaCreateManagedWidget("OK", commandWidgetClass,
aboutbox, NULL);
/* Quit popup */
quitpopup = XtVaCreatePopupShell("quitpopup",transientShellWidgetClass,
toplevel, NULL);
quitbox = XtVaCreateManagedWidget("quitbox", boxWidgetClass,
quitpopup, NULL);
XtVaCreateManagedWidget("quittext", labelWidgetClass,
quitbox,
XtNlabel,
"Changes to the configuration\n"
"been made that have not yet\n"
"been saved. Do you want to\n"
"quit without saving?",
NULL);
quitok = XtVaCreateManagedWidget("Quit WITHOUT Saving",
commandWidgetClass,
quitbox, NULL);
quitcan = XtVaCreateManagedWidget("Continue Editing",
commandWidgetClass,
quitbox, NULL);
/* Button popup */
buttonpopup = XtVaCreatePopupShell("buttonpopup", simpleMenuWidgetClass,
toplevel, NULL);
ndbutton1 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
buttonpopup,
NULL);
edbutton = XtVaCreateManagedWidget("Edit Display", smeBSBObjectClass,
buttonpopup,
NULL);
ddbutton = XtVaCreateManagedWidget("Delete Display", smeBSBObjectClass,
buttonpopup,
NULL);
/* Callbacks */
XtAddCallback(openbutton, XtNcallback, dmxConfigOpenCallback, NULL);
XtAddCallback(savebutton, XtNcallback, dmxConfigSaveCallback, NULL);
XtAddCallback(okbutton, XtNcallback, dmxConfigOkCallback, NULL);
XtAddCallback(canbutton, XtNcallback, dmxConfigCanCallback, NULL);
XtAppAddActions(appContext, actiontable, XtNumber(actiontable));
XtOverrideTranslations(canvas, XtParseTranslationTable(canvastrans));
XtOverrideTranslations(XtNameToWidget(opendialog, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(ecdialog0, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(ecdialog1, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog0, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog1, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog2, "value"),
XtParseTranslationTable(opentrans));
XtAddCallback(ncbutton, XtNcallback, dmxConfigNCCallback, NULL);
XtAddCallback(ecbutton, XtNcallback, dmxConfigECCallback, NULL);
XtAddCallback(ecokbutton, XtNcallback, dmxConfigECOkCallback, NULL);
XtAddCallback(eccanbutton, XtNcallback, dmxConfigECCanCallback, NULL);
XtAddCallback(dcbutton, XtNcallback, dmxConfigDCCallback, NULL);
XtAddCallback(ndbutton0, XtNcallback, dmxConfigNDCallback, NULL);
XtAddCallback(ndbutton1, XtNcallback, dmxConfigNDCallback, NULL);
XtAddCallback(edbutton, XtNcallback, dmxConfigEDCallback, NULL);
XtAddCallback(ddbutton, XtNcallback, dmxConfigDDCallback, NULL);
XtAddCallback(edokbutton, XtNcallback, dmxConfigEDOkCallback, NULL);
XtAddCallback(edcanbutton, XtNcallback, dmxConfigEDCanCallback, NULL);
XtAddCallback(aboutbutton, XtNcallback, dmxConfigAboutCallback, NULL);
XtAddCallback(aboutok, XtNcallback, dmxConfigAboutOkCallback, NULL);
XtAddCallback(quitok, XtNcallback, dmxConfigQuitOkCallback, NULL);
XtAddCallback(quitcan, XtNcallback, dmxConfigQuitCanCallback, NULL);
XtAddCallback(quitbutton, XtNcallback, dmxConfigQuitCallback, NULL);
XtAddCallback(canvas, XtNcallback, dmxConfigCanvasInput, NULL);
XtAddCallback(canvas, XtNcanvasExposeCallback, dmxConfigCanvasExpose,NULL);
XtAddCallback(canvas, XtNcanvasResizeCallback, dmxConfigCanvasResize,NULL);
if (dmxConfigFilename) dmxConfigReadFile();
XtRealizeWidget(toplevel);
dmxConfigCopystrings();
dmxConfigSetupCnamemenu();
XtAppMainLoop(appContext);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink