IPTR ModelClass__OM_UPDATE(Class *cl, Object *o, struct opUpdate *msg)
{
struct ModelData *data = (struct ModelData *)INST_DATA(cl, o);
/* send OM_UPDATE to all members without mapping the tags! */
if (!IsListEmpty((struct List *)&data->memberlist))
{
STACKULONG method = ICM_CHECKLOOP;
if (DoMethodA(o, (Msg)&method) == 0) /* avoid loops */
{
struct TagItem *clonetags;
if ((clonetags = CloneTagItems(msg->opu_AttrList)))
{
struct opUpdate opu = *msg;
Object *member, *objstate;
opu.MethodID = OM_UPDATE; /* not OM_NOTIFY! */
opu.opu_AttrList = clonetags;
method = ICM_SETLOOP;
DoMethodA(o, (Msg)&method);
objstate = (Object *)data->memberlist.mlh_Head;
while((member = NextObject(&objstate)))
{
DoMethodA(member, (Msg)&opu);
/* in case the member object poked around in the taglist: */
RefreshTagItemClones(clonetags, msg->opu_AttrList);
}
method = ICM_CLEARLOOP;
DoMethodA(o, (Msg)&method);
FreeTagItems(clonetags);
}
} /* if (DoMethod(o, ICM_CHECKLOOP) == 0) */
} /* if (!IsListEmpty(&data->memberlist)) */
/* modelclass is a superclass of icclass so not only the members are targets,
* but possibly also the modelclass object itself could have an ICA_Target.
* This is handled by the superclass */
return DoSuperMethodA(cl, o, (Msg)msg);
}
SWDB_ASSERTCLFN()
{
ULONG x;
SW_IDATA *idata = INST_DATA(cl, o);
switch (msg->MethodID) {
SW_DO_MF(SWM_OBox_InsertClass);
SW_DO_MF(SWM_OBox_InsertObject);
SW_DO_MF(SWM_OBox_UpdateObject);
SW_DO_MF(SWM_OBox_Editor);
SW_DO_MF(SWM_OBox_Edit);
SW_DO_MF(SWM_OBox_Save);
SW_DO_MF(SWM_OBox_Load);
SW_DO_MF(SWM_OBox_MethodForward);
SW_DO_MF(SWM_Root_GetDragObj);
SW_DO_MF(MUIM_Cleanup); // when we`re hidden
SW_DO_MF(MUIM_AskMinMax); // ask min max size
SW_DO_MF(MUIM_Draw); // draw object
SW_DO_MF(MUIM_DragQuery); // drag query request
SW_DO_MF(MUIM_DragDrop); // drag drop report
}
// -- handle forward methods ---------------------------------------------
for (x=0; x<MAXMTHF; x++) // move this stuff to root class? Its useful.
if (idata->Method[x] == msg->MethodID)
SWDB_RET((ULONG)DoMethodA(idata->Target[x], msg));
SuperMethod:
SWDB_RET((ULONG)DoSuperMethodA(cl, o, msg));
} SDFT
IPTR Ascii__OM_SET(Class *cl, Object *o, struct opSet *msg)
{
IPTR retval;
/* Pass the attributes to the text class and force a refresh
* if we need it */
if ((retval = DoSuperMethodA (cl, o, (Msg)msg)) && (OCLASS (o) == cl))
{
struct RastPort *rp;
/* Get a pointer to the rastport */
if ((rp = ObtainGIRPort (msg->ops_GInfo)))
{
struct gpRender gpr;
/* Force a redraw */
gpr.MethodID = GM_RENDER;
gpr.gpr_GInfo = msg->ops_GInfo;
gpr.gpr_RPort = rp;
gpr.gpr_Redraw = GREDRAW_UPDATE;
DoMethodA (o, (Msg)&gpr);
/* Release the temporary rastport */
ReleaseGIRPort (rp);
}
retval = 0;
}
return retval;
}
static ULONG
mNew(struct IClass *cl,Object *obj,struct opSet *msg)
{
Object *dto = NULL;
struct BitMapHeader *bmh;
register struct TagItem *attrs = msg->ops_AttrList;
if (obj = (Object *)DoSuperMethodA(cl,obj,(Msg)msg))
{
struct data *data = INST_DATA(cl,obj);
data->cl = cl;
data->obj = obj;
data->sourceType = DTST_FILE;
msg->MethodID = OM_SET;
DoMethodA(obj,(Msg)msg);
msg->MethodID = OM_NEW;
return (ULONG)obj;
}
return 0;
}
/*
* Deletes a 'boopsi' object.
*/
void
DisposeObject (Object *object)
{
ULONG MethodID = OM_DISPOSE;
OCLASS (object)->cl_ObjectCount --;
DoMethodA (object, (Msg)&MethodID);
} /* DisposeObject */
IPTR ModelClass__OM_ADDMEMBER(Class *cl, Object *o, struct opMember *msg)
{
struct ModelData *data = (struct ModelData *)INST_DATA(cl, o);
struct opAddTail method;
method.MethodID = OM_ADDTAIL;
method.opat_List = (struct List *)&data->memberlist;
DoMethodA( msg->opam_Object, (Msg)&method);
return (IPTR)0;
}
STATIC Object *MultiString_AddStringField(struct IClass *cl,Object *obj, struct MUIP_MultiString_AddStringField *msg, struct object_node *prev_node)
{
struct MultiString_Data *data = (struct MultiString_Data*)INST_DATA(cl,obj);
struct object_node *obj_node;
if ((obj_node = (struct object_node*)malloc(sizeof(struct object_node))))
{
obj_node->obj = SingleStringObject,
MUIA_CycleChain, 1,
MUIA_UTF8String_Contents, msg->contents,
MUIA_UTF8String_Charset, user.config.default_codeset,
End;
if (obj_node->obj)
{
Object **sort_array = (Object**)malloc(sizeof(Object*)*(list_length(&data->object_list)+3));
list_insert(&data->object_list, &obj_node->node, &prev_node->node);
DoMethod(obj, MUIM_Group_InitChange);
DoMethod(obj, OM_ADDMEMBER, (ULONG)obj_node->obj);
if (sort_array)
{
int i = 1;
struct object_node *cursor = (struct object_node *)list_first(&data->object_list);
sort_array[0] = (Object*)MUIM_Group_Sort;
while (cursor)
{
sort_array[i] = cursor->obj;
cursor = (struct object_node*)node_next(&cursor->node);
i++;
}
sort_array[i] = NULL;
DoMethodA(obj, (Msg)sort_array);
free(sort_array);
}
DoMethod(obj,MUIM_Group_ExitChange);
DoMethod(obj_node->obj, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, (ULONG)obj, 6, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)MultiString_Acknowledge, (ULONG)cl, (ULONG)obj, (ULONG)obj_node);
DoMethod(obj_node->obj, MUIM_Notify, MUIA_SingleString_Event, MUIV_EveryTime, (ULONG)App, 10, MUIM_Application_PushMethod, (ULONG)App, 7, MUIM_CallHook, (ULONG)&hook_standard, (ULONG)MultiString_Event, (ULONG)cl, (ULONG)obj, (ULONG)obj_node, MUIV_TriggerValue);
return obj_node->obj;
}
}
return NULL;
}
IPTR AROSCycle__GM_GOINACTIVE(Class *cl, Object *o, struct gpGoInactive *msg)
{
struct RastPort *rport;
EG(o)->Flags &= ~GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpgi_GInfo);
if (rport)
{
struct gpRender rmsg = { GM_RENDER, msg->gpgi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
}
return 0;
}
/*
** Layout function. Here, we have to call MUI_Layout() for each
** our children. MUI wants us to place them in a rectangle
** defined by (0,0,lm->lm_Layout.Width-1,lm->lm_Layout.Height-1)
** You are free to put the children anywhere in this rectangle.
*/
BOOL MUI_Layout (Object *obj, LONG left, LONG top, LONG width, LONG height,
ULONG flags)
{
static ULONG method = MUIM_Layout;
Object *parent = _parent(obj);
/*
* Called only by groups, never by windows
*/
g_assert(parent != NULL);
_left(obj) = left + _mleft(parent);
_top(obj) = top + _mtop(parent);
_width(obj) = width;
_height(obj) = height;
DoMethodA(obj, (Msg)&method);
return TRUE;
}
VOID ImageDecoderThread ()
{
LONG args[6];
struct RDArgs *readargs;
if(readargs = ReadArgs("/A/N,/A/N,/A/N,/A/N,/A/N,/A/F", args, NULL))
{
ULONG pageID = *((ULONG *)args[0]);
struct ImageList *images = *((struct ImageList **)args[1]);
Object *ipc = *((Object **)args[2]);
ULONG handle = *((ULONG *)args[3]);
struct Screen *scr = *((struct Screen **)args[4]);
STRPTR url = (STRPTR)args[5];
Object *dt = NULL;
if(dt = NewDTObject(url,
DTA_GroupID, GID_PICTURE,
PDTA_DestMode, MODE_V43,
PDTA_Remap, TRUE,
PDTA_FreeSourceBitMap, TRUE,
PDTA_Screen, scr,
PDTA_UseFriendBitMap, TRUE,
TAG_DONE))
{
DoMethod(dt, DTM_PROCLAYOUT);
}
struct IPCMsg ipcmsg(handle, IPCFlg_Unlock);
ipcmsg.MethodID = MUIM_IPC_DoMessage;
ipcmsg.PageID = pageID;
ipcmsg.Images = images;
ipcmsg.DTObject = dt;
ipcmsg.ImageDecoderThread = FindTask(NULL);
if(!DoMethodA(ipc, (Msg)&ipcmsg))
DisposeDTObject(dt);
UnlockPubScreen(NULL, scr);
}
}
IPTR AROSCycle__GM_GOACTIVE(Class *cl, Object *o, struct gpInput *msg)
{
struct CycleData *data;
struct RastPort *rport;
IPTR retval;
data = INST_DATA(cl, o);
EG(o)->Flags |= GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
retval = GMR_MEACTIVE;
} else
retval = GMR_NOREUSE;
return retval;
}
IPTR ModelClass__OM_DISPOSE(Class *cl, Object *o, Msg msg)
{
struct ModelData *data = (struct ModelData *)INST_DATA(cl, o);
for(;;)
{
/* free all member objects */
Object *member, *objstate;
ULONG method;
objstate = (Object *)data->memberlist.mlh_Head;
member = NextObject(&objstate);
if (!member) break;
method = OM_REMOVE;
DoMethodA(member, (Msg)&method);
DisposeObject(member);
}
return DoSuperMethodA(cl, o, msg);
}
void DoMoveSizeWindow(struct Window *targetwindow, LONG NewLeftEdge, LONG NewTopEdge,
LONG NewWidth, LONG NewHeight, BOOL send_newsize, struct IntuitionBase *IntuitionBase)
{
struct IIHData *iihdata = (struct IIHData *)GetPrivIBase(IntuitionBase)->InputHandler->is_Data;
//struct IntWindow *w = (struct IntWindow *)targetwindow;
struct Layer *targetlayer = WLAYER(targetwindow)/*, *L*/;
struct Requester *req;
struct InputEvent *ie;
LONG OldLeftEdge = targetwindow->LeftEdge;
LONG OldTopEdge = targetwindow->TopEdge;
LONG OldWidth = targetwindow->Width;
LONG OldHeight = targetwindow->Height;
LONG pos_dx, pos_dy, size_dx, size_dy;
/* correct new window coords if necessary */
FixWindowCoords(targetwindow, &NewLeftEdge, &NewTopEdge, &NewWidth, &NewHeight,IntuitionBase);
D(bug("DoMoveSizeWindow to %d,%d %d x %d\n", NewLeftEdge, NewTopEdge, NewWidth, NewHeight));
pos_dx = NewLeftEdge - OldLeftEdge;
pos_dy = NewTopEdge - OldTopEdge;
size_dx = NewWidth - OldWidth;
size_dy = NewHeight - OldHeight;
LOCK_REFRESH(targetwindow->WScreen);
/* jDc: intuition 68k doesn't care about that */
// if (pos_dx || pos_dy || size_dx || size_dy)
// {
if (size_dx || size_dy)
{
WindowSizeWillChange(targetwindow, size_dx, size_dy, IntuitionBase);
}
targetwindow->LeftEdge += pos_dx;
targetwindow->TopEdge += pos_dy;
#ifndef __MORPHOS__
targetwindow->RelLeftEdge += pos_dx;
targetwindow->RelTopEdge += pos_dy;
#endif
targetwindow->Width = NewWidth;
targetwindow->Height = NewHeight;
targetwindow->GZZWidth = targetwindow->Width - targetwindow->BorderLeft - targetwindow->BorderRight;
targetwindow->GZZHeight = targetwindow->Height - targetwindow->BorderTop - targetwindow->BorderBottom;
/* check for GZZ window */
if (BLAYER(targetwindow))
{
/* move outer window first */
MoveSizeLayer(BLAYER(targetwindow), pos_dx, pos_dy, size_dx, size_dy);
}
MoveSizeLayer(targetlayer, pos_dx, pos_dy, size_dx, size_dy);
for (req = targetwindow->FirstRequest; req; req = req->OlderRequest)
{
struct Layer *layer = req->ReqLayer;
if (layer)
{
int dx, dy, dw, dh;
int left, top, right, bottom;
left = NewLeftEdge + req->LeftEdge;
top = NewTopEdge + req->TopEdge;
right = left + req->Width - 1;
bottom = top + req->Height - 1;
if (left > NewLeftEdge + NewWidth - 1)
left = NewLeftEdge + NewWidth - 1;
if (top > NewTopEdge + NewHeight - 1)
top = NewTopEdge + NewHeight - 1;
if (right > NewLeftEdge + NewWidth - 1)
right = NewLeftEdge + NewWidth - 1;
if (bottom > NewTopEdge + NewHeight - 1)
bottom = NewTopEdge + NewHeight - 1;
dx = left - layer->bounds.MinX;
dy = top - layer->bounds.MinY;
dw = right - left - layer->bounds.MaxX + layer->bounds.MinX;
dh = bottom - top - layer->bounds.MaxY + layer->bounds.MinY;
MoveSizeLayer(layer, dx, dy, dw, dh);
}
}
#if 0
if (w->ZipLeftEdge != ~0) w->ZipLeftEdge = OldLeftEdge;
if (w->ZipTopEdge != ~0) w->ZipTopEdge = OldTopEdge;
if (w->ZipWidth != ~0) w->ZipWidth = OldWidth;
if (w->ZipHeight != ~0) w->ZipHeight = OldHeight;
#endif
if (pos_dx || pos_dy)
{
UpdateMouseCoords(targetwindow);
#ifndef __MORPHOS__
if (HAS_CHILDREN(targetwindow))
move_family(targetwindow, pos_dx, pos_dy);
#endif
}
// } /* if (pos_dx || pos_dy || size_dx || size_dy) */
if (size_dx || size_dy)
{
WindowSizeHasChanged(targetwindow, size_dx, size_dy, FALSE, IntuitionBase);
}
ih_fire_intuimessage(targetwindow,
IDCMP_CHANGEWINDOW,
CWCODE_MOVESIZE,
targetwindow,
IntuitionBase);
if (send_newsize)
{
/* Send IDCMP_NEWSIZE and IDCMP_CHANGEWINDOW to resized window, even
if there was no resizing/position change at all. BGUI for example
relies on this! */
ih_fire_intuimessage(targetwindow,
IDCMP_NEWSIZE,
0,
targetwindow,
IntuitionBase);
if ((ie = AllocInputEvent(iihdata)))
{
ie->ie_Class = IECLASS_EVENT;
ie->ie_Code = IECODE_NEWSIZE;
ie->ie_EventAddress = targetwindow;
CurrentTime(&ie->ie_TimeStamp.tv_secs, &ie->ie_TimeStamp.tv_micro);
}
}
// jDc: CheckLayers calls LOCK_REFRESH, so there's no reason to UNLOCK here!
// UNLOCK_REFRESH(targetwindow->WScreen);
CheckLayers(targetwindow->WScreen, IntuitionBase);
UNLOCK_REFRESH(targetwindow->WScreen);
#if 0
if (size_dx || size_dy)
{
if (!(((struct IntWindow *)targetwindow)->CustomShape))
{
struct wdpWindowShape shapemsg;
struct Region *shape;
shapemsg.MethodID = WDM_WINDOWSHAPE;
shapemsg.wdp_Width = targetwindow->Width;
shapemsg.wdp_Height = targetwindow->Height;
shapemsg.wdp_Window = targetwindow;
shapemsg.wdp_TrueColor = (((struct IntScreen *)targetwindow->WScreen)->DInfo.dri.dri_Flags & DRIF_DIRECTCOLOR);
shapemsg.wdp_UserBuffer = ((struct IntWindow *)targetwindow)->DecorUserBuffer;
shape = DoMethodA(((struct IntScreen *)(targetwindow->WScreen))->WinDecorObj, (Msg)&shapemsg);
if (((struct IntWindow *)targetwindow)->OutlineShape) DisposeRegion(((struct IntWindow *)targetwindow)->OutlineShape);
((struct IntWindow *)targetwindow)->OutlineShape = shape;
ChangeWindowShape(targetwindow, shape, NULL);
((struct IntWindow *)targetwindow)->CustomShape = FALSE;
}
}
#endif
}
IPTR AROSCycle__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
{
struct RastPort *rport;
struct CycleData *data;
IPTR retval = GMR_MEACTIVE;
data = INST_DATA(cl, o);
if (msg->gpi_IEvent->ie_Class == IECLASS_RAWMOUSE)
{
if (msg->gpi_IEvent->ie_Code == SELECTUP)
{
if (G(o)->Flags & GFLG_SELECTED)
{
/* mouse is over gadget */
data->active++;
if (data->active == data->numlabels)
data->active = 0;
*msg->gpi_Termination = data->active;
retval = GMR_NOREUSE | GMR_VERIFY;
} else
/* mouse is not over gadget */
retval = GMR_NOREUSE;
/*
G(o)->Flags &= ~GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE };
DoMethodA(o, (Msg)&rmsg);
ReleaseGIRPort(rport);
}*/
} else if (msg->gpi_IEvent->ie_Code == IECODE_NOBUTTON)
{
struct gpHitTest htmsg =
{ GM_HITTEST, msg->gpi_GInfo,
{ msg->gpi_Mouse.X, msg->gpi_Mouse.Y },
}, *p_htmsg = &htmsg;
if (DoMethodA(o, (Msg)p_htmsg) != GMR_GADGETHIT)
{
if (EG(o)->Flags & GFLG_SELECTED)
{
G(o)->Flags &= ~GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
}
}
} else
{
if (!(EG(o)->Flags & GFLG_SELECTED))
{
EG(o)->Flags |= GFLG_SELECTED;
rport = ObtainGIRPort(msg->gpi_GInfo);
if (rport)
{
struct gpRender rmsg =
{ GM_RENDER, msg->gpi_GInfo, rport, GREDRAW_UPDATE }, *p_rmsg = &rmsg;
DoMethodA(o, (Msg)p_rmsg);
ReleaseGIRPort(rport);
}
}
}
} else if (msg->gpi_IEvent->ie_Code == MENUDOWN)
retval = GMR_REUSE;
}
return retval;
}
ULONG DoMethod(Object *obj, ULONG MethodID, ... )
{
return DoMethodA( obj, (Msg)&MethodID );
}
IPTR AslProp__OM_SET(Class * cl, Object * o, struct opSet * msg)
{
struct AslPropData *data;
const struct TagItem *tstate = msg->ops_AttrList;
struct TagItem *ti;
IPTR retval;
BOOL rerender = FALSE;
data = INST_DATA(cl, o);
while((ti = NextTagItem(&tstate)))
{
switch(ti->ti_Tag)
{
case ASLSC_DeltaFactor:
data->deltafactor = (LONG)ti->ti_Data;
break;
case ASLSC_Inc:
case ASLSC_Dec:
if (((LONG)ti->ti_Data > 0) &&
(((struct opUpdate *)msg)->opu_Flags & OPUF_INTERIM))
{
IPTR top, total, visible, newtop;
GetAttr(PGA_Top, o, &top);
GetAttr(PGA_Total, o, &total);
GetAttr(PGA_Visible, o, &visible);
newtop = top;
if (ti->ti_Data == ID_ARROWDEC)
{
if (newtop < data->deltafactor)
{
newtop = 0;
}
else
{
newtop -= data->deltafactor;
}
}
else
{
if (top <= total - visible - data->deltafactor)
{
newtop += data->deltafactor;
}
else
{
newtop = total - visible;
}
}
if (newtop != top)
{
struct TagItem set_tags [] =
{
{PGA_Top, newtop },
{TAG_DONE }
};
struct opSet ops;
ops.MethodID = OM_SET;
ops.ops_AttrList = set_tags;
ops.ops_GInfo = msg->ops_GInfo;
DoMethodA(o, (Msg)&ops);
/* rerender = TRUE; */
}
} /* if ((ti->ti_Data > 0) && (((struct opUpdate *)msg)->opu_Flags & OPUF_INTERIM)) */
} /* switch(ti->ti_Tag) */
} /* while((ti = NextTagItem(&tstate))) */
retval = DoSuperMethodA(cl, o, (Msg) msg);
if (rerender)
{
struct RastPort *rp;
rp = ObtainGIRPort(msg->ops_GInfo);
if (NULL != rp)
{
DoMethod(o, GM_RENDER, (IPTR) msg->ops_GInfo, (IPTR) rp, GREDRAW_UPDATE);
ReleaseGIRPort(rp);
}
}
return retval;
}
METHOD_NOINLINE(SWM_AppBase_RexxCmd, SWP_AppBase_RexxCmd *)
{
STRPTR cmd = ARG0(msg->Rx);
Object *Grp, *App = msg->App;
LONG x;
UBYTE TmpBuff[32];
// -- ONLINE --------------------------------------------------------------
if (!strcmp(cmd, "ONLINE")) {
DoMethod(NN_TCPList(idata), SWM_NTCPList_Online, SWV_NTCPList_Online_On);
goto OK;
}
// -- ISONLINE ------------------------------------------------------------
if (!strcmp(cmd, "ISONLINE")) {
set(App, MUIA_Application_RexxString, idata->Online ? "1" : "0");
goto OK;
}
// -- OFFLINE -------------------------------------------------------------
if (!strcmp(cmd, "OFFLINE")) {
DoMethod(NN_TCPList(idata), SWM_NTCPList_Online, SWV_NTCPList_Online_Off);
goto OK;
}
// -- OPENGROUP -----------------------------------------------------------
if (!strncmp(cmd, "OPENGROUP ", 10)) {
if (!(Grp = FindGroup(idata, cmd+10)))
goto Err;
DoMethod(Grp, SWM_NGroup_StartRead);
goto OK;
}
// -- ISGROUPOPEN ---------------------------------------------------------
if (!strncmp(cmd, "ISGROUPOPEN ", 12)) {
if (!(Grp = FindGroup(idata, cmd+12)))
goto Err;
set(App, MUIA_Application_RexxString,
SWGetUL(Grp, SWA_NGroup_ReaderOpen) ? "1" : "0");
goto OK;
}
// -- GROUPEXISTS ---------------------------------------------------------
if (!strncmp(cmd, "GROUPEXISTS ", 12)) {
set(App, MUIA_Application_RexxString, FindGroup(idata, cmd+12)?"1" :"0");
goto OK;
}
// -- GROUPCOUNT ----------------------------------------------------------
if (!strcmp(cmd, "GROUPCOUNT")) {
SW_MUIListLoop(idata->SWA_NList_L, x, Grp, TRUE);
sprintf(TmpBuff, "%ld", x);
set(App, MUIA_Application_RexxString, TmpBuff);
goto OK;
}
// -- GETGROUP ------------------------------------------------------------
if (!strncmp(cmd, "GETGROUP ", 9)) {
Grp = FindGroup(idata, cmd+9);
if (!Grp) goto Err;
set(App, MUIA_Application_RexxString, SWGetStr(Grp, SWA_NGroup_Name));
goto OK;
}
// -- CLOSEGROUP ----------------------------------------------------------
if (!strncmp(cmd, "CLOSEGROUP ", 11)) {
ULONG Save = TRUE, Force = FALSE;
STRPTR Params;
cmd += 11;
if (Params = strchr(cmd, ' ')) {
if (strstr(Params, "NOSAVE")) Save = FALSE;
if (strstr(Params, "FORCE")) Force = TRUE;
}
if (!(Grp = FindGroup(idata, cmd)))
goto Err;
DoMethod(Grp, SWM_NGroup_StopRead, Save, Force);
goto OK;
}
// -- UPDCOUNT ------------------------------------------------------------
if (!strncmp(cmd, "UPDCOUNT ", 9)) {
if (!(Grp = FindGroup(idata, cmd+9)))
goto Err;
DoMethod(Grp, SWM_NGroup_CheckStats);
goto OK;
}
// -- MARKREAD ------------------------------------------------------------
if (!strncmp(cmd, "MARKREAD ", 9)) {
if (!(Grp = FindGroup(idata, cmd+9)))
goto Err;
DoMethod(Grp, SWM_NGroup_GL_Mark, TRUE);
goto OK;
}
// -- MARKUNREAD ----------------------------------------------------------
if (!strncmp(cmd, "MARKUNREAD ", 11)) {
if (!(Grp = FindGroup(idata, cmd+11)))
goto Err;
DoMethod(Grp, SWM_NGroup_GL_Mark, FALSE);
goto OK;
}
// -- SORTGROUPS ----------------------------------------------------------
if (!strcmp(cmd, "SORTGROUPS")) {
DoMethod(o, MUIM_List_Sort);
goto OK;
}
// -- ADDGROUP ------------------------------------------------------------
if (!strncmp(cmd, "ADDGROUP ", 9)) {
if (FindGroup(idata, cmd+9)) goto Err;
if (!(Grp = MkNewGrp(o, idata, cmd+9))) goto Err;
DoMethod(o, MUIM_List_InsertSingle, Grp, MUIV_List_Insert_Bottom);
goto OK;
}
// -- OPENSERVERGROUPS ----------------------------------------------------
if (!strcmp(cmd, "OPENSERVERGROUPS")) {
DoMethod(o, SWM_NGroupList_OpenSGWin);
goto OK;
}
// -- CLOSESERVERGROUPS ---------------------------------------------------
if (!strcmp(cmd, "CLOSESERVERGROUPS")) {
DoMethod(o, SWM_NGroupList_CloseSGWin);
goto OK;
}
// -- CLEARSERVERGROUPS ---------------------------------------------------
if (!strcmp(cmd, "CLEARSERVERGROUPS")) {
if (!idata->SGWin) goto Err;
DoMethod(idata->SWA_NGroupList_SG_L, MUIM_List_Clear);
goto OK;
}
// -- FETCHSERVERGROUPS ---------------------------------------------------
if (!strncmp(cmd, "FETCHSERVERGROUPS", 17)) {
STRPTR Pat = "*";
if (!idata->SGWin) goto Err;
if (cmd[17] != '\0' && cmd[18] != '\0')
Pat = cmd + 18;
set(idata->s_FetchPat, MUIA_String_Contents, Pat);
DoMethod(o, SWM_NGroupList_FetchSG);
goto OK;
}
// -- SGFETCHPENDING ------------------------------------------------------
if (!strcmp(cmd, "SGFETCHPENDING")) {
set(App, MUIA_Application_RexxString, idata->GL_Srv ? "1" : "0");
goto OK;
}
// -- SERVERGROUPCOUNT ----------------------------------------------------
if (!strcmp(cmd, "SERVERGROUPCOUNT")) {
if (!idata->SGWin) goto Err;
sprintf(TmpBuff, "%ld", SWGetUL(idata->SWA_NGroupList_SG_L, MUIA_List_Entries));
set(App, MUIA_Application_RexxString, TmpBuff);
goto OK;
}
// -- GETSERVERGROUP ------------------------------------------------------
if (!strncmp(cmd, "GETSERVERGROUP ", 15)) {
if (!idata->SGWin) goto Err;
x = atol(cmd+15);
DoMethod(idata->SWA_NGroupList_SG_L, MUIM_List_GetEntry, x, &Grp);
if (!Grp) goto Err;
set(App, MUIA_Application_RexxString, Grp);
goto OK;
}
// -- group cmd -----------------------------------------------------------
if (!strncmp(cmd, "GROUPCMD ", 9)) {
STRPTR GrpCmd, OrigCmd;
UBYTE c;
cmd += 9;
GrpCmd = strchr(cmd, ' ');
if (SW_STRISNULL(GrpCmd) || GrpCmd[1] == '\0') goto Err;
c = *GrpCmd, *GrpCmd = '\0';
Grp = FindGroup(idata, cmd);
*GrpCmd = c;
if (!Grp) goto Err;
GrpCmd++;
OrigCmd = ARG0(msg->Rx);
ARG0(msg->Rx) = GrpCmd;
x = DoMethodA(Grp, msg);
ARG0(msg->Rx) = OrigCmd;
SWDB_RET(x);
}
SWDB_RET(SWV_AppBase_RexxNotFound);
OK:
*msg->rc = RC_OK;
SWDB_RET(SWV_AppBase_RexxFound);
Err:
*msg->rc = RC_ERROR;
SWDB_RET(SWV_AppBase_RexxFound);
} SDFT
/*************
* DESCRIPTION: Loads a image with the datatypes.
* INPUT: filename name of picture to load
* OUTPUT: FALSE if failed
*************/
BOOL IMAGE::LoadAsDatatype(char *filename)
{
struct Library *PictureDTBase;
BOOL pic24bit; // TRUE for new 24bit picture.datatype (V43)
Object *obj;
struct BitMapHeader *bmhd;
struct BitMap *bitmap, *tempbitmap;
int x,y;
SMALL_COLOR *c;
UBYTE *colreg, *buffer;
int color;
ULONG modeid;
struct DisplayInfo dispinfo;
UBYTE r,g,b;
struct RastPort rp, temprp;
struct gpBlitPixelArray arg;
DataTypesBase = OpenLibrary((unsigned char*)"datatypes.library", 39);
if(!DataTypesBase)
return FALSE;
// try to open the 24bit picture datatype
PictureDTBase = OpenLibrary("datatypes/picture.datatype", 43L);
if(PictureDTBase)
{
// we only need the picture.datatype to test the version, therefore
// close it now
CloseLibrary(PictureDTBase);
pic24bit = TRUE;
}
else
pic24bit = FALSE;
if(!pic24bit)
{
// no 24bit version available
// get the picture object
obj = NewDTObject(filename,
DTA_SourceType, DTST_FILE,
DTA_GroupID, GID_PICTURE,
PDTA_Remap, FALSE,
TAG_DONE);
if(!obj)
{
CloseLibrary(DataTypesBase);
return FALSE;
}
}
else
{
// get the picture object
obj = NewDTObject(filename,
DTA_SourceType, DTST_FILE,
DTA_GroupID, GID_PICTURE,
PDTA_Remap, FALSE,
PDTA_DestMode, MODE_V43,
TAG_DONE);
if(!obj)
{
CloseLibrary(DataTypesBase);
return FALSE;
}
}
// get the bitmap header
if(GetDTAttrs(obj,
PDTA_ColorRegisters, &colreg,
PDTA_BitMap, &bitmap,
PDTA_ModeID, &modeid,
PDTA_BitMapHeader, &bmhd,
TAG_DONE) != 4)
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
if(!bmhd || !bitmap)
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
width = bmhd->bmh_Width;
height = bmhd->bmh_Height;
if(!GetDisplayInfoData(NULL, (UBYTE*)&dispinfo, sizeof(struct DisplayInfo), DTAG_DISP, modeid))
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
colormap = (SMALL_COLOR*)malloc(sizeof(SMALL_COLOR)*width*height);
if(!colormap)
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
c = colormap;
if((bmhd->bmh_Depth > 8) && pic24bit)
{
// true color picture
buffer = (UBYTE*)AllocVec(3*width, MEMF_PUBLIC);
if(!buffer)
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
for(y=0; y<height; y++)
{
arg.MethodID = DTM_READPIXELARRAY;
arg.PixelArray = buffer;
arg.PixelArrayMode = RECTFMT_RGB;
arg.PixelArrayMod = 3*width;
arg.LeftEdge = 0;
arg.TopEdge = y;
arg.Width = width;
arg.Height = 1;
#ifdef __PPC__
ppc_DoMethodA(obj, (Msg)&arg);
#else
DoMethodA(obj, (Msg)&arg);
#endif
for(x=0; x<width; x++)
{
c->r = buffer[x*3];
c->g = buffer[x*3+1];
c->b = buffer[x*3+2];
c++;
}
}
FreeVec(buffer);
}
else
{
// normal picture
// planar to chunky conversion
InitRastPort(&rp);
rp.BitMap = bitmap;
tempbitmap = AllocBitMap(width, 1, bmhd->bmh_Depth, BMF_CLEAR, NULL);
if(!tempbitmap)
{
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
InitRastPort(&temprp);
temprp.BitMap = tempbitmap;
buffer = (UBYTE*)AllocVec((width+15)&(~15), MEMF_PUBLIC);
if(!buffer)
{
FreeBitMap(tempbitmap);
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return FALSE;
}
if(dispinfo.PropertyFlags & DIPF_IS_HAM)
{
// Simulate HAM mode
if(bmhd->bmh_Depth == 8)
{
// Super HAM
for(y=0; y<height; y++)
{
r = g = b = 0;
ReadPixelLine8(&rp, 0, y, width, buffer, &temprp);
for(x=0; x<width; x++)
{
color = buffer[x];
switch(color & 0xc0)
{
case 0x00: // Take it from color registers
color *= 3;
r = colreg[color];
g = colreg[color+1];
b = colreg[color+2];
break;
case 0x40: // modify blue
b = color << 2;
break;
case 0x80: // modify red
r = color << 2;
break;
case 0xc0: // modify green
g = color << 2;
break;
}
c->r = r;
c->g = g;
c->b = b;
c++;
}
}
}
else
{
// Normal HAM
for(y=0; y<height; y++)
{
r = g = b = 0;
ReadPixelLine8(&rp, 0, y, width, buffer, &temprp);
for(x=0; x<width; x++)
{
color = buffer[x];
switch(color & 0x30)
{
case 0x00: // Take it from color registers
color *= 3;
r = colreg[color];
g = colreg[color+1];
b = colreg[color+2];
break;
case 0x40: // modify blue
b = color << 4;
break;
case 0x80: // modify red
r = color << 4;
break;
case 0xc0: // modify green
g = color << 4;
break;
}
c->r = r;
c->g = g;
c->b = b;
c++;
}
}
}
}
else
{
for(y=0; y<height; y++)
{
ReadPixelLine8(&rp, 0, y, width, buffer, &temprp);
for(x=0; x<width; x++)
{
color = buffer[x];
color *= 3;
c->r = colreg[color];
c->g = colreg[color+1];
c->b = colreg[color+2];
c++;
}
}
}
FreeVec(buffer);
FreeBitMap(tempbitmap);
}
DisposeDTObject(obj);
CloseLibrary(DataTypesBase);
return TRUE;
}
IPTR ModelClass__OM_REMMEMBER(Class *cl, Object *o, struct opMember *msg)
{
STACKULONG method = OM_REMOVE;
return DoMethodA(msg->opam_Object, (Msg)&method);
}
extern "ASM" unsigned long __saveds _68kStub_ppc_DoMethodA__PUjP00(register __a0 long *args)
{
return DoMethodA((Object*)args[0], (Msg)args[1]);
}
// Add or remove fuel gauge
void lister_set_gauge(Lister *lister,BOOL refresh)
{
BOOL want,change=0;
// If lister is closed, problem is moot
if (!lister->window ||
(lister->more_flags&LISTERF_TITLEBARRED)) return;
// See if lister wants a gauge
want=lister_want_gauge(lister);
// Does lister have gauge and we don't want it to?
if (lister->gauge_gadget && !want)
{
// Remove the gadget
RemoveGList(lister->window,lister->gauge_gadget,1);
// Free gadget
DisposeObject((Object *)lister->gauge_gadget);
lister->gauge_gadget=0;
// Fix border width
lister->window->BorderLeft=lister->old_border_left;
// Free pens
lister_init_colour(lister,ENVCOL_GAUGE,TRUE);
// Set change flag
change=1;
}
// Or, do we not have it but want it?
else
if (!lister->gauge_gadget && want)
{
// Initialise pens
lister_init_colour(lister,ENVCOL_GAUGE,FALSE);
// Create gauge
if ((lister->gauge_gadget=(struct Gadget *)
NewObject(
0,
"dopusgaugeclass",
GA_ID,GAD_GAUGE,
GA_Left,0,
GA_Top,lister->window->BorderTop,
GA_Width,lister->window->BorderRight,
GA_RelHeight,-lister->window->BorderTop-lister->window->BorderBottom+3,
GA_LeftBorder,TRUE,
DGG_FillPen,lister->lst_Colours[ENVCOL_GAUGE].cr_Pen[0],
DGG_FillPenAlert,lister->lst_Colours[ENVCOL_GAUGE].cr_Pen[1],
TAG_END)))
{
// Fix border width
lister->window->BorderLeft=lister->window->BorderRight;
// Add gauge to window after parent button
AddGList(lister->window,lister->gauge_gadget,-1,1,0);
RefreshGList(lister->gauge_gadget,lister->window,0,1);
// Set change flag
change=1;
}
// Failed
else
{
// Free pens
lister_init_colour(lister,ENVCOL_GAUGE,TRUE);
}
}
// Changed?
if (change)
{
// Fix left border related things
lister->window->GZZWidth=lister->window->Width-lister->window->BorderLeft-lister->window->BorderRight;
lister->parent_button.Width=lister->window->BorderLeft;
}
// Changed and need to refresh?
if (change && refresh)
{
// Initialise and refresh
lister_init_display(lister);
lister_refresh(lister,LREFRESH_FULL|LREFRESH_FULL_ICON);
// If the path field is added, refresh it
if (lister->path_field && lister->flags&LISTERF_PATH_FIELD)
{
struct gpResize resize;
// Fill out resize packet
resize.MethodID=GM_RESIZE;
resize.gpr_GInfo=0;
resize.gpr_RPort=0;
resize.gpr_Size.Left=lister->window->BorderLeft;
resize.gpr_Size.Top=-(lister->window->BorderBottom+FIELD_FONT->tf_YSize+4);
resize.gpr_Size.Width=-(lister->window->BorderLeft+lister->window->BorderRight);
resize.gpr_Size.Height=FIELD_FONT->tf_YSize+4;
resize.gpr_Redraw=0;
resize.gpr_Window=lister->window;
resize.gpr_Requester=0;
// Tell string gadget to resize
DoMethodA((Object *)lister->path_field,(Msg)&resize);
// Erase behind path field
SetAPen(lister->window->RPort,3);
RectFill(
lister->window->RPort,
lister->window->BorderLeft,
lister->window->Height+lister->path_field->TopEdge-2,
lister->window->Width-lister->window->BorderRight-1,
lister->window->Height+lister->path_field->TopEdge+lister->path_field->Height+1);
// Refresh path field
RefreshGList(lister->path_field,lister->window,0,1);
}
// Refresh the window frame
RefreshWindowFrame(lister->window);
// Do we have the gauge?
if (lister->gauge_gadget)
{
// Refresh title and gauge
lister_show_name(lister);
}
}
}
