/** DoRev Header ** Do not edit! **
*
* Name             :  winhand.c
* Copyright        :  Free Software
* Creation date    :  12-May-93
* Translator       :  SAS/C 6.2
* Compiler opts.   :  See Makefile
*
* Date       Rev  Author               Comment
* ---------  ---  -------------------  ----------------------------------------
* 22-May-93    1  Michael D. Bayne     Removed mouse blanker
* 12-May-93    0  Michael D. Bayne     Gadget/window handling for Blanker
*
*** DoRev End **/

#include <exec/types.h>
#include <exec/memory.h>
#include <intuition/intuition.h>
#include <libraries/gadtools.h>
#include <libraries/commodities.h>
#include <libraries/reqtools.h>
#include <graphics/displayinfo.h>

#include <dos/dos.h>
#include <dos/dostags.h>

#include <clib/exec_protos.h>
#include <clib/intuition_protos.h>
#include <clib/gadtools_protos.h>
#include <clib/commodities_protos.h>
#include <clib/graphics_protos.h>
#include <clib/reqtools_protos.h>
#include <clib/alib_protos.h>
#include <clib/dos_protos.h>

#include "defs.h"
#include "Blanker.h"

LONG UpdateCX( void );
void getInfo( UBYTE * );
LONG getBlanker( void );

extern	struct	Task *bTask, *Task;
extern	struct	Window *BlankerWnd;
extern	struct	MsgPort *blankerPort, *modulePort;
extern	struct	bMessage bMsg;
extern	struct	Gadget *BlankerGadgets[];
extern	struct	bPrefObject bPrefs;
extern	CxObj	*bBroker, *pHotKey, *bHotKey;
extern	ULONG	validPrefs;
	UBYTE	prefName[108] = "Blanker.prefs", prefDir[108] = "SYS:Prefs/Presets", modInfo[64];

void setPrefs( struct bPrefObject *cP, UBYTE gad )
{
	struct	NameInfo sInf;

	if(( gad == GD_TOUT )||( gad == Blanker_CNT ))
		GT_SetGadgetAttrs( BlankerGadgets[GD_TOUT], BlankerWnd, 0L, GTIN_Number, (cP->bTimeout)/10, 0L );
	if(( gad == GD_PKEY )||( gad == Blanker_CNT ))
		GT_SetGadgetAttrs( BlankerGadgets[GD_PKEY], BlankerWnd, 0L, GTST_String, cP->pKey, 0L );
	if(( gad == GD_BKEY )||( gad == Blanker_CNT ))
		GT_SetGadgetAttrs( BlankerGadgets[GD_BKEY], BlankerWnd, 0L, GTST_String, cP->bKey, 0L );
	if(( gad == GD_MDISPLAY )||( gad == Blanker_CNT )) {
		if( GetDisplayInfoData( 0l, ( UBYTE * )&sInf, sizeof( struct NameInfo ), DTAG_NAME, cP->sMod ))
			GT_SetGadgetAttrs( BlankerGadgets[GD_MDISPLAY], BlankerWnd, NULL, GTTX_Text, sInf.Name, NULL );
		else GT_SetGadgetAttrs( BlankerGadgets[GD_MDISPLAY], BlankerWnd, NULL, GTTX_Text, "No Monitor Info", NULL );
		GT_SetGadgetAttrs( BlankerGadgets[GD_SDEP], BlankerWnd, NULL, GTNM_Number, 1<<(cP->sDep), 0L );
	}
	if(( gad == GD_MODINFO )||( gad == Blanker_CNT ))
		GT_SetGadgetAttrs( BlankerGadgets[GD_MODINFO], BlankerWnd, NULL, GTTX_Text, modInfo, NULL );
	if( gad == Blanker_CNT )
		GT_SetGadgetAttrs( BlankerGadgets[GD_MEMRES], BlankerWnd, 0L, GTCY_Active, bPrefs.resident, TAG_END );
}

void loadPrefs( char *name, char *dir, struct bPrefObject *bPO )
{
	char path[256];
	BPTR prefFile;

	CopyMem( dir, path, 108 );
	if(( AddPart( path, name, 256 ))&&( prefFile = Open( path, MODE_OLDFILE ))) {
		if( FRead( prefFile, bPO, 1, sizeof( struct bPrefObject )) == sizeof( struct bPrefObject ))
			validPrefs = 1;
		else {
			rtEZRequest( "Error reading prefs file.", "OK", 0L, 0L, DEF_TAGS );
			validPrefs = 0;
		}
		Close( prefFile );
	} else rtEZRequest( "Could not open prefs file.", "OK", 0L, 0L, DEF_TAGS );
}

void savePrefs( char *name, char *dir, struct bPrefObject *bPO )
{
	char path[256];
	BPTR prefFile;

	CopyMem( dir, path, 108 );
	if(( AddPart( path, name, 256 ))&&( prefFile = Open( path, MODE_NEWFILE ))) {
		FWrite( prefFile, bPO, 1, sizeof( struct bPrefObject ));
		Close( prefFile );
	} else rtEZRequest( "Could not open prefs file.", "OK", 0L, 0L, DEF_TAGS );
}

void defBlanker( void )
{
	struct	Screen	*Scr;
	UWORD   CTable[] = { 0x0222, 0x0AAA, 0x0AAA };

	bTask = Task;

	Scr = OpenScreenTags( 0l, SA_DisplayID, bPrefs.sMod, SA_Depth, 1, SA_Quiet, TRUE, SA_Overscan,
		OSCAN_STANDARD, TAG_DONE );
	LoadRGB4( &(Scr->ViewPort), CTable, 2 );

	Wait( SIGBREAKF_CTRL_C );

	CloseScreen( Scr );
}

int TOUTClicked( void )
{
	bPrefs.bTimeout = 10*(((struct StringInfo*)(BlankerGadgets[GD_TOUT])->SpecialInfo)->LongInt);
	return( UpdateCX() );
}

int BKEYClicked( void )
{
	CopyMem( ((struct StringInfo *)(BlankerGadgets[GD_BKEY])->SpecialInfo )->Buffer, bPrefs.bKey, 256 );
	return( UpdateCX() );
}

int PKEYClicked( void )
{
	CopyMem( ((struct StringInfo *)(BlankerGadgets[GD_PKEY])->SpecialInfo )->Buffer, bPrefs.pKey, 256 );
	return( UpdateCX() );
}

int HIDEClicked( void )
{
	return( CLOSEWIN );
}

int SAVEClicked( void )
{
	savePrefs( "Blanker.prefs", "ENVARC:", &bPrefs );
	savePrefs( "Blanker.prefs", "ENV:", &bPrefs );
	return( OK );
}

int QUITClicked( void )
{
	return( QUIT );
}

int SMODEClicked( void )
{
	struct rtScreenModeRequester *smRequest;

	if( smRequest = rtAllocRequestA( RT_SCREENMODEREQ, 0l )) {
		rtChangeReqAttr( smRequest, RTSC_DisplayID, bPrefs.sMod, RTSC_DisplayDepth, bPrefs.sDep, TAG_END );
		if( rtScreenModeRequest( smRequest, "Screen Mode", RTSC_Flags, SCREQF_DEPTHGAD|SCREQF_NONSTDMODES,
			DEF_TAGS )) {
			bPrefs.sDep = smRequest->DisplayDepth;
			bPrefs.sMod = smRequest->DisplayID;
			setPrefs( &bPrefs, GD_MDISPLAY );
		}
		rtFreeRequest( smRequest );
	} else
		rtEZRequestTags( "Not enough memory to allocate\nscreen mode requester.", "OK", 0l, 0l, DEF_TAGS );
	return( OK );
}

int MEMRESClicked( void )
{
	if( modulePort ) {
		bMsg.bm_Type = BM_UNLOAD;
		PutMsg( modulePort, ( struct Message * )( &bMsg ));
		WaitPort( blankerPort );
		GetMsg( blankerPort );
		modulePort = 0l;
	}
	bPrefs.resident = BlankerMsg.Code;
	return( OK );
}

int BMODClicked( void )
{
	APTR	lock = rtLockWindow( BlankerWnd );

	if( getBlanker()) {
		if( bPrefs.resident ) bMsg.bm_Type = BM_PREFS;
		else bMsg.bm_Type = BM_PREFS|BM_QUIT;
		bMsg.bm_Valid = validPrefs;
		bMsg.prefData = bPrefs.prefData;
		PutMsg( modulePort, ( struct Message * )( &bMsg ));
		WaitPort( blankerPort );
		GetMsg( blankerPort );
		if( !bPrefs.resident ) modulePort = 0l;
		validPrefs = 1;
	} else rtEZRequest( "No module loaded.", "Ok", 0L, 0L, DEF_TAGS );

	rtUnlockWindow( BlankerWnd, lock );
	return( OK );
}

int LMODClicked( void )
{
	return( BlankerLoadMod());
}

int BlankerOpen( void )
{
	struct rtFileRequester *fRequest;

	if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
		rtChangeReqAttr( fRequest, RTFI_Dir, prefDir, RTFI_MatchPat, "#?.prefs", TAG_END );
		if( rtFileRequest( fRequest, prefName, "Please choose prefs file...", RTFI_Flags, FREQF_PATGAD,
			DEF_TAGS )) {
			loadPrefs( prefName, fRequest->Dir, &bPrefs );
			setPrefs( &bPrefs, Blanker_CNT );
			UpdateCX();
		}
	} else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
	return( OK );
}

int BlankerSaveAs( void )
{
	struct rtFileRequester *fRequest;

	if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
		rtChangeReqAttr( fRequest, RTFI_Dir, prefDir, RTFI_MatchPat, "#?.prefs", TAG_END );
		if( rtFileRequest( fRequest, prefName, "Please choose a save file...", RTFI_Flags,
			FREQF_SAVE|FREQF_PATGAD, DEF_TAGS )) savePrefs( prefName, fRequest->Dir, &bPrefs );
	} else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
	return( OK );
}

int BlankerAbout( void )
{
	rtEZRequestTags( BVERSION"\nby Michael D. Bayne", "Ok", 0L, 0L, DEF_TAGS );
	return( OK );
}

int BlankerLoadMod( void )
{
	struct rtFileRequester *fRequest;

	if( modulePort ) {
		bMsg.bm_Type = BM_UNLOAD;
		PutMsg( modulePort, ( struct Message * )( &bMsg ));
		WaitPort( blankerPort );
		GetMsg( blankerPort );
		modulePort = 0l;
	}

	if( fRequest = rtAllocRequest( RT_FILEREQ, 0L )) {
		rtChangeReqAttr( fRequest, RTFI_Dir, bPrefs.modDir, TAG_END );
		if( rtFileRequest( fRequest, bPrefs.modName, "Please choose blanker module...", RTFI_Flags,
			FREQF_PATGAD, DEF_TAGS )) {
			CopyMem( fRequest->Dir, bPrefs.modDir, 108 );
			validPrefs = 0;
			getInfo( modInfo );
			setPrefs( &bPrefs, GD_MODINFO );
		}
	} else rtEZRequestTags( "Couldn't allocate file requester.", "Ok", 0L, 0L, DEF_TAGS );
	return( OK );
}

int BlankerQuit( void )
{
	return( QUIT );
}

int BlankerLSaved( void )
{
	loadPrefs( "Blanker.prefs", "ENVARC:", &bPrefs );
	setPrefs( &bPrefs, Blanker_CNT );
	UpdateCX();
	return( OK );
}

int BlankerCloseWindow( void )
{
	return( CLOSEWIN );
}

int BlankerVanillaKey( void )
{
	switch( BlankerMsg.Code ) {
	case 'c':
		return( SMODEClicked() );
	case 'r':
		return( BMODClicked() );
	case 'l':
		return( BlankerLoadMod());
	case 'm':
		GT_SetGadgetAttrs( BlankerGadgets[GD_MEMRES], BlankerWnd, 0L, GTCB_Checked,
		bPrefs.resident = !bPrefs.resident, TAG_END );
		return( OK );
	case 't':
		ActivateGadget( BlankerGadgets[GD_TOUT], BlankerWnd, 0l );
		return( OK );
	case 'b':
		ActivateGadget( BlankerGadgets[GD_BKEY], BlankerWnd, 0l );
		return( OK );
	case 'p':
		ActivateGadget( BlankerGadgets[GD_PKEY], BlankerWnd, 0l );
		return( OK );
	case 'h':
		return( HIDEClicked() );
	case 's':
		return( SAVEClicked() );
	case 'q':
		return( QUIT );
	default:
		return( OK );
	}
}