home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
The Fred Fish Collection 1.5
/
ffcollection-1-5-1992-11.iso
/
ff_disks
/
200-299
/
ff256.lzh
/
BlitDemons
/
bdintui.c
< prev
next >
Wrap
C/C++ Source or Header
|
1989-10-19
|
13KB
|
425 lines
/*******************************************************************************
* BlitDemons by Walter Strickler
* This program and all its source code are in the public domain and are
* freely distributable and usable for any purpose, private or commercial.
******************************************************************************/
#include "BDemon.h"
/*******************************************************************************
* Intuition stuff is global:
******************************************************************************/
struct Window *BDWindow;
struct Screen *BDScreen;
/*******************************************************************************
* Defines to make life with Power Windows easier...
*****************************************************************************/
#define BDNewWindow BDWindowNewWindowStructure3
#define ABD1NewWindow ABDWin1NewWindowStructure4
#define ABD2NewWindow ABDWin2NewWindowStructure1
#define ABD3NewWindow ABDWin3NewWindowStructure2
#define ABD1IText ABDWin1IText28
#define ABD2IText ABDWin2IText1
#define ABD3IText ABDWin3IText16
/*******************************************************************************
* This stuff came from PowerWindows, but we gotta know what it is here.
*****************************************************************************/
extern struct NewScreen NewScreenStructure;
extern struct NewWindow BDNewWindow;
extern struct Menu BDWindowMenu1;
extern struct NewWindow ABD1NewWindow;
extern struct NewWindow ABD2NewWindow;
extern struct NewWindow ABD3NewWindow;
extern struct IntuiText ABD1IText;
extern struct IntuiText ABD2IText;
extern struct IntuiText ABD3IText;
/*******************************************************************************
* Here is a useful #define for turning on/off Menu items.
*****************************************************************************/
#define GET_MENU_NUMBER(Menu, Item) (SHIFTMENU((Menu)) + SHIFTITEM((Item)))
/*******************************************************************************
InitIntui() opens various system things.
*******************************************************************************/
int InitIntui()
{
int RetVal;
IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library",0);
if (IntuitionBase == 0)
{
RetVal = NO_INTUI;
}
else
{
GfxBase = (struct GfxBase *) OpenLibrary("graphics.library",0);
if (GfxBase == 0)
{
RetVal = NO_GFX;
}
else
{
BDScreen = OpenScreen(&NewScreenStructure);
if (BDScreen == NULL)
{
RetVal = NO_SCREEN;
}
else
{
/* Set the Palette */
SetPalette();
/* Power Windows doesn't init this schtick 'cause it can't */
BDNewWindow.Screen = BDScreen;
ABD1NewWindow.Screen = BDScreen;
ABD2NewWindow.Screen = BDScreen;
ABD3NewWindow.Screen = BDScreen;
BDWindow = OpenWindow(&BDNewWindow);
if (BDWindow == NULL)
{
RetVal = NO_WIN;
}
else
{
SetMenuStrip(BDWindow, &BDWindowMenu1);
RetVal = INTUI_OK;
} /* END window open */
} /* END screen open */
} /* END Gfx open */
} /* END intuition open */
return RetVal;
} /* END IntuiInit() */
void SetPalette()
{
/*
struct ViewPort *ThisVP;
USHORT RVal,
GVal,
BVal;
int i;
static int Red[32] = {1,1, 0, 0, 0,0,0, 3, 9,11,13,15,15,14,15,0};
static int Green[32] = {0,0, 0, 0, 7,9,9,10,11,12,10, 6, 5, 1, 0,0};
static int Blue[32] = {4,9,12,14,11,5,0, 0, 0, 0, 0, 0, 0, 0, 0,0};
*/
/* Neither of these algorithms produced satisfying results. There was
* Video beam hash with both that didn't exist with the default colors.
*/
/* Set Palette as in MFPU */
/* ThisVP = &(BDScreen -> ViewPort);
for (i = 2; i <= 15; i++)
{
SetRGB4(ThisVP, i, Red[i], Green[i], Blue[i]);
}
*/
/* Set Palette according to algorithm by Loren Blaney: */
/*
RVal = 14;
GVal = 2;
BVal = 0;
for (i = 2; i <= 8; i++)
{
SetRGB4(ThisVP, i, RVal, GVal, BVal);
RVal = RVal - 2;
GVal = GVal + 2;
}
RVal = 0;
GVal = 14;
BVal = 2;
for (i = 9; i <= 15; i++)
{
SetRGB4(ThisVP, i, RVal, GVal, BVal);
GVal = GVal - 2;
BVal = BVal + 2;
}
*/
} /* End SetPalette() */
/*******************************************************************************
* CloseIntui closes everything opened by IntiIntui().
******************************************************************************/
void CloseIntui()
{
if (IntuitionBase != NULL)
{
CloseLibrary((struct Library *) IntuitionBase);
}
if (GfxBase != NULL)
{
CloseLibrary((struct Library *) GfxBase);
}
ClearMenuStrip(BDWindow);
if (BDWindow != NULL)
{
CloseWindow(BDWindow);
}
if (BDScreen != NULL)
{
CloseScreen (BDScreen);
}
}
/*******************************************************************************
* BDClearScreen() clears the blitfield.
*******************************************************************************/
/*
BDClearScreen()
{
SetRast(BDWindow -> RPort, 0);
}
*/
/*******************************************************************************
* This function checks the message port BDWindow -> UserPort, waiting if
* the parameter Control has a value of WAIT, polling otherwise. Returns
* constants relative to the type of message it found.
*******************************************************************************/
int CheckMsg(Control)
int Control;
{
struct IntuiMessage *ThisMessage,
MsgCopy;
ULONG ThisClass;
int RetVal,
MenuVal,
RecurseReturn;
if (Control == WAIT)
{
WaitPort(BDWindow -> UserPort);
}
ThisMessage = (struct IntuiMessage *) GetMsg(BDWindow->UserPort);
if (ThisMessage != NULL)
{
MsgCopy = *ThisMessage;
ReplyMsg((struct Message *) ThisMessage); /* Away with thee! */
ThisClass = MsgCopy.Class;
switch (ThisClass)
{
case MENUVERIFY:
/* Recursion time! */
RecurseReturn = CheckMsg(WAIT); /* Get the menu message */
RetVal = RecurseReturn; /* Return the menu message value */
break;
case MENUPICK:
MenuVal = DoMenus(&MsgCopy);
if (MenuVal != NO_MENU)
{
RetVal = MenuVal;
}
else
{
RetVal = NO_MSG;
}
break;
case CLOSEWINDOW:
RetVal = CLOSE_WIN;
break;
default:
assert (FALSE); /* Shouldn't be here */
break;
} /* End switch(Class) */
} /* End Have a message */
else /* Tell caller no message */
{
RetVal = NO_MSG;
} /* End have no message */
return RetVal;
} /* End CheckMsg() */
/*******************************************************************************
* DoMenus returns a constant depending on what kind of menu item is specified
* by the Message pointed at by Msg.
*******************************************************************************/
#define PROJECT_MENU 0
#define ABOUT_ITEM 0
#define NEW_ITEM 1
#define START_ITEM 2
#define STOP_ITEM 3
#define QUIT_ITEM 4
int DoMenus(Msg)
struct IntuiMessage *Msg;
{
USHORT MenuNumber;
int Item,
RetVal;
MenuNumber = Msg -> Code;
if (MenuNumber != MENUNULL) /* Note: assuming only one menu */
{
Item = ITEMNUM(MenuNumber);
switch (Item)
{
/* This is so obvious it must be good code... */
case ABOUT_ITEM:
RetVal = ABOUT;
break;
case STOP_ITEM:
RetVal = STOP;
break;
case START_ITEM:
RetVal = START;
break;
case NEW_ITEM:
RetVal = NEW;
break;
case QUIT_ITEM:
RetVal = QUIT;
break;
default:
RetVal = NO_MENU;
break;
} /* End switch (Item) */
} /* End if not MENUNULL */
else
{
RetVal = NO_MENU;
} /* End if MENUNULL */
return RetVal;
}
/*******************************************************************************
* DisplayAbout() displays all three "About" windows.
******************************************************************************/
int DisplayAbout()
{
int RetVal;
struct Window *Window1,
*Window2,
*Window3;
ClearBDMenu();
Window1 = Window2 = Window3 = NULL;
Window1 = DisplayOne(&ABD1NewWindow, &ABD1IText);
if (Window1 != NULL)
{
Window2 = DisplayOne(&ABD2NewWindow, &ABD2IText);
CloseWindow(Window1); /* Window2 is now covering blitfield */
if (Window2 != NULL)
{
Window3 = DisplayOne(&ABD3NewWindow, &ABD3IText);
CloseWindow(Window2); /* Window3 is now covering blitfield */
if (Window3 != NULL)
{
/* Window3 opened and close gadget selected, it */
CloseWindow(Window3);
RetVal = DA_OK;
} /* End Window3 OK */
else
{
RetVal = DA_CHOKE;
} /* End Window3 choked */
} /* End Window2 OK */
else
{
RetVal = DA_CHOKE;
} /* End Window2 choked */
} /* End Window1 OK */
else
{
RetVal = DA_CHOKE;
} /* End Window1 choked */
SetBDMenu();
return RetVal;
}
/*******************************************************************************
* DisplayOne() displays one "About" window.
******************************************************************************/
struct Window *DisplayOne(AboutNewWindow, IText)
struct NewWindow *AboutNewWindow;
struct IntuiText *IText;
{
struct Window *AboutWindow;
struct IntuiMessage *ThisMessage;
int AllDone;
AboutWindow = OpenWindow (AboutNewWindow);
if (AboutWindow != 0)
{
PrintIText(AboutWindow -> RPort, IText, 0,0);
AllDone = FALSE;
while (!AllDone)
{
WaitPort(AboutWindow -> UserPort);
ThisMessage =
(struct IntuiMessage *) GetMsg(AboutWindow -> UserPort);
if (ThisMessage != NULL)
{
if (ThisMessage -> Class == CLOSEWINDOW)
{
AllDone = TRUE;
}
ReplyMsg((struct Message *) ThisMessage);
} /* End if Message != NULL */
} /* End while !AllDone */
}
return AboutWindow;
}
/*******************************************************************************
* These functions support information hiding by providing functions to
* operate on relatively hidden objects (in this case, menu items).
******************************************************************************/
void OnStart()
{
OnMenu(BDWindow, GET_MENU_NUMBER(PROJECT_MENU, START_ITEM));
} /* End OnStart */
void OffStart()
{
OffMenu(BDWindow, GET_MENU_NUMBER(PROJECT_MENU, START_ITEM));
} /* End OffStart */
void OnStop()
{
OnMenu(BDWindow, GET_MENU_NUMBER(PROJECT_MENU, STOP_ITEM));
} /* End OnStop */
void OffStop()
{
OffMenu(BDWindow, GET_MENU_NUMBER(PROJECT_MENU, STOP_ITEM));
} /* End OffStop */
void SetBDMenu()
{
ULONG Flags;
Flags = (BDWindow -> IDCMPFlags) | MENUVERIFY; /* Set MENUVERIFY */
ModifyIDCMP(BDWindow, Flags);
SetMenuStrip(BDWindow, &BDWindowMenu1);
}
void ClearBDMenu()
{
ULONG Flags;
Flags = (BDWindow -> IDCMPFlags) & ~MENUVERIFY; /* Clear that nasty */
/* MENUVERIFY bit */
ModifyIDCMP(BDWindow, Flags);
ClearMenuStrip(BDWindow);
}