+
+bool wxDC::DoStretchBlit(wxCoord xdest, wxCoord ydest,
+ wxCoord dstWidth, wxCoord dstHeight,
+ wxDC *source,
+ wxCoord xsrc, wxCoord ysrc,
+ wxCoord srcWidth, wxCoord srcHeight,
+ int logical_func, bool useMask,
+ wxCoord xsrcMask, wxCoord ysrcMask)
+{
+ wxCHECK_MSG(Ok(), false, wxT("wxDC::DoStretchBlit - invalid DC"));
+ wxCHECK_MSG(source->Ok(), false, wxT("wxDC::DoStretchBlit - invalid source DC"));
+
+ if ( logical_func == wxNO_OP )
+ return true ;
+
+ if (xsrcMask == -1 && ysrcMask == -1)
+ {
+ xsrcMask = xsrc;
+ ysrcMask = ysrc;
+ }
+
+ // correct the parameter in case this dc does not have a mask at all
+ if ( useMask && !source->m_macMask )
+ useMask = false ;
+
+ Rect srcrect , dstrect ;
+ srcrect.top = source->YLOG2DEVMAC(ysrc) ;
+ srcrect.left = source->XLOG2DEVMAC(xsrc) ;
+ srcrect.right = source->XLOG2DEVMAC(xsrc + srcWidth ) ;
+ srcrect.bottom = source->YLOG2DEVMAC(ysrc + srcHeight) ;
+ dstrect.top = YLOG2DEVMAC(ydest) ;
+ dstrect.left = XLOG2DEVMAC(xdest) ;
+ dstrect.bottom = YLOG2DEVMAC(ydest + dstHeight ) ;
+ dstrect.right = XLOG2DEVMAC(xdest + dstWidth ) ;
+ short mode = kUnsupportedMode ;
+ bool invertDestinationFirst = false ;
+
+ switch ( logical_func )
+ {
+ case wxAND: // src AND dst
+ mode = adMin ; // ok
+ break ;
+
+ case wxAND_INVERT: // (NOT src) AND dst
+ mode = notSrcOr ; // ok
+ break ;
+
+ case wxAND_REVERSE:// src AND (NOT dst)
+ invertDestinationFirst = true ;
+ mode = srcOr ;
+ break ;
+
+ case wxCLEAR: // 0
+ mode = kEmulatedMode ;
+ break ;
+
+ case wxCOPY: // src
+ mode = srcCopy ; // ok
+ break ;
+
+ case wxEQUIV: // (NOT src) XOR dst
+ mode = srcXor ; // ok
+ break ;
+
+ case wxINVERT: // NOT dst
+ mode = kEmulatedMode ; //or hilite ;
+ break ;
+
+ case wxNAND: // (NOT src) OR (NOT dst)
+ invertDestinationFirst = true ;
+ mode = srcBic ;
+ break ;
+
+ case wxNOR: // (NOT src) AND (NOT dst)
+ invertDestinationFirst = true ;
+ mode = notSrcOr ;
+ break ;
+
+ case wxNO_OP: // dst
+ mode = kEmulatedMode ; // this has already been handled upon entry
+ break ;
+
+ case wxOR: // src OR dst
+ mode = notSrcBic ;
+ break ;
+
+ case wxOR_INVERT: // (NOT src) OR dst
+ mode = srcBic ;
+ break ;
+
+ case wxOR_REVERSE: // src OR (NOT dst)
+ invertDestinationFirst = true ;
+ mode = notSrcBic ;
+ break ;
+
+ case wxSET: // 1
+ mode = kEmulatedMode ;
+ break ;
+
+ case wxSRC_INVERT: // (NOT src)
+ mode = notSrcCopy ; // ok
+ break ;
+
+ case wxXOR: // src XOR dst
+ mode = notSrcXor ; // ok
+ break ;
+
+ default :
+ break ;
+ }
+
+ if ( mode == kUnsupportedMode )
+ {
+ wxFAIL_MSG(wxT("unsupported blitting mode" ));
+
+ return false ;
+ }
+
+ CGrafPtr sourcePort = (CGrafPtr) source->m_macPort ;
+ PixMapHandle bmappixels = GetGWorldPixMap( sourcePort ) ;
+ if ( LockPixels(bmappixels) )
+ {
+ wxMacFastPortSetter helper(this) ;
+
+ if ( source->GetDepth() == 1 )
+ {
+ RGBForeColor( &MAC_WXCOLORREF(m_textForegroundColour.GetPixel()) ) ;
+ RGBBackColor( &MAC_WXCOLORREF(m_textBackgroundColour.GetPixel()) ) ;
+ }
+ else
+ {
+ // the modes need this, otherwise we'll end up having really nice colors...
+ RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF } ;
+ RGBColor black = { 0, 0, 0 } ;
+
+ RGBForeColor( &black ) ;
+ RGBBackColor( &white ) ;
+ }
+
+ if ( useMask && source->m_macMask )
+ {
+ if ( mode == srcCopy )
+ {
+ if ( LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) )
+ {
+ CopyMask( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(source->m_macMask) ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &srcrect , &dstrect ) ;
+ UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ }
+ }
+ else
+ {
+ RgnHandle clipRgn = NewRgn() ;
+ LockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ BitMapToRegion( clipRgn , (BitMap*) *GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ UnlockPixels( GetGWorldPixMap( MAC_WXHBITMAP(source->m_macMask) ) ) ;
+ OffsetRgn( clipRgn , -srcrect.left + dstrect.left, -srcrect.top + dstrect.top ) ;
+
+ if ( mode == kEmulatedMode )
+ {
+ Pattern pat ;
+
+ ::PenPat(GetQDGlobalsBlack(&pat));
+ if ( logical_func == wxSET )
+ {
+ RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxCLEAR )
+ {
+ RGBColor col= { 0x0000, 0x0000, 0x0000 } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxINVERT )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ else
+ {
+ for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
+ {
+ for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
+ {
+ Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
+ Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
+ if ( PtInRgn( dstPoint , clipRgn ) )
+ {
+ RGBColor srcColor, dstColor ;
+
+ // NOTE: Get/SetCPixel are slow!
+ SetPort( (GrafPtr) sourcePort ) ;
+ GetCPixel( srcPoint.h , srcPoint.v , &srcColor ) ;
+ SetPort( (GrafPtr) m_macPort ) ;
+ GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
+ SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if ( invertDestinationFirst )
+ MacInvertRgn( clipRgn ) ;
+
+ CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &dstrect, mode, clipRgn ) ;
+ }
+
+ DisposeRgn( clipRgn ) ;
+ }
+ }
+ else
+ {
+ RgnHandle clipRgn = NewRgn() ;
+ SetRectRgn( clipRgn , dstrect.left , dstrect.top , dstrect.right , dstrect.bottom ) ;
+
+ if ( mode == kEmulatedMode )
+ {
+ Pattern pat ;
+
+ ::PenPat(GetQDGlobalsBlack(&pat));
+ if ( logical_func == wxSET )
+ {
+ RGBColor col= { 0xFFFF, 0xFFFF, 0xFFFF } ;
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxCLEAR )
+ {
+ RGBColor col = { 0x0000, 0x0000, 0x0000 } ;
+
+ ::RGBForeColor( &col ) ;
+ ::PaintRgn( clipRgn ) ;
+ }
+ else if ( logical_func == wxINVERT )
+ {
+ MacInvertRgn( clipRgn ) ;
+ }
+ else
+ {
+ for ( int y = 0 ; y < srcrect.right - srcrect.left ; ++y )
+ {
+ for ( int x = 0 ; x < srcrect.bottom - srcrect.top ; ++x )
+ {
+ Point dstPoint = { dstrect.top + y , dstrect.left + x } ;
+ Point srcPoint = { srcrect.top + y , srcrect.left + x } ;
+ {
+ RGBColor srcColor, dstColor ;
+
+ // NOTE: Get/SetCPixel are slow!
+ SetPort( (GrafPtr) sourcePort ) ;
+ GetCPixel( srcPoint.h , srcPoint.v , &srcColor) ;
+ SetPort( (GrafPtr) m_macPort ) ;
+ GetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ wxMacCalculateColour( logical_func , srcColor , dstColor ) ;
+ SetCPixel( dstPoint.h , dstPoint.v , &dstColor ) ;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if ( invertDestinationFirst )
+ MacInvertRgn( clipRgn ) ;
+
+ CopyBits( GetPortBitMapForCopyBits( sourcePort ) ,
+ GetPortBitMapForCopyBits( MAC_WXHBITMAP(m_macPort) ) ,
+ &srcrect, &dstrect, mode, NULL ) ;
+ }
+
+ DisposeRgn( clipRgn ) ;
+ }
+
+ UnlockPixels( bmappixels ) ;
+ }
+
+ m_macPenInstalled = false ;
+ m_macBrushInstalled = false ;
+ m_macFontInstalled = false ;
+
+ return true;
+}
+
+void wxDC::DoDrawRotatedText(const wxString& str, wxCoord x, wxCoord y,
+ double angle)
+{
+ wxCHECK_RET( Ok(), wxT("wxDC::DoDrawRotatedText - invalid DC") );
+
+ if ( str.empty() )
+ return ;
+
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+
+ OSStatus status = noErr ;
+ ATSUTextLayout atsuLayout ;
+
+ wxMacUniCharBuffer unibuf( str ) ;
+ UniCharCount chars = unibuf.GetChars() ;
+
+ status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
+ &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the rotated text") );
+
+ status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
+ wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
+
+ int iAngle = int( angle );
+ int drawX = XLOG2DEVMAC(x) ;
+ int drawY = YLOG2DEVMAC(y) ;
+
+ ATSUTextMeasurement textBefore, textAfter ;
+ ATSUTextMeasurement ascent, descent ;
+
+ ATSLineLayoutOptions layoutOptions = kATSLineNoLayoutOptions ;
+
+ if (m_font.GetNoAntiAliasing())
+ {
+ layoutOptions |= kATSLineNoAntiAliasing ;
+ }
+
+ Fixed atsuAngle = IntToFixed( iAngle ) ;
+
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSULineLayoutOptionsTag ,
+ kATSULineRotationTag ,
+ } ;
+
+ ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( ATSLineLayoutOptions ) ,
+ sizeof( Fixed ) ,
+ } ;
+
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ &layoutOptions ,
+ &atsuAngle ,
+ } ;
+
+ status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag) - ( abs(iAngle) > 0.001 ? 0 : 1),
+ atsuTags, atsuSizes, atsuValues ) ;
+
+ status = ::ATSUMeasureText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ &textBefore , &textAfter, &ascent , &descent );
+ wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
+
+ if ( m_backgroundMode == wxSOLID )
+ {
+ // background painting must be done by hand, cannot be done by ATSUI
+ wxCoord x2 , y2 ;
+ PolyHandle polygon = OpenPoly();
+
+ ::MoveTo(drawX, drawY);
+
+ x2 = (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent)) ;
+ y2 = (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent)) ;
+ ::LineTo(x2, y2);
+
+ x2 = (int) (drawX + sin(angle / RAD2DEG) * FixedToInt(ascent + descent ) + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ;
+ y2 = (int) (drawY + cos(angle / RAD2DEG) * FixedToInt(ascent + descent) - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ;
+ ::LineTo(x2, y2);
+
+ x2 = (int) (drawX + cos(angle / RAD2DEG) * FixedToInt(textAfter)) ;
+ y2 = (int) (drawY - sin(angle / RAD2DEG) * FixedToInt(textAfter)) ;
+ ::LineTo(x2, y2);
+
+ ::LineTo( drawX, drawY) ;
+ ClosePoly();
+
+ ::ErasePoly( polygon );
+ KillPoly( polygon );
+ }
+
+ drawX += (int)(sin(angle / RAD2DEG) * FixedToInt(ascent));
+ drawY += (int)(cos(angle / RAD2DEG) * FixedToInt(ascent));
+ status = ::ATSUDrawText( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ IntToFixed(drawX) , IntToFixed(drawY) );
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't draw the rotated text") );
+
+ Rect rect ;
+ status = ::ATSUMeasureTextImage( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ IntToFixed(drawX) , IntToFixed(drawY) , &rect );
+ wxASSERT_MSG( status == noErr , wxT("couldn't measure the rotated text") );
+
+ OffsetRect( &rect , -m_deviceLocalOriginX , -m_deviceLocalOriginY ) ;
+ CalcBoundingBox(XDEV2LOG(rect.left), YDEV2LOG(rect.top) );
+ CalcBoundingBox(XDEV2LOG(rect.right), YDEV2LOG(rect.bottom) );
+ ::ATSUDisposeTextLayout(atsuLayout);
+}
+
+void wxDC::DoDrawText(const wxString& strtext, wxCoord x, wxCoord y)
+{
+ DoDrawRotatedText( strtext , x , y , 0) ;
+}
+
+bool wxDC::CanGetTextExtent() const
+{
+ wxCHECK_MSG(Ok(), false, wxT("wxDC::CanGetTextExtent - invalid DC"));
+
+ return true ;
+}
+
+
+void wxDC::DoGetTextExtent( const wxString &str, wxCoord *width, wxCoord *height,
+ wxCoord *descent, wxCoord *externalLeading ,
+ const wxFont *theFont ) const
+{
+ wxCHECK_RET(Ok(), wxT("wxDC::DoGetTextExtent - invalid DC"));
+
+ wxMacFastPortSetter helper(this) ;
+ wxFont formerFont = m_font ;
+ if ( theFont )
+ {
+ // work around the constness
+ *((wxFont*)(&m_font)) = *theFont ;
+ }
+
+ MacInstallFont() ;
+
+ OSStatus status = noErr ;
+ ATSUTextLayout atsuLayout ;
+
+ wxMacUniCharBuffer unibuf( str ) ;
+ UniCharCount chars = unibuf.GetChars() ;
+
+ status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
+ &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
+
+ status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
+ wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
+
+ ATSLineLayoutOptions layoutOptions = kATSLineNoLayoutOptions ;
+
+ if (m_font.GetNoAntiAliasing())
+ {
+ layoutOptions |= kATSLineNoAntiAliasing ;
+ }
+
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSULineLayoutOptionsTag ,
+ } ;
+
+ ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( ATSLineLayoutOptions ) ,
+ } ;
+
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ &layoutOptions ,
+ } ;
+
+ status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
+ atsuTags, atsuSizes, atsuValues ) ;
+
+ ATSUTextMeasurement textBefore, textAfter ;
+ ATSUTextMeasurement textAscent, textDescent ;
+
+ status = ::ATSUGetUnjustifiedBounds( atsuLayout, kATSUFromTextBeginning, kATSUToTextEnd,
+ &textBefore , &textAfter, &textAscent , &textDescent );
+
+ if ( height )
+ *height = YDEV2LOGREL( FixedToInt(textAscent + textDescent) ) ;
+ if ( descent )
+ *descent =YDEV2LOGREL( FixedToInt(textDescent) );
+ if ( externalLeading )
+ *externalLeading = 0 ;
+ if ( width )
+ *width = XDEV2LOGREL( FixedToInt(textAfter - textBefore) ) ;
+
+ ::ATSUDisposeTextLayout(atsuLayout);
+
+
+ if ( theFont )
+ {
+ // work around the constness
+ *((wxFont*)(&m_font)) = formerFont ;
+ m_macFontInstalled = false ;
+ }
+}
+
+bool wxDC::DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+{
+ wxCHECK_MSG(Ok(), false, wxT("wxDC::DoGetPartialTextExtents - invalid DC"));
+
+ widths.Empty();
+ widths.Add(0, text.length());
+
+ if (text.length() == 0)
+ return false;
+
+ wxMacFastPortSetter helper(this) ;
+ MacInstallFont() ;
+
+ OSStatus status = noErr ;
+ ATSUTextLayout atsuLayout ;
+
+ wxMacUniCharBuffer unibuf( text ) ;
+ UniCharCount chars = unibuf.GetChars() ;
+
+ status = ::ATSUCreateTextLayoutWithTextPtr( unibuf.GetBuffer() , 0 , chars , chars , 1 ,
+ &chars , (ATSUStyle*) &m_macATSUIStyle , &atsuLayout ) ;
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't create the layout of the text") );
+
+ status = ::ATSUSetTransientFontMatching( atsuLayout , true ) ;
+ wxASSERT_MSG( status == noErr , wxT("couldn't setup transient font matching") );
+
+ ATSLineLayoutOptions layoutOptions = kATSLineNoLayoutOptions ;
+
+ if (m_font.GetNoAntiAliasing())
+ {
+ layoutOptions |= kATSLineNoAntiAliasing ;
+ }
+
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSULineLayoutOptionsTag ,
+ } ;
+
+ ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( ATSLineLayoutOptions ) ,
+ } ;
+
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ &layoutOptions ,
+ } ;
+
+ status = ::ATSUSetLayoutControls(atsuLayout , sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
+ atsuTags, atsuSizes, atsuValues ) ;
+
+ for ( int pos = 0; pos < (int)chars ; pos ++ )
+ {
+ unsigned long actualNumberOfBounds = 0;
+ ATSTrapezoid glyphBounds;
+
+ // We get a single bound, since the text should only require one. If it requires more, there is an issue
+ OSStatus result;
+ result = ATSUGetGlyphBounds( atsuLayout, 0, 0, kATSUFromTextBeginning, pos + 1,
+ kATSUseDeviceOrigins, 1, &glyphBounds, &actualNumberOfBounds );
+ if (result != noErr || actualNumberOfBounds != 1 )
+ return false;
+
+ widths[pos] = XDEV2LOGREL(FixedToInt( glyphBounds.upperRight.x - glyphBounds.upperLeft.x ));
+ }
+
+ ::ATSUDisposeTextLayout(atsuLayout);
+
+ return true;
+}
+
+wxCoord wxDC::GetCharWidth(void) const
+{
+ wxCoord width = 0 ;
+ DoGetTextExtent( wxT("g"), &width , NULL , NULL , NULL , NULL ) ;
+ return width ;
+}
+
+wxCoord wxDC::GetCharHeight(void) const
+{
+ wxCoord height ;
+ DoGetTextExtent( wxT("g") , NULL , &height , NULL , NULL , NULL ) ;
+ return height ;
+}
+
+void wxDC::Clear(void)
+{
+ wxCHECK_RET(Ok(), wxT("wxDC::Clear - invalid DC"));
+
+ wxMacFastPortSetter helper(this) ;
+ Rect rect = { -31000 , -31000 , 31000 , 31000 } ;
+
+ if ( m_backgroundBrush.Ok() && m_backgroundBrush.GetStyle() != wxTRANSPARENT)
+ {
+ ::PenNormal() ;
+ MacSetupBackgroundForCurrentPort( m_backgroundBrush ) ;
+ ::EraseRect( &rect ) ;
+ }
+}
+
+void wxDC::MacInstallFont() const
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+
+ // if ( m_macFontInstalled )
+ // return ;
+
+ Pattern blackColor ;
+ MacSetupBackgroundForCurrentPort(m_backgroundBrush) ;
+ if ( m_backgroundMode != wxTRANSPARENT )
+ {
+ Pattern whiteColor ;
+ ::BackPat(GetQDGlobalsWhite(&whiteColor));
+ }
+
+ wxASSERT( m_font.Ok() ) ;
+
+ ::TextFont( m_font.MacGetFontNum() ) ;
+ ::TextSize( (short)(m_scaleY * m_font.MacGetFontSize()) ) ;
+ ::TextFace( m_font.MacGetFontStyle() ) ;
+ m_macFontInstalled = true ;
+ m_macBrushInstalled = false ;
+ m_macPenInstalled = false ;
+ RGBColor forecolor = MAC_WXCOLORREF( m_textForegroundColour.GetPixel());
+ RGBColor backcolor = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel());
+ ::RGBForeColor( &forecolor );
+ ::RGBBackColor( &backcolor );
+
+ // TODO:
+ short mode = patCopy ;
+ switch ( m_logicalFunction )
+ {
+ case wxCOPY: // src
+ mode = patCopy ;
+ break ;
+
+ case wxINVERT: // NOT dst
+ ::PenPat(GetQDGlobalsBlack(&blackColor));
+ mode = patXor ;
+ break ;
+
+ case wxXOR: // src XOR dst
+ mode = patXor ;
+ break ;
+
+ case wxOR_REVERSE: // src OR (NOT dst)
+ mode = notPatOr ;
+ break ;
+
+ case wxSRC_INVERT: // (NOT src)
+ mode = notPatCopy ;
+ break ;
+
+ case wxAND: // src AND dst
+ mode = adMin ;
+ break ;
+
+ // TODO: unsupported
+ case wxCLEAR: // 0
+ case wxAND_REVERSE:// src AND (NOT dst)
+ case wxAND_INVERT: // (NOT src) AND dst
+ case wxNO_OP: // dst
+ case wxNOR: // (NOT src) AND (NOT dst)
+ case wxEQUIV: // (NOT src) XOR dst
+ case wxOR_INVERT: // (NOT src) OR dst
+ case wxNAND: // (NOT src) OR (NOT dst)
+ case wxOR: // src OR dst
+ case wxSET: // 1
+ // case wxSRC_OR: // source _bitmap_ OR destination
+ // case wxSRC_AND: // source _bitmap_ AND destination
+ break ;
+
+ default:
+ break ;
+ }
+
+ ::PenMode( mode ) ;
+ OSStatus status = noErr ;
+ status = ATSUCreateAndCopyStyle( (ATSUStyle) m_font.MacGetATSUStyle() , (ATSUStyle*) &m_macATSUIStyle ) ;
+ wxASSERT_MSG( status == noErr , wxT("couldn't set create ATSU style") ) ;
+
+ Fixed atsuSize = IntToFixed( int(m_scaleY * m_font.MacGetFontSize()) ) ;
+ ATSUAttributeTag atsuTags[] =
+ {
+ kATSUSizeTag ,
+ } ;
+ ByteCount atsuSizes[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ sizeof( Fixed ) ,
+ } ;
+ ATSUAttributeValuePtr atsuValues[sizeof(atsuTags)/sizeof(ATSUAttributeTag)] =
+ {
+ &atsuSize ,
+ } ;
+
+ status = ::ATSUSetAttributes((ATSUStyle)m_macATSUIStyle, sizeof(atsuTags)/sizeof(ATSUAttributeTag) ,
+ atsuTags, atsuSizes, atsuValues);
+
+ wxASSERT_MSG( status == noErr , wxT("couldn't modify ATSU style") ) ;
+}
+
+Pattern gPatterns[] =
+{
+ // hatch patterns
+ { { 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF , 0xFF } } ,
+ { { 0x01 , 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , 0x40 , 0x80 } } ,
+ { { 0x80 , 0x40 , 0x20 , 0x10 , 0x08 , 0x04 , 0x02 , 0x01 } } ,
+ { { 0x10 , 0x10 , 0x10 , 0xFF , 0x10 , 0x10 , 0x10 , 0x10 } } ,
+ { { 0x00 , 0x00 , 0x00 , 0xFF , 0x00 , 0x00 , 0x00 , 0x00 } } ,
+ { { 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 , 0x10 } } ,
+ { { 0x81 , 0x42 , 0x24 , 0x18 , 0x18 , 0x24 , 0x42 , 0x81 } } ,
+
+ // dash patterns
+ { { 0xCC , 0x99 , 0x33 , 0x66 , 0xCC , 0x99 , 0x33 , 0x66 } } , // DOT
+ { { 0xFE , 0xFD , 0xFB , 0xF7 , 0xEF , 0xDF , 0xBF , 0x7F } } , // LONG_DASH
+ { { 0xEE , 0xDD , 0xBB , 0x77 , 0xEE , 0xDD , 0xBB , 0x77 } } , // SHORT_DASH
+ { { 0xDE , 0xBD , 0x7B , 0xF6 , 0xED , 0xDB , 0xB7 , 0x6F } } , // DOT_DASH
+} ;
+
+static void wxMacGetPattern(int penStyle, Pattern *pattern)
+{
+ int index = 0; // solid pattern by default
+ switch (penStyle)
+ {
+ // hatches
+ case wxBDIAGONAL_HATCH: index = 1; break;
+ case wxFDIAGONAL_HATCH: index = 2; break;
+ case wxCROSS_HATCH: index = 3; break;
+ case wxHORIZONTAL_HATCH: index = 4; break;
+ case wxVERTICAL_HATCH: index = 5; break;
+ case wxCROSSDIAG_HATCH: index = 6; break;
+
+ // dashes
+ case wxDOT: index = 7; break;
+ case wxLONG_DASH: index = 8; break;
+ case wxSHORT_DASH: index = 9; break;
+ case wxDOT_DASH: index = 10; break;
+
+ default:
+ break;
+ }
+
+ *pattern = gPatterns[index];
+}
+
+void wxDC::MacInstallPen() const
+{
+ wxCHECK_RET(Ok(), wxT("wxDC::MacInstallPen - invalid DC"));
+
+ //Pattern blackColor;
+ // if ( m_macPenInstalled )
+ // return ;
+
+ RGBColor forecolor = MAC_WXCOLORREF( m_pen.GetColour().GetPixel());
+ RGBColor backcolor = MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel());
+ ::RGBForeColor( &forecolor );
+ ::RGBBackColor( &backcolor );
+ ::PenNormal() ;
+
+ // null means only one pixel, at whatever resolution
+ int penWidth = (int) (m_pen.GetWidth() * m_scaleX) ;
+ if ( penWidth == 0 )
+ penWidth = 1 ;
+ ::PenSize(penWidth, penWidth);
+
+ Pattern pat;
+ int penStyle = m_pen.GetStyle();
+ if (penStyle == wxUSER_DASH)
+ {
+ // FIXME: there should be exactly 8 items in the dash
+ wxDash* dash ;
+ int number = m_pen.GetDashes(&dash) ;
+ int index = 0;
+ for ( int i = 0 ; i < 8 ; ++i )
+ {
+ pat.pat[i] = dash[index] ;
+ if (index < number - 1)
+ index++;
+ }
+ }
+ else
+ {
+ wxMacGetPattern(penStyle, &pat);
+ }
+ ::PenPat(&pat);
+
+ // TODO:
+ short mode = patCopy ;
+ switch ( m_logicalFunction )
+ {
+ case wxCOPY: // only foreground color, leave background (thus not patCopy)
+ mode = patOr ;
+ break ;
+
+ case wxINVERT: // NOT dst
+ // ::PenPat(GetQDGlobalsBlack(&blackColor));
+ mode = patXor ;
+ break ;
+
+ case wxXOR: // src XOR dst
+ mode = patXor ;
+ break ;
+
+ case wxOR_REVERSE: // src OR (NOT dst)
+ mode = notPatOr ;
+ break ;
+
+ case wxSRC_INVERT: // (NOT src)
+ mode = notPatCopy ;
+ break ;
+
+ case wxAND: // src AND dst
+ mode = adMin ;
+ break ;
+
+ // TODO: unsupported
+ case wxCLEAR: // 0
+ case wxAND_REVERSE:// src AND (NOT dst)
+ case wxAND_INVERT: // (NOT src) AND dst
+ case wxNO_OP: // dst
+ case wxNOR: // (NOT src) AND (NOT dst)
+ case wxEQUIV: // (NOT src) XOR dst
+ case wxOR_INVERT: // (NOT src) OR dst
+ case wxNAND: // (NOT src) OR (NOT dst)
+ case wxOR: // src OR dst
+ case wxSET: // 1
+ // case wxSRC_OR: // source _bitmap_ OR destination
+ // case wxSRC_AND: // source _bitmap_ AND destination
+ break ;
+
+ default:
+ break ;
+ }
+
+ ::PenMode( mode ) ;
+ m_macPenInstalled = true ;
+ m_macBrushInstalled = false ;
+ m_macFontInstalled = false ;
+}
+
+void wxDC::MacSetupBackgroundForCurrentPort(const wxBrush& background )
+{
+ Pattern whiteColor ;
+
+ if ( background.Ok() )
+ {
+ switch ( background.MacGetBrushKind() )
+ {
+ case kwxMacBrushTheme :
+ ::SetThemeBackground( background.MacGetTheme() , wxDisplayDepth() , true ) ;
+ break ;
+
+ case kwxMacBrushThemeBackground :
+ {
+ Rect extent ;
+ ThemeBackgroundKind bg = background.MacGetThemeBackground( &extent ) ;
+ ::ApplyThemeBackground( bg , &extent, kThemeStateActive , wxDisplayDepth() , true ) ;
+ }
+ break ;
+
+ case kwxMacBrushColour :
+ {
+ ::RGBBackColor( &MAC_WXCOLORREF( background.GetColour().GetPixel()) );
+ int brushStyle = background.GetStyle();
+ if (brushStyle == wxSOLID)
+ ::BackPat(GetQDGlobalsWhite(&whiteColor));
+ else if (background.IsHatch())
+ {
+ Pattern pat ;
+ wxMacGetPattern(brushStyle, &pat);
+ ::BackPat(&pat);
+ }
+ else
+ {
+ ::BackPat(GetQDGlobalsWhite(&whiteColor));
+ }
+ }
+ break ;
+
+ default:
+ break ;
+ }
+ }
+}
+
+void wxDC::MacInstallBrush() const
+{
+ wxCHECK_RET(Ok(), wxT("Invalid DC"));
+
+ // if ( m_macBrushInstalled )
+ // return ;
+
+ Pattern blackColor ;
+ bool backgroundTransparent = (GetBackgroundMode() == wxTRANSPARENT) ;
+ ::RGBForeColor( &MAC_WXCOLORREF( m_brush.GetColour().GetPixel()) );
+ ::RGBBackColor( &MAC_WXCOLORREF( m_backgroundBrush.GetColour().GetPixel()) );
+
+ int brushStyle = m_brush.GetStyle();
+ if (brushStyle == wxSOLID)
+ {
+ switch ( m_brush.MacGetBrushKind() )
+ {
+ case kwxMacBrushTheme :
+ {
+ Pattern whiteColor ;
+ ::BackPat(GetQDGlobalsWhite(&whiteColor));
+ ::SetThemePen( m_brush.MacGetTheme() , wxDisplayDepth() , true ) ;
+ }
+ break ;
+
+ default :
+ ::PenPat(GetQDGlobalsBlack(&blackColor));
+ break ;
+
+ }
+ }
+ else if (m_brush.IsHatch())
+ {
+ Pattern pat ;
+
+ wxMacGetPattern(brushStyle, &pat);
+ ::PenPat(&pat);
+ }
+ else if ( m_brush.GetStyle() == wxSTIPPLE || m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE )
+ {
+ // we force this in order to be compliant with wxMSW
+ backgroundTransparent = false ;
+
+ // for these the text fore (and back for MASK_OPAQUE) colors are used
+ wxBitmap* bitmap = m_brush.GetStipple() ;
+ int width = bitmap->GetWidth() ;
+ int height = bitmap->GetHeight() ;
+ GWorldPtr gw = NULL ;
+
+ if ( m_brush.GetStyle() == wxSTIPPLE )
+ gw = MAC_WXHBITMAP(bitmap->GetHBITMAP(NULL)) ;
+ else
+ gw = MAC_WXHBITMAP(bitmap->GetMask()->GetHBITMAP()) ;
+
+ PixMapHandle gwpixmaphandle = GetGWorldPixMap( gw ) ;
+ LockPixels( gwpixmaphandle ) ;
+ bool isMonochrome = !IsPortColor( gw ) ;
+ if ( !isMonochrome )
+ {
+ if ( (**gwpixmaphandle).pixelSize == 1 )
+ isMonochrome = true ;
+ }
+
+ if ( isMonochrome && width == 8 && height == 8 )
+ {
+ ::RGBForeColor( &MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) );
+ ::RGBForeColor( &MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) );
+ BitMap* gwbitmap = (BitMap*) *gwpixmaphandle ; // since the color depth is 1 it is a BitMap
+ UInt8 *gwbits = (UInt8*) gwbitmap->baseAddr ;
+ int alignment = gwbitmap->rowBytes & 0x7FFF ;
+ Pattern pat ;
+
+ for ( int i = 0 ; i < 8 ; ++i )
+ {
+ pat.pat[i] = gwbits[i * alignment + 0] ;
+ }
+
+ UnlockPixels( GetGWorldPixMap( gw ) ) ;
+ ::PenPat( &pat ) ;
+ }
+ else
+ {
+ // this will be the code to handle power of 2 patterns, we will have to arrive at a nice
+ // caching scheme before putting this into production
+ Handle image;
+ long imageSize;
+
+ PixPatHandle pixpat = NewPixPat() ;
+ CopyPixMap(gwpixmaphandle, (**pixpat).patMap);
+ imageSize = GetPixRowBytes((**pixpat).patMap) *
+ ((**(**pixpat).patMap).bounds.bottom -
+ (**(**pixpat).patMap).bounds.top);
+ PtrToHand( (**gwpixmaphandle).baseAddr, &image, imageSize );
+ (**pixpat).patData = image;
+
+ if ( isMonochrome )
+ {
+ CTabHandle ctable = ((**((**pixpat).patMap)).pmTable) ;
+ ColorSpecPtr ctspec = (ColorSpecPtr) &(**ctable).ctTable ;
+ if ( ctspec[0].rgb.red == 0x0000 )
+ {
+ ctspec[1].rgb = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) ;
+ ctspec[0].rgb = MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) ;
+ }
+ else
+ {
+ ctspec[0].rgb = MAC_WXCOLORREF( m_textBackgroundColour.GetPixel()) ;
+ ctspec[1].rgb = MAC_WXCOLORREF( m_textForegroundColour.GetPixel()) ;
+ }
+ ::CTabChanged( ctable ) ;
+ }
+
+ ::PenPixPat(pixpat);
+ m_macForegroundPixMap = pixpat ;
+ }
+
+ UnlockPixels( gwpixmaphandle ) ;
+ }
+ else
+ {
+ ::PenPat(GetQDGlobalsBlack(&blackColor));
+ }
+
+ short mode = patCopy ;
+ switch ( m_logicalFunction )
+ {
+ case wxCOPY: // src
+ if ( backgroundTransparent )
+ mode = patOr ;
+ else
+ mode = patCopy ;
+ break ;
+
+ case wxINVERT: // NOT dst
+ if ( !backgroundTransparent )
+ ::PenPat(GetQDGlobalsBlack(&blackColor));
+ mode = patXor ;
+ break ;
+
+ case wxXOR: // src XOR dst
+ mode = patXor ;
+ break ;
+
+ case wxOR_REVERSE: // src OR (NOT dst)
+ mode = notPatOr ;
+ break ;
+
+ case wxSRC_INVERT: // (NOT src)
+ mode = notPatCopy ;
+ break ;
+
+ case wxAND: // src AND dst
+ mode = adMin ;
+ break ;
+
+ // TODO: unsupported
+ case wxCLEAR: // 0
+ case wxAND_REVERSE:// src AND (NOT dst)
+ case wxAND_INVERT: // (NOT src) AND dst
+ case wxNO_OP: // dst
+ case wxNOR: // (NOT src) AND (NOT dst)
+ case wxEQUIV: // (NOT src) XOR dst
+ case wxOR_INVERT: // (NOT src) OR dst
+ case wxNAND: // (NOT src) OR (NOT dst)
+ case wxOR: // src OR dst
+ case wxSET: // 1
+ // case wxSRC_OR: // source _bitmap_ OR destination
+ // case wxSRC_AND: // source _bitmap_ AND destination
+ break ;
+
+ default:
+ break ;
+ }
+
+ ::PenMode( mode ) ;
+ m_macBrushInstalled = true ;
+ m_macPenInstalled = false ;
+ m_macFontInstalled = false ;
+}
+
+// ---------------------------------------------------------------------------
+// coordinates transformations
+// ---------------------------------------------------------------------------
+
+wxCoord wxDC::DeviceToLogicalX(wxCoord x) const
+{
+ return XDEV2LOG(x);
+}
+
+wxCoord wxDC::DeviceToLogicalY(wxCoord y) const
+{
+ return YDEV2LOG(y);
+}
+
+wxCoord wxDC::DeviceToLogicalXRel(wxCoord x) const
+{
+ return XDEV2LOGREL(x);
+}
+
+wxCoord wxDC::DeviceToLogicalYRel(wxCoord y) const
+{
+ return YDEV2LOGREL(y);
+}
+
+wxCoord wxDC::LogicalToDeviceX(wxCoord x) const
+{
+ return XLOG2DEV(x);
+}
+
+wxCoord wxDC::LogicalToDeviceY(wxCoord y) const
+{
+ return YLOG2DEV(y);
+}
+
+wxCoord wxDC::LogicalToDeviceXRel(wxCoord x) const
+{
+ return XLOG2DEVREL(x);
+}
+
+wxCoord wxDC::LogicalToDeviceYRel(wxCoord y) const
+{
+ return YLOG2DEVREL(y);
+}
+
+#endif // !wxMAC_USE_CORE_GRAPHICS
projects / wxWidgets.git / blobdiff