andreacavalli/xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
486038fe16
xserver-multidpi/hw/dmx/config/xdmxconfig.c
Keith Packard 9838b7032e Introduce a consistent coding style 
This is strictly the application of the script 'x-indent-all.sh'
from util/modular. Compared to the patch that Daniel posted in
January, I've added a few indent flags:

	-bap
	-psl
	-T PrivatePtr
	-T pmWait
	-T _XFUNCPROTOBEGIN
	-T _XFUNCPROTOEND
	-T _X_EXPORT

The typedefs were needed to make the output of sdksyms.sh match the
previous output, otherwise, the code is formatted badly enough that
sdksyms.sh generates incorrect output.

The generated code was compared with the previous version and found to
be essentially identical -- "assert" line numbers and BUILD_TIME were
the only differences found.

The comparison was done with this script:

dir1=$1
dir2=$2

for dir in $dir1 $dir2; do
	(cd $dir && find . -name '*.o' | while read file; do
		dir=`dirname $file`
		base=`basename $file .o`
		dump=$dir/$base.dump
		objdump -d $file > $dump
	done)
done

find $dir1 -name '*.dump' | while read dump; do
	otherdump=`echo $dump | sed "s;$dir1;$dir2;"`
	diff -u $dump $otherdump
done

Signed-off-by: Keith Packard <keithp@keithp.com>
Acked-by: Daniel Stone <daniel@fooishbar.org>
Acked-by: Alan Coopersmith <alan.coopersmith@oracle.com>
2012-03-21 13:54:42 -07:00

1234 lines
44 KiB
C
Raw Blame History

/*
* Copyright 2002 Red Hat Inc., Durham, North Carolina.
*
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation on the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial
* portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NON-INFRINGEMENT. IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
/*
* Authors:
* Rickard E. (Rik) Faith <faith@redhat.com>
*
*/
#ifdef HAVE_DMX_CONFIG_H
#include <dmx-config.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Box.h>
/* #include <X11/Xaw/Paned.h> */
#include <X11/Xaw/Command.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Dialog.h>
#include <X11/keysym.h>
#include "Canvas.h"
#include "dmxparse.h"
#include "dmxprint.h"
#include "dmxlog.h"
extern int yyparse(void);
extern FILE *yyin;
#define DMX_INFO "xdmxconfig v0.9\nCopyright 2002 Red Hat Inc.\n"
#define DMX_MAIN_WIDTH 800
#define DMX_MAIN_HEIGHT 600
#define DMX_DATA_WIDTH 200
#define DMX_DATA_HEIGHT 200
#define DMX_CANVAS_WIDTH 400
#define DMX_CANVAS_HEIGHT 500
DMXConfigEntryPtr dmxConfigEntry;
static DMXConfigVirtualPtr dmxConfigCurrent, dmxConfigNewVirtual;
static DMXConfigDisplayPtr dmxConfigCurrentDisplay, dmxConfigNewDisplay;
static int dmxConfigGrabbed, dmxConfigGrabbedFine;
static int dmxConfigGrabbedX, dmxConfigGrabbedY;
static char *dmxConfigFilename;
static GC dmxConfigGC, dmxConfigGCRev, dmxConfigGCHL;
static int dmxConfigGCInit = 0;
static Dimension dmxConfigWidgetWidth, dmxConfigWidgetHeight;
static Dimension dmxConfigWallWidth, dmxConfigWallHeight;
static double dmxConfigScaleX, dmxConfigScaleY;
static int dmxConfigNotSaved;
static enum {
dmxConfigStateOpen,
dmxConfigStateSave
} dmxConfigState;
/* Global widgets */
static Widget canvas;
static Widget cnamebox, cdimbox;
static Widget openpopup, opendialog;
static Widget namebox, dimbox, rtbox, origbox;
static Widget okbutton, buttonpopup;
static Widget ecbutton, dcbutton;
static Widget ndbutton0, ndbutton1, edbutton, ddbutton;
static Widget ecpopup, ecdialog0, ecdialog1;
static Widget edpopup, eddialog0, eddialog1, eddialog2;
static Widget aboutpopup, quitpopup;
static void
dmxConfigCanvasGCs(void)
{
Display *dpy = XtDisplay(canvas);
Window win = XtWindow(canvas);
XGCValues gcvals;
unsigned long mask;
Colormap colormap;
XColor fg, bg, hl, tmp;
if (dmxConfigGCInit++)
return;
XtVaGetValues(canvas, XtNcolormap, &colormap, NULL);
XAllocNamedColor(XtDisplay(canvas), colormap, "black", &bg, &tmp);
XAllocNamedColor(XtDisplay(canvas), colormap, "white", &fg, &tmp);
XAllocNamedColor(XtDisplay(canvas), colormap, "red", &hl, &tmp);
mask = (GCFunction | GCPlaneMask | GCClipMask | GCForeground |
GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
GCFillStyle);
/* FIXME: copy this from widget */
gcvals.function = GXcopy;
gcvals.plane_mask = AllPlanes;
gcvals.clip_mask = None;
gcvals.foreground = fg.pixel;
gcvals.background = bg.pixel;
gcvals.line_width = 0;
gcvals.line_style = LineSolid;
gcvals.cap_style = CapNotLast;
gcvals.fill_style = FillSolid;
dmxConfigGC = XCreateGC(dpy, win, mask, &gcvals);
gcvals.foreground = hl.pixel;
dmxConfigGCHL = XCreateGC(dpy, win, mask, &gcvals);
gcvals.foreground = bg.pixel;
gcvals.background = fg.pixel;
dmxConfigGCRev = XCreateGC(dpy, win, mask, &gcvals);
}
static void
dmxConfigGetDims(int *maxWidth, int *maxHeight)
{
DMXConfigSubPtr pt;
DMXConfigEntryPtr e;
*maxWidth = dmxConfigWallWidth = 0;
*maxHeight = dmxConfigWallHeight = 0;
if (!dmxConfigCurrent)
return;
dmxConfigWallWidth = dmxConfigCurrent->width;
dmxConfigWallHeight = dmxConfigCurrent->height;
if (!dmxConfigWallWidth || !dmxConfigWallHeight) {
for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
if (pt->type == dmxConfigDisplay) {
int x = pt->display->scrnWidth + pt->display->rootXOrigin;
int y = pt->display->scrnHeight + pt->display->rootYOrigin;
if (x > dmxConfigWallWidth)
dmxConfigWallWidth = x;
if (y > dmxConfigWallHeight)
dmxConfigWallHeight = y;
}
}
}
/* Compute maximums */
*maxWidth = *maxHeight = 0;
for (e = dmxConfigEntry; e; e = e->next) {
if (e->type != dmxConfigVirtual)
continue;
for (pt = e->virtual->subentry; pt; pt = pt->next) {
if (pt->type == dmxConfigDisplay) {
int x = pt->display->scrnWidth + pt->display->rootXOrigin;
int y = pt->display->scrnHeight + pt->display->rootYOrigin;
if (x > *maxWidth)
*maxWidth = x;
if (y > *maxHeight)
*maxHeight = y;
}
}
}
if (dmxConfigWallWidth > *maxWidth)
*maxWidth = dmxConfigWallWidth;
if (dmxConfigWallHeight > *maxHeight)
*maxHeight = dmxConfigWallHeight;
}
static int
scalex(int x)
{
return (int) ((x * dmxConfigScaleX) + .5);
}
static int
scaley(int y)
{
return (int) ((y * dmxConfigScaleY) + .5);
}
static int
unscalex(int x)
{
return (int) ((x / dmxConfigScaleX) + .5);
}
static int
unscaley(int y)
{
return (int) ((y / dmxConfigScaleY) + .5);
}
static void
dmxConfigDataUpdate(void)
{
/* FIXME: could result in buffer overflows */
char cnambuf[512];
char cdimbuf[128];
char nambuf[512];
char dimbuf[128];
char rtbuf[128];
char offbuf[128];
const char *name;
if (!dmxConfigCurrent) {
XtVaSetValues(cnamebox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(cdimbox, XtNlabel, "", XtNsensitive, False, NULL);
XtVaSetValues(ecbutton, XtNsensitive, False, NULL);
XtVaSetValues(dcbutton, XtNsensitive, False, NULL);
XtVaSetValues(ndbutton0, XtNsensitive, False, NULL);
XtVaSetValues(ndbutton1, XtNsensitive, False, NULL);
}
else {
name = dmxConfigCurrent->name;
snprintf(cnambuf, sizeof(cnambuf), "%s", name ? name : "");
snprintf(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;
snprintf(nambuf, sizeof(nambuf), "%s", name ? name : "");
snprintf(dimbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
dmxConfigCurrentDisplay->scrnWidth,
dmxConfigCurrentDisplay->scrnHeight,
dmxConfigCurrentDisplay->scrnXSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnX,
dmxConfigCurrentDisplay->scrnYSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->scrnY);
snprintf(rtbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
dmxConfigCurrentDisplay->rootWidth,
dmxConfigCurrentDisplay->rootHeight,
dmxConfigCurrentDisplay->rootXSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->rootX,
dmxConfigCurrentDisplay->rootYSign < 0 ? '-' : '+',
dmxConfigCurrentDisplay->rootY);
snprintf(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 snprintf */
if (!dmxConfigCurrent)
return;
dmxConfigSetPopupPosition(ecpopup);
XtVaSetValues(ecdialog0, XtNvalue,
dmxConfigCurrent->name ? dmxConfigCurrent->name : "", NULL);
snprintf(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 snprintf */
if (!dmxConfigCurrent || !dmxConfigCurrentDisplay)
return;
dmxConfigSetPopupPosition(edpopup);
XtVaSetValues(eddialog0, XtNvalue,
dmxConfigCurrentDisplay->name
? dmxConfigCurrentDisplay->name : "", NULL);
snprintf(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);
snprintf(buf, sizeof(buf), "@%dx%d",
dmxConfigCurrentDisplay->rootXOrigin,
dmxConfigCurrentDisplay->rootYOrigin);
XtVaSetValues(eddialog2, XtNvalue, buf, NULL);
XtPopup(edpopup, XtGrabExclusive);
}
static void
dmxConfigNDCallback(Widget w, XtPointer closure, XtPointer callData)
{
int width = 1280, height = 1024;
if (!dmxConfigCurrent)
return;
if (dmxConfigCurrentDisplay) {
width = dmxConfigCurrentDisplay->scrnWidth;
height = dmxConfigCurrentDisplay->scrnHeight;
}
dmxConfigCurrentDisplay = dmxConfigCreateDisplay(NULL, NULL, NULL,
NULL, NULL);
dmxConfigNewDisplay = dmxConfigCurrentDisplay;
dmxConfigCurrentDisplay->scrnWidth = width;
dmxConfigCurrentDisplay->scrnHeight = height;
dmxConfigCurrent->subentry
= dmxConfigAddSub(dmxConfigCurrent->subentry,
dmxConfigSubDisplay(dmxConfigCurrentDisplay));
dmxConfigEDCallback(w, closure, callData);
}
static void
dmxConfigDDCallback(Widget w, XtPointer closure, XtPointer callData)
{
DMXConfigSubPtr pt;
if (!dmxConfigCurrent || !dmxConfigCurrentDisplay)
return;
/* First */
if (dmxConfigCurrent->subentry
&& dmxConfigCurrent->subentry->type == dmxConfigDisplay
&& dmxConfigCurrent->subentry->display == dmxConfigCurrentDisplay) {
dmxConfigCurrent->subentry = dmxConfigCurrent->subentry->next;
}
else {
for (pt = dmxConfigCurrent->subentry; pt && pt->next; pt = pt->next)
if (pt->next->type == dmxConfigDisplay
&& pt->next->display == dmxConfigCurrentDisplay) {
pt->next = pt->next->next;
break;
}
}
dmxConfigFreeDisplay(dmxConfigCurrentDisplay);
dmxConfigCurrentDisplay = NULL;
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
}
static void
dmxConfigAboutCallback(Widget w, XtPointer closure, XtPointer callData)
{
dmxConfigSetPopupPosition(aboutpopup);
XtPopup(aboutpopup, XtGrabExclusive);
}
static void
dmxConfigAboutOkCallback(Widget w, XtPointer closure, XtPointer CallData)
{
XtPopdown(aboutpopup);
}
static void
dmxConfigQuitCallback(Widget w, XtPointer closure, XtPointer callData)
{
if (dmxConfigNotSaved) {
dmxConfigSetPopupPosition(quitpopup);
XtPopup(quitpopup, XtGrabExclusive);
return;
}
exit(0);
}
static void
dmxConfigQuitOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
XtPopdown(quitpopup);
exit(0);
}
static void
dmxConfigQuitCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
XtPopdown(quitpopup);
}
static void
dmxConfigEDOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
char *value;
char *endpt;
dmxConfigNewDisplay = NULL;
dmxConfigGetValueString((char **) &dmxConfigCurrentDisplay->name,
eddialog0);
value = XawDialogGetValueString(eddialog1);
if (*value == '-' || *value == '+') {
dmxConfigCurrentDisplay->scrnWidth = 0;
dmxConfigCurrentDisplay->scrnHeight = 0;
endpt = value;
}
else {
dmxConfigCurrentDisplay->scrnWidth = strtol(value, &endpt, 10);
dmxConfigCurrentDisplay->scrnHeight = strtol(endpt + 1, &endpt, 10);
}
if (*endpt) {
dmxConfigCurrentDisplay->scrnXSign = (*endpt == '-') ? -1 : 1;
dmxConfigCurrentDisplay->scrnX = strtol(endpt + 1, &endpt, 10);
dmxConfigCurrentDisplay->scrnYSign = (*endpt == '-') ? -1 : 1;
dmxConfigCurrentDisplay->scrnY = strtol(endpt + 1, NULL, 10);
}
if (dmxConfigCurrentDisplay->scrnX < 0)
dmxConfigCurrentDisplay->scrnX = -dmxConfigCurrentDisplay->scrnX;
if (dmxConfigCurrentDisplay->scrnY < 0)
dmxConfigCurrentDisplay->scrnY = -dmxConfigCurrentDisplay->scrnY;
value = XawDialogGetValueString(eddialog2);
dmxConfigCurrentDisplay->rootXOrigin = strtol(value + 1, &endpt, 10);
dmxConfigCurrentDisplay->rootYOrigin = strtol(endpt + 1, NULL, 10);
XtPopdown(edpopup);
dmxConfigSetupCnamemenu();
dmxConfigCanvasDraw(NULL);
dmxConfigNotSaved = 1;
}
static void
dmxConfigEDCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
if (dmxConfigNewDisplay)
dmxConfigDDCallback(w, closure, callData);
dmxConfigNewDisplay = NULL;
XtPopdown(edpopup);
}
static void
dmxConfigOkAction(Widget w, XEvent * event,
String * params, Cardinal * num_params)
{
Widget p = XtParent(w);
Widget t;
if (p == opendialog)
dmxConfigOkCallback(w, NULL, NULL);
if (p == ecdialog0) {
t = XtNameToWidget(ecdialog1, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == ecdialog1)
dmxConfigECOkCallback(w, NULL, NULL);
if (p == eddialog0) {
t = XtNameToWidget(eddialog1, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == eddialog1) {
t = XtNameToWidget(eddialog2, "value");
XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
}
if (p == eddialog2)
dmxConfigEDOkCallback(w, NULL, NULL);
}
int
main(int argc, char **argv)
{
XtAppContext appContext;
Widget toplevel;
Widget parent, menubox, bottombox, databox, canvasbox;
Widget filebutton, helpbutton;
Widget filemenu, openbutton, savebutton, quitbutton;
Widget helpmenu, aboutbutton, aboutbox, aboutok;
Widget quitbox, quitok, quitcan;
Widget ncbutton;
Widget canbutton;
Widget ecbox, ecokbutton, eccanbutton;
Widget edbox, edokbutton;
Widget edcanbutton;
/* FIXME: add meta-i, ctrl,meta-z,v? */
const char *opentrans = "<Key>Return: openOk()\n\
<Key>Linefeed: openOk()\n\
Ctrl<Key>M: openOk()\n\
Ctrl<Key>J: openOk()\n\
Ctrl<Key>O: noop()\n\
Ctrl<Key>N: noop()\n\
Ctrl<Key>P: noop()";
const char *canvastrans =
"<Btn3Down>: placeMenu() XtMenuPopup(buttonpopup)";
XtActionsRec actiontable[] = {
{"openOk", dmxConfigOkAction},
{"placeMenu", dmxConfigPlaceMenu},
{"noop", NULL}
};
dmxConfigFilename = XtNewString((argc >= 2) ? argv[1] : "");
toplevel = XtVaAppInitialize(&appContext, "XDmxconfig",
NULL, 0, &argc, argv, NULL, NULL);
/* Main boxes */
parent = XtVaCreateManagedWidget("parent", formWidgetClass, toplevel,
XtNorientation, XtorientVertical,
XtNwidth, DMX_MAIN_WIDTH,
XtNheight, DMX_MAIN_HEIGHT, NULL);
menubox = XtVaCreateManagedWidget("menubox", boxWidgetClass, parent,
XtNborderWidth, 0,
XtNorientation, XtorientHorizontal,
XtNtop, XtChainTop, NULL);
bottombox = XtVaCreateManagedWidget("bottombox", formWidgetClass, parent,
XtNborderWidth, 0,
XtNfromVert, menubox,
XtNorientation, XtorientHorizontal,
NULL);
databox = XtVaCreateManagedWidget("databox", formWidgetClass,
bottombox,
XtNborderWidth, 0,
XtNhorizDistance, 0,
XtNwidth, DMX_DATA_WIDTH,
XtNheight, DMX_DATA_HEIGHT,
XtNleft, XtChainLeft,
XtNorientation, XtorientVertical, NULL);
/* Data */
cnamebox = XtVaCreateManagedWidget("cnamebox", menuButtonWidgetClass,
databox,
XtNtop, XtChainTop,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "",
XtNmenuName, "cnamemenu", NULL);
cdimbox = XtVaCreateManagedWidget("cdimbox", labelWidgetClass,
databox,
XtNfromVert, cnamebox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "", NULL);
namebox = XtVaCreateManagedWidget("namebox", labelWidgetClass, databox,
XtNfromVert, cdimbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "", NULL);
dimbox = XtVaCreateManagedWidget("dimbox", labelWidgetClass,
databox,
XtNfromVert, namebox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "", NULL);
rtbox = XtVaCreateManagedWidget("rtbox", labelWidgetClass,
databox,
XtNfromVert, dimbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "", NULL);
origbox = XtVaCreateManagedWidget("origbox", labelWidgetClass,
databox,
XtNfromVert, rtbox,
XtNjustify, XtJustifyLeft,
XtNwidth, DMX_DATA_WIDTH,
XtNlabel, "", NULL);
/* Canvas */
canvasbox = XtVaCreateManagedWidget("canvasbox", boxWidgetClass,
bottombox,
XtNborderWidth, 0,
XtNwidth, DMX_CANVAS_WIDTH,
XtNheight, DMX_CANVAS_HEIGHT,
XtNfromHoriz, databox, NULL);
canvas = XtVaCreateManagedWidget("canvas", canvasWidgetClass,
canvasbox,
XtNwidth, DMX_CANVAS_WIDTH,
XtNheight, DMX_CANVAS_HEIGHT, NULL);
/* Main menu buttons */
filebutton = XtVaCreateManagedWidget("File", menuButtonWidgetClass,
menubox,
XtNmenuName, "filemenu", NULL);
helpbutton = XtVaCreateManagedWidget("Help", menuButtonWidgetClass,
menubox,
XtNmenuName, "helpmenu", NULL);
/* File submenu buttons */
filemenu = XtVaCreatePopupShell("filemenu", simpleMenuWidgetClass,
filebutton, NULL);
openbutton = XtVaCreateManagedWidget("Open File", smeBSBObjectClass,
filemenu, NULL);
savebutton = XtVaCreateManagedWidget("Save File", smeBSBObjectClass,
filemenu, NULL);
ncbutton = XtVaCreateManagedWidget("New Global", smeBSBObjectClass,
filemenu, NULL);
ecbutton = XtVaCreateManagedWidget("Edit Global", smeBSBObjectClass,
filemenu, NULL);
dcbutton = XtVaCreateManagedWidget("Delete Global", smeBSBObjectClass,
filemenu, NULL);
ndbutton0 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
filemenu, NULL);
quitbutton = XtVaCreateManagedWidget("Quit", smeBSBObjectClass,
filemenu, NULL);
/* Help submenu button */
helpmenu = XtVaCreatePopupShell("helpmenu", simpleMenuWidgetClass,
helpbutton, NULL);
aboutbutton = XtVaCreateManagedWidget("About", smeBSBObjectClass,
helpmenu, NULL);
/* Open popup */
openpopup = XtVaCreatePopupShell("openpopup", transientShellWidgetClass,
toplevel, NULL);
opendialog = XtVaCreateManagedWidget("opendialog", dialogWidgetClass,
openpopup,
XtNlabel, "Filename: ",
XtNvalue, dmxConfigFilename, NULL);
okbutton = XtVaCreateManagedWidget("Open", commandWidgetClass,
opendialog, NULL);
canbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
opendialog, NULL);
/* EC popup */
ecpopup = XtVaCreatePopupShell("ecpopup", transientShellWidgetClass,
toplevel, NULL);
ecbox = XtVaCreateManagedWidget("ecbox", boxWidgetClass, ecpopup, NULL);
ecdialog0 = XtVaCreateManagedWidget("ecdialog0", dialogWidgetClass,
ecbox,
XtNlabel, "Name: ",
XtNvalue, "", NULL);
ecdialog1 = XtVaCreateManagedWidget("ecdialog1", dialogWidgetClass,
ecbox,
XtNlabel, "Dimension: ",
XtNvalue, "", NULL);
ecokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass, ecbox, NULL);
eccanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
ecbox, NULL);
/* ED popup */
edpopup = XtVaCreatePopupShell("edpopup", transientShellWidgetClass,
toplevel, NULL);
edbox = XtVaCreateManagedWidget("edbox", boxWidgetClass, edpopup, NULL);
eddialog0 = XtVaCreateManagedWidget("eddialog0", dialogWidgetClass,
edbox,
XtNlabel, "Display Name: ",
XtNvalue, "", NULL);
eddialog1 = XtVaCreateManagedWidget("eddialog1", dialogWidgetClass,
edbox,
XtNlabel, "Geometry: ",
XtNvalue, "", NULL);
eddialog2 = XtVaCreateManagedWidget("eddialog2", dialogWidgetClass,
edbox,
XtNlabel, "Offset: ",
XtNvalue, "", NULL);
edokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass, edbox, NULL);
edcanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
edbox, NULL);
/* About popup */
aboutpopup = XtVaCreatePopupShell("aboutpopup", transientShellWidgetClass,
toplevel, NULL);
aboutbox = XtVaCreateManagedWidget("aboutbox", boxWidgetClass,
aboutpopup, NULL);
XtVaCreateManagedWidget("abouttext", labelWidgetClass,
aboutbox, XtNlabel, DMX_INFO, NULL);
aboutok = XtVaCreateManagedWidget("OK", commandWidgetClass, aboutbox, NULL);
/* Quit popup */
quitpopup = XtVaCreatePopupShell("quitpopup", transientShellWidgetClass,
toplevel, NULL);
quitbox = XtVaCreateManagedWidget("quitbox", boxWidgetClass,
quitpopup, NULL);
XtVaCreateManagedWidget("quittext", labelWidgetClass,
quitbox,
XtNlabel,
"Changes to the configuration\n"
"been made that have not yet\n"
"been saved. Do you want to\n"
"quit without saving?", NULL);
quitok = XtVaCreateManagedWidget("Quit WITHOUT Saving",
commandWidgetClass, quitbox, NULL);
quitcan = XtVaCreateManagedWidget("Continue Editing",
commandWidgetClass, quitbox, NULL);
/* Button popup */
buttonpopup = XtVaCreatePopupShell("buttonpopup", simpleMenuWidgetClass,
toplevel, NULL);
ndbutton1 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
buttonpopup, NULL);
edbutton = XtVaCreateManagedWidget("Edit Display", smeBSBObjectClass,
buttonpopup, NULL);
ddbutton = XtVaCreateManagedWidget("Delete Display", smeBSBObjectClass,
buttonpopup, NULL);
/* Callbacks */
XtAddCallback(openbutton, XtNcallback, dmxConfigOpenCallback, NULL);
XtAddCallback(savebutton, XtNcallback, dmxConfigSaveCallback, NULL);
XtAddCallback(okbutton, XtNcallback, dmxConfigOkCallback, NULL);
XtAddCallback(canbutton, XtNcallback, dmxConfigCanCallback, NULL);
XtAppAddActions(appContext, actiontable, XtNumber(actiontable));
XtOverrideTranslations(canvas, XtParseTranslationTable(canvastrans));
XtOverrideTranslations(XtNameToWidget(opendialog, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(ecdialog0, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(ecdialog1, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog0, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog1, "value"),
XtParseTranslationTable(opentrans));
XtOverrideTranslations(XtNameToWidget(eddialog2, "value"),
XtParseTranslationTable(opentrans));
XtAddCallback(ncbutton, XtNcallback, dmxConfigNCCallback, NULL);
XtAddCallback(ecbutton, XtNcallback, dmxConfigECCallback, NULL);
XtAddCallback(ecokbutton, XtNcallback, dmxConfigECOkCallback, NULL);
XtAddCallback(eccanbutton, XtNcallback, dmxConfigECCanCallback, NULL);
XtAddCallback(dcbutton, XtNcallback, dmxConfigDCCallback, NULL);
XtAddCallback(ndbutton0, XtNcallback, dmxConfigNDCallback, NULL);
XtAddCallback(ndbutton1, XtNcallback, dmxConfigNDCallback, NULL);
XtAddCallback(edbutton, XtNcallback, dmxConfigEDCallback, NULL);
XtAddCallback(ddbutton, XtNcallback, dmxConfigDDCallback, NULL);
XtAddCallback(edokbutton, XtNcallback, dmxConfigEDOkCallback, NULL);
XtAddCallback(edcanbutton, XtNcallback, dmxConfigEDCanCallback, NULL);
XtAddCallback(aboutbutton, XtNcallback, dmxConfigAboutCallback, NULL);
XtAddCallback(aboutok, XtNcallback, dmxConfigAboutOkCallback, NULL);
XtAddCallback(quitok, XtNcallback, dmxConfigQuitOkCallback, NULL);
XtAddCallback(quitcan, XtNcallback, dmxConfigQuitCanCallback, NULL);
XtAddCallback(quitbutton, XtNcallback, dmxConfigQuitCallback, NULL);
XtAddCallback(canvas, XtNcallback, dmxConfigCanvasInput, NULL);
XtAddCallback(canvas, XtNcanvasExposeCallback, dmxConfigCanvasExpose, NULL);
XtAddCallback(canvas, XtNcanvasResizeCallback, dmxConfigCanvasResize, NULL);
if (dmxConfigFilename)
dmxConfigReadFile();
XtRealizeWidget(toplevel);
dmxConfigCopystrings();
dmxConfigSetupCnamemenu();
XtAppMainLoop(appContext);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink