/*
 *	File:					TASK_About.c
 *	Description:	About requester window.
 *
 *	(C) 1995 Ketil Hunn
 *
 */

#ifndef TASK_ABOUT_C
#define TASK_ABOUT_C

/*** PRIVATE INCLUDES ****************************************************************/
#include "System.h"
#include "AboutLogo.h"
#include "Designer_AREXX.h"
#include "TASK_About.h"

/*** DEFINES *************************************************************************/
#define	GID_ABOUTOK		1

/*** GLOBALS *************************************************************************/
struct egTask		aboutTask;
struct Image		aboutImage;

struct List			*aboutlist;
UBYTE						*abouttext;

struct egGadget *aboutversion,
								*aboutok,
								*aboutlistview;
WORD						aboutsize;

/*** FUNCTIONS ***********************************************************************/

__asm __saveds ULONG RefreshAboutTask(register __a0 struct Hook *hook,
																			register __a2 APTR	      object,
																			register __a1 APTR	      message)
{
#ifdef MYDEBUG_H
	DebugOut("RefreshAboutTask");
#endif
	aboutImage.Width			=ABOUTLOGOWIDTH;
	aboutImage.Height			=ABOUTLOGOHEIGHT;
	aboutImage.Depth			=ABOUTLOGODEPTH;

	aboutImage.ImageData	=AboutLogo;
	aboutImage.PlanePick	=0x3;
	aboutImage.PlaneOnOff	=0x0;
	aboutImage.NextImage	=NULL;

	DrawImage(aboutTask.window->RPort, &aboutImage,
						X1(aboutversion)+(W(aboutversion)-ABOUTLOGOREALWIDTH)/2,
						Y1(aboutversion)-GadVSpace-ABOUTLOGOHEIGHT);
	return 1L;
}

__asm __saveds ULONG RenderAboutTask(register __a0 struct Hook *hook,
																		register __a2 APTR	      object,
																		register __a1 APTR	      message)
{
	WORD  posarray[1], sizearray[1];
	WORD	tmp;

#ifdef MYDEBUG_H
	DebugOut("RenderAboutTask");
#endif

	geta4();
	egCreateContext(eg, &aboutTask);

	sizearray[0]=(ULONG)egTextWidth(eg, egGetString(MSG__OK))+GadHInside*2;
	egSpreadGadgets(	posarray,
										sizearray,
										LeftMargin,
										LeftMargin+aboutsize, 1, TRUE);

	aboutok=egCreateGadget(eg,
								EG_Window,						aboutTask.window,
								EG_TextAttr,					fontattr,
								EG_GadgetKind,				BUTTON_KIND,
								EG_LeftEdge,					posarray[0],
								EG_DefaultHeight,			TRUE,
								EG_PlaceWindowBottom,	TRUE,
								EG_Width,							sizearray[0],
								EG_GadgetText,				egGetString(MSG__OK),
								EG_GadgetID,					GID_ABOUTOK,
								EG_Flags,							0,
								TAG_END);

	ClearList(aboutlist);
	TextToList(	aboutlist,
							abouttext,
							aboutTask.window->Width-RightMargin-(LeftMargin+aboutsize+GadHSpace));

	aboutlistview=egCreateGadget(eg,
								EG_GadgetKind,			LISTVIEW_KIND,
								EG_LeftEdge,				tmp=LeftMargin+aboutsize+GadHSpace,
								EG_PlaceWindowTop,	TRUE,
								EG_Width,						aboutTask.window->Width-RightMargin-tmp,
								EG_Height,					Y2(aboutok)-TopMargin,
								EG_GadgetText,			NULL,
								EG_Arrows,					TRUE,
								EG_GadgetID,				0,
								GTLV_Labels,				aboutlist,
								GTLV_ReadOnly,			TRUE,
								TAG_END);

	{
		register UBYTE version[MAXCHARS];

		sprintf(version, egGetString(MSG_VERSION), VERS);
		aboutversion=egCreateGadget(eg,
									EG_GadgetKind,			TEXT_KIND,
									EG_PlaceWindowLeft,	TRUE,
									EG_TopEdge,					MAX(TopMargin+ABOUTLOGOHEIGHT+GadVSpace, TopMargin+Y2(aboutok)/2+GadVSpace),
									EG_Width,						tmp=egTextWidth(eg, version),
									EG_LeftEdge,				LeftMargin+(ABOUTLOGOREALWIDTH-tmp)/2,
									EG_DefaultHeight,		TRUE,
									GTTX_Text,					version,
									GTTX_CopyText,			TRUE,
									TAG_END);
	}
	return 1L;
}

__asm BYTE TextToList(register __a0 struct List *list,
											register __a1 UBYTE				*text,
											register __d0 UWORD				width)
{
	register BYTE success=FALSE;

#ifdef MYDEBUG_H
	DebugOut("TextToList");
#endif

	if(list && text)
	{
		register UBYTE	*start=text,
										cc,
										*laststop=NULL;

		/* subtract border width */
		width-=25;
		while(*text!='\0')
		{
			while(*text!='\n' && *text!=' ' && *text!='\0')
				text++;

			cc=*text;
			*text='\0';
			if(cc==' ' && TextLength(&eg->RPort, start, text-start)>width)
			{
				if(laststop)
				{
					*laststop='\0';
					AddNode(list, NULL, start);
					*laststop=' ';
					*text=cc;
					text=laststop;
					cc=~0;
					laststop=NULL;
				}
				else
					AddNode(list, NULL, start);
				start=text+1;
			}
			else if(cc=='\n' | cc=='\0')
			{
				if(laststop && TextLength(&eg->RPort, start, text-start)>width)
				{
					register UBYTE lcc=*laststop;

					*laststop='\0';
					AddNode(list, NULL, start);
					*laststop=lcc;
					*text=cc;
					text=laststop;
					cc=~0;
					laststop=NULL;
				}
				else
					AddNode(list, NULL, start);
				start=text+1;
			}
			else
				laststop=text;
			if(cc!=~0)
				*text=cc;
			if(*text!='\0')
				*text++;
		}
		success=TRUE;
	}
	return success;
}

__asm __saveds ULONG CloseAboutTask(register __a0 struct Hook *hook,
																		register __a2 APTR	      object,
																		register __a1 APTR	      message)
{
#ifdef MYDEBUG_H
	DebugOut("CloseAboutTask");
#endif

	FreeVec(abouttext);
	FreeList(aboutlist);

	if(record)
		AddARexxMacroCommand(	macro,
													ER_Command,	"WINDOW ABOUT CLOSE",
													TAG_DONE);
	return 1L;
}
__asm __saveds ULONG OpenAboutTask(	register __a0 struct Hook *hook,
																		register __a2 APTR	      object,
																		register __a1 APTR	      message)
{
	WORD minwidth, minheight;
	UBYTE *aboutwintitle=egGetString(MSG_HELPABOUT);

#ifdef MYDEBUG_H
	DebugOut("OpenAboutTask");
#endif

	geta4();
	if(egTaskToFront(&aboutTask))
			return FALSE;

	aboutsize=egMaxLen(eg,	egGetString(MSG_VERSION),
													egGetString(MSG__OK),
													NULL)+GadHInside;
	aboutsize=MAX(aboutsize, ABOUTLOGOWIDTH);

	minwidth=LeftMargin+aboutsize*2+GadHSpace+RightMargin;
	minheight=TopMargin+ABOUTLOGOHEIGHT+GadDefHeight*2+GadVSpace*2+BottomMargin;

	if(aboutlist=InitList())
	{
		register UBYTE *portname=(context==NULL ? egGetString(MSG_NOAREXXPORT):context->portname);

		if(abouttext=AllocVec((strlen(GetString(&li, MSG_ABOUTTEXT))+strlen(NAME)
																													+strlen(VERS)
																													+strlen(COPYRIGHT)
																													+strlen(DATE)
																													+strlen(TIME))
																													+strlen(portname)
																													+strlen(env.pubname)
																													+1, MEMF_CLEAR))
			sprintf(abouttext, egGetString(MSG_ABOUTTEXT), NAME, VERS, COPYRIGHT, DATE, TIME, portname, env.pubname);
	}

	if(*aboutwintitle!='\0' && (*(aboutwintitle+1)=='\0'))
		aboutwintitle=aboutwintitle+2;

	if(egOpenTask(&aboutTask,
							WA_Title,					aboutwintitle,
							WA_Width,					MAX(minwidth, aboutTask.coords.Width),
							WA_Height,				MAX(minheight, aboutTask.coords.Height),
							WA_MinWidth,			minwidth,
							WA_MinHeight,			minheight,
							WA_MaxWidth,			~0,
							WA_MaxHeight,			~0,
							WA_AutoAdjust,		TRUE,
							WA_Activate,			TRUE,
							WA_DragBar,				TRUE,
							WA_DepthGadget,		TRUE,
							WA_SizeGadget,		TRUE,
							WA_SizeBBottom,		TRUE,
							WA_CloseGadget,		TRUE,
							WA_SimpleRefresh,	env.simplerefresh,
							WA_PubScreen,			mainTask.screen,
							EG_OpenFunc,			(ULONG)OpenAboutTask,
							EG_CloseFunc,			(ULONG)CloseAboutTask,
							EG_RefreshFunc,		(ULONG)RefreshAboutTask,
							EG_RenderFunc,		(ULONG)RenderAboutTask,
							EG_HandleFunc,		(ULONG)HandleAboutTask,
							EG_IDCMP,					IDCMP_CLOSEWINDOW|
																SCROLLERIDCMP|
																ARROWIDCMP|
																IDCMP_GADGETDOWN|
																IDCMP_MENUPICK|
																IDCMP_GADGETUP,
							EG_InitialCentre,	TRUE,
							EG_IconifyGadget,	TRUE,
							EG_HelpNode,			"Description",
							EG_LendMenu,			mainMenu,
							TAG_END))
	{
		if(record)
			SetPointer(	aboutTask.window,
									ER_RecordPointer,
									ER_RECORDPOINTERHEIGHT,
									ER_RECORDPOINTERWIDTH,
									ER_RECORDPOINTEROFFSET,
									0);
		return TRUE;
	}
	return FALSE;
}

__asm __saveds ULONG HandleAboutTask(register __a0 struct Hook *hook,
																		register __a2 APTR	      object,
																		register __a1 APTR	      message)
{
	struct IntuiMessage *msg=eg->msg;

	switch(msg->Class)
	{
		case IDCMP_MENUPICK:
			HandleMainMenu(&mainTask, msg->Code);
			break;
		case IDCMP_GADGETUP:
			switch(((struct Gadget *)msg->IAddress)->GadgetID)
			{
				case GID_ABOUTOK:
					egCloseTask(&aboutTask);
					break;
			}
		break;
	}
	return 1L;
}

#endif