OOP_Object *CM__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
struct Library *UtilityBase = CSD(cl)->cs_UtilityBase;
struct Library *OOPBase = CSD(cl)->cs_OOPBase;
struct colormap_data *data;
ULONG numentries;
struct TagItem *tag, *tstate;
BOOL ok = FALSE;
EnterFunc(bug("ColorMap::New()\n"));
numentries = 256;
for (tstate = msg->attrList; (tag = NextTagItem(&tstate)); )
{
ULONG idx;
if (IS_COLORMAP_ATTR(tag->ti_Tag, idx))
{
switch (idx)
{
case aoHidd_ColorMap_NumEntries:
numentries = tag->ti_Data;
if (numentries > 256 || numentries < 0)
{
D(bug("!!! ILLEGAL value for NumEntries in ColorMap::New()\n"));
}
break;
} /* switch */
}
}
/* Create the object */
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (NULL == o)
return NULL;
data = OOP_INST_DATA(cl, o);
data->clut.entries = numentries;
data->clut.colors = AllocMem(sizeof (HIDDT_Color) * data->clut.entries, MEMF_CLEAR);
if (NULL != data->clut.colors)
{
ok = TRUE;
}
if (!ok)
{
ULONG dispose_mid;
dispose_mid = OOP_GetMethodID(IID_Root, moRoot_Dispose);
OOP_CoerceMethod(cl, o, (OOP_Msg)&dispose_mid);
o = NULL;
}
ReturnPtr("ColorMap::New", OOP_Object *, o);
}
/**************************************************************************
OM_SET
**************************************************************************/
static ULONG Numericbutton__OM_SET(struct IClass *cl, Object * obj, struct opSet *msg)
{
struct Numericbutton_DATA *data = INST_DATA(cl, obj);
const struct TagItem *tags;
struct TagItem *tag;
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
{
switch (tag->ti_Tag)
{
case MUIA_Numeric_Max:
if (tag->ti_Data != XGET(obj, MUIA_Numeric_Max))
data->needs_to_recalculate_sizes = TRUE;
break;
case MUIA_Numeric_Min:
if (tag->ti_Data != XGET(obj, MUIA_Numeric_Min))
data->needs_to_recalculate_sizes = TRUE;
break;
case MUIA_Numeric_Format:
if (tag->ti_Data != XGET(obj, MUIA_Numeric_Format))
data->needs_to_recalculate_sizes = TRUE;
break;
}
}
return DoSuperMethodA(cl, obj, (Msg)msg);
}
IPTR fillrect_set(Class *cl, Object *obj, struct opSet *msg)
{
const struct TagItem *tstate = msg->ops_AttrList;
struct TagItem *tag;
struct FillRectData *data = INST_DATA(cl, obj);
IPTR retval = 0;
while((tag = NextTagItem(&tstate)))
{
switch(tag->ti_Tag)
{
case IA_APattern:
((struct Image *)obj)->ImageData = (APTR)tag->ti_Data;
retval = 1;
break;
case IA_APatSize:
data->apatsize = (WORD)tag->ti_Data;
retval = 1;
break;
case IA_Mode:
data->mode = (WORD)tag->ti_Data;
retval = 1;
break;
}
}
return retval;
}
IPTR _om_set(Class *cl, struct Image *im, struct TagItem *tags)
{
struct TagItem *tstate = tags;
struct TagItem *tag;
IPTR tidata;
BOOL unsupported = FALSE;
while ((tag = NextTagItem((const struct TagItem **)&tstate)))
{
tidata = tag->ti_Data;
switch (tag->ti_Tag)
{
case IA_Left:
im->LeftEdge = (WORD) tidata;
break;
case IA_Top:
im->TopEdge = (WORD) tidata;
break;
case IA_Width:
im->Width = (WORD) tidata;
break;
case IA_Height:
im->Height = (WORD) tidata;
break;
case IA_FGPen:
im->PlanePick = (WORD) tidata;
break;
case IA_BGPen:
im->PlaneOnOff = (WORD) tidata;
break;
case IA_Data:
im->ImageData = (UWORD *) tidata;
break;
default:
unsupported = TRUE;
break;
} /* switch (Tag) */
} /* while (Tag) */
/*
* If all attributes were supported and there is no retval yet,
* set retval to 1.
*/
if (!unsupported)
return (IPTR)1;
else
return (IPTR)0;
}
/**************************************************************************
OM_NEW
**************************************************************************/
IPTR Numeric__OM_NEW(struct IClass *cl, Object * obj, struct opSet *msg)
{
struct MUI_NumericData *data;
struct TagItem *tags, *tag;
BOOL value_set = FALSE;
obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
if (!obj)
return 0;
data = INST_DATA(cl, obj);
data->format = "%ld";
data->max = 100;
data->min = 0;
data->flags = 0;
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags));)
{
switch (tag->ti_Tag)
{
case MUIA_Numeric_CheckAllSizes:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_CHECKALLSIZES);
break;
case MUIA_Numeric_Default:
/* data->defvalue = CLAMP(tag->ti_Data, data->min, data->max); */
data->defvalue = tag->ti_Data;
break;
case MUIA_Numeric_Format:
data->format = (STRPTR)tag->ti_Data;
break;
case MUIA_Numeric_Max:
data->max = tag->ti_Data;
break;
case MUIA_Numeric_Min:
data->min = tag->ti_Data;
break;
case MUIA_Numeric_Reverse:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVERSE);
break;
case MUIA_Numeric_RevLeftRight:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVLEFTRIGHT);
break;
case MUIA_Numeric_RevUpDown:
_handle_bool_tag(data->flags, tag->ti_Data, NUMERIC_REVUPDOWN);
break;
case MUIA_Numeric_Value:
value_set = TRUE;
data->value = (LONG)tag->ti_Data;
break;
}
}
data->value = CLAMP(value_set ? data->value : data->defvalue, data->min, data->max);
return (IPTR)obj;
}
// Allocate an ARexx message, and set arguments and stem values automatically
struct RexxMsg *LIBFUNC L_BuildRexxMsgEx(
REG(a0, struct MsgPort *port),
REG(a1, UBYTE *extension),
REG(d0, UBYTE *host),
REG(a2, struct TagItem *tags))
{
struct RexxMsg *msg;
struct TagItem *tag,*tstate;
char *varname=0;
// Create message
if (!(msg=L_CreateRexxMsgEx(port,extension,host)))
return 0;
// Go through tags
tstate=tags;
while ((tag=NextTagItem(&tstate)))
{
// Argument string?
if (tag->ti_Tag>=RexxTag_Arg0 &&
tag->ti_Tag<=RexxTag_Arg15)
{
short arg;
// Get argument number
arg=tag->ti_Tag-RexxTag_Arg0;
// Create argument string
msg->rm_Args[arg]=CreateArgstring((CONST STRPTR)tag->ti_Data,strlen((char *)tag->ti_Data)+1);
}
// Variable name?
else
if (tag->ti_Tag==RexxTag_VarName)
{
// Store pointer to variable name
varname=(char *)tag->ti_Data;
}
// Variable value?
else
if (tag->ti_Tag==RexxTag_VarValue)
{
// Got valid name pointer?
if (varname)
{
// Set value
L_SetRexxVarEx(msg,varname,(char *)tag->ti_Data,-1);
varname=0;
}
}
}
// Return message
return msg;
}
int parseerrortags(struct TagItem *tags, int err)
{
struct TagItem *ti;
while((ti=NextTagItem(&tags))) {
if(ti->ti_Tag == XPK_GetError)
XpkFault(err, 0, (char *) ti->ti_Data, XPKERRMSGSIZE);
}
return err;
}
static void
PrintTagList(struct TagItem *tags)
{
struct TagItem *tstate;
struct TagItem *tag;
if( tags == NULL )
{
KPrintF( "No taglist!\n" );
}
else
{
tstate = tags;
while( ( tag = NextTagItem( &tstate ) ) )
{
switch( GetDatatype( tag->ti_Tag ) )
{
case dt_Hex:
KPrintF( "\n %30s, 0x%08lx,",
(ULONG) GetTagName( tag->ti_Tag ), tag->ti_Data );
break;
case dt_Dec:
KPrintF( "\n %30s, %ld,",
(ULONG) GetTagName( tag->ti_Tag ), tag->ti_Data );
break;
case dt_Boolean:
KPrintF( "\n %30s, %s,",
(ULONG) GetTagName( tag->ti_Tag ),
tag->ti_Data ? (ULONG) "TRUE" : (ULONG) "FALSE" );
break;
case dt_String:
KPrintF( "\n %30s, %s,",
(ULONG) GetTagName( tag->ti_Tag ),
tag->ti_Data != 0 ? tag->ti_Data : (ULONG) "(null)" );
break;
case dt_Fixed:
{
KPrintF( "\n %30s, %ld.%ld,",
(ULONG) GetTagName( tag->ti_Tag ),
tag->ti_Data >> 16,
( ( tag->ti_Data & 0xffff ) * 1000 ) >> 16 );
break;
}
}
}
KPrintF("\n TAG_DONE)");
}
}
/*** Methods ****************************************************************/
Object *IconImage__OM_NEW
(
Class *CLASS, Object *self, struct opSet *message
)
{
struct IconImage_DATA *data = NULL;
const struct TagItem *tstate = message->ops_AttrList;
struct TagItem *tag = NULL;
struct DiskObject *diskObject = NULL;
CONST_STRPTR file = NULL;
while ((tag = NextTagItem(&tstate)) != NULL)
{
switch (tag->ti_Tag)
{
case MUIA_IconImage_DiskObject:
diskObject = (struct DiskObject *) tag->ti_Data;
break;
case MUIA_IconImage_File:
file = (CONST_STRPTR) tag->ti_Data;
break;
}
}
if (diskObject == NULL && file == NULL) goto error; /* Must specify one */
if (diskObject != NULL && file != NULL) goto error; /* Cannot specify both */
if (diskObject == NULL && file != NULL)
{
diskObject = GetDiskObjectNew(file);
if (diskObject == NULL) goto error;
}
self = (Object *) DoSuperNewTags
(
CLASS, self, NULL,
MUIA_FillArea, FALSE,
TAG_MORE, (IPTR) message->ops_AttrList
);
if (self == NULL) goto error;
data = INST_DATA(CLASS, self);
data->iid_DiskObject = diskObject;
return self;
error:
return NULL;
}
/******* SerialUnit::New() ***********************************/
static OOP_Object *serialunit_new(OOP_Class *cl, OOP_Object *obj, struct pRoot_New *msg)
{
struct HIDDSerialUnitData * data;
struct TagItem *tag, *tstate;
ULONG unitnum = 0;
EnterFunc(bug("SerialUnit::New()\n"));
tstate = msg->attrList;
while ((tag = NextTagItem(&tstate))) {
ULONG idx;
#define csd CSD(cl->UserData)
if (IS_HIDDSERIALUNIT_ATTR(tag->ti_Tag, idx)) {
#undef csd
switch (idx)
{
case aoHidd_SerialUnit_Unit:
unitnum = (ULONG)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
obj = (OOP_Object *)OOP_DoSuperMethod(cl, obj, (OOP_Msg)msg);
if (obj) {
WORD dummy;
data = OOP_INST_DATA(cl, obj);
data->baseaddr = bases[unitnum];
data->datalength = 8;
data->parity = FALSE;
data->baudrate = 0; /* will be initialize in set_baudrate() */
data->unitnum = unitnum;
CSD(cl->UserData)->units[data->unitnum] = data;
D(bug("Unit %d at 0x0%x\n", data->unitnum, data->baseaddr));
/* Init UART - See 14-10 of dragonball documentation */
serial_out_w(data,USTCNT, UEN | RXEN);
dummy = RREG_W(URX1);
serial_out_w(data, USTCNT, (get_ustcnt(data) | UEN | RXEN | TXEN));
set_baudrate(data, SER_DEFAULT_BAUDRATE);
} /* if (obj) */
ReturnPtr("SerialUnit::New()", OOP_Object *, obj);
}
xadTAGPTR FindTagItem(xadTag tagVal, xadTAGPTR tagList)
{
xadTAGPTR tp = tagList, tag;
while((tag = NextTagItem(&tp)))
{
if(tag->ti_Tag == tagVal)
{
return tag;
}
}
return NULL;
}
void DIO_Query(struct DiskIO *dio, const struct TagItem *tags) {
DEBUGF("DIO_Query(%#p, %#p)\n", dio, tags);
const struct TagItem *tag;
ULONG *data;
while ((tag = NextTagItem((struct TagItem **)&tags)) != NULL) {
data = (ULONG *)tag->ti_Data;
switch (tag->ti_Tag) {
case DIOQ_DiskPresent:
*data = dio->disk_present;
break;
case DIOQ_WriteProtected:
*data = dio->write_protected;
break;
case DIOQ_DiskValid:
*data = dio->disk_ok;
break;
case DIOQ_TotalSectors:
*(UQUAD *)data = dio->total_sectors;
break;
case DIOQ_TotalBytes:
*(UQUAD *)data = dio->partition_size;
break;
case DIOQ_BytesPerSector:
*data = dio->sector_size;
break;
case DIOQ_SectorShift:
*data = dio->sector_shift;
break;
case DIOQ_SectorMask:
*data = dio->sector_mask;
break;
case DIOQ_DOSDevName:
*(CONST_STRPTR *)data = dio->devname;
break;
}
}
}
IPTR observerSet(Class * cl, Object * obj, struct opSet * msg)
{
struct ObserverClassData *data;
IPTR retval = 1;
struct TagItem *tag,
*tstate = msg->ops_AttrList;
data = (struct ObserverClassData *) INST_DATA(cl, obj);
while ((tag = NextTagItem(&tstate)))
{
switch (tag->ti_Tag)
{
case OA_InTree:
{
Object *pparent = NULL;
data->inTree = tag->ti_Data;
GetAttr(MUIA_Parent, data->presentation, (IPTR *) &pparent);
// something has to be at the top of the tree...
// the top object won't have a parent
if (data->parent)
{
data->parent = _observer(pparent);
if (data->parent)
DoMethod(obj, MUIM_Notify, OA_Disused, TRUE,
MUIV_EveryTime, (IPTR) data->parent, 2,
OM_Delete, (IPTR) obj);
}
DoMethod(data->presentation, MUIM_Notify, PA_Disused,
TRUE, MUIV_EveryTime, (IPTR) obj, 3, MUIM_Set,
OA_Disused, TRUE);
break;
}
case OA_Parent:
data->parent = (Object *) tag->ti_Data;
if (data->inTree)
DoMethod(obj, MUIM_Notify, OA_Disused, TRUE,
MUIV_EveryTime, (IPTR) data->parent, 2, OM_Delete, (IPTR) obj);
break;
default:
break;
}
}
retval = DoSuperMethodA(cl, obj, (Msg) msg);
return retval;
}
TagItem *FindTagItem(Tag tagValue, TagItem *tagList)
{
TagItem *ti = NULL;
TagItem *tl_copy = tagList;
if (!tagList)
return NULL;
while ((ti = NextTagItem(&tl_copy)) != NULL)
{
if (ti->ti_Tag == tagValue)
break;
}
return ti;
}
ULONG FilterTagItems(TagItem *tagList, Tag *filterArray, ULONG logic)
{
ULONG numValid = 0;
TagItem *ti_tmp;
TagItem *tmp_list = tagList;
if (!tagList)
return 0;
while ((ti_tmp = NextTagItem(&tmp_list)) != NULL)
numValid++;
switch (logic)
{
case TAGFILTER_AND:
tmp_list = tagList;
while ((ti_tmp = NextTagItem(&tmp_list)) != NULL)
{
if (!TagInArray(ti_tmp->ti_Tag, filterArray))
{
ti_tmp->ti_Tag = TAG_IGNORE;
numValid--;
}
}
break;
case TAGFILTER_NOT:
if (!filterArray)
break;
while (*filterArray != TAG_DONE)
{
ti_tmp = FindTagItem(*filterArray++, tagList);
if (ti_tmp)
ti_tmp->ti_Tag = TAG_IGNORE;
}
}
return numValid;
}
IPTR Popstring__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Popstring_DATA *data;
struct TagItem *tag, *tags;
Object *string, *button;
button = (Object*)GetTagData(MUIA_Popstring_Button,0,msg->ops_AttrList);
string = (Object*)GetTagData(MUIA_Popstring_String,0,msg->ops_AttrList);
obj = (Object *) DoSuperNewTags
(
cl, obj, 0,
MUIA_Group_Horiz, TRUE,
MUIA_Group_Spacing, 0,
(string ? Child : TAG_IGNORE), (IPTR) string,
Child, (IPTR) button,
TAG_MORE, (IPTR) msg->ops_AttrList
);
if (!obj) return FALSE;
data = INST_DATA(cl, obj);
data->button = button;
data->string = string;
data->ehn.ehn_Events = IDCMP_RAWKEY;
data->ehn.ehn_Priority = 0;
data->ehn.ehn_Flags = 0;
data->ehn.ehn_Object = obj;
data->ehn.ehn_Class = cl;
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Popstring_Toggle: data->toggle = tag->ti_Data; break;
case MUIA_Popstring_CloseHook: data->close_hook = (struct Hook*)tag->ti_Data;break;
case MUIA_Popstring_OpenHook: data->open_hook = (struct Hook*)tag->ti_Data;break;
}
}
DoMethod(button,MUIM_Notify,MUIA_Pressed,FALSE,(IPTR)obj,1,MUIM_Popstring_Open);
return (IPTR)obj;
}
void RefreshTagItemClones(TagItem *clone, TagItem *original)
{
TagItem *tmp_clone = clone;
TagItem *tmp_list = original;
TagItem *ti_tmp;
if (!clone || !original)
return;
while ((ti_tmp = NextTagItem(&tmp_list)) != NULL)
{
tmp_clone->ti_Tag = ti_tmp->ti_Tag;
tmp_clone->ti_Data = ti_tmp->ti_Data;
tmp_clone++;
}
return;
}
IPTR Colorfield__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Colorfield_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
ULONG *rgb;
obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
if (!obj) return FALSE;
data = INST_DATA(cl, obj);
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Colorfield_Red:
data->rgb[0] = (ULONG)tag->ti_Data;
break;
case MUIA_Colorfield_Green:
data->rgb[1] = (ULONG)tag->ti_Data;
break;
case MUIA_Colorfield_Blue:
data->rgb[2] = (ULONG)tag->ti_Data;
break;
case MUIA_Colorfield_RGB:
rgb = (ULONG *)tag->ti_Data;
data->rgb[0] = *rgb++;
data->rgb[1] = *rgb++;
data->rgb[2] = *rgb++;
break;
case MUIA_Colorfield_Pen:
data->pen = (UBYTE)tag->ti_Data;
data->pen = FLAG_FIXED_PEN;
break;
}
}
return (IPTR)obj;
}
OOP_Object *LinuxMouse__Root__New(OOP_Class *cl, OOP_Object *o, struct pRoot_New *msg)
{
BOOL has_mouse_hidd = FALSE;
ObtainSemaphore(&LSD(cl)->sema);
if (LSD(cl)->mousehidd)
has_mouse_hidd = TRUE;
ReleaseSemaphore(&LSD(cl)->sema);
if (has_mouse_hidd) /* Cannot open twice */
return NULL; /* Should have some error code here */
o = (OOP_Object *)OOP_DoSuperMethod(cl, o, (OOP_Msg)msg);
if (o)
{
struct mouse_data *data = OOP_INST_DATA(cl, o);
struct TagItem *tag, *tstate;
tstate = msg->attrList;
while ((tag = NextTagItem((const struct TagItem **)&tstate)))
{
ULONG idx;
if (IS_HIDDMOUSE_ATTR(tag->ti_Tag, idx))
{
switch (idx)
{
case aoHidd_Mouse_IrqHandler:
data->mouse_callback = (VOID (*)())tag->ti_Data;
break;
case aoHidd_Mouse_IrqHandlerData:
data->callbackdata = (APTR)tag->ti_Data;
break;
}
}
} /* while (tags to process) */
/* Install the mouse hidd */
ObtainSemaphore(&LSD(cl)->sema);
LSD(cl)->mousehidd = o;
ReleaseSemaphore(&LSD(cl)->sema);
}
return o;
}
IPTR Popstring__OM_SET(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct TagItem *tags,*tag;
struct Popstring_DATA *data = INST_DATA(cl, obj);
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem **)&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Popstring_Toggle: data->toggle = tag->ti_Data; break;
case MUIA_Popstring_CloseHook: data->close_hook = (struct Hook*)tag->ti_Data;break;
case MUIA_Popstring_OpenHook: data->open_hook = (struct Hook*)tag->ti_Data;break;
}
}
return DoSuperMethodA(cl,obj,(Msg)msg);
}
void ApplyTagChanges (TagItem *list, TagItem *changeList)
{
TagItem *ti_list = NULL; /* TagItem from the tagList */
TagItem *ti_change = NULL; /* TagItem from the changeList */
TagItem *tl_copy = changeList; /* copy of changeList pointer */
if (list || changeList)
return;
while ((ti_change = NextTagItem(&tl_copy)) != NULL)
{
ti_list = FindTagItem(ti_change->ti_Tag, list);
if (!ti_list)
continue;
ti_list->ti_Data = ti_change->ti_Data;
}
return;
}
/* original : array to copy
* nTags : number of copied tags in new array
*/
TagItem *CloneTagItems(TagItem *original, ULONG *nTags)
{
TagItem *clone = NULL;
TagItem *ti_tmp;
ULONG NumTags = 0;
TagItem *tmp_list = original;
while ((ti_tmp = NextTagItem(&tmp_list)) != NULL)
NumTags++;
clone = AllocateTagItems(NumTags);
if (!clone)
return NULL;
RefreshTagItemClones(clone, original);
if (nTags)
*nTags = NumTags;
return clone;
}
IPTR observerNew(Class * cl, Object * obj, struct opSet * msg)
{
IPTR retval = 0;
struct ObserverClassData *data;
struct TagItem *tstate = msg->ops_AttrList,
*tag;
Object *presentation = NULL,
*parent = NULL;
while ((tag = NextTagItem(&tstate)) != NULL)
{
switch (tag->ti_Tag)
{
case OA_Presentation:
presentation = (Object *) tag->ti_Data;
break;
case OA_Parent:
parent = (Object *) tag->ti_Data;
break;
default:
continue; /* Don't supress non-processed tags */
}
tag->ti_Tag = TAG_IGNORE;
}
retval = DoSuperMethodA(cl, obj, (Msg) msg);
if (retval)
{
obj = (Object *) retval;
data = INST_DATA(cl, obj);
data->presentation = presentation;
data->parent = parent;
NEWLIST((struct List *) &data->freeList);
data->inTree = FALSE;
DoMethod(presentation, MUIM_Notify, PA_InTree, MUIV_EveryTime, (IPTR) obj, 3,
MUIM_Set, OA_InTree, TRUE);
}
return retval;
}
static void _om_set(struct ICData *ic, struct TagItem *tags, struct IntuitionBase *IntuitionBase)
{
struct Library *UtilityBase = GetPrivIBase(IntuitionBase)->UtilityBase;
struct TagItem *tag, *tstate = tags;
while ((tag = NextTagItem(&tstate)))
{
switch(tag->ti_Tag)
{
case ICA_MAP:
ic->ic_Mapping = (struct TagItem *)tag->ti_Data;
break;
case ICA_TARGET:
ic->ic_Target = (Object *)tag->ti_Data;
break;
}
}
}
IPTR Popimage__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Popimage_DATA *data;
struct TagItem *tag, *tags;
obj = (Object *) DoSuperNewTags
(
cl, obj, NULL,
ButtonFrame,
InnerSpacing(4,4),
MUIA_Background, MUII_ButtonBack,
MUIA_InputMode, MUIV_InputMode_RelVerify,
MUIA_Draggable, TRUE,
TAG_MORE, (IPTR) msg->ops_AttrList
);
if (!obj) return FALSE;
data = INST_DATA(cl, obj);
data->wintitle = NULL;
data->adjust_type = MUIV_Imageadjust_Type_All;
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem((const struct TagItem**)&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Window_Title:
data->wintitle = (CONST_STRPTR)tag->ti_Data;
break;
case MUIA_Imageadjust_Type:
data->adjust_type = tag->ti_Data;
break;
}
}
DoMethod(obj, MUIM_Notify, MUIA_Pressed, FALSE, (IPTR)obj, 1,
MUIM_Popimage_OpenWindow);
return (IPTR)obj;
}
SAVEDS ULONG mGet(struct IClass *cl,Object *obj,struct opSet *msg)
{
struct FloatIntData *data = INST_DATA(cl,obj);
struct TagItem *tags,*tag;
for (tags=msg->ops_AttrList;tag=NextTagItem(&tags);)
{
switch (tag->ti_Tag)
{
case MUIA_FloatInt_Contents:
{
return(*((ULONG *)(data->MasterVariable)));
break;
} /* VarPtr */
}
}
return(DoSuperMethodA(cl,obj,(Msg)msg));
}
IPTR Pendisplay__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Pendisplay_DATA *data;
const struct TagItem *tags;
struct TagItem *tag;
obj = (Object *)DoSuperMethodA(cl, obj, (Msg)msg);
if (!obj) return FALSE;
data = INST_DATA(cl, obj);
/* Format identifies need to be long enforced because of RawDoFmt() limits */
snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf), "%lc%ld", (LONG)PST_MUI, (LONG)MPEN_TEXT);
data->pen = -1;
/* parse initial taglist */
for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags)); )
{
switch (tag->ti_Tag)
{
case MUIA_Pendisplay_Reference:
data->refobj = (Object *)tag->ti_Data;
DoMethod(data->refobj, MUIM_Notify, MUIA_Pendisplay_Spec, MUIV_EveryTime,
(IPTR)obj, 3, MUIM_Set, MUIA_Pendisplay_Spec, MUIV_TriggerValue);
break;
case MUIA_Pendisplay_RGBcolor:
{
struct MUI_RGBcolor *rgb = (struct MUI_RGBcolor *)tag->ti_Data;
snprintf(data->penspec.ps_buf, sizeof(data->penspec.ps_buf),
"%lc%08lx,%08lx,%08lx", (LONG)PST_RGB, rgb->red, rgb->green, rgb->blue);
}
break;
case MUIA_Pendisplay_Spec:
data->penspec = *(struct MUI_PenSpec *)tag->ti_Data;
break;
}
}
return (IPTR)obj;
}
ULONG Toolbar_SetAttrib(struct IClass *cl, Object *obj, struct opSet *msg)
{
struct Toolbar_Data *data = (struct Toolbar_Data *)INST_DATA(cl, obj);
struct TagItem *tags, *tag;
for(tags=msg->ops_AttrList; (tag=NextTagItem(&tags)) != NULL; )
{
switch (tag->ti_Tag)
{
case MUIA_Toolbar_HelpString:
data->HelpString = (STRPTR)tag->ti_Data;
break;
case MUIA_Toolbar_Path:
data->Path = (STRPTR)tag->ti_Data;
// A small hack...
DoMethod(obj, MUIM_Toolbar_ReloadImages, data->NormalData, data->SelectData, data->GhostData);
break;
case MUIA_Toolbar_Permutation:
{
if(data->PermutationCreated)
{
data->PermutationCreated = FALSE;
FreeVec(data->Permutation);
}
data->Permutation = (BYTE *)tag->ti_Data;
// There is that hack again...
DoMethod(obj, MUIM_Toolbar_ReloadImages, data->NormalData, data->SelectData, data->GhostData);
}
break;
case MUIA_Toolbar_Qualifier:
data->KeyQualifier = (UWORD)tag->ti_Data;
break;
/* case MUIA_Draggable:
data->dragable = (BOOL)tag->ti_Data;
break;
*/ }
}
return(DoSuperMethodA(cl, obj, (Msg)msg));
}
static void
PrintTagList(struct TagItem *tags)
{
struct TagItem *tstate;
struct TagItem *tag;
if(tags == NULL)
{
KPrintF("No taglist\n");
}
else
{
tstate = tags;
while((tag = NextTagItem(&tstate)))
{
KPrintF("\n %30s, 0x%08lx,", GetTagName( tag->ti_Tag ), tag->ti_Data);
}
KPrintF("\n TAG_DONE)");
}
}
SAVEDS ULONG mChangeFocus(struct IClass *cl,Object *obj,struct opSet *msg)
{
/* struct FloatIntData *data = INST_DATA(cl,obj); */
struct TagItem *tags,*tag;
for (tags=msg->ops_AttrList;tag=NextTagItem(&tags);)
{
switch (tag->ti_Tag)
{
case MUIA_FloatInt_Focus:
{
printf("New Focus: %x\n", tag->ti_Data);
return(0);
break;
} /* Focus */
}
}
return(DoSuperMethodA(cl,obj,(Msg)msg));
}
