mac-rom/ProcessMgr/LayerMgrPatches.c

512 lines
13 KiB
C
Raw Normal View History

/*
File: LayerMgrPatches.c
Contains: Glue between Process Mgr and the Layer Manager.
Written by: Ed Tecot
Copyright: <EFBFBD> 1989-1992 by Apple Computer, Inc., all rights reserved.
Change History (most recent first):
<6> 4/9/92 KST JH,There is only one float layer now instead of one float layer
for each application.
<5> 10/9/91 YK Added NewFloatLayer and DisposeFloatLayer.
<4> 5/23/91 dba do a style of coercion that MPW 3.2 C likes
<3> 1/21/91 DFH (KSM) Process Menu is now called Application Menu.
<0> 4/18/89 EMT New Today.
*/
#pragma segment kernel_segment
#include <types.h>
#include <toolutils.h>
#include <osutils.h>
#include <memory.h>
#include <quickdraw.h>
#include <events.h>
#include <resources.h>
#include <retrace.h>
#include <windows.h>
#include <palette.h>
#include <errors.h>
#include "Glue.h"
#include "Lomem.h"
#include "Data.h"
#include "ScrapCoercion.h"
#include "OSDispatchPrivate.h"
Point GetApplicationMenuLeftCoord(void);
pascal void ZoomRect(Rect *, Rect *, Boolean);
/* GetLayer. This routine returns the layer pointer for the current
* process.
*/
pascal LayerPtr
c_getlayer(void)
{
unsigned long olda5;
LayerPtr retval;
olda5 = ProcessMgrA5SimpleSetup();
retval = pCurrentProcess->p_layer;
A5SimpleRestore(olda5);
return(retval);
}
/* LayerInsert. Can't support anymore. SysError instead. (June 89) */
pascal void
c_layerinsert(LayerPtr, LayerPtr)
{
SysError(dsCoreErr);
}
/* LayerDelete. Can't support anymore. SysError instead. (June 89) */
pascal LayerPtr
c_layerdelete(LayerPtr)
{
SysError(dsCoreErr);
return nil;
}
/* LNewWindow. Can't support anymore. SysError instead. (June 89) */
pascal void
c_lnewwindow(WindowPeek)
{
SysError(dsCoreErr);
}
/* LCloseWindow. Can't support anymore. SysError instead. (June 89) */
pascal void
c_lclosewindow(WindowPeek)
{
SysError(dsCoreErr);
}
/* LCalcVis. Don't support anymore. SysError instead. (April 90) */
pascal void
c_LCalcVis(LayerPtr, WindowPeek)
{
SysError(dsCoreErr);
}
/* LCVBehind. Don't support anymore. SysError instead. (April 90) */
pascal void
c_LCVBehind(LayerPtr, WindowPeek, RgnHandle)
{
SysError(dsCoreErr);
}
/* LPaintOne. Don't support anymore. SysError instead. (April 90) */
pascal void
c_LPaintOne(LayerPtr, WindowPeek, RgnHandle)
{
SysError(dsCoreErr);
}
/* LPaintBehind. Don't support anymore. SysError instead. (April 90) */
pascal void
c_LPaintBehind(LayerPtr, WindowPeek, RgnHandle)
{
SysError(dsCoreErr);
}
/* LShowHide. Don't need anymore. SysError instead. (March 90) */
pascal void
c_LShowHide(LayerPtr, Boolean)
{
SysError(dsCoreErr);
}
/* LClipAbove. ClipAbove knowing about layers closer to the front. */
pascal void
c_LClipAbove(LayerPtr layer, WindowPeek window)
{
layer = SwapCurLayer(layer);
ClipAbove(window);
SetCurLayer(layer);
}
/* MakeTopLayer. This routine will make the given layer the frontmost
* layer, doing the necessary redrawing and visRgn recomputation. We avoid
* calling SelectWindow, since it will generate an extra deactivate/activate.
*/
pascal void
c_maketoplayer(LayerPtr layer)
{
WindowPtr topWindow;
unsigned long olda5;
THz tempZone;
olda5 = ProcessMgrA5Setup();
/* Recalculate vis regions, etc. Switch to the system heap since this is a
* cross-application operation, and we don't want to penalize the current
* application's zone for the memory needed to do the region operations.
* Layer operations are to us what window operations are to apps.
*/
SafeSetZone(tempZone, SYSZONE);
BringToFront(layer);
SafeRestoreZone(tempZone);
/* Highlight the front window (before making layer visible, to avoid flash). */
if ((topWindow = FrontWindowIn(layer)) != nil)
{
HiliteWindow(topWindow, true);
if (Colorized)
ActivatePalette(topWindow);
}
/* Bring layer back out of hiding */
if (((LayerPeek) layer)->visible == false)
HideLayer(layer, true);
A5Restore(olda5);
}
/* Closelayer. This routine is called by exiting processes to remove the
* layer from the screen. Although it is named layerCLOSE, it actually
* destroys the layer. If the layer is owned by the owner of the desktop,
* we also close the desktop layer.
* NOTE: This will not be good if the desktop owner has multiple layers,
* and just wants to close one of them!
*/
pascal void
c_layerclose(LayerPtr layer)
{
/* We own the desklayer too. */
if ((LayerOwner(layer) == desklayerowner))
desklayerowner = nil;
DisposeWindow(layer);
}
/* LayerInit. This routine will initialize the current process' layer. If the
* process is a normal one, the layer goes to the front of the list. If the process
* is a background layer, he goes to the back of the list.
* NOTE: We assume that launch called SetCurLayer(MFLayer). This keeps the layer/window
* lists synchronized before this call, and ensures proper placement of the layer we
* create here.
*/
pascal void
c_layerinit(void)
{
register PEntryPtr pCurrProc;
LayerPtr behind;
unsigned long olda5;
olda5 = ProcessMgrA5Setup();
pCurrProc = pCurrentProcess;
if (pCurrProc->p_layer != nil)
dbmsg("Current application called InitWindows twice");
/* Figure out where the layer should go (foreground vs background). */
behind = (pCurrProc == pFrontProcess) ? (LayerPtr) -1 : nil;
(void) NewLayer(&pCurrProc->p_layer, true, false, behind, (long) pCurrProc);
SetCurLayer(pCurrProc->p_layer);
A5Restore(olda5);
}
/* c_LGetNextLayer. Given a layer, returns the next layer in the list. Given nil,
* returns first.
*/
pascal LayerPtr
c_LGetNextLayer(LayerPtr pCurLayer, Boolean wantVisiblesOnly)
{
unsigned long olda5;
olda5 = ProcessMgrA5Setup();
/* Nil means start at the first layer */
pCurLayer = (pCurLayer == nil) ? GetFrontAppLayer() : ((LayerPeek) pCurLayer)->nextWindow;
/* If the caller will take any layer, return the pCurLayer.
* Otherwise, find the first visible one.
*/
while (pCurLayer != nil)
{
if (wantVisiblesOnly == false || ((LayerPeek) pCurLayer)->visible)
break;
pCurLayer = ((LayerPeek) pCurLayer)->nextWindow;
}
A5Restore(olda5);
return(pCurLayer);
}
/* LayerFind. Given a global mouse coordinate, this routine will snoop through all of
* the layers' windowlists looking for the frontmost layer which contains this mouse
* point. The layer pointer is returned if the mouse is in a layer, otherwise zero is
* returned. Note that it no longer checks the deskrgn.
*/
pascal LayerPtr
c_layerfind(Point where)
{
LayerPtr pLayer, saveLayer;
unsigned long olda5;
olda5 = ProcessMgrA5Setup();
saveLayer = SwapCurLayer(MFLayer);
if (FindLayer(where, &pLayer) != inContent)
pLayer = nil;
SetCurLayer(saveLayer);
A5Restore(olda5);
return(pLayer);
}
/* LGetAuxWin. This routine returns the AuxWin Handle for the given window in the
* given layer. If the window is nil, the handle to the default record is returned.
* The boolean return is TRUE if a unique aux handle was found, FALSE if the default
* is returned.
*/
pascal short
c_lgetauxwin(LayerPtr layer, WindowPeek window, AuxWinHandle awh)
{
short result;
layer = SwapCurLayer(layer);
result = GetAuxWin(window, awh);
SetCurLayer(layer);
return result;
}
/* ColorInvalRect. This routine intersects every displayed window with the given
* device rectangle; for those that intersect, an update is generated.
* NOTE: This routine may change thePort.
*/
pascal void
c_lcolorinvalrect(Rect *pDevRect, short, short sysupdates)
{
#pragma unused (sysupdates)
RgnHandle clobberedRgn;
clobberedRgn = NewRgn();
RectRgn(clobberedRgn, pDevRect);
PaintOnePal(nil, clobberedRgn);
DisposeRgn(clobberedRgn);
}
#define ARE_EQUAL_BOOLEANS(b1, b2) ((((b1) ^ (b2)) & 1) == 0)
#define ARE_NOT_EQUAL_BOOLEANS(b1, b2) ((((b1) ^ (b2)) & 1) != 0)
/* HideLayer. Do the user interface-y aspects of layer hiding.
* NOTE: Requires A5 == PROCESSMGRGLOBALS
*/
Rect hideDstRect; /* Set up at init time */
pascal void
HideLayer(LayerPtr layer, Boolean showFlag)
{
register WindowPeek pFrontWindow;
PEntryPtr pProc;
/* Do nothing if layer is already in requested state (to prevent zooming) */
if (ARE_EQUAL_BOOLEANS(((LayerPeek) layer)->visible, showFlag))
return;
/* Locate topmost visible window. */
pFrontWindow = FrontWindowIn(layer);
do
{
/* Escape from loop if there are no visibles */
if (pFrontWindow == nil)
break;
/* Ignore window if it has nothing on the screen (empty strucRgn), or it is
* a fake DA window (p_wptr is a pointer to it).
*/
if (pFrontWindow->visible)
{
pProc = LayerOwner(layer);
if ( (EmptyRgn(pFrontWindow->strucRgn) == false)
&& (pFrontWindow != pProc->p_wptr) )
break;
}
/* Link to next window back in layer */
pFrontWindow = pFrontWindow->nextWindow;
}
while (true);
/* If hiding, hide windows before zoom */
if (!showFlag)
ShowHide(layer, false);
/* Zoom the top window, if any. */
if (pFrontWindow != nil)
{
Rect hideDstRect, globalOfPortRect;
Rect *pPortBitsBounds;
register short globalToLocalY;
register short globalToLocalX;
/* Create the rect for the top window */
pPortBitsBounds = (pFrontWindow->port.portBits.rowBytes < 0)
? &(*((CGrafPtr)pFrontWindow)->portPixMap)->bounds
: &pFrontWindow->port.portBits.bounds;
globalToLocalY = pPortBitsBounds->top;
globalToLocalX = pPortBitsBounds->left;
/* Create the rect for the Application menu. */
*((Point *)&hideDstRect.top) = *((Point *)&hideDstRect.bottom) = GetApplicationMenuLeftCoord();
/* Convert the "global" port rect to global coords */
globalOfPortRect = pFrontWindow->port.portRect;
globalOfPortRect.top -= globalToLocalY;
globalOfPortRect.left -= globalToLocalX;
globalOfPortRect.bottom -= globalToLocalY;
globalOfPortRect.right -= globalToLocalX;
/* Zoom it, globally */
ZoomRect(&hideDstRect, &globalOfPortRect, showFlag);
}
/* If showing, show windows now that zoom is done. */
if (showFlag)
ShowHide(layer, true);
}
/* ShowHideOthers. Set the invisibility of all layers but the current app and the
* desk layer.
*/
void
ShowHideOthers(Boolean showFlag)
{
LayerPtr pLayer;
pLayer = GetFrontAppLayer();
while ((pLayer = ((LayerPeek) pLayer)->nextWindow) != nil)
ShowHide(pLayer, showFlag);
}
/* ---------------------------------------------------------------------
*
* Below are the kernel support routines for the layer manager.
*
* --------------------------------------------------------------------- */
/* FindAppLayer. For the given window, this routine finds the ancestral
* layer which is a child of MFLayer. If it can't be found, returns nil.
*/
LayerPtr
FindAppBaseLayer(WindowPtr window, LayerPtr layerPtr)
{
register LayerPtr ancestor;
/* Paddle upriver. Must call GetParent the first time, since WindowRecords have
* no "parent" field (parent must be derived). Once we know we have a layer, we
* can use the "parent" field directly.
*/
ancestor = GetParent(window);
while ((ancestor != nil) && (ancestor != layerPtr))
{
window = ancestor;
ancestor = ((LayerPeek) ancestor)->parent;
}
/* No-find means the given layer not below MFLayer. By (the current)
* definition, applications do not control such layers.
*/
if (ancestor == nil)
window = nil;
return (LayerPtr) window;
}
/* CancelUpdateAction. An action procedure which sets the update region to empty. */
pascal OSErr
CancelUpdateAction(WindowPeek window, LayerPeek, void *)
{
SetEmptyRgn(window->updateRgn);
return noErr;
}
/* CancelPendingUpdates. For the given layer, set the update regions of every
* window to the empty region.
*/
void
CancelPendingUpdates(LayerPtr layerPtr)
{
(void) EachWindow(layerPtr, ((LayerPeek)layerPtr)->nextWindow, nil, CancelUpdateAction, nil);
}
/* Floating Window stuff */
#pragma parameter __D0 GetHelpLayer(__D0);
pascal LayerPtr GetHelpLayer()
= {
0x2078,0x02B6, // MOVE.L ExpandMem,A0
0x2068,0x0078, // MOVE.L ExpandMemRec.emHelpGlobals(A0),A0
0x2028,0x00E6 // MOVE.L hmgLayer(A0),D0
};
pascal OSErr
C_NewFloatLayer( LayerPtr *newFloatLayer)
{
LayerPtr hmLayer;
LayerPtr currLayer;
OSErr err = noErr;
unsigned long olda5;
THz tempZone;
olda5 = ProcessMgrA5Setup();
if ( (*newFloatLayer = pCurrentProcess->p_floatLayer)!=nil )
{
A5Restore(olda5);
return noErr;
}
currLayer = SwapCurLayer( GetRootLayer());
SafeSetZone(tempZone, SYSZONE);
if ( IMLayer==nil )
{
if ( ( hmLayer = GetHelpLayer() )==nil )
{
hmLayer = (LayerPtr)-1;
}
err = NewLayer( &IMLayer, true, true, hmLayer, (long)nil);
}
/****
if ( err==noErr )
{
SetCurLayer( IMLayer);
err = NewLayer( newFloatLayer, true, true, (WindowPtr)-1, (long)pCurrentProcess);
}
****/
SafeRestoreZone(tempZone);
//pCurrentProcess->p_floatLayer = *newFloatLayer;
*newFloatLayer = IMLayer;
SetCurLayer( currLayer);
A5Restore(olda5);
return err;
}
pascal OSErr
C_DisposeFloatLayer( LayerPtr *floatLayer)
{
OSErr err = noErr;
unsigned long olda5;
olda5 = ProcessMgrA5Setup();
if ( pCurrentProcess->p_floatLayer == (*floatLayer) )
{
DisposeWindow(*floatLayer);
*floatLayer = nil;
}
else
err = paramErr;
A5Restore(olda5);
return err;
}