STATIC ULONG MultiString_Dispose(struct IClass *cl, Object *obj, Msg msg)
{
struct MultiString_Data *data = (struct MultiString_Data*)INST_DATA(cl,obj);
free(data->contents_array);
return DoSuperMethodA(cl,obj,msg);
}
STATIC ULONG MultiString_Set(struct IClass *cl,Object *group, struct opSet *msg, int construct)
{
struct MultiString_Data *data = (struct MultiString_Data*)INST_DATA(cl, group);
struct TagItem *ti = FindTagItem(MUIA_MultiString_ContentsArray, msg->ops_AttrList);
if (ti || construct)
{
struct object_node *obj = (struct object_node*)list_first(&data->object_list);
static const char *dummy_array[] = {"",NULL};
const char **array = ti?((const char**)ti->ti_Data):dummy_array;
int i = 0;
int group_changed = 0;
if (!array || !*array) array = dummy_array;
while (obj)
{
struct object_node *next_obj = (struct object_node*)node_next(&obj->node);
if (array[i])
{
set(obj->obj, MUIA_UTF8String_Contents, array[i]);
i++;
} else
{
if (!group_changed)
{
group_changed = 1;
DoMethod(group, MUIM_Group_InitChange);
}
DoMethod(group,OM_REMMEMBER, (ULONG)obj->obj);
MUI_DisposeObject(obj->obj);
node_remove(&obj->node);
}
obj = next_obj;
}
if (array[i])
{
struct MUIP_MultiString_AddStringField asf_msg;
asf_msg.MethodID = MUIM_MultiString_AddStringField;
if (!group_changed)
{
group_changed = 1;
DoMethod(group,MUIM_Group_InitChange);
}
for (;array[i];i++)
{
asf_msg.contents = array[i];
MultiString_AddStringField(cl, group, &asf_msg, (struct object_node*)list_last(&data->object_list));
}
}
if (group_changed)
DoMethod(group,MUIM_Group_ExitChange);
}
if (!construct) return DoSuperMethodA(cl,group,(Msg)msg);
return 0;
}
IPTR PointerClass__OM_NEW(Class *cl, Object *o, struct opSet *msg)
{
struct IntuitionBase *IntuitionBase = (struct IntuitionBase *)cl->cl_UserData;
struct GfxBase *GfxBase = GetPrivIBase(IntuitionBase)->GfxBase;
struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
OOP_MethodID HiddBitMapBase = ((struct IntIntuitionBase *)IntuitionBase)->ib_HiddBitMapBase;
D(kprintf("PointerClass: OM_NEW\n"));
if (cl)
{
struct TagItem *tags = msg->ops_AttrList;
struct BitMap *bitmap = (struct BitMap *)GetTagData(POINTERA_BitMap, (IPTR)NULL, tags);
/* Hack: we accept and pass on to AllocSpriteDataA() these attributes in order to
provide code reuse. Applications should not rely on it, this is private! */
BOOL oldbitmap = GetTagData(SPRITEA_OldDataFormat, FALSE, tags);
IPTR width = GetTagData(SPRITEA_Width, 16, tags);
IPTR height = GetTagData(SPRITEA_OutputHeight, 0, tags);
//ULONG xResolution = GetTagData(POINTERA_XResolution, POINTERXRESN_DEFAULT, tags);
//ULONG yResolution = GetTagData(POINTERA_YResolution, POINTERYRESN_DEFAULT, tags);
D(
{
struct TagItem *tagscan=tags;
while(tagscan->ti_Tag != 0)
{
kprintf(" 0x%08lx, %08lx\n",tagscan->ti_Tag,tagscan->ti_Data);
tagscan++;
}
}
)
if (1) // bitmap
{
struct TagItem spritetags[] =
{
{SPRITEA_Width , 0 },
{SPRITEA_OutputHeight , 0 },
{SPRITEA_OldDataFormat, TRUE},
{TAG_DONE }
};
struct ExtSprite *sprite;
struct BitMap *spritedata=(struct BitMap *)bitmap;
if(spritedata != NULL)
{
if (oldbitmap) {
spritetags[0].ti_Data = width;
spritetags[1].ti_Data = height;
} else {
spritetags[0].ti_Data = GetTagData(POINTERA_WordWidth, ((GetBitMapAttr(bitmap, BMA_WIDTH) + 15) & ~15)>>4, tags) * 16;
spritetags[1].ti_Tag = TAG_DONE;
}
}
else
{
D(kprintf("PointerClass: OM_NEW called without bitmap, using dummy sprite !\n"));
spritetags[0].ti_Data = 16;
spritetags[1].ti_Data = 1;
bitmap = (struct BitMap *)posctldata;
}
sprite = AllocSpriteDataA(bitmap, spritetags);
D(kprintf("PointerClass: extSprite 0x%lx\n",sprite));
D(kprintf("MoveSprite data 0x%lx, height %ld, x %ld, y %ld, num %ld, wordwidth, 0x%lx, flags 0x%lx\n",
sprite->es_SimpleSprite.posctldata,
sprite->es_SimpleSprite.height,
sprite->es_SimpleSprite.x,
sprite->es_SimpleSprite.y,
sprite->es_SimpleSprite.num,
sprite->es_wordwidth,
sprite->es_flags));
if (sprite)
{
struct SharedPointer *shared;
/* If our pointer doesn't already have a user-supplied colormap, we attach it here.
This makes the pointer to always have its own colors on hi- and truecolor screens.
In addition it gets an alpha channel.
Note that this relies on the fact that AllocSpriteDataA() always generates HIDD bitmap
in sprite->es_BitMap. */
if (!HIDD_BM_COLMAP(sprite->es_BitMap)) {
ULONG i;
HIDDT_Color col[DEF_POINTER_DEPTH] = {{0}};
struct Color32 *q = GetPrivIBase(IntuitionBase)->Colors;
for (i = 1; i < DEF_POINTER_DEPTH; i++ ) {
col[i].red = q[i + 7].red >> 16;
col[i].green = q[i + 7].green >> 16;
col[i].blue = q[i + 7].blue >> 16;
col[i].alpha = GetPrivIBase(IntuitionBase)->PointerAlpha;
}
HIDD_BM_SetColors(HIDD_BM_OBJ(sprite->es_BitMap), col, 0, DEF_POINTER_DEPTH);
}
shared = CreateSharedPointer(sprite,
GetTagData(POINTERA_XOffset, 0, tags),
GetTagData(POINTERA_YOffset, 0, tags),
IntuitionBase);
if (shared)
{
o = (Object *)DoSuperMethodA(cl, o, (Msg)msg);
if (o)
{
struct PointerData *data = INST_DATA(cl, o);
data->shared_pointer = shared;
//data->xRes = xResolution;
//data->yRes = yResolution;
D(kprintf("PointerClass: set extSprite 0x%lx and XOffset %ld YOffset %ld\n",shared->sprite,shared->xoffset,shared->yoffset));
}
else
{
D(kprintf("PointerClass: free sprite\n"));
ReleaseSharedPointer(shared, IntuitionBase);
}
}
else
{
D(kprintf("PointerClass: free sprite\n"));
FreeSpriteData(sprite);
}
}
/* /// "CfgListDispatcher()" */
AROS_UFH3(IPTR, CfgListDispatcher,
AROS_UFHA(struct IClass *, cl, A0),
AROS_UFHA(Object *, obj, A2),
AROS_UFHA(Msg, msg, A1))
{
AROS_USERFUNC_INIT
// There should never be an uninitialized pointer, but just in case, try to get an mungwall hit if so.
struct CfgListData *data = (struct CfgListData *) 0xABADCAFE;
// on OM_NEW the obj pointer will be void, so don't try to get the data base in this case.
if(msg->MethodID != OM_NEW) data = INST_DATA(cl,obj);
switch(msg->MethodID)
{
case OM_NEW:
if(!(obj = (Object *) DoSuperMethodA(cl,obj,msg)))
return(0);
return((IPTR) obj);
case MUIM_DragBegin:
data->cl_Dragging = TRUE;
break;
case MUIM_DragFinish:
data->cl_Dragging = FALSE;
break;
case MUIM_DragQuery:
{
struct MUI_List_TestPos_Result tpr;
struct Window *win;
win = _window(obj);
if(!win)
{
return(MUIV_DragQuery_Refuse);
}
DoMethod(obj, MUIM_List_TestPos, win->MouseX, win->MouseY, &tpr);
return((IPTR) (CheckDragAccept(obj, tpr.entry) ? MUIV_DragQuery_Accept : MUIV_DragQuery_Refuse));
}
#ifndef MUI_LPR_FULLDROP
#define MUI_LPR_FULLDROP (1<<15)
#endif
case MUIM_List_TestPos:
{
struct MUIP_List_TestPos *tpmsg = (struct MUIP_List_TestPos *) msg;
struct MUI_List_TestPos_Result *res = tpmsg->res;
IPTR rc;
rc = DoSuperMethodA(cl, obj, msg);
if(data->cl_Dragging && (res->entry != -1))
{
if(!CheckDragAccept(obj, res->entry))
{
res->entry = -1; // illegal combination
} else {
res->flags |= MUI_LPR_FULLDROP;
}
}
return(rc);
}
case MUIM_DragDrop:
{
//struct MUIP_DragDrop *ddmsg = (struct MUIP_DragDrop *) msg;
struct MUI_List_TestPos_Result tpr;
struct Window *win;
win = _window(obj);
if(!win)
{
return(FALSE);
}
DoMethod(obj, MUIM_List_TestPos, win->MouseX, win->MouseY, &tpr);
//DoMethod(obj, MUIM_List_TestPos, ddmsg->x, ddmsg->y, &tpr);
if(CheckDragAccept(obj, tpr.entry))
{
ApplyDragAction(obj, tpr.entry);
} else {
MUI_RequestA(_app(obj), _win(obj), 0, NULL, "Oops!",
"Sorry, drag'n drop operation to\n"
"that target is not supported.", NULL);
return(FALSE);
}
return(TRUE);
}
}
return(DoSuperMethodA(cl,obj,msg));
AROS_USERFUNC_EXIT
}
IPTR GTCheckBox__OM_SET(Class *cl, struct Gadget *g, struct opSet *msg)
{
struct CheckBoxData *data;
struct TagItem *tag;
const struct TagItem *taglist = msg->ops_AttrList;
struct RastPort *rp;
IPTR retval = FALSE;
data = INST_DATA(cl, g);
if (data->flags & CF_CustomImage)
{
tag = FindTagItem(GA_Image, taglist);
if (tag)
{
DisposeObject(g->GadgetRender);
g->GadgetRender = NULL;
data->flags &= ~CF_CustomImage;
}
}
if (msg->MethodID != OM_NEW)
retval = DoSuperMethodA(cl, (Object *)g, (Msg)msg);
while ((tag = NextTagItem(&taglist)))
{
switch (tag->ti_Tag)
{
case GA_Disabled:
retval = TRUE;
break;
case GA_DrawInfo:
if (msg->MethodID == OM_NEW)
data->dri = (struct DrawInfo *) tag->ti_Data;
break;
case GA_Image:
case GA_SelectRender:
retval = TRUE;
break;
case GA_LabelPlace:
if (msg->MethodID == OM_NEW)
data->labelplace = (LONG)tag->ti_Data;
break;
case GTCB_Checked:
if (tag->ti_Data)
g->Flags |= GFLG_SELECTED;
else
g->Flags &= ~GFLG_SELECTED;
retval = TRUE;
break;
} /* switch (tag->ti_Tag) */
} /* while ((tag = NextTagItem(&taglist))) */
if (g->Width == 0)
g->Width = CHECKBOX_WIDTH;
if (g->Height == 0)
g->Height = CHECKBOX_HEIGHT;
/* Redraw ourself? */
if ((retval) && (msg->MethodID != OM_NEW) &&
((msg->MethodID != OM_UPDATE) || (OCLASS(g) == cl)))
{
rp = ObtainGIRPort(msg->ops_GInfo);
if (rp)
{
DoMethod((Object *)g, GM_RENDER, (IPTR) msg->ops_GInfo, (IPTR) rp, GREDRAW_UPDATE);
ReleaseGIRPort(rp);
retval = FALSE;
}
}
return retval;
}
IPTR AboutWindow__MUIM_Window_Setup
(
Class *CLASS, Object *self, Msg message
)
{
struct AboutWindow_DATA *data = INST_DATA(CLASS, self);
struct Catalog *catalog = data->awd_Catalog;
STRPTR string = NULL;
if (!DoSuperMethodA(CLASS, self, message)) return FALSE;
/*= Setup window title =================================================*/
{
STRPTR buffer = NULL;
ULONG length = 0;
string = data->awd_Title;
if (string == NULL)
{
GET(self, MUIA_AboutWindow_Title, &string);
if (string != IGNORE)
{
if (string == NULL)
{
GET(_app(self), MUIA_Application_Title, &string);
}
if (string != NULL)
{
length = strlen(string) + strlen(_(MSG_ABOUT)) + 2; /* space + newline */
buffer = AllocVec(length, MEMF_ANY);
if (buffer != NULL)
{
buffer[0] = '\0';
strlcat(buffer, _(MSG_ABOUT), length);
strlcat(buffer, " ", length);
strlcat(buffer, string, length);
set(self, MUIA_Window_Title, buffer);
FreeVec(buffer);
}
}
}
}
}
/*= Setup image ========================================================*/
if (data->awd_ImageObject == NULL)
{
DoMethod(data->awd_RootGroup, OM_REMMEMBER, (IPTR) data->awd_ImageGroup);
}
/*= Setup version ======================================================*/
/*
The version string will have the format:
MUIX_B"<title>"MUIX_N" <version> (<date>) [<extra>]"
*/
{
STRPTR title = data->awd_Title,
versionNumber = data->awd_VersionNumber,
versionDate = data->awd_VersionDate,
versionExtra = data->awd_VersionExtra,
buffer = NULL;
ULONG length = 0;
/*- Setup default values -------------------------------------------*/
if (title == NULL)
{
GET(_app(self), MUIA_Application_Title, &title);
}
if (versionNumber == NULL)
{
GET(_app(self), MUIA_Application_Version_Number, &versionNumber);
}
if (versionDate == NULL)
{
GET(_app(self), MUIA_Application_Version_Date, &versionDate);
}
if (versionExtra == NULL)
{
GET(_app(self), MUIA_Application_Version_Extra, &versionExtra);
}
/* Simplify later checks a little */
if (title == IGNORE) title = NULL;
if (versionNumber == IGNORE) versionNumber = NULL;
if (versionDate == IGNORE) versionDate = NULL;
if (versionExtra == IGNORE) versionExtra = NULL;
/*- Calculate length -----------------------------------------------*/
if (title != NULL)
{
length += strlen(MUIX_B) + strlen(title) + strlen(MUIX_N) + 1;
}
if (versionNumber != NULL)
{
length += 1 /* space */ + strlen(versionNumber);
}
if (versionDate != NULL)
{
length += 1 /* space */ + 1 /* ( */ + strlen(versionDate) + 1 /* ) */;
}
if (versionExtra != NULL)
{
length += 1 /* space */ + 1 /* [ */ + strlen(versionExtra) + 1 /* ] */;
}
/*- Setup version object -------------------------------------------*/
if (length > 0)
{
/*- Allocate memory --------------------------------------------*/
buffer = AllocVec(length, MEMF_ANY);
if (buffer != NULL)
{
buffer[0] = '\0';
/*- Generate text ------------------------------------------*/
if (title != NULL)
{
strlcat(buffer, MUIX_B, length);
strlcat(buffer, title, length);
strlcat(buffer, MUIX_N, length);
}
if (versionNumber != NULL)
{
strlcat(buffer, " ", length);
strlcat(buffer, versionNumber, length);
}
if (versionDate != NULL)
{
strlcat(buffer, " (", length);
strlcat(buffer, versionDate, length);
strlcat(buffer, ")", length);
}
if (versionExtra != NULL)
{
strlcat(buffer, " [", length);
strlcat(buffer, versionExtra, length);
strlcat(buffer, "]", length);
}
set(data->awd_VersionObject, MUIA_Text_Contents, buffer);
FreeVec(buffer); /* don't need it anymore */
}
else
{
DoMethod
(
data->awd_RootGroup, OM_REMMEMBER, (IPTR) data->awd_VersionObject
);
}
}
}
/*= Setup copyright ====================================================*/
if (data->awd_Copyright == NULL)
{
GET(_app(self), MUIA_Application_Copyright, &data->awd_Copyright);
}
if (data->awd_Copyright != IGNORE && data->awd_Copyright != NULL)
{
SET(data->awd_CopyrightObject, MUIA_Text_Contents, data->awd_Copyright);
}
else
{
DoMethod(data->awd_RootGroup, OM_REMMEMBER, (IPTR) data->awd_CopyrightObject);
}
/*= Setup description ==================================================*/
if (data->awd_Description == NULL)
{
GET(_app(self), MUIA_Application_Description, &data->awd_Description);
}
if (data->awd_Description != IGNORE && data->awd_Description != NULL)
{
SET
(
data->awd_DescriptionObject,
MUIA_Text_Contents, data->awd_Description
);
}
else
{
DoMethod
(
data->awd_RootGroup, OM_REMMEMBER, (IPTR) data->awd_DescriptionGroup
);
}
/* We no longer need to know whether to IGNORE or not */
if (data->awd_Title == IGNORE) data->awd_Title = NULL;
if (data->awd_VersionNumber == IGNORE) data->awd_VersionNumber = NULL;
if (data->awd_VersionDate == IGNORE) data->awd_VersionDate = NULL;
if (data->awd_VersionExtra == IGNORE) data->awd_VersionExtra = NULL;
if (data->awd_Copyright == IGNORE) data->awd_Copyright = NULL;
if (data->awd_Description == IGNORE) data->awd_Description = NULL;
return TRUE;
}
IPTR Get(struct IClass *cl, Object *obj, struct opGet *msg)
{
struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
IPTR ti_Data;
switch(msg->opg_AttrID)
{
case MUIA_Font:
ti_Data = (IPTR)(data->Font ? data->Font : muiAreaData(obj)->mad_Font);
break;
case MUIA_ControlChar:
ti_Data = (IPTR)data->CtrlChar;
break;
case MUIA_String_AttachedList:
ti_Data = (IPTR)data->ForwardObject;
break;
case MUIA_String_BufferPos:
ti_Data = (IPTR)data->BufferPos;
break;
case MUIA_String_Acknowledge:
case MUIA_String_Contents:
ti_Data = (IPTR)data->Contents;
break;
case MUIA_String_DisplayPos:
ti_Data = (IPTR)data->DisplayPos;
break;
case MUIA_String_Format:
ti_Data = (IPTR)data->Alignment;
break;
case MUIA_String_Integer:
StrToLong(data->Contents, (ULONG *)&ti_Data);
break;
case MUIA_String_MaxLen:
ti_Data = (IPTR)data->MaxLength;
break;
case MUIA_String_Reject:
ti_Data = (IPTR)data->Reject;
break;
case MUIA_String_Secret:
ti_Data = isFlagSet(data->Flags, FLG_Secret) ? TRUE : FALSE;
break;
case MUIA_String_EditHook:
ti_Data = (IPTR)data->EditHook;
break;
case MUIA_String_AdvanceOnCR:
ti_Data = isFlagSet(data->Flags, FLG_AdvanceOnCr) ? TRUE : FALSE;
break;
case MUIA_BetterString_KeyUpFocus:
ti_Data = (IPTR)data->KeyUpFocus;
break;
case MUIA_BetterString_KeyDownFocus:
ti_Data = (IPTR)data->KeyDownFocus;
break;
case MUIA_BetterString_SelectSize:
ti_Data = isFlagSet(data->Flags, FLG_BlockEnabled) ? data->BlockStop-data->BlockStart : 0;
break;
case MUIA_BetterString_StayActive:
ti_Data = isFlagSet(data->Flags, FLG_StayActive) ? TRUE : FALSE;
break;
case MUIA_BetterString_NoInput:
ti_Data = isFlagSet(data->Flags, FLG_NoInput) ? TRUE : FALSE;
break;
case MUIA_BetterString_InactiveContents:
ti_Data = (IPTR)data->InactiveContents;
break;
case MUIA_BetterString_NoShortcuts:
ti_Data = isFlagSet(data->Flags, FLG_NoShortcuts) ? TRUE : FALSE;
break;
case MUIA_BetterString_SelectOnActive:
{
if((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_ForceSelectOff)) ||
isFlagSet(data->Flags, FLG_ForceSelectOn))
{
ti_Data = TRUE;
}
else
ti_Data = FALSE;
}
break;
case MUIA_Version:
ti_Data = LIB_VERSION;
break;
case MUIA_Revision:
ti_Data = LIB_REVISION;
break;
default:
return DoSuperMethodA(cl, obj, (Msg)msg);
break;
}
*msg->opg_Storage = ti_Data;
return TRUE;
}
