// ****************************************************************************
//
// Function Name: RWindowView::RWindowView( )
//
// Description: Render this views background
//
// Returns: Nothing
//
// Exceptions: None
//
// ****************************************************************************
//
void RWindowView::RenderBackground( RDrawingSurface& drawingSurface, const R2dTransform&, const RIntRect& rcRender ) const
{
// Fill in the background
if( !drawingSurface.IsPrinting( ) )
{
RColor backgroundColor = GetBackgroundColor( );
if ( backgroundColor.GetFillMethod() == RColor::kSolid )
{
RSolidColor solid = backgroundColor.GetSolidColor( );
// Check for something close to TRUE GRAY and alter it slightly
#ifdef _WINDOWS
const YColorComponent kHitBits = 0xC0;
const YColorComponent kNewColor = 0x77;
const YColorComponent kGrayColor = 0x80;
#elif defined( MAC )
const YColorComponent kHitBits = 0xF000;
const YColorComponent kNewColor = 0x7777;
const YColorComponent kGrayColor = 0x8000;
#endif // _WINDOWS or MAC
YColorComponent redColor = (solid.GetRed( ) & kHitBits);
YColorComponent greenColor = (solid.GetGreen( ) & kHitBits);
YColorComponent blueColor = (solid.GetBlue( ) & kHitBits);
if ( (kGrayColor == redColor) && (redColor == greenColor) && (greenColor == blueColor) )
{
backgroundColor = RSolidColor( kNewColor, kNewColor, kNewColor );
}
}
drawingSurface.SetForegroundMode( kNormal );
drawingSurface.SetFillColor( backgroundColor );
drawingSurface.FillRectangle( rcRender );
}
}
// ****************************************************************************
//
// Function Name: RSingleSelection::DrawRotateHandle( )
//
// Description: Draws the rotation line and handle
//
// Returns: Nothing
//
// Exceptions: Memory
//
// ****************************************************************************
//
void RSingleSelection::DrawRotateHandle( RDrawingSurface& drawingSurface, const R2dTransform& transform, const RIntRect& ) const
{
// Get the bounding rect
YSelectionBoundingRect boundingRect;
GetSelectionBoundingRect( boundingRect );
// Get the center point; this will be one end point of the rotate handle line
RRealPoint centerPoint = boundingRect.GetCenterPoint( );
// Get the other end point
RRealPoint lineEndPoint = GetRotateHandleCenterPoint( );
// Draw the line
drawingSurface.MoveTo( centerPoint, transform );
drawingSurface.LineTo( lineEndPoint, transform );
// Now draw the rotate handle
// Convert to device units
::LogicalUnitsToDeviceUnits( lineEndPoint, *m_pView );
// Now build the rotate handle, using this point as the middle of the left side
RRealRect rotateHandleRect;
rotateHandleRect.m_Left = lineEndPoint.m_x - ( kRotateHandleRenderSize / 2 );
rotateHandleRect.m_Top = lineEndPoint.m_y - ( kRotateHandleRenderSize / 2 );
rotateHandleRect.m_Right = lineEndPoint.m_x + ( kRotateHandleRenderSize / 2 ) + 1;
rotateHandleRect.m_Bottom = lineEndPoint.m_y + ( kRotateHandleRenderSize / 2 ) + 1;
::DeviceUnitsToLogicalUnits( rotateHandleRect, *m_pView );
// Now draw the rotate handle
rotateHandleRect *= transform;
drawingSurface.FillRectangle( rotateHandleRect );
}
void RRotateDialog::RotateDisplay( int iPos )
{
if ( iPos == m_iPrevPos )
return;
// We need to use the RBitmap::Rotate() function, so to do that, convert to
// Renaissance types.
CClientDC clientDC( &m_staticDisplay );
HDC hClientDC = clientDC.GetSafeHdc();
RDcDrawingSurface drawSurface;
drawSurface.Initialize( hClientDC, hClientDC );
R2dTransform transform;
// Prepare the image on an offscreen DC
RAutoDrawingSurface drawSurfaceOffscreen;
RRealRect rRealStaticRect(m_rectStaticDisplay);
BOOLEAN fPrepared = drawSurfaceOffscreen.Prepare( &drawSurface, transform, rRealStaticRect );
RDrawingSurface* pSurface = ( (fPrepared)? &drawSurfaceOffscreen : &drawSurface );
// Paint the offscreen DC white
RColor rColor = RSolidColor( kWhite );
pSurface->SetFillColor( rColor );
pSurface->SetPenColor( rColor );
pSurface->FillRectangle( m_rectStaticDisplay );
YAngle flRadiansRotation = ::DegreesToRadians( YFloatType( iPos ) );
// The rotation leaves a black background, so blit with a mask. The mask
// has to be created the same size as the original (not rotated) bitmap
// size, so create it and then rotate it.
RBitmapImage bmpRotated;
RBitmapImage bmpMaskRotated;
RImageLibrary rLibrary;
rLibrary.Rotate( m_rBitmapImage, bmpRotated, bmpMaskRotated, flRadiansRotation );
RIntSize sizeBmpRotated;
sizeBmpRotated.m_dx = bmpRotated.GetWidthInPixels();
sizeBmpRotated.m_dy = bmpRotated.GetHeightInPixels();
RIntRect rectSource;
RIntRect rectDest;
DeriveSourceAndDestinationRects( sizeBmpRotated, rectSource, rectDest );
bmpRotated.RenderWithMask( *pSurface, bmpMaskRotated, rectSource, rectDest );
if ( fPrepared )
drawSurfaceOffscreen.Release();
drawSurface.DetachDCs();
m_iPrevPos = iPos;
}
// ****************************************************************************
//
// Function Name: RSingleSelection::Render( )
//
// Description: Draws the selection rect and handles
//
// Returns: Nothing
//
// Exceptions: Memory
//
// ****************************************************************************
//
void RSingleSelection::Render( RDrawingSurface& drawingSurface, const R2dTransform& transform, const RIntRect& rcRender, BOOLEAN fRenderIfLocked ) const
{
// Get the component attributes
const RComponentAttributes& componentAttributes = m_pSelectedObject->GetComponentAttributes( );
BOOLEAN fIsLocked = componentAttributes.IsLocked( );
if( fRenderIfLocked || !fIsLocked )
{
// Set surface attributes
drawingSurface.SetPenWidth( kSelectionOutlineWidth );
drawingSurface.SetPenStyle( kSolidPen );
RRealRect resizeHandleRect;
// Draw the resize handles
if( componentAttributes.IsResizable( FALSE ) )
{
RArray<RRealRect> rectList;
RRealSize scaleFactor( kDummyScale, kDummyScale );
scaleFactor = m_pSelectedObject->ApplyResizeConstraint( scaleFactor );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
if ( !AreFloatsEqual( scaleFactor.m_dy, kConstrainedScale ) )
{
GetResizeSelectionHandle( resizeHandleRect, transform, kBottomResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kTopResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
}
if ( !AreFloatsEqual( scaleFactor.m_dx, kConstrainedScale ) )
{
GetResizeSelectionHandle( resizeHandleRect, transform, kRightResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
GetResizeSelectionHandle( resizeHandleRect, transform, kLeftResizeHandle, TRUE );
rectList.InsertAtEnd( resizeHandleRect );
}
RArray<RRealRect>::YIterator iterator = rectList.Start( );
RArray<RRealRect>::YIterator iteratorEnd = rectList.End( );
if( fIsLocked )
{
while ( iterator != iteratorEnd )
drawingSurface.FrameRectangle( *iterator++ );
}
else
{
while ( iterator != iteratorEnd )
drawingSurface.FillRectangle( *iterator++ );
}
}
// Draw the rotate line and handle
if( componentAttributes.IsRotatable( ) )
DrawRotateHandle( drawingSurface, transform, rcRender );
// Draw the selection frame
m_pSelectedObject->DrawSelectionFrame( drawingSurface, transform );
}
}