BMgr - Blob Manager source (part 1 of 2)

[maci...@felix.uucp]

#!/bin/sh
# shar: Shell Archiver
# Run the following text with /bin/sh to create:
# BMgr/BlobMgr.h
# BMgr/BMgrCalcRegion.c
# BMgr/BMgrClick.c
# BMgr/BMgrDrag.c
# BMgr/BMgrDraw.c
# BMgr/BMgrFlags.c
# BMgr/BMgrFreeze.c
# BMgr/BMgrHideShow.c
mkdir BMgr
sed 's/^X//' << 'SHAR_EOF' > BMgr/BlobMgr.h
X/* Blob Manager global types and constants */
X
X# ifndef _BlobMgr_
X
X# define _BlobMgr_
X
X# ifndef _Quickdraw_
X#include <QuickDraw.h> /* brings in MacTypes.h as well */
X# endif
X
X# ifndef nil
X# define nil 0L
X# endif
X
X
X/* blob flag masks */
X
Xenum
X{
X bEnableMask = 1,
X bFreezeMask = 2,
X bStatModeMask = 4,
X bDragModeMask = 8,
X bDrawModeMask = 12, /* two bits, derived: bStatModeMask + bDragModeMask */
X bNeedGlobMask = 16,
X bScaleMask = 32,
X bHJustMask = 192, /* two bits: 64 + 128 */
X bVJustMask = 768, /* two bits: 256 + 512 */
X bPicMask = 1024
X};
X
X
X/* blob drawing modes */
X
Xenum
X{
X normalDraw = 1, /* draw blob normally */
X dimDraw = 2 /* draw dimmed blob */
X};
X
X/* blob part codes */
X
Xenum
X{
X inStatBlob = 1, /* static region */
X inDragBlob = 2, /* drag region */
X inFullBlob = 3 /* entire blob */
X};
X
X/*
X special max glue count - no limit
X*/
X
X# define infiniteGlue 0x8000
X
X
X/*
X BlobClick return codes
X*/
X
Xenum
X{
X /* 0 = nothing done */
X bcGlue = 1, /* donor blob glued to receptor */
X bcUnglue, /* glob unglued from receptor */
X bcXfer, /* glob transferred from one receptor to another */
X bcDup, /* glob duplicated from one receptor onto another */
X bcSwap /* globs of two receptors swapped */
X};
X
X
X/*
X Messages passed by BlobClick to advisory functions
X*/
X
Xenum
X{
X advDClick, /* click in donor */
X advRClick, /* click in receptor */
X advGlue, /* glue transaction proposed */
X advUnglue, /* unglue transaction proposed */
X advXfer, /* transfer transaction proposed */
X advDup, /* duplicate transaction proposed */
X advSwap /* swap transaction proposed */
X};
X
X
X/* DragGrayRgn result code for bad drag - Inside Mac is wrong! */
X
X# define badDragResult 0x80008000L
X
X
X/*
X BlobRecord structure
X
X flags:
X bit 0: 1 = enabled, 0 = disabled
X bit 1: 1 = frozen, 0 = thawed (1/0)
X bit 2: 1 = static region is dimmed, 0 = normal
X bit 3: 1 = drag region is dimmed, 0 = normal
X bit 4: 1 = need explicit match, 0 = don't
X
X fzflags:
X bit 2: 1 = static region was dimmed before freeze, 0 = was normal
X bit 3: 1 = drag region was dimmed before freeze, 0 = was normal
X
X*/
X
Xtypedef struct BlobRecord
X{
X int flags; /* flags word */
X int fzFlags; /* freeze flags word */
X union /* pic if bPicMask flag word bit set*/
X { /* proc if bit clear */
X PicHandle bPic; /* blob picture (and original frame) */
X ProcPtr bDrawProc; /* blob drawing procedure */
X } bPicProc;
X RgnHandle statRgn; /* current static region */
X RgnHandle dragRgn; /* current drag region */
X Rect statRect; /* original static region frame */
X Rect dragRect; /* original drag region frame */
X int glueMax; /* maximum times can glue to others */
X int glueCount; /* number of times glued to others */
X struct MatchRecord **matches; /* set of valid matches */
X struct BlobRecord **glob; /* currently glued blob */
X long bRefCon; /* reference value */
X struct BlobRecord **nextBlob; /* next blob in set */
X} BlobRecord, *BlobPtr, **BlobHandle;
X
X
Xtypedef struct MatchRecord
X{
X BlobHandle mBlob; /* blob that matches */
X struct MatchRecord **nextMatch; /* next match record */
X} MatchRecord, *MatchPtr, **MatchHandle;
X
X
Xtypedef struct BlobSetRecord
X{
X BlobHandle firstBlob; /* first Blob of set */
X BlobHandle lastBlob; /* last Blob of set */
X struct BlobSetRecord **nextBlobSet; /* next blob set */
X} BlobSetRecord, *BlobSetPtr, **BlobSetHandle;
X
X
X/*
X Pseudo-functions
X*/
X
X# define FirstBlob(bSet) ((**(bSet)).firstBlob)
X# define LastBlob(bSet) ((**(bSet)).lastBlob)
X# define NextBlob(b) ((**(b)).nextBlob)
X# define SetBRefCon(b,val) ((**(b)).bRefCon = (long) (val))
X# define GetBRefCon(b) ((long) (**(b)).bRefCon)
X# define BStatBox(b) ((**((**(b)).statRgn)).rgnBBox)
X# define BDragBox(b) ((**((**(b)).dragRgn)).rgnBBox)
X# define BGlob(b) ((**(b)).glob)
X# define FirstBMatch(b) ((**((**(b)).matches)).mBlob)
X
X
X/*
X Functions returning non-integral values
X*/
X
XBlobHandle GetBlobHandle ();
XBlobHandle NewBlob ();
XBlobSetHandle NewBlobSet ();
XBoolean BlobQuiet ();
XBoolean BlobSetQuiet ();
XBoolean InBlobMatchSet ();
Xlong DTrackBlob ();
Xlong TrackBlob ();
XBoolean BlobDimmed ();
XBoolean BlobActive ();
XBoolean BlobFrozen ();
XBoolean BlobEnabled ();
XBoolean CanGlue ();
XBoolean PicBlob ();
XRgnHandle BCalcRegion ();
XBoolean BTrackMouse ();
X
X# endifSHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrCalcRegion.c
X# include "BlobMgr.h"
X
X
X/*
X Return copy of the region corresponding to the part code. The
X caller is responsible for disposing of the region that is returned.
X*/
X
XRgnHandle BCalcRegion (b, partCode)
XBlobHandle b;
Xint partCode;
X{
XRgnHandle rgn;
X
X rgn = NewRgn ();
X if (partCode == inDragBlob)
X CopyRgn ((**b).dragRgn, rgn);
X else
X {
X CopyRgn ((**b).statRgn, rgn);
X if (partCode == inFullBlob)
X UnionRgn ((**b).dragRgn, rgn, rgn);
X }
X return (rgn);
X}
SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrClick.c
X/*
X BlobClick and support routines. BlobClick is the basic blob
X transaction handler. Other routines and variables are used
X to modify the way BlobClick functions.
X
X
X unglueZoom determines whether BlobClick will zoom an outline of the
X receptor drag region back to the donor when a donor is unglued
X from a receptor by double-clicking.
X
X badDragZoom determines whether the outline of a dragged donor will
X be zoomed back where it was dragged from if it's not dragged
X somewhere it can be glued to.
X
X The permission booleans control the types of transactions that
X BlobClick is allowed to perform:
X
X ungluePerm is true if double-clicking detaches globs from receptors.
X xferPerm is true if globs can be transferred between receptors.
X swapPerm is true if globs can be swapped between receptors.
X dupPerm is true if globs can be duplicated onto other receptors.
X replacePerm is true if transfers, swaps and duplications can cause
X a receptor's glob to be replaced by another. Note that if
X replacePerm is false, transfers and duplications can only be made
X to empty receptors, and swaps fail altogether.
X
X Swaps take precedence over duplications, and both take precedence
X over transfers, if two or more of these flags are on. All are
X subject to the value of the replacement flag, as noted above.
X
X lastWhen and lastWhere are for double-click detection.
X If lastWhen is set to 0, the next click will not be interpreted
X as a double-click. Since that's how it's initialized, BlobClick
X never mistakes the first click passed to it for a double-click.
X
X BlobClick only saves the click time and location when the user
X clicks in a receptor blob drag region and releases the mouse without
X moving it, since that's the only time a double-click is relevant.
X
X bcAdvise is the BlobClick filter function. If it's nil, BlobClick
X does all the work itself. If bcFilter is set to the address of
X some function, that function is consulted in certain circumstances
X to see whether to continue processing or not. If the filter returns
X false, BlobClick terminates early.
X
X bcResult holds the result of the last call to BlobClick. db1,
X db2, rb1 and rb2 are set to indicate which blobs were involved in
X any transaction that occurs (these are known as the cast (as in
X cast of thousands) of the transaction). The result code and the
X cast may be obtained by the host program with the BClickResult
X routine, and have meanings as follows:
X
X Glue: db1 = donor glued, rb1 = receptor glued to, db2 = donor replaced by
X db1 (nil if none), rb2 nil.
X Unglue: db1 = donor unglued, rb1 = receptor unglued from, db2, rb2 nil.
X Transfer: db1 = donor transferred, rb1 = source receptor,
X rb2 = destination receptor, db2 = donor replaced by db1 (nil if none).
X Duplication: same as transfer, except db1 = donor duplicated.
X Swap: db1 = donor originally on rb1, db2 = donor originally on rb2,
X rb1 = source receptor, rb2 = dest receptor.
X
X The result code and the cast are undefined if a filter function
X causes BlobClick to terminate early.
X
X srcRect and dstRect are used by BlobClick and BadDrag to keep
X track of how to do zoomback on bad drags.
X*/
X
X# include "BlobMgr.h"
X
X
Xstatic Boolean unglueZoom = true;
Xstatic Boolean badDragZoom = true;
X
Xstatic Boolean ungluePerm = true;
Xstatic Boolean xferPerm = true;
Xstatic Boolean replacePerm = true;
Xstatic Boolean dupPerm = false;
Xstatic Boolean swapPerm = true;
X
X
Xstatic long lastWhen = 0L;
Xstatic Point lastWhere;
X
Xstatic Boolean (*bcAdvise)() = nil;
X
Xstatic int bcResult;
Xstatic BlobHandle db1;
Xstatic BlobHandle db2;
Xstatic BlobHandle rb1;
Xstatic BlobHandle rb2;
X
Xstatic Rect srcRect, dstRect;
X
X
X/*
X Set or get the flags determining zoomback behavior on bad drags
X and unglue transactions
X*/
X
XSetBCZoomFlags (uGlueZoom, bDragZoom)
XBoolean uGlueZoom, bDragZoom;
X{
X unglueZoom = uGlueZoom;
X badDragZoom = bDragZoom;
X}
X
X
XGetBCZoomFlags (uGlueZoom, bDragZoom)
XBoolean *uGlueZoom, *bDragZoom;
X{
X *uGlueZoom = unglueZoom;
X *bDragZoom = badDragZoom;
X}
X
X
X/*
X Set or get the flags determining transaction permissions
X*/
X
XSetBCPermissions (canUnglue, canXfer, canDup, canSwap, canRep)
XBoolean canUnglue, canXfer, canDup, canSwap, canRep;
X{
X ungluePerm = canUnglue;
X xferPerm = canXfer;
X dupPerm = canDup;
X swapPerm = canSwap;
X replacePerm = canRep;
X}
X
X
XGetBCPermissions (canUnglue, canXfer, canDup, canSwap, canRep)
XBoolean *canUnglue, *canXfer, *canDup, *canSwap, *canRep;
X{
X *canUnglue = ungluePerm;
X *canXfer = xferPerm;
X *canDup = dupPerm;
X *canSwap = swapPerm;
X *canRep = replacePerm;
X}
X
X
X/*
X Set or get the address of the BlobClick advisory filter routine.
X Pass nil to SetBCFilter to turn the filter off.
X*/
X
XSetBCAdvisory (p)
XBoolean (*p)();
X{
X bcAdvise = p;
X}
X
X
XGetBCAdvisory (p)
XBoolean (**p)();
X{
X *p = bcAdvise;
X}
X
X
X/*
X FindReceptor is called with the point at which the mouse was released
X after a donor or a receptor's glob was dragged. It returns true if
X the mouse was released in a receptor that has an undimmed drag region
X and either (i) has no glob, or (ii) has a glob but replacement
X permission is on. Otherwise it returns false.
X*/
X
Xstatic Boolean FindReceptor (thePoint, rSet, r)
XPoint thePoint; /* point at which mouse released */
XBlobSetHandle rSet; /* receptor set */
XBlobHandle *r; /* return receptor hit in this */
X{
X return (FindBlob (thePoint, rSet, r)
X && GetBDrawMode (*r, inDragBlob) == normalDraw
X && (BGlob (*r) == nil || replacePerm));
X}
X
X
X/*
X BlobClick blob transaction handler
X*/
X
XBlobClick (thePt, t, dSet, rSet)
XPoint thePt;
Xlong t;
XBlobSetHandle dSet, rSet;
X{
XBlobHandle d, r1, r2;
XPoint thePoint;
Xregister long dragDelta;
Xregister Boolean badDrag = true; /* assume the worst */
X
X thePoint = thePt; /* do setup: make local copy of point */
X bcResult = 0; /* and initialize status variables */
X db1 = db2 = rb1 = rb2 = nil;
X
X/*
X Check for double-click if unglue permission is on. If so and both
X clicks were in drag region of a non-dim receptor that has a glob
X glued to it, unglue the glob. (Note that the hit-tests only work
X if the blob is not dimmed - which is as things should be.)
X*/
X if (ungluePerm && t - lastWhen <= GetDblTime ())
X {
X if (rSet != nil
X && FindBlob (thePoint, rSet, &r1) == inDragBlob
X && TestBlob (r1, lastWhere) == inDragBlob)
X {
X if (bcAdvise == nil || (*bcAdvise) (advUnglue, r1))
X {
X db1 = BGlob (r1);
X rb1 = r1;
X bcResult = bcUnglue;
X
X if (unglueZoom)
X ZUnglueGlob (r1);
X else
X UnglueGlob (r1);
X }
X }
X lastWhen = 0L;
X return;
X }
X
X lastWhen = 0L;
X
X/*
X See if the mouse was clicked in a donor blob. If so, drag an
X outline around. If the dragged outline ends up somewhere it
X can be glued to, do so, else zoom the outline back if appropriate.
X*/
X
X if (dSet != nil && FindBlob (thePoint, dSet, &d) == inDragBlob)
X {
X if (bcAdvise != nil && (*bcAdvise) (advDClick, d) == false)
X return; /* advisory says "quit" */
X
X dragDelta = DTrackBlob (d, inDragBlob, thePoint);
X if (dragDelta != badDragResult && dragDelta != 0)
X {
X thePoint.h += LoWord (dragDelta);
X thePoint.v += HiWord (dragDelta);
X srcRect = dstRect = BDragBox (d);
X OffsetRect (&dstRect, LoWord (dragDelta), HiWord (dragDelta));
X if (rSet != nil && FindReceptor (thePoint, rSet, &r1))
X {
X if (bcAdvise == nil || (*bcAdvise) (advGlue, r1))
X {
X db1 = d;
X db2 = BGlob (r1);
X rb1 = r1;
X bcResult = bcGlue;
X GlueGlob (d, r1);
X badDrag = false;
X }
X }
X if (badDrag && badDragZoom)
X ZoomRect (&dstRect, &srcRect);
X }
X }
X
X/*
X Mouse was not clicked in a donor. If it was clicked in a receptor,
X a glob may have been dragged back to the donor, or to another
X receptor, so get ready to process possible unglue or inter-receptor
X transaction. Can quit early if no receptor set was given
X (rSet = nil) or no inter-receptor or unglue transactions are allowed.
X*/
X else if (rSet != nil && (ungluePerm || xferPerm || swapPerm || dupPerm))
X {
X if (FindBlob (thePoint, rSet, &r1) == inDragBlob && BGlob (r1) != nil)
X {
X if (bcAdvise != nil && (*bcAdvise) (advRClick, r1) == false)
X return; /* advisory says "quit" */
X
X/*
X If the mouse is released without being moved, then save the click
X info, since it might be the first click of a double-click. There's
X no need to check any further for a possible transaction since the
X glob wasn't dragged anywhere.
X*/
X if ((dragDelta = DTrackBlob (r1, inDragBlob, thePoint)) == 0L)
X {
X lastWhen = t; /* save click info for possible */
X lastWhere = thePt; /* double-click next time */
X }
X else if (dragDelta != badDragResult)
X {
X thePoint.h += LoWord (dragDelta);
X thePoint.v += HiWord (dragDelta);
X
X/*
X Was the glob dragged back to it's owner? If so, unglue it if
X unglue permission is on. Can't use TestBlob, 'cause that'll
X be false if the donor is dimmed.
X*/
X d = BGlob (r1);
X if (ungluePerm && BlobActive (d)
X && (PtInRgn (thePoint, (**d).dragRgn)
X || PtInRgn (thePoint, (**d).statRgn)))
X {
X if (bcAdvise == nil || (*bcAdvise) (advUnglue, r1))
X {
X db1 = d;
X rb1 = r1;
X bcResult = bcUnglue;
X UnglueGlob (r1); /* no zooming */
X }
X return;
X }
X
X srcRect = dstRect = BDragBox (r1);
X OffsetRect (&dstRect, LoWord (dragDelta), HiWord (dragDelta));
X
X if (FindReceptor (thePoint, rSet, &r2) && r1 != r2)
X {
X
X /*
X Now know where the glob was dragged, so possibly have some kind
X of inter-receptor transaction. If replaces aren't allowed, then
X don't continue unless the receptor that was dragged to has no glob.
X Otherwise do whichever of swapping, duplicating or transferring is
X allowed. Precedence is in that order if more than one of them is
X allowed.
X */
X rb1 = r1; /* set cast now, but they */
X rb2 = r2; /* won't be meaningful if */
X db1 = BGlob (r1); /* no transaction is performed */
X db2 = BGlob (r2);
X if (db2 != nil && swapPerm)
X {
X if (bcAdvise == nil || (*bcAdvise) (advSwap, r2))
X {
X SwapGlob (r1, r2);
X bcResult = bcSwap;
X badDrag = false;
X }
X }
X else if (dupPerm)
X {
X if (CanGlue (db1))
X {
X if (bcAdvise == nil || (*bcAdvise) (advDup, r2))
X {
X DupGlob (r1, r2); /* duplicate blob */
X bcResult = bcDup;
X badDrag = false;
X }
X }
X }
X else if (xferPerm)
X {
X if (bcAdvise == nil || (*bcAdvise) (advXfer, r2))
X {
X TransferGlob (r1, r2); /* transfer blob */
X bcResult = bcXfer;
X badDrag = false;
X }
X }
X }
X if (badDrag && badDragZoom)
X ZoomRect (&dstRect, &srcRect);
X }
X }
X }
X}
X
X
X/*
X Result result code of last call to BlobClick.
X*/
X
XBClickResult ()
X{
X return (bcResult);
X}
X
X
X/*
X Result cast of characters involved in last call to BlobClick.
X*/
X
XBClickCast (d1, d2, r1, r2)
XBlobHandle *d1, *d2, *r1, *r2;
X{
X *d1 = db1;
X *d2 = db2;
X *r1 = rb1;
X *r2 = rb2;
X}
SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrDrag.c
X# include <WindowMgr.h>
X# include "BlobMgr.h"
X
X
X/* -------------------------------------------------------------------- */
X/* Blob Tracking and Dragging Routines */
X/* -------------------------------------------------------------------- */
X
X
X/*
X Blob dragging variables. See discussion of DragGrayRgn in
X the WIndow Manager section of Inside Mac. The defaults for the
X limit and slop rects are inappropriate and really should be set
X by the application.
X*/
X
XRect blobLimitRect = { -30000, -30000, 30000, 30000 };
XRect blobSlopRect = { -30000, -30000, 30000, 30000 };
Xint blobAxis = noConstraint;
X
X
X/* Set blob dragging limit and slop rectangles */
X
XSetBDragRects (limitRect, slopRect)
XRect *limitRect, *slopRect;
X{
X blobLimitRect = *limitRect;
X blobSlopRect = *slopRect;
X}
X
X
X/* get current blob dragging limit and slop rectangles */
X
XGetBDragRects (limitRect, slopRect)
XRect *limitRect, *slopRect;
X{
X *limitRect = blobLimitRect;
X *slopRect = blobSlopRect;
X}
X
X
X/* Set blob dragging axis constraints */
X
XSetBDragAxis (axis)
Xint axis;
X{
X blobAxis = axis;
X}
X
X
X/* Get current blob dragging axis constraints */
X
XGetBDragAxis ()
X{
X return (blobAxis);
X}
X
X
X/*
X Track blob by dragging an outline of the indicated part around
X until the mouse button is released. Return the difference between
X the starting and ending x and y coordinates in the low and high
X order words of the result.
X*/
X
X
Xlong TrackBlob (b, partCode, startPoint, limitRect, slopRect, axis)
XBlobHandle b;
Xint partCode;
XPoint startPoint;
XRect *limitRect, *slopRect;
Xint axis;
X{
XRgnHandle rgn;
XRect limit, bounds;
Xlong result;
X
X rgn = BCalcRegion (b, partCode);
X/*
X adjust the limit rectangle so the outline of the dragged regiopn
X always fits completely within the bounds rectangle
X*/
X limit = *limitRect;
X bounds = (**rgn).rgnBBox;
X limit.left += startPoint.h - bounds.left;
X limit.top += startPoint.v - bounds.top;
X limit.right -= bounds.right - startPoint.h - 1;
X limit.bottom -= bounds.bottom - startPoint.v - 1;
X
X result = DragGrayRgn (rgn, startPoint, &limit, slopRect, axis, nil);
X DisposeRgn (rgn);
X return (result);
X}
X
X
X/*
X Track a blob, using the default limit and slop rects
X*/
X
Xlong DTrackBlob (b, partCode, startPoint)
XBlobHandle b;
Xint partCode;
XPoint startPoint;
X{
X
X return (TrackBlob (b, partCode, startPoint,
X &blobLimitRect, &blobSlopRect, blobAxis));
X}
X
X
X/*
X Drag a blob by tracking it, and then moving it to the point
X where the mouse button was released.
X*/
X
XDragBlob (b, startPoint, limitRect, slopRect, axis)
XBlobHandle b;
XPoint startPoint;
XRect *limitRect, *slopRect;
Xint axis;
X{
Xlong result;
X
X result = TrackBlob (b, inFullBlob, startPoint,
X limitRect, slopRect, axis);
X
X if ((result != badDragResult) && (result != 0))
X OffsetBlob (b, inFullBlob, LoWord (result), HiWord (result));
X}
X
X
XDDragBlob (b, startPoint)
XBlobHandle b;
XPoint startPoint;
X{
X DragBlob (b, startPoint, &blobLimitRect, &blobSlopRect, blobAxis);
X}
SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrDraw.c
X/* --------------------------------------------------------------------- */
X/* Blob Manager Low-level Drawing Routines */
X/* --------------------------------------------------------------------- */
X
X# include "BlobMgr.h"
X
X
X
X/*
X Blob dimming parameters. dimPat and dimMode are the pattern and
X drawing mode used to dim out blobs. The initial pattern is gray.
X*/
X
Xstatic Pattern dimPat = { 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55 };
Xstatic int dimMode = patBic;
X
Xstatic RgnHandle oldClipRgn;
X
X
X/*
X Set or get the pattern to be used to dim blobs
X*/
X
XSetBDimInfo (p, mode)
XPattern *p;
Xint mode;
X{
X BlockMove (p, &dimPat, sizeof (Pattern));
X dimMode = mode;
X}
X
XGetBDimInfo (p, mode)
XPattern *p;
Xint *mode;
X{
X BlockMove (&dimPat, p, sizeof (Pattern));
X *mode = dimMode;
X}
X
X
X/*
X Set the clipping to the given region of the given blob. Return
X a handle to the region, or nil if the region is empty and doesn't
X need to be drawn. The handle should not be disposed of by the
X caller - it's a copy of the handle, not a copy of the region.
X If the handle returned is not nil, call RestoreDrawClip after doing
X the drawing to restore the clipping properly.
X*/
X
Xstatic RgnHandle SetDrawClip (b, partCode)
XBlobHandle b;
Xint partCode;
X{
Xregister RgnHandle drawRgn, newClipRgn;
X
X drawRgn = (partCode == inDragBlob ? (**b).dragRgn : (**b).statRgn);
X if (EmptyRgn (drawRgn)) /* don't bother if fail here! */
X return (nil);
X
X oldClipRgn = NewRgn ();
X newClipRgn = NewRgn ();
X GetClip (oldClipRgn);
X SectRgn (drawRgn, oldClipRgn, newClipRgn);
X SetClip (newClipRgn);
X DisposeRgn (newClipRgn);
X return (drawRgn);
X}
X
X
Xstatic RestoreDrawClip ()
X{
X SetClip (oldClipRgn); /* restore original clipping */
X DisposeRgn (oldClipRgn);
X}
X
X
X/*
X Dim the given region.
X*/
X
Xstatic DimRgn (rgn)
XRgnHandle rgn;
X{
XPenState ps;
X
X GetPenState (&ps); /* save current pen state */
X PenPat (dimPat);
X PenMode (dimMode);
X PaintRgn (rgn);
X SetPenState (&ps); /* restore pen state */
X}
X
X
X/*
X Given a picture and a rectangle corresponding to a portion of the picture
X frame DrawBlobPic draws the picture in the given part of the given blob,
X accounting for size and location differences. Any portion of sRect
X lying outside of the picture's frame will not be drawn.
X The partCode must be inDragBlob or inFullBlob.
X
X The drawing is clipped to the region the be drawn
X (respecting current clipping).
X*/
X
Xstatic DrawBlobPic (b, partCode, p, srcRect)
XBlobHandle b;
Xint partCode;
XPicHandle p;
XRect *srcRect;
X
X{
Xregister RgnHandle rgn;
XRect dstRect, pFrame;
X
X rgn = SetDrawClip (b, partCode);
X if (p != nil && rgn != nil) /* don't bother if fail here! */
X {
X pFrame = (**p).picFrame; /* map frame to correct size */
X dstRect = (**rgn).rgnBBox; /* and location in relation */
X MapRect (&pFrame, srcRect, &dstRect); /* to region to be drawn */
X DrawPicture (p, &pFrame);
X if (GetBDrawMode (b, partCode) == dimDraw) /* region is dimmed */
X DimRgn (rgn);
X }
X if (rgn != nil)
X RestoreDrawClip (); /* restore original clipping */
X}
X
X
X/*
X Draw a blob using a drawing procedure. bDst is the blob to be drawn,
X partCode specifies the region of bDst to draw (either inDragBlob or
X inStatBlob). bSrc is the blob whose region is to be drawn in the
X specified region of bDst, and proc is the drawing procedure to use.
X bSrc is different than bDst if partCode is inDragBlob and bDst has
X a glob.
X*/
X
Xstatic CallBDrawProc (bDst, bSrc, proc, partCode)
XBlobHandle bDst, bSrc;
XProcPtr proc;
Xint partCode;
X{
Xregister RgnHandle rgn;
X
X rgn = SetDrawClip (bDst, partCode);
X if (proc != nil && rgn != nil)
X {
X (*proc) (bDst, bSrc, partCode);
X if (GetBDrawMode (bDst, partCode) == dimDraw) /* region is dimmed */
X DimRgn (rgn);
X }
X if (rgn != nil)
X RestoreDrawClip (); /* restore original clipping */
X}
X
X
X/*
X DrawBlob draws the indicated part of the blob (the entire blob
X if partCode is inFullBlob).
X
X The blob must be enabled. If draw mode is dimDraw then draw
X it dimmed.
X*/
X
X
XDrawBlob (b, partCode)
XBlobHandle b;
Xint partCode;
X
X{
Xregister BlobHandle b2;
Xregister PicHandle pic;
XRect srcFrame;
X
X if (BlobEnabled (b))
X {
X if ((partCode == inStatBlob) || (partCode == inFullBlob))
X {
X if (PicBlob (b))
X {
X srcFrame = (**b).statRect;
X DrawBlobPic (b, inStatBlob, (**b).bPicProc.bPic, &srcFrame);
X }
X else
X CallBDrawProc (b, b, (**b).bPicProc.bDrawProc, inStatBlob);
X }
X
X if ((partCode == inDragBlob) || (partCode == inFullBlob))
X {
X /*
X Set b2 to the blob that should have it's drag region drawn
X in b's drag region. If b has no glob, then it's b.
X */
X if ((b2 = BGlob (b)) == nil)
X b2 = b;
X if (PicBlob (b2))
X {
X pic = (**b2).bPicProc.bPic; /* picture to draw */
X srcFrame = (**b2).dragRect; /* part of picture to draw */
X DrawBlobPic (b, inDragBlob, pic, &srcFrame);
X }
X else
X CallBDrawProc (b, b2, (**b2).bPicProc.bDrawProc, inDragBlob);
X }
X }
X}
X
X
XDrawBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc2 (&DrawBlob, bSet, inFullBlob);
X}
SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrFlags.c
X# include "BlobMgr.h"
X
X
X/* -------------------------------------------------------------------- */
X/* Blob Flag Manipulation Routines */
X/* */
X/* These routines operate only on the content of the blob state fields.*/
X/* They do NOT do any redrawing or change the display in any way. */
X/* */
X/* -------------------------------------------------------------------- */
X
X
XSetBlobFlags (b, bitMask)
XBlobHandle b;
Xint bitMask;
X{
X (**b).flags |= bitMask;
X}
X
X
XClearBlobFlags (b, bitMask)
XBlobHandle b;
Xint bitMask;
X{
X (**b).flags &= ~bitMask; /* what's the operator here? */
X}
X
X
X/*
X Test the function result to be sure it's equal to the bitMask
X passed in, if exact match is required.
X*/
X
XTestBlobFlags (b, bitMask)
XBlobHandle b;
Xint bitMask;
X{
X return ((**b).flags & bitMask);
X}
X
X
XEnableBlob (b)
XBlobHandle b;
X{
X SetBlobFlags (b, bEnableMask);
X}
X
X
XEnableBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&EnableBlob, bSet);
X}
X
X
XDisableBlob (b)
XBlobHandle b;
X{
X ClearBlobFlags (b, bEnableMask);
X}
X
X
XDisableBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&DisableBlob, bSet);
X}
X
X
X
XGetBDrawMode (b, partCode)
XBlobHandle b;
Xint partCode;
X{
Xint mask;
X
X mask = 0;
X switch (partCode)
X {
X case inDragBlob: mask = bDragModeMask; break;
X case inStatBlob: mask = bStatModeMask; break;
X }
X return (TestBlobFlags (b, mask) == mask ? dimDraw : normalDraw);
X}
X
X
XSetBDrawMode (b, partCode, mode)
XBlobHandle b;
Xint partCode;
Xint mode;
X{
Xint mask;
X
X switch (partCode)
X {
X case inFullBlob: mask = bDrawModeMask; break;
X case inDragBlob: mask = bDragModeMask; break;
X case inStatBlob: mask = bStatModeMask; break;
X }
X if (mode == dimDraw)
X SetBlobFlags (b, mask);
X else
X ClearBlobFlags (b, mask);
X}
X
X
XGetFzBDrawMode (b, partCode)
XBlobHandle b;
Xint partCode;
X{
Xint mask;
X
X mask = 0;
X switch (partCode)
X {
X case inDragBlob: mask = bDragModeMask; break;
X case inStatBlob: mask = bStatModeMask; break;
X }
X return (((**b).fzFlags & mask) == mask ? dimDraw : normalDraw);
X}
X
X
X
XBoolean BlobDimmed (b, partCode)
XBlobHandle b;
Xint partCode;
X{
Xint bitMask;
X
X switch (partCode)
X {
X case inFullBlob: bitMask = bDrawModeMask; break;
X case inStatBlob: bitMask = bStatModeMask; break;
X case inDragBlob: bitMask = bDragModeMask; break;
X }
X return (TestBlobFlags (b, bitMask) == bitMask);
X}
X
X
XBoolean BlobEnabled (b)
XBlobHandle b;
X{
X return (TestBlobFlags (b, bEnableMask) == bEnableMask);
X}
X
X
XBoolean BlobFrozen (b)
XBlobHandle b;
X{
X return (TestBlobFlags (b, bFreezeMask) == bFreezeMask);
X}
X
X
X/*
X Active = enabled, but not frozen.
X*/
X
XBoolean BlobActive (b)
XBlobHandle b;
X{
X return (TestBlobFlags (b, bEnableMask | bFreezeMask) == bEnableMask);
X}
X
X
X/*
X Return true if the blob can be glued to another blob. This is true
X if the blob is infinitely gluable or the current glue count is less
X than the blob's maximum glue count.
X*/
X
XBoolean CanGlue (b)
XBlobHandle b;
X{
Xint glueMax;
X
X glueMax = GetBGlueMax (b);
X return (glueMax == infiniteGlue || glueMax > (**b).glueCount);
X}
X
X
X/*
X Return true if the blob is a picture blob, false if it's a
X procedure blob
X*/
X
XBoolean PicBlob (b)
XBlobHandle b;
X{
X return (TestBlobFlags (b, bPicMask) == bPicMask);
X}SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrFreeze.c
X# include "BlobMgr.h"
X
X
XFreezeBlob (b)
XBlobHandle b;
X{
X if (!BlobFrozen (b))
X {
X SetBlobFlags (b, bFreezeMask);
X (**b).fzFlags = ((**b).flags & (bDrawModeMask));
X }
X}
X
X
XFreezeBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&FreezeBlob, bSet);
X}
X
X
XThawBlob (b)
XBlobHandle b;
X{
X if (BlobFrozen (b))
X {
X ClearBlobFlags (b, bFreezeMask); /* unfreeze blob */
X HiliteBlob (b, inStatBlob, GetFzBDrawMode (b, inStatBlob));
X HiliteBlob (b, inDragBlob, GetFzBDrawMode (b, inDragBlob));
X }
X}
X
X
XThawBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&ThawBlob, bSet);
X}
X
X
X/*
X Display enabled quiet blobs with drawing mode quietMode, display
X enabled noisy blobs with drawing mode noisyMode. Freezes all enabled
X blobs, so should be balanced with a call to ThawBlobs.
X*/
X
X
XBlobFeedback (bSet, quietMode, noisyMode)
XBlobSetHandle bSet;
Xint quietMode, noisyMode;
X{
XBlobHandle b;
X
X for (b = FirstBlob (bSet); b != nil; b = NextBlob (b))
X {
X FreezeBlob (b);
X HiliteBlob (b, inFullBlob, (BlobQuiet (b) ? quietMode : noisyMode));
X }
X}
SHAR_EOF
sed 's/^X//' << 'SHAR_EOF' > BMgr/BMgrHideShow.c
X# include "BlobMgr.h"
X
X
X
X/*
X If blob not already hidden, hide it by filling both the bounds
X box of each region with current grafport's background pattern,
X and accumulate the boxes into the update region.
X*/
X
XHideBlob (b)
XBlobHandle b;
X{
XGrafPtr thePort;
XRect r;
X
X if (BlobEnabled (b)) /* ignore if already disabled */
X {
X DisableBlob (b);
X GetPort (&thePort);
X
X r = BStatBox (b);
X FillRect (&r, &thePort->bkPat);
X InvalRect (&r);
X
X r = BDragBox (b);
X FillRect (&r, &thePort->bkPat);
X InvalRect (&r);
X }
X}
X
X
XHideBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&HideBlob, bSet);
X}
X
X
X/*
X If blob is not already enabled, show it.
X*/
X
XShowBlob (b)
XBlobHandle b;
X{
X if (BlobEnabled (b) == false) /* ignore if already enabled */
X {
X EnableBlob (b);
X DrawBlob (b, inFullBlob);
X }
X}
X
X
XShowBlobSet (bSet)
XBlobSetHandle bSet;
X{
X BlobLoopProc1 (&ShowBlob, bSet);
X}
SHAR_EOF
exit