gecko-dev/lib/mac/UserInterface/CSharedPatternWorld.cp

328 строки
9.3 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public
* License Version 1.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
#include "CSharedPatternWorld.h"
#include "UGraphicGizmos.h"
#include <LArray.h>
#include <LArrayIterator.h>
LArray* CSharedPatternWorld::sPatterns = NULL;
Boolean CSharedPatternWorld::sUseUtilityPattern = false;
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ CreateSharedPatternWorld [ static ]
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
CSharedPatternWorld* CSharedPatternWorld::CreateSharedPatternWorld(ResIDT inPatternID)
{
CSharedPatternWorld* thePatternWorld = NULL;
if (sUseUtilityPattern)
inPatternID = cUtilityPatternResID;
try
{
if (sPatterns == NULL)
sPatterns = new LArray(sizeof(CSharedPatternWorld*));
CSharedPatternWorld* theIndexWorld = NULL;
LArrayIterator theIter(*sPatterns, LArrayIterator::from_Start);
while (theIter.Next(&theIndexWorld))
{
if (theIndexWorld->mPatternID == inPatternID)
{
thePatternWorld = theIndexWorld;
break;
}
}
if (thePatternWorld == NULL)
thePatternWorld = new CSharedPatternWorld(inPatternID);
}
catch (...)
{
delete thePatternWorld;
thePatternWorld = NULL;
}
return thePatternWorld;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ CalcRelativePoint [ static ]
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CSharedPatternWorld::CalcRelativePoint(
LPane* inForPane,
EPatternOrientation inOrientation,
Point& outPoint)
{
// the downward scale from 32 to 16 bit coordinate spaces
// in converting from SPoint32 to plain old Point
// is ok because we are guaranteed to be in bounds since we
// wont be drawing if we cant FocusExposed().
switch (inOrientation)
{
case CSharedPatternWorld::eOrientation_Self:
{
SPoint32 theFrameLocation;
inForPane->GetFrameLocation(theFrameLocation);
outPoint.h = theFrameLocation.h;
outPoint.v = theFrameLocation.v;
inForPane->PortToLocalPoint(outPoint);
}
break;
case CSharedPatternWorld::eOrientation_Superview:
{
SPoint32 theFrameLocation;
inForPane->GetSuperView()->GetFrameLocation(theFrameLocation);
outPoint.h = -theFrameLocation.h;
outPoint.v = -theFrameLocation.v;
inForPane->PortToLocalPoint(outPoint);
}
break;
case CSharedPatternWorld::eOrientation_Port:
{
SPoint32 theFrameLocation;
inForPane->GetFrameLocation(theFrameLocation);
outPoint.h = -theFrameLocation.h;
outPoint.v = -theFrameLocation.v;
}
break;
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ CSharedPatternWorld
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
CSharedPatternWorld::CSharedPatternWorld(ResIDT inPatternID)
{
PixPatHandle thePattern = NULL;
mPatternWorld = NULL;
mPatternHandle = NULL;
try
{
mPatternID = inPatternID;
thePattern = ::GetPixPat(inPatternID);
ThrowIfResFail_(thePattern);
// If our pix map is 8 bits or less deep we can avoid making an
// offscreen world to store the pattern.
PixMapHandle thePatPixMap = (*thePattern)->patMap;
mIsShallow = ((*thePatPixMap)->pixelSize <= 8);
if (!IsShallow())
{
// We have a pattern that is deeper than 8 bits. As documented
// in the header file, QuickDraw will draw the pattern differently
// in this case. We need to create an offscreen copy of the pattern
// so that we can draw it ourselves.
// Get the pattern's rect from its pix map and normalize
Rect thePatternFrame = (*thePatPixMap)->bounds;
::OffsetRect(&thePatternFrame, -thePatternFrame.left, -thePatternFrame.top);
// make an offscreen world the same size as the pattern
mPatternWorld = new CGWorld(thePatternFrame, (*thePatPixMap)->pixelSize, 0, (*thePatPixMap)->pmTable);
// and draw into it
ThrowIfNot_(mPatternWorld->BeginDrawing());
::FillCRect(&thePatternFrame, thePattern);
mPatternWorld->EndDrawing();
// Ok, we've successfully copied the pattern so we can get
// rid of the pattern handle.
::DisposePixPat(thePattern);
}
else
{
// the pattern is 8 bits or less. We'll just keep the pattern
// handle around for drawing.
mPatternHandle = thePattern;
}
// add this to static shared pattern list
Assert_(sPatterns);
sPatterns->InsertItemsAt(1, LArray::index_Last, &this);
}
catch (...)
{
delete mPatternWorld;
mPatternWorld = NULL;
if (thePattern != NULL)
::DisposePixPat(thePattern);
throw;
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ ~CSharedPatternWorld
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
CSharedPatternWorld::~CSharedPatternWorld()
{
// remove this from static shared pattern list
Assert_(sPatterns);
sPatterns->Remove(&this);
if (mPatternHandle != NULL)
::DisposePixPat(mPatternHandle);
delete mPatternWorld;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ Fill (Rect)
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CSharedPatternWorld::Fill(
CGrafPtr inPort,
const Rect& inBounds,
Point inAlignTo)
{
if (IsShallow())
FillShallow(inPort, inBounds, inAlignTo);
else
FillDeep(inPort, inBounds, inAlignTo);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ Fill (Region)
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CSharedPatternWorld::Fill(
CGrafPtr inPort,
RgnHandle inRegion,
Point inAlignTo)
{
StClipRgnState theClipSaver;
::SetClip(inRegion);
Rect theBounds = (*inRegion)->rgnBBox;
if (IsShallow())
FillShallow(inPort, theBounds, inAlignTo);
else
FillDeep(inPort, theBounds, inAlignTo);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ FillShallow
//
// Here we fill a rect with a pattern that is 8 bits or less in depth. See
// the header file for why this is necessary.
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CSharedPatternWorld::FillShallow(
CGrafPtr inPort,
const Rect& inBounds,
Point inAlignTo)
{
StClipRgnState theClipSaver;
theClipSaver.ClipToIntersection(inBounds);
StPortOriginState theOriginSaver((GrafPtr)inPort);
Point theOldOrigin = topLeft(inPort->portRect);
Point theNewOrigin;
theNewOrigin.h = theOldOrigin.h - inAlignTo.h;
theNewOrigin.v = theOldOrigin.v - inAlignTo.v;
Point theDelta;
theDelta.h = theNewOrigin.h - theOldOrigin.h;
theDelta.v = theNewOrigin.v - theOldOrigin.v;
StRegion theClip;
::GetClip(theClip);
::OffsetRgn(theClip, theDelta.h, theDelta.v);
::SetClip(theClip);
Rect theOffsetBounds = inBounds;
::OffsetRect(&theOffsetBounds, theDelta.h, theDelta.v);
::SetOrigin(theNewOrigin.h, theNewOrigin.v);
::FillCRect(&theOffsetBounds, mPatternHandle);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ FillDeep
//
// Here we fill a rect with a pattern that is deeper than 8 bits. See
// the header file for why this is necessary.
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CSharedPatternWorld::FillDeep(
CGrafPtr inPort,
const Rect& inBounds,
Point inAlignTo)
{
PixMapHandle thePatternMap = ::GetGWorldPixMap(mPatternWorld->GetMacGWorld());
PixMapHandle theDestMap = inPort->portPixMap;
StClipRgnState theClipSaver;
theClipSaver.ClipToIntersection(inBounds);
StRegion theClip;
::GetClip(theClip);
Rect thePatternFrame = (*thePatternMap)->bounds;
Int16 thePatternWidth = RectWidth(thePatternFrame);
Int16 thePatternHeight = RectHeight(thePatternFrame);
Int32 theStampLeft = inAlignTo.h + thePatternWidth * ((inBounds.left - inAlignTo.h) / thePatternWidth);
Int32 theStampTop = inAlignTo.v + thePatternHeight * ((inBounds.top - inAlignTo.v) / thePatternHeight);
Rect theStamp;
theStamp.top = theStampTop;
theStamp.left = theStampLeft;
theStamp.bottom = theStamp.top + thePatternHeight;
theStamp.right = theStamp.left + thePatternWidth;
while (theStamp.top <= inBounds.bottom)
{
while (theStamp.left <= inBounds.right)
{
if (::RectInRgn(&theStamp, theClip))
::CopyBits((BitMap*)(*thePatternMap), (BitMap*)(*theDestMap), &thePatternFrame, &theStamp, srcCopy, NULL);
theStamp.left += thePatternWidth;
theStamp.right += thePatternWidth;
}
theStamp.left = theStampLeft;
theStamp.top += thePatternHeight;
theStamp.bottom = theStamp.top + thePatternHeight;
theStamp.right = theStamp.left + thePatternWidth;
}
}