Frozen Fish 1: Amiga/FrozenFish-Apr94.iso/bbs/alib/d1xx/d154/wicon.lha/Wicon/macwin.c

C/C++ Source or Header | 1987-06-15 | 5KB | 197 lines

/***************************************************************************
 *
 *    MacWin.c    - routines for making OpenWindow & CloseWindow
 *              behave like a Macintosh        10-Jan-88
 *
 *    Version 1.3 18-Jun-88 Copyright (c) 1988 - Steven Sweeting
 *
 *    Note: if the OpenWindow vector gets in before mwb
 *          (ie run mwb first) then the opening of the window
 *          is done on the real WBENCH screen.
 *
 ***************************************************************************/

#include <intuition/intuitionbase.h>
#include "wicon.h"

extern    struct IntuitionBase   *IntuitionBase;

struct    Box
{
    LONG   Left, Right;
    LONG   Top, Bottom;
};

#define REC_FIRST    1
#define REC_LAST    2
#define REC_HIRES    4

#define MIN(a,b)        ((a)<(b) ? (a):(b))
#define MAX(a,b)        ((a)>(b) ? (a):(b))


/*************************************************************************
 *  SizeRec - resizes a rectangle on the given Screen
 *
 * 03-Jan-88
 */
void
SizeRec(Screen, From, To)
struct    Screen    *Screen;
struct    BoxInfo *From, *To;
{
    struct    Box    Box1, Box2, Box3;
    short        inc;
    long        Left, Right, Top, Bottom;
    int        Flags;
    long        factor, curr = 0, i;
    struct RastPort *RastPort = &(Screen->RastPort);
    static    WORD    ox1, oy1, ox2, oy2; /* Save them for redraw */

    Box1.Left   = MAX( From->LeftEdge,          0              );
    Box1.Right  = MIN( Box1.Left + From->Width, Screen->Width  );
    Box1.Top    = MAX( From->TopEdge,           0              );
    Box1.Bottom = MIN( Box1.Top + From->Height, Screen->Height );

    Box2.Left   = MAX( To->LeftEdge,            0              );
    Box2.Right  = MIN( Box2.Left + To->Width,   Screen->Width  );
    Box2.Top    = MAX( To->TopEdge,             0              );
    Box2.Bottom = MIN( Box2.Top + To->Height,   Screen->Height );

    if (Screen->Flags | HIRES)
        Flags = REC_HIRES;
    else
        Flags = 0;

    SetDrMd(RastPort, (LONG)COMPLEMENT);

    if (Arg_Boxes)
    {
        SetDrMd(RastPort, (LONG)COMPLEMENT);

        LockLayers(&(Screen->LayerInfo));

        inc = 256/Arg_Boxes;

        DrawRec(RastPort, ox1 = Box1.Left, oy1 = Box1.Top,
                  ox2 = Box1.Right, oy2 = Box1.Bottom );
        inc = 256/Arg_Boxes;

        for (i=0; i<256; i += inc )
        {
        WaitTOF();

        DrawRec(RastPort, ox1, oy1, ox2, oy2 );

        DrawRec(
            RastPort,
            ox1 = (WORD)((Box1.Left   *(255-i) + Box2.Left   *i) >>8),
            oy1 = (WORD)((Box1.Top    *(255-i) + Box2.Top    *i) >>8),
            ox2 = (WORD)((Box1.Right  *(255-i) + Box2.Right  *i) >>8),
            oy2 = (WORD)((Box1.Bottom *(255-i) + Box2.Bottom *i) >>8)
               );
        }

        DrawRec(RastPort, ox1, oy1, ox2, oy2);


        UnlockLayers(&(Screen->LayerInfo));
    }

}

/*************************************************************************
 * DrawRec - draws an XOR rectangle on a given RastPort
 *
 * 03-Jan-88
 */
int
DrawRec(RastPort, x1, y1, x2, y2, status)
struct    RastPort    *RastPort;
WORD    x1, y1, x2, y2;
WORD    status;
{
    Move(RastPort, (LONG)x1, (LONG)y1);
    Draw(RastPort, (LONG)x2, (LONG)y1);
    Draw(RastPort, (LONG)x2, (LONG)y2);
    Draw(RastPort, (LONG)x1, (LONG)y2);
    Draw(RastPort, (LONG)x1, (LONG)y1);

    if (status & REC_HIRES)
    {
        Move(RastPort, (LONG)x1+1, (LONG)y1);
        Draw(RastPort, (LONG)x1+1, (LONG)y2);
        Move(RastPort, (LONG)x2-1, (LONG)y1);
        Draw(RastPort, (LONG)x2-1, (LONG)y2);
    }
}

/*************************************************************************
 * M_Open - opens a window - called from the OpenWindow vector
 *        hence it is always run by the task that called it
 *
 */
struct    BoxInfo SmallBox =   { 0, 0, 0, 0 };

struct Window *
M_Open( NewWindow )
struct NewWindow *NewWindow;
{
    extern    struct    Window *OldOpenWindow();

    struct Screen    *Screen;

    if ((NewWindow->Type & SCREENTYPE) == WBENCHSCREEN)
        Screen = WorkBenchScreen;
    else
        Screen = NewWindow->Screen;

    SmallBox.LeftEdge = Screen->MouseX;
    SmallBox.TopEdge  = Screen->MouseY;

    if (Arg_AllScreens || (Screen == WiconScreen))
        SizeRec(Screen, &SmallBox, &(NewWindow->LeftEdge));

    return (OldOpenWindow(NewWindow));
}

/*************************************************************************
 * UnSetFunction - this routine handles properly
 *           the opposite to SetFunction() which
 *           replaces an AmigaDOS `OldVector'
 *           with its own `NewVector'. This function
 *           may never exit because the `NewVector'
 *           may be lost by a newer function which
 *           also does a SetFunction()
 *  10-Jan-87
 */

void UnSetFunction(LibraryBase, FunctionOffset, LibVector, PresentVector)
struct    Library *LibraryBase;
LONG        FunctionOffset;
VOID        (*PresentVector)(),(*LibVector)();
{
    extern    void    (*SetFunction())();     /* AmigaDOS routine */
    extern    void    (*GetFunction())();     /* Sweeting routine */

    Forbid();

    while (GetFunction( LibraryBase, FunctionOffset ) != PresentVector)
    {
        Permit();

        Delay(50L);     /* a second */

        Forbid();
    }

        /* It may be illegal to do this within a Forbid()/Permit() */
        /* But it seems to work OK    */

    SetFunction( LibraryBase, FunctionOffset, LibVector );

    Permit();

}