server/crossedit/MapAttr.c

/*
 *  CrossEdit - game world editor
 *  Copyright (C) 2005 Mark Wedel & Crossfire Development Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 *  The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <assert.h>

#include "MapAttr.h"
#include "CrFace.h" /* XtNadjust */
#include "debug.h" /* debug0, etc */

/*
 * getValue functions
 */

/* Buffer size is defined in MapAttrChange(). */
#define CPY_INT(x) snprintf(str, BUFSIZ, "%d", (x));
#define CPY_STR(x) snprintf(str, BUFSIZ, "%s", (x));

static void getEnterX(mapstruct *map, char *str) {
    CPY_INT(MAP_ENTER_X(map));
}

static void getEnterY(mapstruct *map, char *str) {
    CPY_INT(MAP_ENTER_Y(map));
}

static void getWidth(mapstruct *map, char *str) {
    CPY_INT(MAP_WIDTH(map));
}

static void getHeight(mapstruct *map, char *str) {
    CPY_INT(MAP_HEIGHT(map));
}

static void getTileMapn(mapstruct *map, char *str, int n) {
    if (map->tile_path[n] == NULL) {
        str[0] = '\0';
    } else {
        CPY_STR(map->tile_path[n]);
    }
}

static void getTileMap0(mapstruct *map, char *str) {
    getTileMapn(map, str, 0);
}

static void getTileMap1(mapstruct *map, char *str) {
    getTileMapn(map, str, 1);
}

static void getTileMap2(mapstruct *map, char *str) {
    getTileMapn(map, str, 2);
}

static void getTileMap3(mapstruct *map, char *str) {
    getTileMapn(map, str, 3);
}

static void getTimeout(mapstruct *map, char *str) {
    CPY_INT(MAP_TIMEOUT(map));
}

static void getReset(mapstruct *map, char *str) {
    CPY_INT(MAP_RESET_TIMEOUT(map));
}

static void getDarkness(mapstruct *map, char *str) {
    CPY_INT(MAP_DARKNESS(map));
}

static void getDifficulty(mapstruct *map, char *str) {
    CPY_INT(MAP_DIFFICULTY(map));
}

static void getNoReset(mapstruct *map, char *str) {
    *str = map->fixed_resettime;
}

static void getOutdoor(mapstruct *map, char *str) {
    *str = MAP_OUTDOORS(map);
}

static void getRegion(mapstruct *map, char *str) {
    CPY_STR(get_name_of_region_for_map(map));
}

static void getNoSmooth(mapstruct *map, char *str) {
    *str = MAP_NOSMOOTH(map);
}

#undef CPY_STR
#undef CPY_INT

/*
 * putValue functions
 */

static void putEnterX(mapstruct *map, const char *str) {
    MAP_ENTER_X(map) = atoi(str);
}

static void putEnterY(mapstruct *map, const char *str) {
    MAP_ENTER_Y(map) = atoi(str);
}

static void putTileMapn(mapstruct *map, const char *str, int n) {
    if (map->tile_path[n] != NULL) {
        free(map->tile_path[n]);
        map->tile_path[n] = NULL;
    }
    if (str != NULL && strcmp(str, "") != 0) {
        map->tile_path[n] = strdup_local(str);
    }
}

static void putTileMap0(mapstruct *map, const char *str) {
    putTileMapn(map, str, 0);
}

static void putTileMap1(mapstruct *map, const char *str) {
    putTileMapn(map, str, 1);
}

static void putTileMap2(mapstruct *map, const char *str) {
    putTileMapn(map, str, 2);
}

static void putTileMap3(mapstruct *map, const char *str) {
    putTileMapn(map, str, 3);
}

/* Rather than resize the map twice, record the new size here,
   and apply it once (see MapAttrApply()). */
static int new_width, new_height;

static void putWidth(mapstruct *map, const char *str) {
    new_width = atoi(str);
}
static void putHeight(mapstruct *map, const char *str) {
    new_height = atoi(str);
}

static void putTimeout(mapstruct *map, const char *str) {
    MAP_TIMEOUT(map) = atoi(str);
}

static void putReset(mapstruct *map, const char *str) {
    MAP_RESET_TIMEOUT(map) = atoi(str);
}

static void putDarkness(mapstruct *map, const char *str) {
    MAP_DARKNESS(map) = atoi(str);
}

static void putDifficulty(mapstruct *map, const char *str) {
    MAP_DIFFICULTY(map) = atoi(str);
}

static void putOutdoor(mapstruct *map, const char *str) {
    if (*str)
        MAP_OUTDOORS(map) = 1;
    else
        MAP_OUTDOORS(map) = 0;
}

static void putRegion (mapstruct *map, const char *str) {
    map->region = get_region_by_name(str);
}

static void putNoSmooth(mapstruct *map, const char *str) {
    if (*str)
        MAP_NOSMOOTH(map) = 1;
    else
        MAP_NOSMOOTH(map) = 0;
}

static void putNoReset(mapstruct *map, const char *str) {
    if (*str)
        map->fixed_resettime = 1;
    else
        map->fixed_resettime = 0;
}


/**********************************************************************
 * tags
 **********************************************************************/

static const MapAttrDef MapDescription[] = {
    {"Start X",         MATypeString, getEnterX,        putEnterX},
    {"Start Y",         MATypeString, getEnterY,        putEnterY},
    {"Width",           MATypeString, getWidth,         putWidth},
    {"Height",          MATypeString, getHeight,        putHeight},

    {"Swap Time",       MATypeString, getTimeout,       putTimeout},
    {"Reset Timeout",   MATypeString, getReset,         putReset},

    {"Difficulty",      MATypeString, getDifficulty,    putDifficulty},
    {"Darkness",        MATypeString, getDarkness,      putDarkness},
    {"Region",          MATypeString, getRegion,        putRegion},

    {"East Map",        MATypeString, getTileMap1,      putTileMap1},
    {"West Map",        MATypeString, getTileMap3,      putTileMap3},
    {"North Map",       MATypeString, getTileMap0,      putTileMap0},
    {"South Map",       MATypeString, getTileMap2,      putTileMap2},

    {"Outdoor",         MATypeToggle, getOutdoor,       putOutdoor},
    {"No Smoothing",    MATypeToggle, getNoSmooth,      putNoSmooth},
    {"FixedReset",      MATypeToggle, getNoReset,       putNoReset},
};

static const int NUM_ATTRS = sizeof(MapDescription)/sizeof(MapAttrDef);


/* Build the widgets for the above list of attributes. */
static void MapAttrTagsCreate(MapAttr self, Widget parent)
{
    Widget cont;
    int i;

    self->tags = (Widget *)XtCalloc(NUM_ATTRS, sizeof(Widget));

    /* First, those that use a textbox, */
    for (i = 0; i < NUM_ATTRS; i++) {
        if (MapDescription[i].type == MATypeString) {

            /* A layout composite widget to keep the
               label to the left of the entry box. */
            cont = XtVaCreateManagedWidget
                ("box", boxWidgetClass, parent,
                 XtNorientation, XtorientHorizontal,
                 NULL);
            XtVaCreateManagedWidget
                ("label", labelWidgetClass, cont,
                 XtNlabel, MapDescription[i].label,
                 NULL);
            self->tags[i] = XtVaCreateManagedWidget
                ("value", asciiTextWidgetClass, cont,
                 XtNtype, XawAsciiString,
                 XtNeditType, XawtextEdit,
                 NULL);
        }
    }

    /* Then those that toggle. */
    for (i = 0; i < NUM_ATTRS; i++) {
        if (MapDescription[i].type == MATypeToggle) {

            /* Also, Crossedit.ad puts a few pixels' spacing
               around each list entry by putting a width
               on the *box's* border. */
            cont = XtVaCreateManagedWidget
                ("box", boxWidgetClass, parent,
                 XtNorientation, XtorientHorizontal,
                 NULL);

            self->tags[i] = XtVaCreateManagedWidget
                ("toggle", toggleWidgetClass, cont,
                 XtNlabel, MapDescription[i].label,
                 NULL);
        }
    }
}

/**
 * Write the values from our widgets into self->map. Sort of the reverse of
 * MapAttrChange().
 */
static void MapAttrApply(MapAttr self)
{
    String str;
    int len;
    int i;

    if (self->map == NULL) {
        return;
    }

    /*** name ***/
    XtVaGetValues(self->iw.name,
                  XtNstring, &str,
                  NULL);
    free(self->map->name);
    self->map->name = strdup_local(str);

    /*** message ***/
    XtVaGetValues(self->iw.msg,
                  XtNstring, &str,
                  NULL);

    free(self->map->msg);
    len = strlen(str);
    if (len > 0) {
        if (str[len-1] == '\n') {
            self->map->msg = strdup_local(str);
        } else {
            char *newmsg;

            /* The msg doesn't end with a newline. Append one, otherwise
               the headers can't be read properly. */

            newmsg = malloc(len+2);
            memcpy(newmsg, str, len);
            newmsg[len] = '\n';
            newmsg[len+1] = '\0';

            self->map->msg = newmsg;
        }
    } else {
        self->map->msg = NULL;
    }

    /* For each attribute, extract the state of the input widget,
       and write it to the map. */
    for (i = 0; i < NUM_ATTRS; i++) {
        const MapAttrDef *which = &MapDescription[i];
        if (which->type == MATypeString) {
            XtVaGetValues(self->tags[i], XtNstring, &str, NULL);
            which->putValue(self->map, str);
        } else if (which->type == MATypeToggle) {
            Boolean tmp;
            XtVaGetValues(self->tags[i], XtNstate, &tmp, NULL);
            *str = tmp ? ~0 : 0;
            which->putValue(self->map, str);
        }
    }

    /* The entries for the width and height store in new_width and new_height,
       so we only resize once. */
    if (new_width != MAP_WIDTH(self->map) ||
        new_height != MAP_HEIGHT(self->map)) {
        EditResizeScroll(self->client, new_width, new_height, 0, 0);
    } else {
        EditUpdate(self->client);
    }

    /*** update ***/
    AppUpdate(self->app);

    /* "Dirty" the map. */
    EditModified(self->client);
}

/*
 * callback: receive ok
 */
static void OkCb(Widget w, XtPointer client, XtPointer call)
{
    MapAttr self = (MapAttr)client;

    MapAttrApply(self);
    MapAttrDestroy(self);
}

/*
 * callback: receive apply
 */
static void ApplyCb(Widget w, XtPointer client, XtPointer call)
{
    MapAttr self = (MapAttr)client;

    MapAttrApply(self);
}

/*
 * callback: receive cancel
 */
static void CancelCb(Widget w, XtPointer client, XtPointer call) {
    MapAttr self = (MapAttr)client;

    MapAttrDestroy(self);
}

static void MapAttrLayout(MapAttr self, Widget parent) {
    Widget form, view1, pane, ok, apply, cancel;

    /* This widget gets decorated by the window manager.
       ('Shell' is possibly the Intrinsics name for such widgets.) */
    self->shell = XtVaCreatePopupShell
        ("mapattr", topLevelShellWidgetClass, parent, NULL);

    /* A "composite" widget, for laying out the other widgets. */
    form = XtVaCreateManagedWidget("form", formWidgetClass, self->shell, NULL);

    /* One line for the name,
       (the dimensions of widgets are given in Crossedit.ad. */
    self->iw.name = XtVaCreateManagedWidget
        ("name", asciiTextWidgetClass, form,
         XtNtype, XawAsciiString,
         XtNeditType, XawtextEdit,
         XtNresize, False,
         NULL);

    /* Below the name, several lines for the msg; */
    self->iw.msg = XtVaCreateManagedWidget
        ("msg", asciiTextWidgetClass, form,
         XtNtype, XawAsciiString,
         XtNeditType, XawtextEdit,
         XtNfromVert, self->iw.name,
         NULL);

    /* Below the message window,
       a widget that doesn't display all of its one child;
       instead, it displays scrollbars. */
    view1 = XtVaCreateManagedWidget
        ("view", viewportWidgetClass, form,
         /*XtNallowVert, True,*/
         XtNforceBars, True,
         XtNfromVert, self->iw.msg,
         NULL);

    /* Inside view1, a widget that packs its many children
       as tightly as possible. We've told this one to be tall
       and narrow, so we have a vertically scrolling list, with
       the attribute widgets stacked on top of one-another. */
    pane = XtVaCreateManagedWidget
        ("pane", boxWidgetClass, view1,
         XtNorientation, XtorientVertical,
         NULL);

    /* Below the attribute pane, view1, three button-type
       widgets. */
    ok = XtVaCreateManagedWidget
      ("ok", commandWidgetClass, form,
       XtNfromVert, view1,
       NULL);
    XtAddCallback(ok, XtNcallback, OkCb, (XtPointer)self);
    apply = XtVaCreateManagedWidget
      ("apply", commandWidgetClass, form,
       XtNfromVert, view1,
       XtNfromHoriz, ok,
       NULL);
    XtAddCallback(apply, XtNcallback, ApplyCb, (XtPointer)self);
    cancel = XtVaCreateManagedWidget
      ("cancel", commandWidgetClass, form,
       XtNfromVert, view1,
       XtNfromHoriz, apply,
       NULL);
    XtAddCallback(cancel, XtNcallback, CancelCb, (XtPointer)self);

    /* Add the individual attribute widgets to
       their pane. */
    MapAttrTagsCreate(self, pane);
}

/* Destroy the widget tree and free the internal data (not the map!). */
void MapAttrDestroy(MapAttr self)
{
    XtDestroyWidget(self->shell);
    XtFree((char*)self->tags);

    /* Clear the one pointer to self. */
    assert(self->client->mapattr == self);
    self->client->mapattr = NULL;

    XtFree((char*)self);
}

/* Set self's widgets to reflect the state of the given map.
   The new map is the one subsequent changes will be written to
   (with MapAttrApply()).

   This is sort of MapAttrApply()'s reverse. */
void MapAttrChange(MapAttr self, mapstruct * map) {
    int i;
    char buf[BUFSIZ];

    self->map = map;

    /* Give the name and msg boxes their new values. */
    XtVaSetValues(self->iw.name, XtNstring, self->map->name, NULL);
    XtVaSetValues(self->iw.msg, XtNstring, self->map->msg, NULL);

    /* For each attribute, */
    for (i = 0; i < NUM_ATTRS; i++) {
        /* fetch the value from the map,
           and give it to the matching widget. */

        const MapAttrDef *which = &MapDescription[i];
        which->getValue(map, buf);
        if (which->type == MATypeString) {
              XtVaSetValues(self->tags[i],
                            XtNstring, buf,
                            NULL);

              /* Put the cursor at the end of the line. */
              XtVaSetValues(self->tags[i],
                            XtNinsertPosition, strlen(buf),
                            NULL);
        } else if (which->type == MATypeToggle) {
              XtVaSetValues(self->tags[i],
                            XtNstate, *buf ? TRUE : FALSE,
                            NULL);
        }
    }

    snprintf(buf, sizeof(buf), "Map: %s", self->map->name);
    XtVaSetValues(self->shell,
                  XtNtitle, buf,
                  XtNiconName, buf,
                  NULL);
}

MapAttr MapAttrCreate(mapstruct * map, App app, Edit client)
{
    MapAttr self = (MapAttr)XtMalloc(sizeof(struct _MapAttr));
    self->map = map;
    self->app = client->app;
    self->client = client;

    /* Build the widgets, */
    MapAttrLayout(self, self->app->shell);

    /* fill them with data, */
    MapAttrChange(self, map);

    /* and display the window. */
    XtPopup(self->shell, XtGrabNone);

    return self;
}
Revision:	1.2
Committed:	Sun Aug 13 17:16:01 2006 UTC (20 years, 2 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	Made server compile with C++. Removed cfanim plugin and crossedit. C++ here we come.
#	Content
1	/*
2	* CrossEdit - game world editor
3	* Copyright (C) 2005 Mark Wedel & Crossfire Development Team
4	*
5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.
9	*
10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	* GNU General Public License for more details.
14	*
15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18	*
19	* The authors can be reached via e-mail at crossfire-devel@real-time.com
20	*/
21
22	#include <assert.h>
23
24	#include "MapAttr.h"
25	#include "CrFace.h" /* XtNadjust */
26	#include "debug.h" /* debug0, etc */
27
28	/*
29	* getValue functions
30	*/
31
32	/* Buffer size is defined in MapAttrChange(). */
33	#define CPY_INT(x) snprintf(str, BUFSIZ, "%d", (x));
34	#define CPY_STR(x) snprintf(str, BUFSIZ, "%s", (x));
35
36	static void getEnterX(mapstruct map, char str) {
37	CPY_INT(MAP_ENTER_X(map));
38	}
39
40	static void getEnterY(mapstruct map, char str) {
41	CPY_INT(MAP_ENTER_Y(map));
42	}
43
44	static void getWidth(mapstruct map, char str) {
45	CPY_INT(MAP_WIDTH(map));
46	}
47
48	static void getHeight(mapstruct map, char str) {
49	CPY_INT(MAP_HEIGHT(map));
50	}
51
52	static void getTileMapn(mapstruct map, char str, int n) {
53	if (map->tile_path[n] == NULL) {
54	str[0] = '\0';
55	} else {
56	CPY_STR(map->tile_path[n]);
57	}
58	}
59
60	static void getTileMap0(mapstruct map, char str) {
61	getTileMapn(map, str, 0);
62	}
63
64	static void getTileMap1(mapstruct map, char str) {
65	getTileMapn(map, str, 1);
66	}
67
68	static void getTileMap2(mapstruct map, char str) {
69	getTileMapn(map, str, 2);
70	}
71
72	static void getTileMap3(mapstruct map, char str) {
73	getTileMapn(map, str, 3);
74	}
75
76	static void getTimeout(mapstruct map, char str) {
77	CPY_INT(MAP_TIMEOUT(map));
78	}
79
80	static void getReset(mapstruct map, char str) {
81	CPY_INT(MAP_RESET_TIMEOUT(map));
82	}
83
84	static void getDarkness(mapstruct map, char str) {
85	CPY_INT(MAP_DARKNESS(map));
86	}
87
88	static void getDifficulty(mapstruct map, char str) {
89	CPY_INT(MAP_DIFFICULTY(map));
90	}
91
92	static void getNoReset(mapstruct map, char str) {
93	*str = map->fixed_resettime;
94	}
95
96	static void getOutdoor(mapstruct map, char str) {
97	*str = MAP_OUTDOORS(map);
98	}
99
100	static void getRegion(mapstruct map, char str) {
101	CPY_STR(get_name_of_region_for_map(map));
102	}
103
104	static void getNoSmooth(mapstruct map, char str) {
105	*str = MAP_NOSMOOTH(map);
106	}
107
108	#undef CPY_STR
109	#undef CPY_INT
110
111	/*
112	* putValue functions
113	*/
114
115	static void putEnterX(mapstruct map, const char str) {
116	MAP_ENTER_X(map) = atoi(str);
117	}
118
119	static void putEnterY(mapstruct map, const char str) {
120	MAP_ENTER_Y(map) = atoi(str);
121	}
122
123	static void putTileMapn(mapstruct map, const char str, int n) {
124	if (map->tile_path[n] != NULL) {
125	free(map->tile_path[n]);
126	map->tile_path[n] = NULL;
127	}
128	if (str != NULL && strcmp(str, "") != 0) {
129	map->tile_path[n] = strdup_local(str);
130	}
131	}
132
133	static void putTileMap0(mapstruct map, const char str) {
134	putTileMapn(map, str, 0);
135	}
136
137	static void putTileMap1(mapstruct map, const char str) {
138	putTileMapn(map, str, 1);
139	}
140
141	static void putTileMap2(mapstruct map, const char str) {
142	putTileMapn(map, str, 2);
143	}
144
145	static void putTileMap3(mapstruct map, const char str) {
146	putTileMapn(map, str, 3);
147	}
148
149	/* Rather than resize the map twice, record the new size here,
150	and apply it once (see MapAttrApply()). */
151	static int new_width, new_height;
152
153	static void putWidth(mapstruct map, const char str) {
154	new_width = atoi(str);
155	}
156	static void putHeight(mapstruct map, const char str) {
157	new_height = atoi(str);
158	}
159
160	static void putTimeout(mapstruct map, const char str) {
161	MAP_TIMEOUT(map) = atoi(str);
162	}
163
164	static void putReset(mapstruct map, const char str) {
165	MAP_RESET_TIMEOUT(map) = atoi(str);
166	}
167
168	static void putDarkness(mapstruct map, const char str) {
169	MAP_DARKNESS(map) = atoi(str);
170	}
171
172	static void putDifficulty(mapstruct map, const char str) {
173	MAP_DIFFICULTY(map) = atoi(str);
174	}
175
176	static void putOutdoor(mapstruct map, const char str) {
177	if (*str)
178	MAP_OUTDOORS(map) = 1;
179	else
180	MAP_OUTDOORS(map) = 0;
181	}
182
183	static void putRegion (mapstruct map, const char str) {
184	map->region = get_region_by_name(str);
185	}
186
187	static void putNoSmooth(mapstruct map, const char str) {
188	if (*str)
189	MAP_NOSMOOTH(map) = 1;
190	else
191	MAP_NOSMOOTH(map) = 0;
192	}
193
194	static void putNoReset(mapstruct map, const char str) {
195	if (*str)
196	map->fixed_resettime = 1;
197	else
198	map->fixed_resettime = 0;
199	}
200
201
202
203	/**********************************************************************
204	* tags
205	**********************************************************************/
206
207	static const MapAttrDef MapDescription[] = {
208	{"Start X", MATypeString, getEnterX, putEnterX},
209	{"Start Y", MATypeString, getEnterY, putEnterY},
210	{"Width", MATypeString, getWidth, putWidth},
211	{"Height", MATypeString, getHeight, putHeight},
212
213	{"Swap Time", MATypeString, getTimeout, putTimeout},
214	{"Reset Timeout", MATypeString, getReset, putReset},
215
216	{"Difficulty", MATypeString, getDifficulty, putDifficulty},
217	{"Darkness", MATypeString, getDarkness, putDarkness},
218	{"Region", MATypeString, getRegion, putRegion},
219
220	{"East Map", MATypeString, getTileMap1, putTileMap1},
221	{"West Map", MATypeString, getTileMap3, putTileMap3},
222	{"North Map", MATypeString, getTileMap0, putTileMap0},
223	{"South Map", MATypeString, getTileMap2, putTileMap2},
224
225	{"Outdoor", MATypeToggle, getOutdoor, putOutdoor},
226	{"No Smoothing", MATypeToggle, getNoSmooth, putNoSmooth},
227	{"FixedReset", MATypeToggle, getNoReset, putNoReset},
228	};
229
230	static const int NUM_ATTRS = sizeof(MapDescription)/sizeof(MapAttrDef);
231
232
233	/* Build the widgets for the above list of attributes. */
234	static void MapAttrTagsCreate(MapAttr self, Widget parent)
235	{
236	Widget cont;
237	int i;
238
239	self->tags = (Widget *)XtCalloc(NUM_ATTRS, sizeof(Widget));
240
241	/* First, those that use a textbox, */
242	for (i = 0; i < NUM_ATTRS; i++) {
243	if (MapDescription[i].type == MATypeString) {
244
245	/* A layout composite widget to keep the
246	label to the left of the entry box. */
247	cont = XtVaCreateManagedWidget
248	("box", boxWidgetClass, parent,
249	XtNorientation, XtorientHorizontal,
250	NULL);
251	XtVaCreateManagedWidget
252	("label", labelWidgetClass, cont,
253	XtNlabel, MapDescription[i].label,
254	NULL);
255	self->tags[i] = XtVaCreateManagedWidget
256	("value", asciiTextWidgetClass, cont,
257	XtNtype, XawAsciiString,
258	XtNeditType, XawtextEdit,
259	NULL);
260	}
261	}
262
263	/* Then those that toggle. */
264	for (i = 0; i < NUM_ATTRS; i++) {
265	if (MapDescription[i].type == MATypeToggle) {
266
267	/* Also, Crossedit.ad puts a few pixels' spacing
268	around each list entry by putting a width
269	on the box's border. */
270	cont = XtVaCreateManagedWidget
271	("box", boxWidgetClass, parent,
272	XtNorientation, XtorientHorizontal,
273	NULL);
274
275	self->tags[i] = XtVaCreateManagedWidget
276	("toggle", toggleWidgetClass, cont,
277	XtNlabel, MapDescription[i].label,
278	NULL);
279	}
280	}
281	}
282
283	/**
284	* Write the values from our widgets into self->map. Sort of the reverse of
285	* MapAttrChange().
286	*/
287	static void MapAttrApply(MapAttr self)
288	{
289	String str;
290	int len;
291	int i;
292
293	if (self->map == NULL) {
294	return;
295	}
296
297	/* name */
298	XtVaGetValues(self->iw.name,
299	XtNstring, &str,
300	NULL);
301	free(self->map->name);
302	self->map->name = strdup_local(str);
303
304	/* message */
305	XtVaGetValues(self->iw.msg,
306	XtNstring, &str,
307	NULL);
308
309	free(self->map->msg);
310	len = strlen(str);
311	if (len > 0) {
312	if (str[len-1] == '\n') {
313	self->map->msg = strdup_local(str);
314	} else {
315	char *newmsg;
316
317	/* The msg doesn't end with a newline. Append one, otherwise
318	the headers can't be read properly. */
319
320	newmsg = malloc(len+2);
321	memcpy(newmsg, str, len);
322	newmsg[len] = '\n';
323	newmsg[len+1] = '\0';
324
325	self->map->msg = newmsg;
326	}
327	} else {
328	self->map->msg = NULL;
329	}
330
331	/* For each attribute, extract the state of the input widget,
332	and write it to the map. */
333	for (i = 0; i < NUM_ATTRS; i++) {
334	const MapAttrDef *which = &MapDescription[i];
335	if (which->type == MATypeString) {
336	XtVaGetValues(self->tags[i], XtNstring, &str, NULL);
337	which->putValue(self->map, str);
338	} else if (which->type == MATypeToggle) {
339	Boolean tmp;
340	XtVaGetValues(self->tags[i], XtNstate, &tmp, NULL);
341	*str = tmp ? ~0 : 0;
342	which->putValue(self->map, str);
343	}
344	}
345
346	/* The entries for the width and height store in new_width and new_height,
347	so we only resize once. */
348	if (new_width != MAP_WIDTH(self->map) \|\|
349	new_height != MAP_HEIGHT(self->map)) {
350	EditResizeScroll(self->client, new_width, new_height, 0, 0);
351	} else {
352	EditUpdate(self->client);
353	}
354
355	/* update */
356	AppUpdate(self->app);
357
358	/* "Dirty" the map. */
359	EditModified(self->client);
360	}
361
362	/*
363	* callback: receive ok
364	*/
365	static void OkCb(Widget w, XtPointer client, XtPointer call)
366	{
367	MapAttr self = (MapAttr)client;
368
369	MapAttrApply(self);
370	MapAttrDestroy(self);
371	}
372
373	/*
374	* callback: receive apply
375	*/
376	static void ApplyCb(Widget w, XtPointer client, XtPointer call)
377	{
378	MapAttr self = (MapAttr)client;
379
380	MapAttrApply(self);
381	}
382
383	/*
384	* callback: receive cancel
385	*/
386	static void CancelCb(Widget w, XtPointer client, XtPointer call) {
387	MapAttr self = (MapAttr)client;
388
389	MapAttrDestroy(self);
390	}
391
392	static void MapAttrLayout(MapAttr self, Widget parent) {
393	Widget form, view1, pane, ok, apply, cancel;
394
395	/* This widget gets decorated by the window manager.
396	('Shell' is possibly the Intrinsics name for such widgets.) */
397	self->shell = XtVaCreatePopupShell
398	("mapattr", topLevelShellWidgetClass, parent, NULL);
399
400	/* A "composite" widget, for laying out the other widgets. */
401	form = XtVaCreateManagedWidget("form", formWidgetClass, self->shell, NULL);
402
403	/* One line for the name,
404	(the dimensions of widgets are given in Crossedit.ad. */
405	self->iw.name = XtVaCreateManagedWidget
406	("name", asciiTextWidgetClass, form,
407	XtNtype, XawAsciiString,
408	XtNeditType, XawtextEdit,
409	XtNresize, False,
410	NULL);
411
412	/* Below the name, several lines for the msg; */
413	self->iw.msg = XtVaCreateManagedWidget
414	("msg", asciiTextWidgetClass, form,
415	XtNtype, XawAsciiString,
416	XtNeditType, XawtextEdit,
417	XtNfromVert, self->iw.name,
418	NULL);
419
420	/* Below the message window,
421	a widget that doesn't display all of its one child;
422	instead, it displays scrollbars. */
423	view1 = XtVaCreateManagedWidget
424	("view", viewportWidgetClass, form,
425	/XtNallowVert, True,/
426	XtNforceBars, True,
427	XtNfromVert, self->iw.msg,
428	NULL);
429
430	/* Inside view1, a widget that packs its many children
431	as tightly as possible. We've told this one to be tall
432	and narrow, so we have a vertically scrolling list, with
433	the attribute widgets stacked on top of one-another. */
434	pane = XtVaCreateManagedWidget
435	("pane", boxWidgetClass, view1,
436	XtNorientation, XtorientVertical,
437	NULL);
438
439	/* Below the attribute pane, view1, three button-type
440	widgets. */
441	ok = XtVaCreateManagedWidget
442	("ok", commandWidgetClass, form,
443	XtNfromVert, view1,
444	NULL);
445	XtAddCallback(ok, XtNcallback, OkCb, (XtPointer)self);
446	apply = XtVaCreateManagedWidget
447	("apply", commandWidgetClass, form,
448	XtNfromVert, view1,
449	XtNfromHoriz, ok,
450	NULL);
451	XtAddCallback(apply, XtNcallback, ApplyCb, (XtPointer)self);
452	cancel = XtVaCreateManagedWidget
453	("cancel", commandWidgetClass, form,
454	XtNfromVert, view1,
455	XtNfromHoriz, apply,
456	NULL);
457	XtAddCallback(cancel, XtNcallback, CancelCb, (XtPointer)self);
458
459	/* Add the individual attribute widgets to
460	their pane. */
461	MapAttrTagsCreate(self, pane);
462	}
463
464	/* Destroy the widget tree and free the internal data (not the map!). */
465	void MapAttrDestroy(MapAttr self)
466	{
467	XtDestroyWidget(self->shell);
468	XtFree((char*)self->tags);
469
470	/* Clear the one pointer to self. */
471	assert(self->client->mapattr == self);
472	self->client->mapattr = NULL;
473
474	XtFree((char*)self);
475	}
476
477	/* Set self's widgets to reflect the state of the given map.
478	The new map is the one subsequent changes will be written to
479	(with MapAttrApply()).
480
481	This is sort of MapAttrApply()'s reverse. */
482	void MapAttrChange(MapAttr self, mapstruct * map) {
483	int i;
484	char buf[BUFSIZ];
485
486	self->map = map;
487
488	/* Give the name and msg boxes their new values. */
489	XtVaSetValues(self->iw.name, XtNstring, self->map->name, NULL);
490	XtVaSetValues(self->iw.msg, XtNstring, self->map->msg, NULL);
491
492	/* For each attribute, */
493	for (i = 0; i < NUM_ATTRS; i++) {
494	/* fetch the value from the map,
495	and give it to the matching widget. */
496
497	const MapAttrDef *which = &MapDescription[i];
498	which->getValue(map, buf);
499	if (which->type == MATypeString) {
500	XtVaSetValues(self->tags[i],
501	XtNstring, buf,
502	NULL);
503
504	/* Put the cursor at the end of the line. */
505	XtVaSetValues(self->tags[i],
506	XtNinsertPosition, strlen(buf),
507	NULL);
508	} else if (which->type == MATypeToggle) {
509	XtVaSetValues(self->tags[i],
510	XtNstate, *buf ? TRUE : FALSE,
511	NULL);
512	}
513	}
514
515	snprintf(buf, sizeof(buf), "Map: %s", self->map->name);
516	XtVaSetValues(self->shell,
517	XtNtitle, buf,
518	XtNiconName, buf,
519	NULL);
520	}
521
522	MapAttr MapAttrCreate(mapstruct * map, App app, Edit client)
523	{
524	MapAttr self = (MapAttr)XtMalloc(sizeof(struct _MapAttr));
525	self->map = map;
526	self->app = client->app;
527	self->client = client;
528
529	/* Build the widgets, */
530	MapAttrLayout(self, self->app->shell);
531
532	/* fill them with data, */
533	MapAttrChange(self, map);
534
535	/* and display the window. */
536	XtPopup(self->shell, XtGrabNone);
537
538	return self;
539	}