home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Club Amiga de Montreal - CAM
/
CAM_CD_1.iso
/
files
/
053.lha
/
HackBench
/
hbobj.c
< prev
next >
Wrap
C/C++ Source or Header
|
1986-11-20
|
21KB
|
660 lines
/****************************************************************
/* *
/* HackBench - Part 3 of 4 - hbobj.c - Object Routines *
/* *
/* Copyright (C) 1987 by Bill Kinnersley *
/* CS Dept, Washington State Univ, Pullman, WA 99164 *
/* *
/* Permission granted to redistribute this program *
/* provided the copyright notice remains intact. *
/* May not be used as part of any commercial product. *
/* *
/****************************************************************/
#include "hb.h"
extern struct DosLibrary *DosBase;
extern struct DosInfo *rnInfo;
extern struct MsgPort *IDCMPPort, *WBPort;
extern struct Window *wbWin, *curWin;
extern struct DiskObject defDskObj;
extern struct Menu *menuStrip;
extern struct Gadget
vs_gad, hs_gad, ren_gad, up_gad, dm_gad, lm_gad, rm_gad;
extern struct PropInfo hs_knob, vs_knob;
extern USHORT zz_ptr[];
extern char *title, *rindex();
extern BPTR initialDir, getlock();
extern short debug;
struct Rectangle rect = {4, 11};
struct List wbObjs, selObjs, utilObjs;
short lastHeight=14, toolsRunning = 0, wbFlags = 0;
void *allocList();
int drawobj(), compobj();
char *type[8] = {"", "DISK", "DRAWER", "TOOL", "PROJECT",
"GARBAGE", "DEVICE", "KICK"};
char *empty = "";
struct IntuiText icon_txt = {1, 0, JAM2, 5, 0, NULL, NULL, NULL};
/* Manufacture a new WBObject with a given name, window, and parent */
struct MyWBObject *makeObj(diskObj, name, w, parent)
struct DiskObject *diskObj; char *name;
struct Window *w; struct MyWBObject *parent; {
struct MyWBObject *obj;
char *buf, *p;
SHORT size, i, s;
struct Gadget *g;
struct Image *image;
USHORT *data;
struct MyDrawerData *dd;
struct NewWindow *nwd;
if (!(obj= ALLOC(MyWBObject)))
{error("Can't allocate WB Object"); return;}
NewList(&obj->wo_FreeList.fl_MemList);
buf = allocList(obj, 31);
/* Space for 31 chars in case it's later renamed */
strcpy(buf, name);
obj->wo_Name = obj->wo_MasterNode.ln_Name =
obj->wo_Siblings.ln_Name = obj->wo_SelectNode.ln_Name = buf;
AddTail(&wbObjs, obj);
obj->wo_IconWin = w;
obj->wo_Type = diskObj->do_Type;
if (diskObj->do_ToolTypes) {
for (i = 0; p = diskObj->do_ToolTypes[i]; i++) ;
obj->wo_ToolTypes = allocList(obj, 4*i);
for (i = 0; p = diskObj->do_ToolTypes[i]; i++) {
buf = allocList(obj, strlen(p)+1);
strcpy(buf, p);
obj->wo_ToolTypes[i] = buf;
}
}
if (diskObj->do_ToolWindow) {
buf = allocList(obj, strlen(diskObj->do_ToolWindow)+1);
strcpy(buf, diskObj->do_ToolWindow);
obj->wo_ToolWindow = buf;
}
if (diskObj->do_DefaultTool) {
buf = allocList(obj, strlen(diskObj->do_DefaultTool)+1);
strcpy(buf, diskObj->do_DefaultTool);
obj->wo_DefaultTool = buf;
}
obj->wo_StackSize = diskObj->do_StackSize;
obj->wo_CurrentX = diskObj->do_CurrentX;
obj->wo_CurrentY = diskObj->do_CurrentY;
if (diskObj->do_CurrentX==NO_ICON_POSITION) {
if (debug) printf("<%s>:No Icon Position\n", name);
obj->wo_CurrentX = 20; obj->wo_CurrentY = 10;
/* Should do better placement than this */
}
g = &diskObj->do_Gadget;
/* stc means structure copy */
/*stc*/ obj->wo_Gadget = diskObj->do_Gadget;
image = allocList(obj, sizeof(struct Image));
/*stc*/ *image = *(struct Image *)(diskObj->do_Gadget.GadgetRender);
obj->wo_Gadget.GadgetRender = (APTR)image;
size = (image->Width/16) + ((image->Width%16)>0);
size *= image->Height * image->Depth;
data = allocList(obj, 2*size);
for (i=0; i<size; i++) data[i] = (image->ImageData)[i];
image->ImageData = data;
image = allocList(obj, sizeof(struct Image));
if (diskObj->do_Gadget.SelectRender)
/*stc*/ *image = *(struct Image *)(diskObj->do_Gadget.SelectRender);
else *image = *(struct Image *)(diskObj->do_Gadget.GadgetRender);
obj->wo_Gadget.SelectRender = (APTR)image;
size = (image->Width/16) + ((image->Width%16)>0);
size *= image->Height * image->Depth;
data = allocList(obj, 2*size);
if (diskObj->do_Gadget.SelectRender)
for (i=0; i<size; i++) data[i] = (image->ImageData)[i];
else
for (i=0; i<size; i++) data[i] = ~(image->ImageData)[i];
image->ImageData = data;
if (diskObj->do_DrawerData) {
dd = allocList(obj, sizeof(struct MyDrawerData));
obj->wo_DrawerData = dd;
/* stc */ dd->dd_NewWindow = diskObj->do_DrawerData->dd_NewWindow;
dd->dd_NewWindow.Title = obj->wo_Name;
NewList(&dd->dd_Children);
dd->dd_CurrentX = diskObj->do_DrawerData->dd_CurrentX;
dd->dd_CurrentY = diskObj->do_DrawerData->dd_CurrentY;
nwd = &dd->dd_NewWindow;
nwd->MinWidth = 90;
nwd->MinHeight = 40;
nwd->MaxWidth = nwd->MaxHeight = -1;
dd->dd_MinX = dd->dd_MinY = 0;
dd->dd_MaxX = nwd->Width - 14;
dd->dd_MaxY = nwd->Height - 9;
/*stc*/ dd->dd_HorizScroll = hs_gad;
/*stc*/ dd->dd_VertScroll = vs_gad;
/*stc*/ dd->dd_UpMove = up_gad;
/*stc*/ dd->dd_DownMove = dm_gad;
/*stc*/ dd->dd_LeftMove = lm_gad;
/*stc*/ dd->dd_RightMove = rm_gad;
/*stc*/ dd->dd_HorizProp = hs_knob;
/*stc*/ dd->dd_VertProp = vs_knob;
dd->dd_HorizScroll.GadgetRender = (APTR)&dd->dd_HorizImage;
dd->dd_HorizScroll.SpecialInfo = (APTR)&dd->dd_HorizProp;
dd->dd_VertScroll.GadgetRender = (APTR)&dd->dd_VertImage;
dd->dd_VertScroll.SpecialInfo = (APTR)&dd->dd_VertProp;
dd->dd_HorizScroll.NextGadget = &dd->dd_VertScroll;
dd->dd_VertScroll.NextGadget = &dd->dd_UpMove;
dd->dd_UpMove.NextGadget = &dd->dd_DownMove;
dd->dd_DownMove.NextGadget = &dd->dd_LeftMove;
dd->dd_LeftMove.NextGadget = &dd->dd_RightMove;
dd->dd_NewWindow.FirstGadget = &dd->dd_HorizScroll;
}
obj->wo_NameXOffset = (g->Width/2)-4*strlen(name);
obj->wo_NameYOffset = g->Height;
obj->wo_Parent = parent;
if (parent && parent->wo_DrawerData) {
AddHead(&parent->wo_DrawerData->dd_Children,
&obj->wo_Siblings);
if (debug) printf("Added %lx <%s> to %lx <%s>\n",
obj, obj->wo_Name, parent, parent->wo_Name);
}
return obj;
}
/* Given a List, use off to find the objects,
then perform fn on each object with parameter p1 */
doList(list, off, fn, p1)
struct List *list; long off; int (*fn)(); {
struct MyWBObject *obj;
struct Node *node;
for (node=list->lh_Head; node->ln_Succ; node=node->ln_Succ) {
obj = OBJ(node,off);
(*fn)(obj, p1);
}
}
/* Remove an object from the system */
deleteobj(obj) struct MyWBObject *obj; {
struct MyDrawerData *dd;
struct MyWBObject *child;
struct Node *node;
long off;
if (dd = obj->wo_DrawerData) {
if (dd->dd_DrawerWin) /* Shouldn't happen */
{printf("Can't delete me--I'm open\n"); return;}
if (dd->dd_Lock) {
if (debug) printf("deleteobj: Unlocking dd_Lock: <%s> %lx\n",
obj->wo_Name, dd->dd_Lock);
UnLock(dd->dd_Lock);
dd->dd_Lock = NULL;
}
while (node = RemHead(&dd->dd_Children)) {
child = OBJ(node, CHILD);
if (debug) printf("Found an orphan %lx\n", child);
child->wo_Parent = NULL;
}
}
if (debug) printf("Deleting %lx <%s> %lx\n", obj,
obj->wo_MasterNode.ln_Name, obj->wo_Lock);
if (obj->wo_Lock) {
if (debug) printf("deleteobj: Unlocking wo_Lock: <%s> %lx\n",
obj->wo_Name, obj->wo_Lock);
UnLock(obj->wo_Lock);
obj->wo_Lock = NULL;
}
FreeFreeList(&obj->wo_FreeList);
for (off=0; off<4; off++) {
node = (struct Node *)((long)obj + off*sizeof(struct Node));
if (node->ln_Succ) Remove(node);
}
FreeMem(obj, (long)sizeof(struct MyWBObject));
}
struct DiskObject *getDisk(name) char *name; {
char buf[36];
strcpy(buf, name);
strcat(buf,":Disk");
return GetDiskObject(buf);
}
/* Initial installation of all Volumes on the Device List */
findDisks() {
struct DeviceList *diDev, *ptr;
char diskName[31];
diDev = (struct DeviceList *) BADDR(rnInfo->di_DevInfo);
for (ptr=diDev; ptr; ptr=(struct DeviceList *)BADDR(ptr->dl_Next)){
if (ptr->dl_Type==DLT_VOLUME) {
bs2cs(diskName, ptr->dl_Name);
if (debug) printf("<%s>\n", diskName);
instDisk(diskName);
}
}
}
/* Install an object and icon for a disk */
instDisk(diskName) char *diskName; {
struct DiskObject *dObj;
struct MyWBObject *obj;
if (dObj = getDisk(diskName)) {
if (dObj->do_CurrentX==NO_ICON_POSITION)
dObj->do_CurrentX = 576;
if (dObj->do_CurrentY==NO_ICON_POSITION)
dObj->do_CurrentY = lastHeight;
obj = makeObj(dObj, diskName, wbWin, NULL);
FreeDiskObject(dObj);
}
else {
if (debug) printf("Default icon\n");
dObj = &defDskObj;
dObj->do_CurrentY = lastHeight;
obj = makeObj(dObj, diskName, wbWin, NULL);
}
drawobj(obj, NORM);
lastHeight += 22L;
/* Should try harder to find an empty spot */
}
/* For debugging, print everybody on a List */
dumplist(list, off) struct List *list; long off; {
struct Node *node;
struct MyWBObject *child;
printf("---\n");
for (node=list->lh_Head; node->ln_Succ; node=node->ln_Succ) {
child = OBJ(node,off);
printf("%lx <%s>\n", node, node->ln_Name);
}
}
/* Close a drawer object */
closeobj(obj) struct MyWBObject *obj; {
struct MyDrawerData *dd;
struct Node *node;
struct MyWBObject *child;
struct FileLock mylock;
struct Region *reg;
if (!(dd = obj->wo_DrawerData)) return;
if (!dd->dd_DrawerWin) return;
NewList(&utilObjs);
for (node=dd->dd_Children.lh_Head; node->ln_Succ;
node = node->ln_Succ) {
child = OBJ(node,CHILD);
if (debug) printf("child: %lx <%s>\n", child, child->wo_Name);
if (child->wo_IconWin==dd->dd_DrawerWin) { /* In this window */
if (child->wo_DrawerData) /* a drawer */ {
if (child->wo_DrawerData->dd_DrawerWin) {
if (debug) printf("Child open..retained\n");
child->wo_IconWin = NULL;
if (child->wo_SelectNode.ln_Succ) {
Remove(&child->wo_SelectNode);
child->wo_SelectNode.ln_Succ = NULL;
}
continue;
}
if (child->wo_DrawerData->dd_Children.lh_Head->ln_Succ) {
if (debug) {
printf("Child has children..retained\n");
printf("closeobj: grandchildren:");
dumplist(&child->wo_DrawerData->dd_Children, CHILD);
}
child->wo_IconWin = NULL;
continue;
}
}/* if drawer */
AddHead(&utilObjs, &child->wo_UtilityNode);
}/* if in window */
}/* for children */
doList(&utilObjs, UTIL, deleteobj); /* Kill the kids */
dd->dd_NewWindow.LeftEdge = dd->dd_DrawerWin->LeftEdge;
dd->dd_NewWindow.TopEdge = dd->dd_DrawerWin->TopEdge;
dd->dd_NewWindow.Width = dd->dd_DrawerWin->Width;
dd->dd_NewWindow.Height = dd->dd_DrawerWin->Height;
reg = InstallClipRegion(dd->dd_DrawerWin->WLayer, NULL);
DisposeRegion(reg);
closeWinSafely(dd->dd_DrawerWin);
dd->dd_DrawerWin = NULL;
if (dd->dd_Lock) {
if (debug) printf("closeobj: cd %lx\n", initialDir);
CurrentDir(initialDir);
if (debug) printf("closeobj: Unlocking dd_Lock <%s> %lx\n",
obj->wo_Name, dd->dd_Lock);
UnLock(dd->dd_Lock);
dd->dd_Lock = NULL;
}
}
/* Remove an icon from the screen */
clearobj(obj) struct MyWBObject *obj; {
struct Window *w;
struct MyDrawerData *dd;
long cx=0, cy=0;
if ((w = obj->wo_IconWin)!=wbWin) {
dd = ((struct MyWBObject *)w->UserData)->wo_DrawerData;
cx = dd->dd_CurrentX;
cy = dd->dd_CurrentY;
}
if (debug) printf("clearobj: %lx <%s> win=%lx\n", obj, obj->wo_Name, w);
SetAPen(w->RPort, 0L);
RectFill(w->RPort,
obj->wo_CurrentX - cx, obj->wo_CurrentY + YOFF - cy,
obj->wo_CurrentX + obj->wo_Gadget.Width - cx,
obj->wo_CurrentY + obj->wo_Gadget.Height + YOFF - cy);
RectFill(w->RPort,
obj->wo_CurrentX + obj->wo_NameXOffset - cx,
obj->wo_CurrentY + obj->wo_NameYOffset + YOFF - cy,
obj->wo_CurrentX + obj->wo_NameXOffset +
8L*(long)strlen(obj->wo_Name) - cx,
obj->wo_CurrentY + obj->wo_NameYOffset + YOFF + 10L - cy);
SetAPen(w->RPort, 1L);
}
/* Toggle an icon, highlighted <-> normal */
compobj(obj) struct MyWBObject *obj; {
struct Window *w;
long cx=0, cy=0;
struct MyDrawerData *dd;
if (debug) printf("comp: %lx <%s>\n", obj, obj->wo_Name);
if ((w = obj->wo_IconWin)!=wbWin) {
dd = ((struct MyWBObject *)w->UserData)->wo_DrawerData;
cx = dd->dd_CurrentX;
cy = dd->dd_CurrentY;
}
ClipBlit(w->RPort, obj->wo_CurrentX - cx, obj->wo_CurrentY - cy,
w->RPort, obj->wo_CurrentX - cx, obj->wo_CurrentY - cy,
(long)obj->wo_Gadget.Width, (long)obj->wo_Gadget.Height,
0x50L);
obj->wo_Flags ^= HIGH; /* For use by refresh() */
}
/* At position (x,y) see if an icon was hit and if so whom */
struct MyWBObject *findObj(x, y, w) short x, y; struct Window *w; {
struct Node *node;
struct Gadget *gad;
struct MyWBObject *obj;
struct MyDrawerData *dd;
long cx=0, cy=0;
if (w!=wbWin) {
dd = ((struct MyWBObject *)w->UserData)->wo_DrawerData;
cx = dd->dd_CurrentX;
cy = dd->dd_CurrentY;
}
/* Scan list in reverse order,
so that last icon drawn is first one found */
for (node=wbObjs.lh_TailPred; node->ln_Pred; node=node->ln_Pred) {
obj = (struct MyWBObject *)node;
if (w != obj->wo_IconWin) continue;
gad = &obj->wo_Gadget;
if ((x > (obj->wo_CurrentX-cx)) &&
(x < (obj->wo_CurrentX + gad->Width - cx)) &&
(y > (obj->wo_CurrentY + YOFF - cy)) &&
(y < (obj->wo_CurrentY + gad->Height + YOFF - cy)))
return obj;
}
return NULL;
}
openobj(obj) struct MyWBObject *obj; {
struct Window *w;
struct MyDrawerData *dd;
char name[80];
struct Region *reg;
BPTR lock;
if (debug) printf("openobj:%lx <%s>\n",obj, obj->wo_Name);
if (!(dd = obj->wo_DrawerData)) {
printf("What's this %s doing here??\n",type[obj->wo_Type]);
return;
}
if (dd->dd_DrawerWin) return; /* Already open */
SetPointer(curWin, zz_ptr, 19L, 16L, -7L, -8L);
dd->dd_NewWindow.Title = obj->wo_Name;
dd->dd_NewWindow.IDCMPFlags = 0;
if (!(w = OpenWindow(&dd->dd_NewWindow)))
{error("Couldn't open the drawer\n"); goto opcln;}
dd->dd_DrawerWin = w;
w->UserPort = IDCMPPort;
ModifyIDCMP(w, CLOSEWINDOW | GADGETUP | GADGETDOWN |
MENUPICK | NEWSIZE | MOUSEBUTTONS | REFRESHWINDOW);
SetMenuStrip(w, menuStrip);
SetWindowTitles(w, -1L, title);
reclip(w);
/* UserData holds a pointer back to the object */
w->UserData = (BYTE *)obj;
lock = getlock(obj);
if (debug) printf("openobj: cd %lx\n", lock);
CurrentDir(lock);
if (!dd->dd_Lock) {
strcpy(name, obj->wo_Name);
if (obj->wo_Type==WBDISK) strcat(name,":");
dd->dd_Lock = Lock(name, ACCESS_READ);
if (debug) printf("openobj Locked <%s> %lx\n",
name, dd->dd_Lock);
if (!dd->dd_Lock) {
error("This drawer cannot be opened");
/* Probably an .info file all by itself */
reg = InstallClipRegion(w->WLayer, NULL);
DisposeRegion(reg);
closeWinSafely(w);
dd->dd_DrawerWin = NULL;
goto opcln;
}
}
dir(obj, w);
resize(w);
opcln: ClearPointer(curWin);
}
/* Search a directory for .info files */
dir(obj, w) struct MyWBObject *obj; struct Window *w; {
FILE *fd;
struct InfoData *id;
LONG success;
struct FileInfoBlock *m;
BPTR oldlock, newLock;
char *name, buf[80], buf2[80], *s;
struct DiskObject *dObj;
struct MyWBObject *wbObj;
struct Node *node;
struct MyDrawerData *dd;
dd = obj->wo_DrawerData;
name = obj->wo_Name;
strcpy(buf, name);
strcat(buf,":");
if (!(newLock = dd->dd_Lock)) {printf("No lock\n"); return;}
if (debug) printf("dir: cd %lx\n", newLock);
oldlock = CurrentDir(newLock);
/* If we were using the .info file itself: */
/*if (fd=fopen(".info","r")) {
if (fseek(fd, 16L, 0)!=-1) {
while (fgets(buf2, 70, fd)) {
buf2[strlen(buf2)-1]=0;
if (dObj=GetDiskObject(buf2)) {
obj = makeObj(dObj, buf2, w, obj);
doList(&selObjs, SEL, drawobj, NORM);
FreeDiskObject(dob);
}
else printf("can't get <%s>\n",buf2);
}
}
fclose(fd);
return;
}*/
if (!(id = ALLOC(InfoData)))
{error("Can't allocate id"); goto dirCln;}
if (!(success = Info(newLock, id)))
{error("Can't get info"); goto dirCln;}
if (!(m = ALLOC(FileInfoBlock)))
{error("Can't allocate m"); goto dirCln;}
if (!(success = Examine(newLock, m)))
{error("Can't examine directory"); goto dirCln;}
if (m->fib_DirEntryType<=0)
{error("Not a directory"); goto dirCln;}
NewList(&utilObjs);
while (success = ExNext(newLock, m)) {
strcpy(buf, m->fib_FileName);
if (s = rindex(buf,'.')) if (strcmp(s,".info")==0) {
*s = 0;
if ((*buf) && (strcmp(buf,"Disk"))) {
if (debug) printf("Looking for <%s>\n", buf);
if (node = FindName(&dd->dd_Children, buf)) {
wbObj = OBJ(node,CHILD);
if (debug) printf("Found child <%s> %lx\n",
node->ln_Name, wbObj);
if (!wbObj->wo_IconWin)
wbObj->wo_IconWin = dd->dd_DrawerWin;
AddTail(&utilObjs, &wbObj->wo_UtilityNode);
}
else if (dObj = GetDiskObject(buf)) {
wbObj = makeObj(dObj, buf, w, obj);
FreeDiskObject(dObj);
AddTail(&utilObjs, &wbObj->wo_UtilityNode);
}
else printf("Can't get <%s>\n", m->fib_FileName);
} /* if buf */
} /* if s */
} /* while */
doList(&utilObjs, UTIL, drawobj, NORM);
dirCln: if (m) FreeMem(m, (long)sizeof(struct FileInfoBlock));
if (id) FreeMem(id, (long)sizeof(struct InfoData));
}
/* Draw an icon, either normal or hightlighted */
drawobj(obj, mode) struct MyWBObject *obj; {
struct Window *w;
long cx=0, cy=0;
struct MyDrawerData *dd;
APTR im;
if ((w = obj->wo_IconWin)!=wbWin) {
dd = ((struct MyWBObject *)w->UserData)->wo_DrawerData;
cx = dd->dd_CurrentX;
cy = dd->dd_CurrentY;
}
im = (mode & HIGH) ? obj->wo_Gadget.SelectRender :
obj->wo_Gadget.GadgetRender;
DrawImage(w->RPort, im, obj->wo_CurrentX - cx,
obj->wo_CurrentY + YOFF - cy);
if (mode & HIGH) obj->wo_Flags |= HIGH; /* For use by refresh() */
else obj->wo_Flags &= ~HIGH;
icon_txt.IText = obj->wo_Name;
icon_txt.LeftEdge = obj->wo_NameXOffset;
icon_txt.TopEdge = obj->wo_NameYOffset;
PrintIText(w->RPort, &icon_txt, obj->wo_CurrentX - cx,
obj->wo_CurrentY + YOFF - cy);
}
/* Run something */
run(obj) struct MyWBObject *obj; {
struct WBStartup *msg;
struct Process *proc;
long seg, stack;
struct MsgPort *id;
struct Node *node;
char *name, i;
struct MyWBObject *arg;
BPTR lock;
if (obj->wo_Type==WBPROJECT) {
if (!(name = obj->wo_DefaultTool))
{error("This project has no default tool"); return;}
if (debug) printf("Default Tool: <%s>\n", name);
}
else if (obj->wo_Type==WBTOOL) name = obj->wo_Name;
if (debug) printf("Running <%s>\n", name);
if (!obj->wo_Parent) {printf("I've lost my mommy\n"); return;}
lock = getlock(obj);
if (debug) printf("run: cd %lx\n", lock);
CurrentDir(lock);
if (!(seg = LoadSeg(name)))
{error("Can't load the tool"); goto runCln;}
stack = (obj->wo_StackSize) ? obj->wo_StackSize : 5000L;
if (debug) printf("stack=%ld\n", stack);
if (!(id = CreateProc(name, 0L, seg, stack)))
{printf("Can't create a process\n"); goto runCln;}
proc = (struct Process *)((long)(id) - sizeof(struct Task));
if (!(msg = ALLOC(WBStartup)))
{printf("Can't make a msg\n"); goto runCln;}
msg->sm_Message.mn_ReplyPort = WBPort;
msg->sm_Process = id;
msg->sm_Segment = seg;
msg->sm_NumArgs = 0;
if (obj->wo_Type==WBPROJECT) msg->sm_NumArgs++;
for (node=selObjs.lh_Head; node->ln_Succ; node=node->ln_Succ)
msg->sm_NumArgs++;
if (debug) printf("%ld args\n",msg->sm_NumArgs);
if (!(msg->sm_ArgList =
AllocMem(msg->sm_NumArgs*(long)sizeof(struct WBArg), MEMF_CPC)))
{printf("Can't allocate arglist\n"); return;}
i = 0;
if (obj->wo_Type==WBPROJECT) {
msg->sm_ArgList[i].wa_Name = name;
msg->sm_ArgList[i].wa_Lock = Lock(name, ACCESS_READ);
i++;
}
msg->sm_ArgList[i].wa_Name = obj->wo_Name;
msg->sm_ArgList[i].wa_Lock = lock;
i++;
for (node=selObjs.lh_Head; node->ln_Succ; node=node->ln_Succ) {
arg = OBJ(node,SEL);
if (arg==obj) continue;
if (arg->wo_Type==WBTOOL || arg->wo_Type==WBPROJECT)
msg->sm_ArgList[i].wa_Name = arg->wo_Name;
else msg->sm_ArgList[i].wa_Name = empty;
msg->sm_ArgList[i].wa_Lock = getlock(arg);
if (debug) printf("<%s> %lx\n",
msg->sm_ArgList[i].wa_Name,
msg->sm_ArgList[i].wa_Lock);
/* Wrong for dirs--the lock should be a lock
on the object itself */
i++;
}
msg->sm_ToolWindow = obj->wo_ToolWindow;
if (obj->wo_ToolWindow) if (debug)
printf("ToolWindow:<%s>\n", obj->wo_ToolWindow);
PutMsg(id, msg);
toolsRunning++;
return;
runCln: if (seg) {
if (debug) printf("runCln: unloading\n");
UnLoadSeg(seg);
}
}
void *allocList(obj, size) struct MyWBObject *obj; {
void *buf;
if (!(buf = AllocMem((long)size, MEMF_CPC)))
closeAll("Can't allocList");
AddFreeList(&obj->wo_FreeList, buf, (long)size);
return buf;
}
refresh(w) struct Window *w; {
struct MyWBObject *obj;
struct Node *node;
if (debug) printf("Refresh %lx <%s>\n", w, w->Title);
for (node=wbObjs.lh_Head; node->ln_Succ; node=node->ln_Succ) {
obj = (struct MyWBObject *) node;
if (obj->wo_IconWin==w) drawobj(obj, obj->wo_Flags & HIGH);
}
}