diff options
Diffstat (limited to 'nx-X11/programs/Xserver/hw/dmx/config')
45 files changed, 4651 insertions, 0 deletions
diff --git a/nx-X11/programs/Xserver/hw/dmx/config/Canvas.c b/nx-X11/programs/Xserver/hw/dmx/config/Canvas.c new file mode 100644 index 000000000..4dccd7382 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/Canvas.c @@ -0,0 +1,160 @@ +/* $XFree86$ */ +/* + * Copyright 1987, 1998 The Open Group + * + * Permission to use, copy, modify, distribute, and sell this software and its + * documentation for any purpose is hereby granted without fee, provided that + * the above copyright notice appear in all copies and that both that + * copyright notice and this permission notice appear in supporting + * documentation. + * + * 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 THE + * OPEN GROUP 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 The Open Group shall not be + * used in advertising or otherwise to promote the sale, use or other dealings + * in this Software without prior written authorization from The Open Group. + */ + +/* + * 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> + * + * This file was originally taken from xc/lib/Xaw/Template.c + */ + +#include <X11/IntrinsicP.h> +#include <X11/StringDefs.h> +#include "CanvasP.h" + +static void CanvasInitialize(Widget request, Widget w, + ArgList args, Cardinal *num_args) +{ +} + +static void CanvasExpose(Widget w, XEvent *event, Region region) +{ + CanvasExposeDataRec data; + + data.w = w; + data.event = event; + data.region = region; + + if (!XtIsRealized(w)) return; + XtCallCallbacks(w, XtNcanvasExposeCallback, (XtPointer)&data); +} + +static void CanvasResize(Widget w) +{ + if (!XtIsRealized(w)) return; + XtCallCallbacks(w, XtNcanvasResizeCallback, (XtPointer)w); +} + +static void CanvasAction(Widget w, XEvent *event, + String *params, Cardinal *num_params) +{ + XtCallCallbacks(w, XtNcallback, (XtPointer)event); +} + +#define offset(field) XtOffsetOf(CanvasRec, canvas.field) +static XtResource resources[] = { + { XtNcallback, XtCCallback, XtRCallback, + sizeof(XtCallbackList), offset(input_callback), XtRCallback, NULL }, + { XtNcanvasExposeCallback, XtCcanvasExposeCallback, XtRCallback, + sizeof(XtCallbackList), offset(expose_callback), XtRCallback, NULL }, + { XtNcanvasResizeCallback, XtCcanvasResizeCallback, XtRCallback, + sizeof(XtCallbackList), offset(resize_callback), XtRCallback, NULL }, +}; +#undef offset + +static XtActionsRec actions[] = +{ + {"canvas", CanvasAction}, +}; + +static char translations[] = +"<Key>: canvas()\n\ +<Motion>: canvas()\n\ +<BtnDown>: canvas()\n\ +<BtnUp>: canvas()\n\ +" +; + +#define Superclass (&widgetClassRec) +CanvasClassRec canvasClassRec = { + /* core */ + { + (WidgetClass)Superclass, /* superclass */ + "Canvas", /* class_name */ + sizeof(CanvasRec), /* widget_size */ + NULL, /* class_initialize */ + NULL, /* class_part_initialize */ + False, /* class_inited */ + CanvasInitialize, /* initialize */ + NULL, /* initialize_hook */ + XtInheritRealize, /* realize */ + actions, /* actions */ + XtNumber(actions), /* num_actions */ + resources, /* resources */ + XtNumber(resources), /* num_resources */ + NULLQUARK, /* xrm_class */ + True, /* compress_motion */ + True, /* compress_exposure */ + True, /* compress_enterleave */ + False, /* visible_interest */ + NULL, /* destroy */ + CanvasResize, /* resize */ + CanvasExpose, /* expose */ + NULL, /* set_values */ + NULL, /* set_values_hook */ + XtInheritSetValuesAlmost, /* set_values_almost */ + NULL, /* get_values_hook */ + NULL, /* accept_focus */ + XtVersion, /* version */ + NULL, /* callback_private */ + translations, /* tm_table */ + XtInheritQueryGeometry, /* query_geometry */ + XtInheritDisplayAccelerator, /* display_accelerator */ + NULL, /* extension */ + }, + /* canvas */ + { + NULL, /* extension */ + } +}; + +WidgetClass canvasWidgetClass = (WidgetClass)&canvasClassRec; diff --git a/nx-X11/programs/Xserver/hw/dmx/config/Canvas.h b/nx-X11/programs/Xserver/hw/dmx/config/Canvas.h new file mode 100644 index 000000000..a36851a6d --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/Canvas.h @@ -0,0 +1,56 @@ +/* $XFree86$ */ +/* + +Copyright 1987, 1998 The Open Group +Copyright 2002 Red Hat Inc., Durham, North Carolina. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 THE +OPEN GROUP 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 The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +/* + * Authors: + * Rickard E. (Rik) Faith <faith@redhat.com> + * + * This file was originally taken from xc/lib/Xaw/Template.h + */ + +#ifndef _Canvas_h +#define _Canvas_h + +#include <X11/Intrinsic.h> + +#define XtNcanvasExposeCallback "canvasExposeCallback" +#define XtCcanvasExposeCallback "CanvasExposeCallback" +#define XtNcanvasResizeCallback "canvasResizeCallback" +#define XtCcanvasResizeCallback "CanvasResizeCallback" + +typedef struct _CanvasClassRec *CanvasWidgetClass; +typedef struct _CanvasRec *CanvasWidget; +extern WidgetClass canvasWidgetClass; + +typedef struct _CanvasExposeDataRec { + Widget w; + XEvent *event; + Region region; +} CanvasExposeDataRec, *CanvasExposeDataPtr; + +#endif /* _Canvas_h */ diff --git a/nx-X11/programs/Xserver/hw/dmx/config/CanvasP.h b/nx-X11/programs/Xserver/hw/dmx/config/CanvasP.h new file mode 100644 index 000000000..98f95b94e --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/CanvasP.h @@ -0,0 +1,66 @@ +/* $XFree86$ */ +/* + +Copyright 1987, 1998 The Open Group +Copyright 2002 Red Hat Inc., Durham, North Carolina. + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +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 THE +OPEN GROUP 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 The Open Group shall not be +used in advertising or otherwise to promote the sale, use or other dealings +in this Software without prior written authorization from The Open Group. + +*/ + +/* + * Authors: + * Rickard E. (Rik) Faith <faith@redhat.com> + * + * This file was originally taken from xc/lib/Xaw/TemplateP.h + */ + +#ifndef _CanvasP_h +#define _CanvasP_h + +#include "Canvas.h" + +/* include superclass private header file */ +#include <X11/CoreP.h> + +typedef struct { + XtPointer extension; +} CanvasClassPart; + +typedef struct _CanvasClassRec { + CoreClassPart core_class; + CanvasClassPart canvas_class; +} CanvasClassRec; + +extern CanvasClassRec canvasClassRec; + +typedef struct { + XtCallbackList input_callback; + XtCallbackList expose_callback; + XtCallbackList resize_callback; +} CanvasPart; + +typedef struct _CanvasRec { + CorePart core; + CanvasPart canvas; +} CanvasRec; + +#endif /* _CanvasP_h */ diff --git a/nx-X11/programs/Xserver/hw/dmx/config/Imakefile b/nx-X11/programs/Xserver/hw/dmx/config/Imakefile new file mode 100644 index 000000000..08039c03e --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/Imakefile @@ -0,0 +1,101 @@ +XCOMM $XFree86$ + +#include <Server.tmpl> +#include <lnxdoc.rules> + +YFLAGS = -d + +LIBSRCS = parser.c scanner.c dmxparse.c dmxprint.c dmxcompat.c dmxconfig.c +LIBOBJS = parser.o scanner.o dmxparse.o dmxprint.o dmxcompat.o dmxconfig.o + +#if !BuildServersOnly +CONFIGSRCS = xdmxconfig.c dmxlog.c Canvas.c +CONFIGOBJS = xdmxconfig.o dmxlog.o Canvas.o + +COMPATSRCS = vdltodmx.c +COMPATOBJS = vdltodmx.o + +TESTSRCS = dmxtodmx.c +TESTOBJS = dmxtodmx.o +#endif + +SRCS = $(LIBSRCS) $(CONFIGSRCS) $(COMPATSRCS) $(TESTSRCS) +OBJS = $(LIBOBJS) $(CONFIGOBJS) $(COMPATOBJS) $(TESTOBJS) + +#if !BuildServersOnly +EXES = xdmxconfig vdltodmx dmxtodmx +#endif + +LOCAL_LIBRARIES = -L. -ldmxconfig + +#include <dmx.cf> + +INCLUDES = -I. -I.. -I$(XBUILDINCDIR) -I$(FONTINCSRC) -I../../../mi \ + -I../../../include -I../../../render -I$(EXTINCSRC) + +DEFINES = $(OS_DEFINES) $(EXT_DEFINES) -DDMX_LOG_STANDALONE $(DMX_DEFINES) + +all:: + +LexFile(scanner) +YaccFile(parser,$(YFLAGS)) + +#if HasGcc3 +XCOMM These rules remove some of the default warnings and, therefore, the +XCOMM clutter from the compiler output. Only do this for GCC 3, since the +XCOMM undef warning was added in 2.8. (The warnings are harmless, so be +XCOMM conservative in their removal.) +SpecialCObjectRule(parser,parser.h,-Wno-undef) +SpecialCObjectRule(scanner,parser.h,-Wno-undef -Wno-unused-function -Wno-unused-label -Wno-unused-variable) +#endif + +NormalLibraryObjectRule() +NormalLibraryTarget(dmxconfig,$(LIBOBJS)) + +#if !BuildServersOnly +NormalProgramTarget(xdmxconfig,$(CONFIGOBJS),\ + libdmxconfig.a XawClientDepLibs $(DEPXTOOLLIB),\ + $(LOCAL_LIBRARIES) XawClientLibs $(XTOOLLIB),NullParameter) +AllTarget(ProgramTargetName(xdmxconfig)) + +NormalProgramTarget(vdltodmx,$(COMPATOBJS),libdmxconfig.a,\ + $(LOCAL_LIBRARIES),NullParameter) +AllTarget(ProgramTargetName(vdltodmx)) + +NormalProgramTarget(dmxtodmx,$(TESTOBJS),libdmxconfig.a,\ + $(LOCAL_LIBRARIES),NullParameter) +AllTarget(ProgramTargetName(dmxtodmx)) + +LinkSourceFile(dmxlog.c,..) + +InstallProgram(dmxtodmx,$(BINDIR)) +InstallProgram(vdltodmx,$(BINDIR)) +InstallProgram(xdmxconfig,$(BINDIR)) + +InstallManPage(dmxtodmx,$(MANDIR)) +InstallManPage(vdltodmx,$(MANDIR)) +InstallManPage(xdmxconfig,$(MANDIR)) +#endif + +DependTarget() + +#if !BuildServersOnly +test: $(EXES) + @for i in test-*.in; do \ + b=`echo $$i | sed 's,.in$$,,'` \ + export b; \ + (./dmxtodmx < $$i > $$b.tmp 2>&1; exit 0); \ + if cmp -s ./$$b.out ./$$b.tmp; \ + then echo PASSED $$b; rm -f $$b.tmp; \ + else echo "FAILED $$b **********"; \ + fi \ + done + +test-update: + @for i in test-*.in; do \ + b=`echo $$i | sed 's,.in$$,,'` \ + export b; \ + echo Writing $$b.out; \ + (./dmxtodmx < $$i > $$b.out 2>&1; exit 0) \ + done +#endif diff --git a/nx-X11/programs/Xserver/hw/dmx/config/TODO b/nx-X11/programs/Xserver/hw/dmx/config/TODO new file mode 100644 index 000000000..2998ff4a0 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/TODO @@ -0,0 +1,7 @@ +Fri May 31 13:20:17 2002 + +1) Sanitize values from input boxes. + +2) Add canvas colors to cavas widget resources or to command-line options. + +3) Add ability to edit option line(s) and wall. diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.c b/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.c new file mode 100644 index 000000000..3681e8aa2 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.c @@ -0,0 +1,237 @@ +/* $XFree86$ */ +/* + * 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> + */ + +/** \file + * This file provides some compatibility support for reading VDL files + * that are used by xmovie + * (http://www.llnl.gov/icc/sdd/img/xmovie/xmovie.shtml). + * + * This file is not used by the DMX server. + */ + +#ifdef HAVE_DMX_CONFIG_H +#include <dmx-config.h> +#endif + +#include "dmxconfig.h" +#include "dmxparse.h" +#include "dmxcompat.h" +#include "parser.h" +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <ctype.h> + +static int dmxVDLReadLine(FILE *str, char *buf, int len) +{ + if (fgets(buf, len, str)) return strlen(buf); + return 0; +} + +static int dmxVDLCount(const char *buf) +{ + return strtol(buf, NULL, 10); +} + +static void dmxVDLVirtualEntry(const char *buf, + char *name, int *len, + int *x, int *y) +{ + char *end; + const char *s; + char *d; + int start; + + *x = strtol(buf, &end, 10); + *y = strtol(end, &end, 10); + + for (s = end, d = name, start = 1; *s && *s != '['; ++s) { + if (start && isspace(*s)) continue; + *d++ = *s; + start = 0; + } + *d = '\0'; + while (d > name && isspace(d[-1])) *--d = '\0'; /* remove trailing space */ + *len = strlen(name); +} + +static void dmxVDLDisplayEntry(const char *buf, + char *name, int *len, + int *x, int *y, + int *xoff, int *yoff, + int *xorig, int *yorig) +{ + const char *pt; + char *end; + + pt = strchr(buf, ' '); + strncpy(name, buf, pt-buf); + name[pt-buf] = '\0'; + *len = strlen(name); + + *x = strtol(pt, &end, 10); + *y = strtol(end, &end, 10); + *xorig = strtol(end, &end, 10); + *yorig = strtol(end, &end, 10); + *xoff = strtol(end, &end, 10); + *yoff = strtol(end, NULL, 10); +} + +/** Read from the VDL format \a filename and return a newly allocated \a + * DMXConfigEntryPtr */ +DMXConfigEntryPtr dmxVDLRead(const char *filename) +{ + FILE *str; + char buf[2048]; /* RATS: Use ok */ + char *pt; + int lineno = 0; + DMXConfigEntryPtr entry = NULL; + DMXConfigVirtualPtr virtual = NULL; + DMXConfigSubPtr sub = NULL; + DMXConfigDisplayPtr display = NULL; + DMXConfigFullDimPtr fdim = NULL; + int vcount = 0; + int dcount = 0; + int icount = 0; + int x, y, xoff, yoff, xorig, yorig; + char name[2048]; /* RATS: Use ok */ + const char *tmp; + int len; + enum { + simulateFlag, + virtualCount, + virtualEntry, + displayCount, + displayEntry, + ignoreCount, + ignoreEntry + } state = simulateFlag; + + if (!filename) str = stdin; + else str = fopen(filename, "r"); + if (!str) return NULL; + + while (dmxVDLReadLine(str, buf, sizeof(buf))) { + DMXConfigCommentPtr comment = NULL; + + ++lineno; + for (pt = buf; *pt; pt++) + if (*pt == '\r' || *pt == '\n') { + *pt = '\0'; + break; + } + if (buf[0] == '#') { + tmp = dmxConfigCopyString(buf + 1, strlen(buf + 1)); + comment = dmxConfigCreateComment(T_COMMENT, lineno, tmp); + entry = dmxConfigAddEntry(entry, dmxConfigComment, comment, NULL); + continue; + } + switch (state) { + case simulateFlag: + state = virtualCount; + break; + case virtualCount: + vcount = dmxVDLCount(buf); + state = virtualEntry; + break; + case virtualEntry: + len = sizeof(name); + dmxVDLVirtualEntry(buf, name, &len, &x, &y); + tmp = dmxConfigCopyString(name, len); + virtual = dmxConfigCreateVirtual(NULL, + dmxConfigCreateString(T_STRING, + lineno, + NULL, + tmp), + dmxConfigCreatePair(T_DIMENSION, + lineno, + NULL, + x, y, 0, 0), + NULL, NULL, NULL); + state = displayCount; + break; + case displayCount: + dcount = dmxVDLCount(buf); + state = displayEntry; + break; + case displayEntry: + dmxVDLDisplayEntry(buf, name, &len, &x, &y, &xoff, &yoff, + &xorig, &yorig); + tmp = dmxConfigCopyString(name, len); + fdim = dmxConfigCreateFullDim( + dmxConfigCreatePartDim( + dmxConfigCreatePair(T_DIMENSION, + lineno, + NULL, + x, y, 0, 0), + dmxConfigCreatePair(T_OFFSET, + lineno, + NULL, + xoff, yoff, + xoff, yoff)), + NULL); + display = dmxConfigCreateDisplay(NULL, + dmxConfigCreateString(T_STRING, + lineno, + NULL, + tmp), + fdim, + dmxConfigCreatePair(T_ORIGIN, + lineno, + NULL, + xorig, yorig, + 0, 0), + NULL); + sub = dmxConfigAddSub(sub, dmxConfigSubDisplay(display)); + if (!--dcount) { + state = ignoreCount; + virtual->subentry = sub; + entry = dmxConfigAddEntry(entry, + dmxConfigVirtual, + NULL, + virtual); + virtual = NULL; + sub = NULL; + } + break; + case ignoreCount: + icount = dmxVDLCount(buf); + state = ignoreEntry; + break; + case ignoreEntry: + if (!--icount) state = virtualEntry; + break; + } + } + return entry; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.h b/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.h new file mode 100644 index 000000000..416ec7873 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxcompat.h @@ -0,0 +1,45 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * Interface to VDL compatibility support. \see dmxcompat.c + * + * This file is not used by the DMX server. + */ + +#ifndef _DMXCOMPAT_H_ +#define _DMXCOMPAT_H_ + +extern DMXConfigEntryPtr dmxVDLRead(const char *filename); +#endif diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.c b/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.c new file mode 100644 index 000000000..353ce11db --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.c @@ -0,0 +1,499 @@ +/* $XFree86$ */ +/* + * Copyright 2002-2003 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> + * + */ + +/** \file + * Provides interface for reading DMX configuration files and for + * combining that information with command-line configuration parameters. */ + + +#ifdef HAVE_DMX_CONFIG_H +#include <dmx-config.h> +#endif + +#include "dmx.h" +#include "dmxinput.h" +#include "dmxconfig.h" +#include "dmxparse.h" +#include "dmxlog.h" +#include "dmxcb.h" +#include "dmxstat.h" +#include "parser.h" + +extern int yyparse(void); +extern FILE *yyin; + +static char *dmxXkbRules; +static char *dmxXkbModel; +static char *dmxXkbLayout; +static char *dmxXkbVariant; +static char *dmxXkbOptions; + +/** Stores lists of configuration information. */ +typedef struct DMXConfigListStruct { + const char *name; + struct DMXConfigListStruct *next; +} DMXConfigList, *DMXConfigListPtr; + +/** This stucture stores the parsed configuration information. */ +typedef struct DMXConfigCmdStruct { + const char *filename; + const char *config; + DMXConfigList *displays; + DMXConfigList *inputs; + DMXConfigList *xinputs; +} DMXConfigCmd, *DMXConfigCmdPtr; + +DMXConfigEntryPtr dmxConfigEntry; +static DMXConfigCmd dmxConfigCmd; + +static int dmxDisplaysFromCommandLine; + +/** Make a note that \a display is the name of an X11 display that + * should be initialized as a backend (output) display. Called from + * #ddxProcessArgument. */ +void dmxConfigStoreDisplay(const char *display) +{ + DMXConfigListPtr entry = malloc(sizeof(*entry)); + entry->name = strdup(display); + entry->next = NULL; + if (!dmxConfigCmd.displays) dmxConfigCmd.displays = entry; + else { + DMXConfigList *pt; + for (pt = dmxConfigCmd.displays; pt->next; pt = pt->next); + if (!pt) + dmxLog(dmxFatal, "dmxConfigStoreDisplay: end of list non-NULL\n"); + pt->next = entry; + } + ++dmxDisplaysFromCommandLine; +} + +/** Make a note that \a input is the name of an X11 display that should + * be used for input (either a backend or a console input device). */ +void dmxConfigStoreInput(const char *input) +{ + DMXConfigListPtr entry = malloc(sizeof(*entry)); + entry->name = strdup(input); + entry->next = NULL; + if (!dmxConfigCmd.inputs) dmxConfigCmd.inputs = entry; + else { + DMXConfigList *pt; + for (pt = dmxConfigCmd.inputs; pt->next; pt = pt->next); + if (!pt) + dmxLog(dmxFatal, "dmxConfigStoreInput: end of list non-NULL\n"); + pt->next = entry; + } +} + +/** Make a note that \a input is the name of an X11 display that should + * be used for input from XInput extension devices. */ +void dmxConfigStoreXInput(const char *input) +{ + DMXConfigListPtr entry = malloc(sizeof(*entry)); + entry->name = strdup(input); + entry->next = NULL; + if (!dmxConfigCmd.xinputs) dmxConfigCmd.xinputs = entry; + else { + DMXConfigList *pt; + for (pt = dmxConfigCmd.xinputs; pt->next; pt = pt->next); + if (!pt) + dmxLog(dmxFatal, "dmxConfigStoreXInput: end of list non-NULL\n"); + pt->next = entry; + } +} + +/** Make a note that \a file is the configuration file. */ +void dmxConfigStoreFile(const char *file) +{ + if (dmxConfigCmd.filename) + dmxLog(dmxFatal, "Only one -configfile allowed\n"); + dmxConfigCmd.filename = strdup(file); +} + +/** Make a note that \a config should be used as the configuration for + * current instantiation of the DMX server. */ +void dmxConfigStoreConfig(const char *config) +{ + if (dmxConfigCmd.config) dmxLog(dmxFatal, "Only one -config allowed\n"); + dmxConfigCmd.config = strdup(config); +} + +static int dmxConfigReadFile(const char *filename, int debug) +{ + FILE *str; + + if (!(str = fopen(filename, "r"))) return -1; + dmxLog(dmxInfo, "Reading configuration file \"%s\"\n", filename); + yyin = str; + yydebug = debug; + yyparse(); + fclose(str); + return 0; +} + +static const char *dmxConfigMatch(const char *target, DMXConfigEntryPtr entry) +{ + DMXConfigVirtualPtr v = entry->virtual; + const char *name = NULL; + + if (v && v->name) name = v->name; + + if (v && !dmxConfigCmd.config) return v->name ? v->name : "<noname>"; + if (!name) return NULL; + if (!strcmp(name, target)) return name; + return NULL; +} + +static DMXScreenInfo *dmxConfigAddDisplay(const char *name, + int scrnWidth, int scrnHeight, + int scrnX, int scrnY, + int scrnXSign, int scrnYSign, + int rootWidth, int rootHeight, + int rootX, int rootY, + int rootXSign, int rootYSign) +{ + DMXScreenInfo *dmxScreen; + + if (!(dmxScreens = realloc(dmxScreens, + (dmxNumScreens+1) * sizeof(*dmxScreens)))) + dmxLog(dmxFatal, + "dmxConfigAddDisplay: realloc failed for screen %d (%s)\n", + dmxNumScreens, name); + + dmxScreen = &dmxScreens[dmxNumScreens]; + memset(dmxScreen, 0, sizeof(*dmxScreen)); + dmxScreen->name = name; + dmxScreen->index = dmxNumScreens; + dmxScreen->scrnWidth = scrnWidth; + dmxScreen->scrnHeight = scrnHeight; + dmxScreen->scrnX = scrnX; + dmxScreen->scrnY = scrnY; + dmxScreen->scrnXSign = scrnXSign; + dmxScreen->scrnYSign = scrnYSign; + dmxScreen->rootWidth = rootWidth; + dmxScreen->rootHeight = rootHeight; + dmxScreen->rootX = rootX; + dmxScreen->rootY = rootY; + dmxScreen->stat = dmxStatAlloc(); + ++dmxNumScreens; + return dmxScreen; +} + +DMXInputInfo *dmxConfigAddInput(const char *name, int core) +{ + DMXInputInfo *dmxInput; + + if (!(dmxInputs = realloc(dmxInputs, + (dmxNumInputs+1) * sizeof(*dmxInputs)))) + dmxLog(dmxFatal, + "dmxConfigAddInput: realloc failed for input %d (%s)\n", + dmxNumInputs, name); + + dmxInput = &dmxInputs[dmxNumInputs]; + + memset(dmxInput, 0, sizeof(*dmxInput)); + dmxInput->name = name; + dmxInput->inputIdx = dmxNumInputs; + dmxInput->scrnIdx = -1; + dmxInput->core = core; + ++dmxNumInputs; + return dmxInput; +} + +static void dmxConfigCopyFromDisplay(DMXConfigDisplayPtr d) +{ + DMXScreenInfo *dmxScreen; + + dmxScreen = dmxConfigAddDisplay(d->name, + d->scrnWidth, d->scrnHeight, + d->scrnX, d->scrnY, + d->scrnXSign, d->scrnYSign, + d->rootWidth, d->rootHeight, + d->rootX, d->rootY, + d->rootXSign, d->rootXSign); + dmxScreen->where = PosAbsolute; + dmxScreen->whereX = d->rootXOrigin; + dmxScreen->whereY = d->rootYOrigin; +} + +static void dmxConfigCopyFromWall(DMXConfigWallPtr w) +{ + DMXConfigStringPtr pt; + DMXScreenInfo *dmxScreen; + int edge = dmxNumScreens; + int last = dmxNumScreens; + + if (!w->xwall && !w->ywall) { /* Try to make it square */ + int count; + for (pt = w->nameList, count = 0; pt; pt = pt->next) ++count; + w->xwall = sqrt(count) + .5; + } + + for (pt = w->nameList; pt; pt = pt->next) { + dmxScreen = dmxConfigAddDisplay(pt->string, w->width, w->height, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); + if (pt == w->nameList) { /* Upper left */ + dmxScreen->where = PosAbsolute; + dmxScreen->whereX = 0; + dmxScreen->whereY = 0; + } else if (w->xwall) { /* Tile left to right, then top to bottom */ + if (!((dmxNumScreens-1) % w->xwall)) { + dmxScreen->where = PosBelow; + dmxScreen->whereRefScreen = edge; + edge = dmxNumScreens-1; + } else { + dmxScreen->where = PosRightOf; + dmxScreen->whereRefScreen = last; + } + } else { /* Tile top to bottom, then left to right */ + if (!((dmxNumScreens-1) % w->ywall)) { + dmxScreen->where = PosRightOf; + dmxScreen->whereRefScreen = edge; + edge = dmxNumScreens-1; + } else { + dmxScreen->where = PosBelow; + dmxScreen->whereRefScreen = last; + } + + } + last = dmxNumScreens-1; + if (dmxScreen->where == PosAbsolute) + dmxLog(dmxInfo, "Added %s at %d %d\n", + pt->string, dmxScreen->whereX, dmxScreen->whereY); + else + dmxLog(dmxInfo, "Added %s %s %s\n", + pt->string, + dmxScreen->where == PosBelow ? "below" : "right of", + dmxScreens[dmxScreen->whereRefScreen].name); + } +} + +static void dmxConfigCopyFromOption(DMXConfigOptionPtr o) +{ + DMXConfigStringPtr pt; + int argc = 0; + char **argv = NULL; + + if (serverGeneration != 1) return; /* FIXME: only do once, for now */ + if (!o || !o->string) return; + for (pt = o->option; pt; pt = pt->next) { + if (pt->string) { + ++argc; + argv = realloc(argv, (argc+1) * sizeof(*argv)); + argv[argc] = (char *)pt->string; + } + } + argv[0] = NULL; + ProcessCommandLine(argc+1, argv); + free(argv); +} + +static void dmxConfigCopyFromParam(DMXConfigParamPtr p) +{ + const char **argv; + int argc; + + if ((argv = dmxConfigLookupParam(p, "xkbrules", &argc)) && argc == 2) { + dmxConfigSetXkbRules(argv[1]); + } else if ((argv = dmxConfigLookupParam(p, "xkbmodel", &argc)) + && argc == 2) { + dmxConfigSetXkbModel(argv[1]); + } else if ((argv = dmxConfigLookupParam(p, "xkblayout", &argc)) + && argc == 2) { + dmxConfigSetXkbLayout(argv[1]); + } else if ((argv = dmxConfigLookupParam(p, "xkbvariant", &argc)) + && argc == 2) { + dmxConfigSetXkbVariant(argv[1]); + } else if ((argv = dmxConfigLookupParam(p, "xkboptions", &argc)) + && argc == 2) { + dmxConfigSetXkbOptions(argv[1]); + } +} + +static void dmxConfigCopyData(DMXConfigVirtualPtr v) +{ + DMXConfigSubPtr sub; + + if (v->dim) dmxSetWidthHeight(v->dim->x, v->dim->y); + else dmxSetWidthHeight(0, 0); + for (sub = v->subentry; sub; sub = sub->next) { + switch (sub->type) { + case dmxConfigDisplay: dmxConfigCopyFromDisplay(sub->display); break; + case dmxConfigWall: dmxConfigCopyFromWall(sub->wall); break; + case dmxConfigOption: dmxConfigCopyFromOption(sub->option); break; + case dmxConfigParam: dmxConfigCopyFromParam(sub->param); break; + default: + dmxLog(dmxFatal, + "dmxConfigCopyData: not a display, wall, or value\n"); + } + } +} + +static void dmxConfigFromCommandLine(void) +{ + DMXConfigListPtr pt; + + dmxLog(dmxInfo, "Using configuration from command line\n"); + for (pt = dmxConfigCmd.displays; pt; pt = pt->next) { + DMXScreenInfo *dmxScreen = dmxConfigAddDisplay(pt->name, + 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0); + if (dmxNumScreens == 1) { + dmxScreen->where = PosAbsolute; + dmxScreen->whereX = 0; + dmxScreen->whereY = 0; + dmxLog(dmxInfo, "Added %s at %d %d\n", + dmxScreen->name, dmxScreen->whereX, dmxScreen->whereY); + } else { + dmxScreen->where = PosRightOf; + dmxScreen->whereRefScreen = dmxNumScreens - 2; + if (dmxScreen->whereRefScreen < 0) dmxScreen->whereRefScreen = 0; + dmxLog(dmxInfo, "Added %s %s %s\n", + dmxScreen->name, + dmxScreen->where == PosBelow ? "below" : "right of", + dmxScreens[dmxScreen->whereRefScreen].name); + } + } +} + +static void dmxConfigFromConfigFile(void) +{ + DMXConfigEntryPtr pt; + const char *name; + + for (pt = dmxConfigEntry; pt; pt = pt->next) { + /* FIXME -- if an input is specified, use it */ + if (pt->type != dmxConfigVirtual) continue; + if ((name = dmxConfigMatch(dmxConfigCmd.config, pt))) { + dmxLog(dmxInfo, "Using configuration \"%s\"\n", name); + dmxConfigCopyData(pt->virtual); + return; + } + } + dmxLog(dmxFatal, "Could not find configuration \"%s\" in \"%s\"\n", + dmxConfigCmd.config, dmxConfigCmd.filename); +} + +static void dmxConfigConfigInputs(void) +{ + DMXConfigListPtr pt; + + if (dmxNumInputs) return; + + if (dmxConfigCmd.inputs) { /* Use command line */ + for (pt = dmxConfigCmd.inputs; pt; pt = pt->next) + dmxConfigAddInput(pt->name, TRUE); + } else if (dmxNumScreens) { /* Use first display */ + dmxConfigAddInput(dmxScreens[0].name, TRUE); + } else { /* Use dummy */ + dmxConfigAddInput("dummy", TRUE); + } + + if (dmxConfigCmd.xinputs) { /* Non-core devices from command line */ + for (pt = dmxConfigCmd.xinputs; pt; pt = pt->next) + dmxConfigAddInput(pt->name, FALSE); + } +} + +/** Set up the appropriate global variables so that the DMX server will + * be initialized using the configuration specified in the config file + * and on the command line. */ +void dmxConfigConfigure(void) +{ + if (dmxConfigEntry) { + dmxConfigFreeEntry(dmxConfigEntry); + dmxConfigEntry = NULL; + } + if (dmxConfigCmd.filename) { + if (dmxConfigCmd.displays) + dmxLog(dmxWarning, + "Using configuration file \"%s\" instead of command line\n", + dmxConfigCmd.filename); + dmxConfigReadFile(dmxConfigCmd.filename, 0); + dmxConfigFromConfigFile(); + } else { + if (dmxConfigCmd.config) + dmxLog(dmxWarning, + "Configuration name (%s) without configuration file\n", + dmxConfigCmd.config); + dmxConfigFromCommandLine(); + } + dmxConfigConfigInputs(); +} + +/** This function determines the number of displays we WILL have and + * sets MAXSCREENS to that value. This is difficult since the number + * depends on the command line (which is easy to count) or on the config + * file, which has to be parsed. */ +void dmxConfigSetMaxScreens(void) +{ + static int processing = 0; + + if (processing) return; /* Prevent reentry via ProcessCommandLine */ + processing = 1; + if (dmxConfigCmd.filename) { + if (!dmxNumScreens) + dmxConfigConfigure(); +#ifndef MAXSCREENS + SetMaxScreens(dmxNumScreens); +#endif + } else +#ifndef MAXSCREENS + SetMaxScreens(dmxDisplaysFromCommandLine); +#endif + processing = 0; +} + +/** This macro is used to generate the following access methods: + * - dmxConfig{Set,Get}rules + * - dmxConfig{Set,Get}model + * - dmxConfig{Set,Get}layout + * - dmxConfig{Set,Get}variant + * - dmxConfig{Set,Get}options + * These methods are used to read and write information about the keyboard. */ + +#define GEN(param,glob,def) \ + void dmxConfigSet##glob(const char *param) { \ + if (dmx##glob) free((void *)dmx##glob); \ + dmx##glob = strdup(param); \ + } \ + char *dmxConfigGet##glob(void) { \ + return (char *)(dmx##glob ? dmx##glob : def); \ + } + +GEN(rules, XkbRules, DMX_DEFAULT_XKB_RULES) +GEN(model, XkbModel, DMX_DEFAULT_XKB_MODEL) +GEN(layout, XkbLayout, DMX_DEFAULT_XKB_LAYOUT) +GEN(variant, XkbVariant, DMX_DEFAULT_XKB_VARIANT) +GEN(options, XkbOptions, DMX_DEFAULT_XKB_OPTIONS) + diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.h b/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.h new file mode 100644 index 000000000..b5c0c1f1c --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxconfig.h @@ -0,0 +1,65 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * Interface for DMX configuration file support. \see dmxconfig.c */ + +#ifndef _DMXCONFIG_H_ +#define _DMXCONFIG_H_ +#define DMX_DEFAULT_XKB_RULES "xfree86" +#define DMX_DEFAULT_XKB_MODEL "pc101" +#define DMX_DEFAULT_XKB_LAYOUT "us" +#define DMX_DEFAULT_XKB_VARIANT NULL +#define DMX_DEFAULT_XKB_OPTIONS NULL + +extern void dmxConfigStoreDisplay(const char *display); +extern void dmxConfigStoreInput(const char *input); /* Core devices */ +extern void dmxConfigStoreXInput(const char *input); /* Non-core devices */ +extern void dmxConfigStoreFile(const char *file); +extern void dmxConfigStoreConfig(const char *config); +extern void dmxConfigConfigure(void); +extern void dmxConfigSetMaxScreens(void); + +extern void dmxConfigSetXkbRules(const char *rules); +extern void dmxConfigSetXkbModel(const char *model); +extern void dmxConfigSetXkbLayout(const char *layout); +extern void dmxConfigSetXkbVariant(const char *variant); +extern void dmxConfigSetXkbOptions(const char *options); + +extern char *dmxConfigGetXkbRules(void); +extern char *dmxConfigGetXkbModel(void); +extern char *dmxConfigGetXkbLayout(void); +extern char *dmxConfigGetXkbVariant(void); +extern char *dmxConfigGetXkbOptions(void); +#endif diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.c b/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.c new file mode 100644 index 000000000..1acb6d13e --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.c @@ -0,0 +1,611 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * + * This file provides support routines and helper functions to be used + * by the DMX configuration file parser. + * + * Because the DMX configuration file parsing should be capable of being + * used in a stand-alone fashion (i.e., independent from the DMX server + * source tree), no dependencies on other DMX routines are made. */ + +#ifdef HAVE_DMX_CONFIG_H +#include <dmx-config.h> +#endif + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdarg.h> +#include "dmxparse.h" + +/** A general error logging routine that does not depend on the dmxLog + * functions. */ +void dmxConfigLog(const char *format, ...) +{ + va_list args; + + va_start(args, format); + vprintf(format, args); /* RATS: All calls to dmxConfigLog from + * dmxparse.c and dmxprint.c use a + * trusted format. */ + va_end(args); +} + +void *dmxConfigAlloc(unsigned long bytes) +{ + void *area = malloc(bytes); + if (!area) { + dmxConfigLog("dmxConfigAlloc: out of memory\n"); + return NULL; + } + memset(area, 0, bytes); + return area; +} + +void *dmxConfigRealloc(void *orig, unsigned long orig_bytes, + unsigned long bytes) +{ + unsigned char *area = realloc(orig, bytes); + if (!area) { + dmxConfigLog("dmxConfigRealloc: out of memory\n"); + return NULL; + } + memset(area + orig_bytes, 0, bytes - orig_bytes); + return area; +} + +const char *dmxConfigCopyString(const char *string, int length) +{ + char *copy; + + if (!length) length = strlen(string); + copy = dmxConfigAlloc(length + 1); + if (length) strncpy(copy, string, length); + copy[length] = '\0'; + return copy; +} + +void dmxConfigFree(void *area) +{ + if (area) free(area); +} + +DMXConfigTokenPtr dmxConfigCreateToken(int token, int line, + const char *comment) +{ + DMXConfigTokenPtr pToken = dmxConfigAlloc(sizeof(*pToken)); + pToken->token = token; + pToken->line = line; + pToken->comment = comment; + return pToken; +} + +void dmxConfigFreeToken(DMXConfigTokenPtr p) +{ + if (!p) return; + dmxConfigFree((void *)p->comment); + dmxConfigFree(p); +} + +DMXConfigStringPtr dmxConfigCreateString(int token, int line, + const char *comment, + const char *string) +{ + DMXConfigStringPtr pString = dmxConfigAlloc(sizeof(*pString)); + + pString->token = token; + pString->line = line; + pString->comment = comment; + pString->string = string; + return pString; +} + +void dmxConfigFreeString(DMXConfigStringPtr p) +{ + DMXConfigStringPtr next; + + if (!p) return; + do { + next = p->next; + dmxConfigFree((void *)p->comment); + dmxConfigFree((void *)p->string); + dmxConfigFree(p); + } while ((p = next)); +} + +DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line, + const char *comment, + int number) +{ + DMXConfigNumberPtr pNumber = dmxConfigAlloc(sizeof(*pNumber)); + + pNumber->token = token; + pNumber->line = line; + pNumber->comment = comment; + pNumber->number = number; + return pNumber; +} + +void dmxConfigFreeNumber(DMXConfigNumberPtr p) +{ + if (!p) return; + dmxConfigFree((void *)p->comment); + dmxConfigFree(p); +} + +DMXConfigPairPtr dmxConfigCreatePair(int token, int line, + const char *comment, + int x, int y, + int xsign, int ysign) +{ + DMXConfigPairPtr pPair = dmxConfigAlloc(sizeof(*pPair)); + + pPair->token = token; + pPair->line = line; + pPair->comment = comment; + pPair->x = x; + pPair->y = y; + pPair->xsign = (xsign < 0) ? -1 : 1; + pPair->ysign = (ysign < 0) ? -1 : 1; + return pPair; +} + +void dmxConfigFreePair(DMXConfigPairPtr p) +{ + if (!p) return; + dmxConfigFree((void *)p->comment); + dmxConfigFree(p); +} + +DMXConfigCommentPtr dmxConfigCreateComment(int token, int line, + const char *comment) +{ + DMXConfigCommentPtr pComment = dmxConfigAlloc(sizeof(*pComment)); + + pComment->token = token; + pComment->line = line; + pComment->comment = comment; + return pComment; +} + +void dmxConfigFreeComment(DMXConfigCommentPtr p) +{ + if (!p) return; + dmxConfigFree((void *)p->comment); + dmxConfigFree(p); +} + +DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim, + DMXConfigPairPtr pOffset) +{ + DMXConfigPartDimPtr pPart = dmxConfigAlloc(sizeof(*pPart)); + pPart->dim = pDim; + pPart->offset = pOffset; + return pPart; +} + +void dmxConfigFreePartDim(DMXConfigPartDimPtr p) +{ + if (!p) return; + dmxConfigFreePair(p->dim); + dmxConfigFreePair(p->offset); + dmxConfigFree(p); +} + +DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn, + DMXConfigPartDimPtr pRoot) +{ + DMXConfigFullDimPtr pFull = dmxConfigAlloc(sizeof(*pFull)); + pFull->scrn = pScrn; + pFull->root = pRoot; + return pFull; +} + +void dmxConfigFreeFullDim(DMXConfigFullDimPtr p) +{ + if (!p) return; + dmxConfigFreePartDim(p->scrn); + dmxConfigFreePartDim(p->root); + dmxConfigFree(p); +} + +DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pName, + DMXConfigFullDimPtr pDim, + DMXConfigPairPtr pOrigin, + DMXConfigTokenPtr pEnd) +{ + DMXConfigDisplayPtr pDisplay = dmxConfigAlloc(sizeof(*pDisplay)); + + memset(pDisplay, 0, sizeof(*pDisplay)); + + pDisplay->start = pStart; + pDisplay->dname = pName; + pDisplay->dim = pDim; + pDisplay->origin = pOrigin; + pDisplay->end = pEnd; + + pDisplay->name = pName ? pName->string : NULL; + pDisplay->rootXOrigin = pOrigin ? pOrigin->x : 0; + pDisplay->rootYOrigin = pOrigin ? pOrigin->y : 0; + + if (pDim && pDim->scrn && pDim->scrn->dim) { + pDisplay->scrnWidth = pDim->scrn->dim->x; + pDisplay->scrnHeight = pDim->scrn->dim->y; + } + if (pDim && pDim->scrn && pDim->scrn->offset) { + pDisplay->scrnX = pDim->scrn->offset->x; + pDisplay->scrnY = pDim->scrn->offset->y; + pDisplay->scrnXSign = pDim->scrn->offset->xsign; + pDisplay->scrnYSign = pDim->scrn->offset->ysign; + } + + if (pDim && pDim->root) { + if (pDim->root->dim) { + pDisplay->rootWidth = pDim->root->dim->x; + pDisplay->rootHeight = pDim->root->dim->y; + } + if (pDim->root->offset) { + pDisplay->rootX = pDim->root->offset->x; + pDisplay->rootY = pDim->root->offset->y; + pDisplay->rootXSign = pDim->root->offset->xsign; + pDisplay->rootYSign = pDim->root->offset->ysign; + } + } else { /* If no root specification, copy width + * and height from scrn -- leave offset + * as zero, since it is relative to + * scrn. */ + pDisplay->rootWidth = pDisplay->scrnWidth; + pDisplay->rootHeight = pDisplay->scrnHeight; + } + + + return pDisplay; +} + +void dmxConfigFreeDisplay(DMXConfigDisplayPtr p) +{ + if (!p) return; + dmxConfigFreeToken(p->start); + dmxConfigFreeString(p->dname); + dmxConfigFreeFullDim(p->dim); + dmxConfigFreeToken(p->end); + dmxConfigFree(p); +} + +DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart, + DMXConfigPairPtr pWallDim, + DMXConfigPairPtr pDisplayDim, + DMXConfigStringPtr pNameList, + DMXConfigTokenPtr pEnd) +{ + DMXConfigWallPtr pWall = dmxConfigAlloc(sizeof(*pWall)); + + pWall->start = pStart; + pWall->wallDim = pWallDim; + pWall->displayDim = pDisplayDim; + pWall->nameList = pNameList; + pWall->end = pEnd; + + pWall->width = pDisplayDim ? pDisplayDim->x : 0; + pWall->height = pDisplayDim ? pDisplayDim->y : 0; + pWall->xwall = pWallDim ? pWallDim->x : 0; + pWall->ywall = pWallDim ? pWallDim->y : 0; + + return pWall; +} + +void dmxConfigFreeWall(DMXConfigWallPtr p) +{ + if (!p) return; + dmxConfigFreeToken(p->start); + dmxConfigFreePair(p->wallDim); + dmxConfigFreePair(p->displayDim); + dmxConfigFreeString(p->nameList); + dmxConfigFreeToken(p->end); + dmxConfigFree(p); +} + +DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pOption, + DMXConfigTokenPtr pEnd) +{ + int length = 0; + int offset = 0; + DMXConfigStringPtr p; + DMXConfigOptionPtr option = dmxConfigAlloc(sizeof(*option)); + + for (p = pOption; p; p = p->next) { + if (p->string) length += strlen(p->string) + 1; + } + + option->string = dmxConfigAlloc(length + 1); + + for (p = pOption; p; p = p->next) { + if (p->string) { + int len = strlen(p->string); + strncpy(option->string + offset, p->string, len); + offset += len; + if (p->next) option->string[offset++] = ' '; + } + } + option->string[offset] = '\0'; + + option->start = pStart; + option->option = pOption; + option->end = pEnd; + + return option; +} + +void dmxConfigFreeOption(DMXConfigOptionPtr p) +{ + if (!p) return; + if (p->string) free(p->string); + dmxConfigFreeToken(p->start); + dmxConfigFreeString(p->option); + dmxConfigFreeToken(p->end); + dmxConfigFree(p); +} + +const char **dmxConfigLookupParam(DMXConfigParamPtr p, const char *key, + int *argc) +{ + DMXConfigParamPtr pt; + + for (pt = p; pt; pt = pt->next) { + if (pt->argv && !strcasecmp(pt->argv[0], key)) { + *argc = pt->argc; + return pt->argv; + } + } + *argc = 0; + return NULL; +} + +DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart, + DMXConfigTokenPtr pOpen, + DMXConfigStringPtr pParam, + DMXConfigTokenPtr pClose, + DMXConfigTokenPtr pEnd) +{ + DMXConfigParamPtr param = dmxConfigAlloc(sizeof(*param)); + DMXConfigStringPtr pt; + + param->argc = 0; + param->argv = NULL; + for (pt = pParam; pt; pt = pt->next) { + if (pt->string) { + param->argv = realloc(param->argv, + (param->argc+2) * sizeof(*param->argv)); + param->argv[param->argc] = pt->string; + ++param->argc; + } + } + if (param->argv) param->argv[param->argc] = NULL; + + param->start = pStart; + param->open = pOpen; + param->param = pParam; + param->close = pClose; + param->end = pEnd; + + return param; +} + +void dmxConfigFreeParam(DMXConfigParamPtr p) +{ + DMXConfigParamPtr next; + + if (!p) return; + do { + next = p->next; + dmxConfigFreeToken(p->start); + dmxConfigFreeToken(p->open); + dmxConfigFreeString(p->param); + dmxConfigFreeToken(p->close); + dmxConfigFreeToken(p->end); + dmxConfigFree(p->argv); + dmxConfigFree(p); + } while ((p = next)); +} + +DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigDisplayPtr display, + DMXConfigWallPtr wall, + DMXConfigOptionPtr option, + DMXConfigParamPtr param) +{ + DMXConfigSubPtr pSub = dmxConfigAlloc(sizeof(*pSub)); + pSub->type = type; + switch (type) { + case dmxConfigComment: pSub->comment = comment; break; + case dmxConfigDisplay: pSub->display = display; break; + case dmxConfigWall: pSub->wall = wall; break; + case dmxConfigOption: pSub->option = option; break; + case dmxConfigParam: pSub->param = param; break; + default: dmxConfigLog("Type %d not supported in subentry\n", type); break; + } + return pSub; +} + +void dmxConfigFreeSub(DMXConfigSubPtr sub) +{ + DMXConfigSubPtr pt; + + for (pt = sub; pt; pt = pt->next) { + switch (pt->type) { + case dmxConfigComment: dmxConfigFreeComment(pt->comment); break; + case dmxConfigDisplay: dmxConfigFreeDisplay(pt->display); break; + case dmxConfigWall: dmxConfigFreeWall(pt->wall); break; + case dmxConfigOption: dmxConfigFreeOption(pt->option); break; + case dmxConfigParam: dmxConfigFreeParam(pt->param); break; + default: + dmxConfigLog("Type %d not supported in subentry\n", pt->type); + break; + } + } + dmxConfigFree(sub); +} + +DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment) +{ + return dmxConfigCreateSub(dmxConfigComment, comment, NULL, NULL, NULL, + NULL); +} + +DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display) +{ + return dmxConfigCreateSub(dmxConfigDisplay, NULL, display, NULL, NULL, + NULL); +} + +DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall) +{ + return dmxConfigCreateSub(dmxConfigWall, NULL, NULL, wall, NULL, NULL); +} + +DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option) +{ + return dmxConfigCreateSub(dmxConfigOption, NULL, NULL, NULL, option, NULL); +} + +DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param) +{ + return dmxConfigCreateSub(dmxConfigParam, NULL, NULL, NULL, NULL, param); +} + +extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head, + DMXConfigSubPtr sub) +{ + DMXConfigSubPtr pt; + + if (!head) return sub; + for (pt = head; pt->next; pt = pt->next); + pt->next = sub; + return head; +} + +DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pName, + DMXConfigPairPtr pDim, + DMXConfigTokenPtr pOpen, + DMXConfigSubPtr pSubentry, + DMXConfigTokenPtr pClose) +{ + DMXConfigVirtualPtr pVirtual = dmxConfigAlloc(sizeof(*pVirtual)); + + pVirtual->start = pStart; + pVirtual->vname = pName; + pVirtual->dim = pDim; + pVirtual->open = pOpen; + pVirtual->subentry = pSubentry; + pVirtual->close = pClose; + + pVirtual->name = pName ? pName->string : NULL; + pVirtual->width = pDim ? pDim->x : 0; + pVirtual->height = pDim ? pDim->y : 0; + + return pVirtual; +} + +void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual) +{ + dmxConfigFreeToken(virtual->start); + dmxConfigFreeString(virtual->vname); + dmxConfigFreePair(virtual->dim); + dmxConfigFreeToken(virtual->open); + dmxConfigFreeSub(virtual->subentry); + dmxConfigFreeToken(virtual->close); + dmxConfigFree(virtual); +} + +DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigVirtualPtr virtual) +{ + DMXConfigEntryPtr pEntry = dmxConfigAlloc(sizeof(*pEntry)); + pEntry->type = type; + switch (type) { + case dmxConfigComment: pEntry->comment = comment; break; + case dmxConfigVirtual: pEntry->virtual = virtual; break; + default: dmxConfigLog("Type %d not supported in entry\n", type); break; + } + return pEntry; +} + +void dmxConfigFreeEntry(DMXConfigEntryPtr entry) +{ + DMXConfigEntryPtr pt; + + for (pt = entry; pt; pt = pt->next) { + switch (pt->type) { + case dmxConfigComment: dmxConfigFreeComment(pt->comment); break; + case dmxConfigVirtual: dmxConfigFreeVirtual(pt->virtual); break; + default: + dmxConfigLog("Type %d not supported in entry\n", pt->type); + break; + } + } + dmxConfigFree(entry); +} + +DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head, + DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigVirtualPtr virtual) +{ + DMXConfigEntryPtr child = dmxConfigCreateEntry(type, comment, virtual); + DMXConfigEntryPtr pt; + + if (!head) return child; + + for (pt = head; pt->next; pt = pt->next); + pt->next = child; + + return head; +} + +DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment) +{ + return dmxConfigCreateEntry(dmxConfigComment, comment, NULL); +} + +DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual) +{ + return dmxConfigCreateEntry(dmxConfigVirtual, NULL, virtual); +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.h b/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.h new file mode 100644 index 000000000..8ea84f4e3 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxparse.h @@ -0,0 +1,298 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * Interface to DMX configuration file parser. \see dmxparse.c */ + +#ifndef _DMXPARSE_H_ +#define _DMXPARSE_H_ + +#include <stdio.h> /* For FILE */ + +/** Stores tokens not stored in other structures (e.g., keywords and ;) */ +typedef struct _DMXConfigToken { + int token; + int line; + const char *comment; +} DMXConfigToken, *DMXConfigTokenPtr; + +/** Stores parsed strings. */ +typedef struct _DMXConfigString { + int token; + int line; + const char *comment; + const char *string; + struct _DMXConfigString *next; +} DMXConfigString, *DMXConfigStringPtr; + +/** Stores parsed numbers. */ +typedef struct _DMXConfigNumber { + int token; + int line; + const char *comment; + int number; +} DMXConfigNumber, *DMXConfigNumberPtr; + +/** Stores parsed pairs (e.g., x y) */ +typedef struct _DMXConfigPair { + int token; + int line; + const char *comment; + int x; + int y; + int xsign; + int ysign; +} DMXConfigPair, *DMXConfigPairPtr; + +/** Stores parsed comments not stored with a token. */ +typedef struct _DMXConfigComment { + int token; + int line; + const char *comment; +} DMXConfigComment, *DMXConfigCommentPtr; + +typedef enum { + dmxConfigComment, + dmxConfigVirtual, + dmxConfigDisplay, + dmxConfigWall, + dmxConfigOption, + dmxConfigParam +} DMXConfigType; + +/** Stores a geometry specification. */ +typedef struct _DMXConfigPartDim { + DMXConfigPairPtr dim; + DMXConfigPairPtr offset; +} DMXConfigPartDim, *DMXConfigPartDimPtr; + +/** Stores a pair of geometry specifications. */ +typedef struct _DMXConfigFullDim { + DMXConfigPartDimPtr scrn; + DMXConfigPartDimPtr root; +} DMXConfigFullDim, *DMXConfigFullDimPtr; + +/** Stores parsed display information. */ +typedef struct _DMXConfigDisplay { + /* Summary information */ + const char *name; + /* Screen Window Geometry */ + int scrnWidth, scrnHeight; + int scrnX, scrnY; + int scrnXSign, scrnYSign; + /* Root Window Geometry */ + int rootWidth, rootHeight; + int rootX, rootY; + int rootXSign, rootYSign; + /* Origin in global space */ + int rootXOrigin, rootYOrigin; + + /* Raw configuration information */ + DMXConfigTokenPtr start; + DMXConfigStringPtr dname; + DMXConfigFullDimPtr dim; + DMXConfigPairPtr origin; + DMXConfigTokenPtr end; +} DMXConfigDisplay, *DMXConfigDisplayPtr; + +/** Stores parsed wall information. */ +typedef struct _DMXConfigWall { + /* Summary information */ + int width, height; /* dimensions of displays */ + int xwall, ywall; /* dimensions of wall, in tiles */ + + + /* Raw configuration informaiton */ + DMXConfigTokenPtr start; + DMXConfigPairPtr wallDim; + DMXConfigPairPtr displayDim; + DMXConfigStringPtr nameList; + DMXConfigTokenPtr end; +} DMXConfigWall, *DMXConfigWallPtr; + +/** Stores parsed option information. */ +typedef struct _DMXConfigOption { + /* Summary information */ + char *string; + + /* Raw configuration informaiton */ + DMXConfigTokenPtr start; + DMXConfigStringPtr option; + DMXConfigTokenPtr end; +} DMXConfigOption, *DMXConfigOptionPtr; + +/** Stores parsed param information. */ +typedef struct _DMXConfigParam { + int argc; + const char **argv; + + DMXConfigTokenPtr start; + DMXConfigTokenPtr open; + DMXConfigStringPtr param; + DMXConfigTokenPtr close; + DMXConfigTokenPtr end; /* Either open/close OR end */ + struct _DMXConfigParam *next; +} DMXConfigParam, *DMXConfigParamPtr; + +/** Stores options under an entry (subentry). */ +typedef struct _DMXConfigSub { + DMXConfigType type; + DMXConfigCommentPtr comment; + DMXConfigDisplayPtr display; + DMXConfigWallPtr wall; + DMXConfigOptionPtr option; + DMXConfigParamPtr param; + struct _DMXConfigSub *next; +} DMXConfigSub, *DMXConfigSubPtr; + +/** Stores parsed virtual information. */ +typedef struct _DMXConfigVirtual { + /* Summary information */ + const char *name; + int width, height; + + /* Raw configuration information */ + DMXConfigTokenPtr start; + DMXConfigStringPtr vname; + DMXConfigPairPtr dim; + DMXConfigTokenPtr open; + DMXConfigSubPtr subentry; + DMXConfigTokenPtr close; +} DMXConfigVirtual, *DMXConfigVirtualPtr; + +/** Heads entry storage. */ +typedef struct _DMXConfigEntry { + DMXConfigType type; + DMXConfigCommentPtr comment; + DMXConfigVirtualPtr virtual; + struct _DMXConfigEntry *next; +} DMXConfigEntry, *DMXConfigEntryPtr; + +extern DMXConfigEntryPtr dmxConfigEntry; + +extern int yylex(void); +extern int yydebug; +extern void yyerror(const char *message); + +extern void dmxConfigLog(const char *format, ...); +extern void *dmxConfigAlloc(unsigned long bytes); +extern void *dmxConfigRealloc(void *orig, + unsigned long orig_bytes, + unsigned long bytes); +extern const char *dmxConfigCopyString(const char *string, + int length); +extern void dmxConfigFree(void *area); +extern DMXConfigTokenPtr dmxConfigCreateToken(int token, int line, + const char *comment); +extern void dmxConfigFreeToken(DMXConfigTokenPtr p); +extern DMXConfigStringPtr dmxConfigCreateString(int token, int line, + const char *comment, + const char *string); +extern void dmxConfigFreeString(DMXConfigStringPtr p); +extern DMXConfigNumberPtr dmxConfigCreateNumber(int token, int line, + const char *comment, + int number); +extern void dmxConfigFreeNumber(DMXConfigNumberPtr p); +extern DMXConfigPairPtr dmxConfigCreatePair(int token, int line, + const char *comment, + int x, int y, + int xsign, int ysign); +extern void dmxConfigFreePair(DMXConfigPairPtr p); +extern DMXConfigCommentPtr dmxConfigCreateComment(int token, int line, + const char *comment); +extern void dmxConfigFreeComment(DMXConfigCommentPtr p); +extern DMXConfigPartDimPtr dmxConfigCreatePartDim(DMXConfigPairPtr pDim, + DMXConfigPairPtr pOffset); +extern void dmxConfigFreePartDim(DMXConfigPartDimPtr p); +extern DMXConfigFullDimPtr dmxConfigCreateFullDim(DMXConfigPartDimPtr pScrn, + DMXConfigPartDimPtr pRoot); +extern void dmxConfigFreeFullDim(DMXConfigFullDimPtr p); +extern DMXConfigDisplayPtr dmxConfigCreateDisplay(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pName, + DMXConfigFullDimPtr pDim, + DMXConfigPairPtr pOrigin, + DMXConfigTokenPtr pEnd); +extern void dmxConfigFreeDisplay(DMXConfigDisplayPtr p); +extern DMXConfigWallPtr dmxConfigCreateWall(DMXConfigTokenPtr pStart, + DMXConfigPairPtr pWallDim, + DMXConfigPairPtr pDisplayDim, + DMXConfigStringPtr pNameList, + DMXConfigTokenPtr pEnd); +extern void dmxConfigFreeWall(DMXConfigWallPtr p); +extern DMXConfigOptionPtr dmxConfigCreateOption(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pOption, + DMXConfigTokenPtr pEnd); +extern void dmxConfigFreeOption(DMXConfigOptionPtr p); +extern DMXConfigParamPtr dmxConfigCreateParam(DMXConfigTokenPtr pStart, + DMXConfigTokenPtr pOpen, + DMXConfigStringPtr pParam, + DMXConfigTokenPtr pClose, + DMXConfigTokenPtr pEnd); +extern void dmxConfigFreeParam(DMXConfigParamPtr p); +extern const char **dmxConfigLookupParam(DMXConfigParamPtr p, + const char *key, + int *argc); +extern DMXConfigSubPtr dmxConfigCreateSub(DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigDisplayPtr display, + DMXConfigWallPtr wall, + DMXConfigOptionPtr option, + DMXConfigParamPtr param); +extern void dmxConfigFreeSub(DMXConfigSubPtr sub); +extern DMXConfigSubPtr dmxConfigSubComment(DMXConfigCommentPtr comment); +extern DMXConfigSubPtr dmxConfigSubDisplay(DMXConfigDisplayPtr display); +extern DMXConfigSubPtr dmxConfigSubWall(DMXConfigWallPtr wall); +extern DMXConfigSubPtr dmxConfigSubOption(DMXConfigOptionPtr option); +extern DMXConfigSubPtr dmxConfigSubParam(DMXConfigParamPtr param); +extern DMXConfigSubPtr dmxConfigAddSub(DMXConfigSubPtr head, + DMXConfigSubPtr sub); +extern DMXConfigVirtualPtr dmxConfigCreateVirtual(DMXConfigTokenPtr pStart, + DMXConfigStringPtr pName, + DMXConfigPairPtr pDim, + DMXConfigTokenPtr pOpen, + DMXConfigSubPtr pSubentry, + DMXConfigTokenPtr pClose); +extern void dmxConfigFreeVirtual(DMXConfigVirtualPtr virtual); +extern DMXConfigEntryPtr dmxConfigCreateEntry(DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigVirtualPtr virtual); +extern void dmxConfigFreeEntry(DMXConfigEntryPtr entry); +extern DMXConfigEntryPtr dmxConfigAddEntry(DMXConfigEntryPtr head, + DMXConfigType type, + DMXConfigCommentPtr comment, + DMXConfigVirtualPtr virtual); +extern DMXConfigEntryPtr dmxConfigEntryComment(DMXConfigCommentPtr comment); +extern DMXConfigEntryPtr dmxConfigEntryVirtual(DMXConfigVirtualPtr virtual); + +#endif diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.c b/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.c new file mode 100644 index 000000000..ed3fc213d --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.c @@ -0,0 +1,456 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * + * This file provides support routines and helper functions to be used + * to pretty-print DMX configurations. + * + * Because the DMX configuration file parsing should be capable of being + * used in a stand-alone fashion (i.e., independent from the DMX server + * source tree), no dependencies on other DMX routines are made. */ + +#ifdef HAVE_DMX_CONFIG_H +#include <dmx-config.h> +#endif + +#include "dmxconfig.h" +#include "dmxparse.h" +#include "dmxprint.h" +#include "parser.h" +#include <stdio.h> +#include <stdarg.h> +#include <ctype.h> + +static FILE *str = NULL; +static int indent = 0; +static int pos = 0; + +/** Stack of indentation information used for pretty-printing + * configuration information. */ +static struct stack { + int base; + int comment; + int step; + struct stack *next; +} *stack, initialStack = { 0, 0, 4, NULL }; + +static void dmxConfigIndent(void) +{ + int i; + if (indent < 0) indent = 0; + if (indent > 40) indent = 40; + for (i = 0; i < indent; i++) fprintf(str, " "); +} + +static void dmxConfigNewline(void) +{ + if (pos) fprintf(str, "\n"); + pos = 0; +} + +static void dmxConfigPushState(int base, int comment, int step) +{ + struct stack *new = dmxConfigAlloc(sizeof(*new)); + new->base = base; + new->comment = comment; + new->step = step; + new->next = stack; + stack = new; + indent = base; + dmxConfigNewline(); +} + +static void dmxConfigPushComment(void) +{ + if (stack) indent = stack->comment; +} + +static void dmxConfigPushStep(void) +{ + if (stack) indent = stack->step; +} + +static void dmxConfigPopState(void) +{ + struct stack *old = stack; + + if (!stack) return; + indent = old->base; + stack = old->next; + if (!stack) dmxConfigLog("Stack underflow\n"); + dmxConfigFree(old); + dmxConfigNewline(); +} + +static void dmxConfigOutput(int addSpace, int doNewline, const char *comment, + const char *format, ...) +{ + va_list args; + + if (!pos) dmxConfigIndent(); + else if (addSpace) fprintf(str, " "); + + if (format) { + va_start(args, format); + /* RATS: This hasn't been audited -- it + * could probably result in a buffer + * overflow. */ + pos += vfprintf(str, format, args); /* assumes no newlines! */ + va_end(args); + } + + if (comment) { + if (pos) fprintf(str, " "); + pos += fprintf(str, "#%s", comment); + dmxConfigNewline(); + dmxConfigPushComment(); + } else if (doNewline) dmxConfigNewline(); +} + +static void dmxConfigPrintComment(DMXConfigCommentPtr p) +{ + dmxConfigOutput(1, 1, p->comment, NULL); +} + +static void dmxConfigPrintTokenFlag(DMXConfigTokenPtr p, int flag) +{ + if (!p) return; + switch (p->token) { + case T_VIRTUAL: + dmxConfigPushState(0, 4, 4); + dmxConfigOutput(0, 0, p->comment, "virtual"); + break; + case T_DISPLAY: + dmxConfigPushState(4, 12, 16); + dmxConfigOutput(0, 0, p->comment, "display"); + break; + case T_WALL: + dmxConfigPushState(4, 12, 16); + dmxConfigOutput(0, 0, p->comment, "wall"); + break; + case T_OPTION: + dmxConfigPushState(4, 12, 16); + dmxConfigOutput(0, 0, p->comment, "option"); + break; + case T_PARAM: + dmxConfigPushState(4, 8, 12); + dmxConfigOutput(0, 0, p->comment, "param"); + break; + case ';': + dmxConfigOutput(0, 1, p->comment, ";"); + if (flag) dmxConfigPopState(); + break; + case '{': + dmxConfigOutput(1, 1, p->comment, "{"); + dmxConfigPushStep(); + break; + case '}': + if (flag) dmxConfigPopState(); + dmxConfigOutput(0, 1, p->comment, "}"); + break; + case '/': + dmxConfigOutput(1, 0, NULL, "/"); + break; + default: + dmxConfigLog("unknown token %d on line %d\n", p->token, p->line); + } +} + +static void dmxConfigPrintToken(DMXConfigTokenPtr p) +{ + dmxConfigPrintTokenFlag(p, 1); +} + +static void dmxConfigPrintTokenNopop(DMXConfigTokenPtr p) +{ + dmxConfigPrintTokenFlag(p, 0); +} + +static int dmxConfigPrintQuotedString(const char *s) +{ + const char *pt; + + if (!s || !s[0]) return 1; /* Quote empty string */ + for (pt = s; *pt; ++pt) if (isspace(*pt)) return 1; + return 0; +} + +static void dmxConfigPrintString(DMXConfigStringPtr p, int quote) +{ + DMXConfigStringPtr pt; + + if (!p) return; + for (pt = p; pt; pt = pt->next) { + if (quote && dmxConfigPrintQuotedString(pt->string)) { + dmxConfigOutput(1, 0, pt->comment, "\"%s\"", + pt->string ? pt->string : ""); + } else + dmxConfigOutput(1, 0, pt->comment, "%s", + pt->string ? pt->string : ""); + } +} + +static int dmxConfigPrintPair(DMXConfigPairPtr p, int addSpace) +{ + const char *format = NULL; + + if (!p) return 0; + switch (p->token) { + case T_ORIGIN: format = "@%dx%d"; break; + case T_DIMENSION: format = "%dx%d"; break; + case T_OFFSET: format = "%c%d%c%d"; break; + } + if (p->token == T_OFFSET) { + if (!p->comment && !p->x && !p->y && p->xsign >= 0 && p->ysign >= 0) + return 0; + dmxConfigOutput(addSpace, 0, p->comment, format, + p->xsign < 0 ? '-' : '+', p->x, + p->ysign < 0 ? '-' : '+', p->y); + } else { + if (!p->comment && !p->x && !p->y) return 0; + dmxConfigOutput(addSpace, 0, p->comment, format, p->x, p->y); + } + return 1; +} + +static void dmxConfigPrintDisplay(DMXConfigDisplayPtr p) +{ + DMXConfigToken dummyStart = { T_DISPLAY, 0, NULL }; + DMXConfigToken dummyEnd = { ';', 0, NULL }; + DMXConfigToken dummySep = { '/', 0, NULL }; + DMXConfigString dummyName = { T_STRING, 0, NULL, NULL, NULL }; + DMXConfigPair dummySDim = { T_DIMENSION, 0, NULL, 0, 0, 0, 0 }; + DMXConfigPair dummySOffset = { T_OFFSET, 0, NULL, 0, 0, 0, 0 }; + DMXConfigPair dummyRDim = { T_DIMENSION, 0, NULL, 0, 0, 0, 0 }; + DMXConfigPair dummyROffset = { T_OFFSET, 0, NULL, 0, 0, 0, 0 }; + DMXConfigPair dummyOrigin = { T_ORIGIN, 0, NULL, 0, 0, 0, 0 }; + int output; + + if (p->dname) p->dname->string = p->name; + else dummyName.string = p->name; + + if (p->dim && p->dim->scrn && p->dim->scrn->dim) { + p->dim->scrn->dim->x = p->scrnWidth; + p->dim->scrn->dim->y = p->scrnHeight; + } else { + dummySDim.x = p->scrnWidth; + dummySDim.y = p->scrnHeight; + } + + if (p->dim && p->dim->scrn && p->dim->scrn->offset) { + p->dim->scrn->offset->x = p->scrnX; + p->dim->scrn->offset->y = p->scrnY; + } else { + dummySOffset.x = p->scrnX; + dummySOffset.y = p->scrnY; + } + + if (p->dim && p->dim->root && p->dim->root->dim) { + p->dim->root->dim->x = p->rootWidth; + p->dim->root->dim->y = p->rootHeight; + } else { + dummyRDim.x = p->rootWidth; + dummyRDim.y = p->rootHeight; + } + + if (p->dim && p->dim->root && p->dim->root->offset) { + p->dim->root->offset->x = p->rootX; + p->dim->root->offset->y = p->rootY; + } else { + dummyROffset.x = p->rootX; + dummyROffset.y = p->rootY; + } + + if (p->origin) { + p->origin->x = p->rootXOrigin, p->origin->y = p->rootYOrigin; + p->origin->xsign = p->rootXSign, p->origin->ysign = p->rootYSign; + } else { + dummyOrigin.x = p->rootXOrigin, dummyOrigin.y = p->rootYOrigin; + dummyOrigin.xsign = p->rootXSign, dummyOrigin.ysign = p->rootYSign; + } + + dmxConfigPrintToken(p->start ? p->start : &dummyStart); + dmxConfigPrintString(p->dname ? p->dname : &dummyName, 1); + + if (p->dim && p->dim->scrn && p->dim->scrn->dim) + output = dmxConfigPrintPair(p->dim->scrn->dim, 1); + else + output = dmxConfigPrintPair(&dummySDim, 1); + if (p->dim && p->dim->scrn && p->dim->scrn->offset) + dmxConfigPrintPair(p->dim->scrn->offset, !output); + else + dmxConfigPrintPair(&dummySOffset, !output); + + if (p->scrnWidth != p->rootWidth + || p->scrnHeight != p->rootHeight + || p->rootX + || p->rootY) { + dmxConfigPrintToken(&dummySep); + if (p->dim && p->dim->root && p->dim->root->dim) + output = dmxConfigPrintPair(p->dim->root->dim, 1); + else + output = dmxConfigPrintPair(&dummyRDim, 1); + if (p->dim && p->dim->root && p->dim->root->offset) + dmxConfigPrintPair(p->dim->root->offset, !output); + else + dmxConfigPrintPair(&dummyROffset, !output); + } + + dmxConfigPrintPair(p->origin ? p->origin : &dummyOrigin, 1); + dmxConfigPrintToken(p->end ? p->end : &dummyEnd); +} + +static void dmxConfigPrintWall(DMXConfigWallPtr p) +{ + dmxConfigPrintToken(p->start); + dmxConfigPrintPair(p->wallDim, 1); + dmxConfigPrintPair(p->displayDim, 1); + dmxConfigPrintString(p->nameList, 1); + dmxConfigPrintToken(p->end); +} + +static void dmxConfigPrintOption(DMXConfigOptionPtr p) +{ + DMXConfigToken dummyStart = { T_OPTION, 0, NULL }; + DMXConfigString dummyOption = { T_STRING, 0, NULL, NULL, NULL }; + DMXConfigToken dummyEnd = { ';', 0, NULL }; + + dummyOption.string = p->string; + + dmxConfigPrintToken(p->start ? p->start : &dummyStart); + dmxConfigPrintString(&dummyOption, 0); + dmxConfigPrintToken(p->end ? p->end : &dummyEnd); +} + +static void dmxConfigPrintParam(DMXConfigParamPtr p) +{ + if (!p) return; + if (p->start) { + if (p->open && p->close) { + dmxConfigPrintToken(p->start); + dmxConfigPrintToken(p->open); + dmxConfigPrintParam(p->next); + dmxConfigPrintToken(p->close); + } else if (p->end && p->param) { + dmxConfigPrintToken(p->start); + dmxConfigPrintString(p->param, 1); + dmxConfigPrintToken(p->end); + } else + dmxConfigLog("dmxConfigPrintParam: cannot handle format (a)\n"); + } else if (p->end && p->param) { + dmxConfigPrintString(p->param, 1); + dmxConfigPrintTokenNopop(p->end); + dmxConfigPrintParam(p->next); + } else + dmxConfigLog("dmxConfigPrintParam: cannot handle format (b)\n"); +} + +static void dmxConfigPrintSub(DMXConfigSubPtr p) +{ + DMXConfigSubPtr pt; + + if (!p) return; + for (pt = p; pt; pt = pt->next) { + switch (pt->type) { + case dmxConfigComment: dmxConfigPrintComment(pt->comment); break; + case dmxConfigDisplay: dmxConfigPrintDisplay(pt->display); break; + case dmxConfigWall: dmxConfigPrintWall(pt->wall); break; + case dmxConfigOption: dmxConfigPrintOption(pt->option); break; + case dmxConfigParam: dmxConfigPrintParam(pt->param); break; + default: + dmxConfigLog("dmxConfigPrintSub:" + " cannot handle type %d in subentry\n", pt->type); + } + } +} + +static void dmxConfigPrintVirtual(DMXConfigVirtualPtr p) +{ + DMXConfigToken dummyStart = { T_VIRTUAL, 0, NULL }; + DMXConfigToken dummyOpen = { '{', 0, NULL }; + DMXConfigToken dummyClose = { '}', 0, NULL }; + DMXConfigString dummyName = { T_STRING, 0, NULL, NULL, NULL }; + DMXConfigPair dummyDim = { T_DIMENSION, 0, NULL, 0, 0 }; + + if (p->vname) p->vname->string = p->name; + else dummyName.string = p->name; + + if (p->dim) p->dim->x = p->width, p->dim->y = p->height; + else dummyDim.x = p->width, dummyDim.y = p->height; + + + dmxConfigPrintToken(p->start ? p->start : &dummyStart); + dmxConfigPrintString(p->vname ? p->vname : &dummyName, 1); + dmxConfigPrintPair(p->dim ? p->dim : &dummyDim, 1); + dmxConfigPrintToken(p->open ? p->open : &dummyOpen); + dmxConfigPrintSub(p->subentry); + dmxConfigPrintToken(p->close ? p->close : &dummyClose); +} + +/** The configuration information in \a entry will be pretty-printed to + * the \a stream. If \a stream is NULL, then stdout will be used. */ +void dmxConfigPrint(FILE *stream, DMXConfigEntryPtr entry) +{ + DMXConfigEntryPtr pt; + + if (!stream) str = stdout; + else str = stream; + + stack = &initialStack; + + for (pt = entry; pt; pt = pt->next) { + switch (pt->type) { + case dmxConfigComment: dmxConfigPrintComment(pt->comment); break; + case dmxConfigVirtual: dmxConfigPrintVirtual(pt->virtual); break; + default: + dmxConfigLog("dmxConfigPrint: cannot handle type %d in entry\n", + pt->type); + } + } + if (pos) dmxConfigNewline(); +} + +/** The configuration information in \a p will be pretty-printed to the + * \a stream. If \a stream is NULL, then stdout will be used. */ +void dmxConfigVirtualPrint(FILE *stream, DMXConfigVirtualPtr p) +{ + if (!stream) str = stdout; + else str = stream; + + stack = &initialStack; + + dmxConfigPrintVirtual(p); + if (pos) dmxConfigNewline(); +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.h b/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.h new file mode 100644 index 000000000..b68c29620 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxprint.h @@ -0,0 +1,44 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +/** \file + * Interface to DMX configuration file pretty-printer. \see dmxprint.c */ + +#ifndef _DMXPRINT_H_ +#define _DMXPRINT_H_ + +void dmxConfigPrint(FILE *str, DMXConfigEntryPtr entry); +void dmxConfigVirtualPrint(FILE *str, DMXConfigVirtualPtr p); + +#endif diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.c b/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.c new file mode 100644 index 000000000..706c49908 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.c @@ -0,0 +1,50 @@ +/* $XFree86$ */ +/* + * 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> + * + * This is a simple filter for testing. + */ + +#include "dmxconfig.h" +#include "dmxparse.h" +#include "dmxprint.h" +#include "dmxcompat.h" + +extern int yyparse(void); +extern FILE *yyin; + +int main(int argc, char **argv) +{ + yydebug = 0; + yyparse(); + dmxConfigPrint(stdout, dmxConfigEntry); + return 0; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.man b/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.man new file mode 100644 index 000000000..68c7f5b40 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/dmxtodmx.man @@ -0,0 +1,41 @@ +.\" $XFree86$ +.\" 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> +.\" +.TH dmxtodmx 1 __vendorversion__ +.SH NAME +dmxtodmx - dmx configuration file parser and printer +.SH SYNOPSIS +.B dmxtodmx +.SH DESCRIPTION +.I dmxtodmx +reads the standard input, parsing a configuration file for the +.I Xdmx +distributed multi-head X server. After a successful parse, the file is +pretty-printed to standard output. +.SH "SEE ALSO" +Xdmx(1), vdltodmx(1), xdmxconfig(1) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/parser.y b/nx-X11/programs/Xserver/hw/dmx/config/parser.y new file mode 100644 index 000000000..ac2441017 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/parser.y @@ -0,0 +1,226 @@ +/* $XFree86$ */ +/* + * Copyright 2002-2003 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 "dmxparse.h" +#include <string.h> +#include <stdlib.h> +#define YYDEBUG 1 +#define YYERROR_VERBOSE +#define YY_USE_PROTOS + +DMXConfigEntryPtr dmxConfigEntry = NULL; +#define APPEND(type, h, t) \ +{ \ + type pt; \ + for (pt = h; pt->next; pt = pt->next); \ + pt->next = t; \ +} +%} + +%union { + DMXConfigTokenPtr token; + DMXConfigStringPtr string; + DMXConfigNumberPtr number; + DMXConfigPairPtr pair; + DMXConfigFullDimPtr fdim; + DMXConfigPartDimPtr pdim; + DMXConfigDisplayPtr display; + DMXConfigWallPtr wall; + DMXConfigOptionPtr option; + DMXConfigParamPtr param; + DMXConfigCommentPtr comment; + DMXConfigSubPtr subentry; + DMXConfigVirtualPtr virtual; + DMXConfigEntryPtr entry; +} + + /* Terminals */ +%token <token> '{' '}' ';' '/' T_VIRTUAL T_DISPLAY T_WALL T_OPTION T_PARAM +%token <string> T_STRING +%token <pair> T_DIMENSION T_OFFSET T_ORIGIN +%token <comment> T_COMMENT T_LINE_COMMENT + + /* Non-termials */ +%type <token> Display Wall Terminal Open Close +%type <string> NameList Name +%type <pair> Dimension Offset Origin +%type <pdim> PartialDim +%type <fdim> FullDim +%type <display> DisplayEntry +%type <option> OptionEntry +%type <param> ParamEntry ParamList Param +%type <subentry> SubList Sub +%type <wall> WallEntry +%type <virtual> Virtual +%type <entry> Program EntryList Entry + +%% + +Program : EntryList { dmxConfigEntry = $1; } + ; + +EntryList : Entry + | EntryList Entry { APPEND(DMXConfigEntryPtr,$1,$2); $$ = $1; } + ; + +Entry : Virtual { $$ = dmxConfigEntryVirtual($1); } + | T_LINE_COMMENT { $$ = dmxConfigEntryComment($1); } + ; + +Virtual : T_VIRTUAL Open SubList Close + { $$ = dmxConfigCreateVirtual($1, NULL, NULL, $2, $3, $4); } + | T_VIRTUAL Dimension Open SubList Close + { $$ = dmxConfigCreateVirtual($1, NULL, $2, $3, $4, $5); } + | T_VIRTUAL Name Open SubList Close + { $$ = dmxConfigCreateVirtual($1, $2, NULL, $3, $4, $5); } + | T_VIRTUAL Name Dimension Open SubList Close + { $$ = dmxConfigCreateVirtual($1, $2, $3, $4, $5, $6 ); } + ; + +SubList : Sub + | SubList Sub { APPEND(DMXConfigSubPtr,$1,$2); $$ = $1; } + ; + +Sub : T_LINE_COMMENT { $$ = dmxConfigSubComment($1); } + | DisplayEntry { $$ = dmxConfigSubDisplay($1); } + | WallEntry { $$ = dmxConfigSubWall($1); } + | OptionEntry { $$ = dmxConfigSubOption($1); } + | ParamEntry { $$ = dmxConfigSubParam($1); } + ; + +OptionEntry : T_OPTION NameList Terminal + { $$ = dmxConfigCreateOption($1, $2, $3); } + ; + +ParamEntry : T_PARAM NameList Terminal + { $$ = dmxConfigCreateParam($1, NULL, $2, NULL, $3); } + | T_PARAM Open ParamList Close + { $$ = dmxConfigCreateParam($1, $2, NULL, $4, NULL); + $$->next = $3; + } + ; + +ParamList : Param + | ParamList Param { APPEND(DMXConfigParamPtr,$1,$2); $$ = $1; } + ; + +Param : NameList Terminal + { $$ = dmxConfigCreateParam(NULL, NULL, $1, NULL, $2); } + ; + +PartialDim : Dimension Offset + { $$ = dmxConfigCreatePartDim($1, $2); } + | Dimension + { $$ = dmxConfigCreatePartDim($1, NULL); } + | Offset + { $$ = dmxConfigCreatePartDim(NULL, $1); } + ; + +FullDim : PartialDim '/' PartialDim + { $$ = dmxConfigCreateFullDim($1, $3); } + | '/' PartialDim + { $$ = dmxConfigCreateFullDim(NULL, $2); } + | PartialDim + { $$ = dmxConfigCreateFullDim($1, NULL); } + ; + +DisplayEntry : Display Name FullDim Origin Terminal + { $$ = dmxConfigCreateDisplay($1, $2, $3, $4, $5); } + | Display FullDim Origin Terminal + { $$ = dmxConfigCreateDisplay($1, NULL, $2, $3, $4); } + | Display Name Origin Terminal + { $$ = dmxConfigCreateDisplay($1, $2, NULL, $3, $4); } + + | Display Name FullDim Terminal + { $$ = dmxConfigCreateDisplay($1, $2, $3, NULL, $4); } + | Display FullDim Terminal + { $$ = dmxConfigCreateDisplay($1, NULL, $2, NULL, $3); } + | Display Name Terminal + { $$ = dmxConfigCreateDisplay($1, $2, NULL, NULL, $3); } + | Display Terminal + { $$ = dmxConfigCreateDisplay($1, NULL, NULL, NULL, $2); } + ; + +WallEntry : Wall Dimension Dimension NameList Terminal + { $$ = dmxConfigCreateWall($1, $2, $3, $4, $5); } + | Wall Dimension NameList Terminal + { $$ = dmxConfigCreateWall($1, $2, NULL, $3, $4); } + | Wall NameList Terminal + { $$ = dmxConfigCreateWall($1, NULL, NULL, $2, $3); } + ; + +Display : T_DISPLAY + | T_DISPLAY T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Name : T_STRING + | T_STRING T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Dimension : T_DIMENSION + | T_DIMENSION T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Offset : T_OFFSET + | T_OFFSET T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Origin : T_ORIGIN + | T_ORIGIN T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Terminal : ';' + | ';' T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Open : '{' + | '{' T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Close : '}' + | '}' T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +Wall : T_WALL + | T_WALL T_COMMENT { $$ = $1; $$->comment = $2->comment; } + ; + +NameList : Name + | NameList Name { APPEND(DMXConfigStringPtr, $1, $2); $$ = $1; } + ; diff --git a/nx-X11/programs/Xserver/hw/dmx/config/scanner.l b/nx-X11/programs/Xserver/hw/dmx/config/scanner.l new file mode 100644 index 000000000..ec450243a --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/scanner.l @@ -0,0 +1,183 @@ +/* $XFree86$ */ +/* + * 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 "dmxparse.h" +#include "parser.h" +#include <string.h> +#include <ctype.h> +static int getdimension(int token, const char *text, int leng); +static int getstring(int token, const char *text, int leng); +static int gettoken(int token, const char *text, int leng); +static int getcomment(int token, const char *text, int leng); +static int lineno = 1; +%} +%s OTHER +comment #.* +word ([[:alpha:]_/:\-\+\.\*][[:alnum:]_/:\-\+\.\*]+) +string \"(([^\"\n])|\"\")*\" +badstring \"(([^\"\n])|\"\")* +number [[:digit:]x]+ +dimension [[:digit:]]+[[:blank:]]*x[[:blank:]]*[[:digit:]]+ +offset [+-][[:digit:]]+[[:blank:]]*[+-][[:blank:]]*[[:digit:]]+ +origin @[[:blank:]]*[[:digit:]]+[[:blank:]]*[[:blank:]]*x[[:digit:]]+ +NL \n +WS [[:blank:]]+ +%% +virtual return gettoken(T_VIRTUAL, yytext, yyleng); +display return gettoken(T_DISPLAY, yytext, yyleng); +wall return gettoken(T_WALL, yytext, yyleng); +option return gettoken(T_OPTION, yytext, yyleng); +param return gettoken(T_PARAM, yytext, yyleng); +{dimension} return getdimension(T_DIMENSION, yytext, yyleng); +{offset} return getdimension(T_OFFSET, yytext+1, yyleng-1); +{origin} return getdimension(T_ORIGIN, yytext+1, yyleng-1); +{word} return getstring(T_STRING, yytext, yyleng); +{string} return getstring(T_STRING, yytext+1, yyleng-2); +{NL} ++lineno; +{WS} +\{ return gettoken(yytext[0], yytext, yyleng); +\} return gettoken(yytext[0], yytext, yyleng); +\; return gettoken(yytext[0], yytext, yyleng); +\/ return gettoken(yytext[0], yytext, yyleng); +^{comment} return getcomment(T_LINE_COMMENT, yytext, yyleng); +{comment} return getcomment(T_COMMENT, yytext, yyleng); +. return getstring(T_STRING, yytext, yyleng); +<<EOF>> return 0; +%% +int yywrap(void) +{ + return 1; +} + +void yyerror(const char *message) +{ + const char *pt, *end; + struct _entry { + const char *from; + const char *to; + } *entry, list[] = { + { "T_VIRTUAL", "\"virtual\"" }, + { "T_DISPLAY", "\"display\"" }, + { "T_WALL", "\"wall\"" }, + { "T_OPTION", "\"option\"" }, + { "T_PARAM", "\"param\"" }, + { "T_DIMENSION", "dimension (e.g., 2x2 or 1024x768)" }, + { "T_OFFSET", "display offset (e.g., +10-10)" }, + { "T_ORIGIN", "tile origin (e.g., @1280x1024)" }, + { "T_STRING", "string" }, + { "T_COMMENT", "comment (e.g., #...)" }, + { "T_LINE_COMMENT", "comment (e.g., #...)" }, + { NULL, NULL } + }; + + fprintf(stderr, "parse error on line %d at token \"%*.*s\"\n", + lineno, yyleng, yyleng, yytext); + end = message + strlen(message); + for (pt = message; *pt; pt++) { + if (pt[0] == 'T' && pt[1] == '_') { + const char *next = strchr(pt, ' '); + if (!next || !*next) next = strchr(pt, '\0'); + if (!next) goto bail; + --next; + if (next-pt == 1 && next[1] + && next[2] == '\'' && next[3] == '\'') { + fprintf(stderr, "\"%c\"", next[1]); + pt += 4; + goto cnt; + } + for (entry = list; entry->from; ++entry) { + if (!strncmp(entry->from, pt, strlen(entry->from))) { + fprintf(stderr, "%s", entry->to); + pt = next; + goto cnt; + } + } + } else if (end-pt >= 5 && pt[0] == '\'' && pt[1] == '\'' && pt[3] + && pt[4] == '\'' && pt[5] == '\'') { + fprintf(stderr, "\"%c\"", pt[3]); + pt += 5; + } else if (end-pt >= 3 && pt[0] == '\'' && pt[1] && pt[2] == '\'') { + fprintf(stderr, "\"%c\"", pt[1]); + pt += 3; + } + bail: + putc(*pt, stderr); + cnt: + ; + } + fprintf(stderr, "\n"); + exit( 1 ); +} + +static int getdimension(int token, const char *text, int leng) +{ + char *endptr; + char *tmp = dmxConfigAlloc(leng+1); + int x, y; + + strncpy(tmp, text, leng); + x = strtol(tmp, &endptr, 10); + while (*endptr && !isdigit(*endptr)) ++endptr; + y = strtol(endptr, NULL, 10); + dmxConfigFree(tmp); + yylval.pair = dmxConfigCreatePair(token, lineno, NULL, x, y, 1, 1); + return token; +} + +static int getstring(int token, const char *text, int leng) +{ + yylval.string = dmxConfigCreateString(token, lineno, NULL, + dmxConfigCopyString(leng ? text : "", + leng)); + return token; +} + +static int gettoken(int token, const char *text, int leng) +{ + yylval.token = dmxConfigCreateToken(token, lineno, NULL); + return token; +} + +static int getcomment(int token, const char *text, int leng) +{ + yylval.comment = dmxConfigCreateComment(token, lineno, + dmxConfigCopyString(text + 1, + leng - 1)); + return token; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-a.in b/nx-X11/programs/Xserver/hw/dmx/config/test-a.in new file mode 100644 index 000000000..827675374 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-a.in @@ -0,0 +1 @@ +error diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-a.out b/nx-X11/programs/Xserver/hw/dmx/config/test-a.out new file mode 100644 index 000000000..d35b29fc0 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-a.out @@ -0,0 +1,2 @@ +parse error on line 1 at token "error" +syntax error, unexpected string expecting "virtual" or comment (e.g., #...) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-b.in b/nx-X11/programs/Xserver/hw/dmx/config/test-b.in new file mode 100644 index 000000000..308ec1db4 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-b.in @@ -0,0 +1 @@ +# comment diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-b.out b/nx-X11/programs/Xserver/hw/dmx/config/test-b.out new file mode 100644 index 000000000..308ec1db4 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-b.out @@ -0,0 +1 @@ +# comment diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-c.in b/nx-X11/programs/Xserver/hw/dmx/config/test-c.in new file mode 100644 index 000000000..e07ae5ba6 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-c.in @@ -0,0 +1 @@ +virtual diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-c.out b/nx-X11/programs/Xserver/hw/dmx/config/test-c.out new file mode 100644 index 000000000..7390397a4 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-c.out @@ -0,0 +1,2 @@ +parse error on line 2 at token " " +syntax error, unexpected $end, expecting "{" or string or dimension (e.g., 2x2 or 1024x768) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-d.in b/nx-X11/programs/Xserver/hw/dmx/config/test-d.in new file mode 100644 index 000000000..6827503b1 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-d.in @@ -0,0 +1 @@ +display diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-d.out b/nx-X11/programs/Xserver/hw/dmx/config/test-d.out new file mode 100644 index 000000000..f3219b301 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-d.out @@ -0,0 +1,2 @@ +parse error on line 1 at token "display" +syntax error, unexpected "display" expecting "virtual" or comment (e.g., #...) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-e.in b/nx-X11/programs/Xserver/hw/dmx/config/test-e.in new file mode 100644 index 000000000..21dbde95c --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-e.in @@ -0,0 +1 @@ +display; diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-e.out b/nx-X11/programs/Xserver/hw/dmx/config/test-e.out new file mode 100644 index 000000000..f3219b301 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-e.out @@ -0,0 +1,2 @@ +parse error on line 1 at token "display" +syntax error, unexpected "display" expecting "virtual" or comment (e.g., #...) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-f.in b/nx-X11/programs/Xserver/hw/dmx/config/test-f.in new file mode 100644 index 000000000..17f6c6327 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-f.in @@ -0,0 +1,2 @@ +virtual { +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-f.out b/nx-X11/programs/Xserver/hw/dmx/config/test-f.out Binary files differnew file mode 100644 index 000000000..ba3f441d7 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-f.out diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-g.in b/nx-X11/programs/Xserver/hw/dmx/config/test-g.in new file mode 100644 index 000000000..453d8121c --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-g.in @@ -0,0 +1,4 @@ +virtual a { + display d0:0 1280x1024; + display d1:0 1280x1024; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-g.out b/nx-X11/programs/Xserver/hw/dmx/config/test-g.out new file mode 100644 index 000000000..453d8121c --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-g.out @@ -0,0 +1,4 @@ +virtual a { + display d0:0 1280x1024; + display d1:0 1280x1024; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-h.in b/nx-X11/programs/Xserver/hw/dmx/config/test-h.in new file mode 100644 index 000000000..1193d309e --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-h.in @@ -0,0 +1,7 @@ +# comment a +# comment b +## comment c +# <-- tab +# Next comment is empty +# +# Non empty diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-h.out b/nx-X11/programs/Xserver/hw/dmx/config/test-h.out new file mode 100644 index 000000000..1193d309e --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-h.out @@ -0,0 +1,7 @@ +# comment a +# comment b +## comment c +# <-- tab +# Next comment is empty +# +# Non empty diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-i.in b/nx-X11/programs/Xserver/hw/dmx/config/test-i.in new file mode 100644 index 000000000..b65967e62 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-i.in @@ -0,0 +1,3 @@ +virtual a { + param a b; # comment +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-i.out b/nx-X11/programs/Xserver/hw/dmx/config/test-i.out new file mode 100644 index 000000000..b65967e62 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-i.out @@ -0,0 +1,3 @@ +virtual a { + param a b; # comment +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-j.in b/nx-X11/programs/Xserver/hw/dmx/config/test-j.in new file mode 100644 index 000000000..cc1cdd0ea --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-j.in @@ -0,0 +1,13 @@ +virtual a { + option aaa # bbb + aa cc; + param { # comment 1 + a b; + c d; + x y z; # comment 2 + } + param e f g h; # comment 3 + param e f g hlskdjflskdfjsd #comment 4 + flksdjf sldkfjsldkfjsdlf + "lsdkfjsldkfjlsdkjflskdjflsdkjfl" "lkjsdlfjsdlfkjsdlfj"; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-j.out b/nx-X11/programs/Xserver/hw/dmx/config/test-j.out new file mode 100644 index 000000000..9acaa009b --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-j.out @@ -0,0 +1,11 @@ +virtual a { + option "aaa aa cc"; + param { # comment 1 + a b; + c d; + x y z; # comment 2 + } + param e f g h; # comment 3 + param e f g hlskdjflskdfjsd #comment 4 + flksdjf sldkfjsldkfjsdlf lsdkfjsldkfjlsdkjflskdjflsdkjfl lkjsdlfjsdlfkjsdlfj; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-k.in b/nx-X11/programs/Xserver/hw/dmx/config/test-k.in new file mode 100644 index 000000000..2218d26d9 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-k.in @@ -0,0 +1,3 @@ +virtual a { + option +xinerama -syncbatch 0; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-k.out b/nx-X11/programs/Xserver/hw/dmx/config/test-k.out new file mode 100644 index 000000000..ebd743923 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-k.out @@ -0,0 +1,3 @@ +virtual a { + option "+xinerama -syncbatch 0"; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-l.in b/nx-X11/programs/Xserver/hw/dmx/config/test-l.in new file mode 100644 index 000000000..7bf05139b --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-l.in @@ -0,0 +1,12 @@ +virtual a { + display d0:0 1x2; + display d1:0 +3+4; + display d2:0 100x200 @1x1; + display d3:0 +3+4 @2x2; + display d4:0 100x200+3+4 @3x3; + display d5:0 / 1x2+3+4; + display d6:0 / 1x2; + display d7:0 / +3+4; + display d8:0 / 1x2+3+4 @4x4; + display d9:0 11x22+33+44 / 111x222+333+444 @1000x1100; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/test-l.out b/nx-X11/programs/Xserver/hw/dmx/config/test-l.out new file mode 100644 index 000000000..7bf05139b --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/test-l.out @@ -0,0 +1,12 @@ +virtual a { + display d0:0 1x2; + display d1:0 +3+4; + display d2:0 100x200 @1x1; + display d3:0 +3+4 @2x2; + display d4:0 100x200+3+4 @3x3; + display d5:0 / 1x2+3+4; + display d6:0 / 1x2; + display d7:0 / +3+4; + display d8:0 / 1x2+3+4 @4x4; + display d9:0 11x22+33+44 / 111x222+333+444 @1000x1100; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.c b/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.c new file mode 100644 index 000000000..33cd8fe8a --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.c @@ -0,0 +1,58 @@ +/* $XFree86$ */ +/* + * 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> + * + */ + +#include "dmxconfig.h" +#include "dmxparse.h" +#include "dmxprint.h" +#include "dmxcompat.h" + +int main(int argc, char **argv) +{ + DMXConfigEntryPtr entry; + FILE *str; + + if (argc != 2 && argc !=3) { + fprintf(stderr, "Usage: vdltodmx inFile [outFile]\n"); + return 1; + } + if (argc == 2) { + str = stdout; + } else if (!(str = fopen(argv[2], "w"))) { + fprintf(stderr, "Cannot open %s for write\n", argv[2]); + return 2; + } + entry = dmxVDLRead(argv[1]); + dmxConfigPrint(str, entry); + return 0; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.man b/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.man new file mode 100644 index 000000000..b733db7ab --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/vdltodmx.man @@ -0,0 +1,95 @@ +.\" $XFree86$ +.\" 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> +.\" +.TH vdltodmx 1 __vendorversion__ +.SH NAME +vdltodmx - dmx configuration file parser and printer +.SH SYNOPSIS +.B vdltodmx +.I infile +.I outfile +.SH DESCRIPTION +.I vdltodmx +reads the input file, which should be in VDL configuration file format. +After a successful parse, a file in Xdmx configuration file format is +written to the output file. +.P +The VDL file format is used with +.IR xmovie , +which is available from +http://www.llnl.gov/icc/lc/img/xmovie/xmovie.html +.SH EXAMPLE +Given the following VDL-format file: +.RS +.nf +0 +2 +# +# +2560 2048 Left two-thirds [restrict=*:2] +2 +:2.1 1280 2048 0 0 0 0 +:2.2 1280 2048 1280 0 0 0 +4 +1280 1024 0 0 +1280 1024 0 1024 +1280 1024 1280 0 +1280 1024 1280 1024 +# +2560 2048 Right two-thirds [restrict=*:2] +2 +:2.2 1280 2048 0 0 0 0 +:2.3 1280 2048 1280 0 0 0 +4 +1280 1024 1280 0 +1280 1024 1280 1024 +1280 1024 2560 0 +1280 1024 2560 1024 +.fi +.RE +the following DMX-format file will be produced: +.RS +.nf +# +# +virtual "Left two-thirds" 2560x2048 { + display :2.1 1280x2048; + display :2.2 1280x2048 @1280x0; +} +# +virtual "Right two-thirds" 2560x2048 { + display :2.2 1280x2048; + display :2.3 1280x2048 @1280x0; +} +.fi +.RE +.SH BUGS +If the VDL file is not in the expected format, the program will probably +dump core. +.SH "SEE ALSO" +Xdmx(1), xdmxconfig(1), vdl(3), xmovie(1) diff --git a/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.c b/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.c new file mode 100644 index 000000000..4ba9ee5f8 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.c @@ -0,0 +1,1192 @@ +/* $XFree86$ */ +/* + * 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$Id: xdmxconfig.c,v 1.3 2005/10/06 02:40:41 kem Exp $" + +#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; + *maxWidth = 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, abouttext, aboutok; + Widget quitbox, quittext, 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); + abouttext = 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); + quittext = 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; +} diff --git a/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.man b/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.man new file mode 100644 index 000000000..dcceea0e3 --- /dev/null +++ b/nx-X11/programs/Xserver/hw/dmx/config/xdmxconfig.man @@ -0,0 +1,63 @@ +.\" $XFree86$ +.\" 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> +.\" +.TH xdmxconfig 1 __vendorversion__ +.SH NAME +xdmxconfig - a graphical configuration tool for Xdmx configuration files +.SH SYNOPSIS +.B xdmxconfig +[filename] +.SH DESCRIPTION +.I xdmxconfig +reads, edits, and writes configuration files for the Xdmx server. The +grammar for the configuration file is specified in the Xdmx(1) manual +page. +.PP +To start from scratch, create a "New Global" and specify the name and +overall dimensions for the configuration. Then use "New Display" to +enter more displays. +.PP +If there is more than one configuration, the configuration name button +will bring up a selection menu. +.PP +In the right-hand pannel, the left mouse button will move the +highlighted display at "tool resolution"; the middle mouse button will +move the highlighted display by a single pixel (at "wall resolution"); +and the right mouse button will bring up a menu allowing the highlighted +display to be edited or deleted. The arrow keys will also move the +highlighted display by a single pixel. +.SH BUGS +Currently, entries with the +.B wall +keyword are not editable, but will be preserved in the new output file. +The tool will quit when requested by the user, even if a configuration +file has not been written out (i.e., without warning). The menu +interaction should be improved (menu entries that don't currently work +should be greyed-out, for example). The Help button does not work. +.SH "SEE ALSO" +Xdmx(1), vdltodmx(1) |