/* PowerWindows: Boopsi.c */

#include <dos/dos.h>
#include <graphics/gfx.h>
#include <intuition/intuition.h>
#include <intuition/imageclass.h>
#include <intuition/gadgetclass.h>
#include <utility/utility.h>

#include <pragma/exec_lib.h>
#include <pragma/dos_lib.h>
#include <pragma/utility_lib.h>
#include <pragma/intuition_lib.h>
#include <pragma/graphics_lib.h>
#include <pragma/timer_lib.h>
#include <pragma/commodities_lib.h>
#include <pragma/input_lib.h>
#include <clib/alib_protos.h>

#pragma header

#include <stdlib.h>
#include <string.h>

#include "config.h"
#include "PowerWindows.h"
#include "PWDevelopper.h"

extern struct Library *InputBase;

static void DoIconActivateWin(struct MyButtonData *MyData)
{
	struct ActionMsg *MyMsg;

	SendActionMsg(MyMsg,MyData->ParentWindow,
							 MyData->WindowLeft,
							 MyData->WindowTop,
							 0,	/* IconWin auf 0, sonst versucht der ActionPort es zu de-iconifizieren! */
							 FindScreen(MyData->ParentWindow->WLayer->LayerInfo),
							 AM_ACTIVATEWINDOW);

}


/* MyImageDispatcher ==============================================================*/

ULONG MyImageDispatcher(struct IClass *Klasse,struct Image *im,Msg msg)
{
	struct MyImageData *data;
	struct cwRenderIG rendermsg;
	struct RastPort *rp;
	struct DrawInfo *di;
	struct TagItem *ti;
	
	ULONG rc=0;

	WORD	x,y,x1,y1,x2,y2,dx,dy,state;
	BOOL	IsSelected,IsInactive;
	
	switch (msg->MethodID)
	{
		case OM_NEW:
			im=(struct Image *)DoSuperMethodA(Klasse,(Object *)im,msg);
			if (im)
			{
				data=INST_DATA(Klasse,im);
				if ((ti=FindTagItem(SYSIA_Which,((struct opSet *)msg)->ops_AttrList)))
				{
					data->ImageTyp=ti->ti_Data;
				} else {
					data->ImageTyp=IMAGE_ICONIFYGADGET;
				}
				if ((ti=FindTagItem(CGA_ParentWindow,((struct opSet *)msg)->ops_AttrList)))
				{
					data->win=(struct Window *)ti->ti_Data;
				}
				MyImageClassCounter++;
				rc=(ULONG)im;
			}
			break;
		
		case OM_DISPOSE:
			MyImageClassCounter--;
			rc=DoSuperMethodA(Klasse,(Object *)im,msg);
			break;

		case IM_DRAW:
		case IM_DRAWFRAME:
			data=INST_DATA(Klasse,im);
			
			switch(data->ImageTyp)
			{
				case IMAGE_ICONIFYGADGET:
					if (MyConfig.WindowChecker_Seg)
					{
						rendermsg.MethodID=CW_RENDERIG;
						rendermsg.GadImage=im;
						rendermsg.DrawImageMsg=(struct impDraw *)msg;
						if ((*MyConfig.WindowChecker)((Msg)&rendermsg)!=0) return 0;
					}
					if (!(di=((struct impDraw *)msg)->imp_DrInfo)) return FALSE;
					
					x1=((struct impDraw *)msg)->imp_Offset.X+im->LeftEdge;
					y1=((struct impDraw *)msg)->imp_Offset.Y+im->TopEdge;
					x2=x1-1+(msg->MethodID==IM_DRAW ? im->Width : ((struct impDraw *)msg)->imp_Dimensions.Width);
					y2=y1-1+(msg->MethodID==IM_DRAW ? im->Height : ((struct impDraw *)msg)->imp_Dimensions.Height);
					dx=(x2-x1+1)*23/100;dy=(y2-y1+1)*22/100;
					
					rp=((struct impDraw *)msg)->imp_RPort;
					state=((struct impDraw *)msg)->imp_State;
					
					IsInactive=((state==IDS_INACTIVENORMAL) || (state==IDS_INACTIVESELECTED) || (state==IDS_INACTIVEDISABLED));
					IsSelected=((state==IDS_SELECTED) || (state==IDS_INACTIVESELECTED) || (state==IDS_SELECTEDDISABLED));
		
					SetDrMd(rp,JAM2);
					SetAPen(rp,IsInactive ? di->dri_Pens[BACKGROUNDPEN] : di->dri_Pens[FILLPEN]);
					RectFill(rp,x1+2,y1+1,x2-1,y2-1); /* Hintergrund */
					SetAPen(rp,di->dri_Pens[SHADOWPEN]);
					RectFill(rp,x1,y1+1,x1,y2-1);			/* schwarzer Strich links */
				
					SetAPen(rp,IsSelected ? di->dri_Pens[SHADOWPEN] : di->dri_Pens[SHINEPEN]);
					RectFill(rp,x1+1,y1,x1+1,y2-1);		/* Kante links */
					RectFill(rp,x1,y1,x2,y1);			/* Kante oben */
					SetAPen(rp,IsSelected ? di->dri_Pens[SHINEPEN] : di->dri_Pens[SHADOWPEN]);
					RectFill(rp,x2,y1+1,x2,y2);			/* Kante rechts */
					RectFill(rp,x1+1,y2,x2-1,y2);		/* Kante unten */
				
					switch (MyConfig.IconImageType)
					{
						case ICONIMAGE_NORMAL:
						case ICONIMAGE_VISUALPREFS:

							x=(IsSelected ? x1+1+dx+7 : x2-dx);			/* rechts von innerem Rechteck */
							y=(IsSelected ? y2-dy-6 : y1+dy);			/* oben von innerem Rechteck */
							
							SetAPen(rp,di->dri_Pens[SHADOWPEN]);
							RectFill(rp,x1+1+dx,y,x,y);				/* kl. oben */
							RectFill(rp,x,y,x,y2-dy);				/* kl. rechts */
							RectFill(rp,x1+1+dx,y2-dy,x,y2-dy);	/* kl. unten */
							RectFill(rp,x1+1+dx,y,x1+1+dx,y2-dy); /* kl. links */
				
							RectFill(rp,x1+1+dx+2,y2-dy-6+2,x1+1+dx+7-2,y2-dy-2); /* icon rahmen */
							
							SetAPen(rp,IsInactive ? di->dri_Pens[BACKGROUNDPEN] : di->dri_Pens[SHINEPEN]);
							RectFill(rp,x1+1+dx+2+1,y2-dy-6+2+1,x1+1+dx+7-2-1,y2-dy-2-1);
							break;
							
						case ICONIMAGE_NICE:
							if (!IsSelected)
							{
								SetAPen(rp,di->dri_Pens[SHADOWPEN]);
								RectFill(rp,x1+dx,y1+dy,x2-dx,y1+dy);
								RectFill(rp,x2-dx,y1+dy,x2-dx,y2-dy);
								RectFill(rp,x1+dx,y2-dy,x2-dx,y2-dy);
								RectFill(rp,x1+dx,y1+dy,x1+dx,y2-dy);			/* Rechteck */
								y=((y2-y1)<11) ? y1+dy+2 : y1+dy+3;
								RectFill(rp,x1+dx,y,x2-dx,y);
		
								if (IsInactive) SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]); else SetAPen(rp,di->dri_Pens[SHINEPEN]);
								RectFill(rp,x1+dx+1,y1+dy+1,x2-dx-1,y-1);	/* Balken */
								
								if (IsInactive) SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]); else SetAPen(rp,di->dri_Pens[FILLPEN]);
								RectFill(rp,x1+dx+1,y1+dy+4,x2-dx-1,y2-dy-1);
								
								SetAPen(rp,di->dri_Pens[SHADOWPEN]);
								RectFill(rp,x1+dx+1,y2-dy-2,x1+dx+7,y2-dy-1);
								SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]);
								RectFill(rp,x1+dx+1,y2-dy-1,x1+dx+6,y2-dy-1);
							} else {
								SetAPen(rp,di->dri_Pens[SHADOWPEN]);
								RectFill(rp,x1+dx,y2-dy-2,x1+dx+7,y2-dy);
								if (IsInactive) SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]); else SetAPen(rp,di->dri_Pens[SHINEPEN]);
								RectFill(rp,x1+dx+1,y2-dy-1,x1+dx+6,y2-dy-1);
							}
							break;
		
						case ICONIMAGE_SYSI:
							x=(IsSelected ? x1+1+dx+7 : x2-dx);			/* rechts von innerem Rechteck */
							y=(IsSelected ? y2-dy-6 : y1+dy);			/* oben von innerem Rechteck */
							
							SetAPen(rp,di->dri_Pens[SHADOWPEN]);
							RectFill(rp,x1+1+dx,y,x1+1+dx,y2-dy); /* kl. links */
							RectFill(rp,x1+1+dx,y,x,y);				/* kl. oben */
							SetAPen(rp,di->dri_Pens[SHINEPEN]);
							
							RectFill(rp,x,y,x,y2-dy);				/* kl. rechts */
							RectFill(rp,x1+1+dx,y2-dy,x,y2-dy);	/* kl. unten */
				
							RectFill(rp,x1+1+dx+2,y2-dy-6+2,x1+1+dx+7-2,y2-dy-2);
							SetAPen(rp,di->dri_Pens[SHADOWPEN]);
							RectFill(rp,x1+1+dx+3,y2-dy-6+3,x1+1+dx+7-2,y2-dy-2); /* icon rahmen */
		
							SetAPen(rp,IsInactive ? di->dri_Pens[BACKGROUNDPEN] : di->dri_Pens[FILLPEN]);
							RectFill(rp,x1+1+dx+2+1,y2-dy-6+2+1,x1+1+dx+7-2-1,y2-dy-2-1);
							break;
		
						case ICONIMAGE_SYSIMUI:
							x1+=dx;x2-=dx;x=(x2-x1+1)/2-1;
							y1+=dy;y2-=dy;y=(y2-y1+1)*45/100;
							if (IsSelected) x2-=(x-1);
							SetAPen(rp,di->dri_Pens[IsSelected ? SHINEPEN : SHADOWPEN]);
							RectFill(rp,x1,y1,x1,y2);
							RectFill(rp,x1+1,y1,x2,y1);

							RectFill(rp,x1+1+1,y2-1,x1+x,y2-1);
							RectFill(rp,x1+x,y1+y+1,x1+x,y2-1-1);

							SetAPen(rp,di->dri_Pens[IsSelected ? SHADOWPEN : SHINEPEN]);
							RectFill(rp,x2,y1+1,x2,y2);
							RectFill(rp,x1+1,y2,x2-1,y2);

							RectFill(rp,x1+1,y1+y,x1+x,y1+y);
							RectFill(rp,x1+1,y1+y+1,x1+1,y2-1);
							break;

						case ICONIMAGE_SYSINICE:
							SetAPen(rp,di->dri_Pens[SHADOWPEN]);
							RectFill(rp,x1+dx,y1+dy,x1+dx,y2-dy);			/* Rechteck */
							RectFill(rp,x1+dx,y1+dy,x2-dx,y1+dy);
							SetAPen(rp,di->dri_Pens[SHINEPEN]);
							RectFill(rp,x2-dx,y1+dy,x2-dx,y2-dy);
							RectFill(rp,x1+dx+1,y2-dy,x2-dx,y2-dy);
							y=((y2-y1)<11) ? y1+dy+3 : y1+dy+4;
	
							if (!IsSelected)
							{
								SetAPen(rp,di->dri_Pens[SHADOWPEN]);
								RectFill(rp,x1+dx+1,y1+dy+1,x2-dx-1,y);
								SetAPen(rp,di->dri_Pens[SHINEPEN]);
								RectFill(rp,x1+dx+1,y1+dy+1,x2-dx-2,y-1);
		
								if (IsInactive) SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]); else SetAPen(rp,di->dri_Pens[FILLPEN]);
								RectFill(rp,x1+dx+2,y1+dy+2,x2-dx-2,y-1);	/* Balken */
								
							} else {
								SetAPen(rp,di->dri_Pens[SHADOWPEN]);
								RectFill(rp,x1+dx+2,y2-dy-2,x1+dx+8,y2-dy-1);
								SetAPen(rp,di->dri_Pens[SHINEPEN]);
								RectFill(rp,x1+dx+1,y2-dy-3,x1+dx+8-1,y2-dy-2);
								if (IsInactive) SetAPen(rp,di->dri_Pens[BACKGROUNDPEN]); else SetAPen(rp,di->dri_Pens[FILLPEN]);
								RectFill(rp,x1+dx+2,y2-dy-2,x1+dx+7,y2-dy-2);
							}
							break;

					} /* switch (IconImageType */
					break;
					
				case IMAGE_ICONNODRAG:
					switch(((struct impDraw *)msg)->imp_State)
					{
						case IDS_SELECTED:
						case IDS_INACTIVESELECTED:
						   rc=RI_RENDERFRAMESEL;
						   break;
						
						default:
							rc=RI_RENDERFRAME;
							break;
					}
					
					if (!ExtIconRenderer)
					{
						RenderIconFrame(rc,data->win,((struct impDraw *)msg)->imp_RPort);
					} else {
						RenderIconFrameExt(rc,data->win,((struct impDraw *)msg)->imp_RPort);
					}
					break;

			} /* switch (data->ImageTyp) */
			
			rc=0;
			break;

		default :
			rc=DoSuperMethodA(Klasse,(Object *)im,msg);
			break;
	}
	return rc;
}

	
/* Image-Tester ==================================================================*/

#ifdef DebugMe

void ImageTester(void)
{
	struct Screen *scr=0;
	struct DrawInfo *di=0;
	struct RastPort *rp=0;
	struct Image *im=0;
	WORD	i;

	if (!MyImageClass) return;
	scr=LockPubScreen(0);
	if (!scr) return;
	rp=&scr->RastPort;
	di=GetScreenDrawInfo(scr);
	if (di)
	{
		im=NewObject(MyImageClass,0,
						SYSIA_Which,IMAGE_ICONIFYGADGET,
						IA_WIDTH,32,
						IA_HEIGHT,16,
						TAG_DONE);
		if (im)
		{
			for (i=0;i<=8;i++)
			{
				DrawImageState(rp,im,60*i,0,i,di);
			}
			DisposeObject(im);
		}
		FreeScreenDrawInfo(scr,di);
	}
	UnlockPubScreen(0,scr);
}

#endif




/* NEW_Button =====================================================================*/

static ULONG NEW_Button(struct IClass *Klasse,struct Gadget *gad,struct opSet *msg)
{
	struct MyButtonData *MyData,FirstData;
	struct TagItem *ti,*systypeti=0;
	ULONG dummy=0xCAFFEAFFE;

	memset(&FirstData,0,sizeof(FirstData));
	
	if ((!MyConfig.NoDGPatch) &&
	    (systypeti=FindTagItem(GA_SysGType,msg->ops_AttrList)))
	{
		if (systypeti->ti_Data==GTYP_WDEPTH)
		{
			systypeti->ti_Tag=TAG_IGNORE;
			FirstData.GadgetType=GADGET_WINDOWDEPTH;
		} else systypeti=0;
	}

	if (!FirstData.GadgetType)
	{
		FirstData.GadgetType=GetTagData(GA_ID,0,msg->ops_AttrList);
	}
	
	if ((ti=FindTagItem(CGA_ParentWindow,msg->ops_AttrList)))
	{
		FirstData.ParentWindow=(struct Window *)ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}
	
	if ((ti=FindTagItem(CGA_WindowTitle,msg->ops_AttrList)))
	{
		FirstData.WindowTitle=(STRPTR)ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}
	
	if ((ti=FindTagItem(CGA_WindowLeft,msg->ops_AttrList)))
	{
		FirstData.WindowLeft=ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}
	
	if ((ti=FindTagItem(CGA_WindowTop,msg->ops_AttrList)))
	{
		FirstData.WindowTop=ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}
	
	if ((ti=FindTagItem(CGA_UserDataIcon,msg->ops_AttrList)))
	{
		FirstData.UserDataIcon=(APTR)ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}

	if ((ti=FindTagItem(CGA_Task,msg->ops_AttrList)))
	{
		FirstData.task=(struct Task *)ti->ti_Data;
		ti->ti_Tag=TAG_IGNORE;
	}

	gad=(struct Gadget *)DoSuperMethodA(Klasse,(Object *)gad,(Msg)msg);

	if (systypeti)	// wieder zurucksetzen, wenn wir die taglist illegalerweise geaendert haben
	{
		systypeti->ti_Tag=GA_SysGType;
		systypeti->ti_Data=GTYP_WDEPTH;
		
		if (gad) gad->GadgetID=GADGET_WINDOWDEPTH;
	}
	
	if (gad)
	{
		MyData=INST_DATA(Klasse,gad);
		*MyData=FirstData;

		GetSysTime(&MyData->Time2);
		MyData->Time2.tv_secs-=10;	/* erster Click soll nie Double-Click auslosen! */
		MyData->ThisGadget=gad;
		MyButtonClassCounter++;
	}
	return (ULONG)gad;
}	

/* DISPOSE_Button =================================================================*/

static ULONG DISPOSE_Button(struct IClass *Klasse,struct Gadget *gad,Msg msg)
{
	MyButtonClassCounter--;
	return DoSuperMethodA(Klasse,(Object *)gad,msg);
}

/* GET_Button =====================================================================*/

ULONG GET_Button(struct IClass *Klasse,struct Gadget *gad,struct opGet *msg)
{
	struct MyButtonData *MyData;
	ULONG rc=TRUE;

	MyData=INST_DATA(Klasse,gad);
	switch (msg->opg_AttrID)
	{
		case CGA_ParentWindow:
			*msg->opg_Storage=(ULONG)MyData->ParentWindow;
			break;
			
		case CGA_WindowTitle:
			*msg->opg_Storage=(ULONG)MyData->WindowTitle;
			break;

		case CGA_WindowLeft:
			*msg->opg_Storage=MyData->WindowLeft;
			break;

		case CGA_WindowTop:
			*msg->opg_Storage=MyData->WindowTop;
			break;

		case CGA_UserDataIcon:
			*msg->opg_Storage=(ULONG)MyData->UserDataIcon;
			break;

		case CGA_Task:
			*msg->opg_Storage=(ULONG)MyData->task;
			break;
			
		case GA_ID:
			*msg->opg_Storage=MyData->GadgetType;
			break;

		default:
			rc=DoSuperMethodA(Klasse,(Object *)gad,(Msg) msg);
			break;
	}
	return rc;
}

/* GOACTIVE_Button ================================================================*/

ULONG GOACTIVE_Button (struct IClass *Klasse,struct Gadget *gad,struct gpInput *msg)
{
	struct MyButtonData *MyData;
	struct Window *win;
	ULONG rc;

	MyData=INST_DATA(Klasse,gad);

	switch (MyData->GadgetType)
	{
		case GADGET_ICONDRAG:
			MyData->Time1=MyData->Time2;
			win=msg->gpi_GInfo->gi_Window;
			GetSysTime(&MyData->Time2);

			if (DoubleClick(MyData->Time1.tv_secs,MyData->Time1.tv_micro,MyData->Time2.tv_secs,MyData->Time2.tv_micro))
			{
				if ((abs(win->LeftEdge - MyData->Last_WindowLeft)<4) &&
				    (abs(win->TopEdge - MyData->Last_WindowTop)<4))
				{
					DoMethod((Object *)gad,CGM_DeIconify,win);
				}
			} else if (MyConfig.IconsActivateWin) {
				DoIconActivateWin(MyData);
			}

			MyData->Last_WindowLeft=win->LeftEdge;
			MyData->Last_WindowTop=win->TopEdge;

//			rc=DoSuperMethodA(Klasse,(Object *)gad,(Msg)msg);
//			break;
//			==> falls back to default anyway!
			
		default:
			rc=DoSuperMethodA(Klasse,(Object *)gad,(Msg)msg);
			break;
	}
	return rc;
}

/* HANDLEINPUT_Button =============================================================*/

ULONG HANDLEINPUT_Button(struct IClass *Klasse,struct Gadget *gad,struct gpInput *msg)
{
	struct MyButtonData *MyData;
	ULONG rc=FALSE;

	MyData=INST_DATA(Klasse,gad);

	rc=DoSuperMethodA(Klasse,(Object *)gad,(Msg)msg);
	
	switch (MyData->GadgetType)
	{
		case GADGET_ICONIFY:
			if (!(rc&GMR_MEACTIVE))
			{
				if (rc&GMR_VERIFY)
				{
					rc &= (~GMR_VERIFY);	/* Fenster darf keinen Message erhalten!!!! */

					SendActionMsg(MyMsg,msg->gpi_GInfo->gi_Window,
											 0,
											 0,
											 0,
											 FindScreen(msg->gpi_GInfo->gi_Window->WLayer->LayerInfo),
											 AM_ICONIFY);
				}
			}
			break;

		case GADGET_ICONDRAG:
			rc &= (~GMR_VERIFY);
			break;

		case GADGET_ICONCLOSE:
			if (rc&GMR_VERIFY)
			{
				SendActionMsg(MyMsg,MyData->ParentWindow,
										 0,
										 0,
										 0,
										 0,
										 AM_ICONCLOSEGADGET);
			}
			rc &= (~GMR_VERIFY);
			break;
			
		case GADGET_WINDOWDEPTH:
			if (!MyConfig.NoDGPatch)
			{
				if (rc&GMR_VERIFY)
				{
					rc &= (~GMR_VERIFY);
					DEPTH_Win=msg->gpi_GInfo->gi_Window;
					Signal(MainTask,DepthGadMask);
				}
			}
			break;

		case GADGET_ICONNODRAG:
			if (rc&GMR_VERIFY)
			{
				if ((gad=FindIconGadget(msg->gpi_GInfo->gi_Window)))
				{
					DoMethod((Object *)gad,CGM_DeIconify,msg->gpi_GInfo->gi_Window);
				}
			}
			rc &= (~GMR_VERIFY);
			break;
			
		default:
			rc &= (~GMR_VERIFY);
			break;
	}
	return rc;
}

/* HANDLEHIT_Button ===============================================================*/

ULONG HANDLEHIT_Button(struct IClass *Klasse, struct Gadget *gad, struct gpHitTest *msg)
{
	struct MyButtonData *MyData;
	struct Window *win;
	ULONG rc=0;
	
	MyData=INST_DATA(Klasse,gad);
	win=msg->gpht_GInfo->gi_Window;

	if (MyData->GadgetType==GADGET_ICONNODRAG &&
		 (PeekQualifier() & IEQUALIFIER_CONTROL))
	{
		rc=FALSE;
	} else {
		rc=DoSuperMethodA(Klasse,(Object *)gad,(Msg)msg);
	}

	return rc;
}

/* DEICONIFY_Button ===============================================================*/

ULONG DEICONIFY_Button(struct IClass *Klasse,struct Gadget *gad,struct gpDeIconify *msg)
{
	struct MyButtonData *MyData;
	struct ActionMsg *MyMsg;

	MyData=INST_DATA(Klasse,gad);

	SendActionMsg(MyMsg,MyData->ParentWindow,
							 MyData->WindowLeft,
							 MyData->WindowTop,
							 msg->gpdi_IconWindow,
							 FindScreen(MyData->ParentWindow->WLayer->LayerInfo),
							 AM_MOVEWINDOW);
	return FALSE;
}

/* ICONIFY_Button =================================================================*/

ULONG ICONIFY_Button(struct IClass *Klasse,struct Gadget *gad,Msg msg)
{
	struct MyButtonData *MyData;
	struct ActionMsg *MyMsg;
	struct ScreenEntry *se;
		
	MyData=INST_DATA(Klasse,gad);
	
	if ((se=FindScreen(MyData->ParentWindow->WLayer->LayerInfo)))
	{
		if (MyData->ParentWindow->LeftEdge >= (se->se_NormalWidth-MyConfig.IconifyOffset)) return FALSE;
		if (MyData->ParentWindow->TopEdge  >= (se->se_NormalHeight)) return FALSE;
	}

	SendActionMsg(MyMsg,MyData->ParentWindow,
							 0,
							 0,
							 0,
							 FindScreen(MyData->ParentWindow->WLayer->LayerInfo),
							 AM_ICONIFY);
	return FALSE;
}

/* MyButtonDispatcher =============================================================*/

ULONG MyButtonDispatcher(struct IClass *Klasse,struct Gadget *gad,Msg msg)
{
	ULONG rc;

	switch (msg->MethodID)
	{
		case OM_NEW:
			rc=NEW_Button(Klasse,gad,(struct opSet *)msg);
			break;

		case OM_DISPOSE:
			rc=DISPOSE_Button(Klasse,gad,msg);
			break;
			
		case OM_GET:
			rc=GET_Button(Klasse,gad,(struct opGet *)msg);
			break;
			
		case GM_GOACTIVE:
			rc=GOACTIVE_Button(Klasse,gad,(struct gpInput *)msg);
			break;
					
		case GM_HANDLEINPUT:
			rc=HANDLEINPUT_Button(Klasse,gad,(struct gpInput *)msg);
			break;

		case GM_HITTEST:
			rc=HANDLEHIT_Button(Klasse,gad,(struct gpHitTest *)msg);
			break;

		case CGM_DeIconify:
			rc=DEICONIFY_Button(Klasse,gad,(struct gpDeIconify *)msg);
			break;

		case CGM_Iconify:
			rc=ICONIFY_Button(Klasse,gad,msg);
			break;

		default:
			rc=DoSuperMethodA(Klasse,(Object *)gad,msg);
			break;
	}
	return rc;
}