512 lines
13 KiB
C
512 lines
13 KiB
C
/*
|
|
File: LayerMgrPatches.c
|
|
|
|
Contains: Glue between Process Mgr and the Layer Manager.
|
|
|
|
Written by: Ed Tecot
|
|
|
|
Copyright: © 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;
|
|
}
|
|
|