/*
 *  FM_ReactionBasics.c
 *
 *  Basic functions for reaction-windows.
 *  V1.0, 05.06.2001
 *  Coded by Edgar Schwan
 */

#include <libraries/resource.h>
#include <libraries/gadtools.h>
#include <classes/window.h>

#include <clib/intuition_protos.h>
#include <clib/exec_protos.h>
#include <clib/locale_protos.h>
#include <clib/resource_protos.h>
#include <clib/alib_protos.h>

#include <pragmas/intuition_pragmas.h>
#include <pragmas/exec_pragmas.h>
#include <pragmas/locale_pragmas.h>
#include <pragmas/resource_pragmas.h>

#include "FM_ReactionBasics.h"
#include "FM_Reaction.h"
#include "FM_ReactionCD.h"

struct CatCompArrayType {
	LONG   cca_ID;
	STRPTR cca_Str;
	};

extern struct CatCompArrayType CatCompArray;
extern struct Library *ResourceBase;
//extern struct Library *LocaleBase;
extern struct Catalog *CatalogPtr;
extern ULONG RETURNVALUE;
extern struct TextAttr MYFONTSTRUCT;

struct MsgPort *IDCMPortPtr = NULL;
struct MsgPort *AppPortPtr = NULL;
RESOURCEFILE ResourcePtr = NULL;
struct Screen *LockedScreen = NULL;
BOOL ScreenSet = FALSE;

BOOL InitReaction(char *ScrPubName)
{
#if 0
return(FALSE);  /* Force GadTools-Windows */
#endif

if (ResourceBase = OpenLibrary("resource.library", 0L)) {
	if (LockedScreen = LockPubScreen((STRPTR) ScrPubName)) {
		if (IDCMPortPtr = CreateMsgPort()) {
			if (AppPortPtr = CreateMsgPort()) {
				if (ResourcePtr = RL_OpenResource(RCTResource, NULL, CatalogPtr)) {
					if (RL_SetResourceScreen(ResourcePtr, LockedScreen) == TRUE) {
						ScreenSet = TRUE;
     		         return(TRUE);
						}
					}
				}
			}
		}
	}

FreeReaction();
return(FALSE);
}

void FreeReaction(void)
{
if (ScreenSet == TRUE) {RL_SetResourceScreen(ResourcePtr, NULL); ScreenSet = FALSE;}
if (ResourcePtr) {RL_CloseResource(ResourcePtr); ResourcePtr = NULL;}
if (AppPortPtr) {DeleteMsgPort(AppPortPtr); AppPortPtr = NULL;}
if (IDCMPortPtr) {DeleteMsgPort(IDCMPortPtr); IDCMPortPtr = NULL;}
if (LockedScreen) {UnlockPubScreen(NULL,LockedScreen); LockedScreen = NULL;}
if (ResourceBase) {CloseLibrary(ResourceBase); ResourceBase = NULL;}
}

struct ReactWinData *OpenReactionWindow(RESOURCEID WinResID, RESOURCEID GadResID)
{
struct ReactWinData *rwd = NULL;
if (!(ResourceBase)) return(NULL);

if (rwd = AllocVec(sizeof(struct ReactWinData), MEMF_PUBLIC|MEMF_CLEAR)) {
	if (rwd->RWD_WindowObject = RL_NewObject(ResourcePtr, WinResID, WINDOW_SharedPort, IDCMPortPtr,
														  WINDOW_AppPort, AppPortPtr, TAG_END)) {
//		SetAttrs(rwd->RWD_WindowObject, WINDOW_TextAttr, &MYFONTSTRUCT, TAG_DONE);
		DoMethod(rwd->RWD_WindowObject, WM_OPEN);
		rwd->RWD_GadgetArray = (struct Gadget **) RL_GetObjectArray(ResourcePtr, rwd->RWD_WindowObject, GadResID);
		GetAttr(WINDOW_Window, rwd->RWD_WindowObject, (ULONG *) &rwd->RWD_IWindow);
		GetAttr(WINDOW_SigMask, rwd->RWD_WindowObject, &rwd->RWD_WSignals);
		return(rwd);
		}
	}

CloseReactionWindow(rwd);
return(NULL);
}

void CloseReactionWindow(struct ReactWinData *rwd)
{
DoMethod(rwd->RWD_WindowObject, WM_CLOSE);
RL_DisposeObject(ResourcePtr, rwd->RWD_WindowObject);
FreeVec(rwd);
}

STRPTR GetDefStr(LONG id)
{
STRPTR string = NULL;
struct CatCompArrayType *array = &CatCompArray;

if (LocaleBase) {
	while (1) {
		if (array->cca_ID == id) {
			string = array->cca_Str;
			break;
			}
		if (array->cca_ID == LAST_CAT_ENTRY) break;
		array++;
		}
	}

return(string);
}

ULONG DisplayError(struct Window *Win, LONG id, ULONG ErrorLevel)
{
struct EasyStruct es = {
	sizeof(struct EasyStruct),		/* es_StructSize */
	0,										/* es_Flags */
	CATSTR(TXT_FMErrorTitle),		/* es_Title */
	"%s",									/* es_TextFormat */
	CATSTR(TXT_OK),					/* es_GadgetFormat */
	};
ULONG idcmp = IDCMP_RAWKEY;

EasyRequest(Win, &es, &idcmp, CATSTR(id));

RETURNVALUE = ErrorLevel;

return(ErrorLevel);
}

extern ULONG lastsignal;

void CloseDownDisplay(struct Screen *screen)
{
ULONG status, received;

FreeReaction();

if ((status = PubScreenStatus(screen, PSNF_PRIVATE)) & 1) return;
else { /* Close as soon as possible */
   DisplayError(NULL, TXT_ERR_CantMakeScreenPrivate, 0);
   while(1) {
      received = Wait(lastsignal);
      if ((status = PubScreenStatus(screen, PSNF_PRIVATE)) & 1) return;
      DisplayError(NULL, TXT_ERR_CantMakeScreenPrivate, 0);
      }
   }
}

void LocalizeMenu(struct NewMenu *nm)
{
struct NewMenu *item;
for(item = nm; item->nm_Type != NM_END; item++) {
	if(item->nm_UserData) {
		const STRPTR str = CATSTR((ULONG) item->nm_UserData);
		item->nm_Label = (STRPTR) str;
		}
	}
}