server/crossedit/Edit.c

/*
 *  CrossEdit - game world editor
 *  Copyright (C) 1993 Jarkko Sonninen & Petri Heinila
 *
 *  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 to Jarkko.Sonninen@lut.fi
 *  or Petri.Heinila@lut.fi .
 */

#include "Defines.h"
#include "Edit.h"

#include "X11.h"
#include "Ansi.h"

#include "debug.h"

#include "CrList.h"
#include "CrEdit.h"

#include "Cnv.h"
/* HACK Make sure we know how big CnvPromptMax is. */
#include "Cnv/config.h"
#include "App.h"
#include "Attr.h"
#include "MapAttr.h"
#include "Str.h"
#include "Bitmaps.h"


/*
 * This function relinks all _pointers_ to the objects from
 * one map to another.
 * Note: You can _not_ free the objects in the original map
 * after this function has been called.
 * (What happened to this function? It no longer copies the pointers! -Frank)
 * moved to Edit.c from common/map.c since Edit.c is the only file that uses it.
 */

void copy_map(mapstruct *m1, mapstruct *m2) {
    int x,y;

    memcpy(m2, m1, sizeof(mapstruct));

    for(x=0;x<MAP_WIDTH(m1)&&x<MAP_WIDTH(m2);x++)
        for(y=0;y<MAP_HEIGHT(m1)&&y<MAP_HEIGHT(m2);y++) {
            SET_MAP_FACE(m2,x,y,GET_MAP_FACE(m1,x,y,0),0);
            SET_MAP_FACE(m2,x,y,GET_MAP_FACE(m1,x,y,1),1);
            SET_MAP_FACE(m2,x,y,GET_MAP_FACE(m1,x,y,2),2);
        }
}

/*
 * member: copy by translate objects from source to a new map
 * source: -map
 * width : width of target map
 * height: height of target map
 * dx    : positive translate to right
 * dy    : positive translate to down
 */
mapstruct *MapMoveScrollResize(mapstruct *source, 
                                int width, int height, int dx, int dy) 
{
    mapstruct *target;
    object *obj,*prt; /* PaRT of obj */
    int x,y,sx = MAP_WIDTH(source), sy = MAP_HEIGHT(source);
    int linked = 0, link=0;
    int i;

    if (!width) width = sx;
    if (!height) height = sy;
    target = get_empty_map (width, height);

    if(dx < 0) dx += MAP_WIDTH(target);
    if(dy < 0) dy += MAP_HEIGHT(target);

    /*
     * Copy the map-headers from source to target.
     *
     * The name, msg and tiling paths are allocated for
     * each map (see map.c::load_map_header()). Copy
     * the pointer, then NULL the pointer in source so
     * the strings aren't freed.
     *
     * Statements below in the order the fields appear
     * in map.h.
     */

#define MOVE_AND_CLEAR(to, from) to = from; from = NULL;
    strncpy (target->path, source->path, HUGE_BUF - 1);
    target->path[HUGE_BUF - 1] = '\0';    
    MOVE_AND_CLEAR(target->tmpname, source->tmpname);    
    MOVE_AND_CLEAR(target->name, source->name);    
    target->region = source->region;
    MAP_WHEN_RESET(target) = MAP_WHEN_RESET(source);
    MAP_RESET_TIMEOUT(target) = MAP_RESET_TIMEOUT(source);
    target->fixed_resettime = source->fixed_resettime;
    target->unique = source->unique;
    MAP_NOSMOOTH(target) = MAP_NOSMOOTH(source);
    MAP_TIMEOUT(target) = MAP_TIMEOUT(source);
    MAP_SWAP_TIME(target) = MAP_SWAP_TIME(source);
    /* fields players/in_memory not copied */
    target->compressed = source->compressed;
    MAP_DIFFICULTY(target) = MAP_DIFFICULTY(source);    
    MAP_DARKNESS(target) = MAP_DARKNESS(source);
    MAP_WIDTH(target) = width;
    MAP_HEIGHT(target) = height;  
    MAP_ENTER_X(target) = (MAP_ENTER_X(source) + dx) % width;
    MAP_ENTER_Y(target) = (MAP_ENTER_Y(source) + dy) % height;
    target->outdoor = MAP_OUTDOORS(source);     
    MAP_TEMP(target) = MAP_TEMP(source);
    MAP_PRESSURE(target) = MAP_PRESSURE(source);
    MAP_HUMID(target) = MAP_HUMID(source);
    MAP_WINDSPEED(target) = MAP_WINDSPEED(source);
    MAP_WINDDIRECTION(target) = MAP_WINDDIRECTION(source);
    MAP_SKYCOND(target) = MAP_SKYCOND(source);
    /* fields wpartx/wparty not copied */
    MOVE_AND_CLEAR(target->msg, source->msg)
    /* Tiling paths. */
    for (i = 0; i < 4; i++) { 
        MOVE_AND_CLEAR(target->tile_path[i], source->tile_path[i]);
    }    
#undef MOVE_AND_CLEAR    

    for(y=0; y < sy && y < MAP_HEIGHT(target); y++)
        for(x=0; x < sx && x < MAP_WIDTH(target); x++)
            while((obj = get_map_ob(source,x,y)) && !obj->head) {
                if ((linked = QUERY_FLAG (obj,FLAG_IS_LINKED))) {
                    link = get_button_value (obj);
                    remove_button_link (obj);
                }
                remove_ob(obj);
                for(prt = obj; prt; prt = prt->more) {
                    prt->x += dx;
                    prt->x %= MAP_WIDTH(target); /* it can be split by edge */
                    prt->y += dy;           /* designers problem to fix */
                    prt->y %= MAP_HEIGHT(target);
                }
                insert_ob_in_map(obj,target,obj,INS_NO_MERGE | INS_NO_WALK_ON);
                if (linked)
                    add_button_link(obj, target, link);
            }
    /*free_all_objects(source);*/
    free_map (source, 1);
    delete_map (source);
    return target;
}


object * MapGetRealObject (mapstruct * emap, int x, int y, int z)
{
    object *tmp = MapGetObjectZ (emap, x, y, z);
    return tmp ? (tmp->head ? tmp->head : tmp) : tmp;
}

int MapInsertObjectZ(mapstruct *emap,object *o,int x, int y, int z)
{
    object *op, *above, *below;

    if (o->more)
        MapInsertObjectZ (emap,o->more, x, y, z);

    o->x += x;
    o->y += y;
    o->map = emap;
    CLEAR_FLAG(o,FLAG_REMOVED);

    op = get_map_ob (emap, o->x, o->y);
    if (z < 0) {
        above = op;
        below = NULL;
    } else {
        while (op && op->above)
            op = op->above;
    
        above = NULL;
        below = op;
        while (op && z-- > 0) {
            above = op;
            below = op = op->below;
        }
    }
    o->below = below;
    o->above = above;

    if (above)
        above->below = o;
    else {
        SET_MAP_FACE (emap, o->x, o->y, o->face,0);
    }
    if (below)
        below->above = o;
    else
        set_map_ob (emap, o->x, o->y, o);
    
    return (0);
}

int MapObjectOut (mapstruct *target, object *obj, int x, int y) {
    object *tmp;
    for(tmp = obj; tmp; tmp = tmp->more)
        if(OUT_OF_REAL_MAP(target,x + tmp->x,y + tmp->y)) return 1;
    return 0;
}

object * MapGetObjectZ (mapstruct * emap, int x, int y, int z)
{
    object *op;

    if (!emap || out_of_map (emap, x, y))
        return (NULL);
    op = get_map_ob (emap, x, y);
    while (op && op->above)
        op = op->above;
    while (op && z-- > 0)
        op = op->below;
    return (op);
}


/**********************************************************************
 * inner declarations
 **********************************************************************/

/*
static void CbEditSetPath (Widget w, XtPointer client, XtPointer call);
static void EditRefreshCb (Widget w, XtPointer client, XtPointer call);
static void CbEditStart (Widget w, XtPointer client, XtPointer call);

static void CbEditToggleRead (Widget w, XtPointer client, XtPointer call);
static void CbEditToggleOver (Widget w, XtPointer client, XtPointer call);
static void CbEditToggleAuto (Widget w, XtPointer client, XtPointer call);
 */
/*
static Boolean EdFreeMap ( Edit *);
static Boolean Load ( Edit *, char *name );
static int EdSelectItem ( Edit *, int x, int y );
*/
static Boolean EdSaveMap (Edit self, char *name);
/*
static void EditResizeScroll(Edit self,int width,int height,int dx,int dy);
*/
static void EditInsertArch (Edit self, int x, int y, int i, archetype * at);

object *EditCloneInsert (Edit self,object *obj,int x, int y, int z);
Boolean EditObjectDelete (Edit self, int x, int y, int z);

/*
 * to all refresh  
 */
const XRectangle EditRectAll = {
    0,0,
    10000,10000
};

/**********************************************************************
 * privates
 **********************************************************************/


/*
 *
 */
static Boolean EdFreeMap (Edit self)
{
    if (!self) return False;
    
    /*** no item from self map anymore ***/
    if (AppItemGetEdit(self->app) == self) {
        AppItemSet (self->app, NULL,NULL,0);
    }
    if(self->app->look.edit == self)
        AppSelectUnset(self->app);
    if (self->emap) {
        *self->emap->path = '\0';
        free_map (self->emap, 1);
        delete_map (self->emap);
        self->emap = NULL;
    }
    return True;
}

/*
 * member   : load map from file to memory
 *            there should no other map loading function for editor
 *            than self
 * name     : filename of map, relative ( level number )  
 * return   : True, if map is loaded
 */
static Boolean Load(Edit self, char *name)
{
    int mask;
    mapstruct *tmp;
    char path[PATH_MAX+1],save[PATH_MAX+1];
    char buf[BUFSIZ];
    
    strcpy(path, name);
    if((mask = check_path (path,1)) < 4) {
        sprintf(buf,"You can't access %s",path);
        CnvNotify(buf,"Continue",NULL);
        return False;
    }

    /* new map, no refs */
    if(self->app->look.edit == self) {
        AppSelectUnset(self->app);
        AttrChange(self->app->attr,NULL, 0, 0);
    }
    /*** remove old mapstructure ***/
    if(self->emap)
        strcpy(save,self->emap->path); /* klydge */
    EdFreeMap (self);
    if(!(tmp = ready_map_name (path, MAP_FLUSH))) {
        /* Make the map null, since right now we don't have a valid map
         * in memory.  The CnfNotify call will force a redraw - we
         * can check for Null map data pretty easy, but can't really check
         * for unknown map data.
         */
        if (self->w) /* only when already a window, open otherwhise coredump */
            XtVaSetValues(self->w, XtNmap, NULL, NULL);
        sprintf(buf,"Cannot load map %s",path);
        CnvNotify(buf,"Continue",NULL);
        if(!(tmp = ready_map_name(save,MAP_FLUSH))) return False;
    }

    /*** initialiaze map ***/
    debug1("Edit-Load() %s\n",path);
    if(self->view) XawViewportSetLocation(self->view,0,0);
    self->emap = tmp;
    self->read_only = mask & 2 ? 0 : 1;
    strcpy (self->emap->path, path);
    EditUnmodified(self);
    EditUpdate(self);
    CrEditRefresh(self->w,EditRectAll);
    return True;
}

/**********************************************************************
 * wall handling
 **********************************************************************/

static int direction_x[] = {0, -1, 0, 1};
static int direction_y[] = {1, 0, -1, 0};

/*
 *
 */
static int find_draw_arch (mapstruct * emap, int line, archetype * at)
{
    int i;
    object *tmp;

    for (i = 0; i < 16; i++)
        if ((tmp = get_map_ob (emap, i, line)) &&
          tmp->arch == at)
            return (i);
    return (-1);
}

static void EditInsertArch (Edit self, int x, int y, int i, archetype * at)
{
    Window w;
    mapstruct *emap;
    object *op,*tmp;
    int j = i;
    XRectangle rect;

    emap = self->emap;
    w = XtWindow(self->w);
    op = get_map_ob (emap, x, y);

    /* check for duplicate object */
    while (op && op->above)
        op = op->above;
    while (op && j-- > 0)
        op = op->below;
    if (op && op->arch == at)
        return;

    if (ob_blocked(&at->clone, self->emap, x, y) & P_OUT_OF_MAP) {
        debug("Out of Map\n");
        return;
    }
    op = object_create_arch (at);
    if (op) {
        MapInsertObjectZ(emap,op,x,y,i);
        /*debug3 ("Inserting %s %d %d\n", op->name, op->x, op->y);*/

        for (tmp = op; tmp; tmp = tmp->more) {
            if (self->app->look.rect.x == tmp->x && 
                self->app->look.rect.y == tmp->y)
                AppUpdate(self->app);
        }
        rect.x = x;
        rect.y = y;
        rect.width = rect.height = 1;
        CrEditRefresh(self->w,rect);
    } else {
        free_object (op);
        debug0 ("Inserting failed\n");
    }

    return;
}

/*
 * member: hmm
 */
static int update_wall (Edit self, int x, int y, int add, int rem)
{
    int i;
    object *tmp, *op;
    Window w;
    mapstruct * emap;
    
    emap = self->emap;
    w = XtWindow(self->w);

    if (out_of_map (emap, x, y) || !(op = get_map_ob (emap, x, y)))
        return False;

    while (op->above)
        op = op->above;

    /*
    i = find_draw_arch (self->app->item.wall_map, 
                        self->app->item.wall_set, 
                        op->arch);
                        */
    i = find_draw_arch (AppItemGetMap(self->app), 
                        AppItemGetWall(self->app), 
                        op->arch);
    if (i >= 0) {
        /* debug4 ("%d | %d & ~%d = %d\n", i, add, rem, (i | add) & ~rem); */
        remove_ob (op);
        free_object (op);
        tmp = get_map_ob (AppItemGetMap(self->app), ((i | add) & ~rem),
          AppItemGetWall(self->app));
        if (tmp)
            EditInsertArch (self, x, y, 0, tmp->arch);
        return True;
    }
    return False;
}

/*
 *
 */
static void draw_add (Edit self, int x, int y)
{
    int i, mask = 0;

    if (!self->app->item.wall_map)
        CnvDie(self->shell,"No Wall map");

    if (MAP_WIDTH(self->app->item.wall_map) < 16)
        CnvDie(self->shell,"Wall Map has wrong width\n");

    for (i = 0; i < 4; i++)
        if (update_wall (self, x + direction_x[i], y + direction_y[i], 
                         (1 << i), 0))
            mask |= (1 << (i ^ 2));

    update_wall (self, x, y, mask, 0);
}

/*
 *
 */
static void draw_remove (Edit self, int x, int y)
{
    if (!self->app->item.wall_map)
        CnvDie(self->shell,"No Wall map");

    if (MAP_WIDTH(self->app->item.wall_map) < 16)
        CnvDie(self->shell,"Wall Map has wrong width\n");

    update_wall (self, x, y + 1, 0, 1);
    update_wall (self, x - 1, y, 0, 2);
    update_wall (self, x, y - 1, 0, 4);
    update_wall (self, x + 1, y, 0, 8);
}


/*
 * member: resize and scroll mao of editor
 * width : new width, if zero, no resize
 * height: new height, if zero, no resize
 * dx    : amount to scroll, neg. to left, pos. to right
 * dy    : amount to scroll, neg, to up, pos. to down
 */
void EditResizeScroll(Edit self,int width,int height,int dx,int dy)
{
    mapstruct *tmp;
    char buf[BUFSIZ];

    if(!self || self->read_only) return;
    if(self->type != ClipBoard &&  
       (width < MapMinWidth || width > MapMaxWidth ||
        height < MapMinHeight || height > MapMaxHeight)) {
        sprintf(buf,"Map cannot be smaller than %dx%d",
                MapMinWidth,MapMinHeight);
        CnvNotify(buf,"Continue",NULL);
        return;
    }


    /*
     * SelectUnset before EdFreeMap, since, it tries to 
     *  do that, and there's no mapstuct at that moment 
     */
    if(self->app->look.edit == self)
        AppSelectUnset(self->app);
    
    tmp = MapMoveScrollResize(self->emap, width, height, dx, dy);
    self->emap = NULL; /* MapMoveScrollResize destroys the old map */
    EdFreeMap(self);
    self->emap = tmp;
    EditModified(self);
    EditUpdate(self);

    CrEditRefresh(self->w,EditRectAll);

    debug5("EditResizeScroll() %s %dx%d+%d+%d\n",
           EditGetPath(self),width,height,dx,dy);
}

/**********************************************************************
 * File-menu callbacks
 **********************************************************************/

/*
 * callback: save current map, ask name if not given
 */
static void SaveCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    EditSave(self);
}

/*
 * callback: save map as name
 */
static void SaveAsCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    char path[PATH_MAX];

    if(CnvPathSelect(self->app->path) == CnvPathCancel) return;
    sprintf(path,"%s/%s",
            self->app->path->current,
            self->app->path->filename);
    EdSaveMap(self,path);
}

/*
 * callback: load current map again
 */
static void ClearCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    Map tmp;

    debug1("ClearCb() %s\n",self->emap->path);
    if(self->read_only) return;
    tmp = get_empty_map(MAP_WIDTH(self->emap), MAP_HEIGHT(self->emap));
    copy_map (self->emap, tmp); 
    EdFreeMap(self);
    self->emap = tmp;
    EditUnmodified(self);
    EditUpdate(self);
}

/*
 * callback: load new map
 */
static void LoadCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    char path[PATH_MAX+1],buf[BUFSIZ];

    /*** save, if modified ***/
    if (self->modified) {
        switch (CnvNotify ("Map modified, save",
                           "OK","Cancel","No",NULL)) {
          case 1:
            EditSave(self);
            break;
          case 2:
            return; 
          default:
            break;
        }
    }
    /*** load map ***/
    if(CnvPathSelect(self->app->path) == CnvPathCancel) return;
    sprintf(path,"%s/%s",self->app->path->current,self->app->path->filename);
    /*** check out if map can load ***/
    if (has_been_loaded (path)) {
      sprintf(buf,"%s already in memory",path);
      CnvNotify(buf,"Continue",NULL);
      return;
    }
    Load(self,path);
}

/*
 * callback: load current map again
 */
static void ReloadCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    debug1("ReloadCb() %s\n",self->emap->path);
    Load(self,self->emap->path);
}

/* 
 * callback: enter to map in Look window 
 */
static void EnterCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    object *obj = NULL, *tmp;
    char buf[BUFSIZ];
    char loadPath[PATH_MAX+1];
    const char *path;
    XRectangle rect;
    
    /*** find object ***/
    if(self->app->look.edit)
        obj = MapGetObjectZ
            (self->app->look.edit->emap,
             self->app->look.rect.x,
             self->app->look.rect.y,0);
    if (!obj || !self->app->look.edit) {
        CnvNotify("Select exit to enter","Continue",NULL);
        return;
    }
    /*** foreach object in list, if exit load it ***/
    tmp = obj;
    do {
        obj = tmp->head ? tmp->head : tmp;
        if (obj->type == PLAYER_CHANGER || obj->type == TELEPORTER || obj->type==EXIT) {
            /*** check out if exit leads ***/
            if(!EXIT_PATH(obj)) {
                CnvNotify("Exit leads nowhere",
                          "OK",NULL);
                return;
            }
            path = EXIT_PATH(obj);
            rect.x = EXIT_X(obj);
            rect.y = EXIT_Y(obj);
            /*** save current map if modified ***/
            if (self->modified) {
                switch (CnvNotify ("Map modified, save",
                                   "Save","Cancel","Forget",NULL)) {
                  case 1:
                    EditSave(self);
                    break;
                  case 2:
                    return;
                  default:
                    break;
                }
            }
            /*** load & update ***/
            StrPathCd(strcpy(loadPath,EditGetPath(self)),path);
            debug1("EnterCb() %s\n",loadPath);

            /*** check out if map can load ***/
            if (has_been_loaded (loadPath)) {
                sprintf(buf,"%s already in memory",loadPath);
                CnvNotify(buf,"Continue",NULL);
                return;
            }
            if(!Load(self,loadPath)) return;
            if (rect.x == 0 && rect.y == 0) {
                rect.x = MAP_ENTER_X(self->emap);
                rect.y = MAP_ENTER_Y(self->emap);
            }
            rect.width = rect.height = 0;
            AppSelectSet(self->app, self, rect);
            CrEditSelect(self->w, rect);
            return;
        }
        tmp = tmp->below;
    } while(tmp);
    CnvNotify("That's not exit","Continue",NULL);
}

/*
 * callback: reset this map from crossfire 
 */
static void ResetCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    char cmd[ARG_MAX+1],buf[MAX_INPUT+1];

    debug0("ResetCb()\n");
    if(!self->app->res.cmdReset) {
        CnvNotify("no defined *cmdReset:","Continue",NULL);
        return;
    }
    sprintf(cmd,self->app->res.cmdReset,EditGetPath(self));
    if(system(cmd)) {
        sprintf(buf,"Command failed \"%s\"",cmd);
        CnvNotify(buf,"Continue",NULL);
    }
}

/*
 * callback: quit map editor
 */
static void CloseCb (Widget w, XtPointer client, XtPointer call)
{
    char buf[BUFSIZ];
    Edit self = (Edit) client;
    if (EditIsModified(self)) {
        sprintf (buf, "Quitting, save %s ?", self->emap->path);
        switch (CnvNotify (buf,"Save","Cancel", "Forget",NULL)) {
          case 1:               /* ok */
            EditSave(self);
            break;
          case 2:
            return;
          default:
            EditUnmodified(self); /* to fool EditDestroy */
            break;
        }
    }
    EditDestroy(self);
}

static CnvMenuRec fileMenu[] = {
    {"save",   SaveCb},
    {"saveAs", SaveAsCb},
    {"----",   NULL},
    {"load",   LoadCb},
    {"reload", ReloadCb},
    {"----",   NULL},
    {"clear",  ClearCb},
    {"reset",  ResetCb},
    {"----",   NULL},
    {"enter",  EnterCb},
    {"----",   NULL},
    {"close",  CloseCb},
    {"",       NULL },
};

/**********************************************************************
 * Auto Creating stuff
 **********************************************************************/

static char * MapMessageCreate (App self) {
    char buf[MAX_BUF];
    time_t t = time(NULL);
    sprintf (buf, "Creator: %s\nEmail: %s\nDate: %s",
             self->res.creator,self->res.email, ctime (&t));
    return strdup_local (buf);
}

#if 0
static char * MapNameCreate (String path)
{
    char name[PATH_MAX+1];
    int i,j;

    strncpy(name,path,PATH_MAX);
    name[PATH_MAX] = '\0';
    for(i = strlen(name)-1; i && name[i] != '/';i--);
    i++;
    for(j = i; name[j] && name[j] != '.';j++);
    if(name[j] == '.') name[j] = 0;
    return strdup_local (&name[i]);
}
#endif
/**********************************************************************
 * Options - menu
 **********************************************************************/


#if 0
/*
 * callback: set new path of map
 */
static void SetPathCb (Widget w, XtPointer client, XtPointer call)
{
    char path[CnvPromptMax+1];
    Edit self = (Edit) client;
    
    switch (CnvPrompt ("Set path", self->emap->path, path, 
                       "OK","Cancel",NULL)) {
    case 1:
        EditSetPath(self,path);
    default:
        break;
    }
}

/*
 * callback: resize and scroll map
 */
static void ResizeCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    char buf[1025], path[CnvPromptMax+1];
    unsigned x, y;
    int sx = 0, sy = 0, res;

    if (self->read_only)
        return;

    sprintf (buf, "%dx%d+0+0", 
             MAP_WIDTH(self->emap), MAP_HEIGHT(self->emap));
    switch (CnvPrompt ("ResizeScroll",
                       buf, path,"OK",NULL)) {
    case 1:
        res = XParseGeometry (path, &sx, &sy, &x, &y);
        
        if (!(res & WidthValue))
            x = MAP_WIDTH(self->emap);
        if (!(res & HeightValue))
            y = MAP_HEIGHT(self->emap);
        
        if (!(res & XValue))
            sx = 0;
        if (!(res & YValue))
            sy = 0;

        if (x < 3 || y < 3 || x > 100 || y > 100) {
            CnvNotify ("Illegal size","OK",NULL);
            return;
        }
        EditResizeScroll (self, x,y,sx, sy);
        break;
    default:
        return;
    }
}

/*
 * callback: set start point
 */
static void StartCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit) client;
    char buf[BUFSIZ], reply[CnvPromptMax+1];
    int x, y, flags;
    int width, height;

    sprintf (buf, "%dx%d", 
             MAP_ENTER_X(self->emap),
             MAP_ENTER_Y(self->emap));
    switch (CnvPrompt ("Start of map", buf,reply,
        "OK","Cancel",NULL)) {
    case 1:                     /* ok */
        flags = XParseGeometry (reply, &x, &y, &width, &height);
        if ((flags != (WidthValue | HeightValue))) {
            CnvNotify ( "Illegal value","Ok",NULL);
            return;
        }
        if (out_of_map(self->emap,width,height)) {
            sprintf (buf, "Point  %dx%d out of map", width, height);
            CnvNotify (buf,"OK",NULL);
            return;
        } else {
            MAP_ENTER_X(self->emap) = width;
            MAP_ENTER_Y(self->emap) = height;
            EditModified(self);
        }
        EditUpdate(self);
        return;
    default:
        return;
    }
}
#endif


/*
 * Edit attributes of the Map
 */
static void AttributesCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit)client;
        
    debug0("Edit::AttributesCb()\n");

    if (self->mapattr == NULL) {
        self->mapattr = MapAttrCreate(self->emap, self->app, self);
    } else {
        MapAttrDestroy(self->mapattr);
    }
}

/* 
 * callback: refresh map
 */
static void RefreshCb (Widget w, XtPointer client, XtPointer call)
{  
  Edit self = (Edit)client;
  CrEditRefresh(self->w,EditRectAll);
  EditUpdate(self);
}

#if 0
/* 
 * callback: toggle write accces 
 */
static void ToggleReadCb (Widget w, XtPointer client, XtPointer call)
{
  Edit self = (Edit)client;

  if(self->type == Pick ||
     self->type == Wall) return;
  ((Edit) client)->read_only++;
  EditUpdate(self);
  debug ("CbEditToggleRead()\n");
}
#endif

/* 
 * callback: Toggle overwrite mode 
 */
static void ToggleOverCb (Widget w, XtPointer client, XtPointer call)
{
  Edit self = (Edit)client;

  if(self->type == Pick ||
     self->type == Wall) return;
  ((Edit) client)->overwrite++;
  EditUpdate(self);
  debug ("CbEditToggleOver()\n");
}

/* 
 * callback: Toggle auto choose 
 */
static void ToggleAutoCb (Widget w, XtPointer client, XtPointer call)
{
  Edit self = (Edit)client;

  if(self->type == Pick ||
     self->type == Wall) return;
  ((Edit) client)->auto_choose++;
  EditUpdate(self);
  debug ("CbEditToggleAuto()\n");
}

/* 
 * callback: Toggle showing weak walls
 */
static void ToggleWeakCb (Widget w, XtPointer client, XtPointer call)
{
    Edit self = (Edit)client;
    Cardinal weak_walls;
  
    XtVaGetValues(self->w, XtNshow_weak_walls, &weak_walls, NULL);
    XtVaSetValues(self->w, XtNshow_weak_walls, !weak_walls, NULL);

    EditUpdate(self);
    debug("CbEditToggleWeak()\n");
}

/*
 * callback: Adjust stacking size
 */
static void SetStackingCb(Widget w, XtPointer client, XtPointer call)
{
    char buf[MAX_BUF];
    char retbuf[CnvPromptMax+1];
    Edit self = (Edit)client;
    Cardinal stacking;
    int ret;
    
    XtVaGetValues(self->w, XtNstacking, &stacking, NULL);
    
    snprintf(buf, sizeof(buf), "%d", stacking);
    
    ret = CnvPrompt("Set stacking (0 = off)", buf, retbuf, "OK", "Cancel", NULL);
        
    if (ret != 1)
        return;
    
    stacking = atoi(retbuf);
    
    debug2("SetStackingCb %s %d\n", retbuf, stacking);

    /* TODO How did they come up with this magic number? */
    if (stacking > 48) {
        CnvNotify("Illegal space", "Ok", NULL);
        return;
    }
    XtVaSetValues(self->w, XtNstacking, stacking, NULL);

    EditUpdate(self);
} 

static Widget OptionMenu(String name,Edit self,Widget parent)
{
    Widget shell,refresh, use;

    shell = XtVaCreatePopupShell 
      (name, simpleMenuWidgetClass, parent, NULL);

    use = XtVaCreateManagedWidget
        ("attributes",smeBSBObjectClass, shell,
         NULL);
    XtAddCallback(use,XtNcallback,AttributesCb,(XtPointer)self);

    /*** refresh ***/
    XtVaCreateManagedWidget ("line", smeLineObjectClass, shell, NULL);
    refresh = XtVaCreateManagedWidget
        ("refresh",smeBSBObjectClass,shell,
         NULL);
    XtAddCallback
        (refresh,XtNcallback,RefreshCb,(XtPointer)self);
    /*** toggles ***/
    XtVaCreateManagedWidget ("line", smeLineObjectClass, shell, NULL);
    self->iw.overwrite = XtVaCreateManagedWidget 
        ("overWrite", smeBSBObjectClass, shell, NULL);
    XtAddCallback (self->iw.overwrite,
                   XtNcallback,ToggleOverCb, (XtPointer) self);
    self->iw.auto_choose = XtVaCreateManagedWidget 
        ("autoChoose", smeBSBObjectClass, shell, NULL);
    XtAddCallback (self->iw.auto_choose,
                   XtNcallback,ToggleAutoCb, (XtPointer) self);
    self->iw.weak_walls = XtVaCreateManagedWidget 
        ("weakWalls", smeBSBObjectClass, shell, NULL);
    XtAddCallback (self->iw.weak_walls,
                   XtNcallback,ToggleWeakCb, (XtPointer) self);
    self->iw.stacking = XtVaCreateManagedWidget 
        ("sparse", smeBSBObjectClass, shell, NULL);
    XtAddCallback (self->iw.stacking,
                   XtNcallback,SetStackingCb, (XtPointer) self);

    return shell;
}

/**********************************************************************
 * edit routines - CrEdit callbacks
 *   insert
 *   select
 *   delete
 *   align
 *   feed
 **********************************************************************/

static void InsertCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    AppSelectUnset(self->app);
    EditInsert(self,call->rect.x,call->rect.y,call->z);
}

static void SelectCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    if(self->auto_choose) {
        if(self->type == Wall && call->rect.x == 0) {
            AppItemSet(self->app,self,NULL,call->rect.y);
        } else {
            object *obj;
            obj = MapGetRealObject(self->emap,call->rect.x,call->rect.y,0);
            AppItemSet(self->app,self,obj,AppItemNoWall);
        }
    } else {
        AppSelectSet(self->app,self,call->rect);
    }
}

static void PropsCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    debug0 ("PropsCb()\n");
    if(!self->auto_choose) {
        object *ob = MapGetRealObject
            (self->emap, call->rect.x, call->rect.y, call->z);
        if(!self->app->attr) {
            self->app->attr = AttrCreate 
                ("attr", self->app, ob, AttrDescription, GetType(ob), self);
        } else {
            AttrChange (self->app->attr,ob, GetType(ob), self);
        }
    }
    return;
}

static void DeleteCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    AppSelectUnset(self->app);
    EditDelete(self,call->rect.x,call->rect.y,call->z);
}

static void AlignCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    debug4("Edit::AlignCb() by %dx%d+%d+%d\n",call->rect.width,
           call->rect.height,call->rect.x,call->rect.y);
    EditResizeScroll(self,call->rect.width,
                     call->rect.height,call->rect.x,call->rect.y);
}

static void FeedCb(Widget w,XtPointer clientData,XtPointer callData)
{
    Edit self = (Edit)clientData;
    CrEditCall call = (CrEditCall)callData;
    char buf[BUFSIZ],*str;
    
    debug("FeedCb()\n");
    /*** path, modified for game, not clean thing  ***/
    str = buf;
    if (!self->app->attr || !self->app->attr->op)
        return;
    if(!strcmp(self->app->attr->op->map->path,call->map->path)) {
        StrBasename(buf,self->app->attr->op->map->path);
    } else {
        strcpy(buf,self->app->attr->op->map->path);
        StrPathGenCd(buf,call->map->path);
        if(strlen(buf) > 2) str = &buf[2];
    }
    XtVaSetValues (self->app->attr->tags[I_Path].value, 
                   XtNstring, str, 
                   NULL);
    /*** x ***/
    sprintf (buf, "%d", call->rect.x);
    XtVaSetValues (self->app->attr->tags[I_X].value,
                   XtNstring, buf, 
                   NULL);
    /*** y ***/
    sprintf (buf, "%d", call->rect.y);
    XtVaSetValues (self->app->attr->tags[I_Y].value,
                   XtNstring, buf, 
                   NULL);
}

/**********************************************************************
 * layout
 **********************************************************************/

static void Layout(Edit self,Widget parent,Cardinal stacking)
{
    Widget vbox, hbox,use;
    Widget editMenu, optionMenu;

    /*** shell ***/
    self->shell = XtVaCreatePopupShell 
      ("edit",topLevelShellWidgetClass, self->app->shell,
       XtNwidth,
       (MAP_WIDTH(self->emap) > self->app->res.mapWidth ?
        self->app->res.mapWidth * FontSize :
        MAP_WIDTH(self->emap) * FontSize ) + 16,/* kludge */
       XtNheight,
       (MAP_HEIGHT(self->emap) > self->app->res.mapHeight ?
        self->app->res.mapHeight * FontSize :
        MAP_HEIGHT(self->emap) * FontSize ) + 46,/* kludge */
       XtNiconPixmap,bitmaps.edit,
       NULL);
    vbox = XtVaCreateManagedWidget ("vbox", panedWidgetClass,
      self->shell, NULL);

    /*** menu bar ***/
    hbox = XtVaCreateManagedWidget ("hbox", boxWidgetClass,
      vbox, NULL);
    
    if(self->type != ClipBoard) {
        use = XtVaCreateManagedWidget 
            ("mapFileButton", menuButtonWidgetClass, hbox,
             XtNmenuName,"fileMenu",
             NULL);
        CnvMenu("fileMenu",use,fileMenu,(XtPointer)self);

        editMenu = XtVaCreateManagedWidget 
            ("mapEditButton", menuButtonWidgetClass, hbox,
             XtNmenuName,"mapEdit",
             NULL);

        optionMenu = XtVaCreateManagedWidget 
            ("mapOptionButton", menuButtonWidgetClass, hbox,
             XtNmenuName,"optionMenu",
             NULL);
        OptionMenu("optionMenu",self,optionMenu);
    }


    /*** editor-widget ***/
    self->view = XtVaCreateManagedWidget 
        ("veivi",viewportWidgetClass, vbox, 
         XtNallowResize,True,
         XtNforceBars,True,
         XtNallowHoriz,True,
         XtNallowVert,True,
         NULL);
    self->w = XtVaCreateManagedWidget 
        ("cross",crEditWidgetClass,self->view,
         XtNresizable,True,
         XtNmap,self->emap,
         XtNstacking,stacking,
         XtNselectArea,True,
         NULL);
    XtAddCallback(self->w,XtNinsertCallback,InsertCb,(XtPointer)self);
    XtAddCallback(self->w,XtNselectCallback,SelectCb,(XtPointer)self);
    XtAddCallback(self->w,XtNpropsCallback,PropsCb,(XtPointer)self);
    XtAddCallback(self->w,XtNdeleteCallback,DeleteCb,(XtPointer)self);
    XtAddCallback(self->w,XtNalignCallback,AlignCb,(XtPointer)self);
    XtAddCallback(self->w,XtNfeedCallback,FeedCb,(XtPointer)self);
}

/**********************************************************************
 * public
 **********************************************************************/

/*
 * create editing window for map for crossfire-abs-path file-name
 */
Edit EditCreate(App app,EditType type,String path)
{
    Edit self;

    /*** initialising ***/
    self = (Edit)XtMalloc(sizeof(struct _Edit));
    self->app = app;
    self->shell = NULL;
    self->w = NULL;
    self->view = NULL;
    self->next = NULL;
    self->emap = NULL;
    self->type = type;
    self->overwrite = 0;
    self->mapattr = NULL;
    self->modified = False;

    /*** load or create map ***/
    if (type == ClipBoard) {
        if (!self->emap)
            self->emap = get_empty_map(MapMinWidth,MapMinHeight);
        strcpy (self->emap->path, "/ClipBoard");

        if (!self->emap->msg) {
            self->emap->msg = MapMessageCreate (app);
        }
    } else if(path && *path != '\0') {
        if (!Load(self,path)) return 0;
    } else {
        self->emap = get_empty_map(16,16);
        strcpy (self->emap->path, "/Noname");

        if (!self->emap->msg) {
            self->emap->msg = MapMessageCreate (app);
        }
    }
    
    if (!self->emap)
        return 0;
    
    /*** creating ***/
    Layout(self,self->app->shell,0);
    EditUnmodified(self);

    /*** type specific ***/
    switch (self->type) {
    case Regular:
        self->read_only = 0;
        self->auto_choose = 0;
        break;
    case Pick:
    case Wall:
        self->read_only = 1;
        self->auto_choose = 1;
        XtVaSetValues(self->w,
                      XtNstacking,1,
                      XtNselectArea,False,
                      NULL);
        break;
    case ClipBoard:
        self->read_only = 0;
        self->auto_choose = 0;
        break;
    default:
        fprintf(stderr,"unknown MapType");
        exit(EXIT_FAILURE);
    }
    EditUpdate(self);
    /*** show-map-editor ***/
    if(type != ClipBoard)
        XtPopup (self->shell, XtGrabNone);

    return self;
}

/*
 * member: destroy edit
 */
void EditDestroy(Edit self)
{
    char buf[BUFSIZ];
    
    if(!self) return;
    debug1 ("EditDestroy() %s\n",EditGetPath(self));
    
    /*** reply to save if designed ***/
    if (EditIsModified(self)) {
        sprintf (buf, "Quitting, save %s ?", self->emap->path);
        switch (CnvNotify (buf,"Save","Forget",NULL)) {
        case 1:         /* ok */
            EditSave(self);
            break;
        default:
            break;
        }
    }
    /*** outer coonections ***/
    if (self->mapattr) {
        MapAttrDestroy(self->mapattr);
    }
    if (self->app->attr && self->app->attr->op &&
        self->app->attr->op->map == self->emap) {
        AttrChange(self->app->attr, NULL, 0, (Edit)0);
    }
    if (AppItemGetEdit(self->app) == self) {
        AppItemSet (self->app, NULL,NULL,0);
    }
    AppUpdate(self->app);
    AppEditDeattach(self->app,self);
    EdFreeMap (self);

    /*** inner remove ***/
    XtDestroyWidget (self->shell);
    XtFree((char*)self);
}

/*
 * member: update Edit values
 */
void EditUpdate(Edit self)
{
    char buf[BUFSIZ];

    if(!(self && self->shell && self->emap)) return;

    /*** map title ***/
    snprintf(buf, sizeof(buf),
            "Edit %s %s",
            self->emap->path,
            self->modified ? "*" : "");
    XtVaSetValues(self->shell,
                  XtNtitle,buf,
                  XtNiconName,buf,
                  NULL);
    
    /*** info ***/
    if (self->mapattr != NULL)
        MapAttrChange(self->mapattr, self->emap);

    /*** toggles ***/
    if(self->type != ClipBoard) {
        Cardinal weak_walls;
        Cardinal stacking;
    
#if 0
        XtVaSetValues 
            (self->iw.read_only,
             XtNleftBitmap, self->read_only ? bitmaps.mark : None, NULL);
#endif
        XtVaSetValues 
            (self->iw.overwrite, 
             XtNleftBitmap, self->overwrite ? bitmaps.mark : None, NULL);
        XtVaSetValues 
            (self->iw.auto_choose, 
             XtNleftBitmap, self->auto_choose ? bitmaps.mark : None, 
             NULL);
        
        XtVaGetValues(self->w, XtNshow_weak_walls, &weak_walls, NULL);
        XtVaSetValues 
            (self->iw.weak_walls, 
             XtNleftBitmap, weak_walls ? bitmaps.mark : None, 
             NULL);

        XtVaGetValues(self->w, XtNstacking, &stacking, NULL);
        XtVaSetValues 
            (self->iw.stacking, 
             XtNleftBitmap, (stacking != 0) ? bitmaps.mark : None, 
             NULL);
    }
    /*** map area ***/
    if(self->emap && self->w)
        XtVaSetValues(self->w,XtNmap,self->emap,NULL);

    if (self->app->look.edit == self)
        CrEditRefresh (self->w, self->app->look.rect);
}

/*
 * member : save map from memory to file, there should be no other
 *            map saving routine than self
 * self   : pointer to current Edit structure
 * name   : filename of map, relative ( level number )  ???
 * return : True, map is saved
 */
static Boolean EdSaveMap (Edit self, char *name)
{
    mapstruct *m = self->emap;
    char buf[BUFSIZ];

    debug0 ("Saving Map by name\n");

    strcpy (m->path, name);

    /*** updating map name here ***/
    EditSetPath(self,name);
    if(new_save_map (m, 1)) {
        sprintf(buf,"Error in saving map %s",EditGetPath(self));
        CnvNotify ("Error in saving map !","OK",NULL);
        return False;
    }
    EditUnmodified(self);
    return True;
}

/*
 * member: save contents of map to file
 * return: status
 */
EditReturn EditSave(Edit self)
{
    char path[PATH_MAX+1];  

    if (self->read_only) {
        CnvNotify ( "Map is read-only!","OK",NULL);
        return EditOk;
    }
    if (!self->modified) {
        CnvNotify ( "No changes to save", "OK",NULL);
        return EditOk;
    }
    /*** if empty path, ask it ***/
    if (!*self->emap->path) {
        if(CnvPathSelect(self->app->path) == CnvPathCancel) return EditOk;
        sprintf(path,"%s/%s",self->app->path->current,
                self->app->path->filename);
        strcpy (self->emap->path, path);
    }
    if(!EdSaveMap(self,self->emap->path)) return EditOk;
    EditUpdate(self);
    return EditOk;
}

/*
 * member: load map from file
 * self   : pointer to current Edit structure
 * return : status
 */
EditReturn EditLoad(Edit self)
{
  if(Load(self, self->emap->path))
    return EditOk;
  else
    return EditError;
}

/*
 * member: make fill
 * x,y   : point to start fill
 */
void EditPerformFill(Edit self, int x, int y)
{
    int dx, dy;
    if (!self->emap) return;

    for (dx=x; dx< x+self->app->look.rect.width; dx++) {
        for (dy=y; dy < y+self->app->look.rect.height; dy++) {
            if (!OUT_OF_REAL_MAP (self->emap, dx, dy))
                EditInsert(self, dx, dy, 0);
        }
    }
}

/*
 * member: make fill
 * x,y   : point to start fill
 */
void EditPerformFillBelow(Edit self, int x, int y)
{
    int dx, dy;
    if (!self->emap) return;

    for (dx=x; dx< x+self->app->look.rect.width; dx++) {
        for (dy=y; dy < y+self->app->look.rect.height; dy++) {
            if (!OUT_OF_REAL_MAP (self->emap, dx, dy))
                EditInsert(self, dx, dy, -1);
        }
    }
}

/*
 * member: fill
 * x,y   : point to start fill
 */
void EditFillRectangle(Edit self, XRectangle rec)
{
    int x,y;

    if (!self->emap || self->read_only)
        return;

    for(x = 0; x < rec.width; x++)
        for(y = 0; y < rec.height; y++)
            EditInsert (self, x + rec.x, y + rec.y, 0);

    return;
}


/*
 * member: wipe
 * x,y   : point to start fill
 */
void EditWipeRectangle(Edit self, XRectangle rec)
{
    int x,y;

    if (!self || !self->emap || self->read_only)
        return;

    for(x=0; x < rec.width; x++)
        for(y=0; y < rec.height; y++)
            while(get_map_ob(self->emap,x + rec.x, y + rec.y))
                EditObjectDelete (self, x + rec.x, y + rec.y, 0);
    CrEditRefresh (self->w, rec);
    return;
}

/*
 * member: shave
 * x,y   : point to start fill
 */
void EditShaveRectangle(Edit self, XRectangle rec)
{
    int x,y;

    if (!self || !self->emap || self->read_only)
        return;

    for(x=0; x < rec.width; x++)
        for(y=0; y < rec.height; y++)
            EditObjectDelete (self, x + rec.x, y + rec.y, 0);

    CrEditRefresh (self->w, rec);
    return;
}

void EditShaveRectangleBelow(Edit self, XRectangle rec)
{
    int x,y;

    if (!self || !self->emap || self->read_only)
        return;

    for(x=0; x < rec.width; x++)
        for(y=0; y < rec.height; y++)
            EditObjectDelete (self, x + rec.x, y + rec.y, -1);

    CrEditRefresh (self->w, rec);
    return;
}

/*
 * member: copy rectangle area (x,y,width,height) from src to
 *         self to point (x,y)
 */
void EditCopyRectangle(Edit self,Edit src,XRectangle rect,int sx,int sy)
{
    int x, y, z;
    object *obj,*tmp;

    if(!self || 
       !src ||
       self->read_only)
        return;

    if (rect.width > MAP_WIDTH(self->emap) - sx)
        rect.width = MAP_WIDTH(self->emap) - sx;
    if (rect.width > MAP_WIDTH(src->emap))
        rect.width = MAP_WIDTH(src->emap);

    if (rect.height > MAP_HEIGHT(self->emap) - sy)
        rect.height = MAP_HEIGHT(self->emap);
    if (rect.height > MAP_HEIGHT(src->emap))
        rect.height = MAP_HEIGHT(src->emap);

    debug2("EditCopyRectangle() %s -> %s\n",EditGetPath(src),
          EditGetPath(self));
    if(self->overwrite) 
        for(x=0; x < rect.width; x++)
            for(y=0; y < rect.height; y++)
                EditDeletePoint(self,(sx+x),(sy+y));
                
    for(x=0; x < rect.width; x++)
        for(y=0; y < rect.height; y++) {
            obj = MapGetObjectZ(src->emap,(rect.x + x),(rect.y + y),0);
            for(tmp = obj,z=0; tmp; tmp = tmp->below,z++) {
                if(tmp->head) {continue;}
                /*EditObjectInsert(self,tmp,(sx+x),(sy+y),z);*/
                EditCloneInsert(self,tmp,(sx+x),(sy+y),z);
            }
        }
    rect.x = sx;
    rect.y = sy;
    CrEditRefresh (self->w, rect);
    EditModified(self);
}

/*
 *
 */
void EditDeletePoint(Edit self,int x,int y)
{
    while(get_map_ob(self->emap,x,y))
        EditDelete(self,x,y,0);
}

/*
 * Member: set Edit to modified state
 */
void EditModified(Edit self)
{
    if (self && !self->modified) {
      self->modified = True;
      EditUpdate(self);
    }
}

/*
 * member: set Edit to modified state
 */
void EditUnmodified(Edit self)
{
    if (self && self->modified) {
      self->modified = False;
      EditUpdate(self);
    }
}

static void EditObjectCalc(Edit self,object *obj,XRectangle *rect)
{
    object *tmp;

    rect->x = 10000;
    rect->y = 10000;
    rect->width = 0;
    rect->height = 0;
    for (tmp = obj; tmp; tmp = tmp->more) {
        if (self->app->look.rect.x == tmp->x && 
            self->app->look.rect.y == tmp->y)
            AppUpdate(self->app);
        if(tmp->x < rect->x) rect->x = tmp->x;
        if(tmp->y < rect->y) rect->y = tmp->y;
        if(tmp->x - rect->x + 1> rect->width) 
            rect->width = tmp->x - rect->x + 1;
        if(tmp->y - rect->y + 1> rect->height) 
            rect->height = tmp->y - rect->y + 1;
    }
}

/*
 * member: delete object from map of editor
 * x,y,z : delete object from self point
 * return: True, if object deleted
 */
Boolean EditDelete (Edit self, int x, int y, int z)
{
    object *obj;
    XRectangle rect;

    obj = MapGetObjectZ(self->emap, x, y, z);
    if (self->read_only || z < 0 || !obj)
      return False;
    if (obj->head)
        obj = obj->head;

    EditObjectCalc (self,obj,&rect);
    if (!EditObjectDelete (self, x, y, z))
      return False;
    CrEditRefresh (self->w,rect);

    if (self->app->item.wall_map)
        draw_remove (self, x, y);
    
    EditModified(self);
    return True;
}

/*
 * member: delete object from map of editor
 * x,y,z : delete object from self point
 * return: True, if object deleted
 */
Boolean EditObjectDelete (Edit self, int x, int y, int z)
{
    object *obj;

    obj = MapGetObjectZ(self->emap, x, y, z);
    if (self->read_only || !obj)
      return False;

    if (obj->head)
                obj = obj->head;

    if (z < 0) {
        if (obj->below)
            obj = obj->below;
        else
            return False;
    }
    /* This is just plain wrong 
    **                    -- deletes object above the selected object!
    ** if (z > 0)
    **    obj = obj->above;
    */
    if (self->app->attr && self->app->attr->op == obj)
        AttrChange(self->app->attr, NULL, 0, 0);
    if (AppItemGetEdit(self->app) == self)
      AppItemSet (self->app, NULL,NULL,0);

    debug4("EditDelete() %s in %dx%dx%d\n",obj->name,x, y, z);

    remove_ob (obj);
    free_object (obj);
    /* remove_ob should do this for us */
    /* But it doesnt - ds */
    SET_MAP_FLAGS(self->emap, x, y, P_NEED_UPDATE);
    update_position (self->emap, x, y);
    return True;
}

/*
 * member: insert object to point of map of editor
 * object:
 * x,y,z : point to insert
 * return: True, if obejct inserted
 */
object *EditCloneInsert (Edit self,object *obj,int x, int y, int z)
{
    object *op;
    int button_value;

    /*** create & insert ***/
    if ((op = object_create_clone(obj))) {
        /*** object do not fit ***/
        if(!MapObjectOut(self->emap,op,x,y)) {
            MapInsertObjectZ (self->emap, op, x, y, z);
            if (QUERY_FLAG(obj, FLAG_IS_LINKED) && 
              (button_value = get_button_value(obj))) {
                add_button_link(op, self->emap, button_value);
              }
            return op;
        }
    } 
    debug0 ("Inserting failed\n");
    return NULL;
}

/*
 * member: insert object to point of map of editor
 * x,y,z : point to insert
 * return: True, if obejct inserted
 */
Boolean EditInsert (Edit self,int x, int y, int z)
{
    int zi = z;
    object *op,*tmp;
    XRectangle rect;

    /*** ***/
    if (!self ||
        self->read_only ||
        !self->emap || 
        out_of_map (self->emap, x, y))
        return False;

    /*** something to insert ***/
    if (!AppItemGetObject(self->app) && !AppItemGetMap(self->app)) {
        CnvNotify ( "Select item to insert.", "OK", NULL);
        return False;
    }
    /*** check for duplicate object ***/
    if (z >= 0) {
        op = get_map_ob (self->emap, x, y);
        while (op && op->above)
            op = op->above;
        while (op && zi-- > 0)
            op = op->below;
        if (op && op->arch == self->app->item.clone->arch)
            return False;
    }
    /* Hopefully this doesn't break anything */
    else {
        op = get_map_ob (self->emap, x, y);
        if (op && op->arch == self->app->item.clone->arch)
            return False;
    }

    debug3("EditInsert() %dx%dx%d\n",x,y,z);

    /*** handle background ***/
    if (self->overwrite)
        while (get_map_ob (self->emap, x, y))
            EditDelete(self, x, y, 0);
    else {
        tmp = MapGetObjectZ (self->emap, x, y, z);
        if (tmp && 
            (tmp->arch == self->app->item.clone->arch ||
            (self->app->item.wall_map &&
              find_draw_arch (AppItemGetMap(self->app),
                AppItemGetWall(self->app),
                tmp->arch) >= 0)))
            return False;
    }

    /*** create & insert ***/
    op = EditCloneInsert (self, self->app->item.clone, x, y, z);

    if (self->app->item.wall_map) 
        draw_add (self, x, y);

    EditObjectCalc(self,op,&rect);
    SET_MAP_FLAGS(self->emap, x, y, P_NEED_UPDATE);
    update_position (self->emap, x, y);
    CrEditRefresh(self->w,rect);

    EditModified(self);
    return True;
}


/*
 * member: insert object to point of map of editor
 * object:
 * x,y,z : point to insert
 * return: True, if obejct inserted
 */
Boolean EditObjectInsert (Edit self,object *obj,int x, int y, int z)
{
    int zi = z;
    object *op,*tmp;
    XRectangle rect;

    /*** ***/
    if (!self ||
        self->read_only ||
        !self->emap || 
        out_of_map (self->emap, x, y) ||
        !obj)
        return False;

    /*** check for duplicate object ***/
    op = get_map_ob (self->emap, x, y);
    while (op && op->above)
        op = op->above;
    while (op && zi-- > 0)
        op = op->below;
    if (op && op->arch == obj->arch)
        return False;

    debug3("EditInsert() %dx%dx%d\n",x,y,z);

    /*** handle background ***/
    tmp = MapGetObjectZ (self->emap, x, y, z);
    if (tmp && (tmp->arch == obj->arch))
        return False;
    
    /*** create & insert ***/
    op = EditCloneInsert (self, op, x, y, z);

    EditObjectCalc(self,op,&rect);
    CrEditRefresh(self->w,rect);

    EditModified(self);
    return True;
}

/*
 * member: set path name of map
 * path  : path of file representing map
 */
void EditSetPath(Edit self,String path)
{
    if(!self) return;
    strcpy(self->emap->path,path);
    EditUpdate(self);
}

/*** end of Edit.c ***/
Revision:	1.1.1.1 (vendor branch)
Committed:	Fri Feb 3 07:11:44 2006 UTC (18 years, 4 months ago) by root
Content type:	text/plain
Branch:	UPSTREAM
CVS Tags:	UPSTREAM_2006_03_15, UPSTREAM_2006_02_22, UPSTREAM_2006_02_03
Changes since 1.1:	+0 -0 lines
Log Message:	initial import