static void bitmap_dispose(Class *cl, Object *obj, Msg *msg)
{
struct HIDDBitMapAmigaIntuiData *data = INST_DATA(cl, obj);
struct pHidd_BitMap_PrivateSet private_set_msg;
EnterFunc(bug("BitMapAmigaIntui::Dispose()\n"));
if(data->screen)
{
/*
We use an own buffer so set the BaseAddress to NULL to prevent
the superclass to free our own buffer.
*/
struct TagItem set[] =
{
{aHidd_BitMap_BaseAddress, NULL},
{TAG_END , 0 }
};
CloseScreen(data->screen);
private_set_msg.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet);
private_set_msg.attrList = set;
DoSuperMethod(cl, obj, (Msg) &private_set_msg);
}
DoSuperMethod(cl, obj, (Msg) msg);
ReturnVoid("BitMapAmigaIntui::Dispose");
}
static IPTR mAbout(struct IClass *cl, Object *obj, UNUSED Msg msg)
{
struct data *data = INST_DATA(cl,obj);
superset(cl,obj,MUIA_Application_Sleep,TRUE);
if(data->about == NULL)
{
if(g_aboutClass != NULL || initAboutClass() == TRUE)
{
if((data->about = aboutObject,
MUIA_Aboutmui_Application, obj,
MUIA_Window_RefWindow, data->win,
End) != NULL)
{
DoSuperMethod(cl,obj,OM_ADDMEMBER,(IPTR)data->about);
DoMethod(data->about,MUIM_Notify,MUIA_Window_CloseRequest,TRUE,(IPTR)obj,5,
MUIM_Application_PushMethod,(IPTR)obj,2,MUIM_App_DisposeWin,(IPTR)data->about);
}
}
}
openWindow(obj,data->about);
superset(cl,obj,MUIA_Application_Sleep,FALSE);
return 0;
}
IPTR GTSlider__GM_HANDLEINPUT(Class *cl, Object *o, struct gpInput *msg)
{
struct InputEvent *ie = msg->gpi_IEvent;
IPTR retval;
struct SliderData *data = INST_DATA(cl ,o);
EnterFunc(bug("Slider::HandleInput()\n"));
retval = DoSuperMethodA(cl, o, (Msg)msg);
/* Mousemove ? */
if ((ie->ie_Class == IECLASS_RAWMOUSE) && (ie->ie_Code == IECODE_NOBUTTON))
{
LONG top;
/* Get the PGA_Top attribute */
DoSuperMethod(cl, o, OM_GET, PGA_Top, (IPTR) &top);
/* Level changed ? */
if (data->level - data->min != top)
{
data->level = data->min + top;
notifylevel(cl, o, data->level, msg->gpi_GInfo, GadToolsBase);
}
}
else
{
if (retval != GMR_MEACTIVE)
{
data->level = data->min + (WORD)*(msg->gpi_Termination);
notifylevel(cl, o, data->level, msg->gpi_GInfo, GadToolsBase);
}
}
ReturnInt("Slider::HandleInput", IPTR, retval);
}
Object * VARARGS68K DoSuperNew(struct IClass *cl, Object *obj, ...)
{
Object *rc;
VA_LIST args;
VA_START(args, obj);
rc = (Object *)DoSuperMethod(cl, obj, OM_NEW, VA_ARG(args, ULONG), NULL);
VA_END(args);
return rc;
}
static IPTR mDispose(struct IClass *cl, Object *obj, Msg msg)
{
struct data *data = INST_DATA(cl,obj);
struct DiskObject *icon = data->icon;
IPTR res;
/*
** Because of users hate an app that saves on disc
** at any exit, we check if you must save something
*/
if (DoMethod(data->win,MUIM_App_CheckSave))
{
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENV);
DoSuperMethod(cl,obj,MUIM_Application_Save,(IPTR)MUIV_Application_Save_ENVARC);
}
res = DoSuperMethodA(cl,obj,msg);
if (icon) FreeDiskObject(icon);
return res;
}
static IPTR mDisposeWin(struct IClass *cl, Object *obj, struct MUIP_App_DisposeWin *msg)
{
struct data *data = INST_DATA(cl,obj);
Object *win = msg->win;
set(win,MUIA_Window_Open,FALSE);
DoSuperMethod(cl,obj,OM_REMMEMBER,(IPTR)win);
MUI_DisposeObject(win);
if(win==data->about)
data->about = NULL;
return 0;
}
STATIC VOID notifylevel(Class *cl, Object *o, WORD level, struct GadgetInfo *ginfo,
struct GadToolsBase_intern *GadToolsBase)
{
struct TagItem ntags[] =
{
{GTSL_Level , (IPTR)NULL },
{TAG_DONE }
};
ntags[0].ti_Data = (IPTR)level;
DoSuperMethod(cl, o, OM_NOTIFY, (IPTR) ntags, (IPTR) ginfo, 0);
return;
}
ULONG mainDispatcher( struct Class *c, Object *o, struct Msg *m )
{
ULONG retVal = (ULONG)NULL;
// we dont call super methods beacouse this method is done on root
DEBUG("MAINNEW dispatcher MID %ld \n", m->MethodID );
//o->curr_MethodID = m->MethodID;
switch( m->MethodID )
{
case FM_NEW: return mainNew( c, o, m );
break;
case FM_DISPOSE: return mainDispose( c, o, m );
break;
case FM_SET: return mainSet( c, o, m );
break;
//case OM_GET:
// break;
case FM_ADDTAIL:
break;
case FM_REMOVE:
break;
case FM_NOTIFY:
break;
case FM_UPDATE:
break;
case FM_ADDMEMBER:
break;
case FM_REMMEMBER:
break;
default:
retVal = DoSuperMethod( c, o, m );
break;
}
return retVal;
}
ULONG mainSet( Class *c, Object *o, struct Msg *msg )
{
ULONG res = 0;
DEBUG("MAINNEW set\n");
struct opSet *set = (struct opSet *)msg;
struct TagItem *lt = (set->ops_AttrList);
while( lt->ti_Tag != TAG_END )
{
//printf("MAINNEW set loop %x %lu\n", lt->ti_Tag, lt->ti_Data );
lt++;
}
DoSuperMethod( c, o, msg );
return res;
}
static ULONG
mNew(struct IClass *cl,Object *obj,struct opSet *msg)
{
if (obj = (Object *)DoSuperNew(cl,obj,
MUIA_Group_Horiz, TRUE,
MUIA_Group_HorizSpacing, 1,
MUIA_Group_SameSize, TRUE,
TAG_MORE,(ULONG)msg->ops_AttrList))
{
struct data *data = INST_DATA(cl,obj);
int i;
for (i= 0; i<7; i++)
{
Object *o;
o = TextObject,
MUIA_CycleChain, TRUE,
MUIA_Font, MUIV_Font_Button,
MUIA_InputMode, MUIV_InputMode_Immediate,
ButtonFrame,
MUIA_Background, MUII_ButtonBack,
MUIA_Text_Contents, GetLocaleStr(lib_locale,ABDAY_1+i),
MUIA_Text_PreParse, MUIX_C,
MUIA_Text_SetMax, TRUE,
End;
if (o)
{
DoSuperMethod(cl,obj,OM_ADDMEMBER,(ULONG)o);
DoMethod(o,MUIM_Notify,MUIA_Selected,TRUE,(ULONG)obj,3,MUIM_Set,MUIA_Calendar_StartDay,i);
data->days[i] = o;
}
else
{
CoerceMethod(cl->cl_Super,obj,OM_DISPOSE);
return 0;
}
}
}
return (ULONG)obj;
}
ULONG mainDispose( Class *c, Object *o, struct Msg *msg )
{
ULONG res = 0;
DEBUG("MAINDISPOSE start\n");
if( o->o_UserData != NULL)
{
free( o->o_UserData );
o->o_UserData = NULL;
}
DoSuperMethod( c, o, msg );
free( o );
DEBUG("MAINDISPOSE END\n");
return res;
}
IPTR GTSlider__OM_SET(Class * cl, Object * o, struct opSet * msg)
{
IPTR retval = 0UL;
const struct TagItem *tstate;
struct TagItem *tag, *dosuper_tags, tags[] =
{
{PGA_Total , 0 },
{PGA_Top , 0 },
{TAG_MORE , 0 }
};
struct SliderData *data = INST_DATA(cl, o);
BOOL val_set = FALSE;
EnterFunc(bug("Slider::Set(attrlist=%p)\n", msg->ops_AttrList));
dosuper_tags = msg->ops_AttrList;
tstate = msg->ops_AttrList;
while ((tag = NextTagItem(&tstate)))
{
IPTR tidata = tag->ti_Data;
switch (tag->ti_Tag)
{
case GTSL_Min:
data->min = (WORD)tidata;
val_set = TRUE;
break;
case GTSL_Max:
data->max = (WORD)tidata;
val_set = TRUE;
break;
case GTSL_Level: /* [ISN] */
if (tidata != data->level)
{
data->level = data->freedom==FREEHORIZ?(WORD)tidata:data->max-(WORD)tidata+data->min;
notifylevel(cl, o, data->level, msg->ops_GInfo, GadToolsBase);
val_set = TRUE;
}
break;
} /* switch () */
} /* while (iterate taglist) */
if (val_set)
{
tags[0].ti_Data = data->max - data->min + 1;
tags[1].ti_Data = data->level - data->min;
tags[2].ti_Data = (IPTR)msg->ops_AttrList;
dosuper_tags = tags;
retval = 1UL;
}
ReturnInt ("Slider::Set", IPTR, DoSuperMethod(cl, o, OM_SET, (IPTR) dosuper_tags, (IPTR) msg->ops_GInfo));
}
IPTR DoSuperNew(struct IClass *cl, Object *obj, IPTR tag1, ...)
{
AROS_SLOWSTACKTAGS_PRE(tag1)
retval = DoSuperMethod(cl, obj, OM_NEW, AROS_SLOWSTACKTAGS_ARG(tag1));
AROS_SLOWSTACKTAGS_POST
}
static IPTR mGetPrefs(struct IClass *cl,Object *obj, struct MUIP_Win_GetPrefs *msg)
{
struct data *data = INST_DATA(cl,obj);
struct URL_Prefs *p;
struct URL_BrowserNode *bn;
struct URL_MailerNode *mn;
struct URL_FTPNode *fn;
ULONG mode, error = 0;
/* get the openurl.library prefs */
switch (msg->mode)
{
case MUIV_Win_GetPrefs_InUse: mode = URL_GetPrefs_Mode_InUse; break;
case MUIV_Win_GetPrefs_LastSaveds: mode = URL_GetPrefs_Mode_Envarc; break;
case MUIV_Win_GetPrefs_Restore: mode = URL_GetPrefs_Mode_Env; break;
case MUIV_Win_GetPrefs_Defaults: mode = URL_GetPrefs_Mode_Default; break;
default: return FALSE;
}
p = URL_GetPrefs(URL_GetPrefs_Mode,mode,TAG_DONE);
if (!p) error = MSG_Err_NoPrefs;
else if (p->up_Version!=PREFS_VERSION) error = MSG_Err_BadPrefs;
if (error)
{
MUI_Request(_app(obj),NULL,0,getString(MSG_ErrReqTitle),
getString(MSG_ErrReqGadget),
getString(error),
p ? p->up_Version : 0);
if (p) URL_FreePrefsA(p,NULL);
return FALSE;
}
/* Browsers */
set(data->browserList,MUIA_List_Quiet,TRUE);
DoMethod(data->browserList,MUIM_List_Clear);
for (bn = (struct URL_BrowserNode *)p->up_BrowserList.mlh_Head;
bn->ubn_Node.mln_Succ;
bn = (struct URL_BrowserNode *)bn->ubn_Node.mln_Succ)
{
DoMethod(data->browserList,MUIM_List_InsertSingle,(IPTR)bn,MUIV_List_Insert_Bottom);
}
set(data->browserList,MUIA_List_Quiet,FALSE);
/* Mailers */
set(data->mailerList,MUIA_List_Quiet,TRUE);
DoMethod(data->mailerList,MUIM_List_Clear);
for (mn = (struct URL_MailerNode *)p->up_MailerList.mlh_Head;
mn->umn_Node.mln_Succ;
mn = (struct URL_MailerNode *)mn->umn_Node.mln_Succ)
{
DoMethod(data->mailerList,MUIM_List_InsertSingle,(IPTR)mn,MUIV_List_Insert_Bottom);
}
set(data->mailerList,MUIA_List_Quiet,FALSE);
/* FTPs */
set(data->FTPList,MUIA_List_Quiet,TRUE);
DoMethod(data->FTPList,MUIM_List_Clear);
for (fn = (struct URL_FTPNode *)p->up_FTPList.mlh_Head;
fn->ufn_Node.mln_Succ;
fn = (struct URL_FTPNode *)fn->ufn_Node.mln_Succ)
{
DoMethod(data->FTPList,MUIM_List_InsertSingle,(IPTR)fn,MUIV_List_Insert_Bottom);
}
set(data->FTPList,MUIA_List_Quiet,FALSE);
/* Miscellaneous */
set(data->prepend, MUIA_Selected, isFlagSet(p->up_Flags, UPF_PREPENDHTTP));
set(data->mailto, MUIA_Selected, isFlagSet(p->up_Flags, UPF_DOMAILTO));
set(data->useFTP, MUIA_Selected, isFlagSet(p->up_Flags, UPF_DOFTP));
set(data->show, MUIA_Selected, p->up_DefShow);
set(data->toFront, MUIA_Selected, p->up_DefBringToFront);
set(data->newWin, MUIA_Selected, p->up_DefNewWindow);
set(data->launch, MUIA_Selected, p->up_DefLaunch);
/* Activate the first entry */
DoSuperMethod(cl,obj,MUIM_MultiSet,MUIA_List_Active,MUIV_List_Active_Top,
(IPTR)data->browserList,
(IPTR)data->mailerList,
(IPTR)data->FTPList,
NULL);
URL_FreePrefsA(p,NULL);
return TRUE;
}
// Listview dispatcher
ULONG LIBFUNC listview_dispatch(
REG(a0, Class *cl),
REG(a2, Object *obj),
REG(a1, Msg msg))
{
ListViewData *data=0;
struct Gadget *gadget=0;
ULONG retval=0;
// Get gadget and data pointers
if (obj)
{
gadget=(struct Gadget *)obj;
data=INST_DATA(cl,obj);
}
// Look at method
switch (msg->MethodID)
{
// Create a new instance
case OM_NEW:
// Create superclass instance
if ((retval=DoSuperMethodA(cl,obj,msg)))
{
struct TagItem *tags,*tag;
short a;
struct Image *image;
struct TextAttr *attr;
// Get pointer to our gadget and instance data
gadget=(struct Gadget *)retval;
data=INST_DATA(cl,(APTR)retval);
// Initialise data
data->dims=*(struct IBox *)&gadget->LeftEdge;
NewList(&data->boopsi_list);
data->sel=-1;
data->last_selection=-1;
// Initialise mapping tags
data->scroll_map[0].ti_Tag=PGA_Top;
data->scroll_map[0].ti_Data=DLV_Top;
data->scroll_map[1].ti_Tag=TAG_END;
data->arrow_up_map[0].ti_Tag=GA_ID;
data->arrow_up_map[0].ti_Data=DLV_ScrollUp;
data->arrow_up_map[1].ti_Tag=TAG_END;
data->arrow_down_map[0].ti_Tag=GA_ID;
data->arrow_down_map[0].ti_Data=DLV_ScrollDown;
data->arrow_down_map[1].ti_Tag=TAG_END;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Get width of scroller
data->scroller_width=GetTagData(DLV_ScrollWidth,16,tags);
// Flags
if (FindTagItem(DLV_ShowSelected,tags))
data->flags|=LVF_SHOW_SELECTED;
if (GetTagData(DLV_ThinBorder,0,tags))
data->flags|=LVF_THIN_BORDER;
if (GetTagData(DLV_MultiSelect,0,tags))
data->flags|=LVF_MULTI_SELECT;
else
if (GetTagData(DLV_Check,0,tags))
data->flags|=LVF_SELECTED_CHECK;
else
if ((a=GetTagData(DLV_ShowChecks,0,tags)))
{
data->flags|=LVF_SHOW_CHECKS;
if (a==2) data->flags|=LVF_NO_HIGHLIGHT;
}
if (GetTagData(DLV_Highlight,0,tags))
data->flags|=LVF_SELECTED_HIGH;
if (GetTagData(DLV_ReadOnly,0,tags))
data->flags|=LVF_READ_ONLY;
if (GetTagData(DLV_NoScroller,0,tags))
{
data->flags|=LVF_NO_SCROLLER;
data->scroller_width=0;
}
else
if (GetTagData(DLV_ScrollLeft,0,tags))
data->flags|=LVF_SCROLLER_LEFT;
if (GetTagData(DLV_TopJustify,0,tags))
data->flags|=LVF_TOP_JUSTIFY;
if (GetTagData(DLV_RightJustify,0,tags))
data->flags|=LVF_RIGHT_JUSTIFY;
if ((a=GetTagData(DLV_DragNotify,0,tags)))
{
data->flags|=LVF_DRAG_NOTIFY;
if (a==2) data->flags|=LVF_NO_VERT_SCROLL;
}
data->layout_flags=GetTagData(DLV_Flags,PLACETEXT_ABOVE,tags);
if (GetTagData(DLV_ShowFilenames,0,tags))
data->flags|=LVF_SHOW_FILENAMES;
if (GetTagData(DLV_ShowSeparators,0,tags))
data->flags|=LVF_SHOW_SEPARATORS;
// Get title
if ((tag=FindTagItem(GA_Text,tags)))
{
char *ptr;
short pos=0;
// Get pointer to title
if ((ptr=(char *)tag->ti_Data))
{
data->title_uscore=-1;
// Copy title string, look for underscore
while (*ptr && pos<78)
{
// Underscore?
if (*ptr=='_')
{
// Remember position, skip over it
data->title_uscore=pos;
}
// Otherwise, store
else data->title[pos++]=*ptr;
++ptr;
}
data->title[pos]=0;
}
}
// Get font to use
if ((attr=(struct TextAttr *)GetTagData(GTCustom_TextAttr,0,tags)))
{
if ((data->list_font=OpenFont(attr)))
data->flags|=LVF_GOT_FONT;
}
if (!data->list_font) data->list_font=((struct GfxBase *)GfxBase)->DefaultFont;
// Arrow height
data->arrow_height=data->list_font->tf_YSize-2;
if (data->arrow_height<10) data->arrow_height=10;
// Fix dimensions
listview_get_dims(cl,data);
data->text_height=data->list_font->tf_YSize;
// Need check mark?
if (data->flags&(LVF_MULTI_SELECT|LVF_SHOW_CHECKS) ||
(data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
{
// Create check image
if ((data->check=(struct Image *)NewObject(
0,"dopusiclass",
DIA_Type,IM_CHECK,
IA_Width,13,
IA_Height,data->text_height-1,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->check,OM_ADDTAIL,&data->boopsi_list);
}
data->text_offset=23;
}
else data->text_offset=2;
// Scroller needed?
if (!(data->flags&LVF_NO_SCROLLER))
{
// Create scroller
if ((data->scroller=(struct Gadget *)NewObject(
0,"propgclass",
GA_Previous,gadget,
GA_ID,LVGID_SCROLLER,
GA_Left,(data->flags&LVF_SCROLLER_LEFT)?data->dims.Left+4:data->dims.Left+data->dims.Width-data->scroller_width+4,
GA_Top,data->dims.Top+2,
GA_Width,data->scroller_width-8,
GA_Height,data->dims.Height-4-(data->arrow_height<<1),
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
PGA_Freedom,FREEVERT,
PGA_NewLook, TRUE,
PGA_Borderless,TRUE,
PGA_Visible,1,
PGA_Total,1,
ICA_TARGET,gadget,
ICA_MAP,data->scroll_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->scroller,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_UP,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow button
if ((data->arrows[0]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->scroller,
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_up_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[0],OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_DOWN,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow button
if ((data->arrows[1]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->arrows[0],
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height+data->arrow_height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_down_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[1],OM_ADDTAIL,&data->boopsi_list);
}
}
}
else break;
// Fall through to OM_SET
// Update/Set
case OM_UPDATE:
case OM_SET:
{
struct TagItem *tag,*tags;
unsigned short old;
struct Node *node;
short item;
short redraw=0;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Make visible?
if ((tag=FindTagItem(DLV_MakeVisible,tags)))
{
short scroll;
// Remember old top
old=data->top;
// Get scroll amount
scroll=tag->ti_Data-old;
// Need to scroll?
if (scroll<0 ||
scroll>=data->lines)
{
// Get scroll amount
if (scroll>=data->lines)
scroll-=data->lines-1;
// Get new top
data->top+=scroll;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
}
// New top?
else
if ((tag=FindTagItem(DLV_Top,tags)))
{
// Remember old top
old=data->top;
// Get new top
data->top=tag->ti_Data;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
// Scroll up
else
if ((tag=FindTagItem(DLV_ScrollUp,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top>0)
{
--data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// Scroll down
else
if ((tag=FindTagItem(DLV_ScrollDown,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top<data->count-data->lines)
{
++data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// New labels
if ((tag=FindTagItem(DLV_Labels,tags)))
{
// clear top item
data->top_item=0;
// Store new label pointer
data->labels=(struct List *)tag->ti_Data;
// Detached list?
if (data->labels==(struct List *)~0)
data->flags|=LVF_DETACHED;
// No list
else
if (data->labels==0)
{
// Clear detach flag
data->count=0;
data->flags&=~LVF_DETACHED;
redraw=1;
}
// Valid list
else
{
// Count items
for (data->count=0,node=data->labels->lh_Head;
node->ln_Succ;
data->count++,node=node->ln_Succ);
// Bounds check top
if (data->top+data->lines>data->count)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Check selection for out-of-bounds
if (data->sel>data->count-1) data->sel=-1;
// Clear detach flag
data->flags&=~LVF_DETACHED;
redraw=1;
}
}
// Selected
if ((tag=FindTagItem(DLV_Selected,tags)) ||
(tag=FindTagItem(DLV_SelectPrevious,tags)) ||
(tag=FindTagItem(DLV_SelectNext,tags)) ||
(tag=FindTagItem(DLV_PageUp,tags)) ||
(tag=FindTagItem(DLV_PageDown,tags)) ||
(tag=FindTagItem(DLV_Home,tags)) ||
(tag=FindTagItem(DLV_End,tags)))
{
// Store old
old=data->sel;
// Get new selected
if (tag->ti_Tag==DLV_Selected)
{
data->sel=tag->ti_Data;
}
else
if (tag->ti_Tag==DLV_SelectPrevious)
{
if (data->sel>0) --data->sel;
}
else
if (tag->ti_Tag==DLV_SelectNext)
{
++data->sel;
}
else
if (tag->ti_Tag==DLV_PageUp)
{
if (data->sel==data->top)
data->sel-=data->lines-1;
else
data->sel=data->top;
if (data->sel<0) data->sel=0;
}
else
if (tag->ti_Tag==DLV_PageDown)
{
if (data->sel==data->top+data->lines-1)
data->sel+=data->lines-1;
else
data->sel=data->top+data->lines-1;
}
else
if (tag->ti_Tag==DLV_Home)
{
data->sel=0;
}
else
if (tag->ti_Tag==DLV_End)
{
data->sel=data->count-1;
}
// Bounds check
if (data->sel>data->count-1) data->sel=data->count-1;
if (data->sel<0) data->sel=-1;
// Changed?
if (data->sel!=old && !(gadget->Flags&GFLG_DISABLED))
{
// Save selection
if (!redraw)
{
data->last_sel=data->last_selection;
redraw=2;
}
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct opSet *)msg)->ops_GInfo,0);
}
}
// Disabled (set only)
if (msg->MethodID==OM_SET &&
(tag=FindTagItem(GA_Disabled,tags)))
{
// Different to current state?
if ((tag->ti_Data && !(gadget->Flags&GFLG_DISABLED)) ||
(!tag->ti_Data && gadget->Flags&GFLG_DISABLED))
{
struct TagItem distags[2];
short a;
// Fill out disable tags
distags[0].ti_Tag=GA_Disabled;
distags[0].ti_Data=tag->ti_Data;
distags[1].ti_Tag=TAG_DONE;
// Set state of slider
if (data->scroller)
{
DoMethod(
(Object *)data->scroller,
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// And arrows
for (a=0;a<2;a++)
DoMethod(
(Object *)data->arrows[a],
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// Set flag to say disable state changed
if (!tag->ti_Data)
data->flags|=LVF_DISABLE_CHANGE;
}
// Change disable state and redraw
gadget->Flags^=GFLG_DISABLED;
redraw=1;
}
}
// Get top item
if (!data->labels) data->top_item=0;
else
if (!(data->flags&LVF_DETACHED) && data->labels)
{
for (node=data->labels->lh_Head,item=0;
node->ln_Succ && item<data->top;
node=node->ln_Succ,item++);
data->top_item=node;
}
// Do we need to redraw the list?
if (msg->MethodID==OM_SET || msg->MethodID==OM_UPDATE)
{
if (redraw && !(data->flags&LVF_DETACHED))
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(((struct opSet *)msg)->ops_GInfo)))
{
// Send redraw
DoMethod(
obj,
GM_RENDER,
((struct opSet *)msg)->ops_GInfo,
rp,
(redraw==2)?GREDRAW_UPDATE:GREDRAW_REDRAW);
ReleaseGIRPort(rp);
}
}
}
}
break;
// Get an attribute
case OM_GET:
{
struct opGet *get;
// Get get message
get=(struct opGet *)msg;
// Default to ok
retval=1;
// Look at attribute
switch (get->opg_AttrID)
{
// Selected
case DLV_Selected:
*get->opg_Storage=(ULONG)data->last_selection;
break;
// Top
case DLV_Top:
*get->opg_Storage=(ULONG)data->top;
break;
// Lines
case DLV_Lines:
*get->opg_Storage=(ULONG)data->lines;
break;
// Labels
case DLV_Labels:
*get->opg_Storage=(ULONG)data->labels;
break;
// Get line from coordinates
case DLV_GetLine:
{
unsigned short x,y;
struct gpInput fake;
// Get coordinates
x=((*get->opg_Storage)>>16)&0xffff;
y=(*get->opg_Storage)&0xffff;
// Fake gpInput
fake.gpi_Mouse.X=x-gadget->LeftEdge;
fake.gpi_Mouse.Y=y-gadget->TopEdge;
// Get selection
*get->opg_Storage=(ULONG)listview_get_sel(cl,gadget,data,&fake,0);
}
break;
// Draw a line from the listview
case DLV_DrawLine:
{
ListViewDraw *draw=(ListViewDraw *)*get->opg_Storage;
// Draw line
listview_draw_item(
cl,
gadget,
draw->rp,
draw->drawinfo,
data,
draw->node,
draw->line,
&draw->box);
}
break;
// Other
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
}
break;
// Kill an instance
case OM_DISPOSE:
{
APTR object_ptr;
Object *object;
// Free BOOPSI objects
object_ptr=data->boopsi_list.lh_Head;
while ((object=NextObject((APTR)&object_ptr)))
DisposeObject(object);
// Free font
if (data->flags&LVF_GOT_FONT)
CloseFont(data->list_font);
retval=DoSuperMethodA(cl,obj,msg);
}
break;
// Render gadget
case GM_RENDER:
// Cache DrawInfo
data->draw_info=((struct gpRender *)msg)->gpr_GInfo->gi_DrInfo;
// If a full redraw, clear double-click time
if (((struct gpRender *)msg)->gpr_Redraw==GREDRAW_REDRAW)
data->seconds=0;
// Show gadget
listview_render(cl,gadget,data,(struct gpRender *)msg);
break;
// Hit test
case GM_HITTEST:
{
struct gpHitTest *test;
// Get test pointer
test=(struct gpHitTest *)msg;
// See if we're hit
if (test->gpht_Mouse.X>=data->text_dims.Left-gadget->LeftEdge &&
test->gpht_Mouse.Y>=data->text_dims.Top-gadget->TopEdge &&
test->gpht_Mouse.X<data->text_dims.Left+data->text_dims.Width-gadget->LeftEdge &&
test->gpht_Mouse.Y<data->text_dims.Top+data->text_dims.Height-gadget->TopEdge)
{
retval=GMR_GADGETHIT;
}
}
break;
// Notify
case OM_NOTIFY:
// Drag notify?
if (data->flags&LVF_DRAG_FLAG)
{
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_DragNotify;
data->notify_tags[0].ti_Data=data->drag_sel;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=GA_Left;
data->notify_tags[2].ti_Data=data->text_dims.Left;
data->notify_tags[3].ti_Tag=GA_Top;
data->notify_tags[3].ti_Data=data->text_dims.Top+
UMult32(data->drag_sel-data->top,data->text_height);
data->notify_tags[4].ti_Tag=GA_Width;
data->notify_tags[4].ti_Data=data->text_dims.Width;
data->notify_tags[5].ti_Tag=GA_Height;
data->notify_tags[5].ti_Data=data->text_height;
data->notify_tags[6].ti_Tag=GA_RelRight;
data->notify_tags[6].ti_Data=data->drag_x_position;
data->notify_tags[7].ti_Tag=GA_RelBottom;
data->notify_tags[7].ti_Data=data->drag_y_position;
data->notify_tags[8].ti_Tag=DLV_Top;
data->notify_tags[8].ti_Data=data->top;
data->notify_tags[9].ti_Tag=DLV_Object;
data->notify_tags[9].ti_Data=(ULONG)gadget;
data->notify_tags[10].ti_Tag=TAG_END;
// Clear flag
data->flags&=~LVF_DRAG_FLAG;
}
// Otherwise normal notify
else
{
ULONG seconds,micros;
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_Selected;
data->notify_tags[0].ti_Data=data->last_selection;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=TAG_END;
// Get current time
CurrentTime(&seconds,µs);
// Double-click?
if (data->click_sel==data->last_selection &&
DoubleClick(data->seconds,data->micros,seconds,micros))
{
// Set double-click flag
data->notify_tags[2].ti_Tag=DLV_DoubleClick;
data->notify_tags[2].ti_Data=TRUE;
data->notify_tags[3].ti_Tag=TAG_END;
// Clear double-click
data->seconds=0;
}
// Otherwise
else
{
// Remember double-click
data->seconds=seconds;
data->micros=micros;
data->click_sel=data->last_selection;
}
}
// Send message
DoSuperMethod(cl,obj,OM_NOTIFY,data->notify_tags,((struct opUpdate *)msg)->opu_GInfo,0);
break;
// Go (in)active/Handle input
case GM_GOACTIVE:
case GM_GOINACTIVE:
case GM_HANDLEINPUT:
{
struct gpInput *input;
short redraw=0;
// Get input pointer
input=(struct gpInput *)msg;
// Go active?
if (input->MethodID==GM_GOACTIVE)
{
// Default is not to activate
retval=GMR_NOREUSE;
// Ok to go active?
if (!(gadget->Flags&GFLG_DISABLED) && input->gpi_IEvent)
{
// Left button down and valid list?
if (input->gpi_IEvent->ie_Code==SELECTDOWN &&
data->labels &&
!(data->flags&(LVF_READ_ONLY|LVF_DETACHED)))
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,0))>-1)
{
// Ok to activate
retval=GMR_MEACTIVE;
// Store current top
data->last_top=data->top;
// Remember x and y click-offset
data->drag_x_position=input->gpi_Mouse.X-
(data->text_dims.Left-data->dims.Left);
data->drag_y_position=input->gpi_Mouse.Y-
(data->text_dims.Top-data->dims.Top)-
UMult32(sel-data->top,data->text_height);
// Change?
if (data->sel!=sel ||
!(data->flags&LVF_SHOW_SELECTED) ||
(data->flags&LVF_SELECTED_CHECK))
{
// New selection
data->last_sel=data->last_selection;
data->sel=sel;
redraw=1;
}
// Set selected flag
gadget->Flags|=GFLG_SELECTED;
}
}
}
}
// Go inactive?
else
if (msg->MethodID==GM_GOINACTIVE)
{
// Clear selected flag
gadget->Flags&=~GFLG_SELECTED;
// If we're showing selection with checks, we need to redraw last selection
if ((data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
data->last_sel=data->last_selection;
redraw=1;
// Save this selection
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct gpInput *)msg)->gpi_GInfo,0);
// Clear cancel flag
data->flags&=~LVF_CANCEL;
}
// Handle input
else
{
// Default return value
retval=GMR_MEACTIVE;
// Is it a mouse event?
if (input->gpi_IEvent->ie_Class==IECLASS_RAWMOUSE)
{
// Look at mouse code
switch (input->gpi_IEvent->ie_Code)
{
// Left button up
case SELECTUP:
{
// Set return code
*input->gpi_Termination=data->sel;
// Gadget processing finished
retval=GMR_NOREUSE|GMR_VERIFY;
data->flags|=LVF_CANCEL;
// Multi-selection?
if (data->flags&LVF_MULTI_SELECT)
{
struct Node *node;
short count;
// Get this node
for (node=data->labels->lh_Head,count=0;
node->ln_Succ && count<data->sel;
node=node->ln_Succ,count++);
// Did we get it?
if (node && node->ln_Succ)
{
// Save old selection
data->last_sel=data->sel;
// Toggle selection
node->lve_Flags^=LVEF_SELECTED;
redraw=1;
}
}
}
break;
// No button; mouse moved
case IECODE_NOBUTTON:
{
short sel;
// Is mouse outside of lister?
if (input->gpi_Mouse.X<0 ||
input->gpi_Mouse.X>=data->list_dims.Width)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Valid selection?
if (data->sel>-1)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN (if NO_VERT_SCROLL)
if (!(data->flags&LVF_NO_VERT_SCROLL))
{
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
break;
}
}
else break;
}
else break;
}
// Get selection
else
if ((sel=listview_get_sel(cl,gadget,data,input,1))>-1 ||
(sel==-1 && (data->flags&LVF_NO_VERT_SCROLL)))
{
// Change?
if (data->sel!=sel || sel==-1)
{
// Clear double-click
data->seconds=0;
// No vertical scroll?
if (data->flags&LVF_NO_VERT_SCROLL)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN
}
else break;
}
// Otherwise
else
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
redraw=1;
break;
}
}
else break;
}
else break;
}
// Right button does cancel
case MENUDOWN:
{
// Gadget processing finished
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
// Show selected?
if (data->flags&LVF_SHOW_SELECTED)
{
// Restore last selection
data->last_sel=data->sel;
data->sel=data->last_selection;
// Does top need to change?
if (data->top!=data->last_top)
{
short item;
data->top=data->last_top;
data->last_sel=-1;
for (data->top_item=data->labels->lh_Head,item=0;
data->top_item->ln_Succ && item<data->top;
data->top_item=data->top_item->ln_Succ,item++);
}
redraw=1;
}
}
break;
}
}
// Or a timer event
else
if (input->gpi_IEvent->ie_Class==IECLASS_TIMER)
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,2))>-1)
{
// Change?
if (data->sel!=sel)
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
// Do we have to scroll?
if (sel<data->top)
{
if (data->top>0)
{
// Scroll up
--data->top;
data->top_item=data->top_item->ln_Pred;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else
if (sel>=data->top+data->lines)
{
if (data->top+data->lines<data->count)
{
// Scroll down
++data->top;
data->top_item=data->top_item->ln_Succ;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else redraw=1;
}
}
}
}
// Redraw needed?
if (redraw)
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(input->gpi_GInfo)))
{
// Send redraw
DoMethod(obj,GM_RENDER,input->gpi_GInfo,rp,GREDRAW_UPDATE);
ReleaseGIRPort(rp);
}
}
}
break;
// Resize
case GM_RESIZE:
// Handle the resize
listview_resize(cl,gadget,data,(struct gpResize *)msg);
break;
// Unknown method
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
return retval;
}
ULONG __stdargs __inline DoSuperNew(struct IClass *cl,Object *obj,ULONG tag1,...)
{
return(DoSuperMethod(cl,obj,OM_NEW,&tag1,NULL));
}
/*
** Here we go
*/
static IPTR mNew(struct IClass *cl, Object *obj, struct opSet *msg)
{
Object *strip, *win;
if((obj = (Object *)DoSuperNew(cl,obj,
MUIA_Application_Title, "OpenURL-Prefs",
MUIA_Application_Version, "$VER: OpenURL-Prefs " LIB_REV_STRING " [" SYSTEMSHORT "/" CPU "] (" LIB_DATE ") " LIB_COPYRIGHT,
MUIA_Application_Author, APPAUTHOR,
MUIA_Application_Copyright, getString(MSG_App_Copyright),
MUIA_Application_Description, getString(MSG_App_Description),
MUIA_Application_HelpFile, APPHELP,
MUIA_Application_Base, APPBASENAME,
MUIA_Application_Menustrip, strip = MUI_MakeObject(MUIO_MenustripNM,(IPTR)menu,MUIO_MenustripNM_CommandKeyCheck),
MUIA_Application_UsedClasses, usedClasses,
MUIA_Application_Window, win = winObject, End,
TAG_MORE,msg->ops_AttrList)) != NULL)
{
struct data *data = INST_DATA(cl,obj);
/*
** Setup data
*/
data->win = win;
if((data->icon = GetDiskObject((STRPTR)"PROGDIR:OpenURL")) != NULL)
superset(cl,obj,MUIA_Application_DiskObject,data->icon);
/* Menus */
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_About),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,1,MUIM_App_About);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_AboutMUI),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)MUIV_Notify_Application,2,MUIM_Application_AboutMUI,(IPTR)win);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Hide),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,3,MUIM_Set,MUIA_Application_Iconified,TRUE);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Quit),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Save),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)win,2,MUIM_Win_StorePrefs,MUIV_Win_StorePrefs_Save);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Use),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)win,2,MUIM_Win_StorePrefs,MUIV_Win_StorePrefs_Use);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_LastSaved),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_LastSaveds);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Restore),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_Restore);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_Defaults),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_App_GetPrefs,MUIV_App_GetPrefs_Defaults);
DoMethod((Object *)DoMethod(strip,MUIM_FindUData,MSG_Menu_MUI),MUIM_Notify,MUIA_Menuitem_Trigger,MUIV_EveryTime,(IPTR)obj,2,MUIM_Application_OpenConfigWindow,0);
/* Menus help */
DoSuperMethod(cl,obj,MUIM_Notify,MUIA_Application_MenuHelp,MUIV_EveryTime,MUIV_Notify_Self,
5,MUIM_Application_ShowHelp,(IPTR)win,(IPTR)APPHELP,(IPTR)"MENUS",0);
/*
** Load list formats
*/
DoSuperMethod(cl,obj,MUIM_Application_Load,(IPTR)MUIV_Application_Load_ENV);
/*
** Try to get OpenURL prefs and open window
*/
if (!DoMethod(win,MUIM_Win_GetPrefs,MUIV_Win_GetPrefs_Restore) || !openWindow(obj,win))
{
CoerceMethod(cl,obj,OM_DISPOSE);
return 0;
}
}
return (IPTR)obj;
}
static Object *bitmap_new(Class *cl, Object *obj, struct pRoot_New *msg)
{
struct TagItem tags[] = {
{aHidd_BitMap_AllocBuffer, FALSE },
{TAG_MORE , (IPTR) NULL}
};
struct HIDDBitMapAmigaIntuiData *data;
struct TagItem *tag, *tstate, *newTagList;
BOOL ok = FALSE;
struct pRoot_New new_msg;
struct pHidd_BitMap_PrivateSet private_set_msg;
ULONG width, height, depth, format;
BOOL displayable;
EnterFunc(bug("BitMapAmigaIntui::New()\n"));
new_msg.mID = GetMethodID(IID_Root, moRoot_New);
private_set_msg.mID = GetMethodID(IID_Hidd_BitMap, moHidd_BitMap_PrivateSet);
displayable = (BOOL) GetTagData(aHidd_BitMap_Displayable, 0, msg->attrList);
if(!displayable)
{
/* let the superclass do all work */
obj = (Object *) DoSuperMethod(cl, obj, (Msg) msg);
if(obj) ok = TRUE;
}
else
{
/*
aHidd_BitMap_AllocBuffer and aHidd_BitMap_Displayable must be
FALSE. To make this easy first a copy of the taglist is
created. In the new list Hidd_BitMap_Displayable is set to
FALSE. If the taglist contains a "aHidd_BitMap_AllocBuffer"
tag then ti_Data is set to FALSE else tags(see above) is
connected with the new list.
NOTE: If msg.attrList contains more than one
"aHidd_BitMap_AllocBuffer" we have a problem.
*/
newTagList = CloneTagItems(msg->attrList);
if(newTagList)
{
tag = FindTagItem(aHidd_BitMap_Displayable, newTagList);
if(tag)
{
tag->ti_Data = FALSE;
}
tag = FindTagItem(aHidd_BitMap_AllocBuffer, newTagList);
if(tag)
{
tag->ti_Data = FALSE;
new_msg.attrList = newTagList;
}
else
{
tags[1].ti_Data = (IPTR) newTagList;
new_msg.attrList = tags;
}
obj = (Object *) DoSuperMethod(cl, obj, (Msg) &new_msg);
FreeTagItems(newTagList);
}
if(obj)
{
data = INST_DATA(cl, obj);
/* clear all data and set some default values */
memset(data, 0, sizeof(struct HIDDBitMapAmigaIntuiData));
GetAttr(obj, aHidd_BitMap_Width, &width);
GetAttr(obj, aHidd_BitMap_Height, &height);
GetAttr(obj, aHidd_BitMap_Depth, &depth);
GetAttr(obj, aHidd_BitMap_Format, &format);
if(format == vHIDD_BitMap_Format_Planar)
{
/* only displayable support for planar format */
struct TagItem tags[] =
{
{SA_Left , 0},
{SA_Top , 0},
{SA_Width , width},
{SA_Height , height},
{SA_Depth , depth},
{TAG_SKIP , 1}, /* Use SA_DisplayID only wenn a display mode */
{SA_DisplayID, 0}, /* is specified */
{SA_Title , (ULONG) "AROS graphics hidd"},
{SA_Type , CUSTOMSCREEN},
/* Will be use later */
/* SA_Quiet , TRUE, */
/* SA_BitMap , 0 On V37 double buffering could only
implemented with a custom bitmap */
{TAG_DONE, 0}
};
data->screen = OpenScreenTagList(NULL, tags);
if(data->screen)
{
struct TagItem set[] =
{
{aHidd_BitMap_BaseAddress, (IPTR) &data->screen->RastPort.BitMap->Planes[0]},
{aHidd_BitMap_Format , vHIDD_BitMap_Format_Planar},
{aHidd_BitMap_Displayable, TRUE },
{aHidd_BitMap_BytesPerRow, data->screen->RastPort.BitMap->BytesPerRow},
{TAG_END , 0 }
};
private_set_msg.attrList = set;
DoSuperMethod(cl, obj, (Msg) &private_set_msg);
ok = TRUE;
} /* if(data->screen) */
} /* if(format == vHIDD_BitMap_Format_Planar) */
} /* if(obj) */
} /* if(!displayable) */
/* free all on error */
if(ok == FALSE)
{
if(obj) DisposeObject(obj);
obj = NULL;
}
ReturnPtr("BitMapAmigaIntui::New", Object *, obj);
}
STATIC IPTR scroller_set(Class * cl, Object * o, struct opSet * msg)
{
IPTR retval = 0UL;
struct TagItem *tag, tags[] =
{
{PGA_Total , 0 },
{PGA_Top , 0 },
{PGA_Visible , 0 },
{TAG_MORE }
};
const struct TagItem *tstate = msg->ops_AttrList;
struct ScrollerData *data = INST_DATA(cl, o);
D(bug("scroller_set(cl 0x%lx o 0x%lx msg 0x%lx)\n",cl,o,msg));
tags[3].ti_Data = (IPTR)msg->ops_AttrList;
/* Get old values */
DoSuperMethod(cl, o, OM_GET, PGA_Total, (IPTR) &(tags[0].ti_Data));
DoSuperMethod(cl, o, OM_GET, PGA_Top, (IPTR) &(tags[1].ti_Data));
DoSuperMethod(cl, o, OM_GET, PGA_Visible, (IPTR) &(tags[2].ti_Data));
D(bug("scroller_set: Old Total %ld Top %ld Visible %ld\n",
tags[0].ti_Data,
tags[1].ti_Data,
tags[2].ti_Data));
while ((tag = NextTagItem(&tstate)))
{
switch (tag->ti_Tag)
{
case GTA_GadgetKind:
data->gadgetkind = tag->ti_Data;
break;
case GTSC_Total:
D(bug("scroller_set: GTSC_Total %ld\n",tag->ti_Data));
tags[0].ti_Data = tag->ti_Data;
break;
case GTSC_Top:
D(bug("scroller_set: GTSC_Top %ld\n",tag->ti_Data));
tags[1].ti_Data = tag->ti_Data;
break;
case GTSC_Visible:
D(bug("scroller_set: GTSC_Visible %ld\n",tag->ti_Data));
tags[2].ti_Data = tag->ti_Data;
break;
case GTA_Scroller_Dec:
if (tags[1].ti_Data > 0)
{
tags[1].ti_Data --;
retval = 1UL;
}
break;
case GTA_Scroller_Inc:
/* Top < (Total - Visible) ? */
if (tags[1].ti_Data < (tags[0].ti_Data - tags[2].ti_Data))
{
tags[1].ti_Data ++;
retval = 1UL;
}
break;
case GTA_Scroller_Arrow1:
data->arrow1 = (struct Gadget *)tag->ti_Data;
break;
case GTA_Scroller_Arrow2:
data->arrow2 = (struct Gadget *)tag->ti_Data;
break;
case GA_Disabled:
{
struct TagItem set_tags[] =
{
{GA_Disabled , tag->ti_Data },
{TAG_DONE }
};
if (data->arrow1)
{
if (msg->ops_GInfo)
{
SetGadgetAttrsA(data->arrow1, msg->ops_GInfo->gi_Window, 0, set_tags);
} else {
SetAttrsA((Object *)data->arrow1, set_tags);
}
}
if (data->arrow2)
{
if (msg->ops_GInfo)
{
SetGadgetAttrsA(data->arrow2, msg->ops_GInfo->gi_Window, 0, set_tags);
} else {
SetAttrsA((Object *)data->arrow2, set_tags);
}
}
}
break;
} /* switch (tag->ti_Tag) */
} /* while ((tag = NextTagItem(&tstate))) */
DoSuperMethod(cl, o, OM_SET, (IPTR) tags, (IPTR) msg->ops_GInfo);
return (retval);
}
ULONG STDARGS
DoSuperNew(struct IClass *cl,Object *obj,ULONG tag1,...)
{
return DoSuperMethod(cl,obj,OM_NEW,&tag1,NULL);
}
IPTR PUBLIC DispatchScrollerGadget(REG(a0, Class *cl), REG(a2, Object *o), REG(a1, Msg msg))
{
struct ScrollerGData *sd;
struct ClassBase *cb;
IPTR retval = 0;
sd = INST_DATA(cl,o);
cb = (APTR)cl->cl_UserData;
switch(msg->MethodID)
{
case OM_NEW:
if ((retval = DoSuperMethodA(cl,o,msg)) != 0)
{
struct Gadget *gad = (struct Gadget *)retval;
sd = INST_DATA(cl,retval);
if (DispatchScrollerNew(cb,sd,gad,(struct opSet *)msg))
{
//gad->NextGadget = sd->sd_Down;
SetAttrs((APTR)retval,GA_Left, gad->LeftEdge+4,
GA_Top, gad->TopEdge+2,
GA_Width, gad->Width-8,
GA_Height, gad->Height-2*sd->sd_UpImage->Height-4,
PGA_Total, GetTagData(PGA_Total,0,((struct opSet *)msg)->ops_AttrList),
GA_RelVerify, TRUE,
TAG_END);
}
else
{
DoMethod(o,OM_DISPOSE);
retval = 0;
}
}
break;
case OM_UPDATE:
{
struct opUpdate *opu = (APTR)msg;
long move = 0;
retval = DoSuperMethodA(cl,o,msg);
if ((move = -GetTagData(SGA_Up,0,opu->opu_AttrList)) != 0)
if (!(sd->sd_Up->Flags & GFLG_SELECTED))
move = 0;
if (!move && (move = GetTagData(SGA_Down,0,opu->opu_AttrList)))
if (!(sd->sd_Down->Flags & GFLG_SELECTED))
move = 0;
if (move)
{
long top;
if (GetAttr(PGA_Top,o,(IPTR *)&top))
{
top += move;
if (top >= 0)
{
struct RastPort *rp = ObtainGIRPort(opu->opu_GInfo);
struct TagItem tags[] = {{PGA_Top,0},{TAG_END}};
SetAttrs(o,PGA_Top,top,TAG_END);
GetAttr(PGA_Top,o,&tags[0].ti_Data);
DoSuperMethod(cl,o,OM_NOTIFY,tags,opu->opu_GInfo,0);
DoSuperMethod(cl,o,GM_RENDER,opu->opu_GInfo,rp,GREDRAW_UPDATE);
ReleaseGIRPort(rp);
}
}
}
break;
}
case OM_DISPOSE:
DisposeObject(sd->sd_UpImage);
DisposeObject(sd->sd_DownImage);
DisposeObject(sd->sd_Up);
DisposeObject(sd->sd_Down);
DisposeObject(sd->sd_Frame);
retval = DoSuperMethodA(cl,o,msg);
break;
case GM_RENDER:
{
struct gpRender *gpr = (struct gpRender *)msg;
DrawImage(gpr->gpr_RPort,sd->sd_Frame,0,0);
retval = DoSuperMethodA(cl,o,msg);
break;
}
default:
retval = DoSuperMethodA(cl,o,msg);
}
return(retval);
}
