#include "wx/wxprec.h"
-#include "wx/menu.h"
#include "wx/window.h"
-#include "wx/dc.h"
-#include "wx/dcclient.h"
-#include "wx/utils.h"
-#include "wx/app.h"
-#include "wx/panel.h"
-#include "wx/layout.h"
-#include "wx/dialog.h"
-#include "wx/scrolbar.h"
-#include "wx/statbox.h"
-#include "wx/button.h"
-#include "wx/settings.h"
-#include "wx/msgdlg.h"
-#include "wx/frame.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/app.h"
+ #include "wx/utils.h"
+ #include "wx/panel.h"
+ #include "wx/frame.h"
+ #include "wx/dc.h"
+ #include "wx/dcclient.h"
+ #include "wx/button.h"
+ #include "wx/menu.h"
+ #include "wx/dialog.h"
+ #include "wx/settings.h"
+ #include "wx/msgdlg.h"
+ #include "wx/scrolbar.h"
+ #include "wx/statbox.h"
+ #include "wx/textctrl.h"
+ #include "wx/toolbar.h"
+ #include "wx/layout.h"
+ #include "wx/statusbr.h"
+ #include "wx/menuitem.h"
+ #include "wx/treectrl.h"
+ #include "wx/listctrl.h"
+#endif
+
#include "wx/tooltip.h"
-#include "wx/statusbr.h"
-#include "wx/menuitem.h"
#include "wx/spinctrl.h"
-#include "wx/log.h"
#include "wx/geometry.h"
-#include "wx/textctrl.h"
-#include "wx/toolbar.h"
-#include "wx/dc.h"
+#if wxUSE_LISTCTRL
+ #include "wx/listctrl.h"
+#endif
+
+#if wxUSE_TREECTRL
+ #include "wx/treectrl.h"
+#endif
#if wxUSE_CARET
#include "wx/caret.h"
#endif
+#if wxUSE_DRAG_AND_DROP
+#include "wx/dnd.h"
+#endif
+
+#include "wx/mac/uma.h"
+
#define MAC_SCROLLBAR_SIZE 15
#define MAC_SMALL_SCROLLBAR_SIZE 11
-#include "wx/mac/uma.h"
#ifndef __DARWIN__
#include <Windows.h>
#include <ToolUtils.h>
#endif
#endif
-#if wxUSE_DRAG_AND_DROP
-#include "wx/dnd.h"
-#endif
-
#include <string.h>
-extern wxList wxPendingDelete;
-
#ifdef __WXUNIVERSAL__
IMPLEMENT_ABSTRACT_CLASS(wxWindowMac, wxWindowBase)
-#else // __WXMAC__
+#else
IMPLEMENT_DYNAMIC_CLASS(wxWindow, wxWindowBase)
-#endif // __WXUNIVERSAL__/__WXMAC__
+#endif
BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
EVT_NC_PAINT(wxWindowMac::OnNcPaint)
#define wxMAC_DEBUG_REDRAW 0
#endif
-#define wxMAC_USE_THEME_BORDER 1
-
// ---------------------------------------------------------------------------
// Utility Routines to move between different coordinate systems
// ---------------------------------------------------------------------------
// Carbon Events
// ---------------------------------------------------------------------------
-extern long wxMacTranslateKey(unsigned char key, unsigned char code) ;
-pascal OSStatus wxMacSetupControlBackground( ControlRef iControl , SInt16 iMessage , SInt16 iDepth , Boolean iIsColor ) ;
-
#if TARGET_API_MAC_OSX
#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_3
-enum {
- kEventControlVisibilityChanged = 157
+enum
+{
+ kEventControlVisibilityChanged = 157
};
#endif
static const EventTypeSpec eventList[] =
{
+ { kEventClassCommand, kEventProcessCommand } ,
+ { kEventClassCommand, kEventCommandUpdateStatus } ,
+
+ { kEventClassControl , kEventControlGetClickActivation } ,
{ kEventClassControl , kEventControlHit } ,
-#if TARGET_API_MAC_OSX
+
+ { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
+ { kEventClassTextInput, kEventTextInputUpdateActiveInputArea } ,
+
{ kEventClassControl , kEventControlDraw } ,
+#if TARGET_API_MAC_OSX
{ kEventClassControl , kEventControlVisibilityChanged } ,
{ kEventClassControl , kEventControlEnabledStateChanged } ,
{ kEventClassControl , kEventControlHiliteChanged } ,
+
+ { kEventClassControl , kEventControlActivate } ,
+ { kEventClassControl , kEventControlDeactivate } ,
+#endif
{ kEventClassControl , kEventControlSetFocusPart } ,
{ kEventClassService , kEventServiceGetTypes },
{ kEventClassService , kEventServiceCopy },
{ kEventClassService , kEventServicePaste },
- // { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
-// { kEventClassControl , kEventControlBoundsChanged } ,
-#endif
+// { kEventClassControl , kEventControlInvalidateForSizeChange } , // 10.3 only
+// { kEventClassControl , kEventControlBoundsChanged } ,
} ;
static pascal OSStatus wxMacWindowControlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
- switch( GetEventKind( event ) )
+ switch ( GetEventKind( event ) )
{
#if TARGET_API_MAC_OSX
case kEventControlDraw :
RgnHandle updateRgn = NULL ;
RgnHandle allocatedRgn = NULL ;
wxRegion visRegion = thisWindow->MacGetVisibleRegion() ;
- Rect controlBounds ;
- if ( thisWindow->GetPeer()->IsCompositing() == false )
- {
- if ( thisWindow->GetPeer()->IsRootControl() == false )
- GetControlBounds( thisWindow->GetPeer()->GetControlRef() , &controlBounds ) ;
- else
- thisWindow->GetPeer()->GetRect( &controlBounds ) ;
- }
if ( cEvent.GetParameter<RgnHandle>(kEventParamRgnHandle, &updateRgn) != noErr )
{
}
else
{
- if ( thisWindow->GetPeer()->IsCompositing() == false )
+ if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
{
+ // as this update region is in native window locals we must adapt it to wx window local
allocatedRgn = NewRgn() ;
CopyRgn( updateRgn , allocatedRgn ) ;
- OffsetRgn( allocatedRgn , -controlBounds.left , -controlBounds.top ) ;
+
// hide the given region by the new region that must be shifted
wxMacNativeToWindow( thisWindow , allocatedRgn ) ;
updateRgn = allocatedRgn ;
}
- else
- {
- if ( thisWindow->MacGetLeftBorderSize() != 0 || thisWindow->MacGetTopBorderSize() != 0 )
- {
- // as this update region is in native window locals we must adapt it to wx window local
- allocatedRgn = NewRgn() ;
- CopyRgn( updateRgn , allocatedRgn ) ;
- // hide the given region by the new region that must be shifted
- wxMacNativeToWindow( thisWindow , allocatedRgn ) ;
- updateRgn = allocatedRgn ;
- }
- }
}
Rect rgnBounds ;
GetRegionBounds( updateRgn , &rgnBounds ) ;
+
#if wxMAC_DEBUG_REDRAW
if ( thisWindow->MacIsUserPane() )
{
- CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
static float color = 0.5 ;
static channel = 0 ;
- HIRect bounds;
- HIViewGetBounds( controlRef, &bounds );
+ HIRect bounds;
+ CGContextRef cgContext = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef) ;
+
+ HIViewGetBounds( controlRef, &bounds );
CGContextSetRGBFillColor( cgContext, channel == 0 ? color : 0.5 ,
channel == 1 ? color : 0.5 , channel == 2 ? color : 0.5 , 1 );
CGContextFillRect( cgContext, bounds );
}
}
#endif
+
{
#if wxMAC_USE_CORE_GRAPHICS
bool created = false ;
- CGContextRef cgContext = 0 ;
- if ( cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) != noErr )
- {
- wxASSERT( thisWindow->GetPeer()->IsCompositing() == false ) ;
-
- // this parameter is not provided on non-composited windows
- created = true ;
- // rest of the code expects this to be already transformed and clipped for local
- CGrafPtr port = GetWindowPort( (WindowRef) thisWindow->MacGetTopLevelWindowRef() ) ;
- Rect bounds ;
- GetPortBounds( port , &bounds ) ;
- CreateCGContextForPort( port , &cgContext ) ;
-
- wxMacWindowToNative( thisWindow , updateRgn ) ;
- OffsetRgn( updateRgn , controlBounds.left , controlBounds.top ) ;
- ClipCGContextToRegion( cgContext , &bounds , updateRgn ) ;
- wxMacNativeToWindow( thisWindow , updateRgn ) ;
- OffsetRgn( updateRgn , -controlBounds.left , -controlBounds.top ) ;
-
- CGContextTranslateCTM( cgContext , 0 , bounds.bottom - bounds.top ) ;
- CGContextScaleCTM( cgContext , 1 , -1 ) ;
-
- CGContextTranslateCTM( cgContext , controlBounds.left , controlBounds.top ) ;
-
-#if 0
- CGContextSetRGBFillColor( cgContext , 1.0 , 1.0 , 1.0 , 1.0 ) ;
- CGContextFillRect(cgContext , CGRectMake( 0 , 0 ,
- controlBounds.right - controlBounds.left ,
- controlBounds.bottom - controlBounds.top ) );
-#endif
-
- }
+ CGContextRef cgContext = NULL ;
+ OSStatus err = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, &cgContext) ;
+ wxASSERT_MSG( err == noErr , wxT("Unable to retrieve CGContextRef") ) ;
thisWindow->MacSetCGContextRef( cgContext ) ;
+
{
wxMacCGContextStateSaver sg( cgContext ) ;
+ float alpha = 1.0 ;
+ {
+ wxWindow* iter = thisWindow ;
+ while ( iter )
+ {
+ alpha *= (float) iter->GetTransparent()/255.0 ;
+ if ( iter->IsTopLevel() )
+ iter = NULL ;
+ else
+ iter = iter->GetParent() ;
+ }
+ }
+ CGContextSetAlpha( cgContext , alpha ) ;
#endif
if ( thisWindow->MacDoRedraw( updateRgn , cEvent.GetTicks() ) )
result = noErr ;
+
#if wxMAC_USE_CORE_GRAPHICS
thisWindow->MacSetCGContextRef( NULL ) ;
}
+
if ( created )
CGContextRelease( cgContext ) ;
#endif
case kEventControlHiliteChanged :
thisWindow->MacHiliteChanged() ;
break ;
+
+ case kEventControlActivate :
+ case kEventControlDeactivate :
+ // FIXME: we should have a virtual function for this!
+#if wxUSE_TREECTRL
+ if ( thisWindow->IsKindOf( CLASSINFO( wxTreeCtrl ) ) )
+ thisWindow->Refresh();
#endif
+#if wxUSE_LISTCTRL
+ if ( thisWindow->IsKindOf( CLASSINFO( wxListCtrl ) ) )
+ thisWindow->Refresh();
+#endif
+ break ;
+#endif // TARGET_API_MAC_OSX
// we emulate this event under Carbon CFM
case kEventControlSetFocusPart :
{
Boolean focusEverything = false ;
ControlPartCode controlPart = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode );
+
#ifdef __WXMAC_OSX__
if ( cEvent.GetParameter<Boolean>(kEventParamControlFocusEverything , &focusEverything ) == noErr )
{
}
#endif
+ if ( thisWindow->MacIsUserPane() )
+ result = noErr ;
+
if ( controlPart == kControlFocusNoPart )
{
#if wxUSE_CARET
#endif
static bool inKillFocusEvent = false ;
+
if ( !inKillFocusEvent )
{
inKillFocusEvent = true ;
event.SetEventObject(thisWindow);
thisWindow->GetEventHandler()->ProcessEvent(event) ;
}
-
- if ( thisWindow->MacIsUserPane() )
- result = noErr ;
}
break ;
result = thisWindow->MacControlHit( handler , event ) ;
break ;
+ case kEventControlGetClickActivation :
+ {
+ // fix to always have a proper activation for DataBrowser controls (stay in bkgnd otherwise)
+ WindowRef owner = cEvent.GetParameter<WindowRef>(kEventParamWindowRef);
+ if ( !IsWindowActive(owner) )
+ {
+ cEvent.SetParameter(kEventParamClickActivation,(UInt32) kActivateAndIgnoreClick) ;
+ result = noErr ;
+ }
+ }
+ break ;
+
default :
break ;
}
if ( textCtrl->IsEditable() )
pasteTypes = cEvent.GetParameter< CFMutableArrayRef >( kEventParamServicePasteTypes , typeCFMutableArrayRef ) ;
- static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt' , 'PICT', 'MooV', 'AIFF' */ };
+ static const OSType textDataTypes[] = { kTXNTextData /* , 'utxt', 'PICT', 'MooV', 'AIFF' */ };
for ( size_t i = 0 ; i < WXSIZEOF(textDataTypes) ; ++i )
{
CFStringRef typestring = CreateTypeStringWithOSType(textDataTypes[i]);
if ( typestring )
{
if ( copyTypes )
- CFArrayAppendValue (copyTypes, typestring) ;
+ CFArrayAppendValue(copyTypes, typestring) ;
if ( pasteTypes )
- CFArrayAppendValue (pasteTypes, typestring) ;
+ CFArrayAppendValue(pasteTypes, typestring) ;
CFRelease( typestring ) ;
}
{
ScrapRef scrapRef = cEvent.GetParameter< ScrapRef > ( kEventParamScrapRef , typeScrapRef ) ;
Size textSize, pastedSize ;
- verify_noerr( GetScrapFlavorSize (scrapRef, kTXNTextData, &textSize) ) ;
+ verify_noerr( GetScrapFlavorSize(scrapRef, kTXNTextData, &textSize) ) ;
textSize++ ;
char *content = new char[textSize] ;
- GetScrapFlavorData (scrapRef, kTXNTextData, &pastedSize, content );
- content[textSize-1] = 0 ;
+ GetScrapFlavorData(scrapRef, kTXNTextData, &pastedSize, content );
+ content[textSize - 1] = 0 ;
#if wxUSE_UNICODE
- textCtrl->WriteText( wxString( content , wxConvLocal ) );
+ textCtrl->WriteText( wxString( content , wxConvLocal ) );
#else
textCtrl->WriteText( wxString( content ) ) ;
#endif
return result ;
}
+pascal OSStatus wxMacUnicodeTextEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+ wxWindowMac* focus = (wxWindowMac*) data ;
+
+ wchar_t* uniChars = NULL ;
+ UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
+
+ UniChar* charBuf = NULL;
+ ByteCount dataSize = 0 ;
+ int numChars = 0 ;
+ UniChar buf[2] ;
+ if ( GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, 0 , &dataSize, NULL ) == noErr )
+ {
+ numChars = dataSize / sizeof( UniChar) + 1;
+ charBuf = buf ;
+
+ if ( (size_t) numChars * 2 > sizeof(buf) )
+ charBuf = new UniChar[ numChars ] ;
+ else
+ charBuf = buf ;
+
+ uniChars = new wchar_t[ numChars ] ;
+ GetEventParameter( event, kEventParamTextInputSendText, typeUnicodeText, NULL, dataSize , NULL , charBuf ) ;
+ charBuf[ numChars - 1 ] = 0;
+#if SIZEOF_WCHAR_T == 2
+ uniChars = (wchar_t*) charBuf ;
+/* memcpy( uniChars , charBuf , numChars * 2 ) ;*/ // is there any point in copying charBuf over itself? (in fact, memcpy isn't even guaranteed to work correctly if the source and destination ranges overlap...)
+#else
+ // the resulting string will never have more chars than the utf16 version, so this is safe
+ wxMBConvUTF16 converter ;
+ numChars = converter.MB2WC( uniChars , (const char*)charBuf , numChars ) ;
+#endif
+ }
+
+ switch ( GetEventKind( event ) )
+ {
+ case kEventTextInputUpdateActiveInputArea :
+ {
+ // An IME input event may return several characters, but we need to send one char at a time to
+ // EVT_CHAR
+ for (int pos=0 ; pos < numChars ; pos++)
+ {
+ WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
+ WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
+ wxTheApp->MacSetCurrentEvent( event , handler ) ;
+
+ UInt32 message = uniChars[pos] < 128 ? (char)uniChars[pos] : '?';
+/*
+ NB: faking a charcode here is problematic. The kEventTextInputUpdateActiveInputArea event is sent
+ multiple times to update the active range during inline input, so this handler will often receive
+ uncommited text, which should usually not trigger side effects. It might be a good idea to check the
+ kEventParamTextInputSendFixLen parameter and verify if input is being confirmed (see CarbonEvents.h).
+ On the other hand, it can be useful for some applications to react to uncommitted text (for example,
+ to update a status display), as long as it does not disrupt the inline input session. Ideally, wx
+ should add new event types to support advanced text input. For now, I would keep things as they are.
+
+ However, the code that was being used caused additional problems:
+ UInt32 message = (0 << 8) + ((char)uniChars[pos] );
+ Since it simply truncated the unichar to the last byte, it ended up causing weird bugs with inline
+ input, such as switching to another field when one attempted to insert the character U+4E09 (the kanji
+ for "three"), because it was truncated to 09 (kTabCharCode), which was later "converted" to WXK_TAB
+ (still 09) in wxMacTranslateKey; or triggering the default button when one attempted to insert U+840D
+ (the kanji for "name"), which got truncated to 0D and interpreted as a carriage return keypress.
+ Note that even single-byte characters could have been misinterpreted, since MacRoman charcodes only
+ overlap with Unicode within the (7-bit) ASCII range.
+ But simply passing a NUL charcode would disable text updated events, because wxTextCtrl::OnChar checks
+ for codes within a specific range. Therefore I went for the solution seen above, which keeps ASCII
+ characters as they are and replaces the rest with '?', ensuring that update events are triggered.
+ It would be better to change wxTextCtrl::OnChar to look at the actual unicode character instead, but
+ I don't have time to look into that right now.
+ -- CL
+*/
+ if ( wxTheApp->MacSendCharEvent(
+ focus , message , 0 , when , 0 , 0 , uniChars[pos] ) )
+ {
+ result = noErr ;
+ }
+
+ wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
+ }
+ }
+ break ;
+ case kEventTextInputUnicodeForKeyEvent :
+ {
+ UInt32 keyCode, modifiers ;
+ Point point ;
+ EventRef rawEvent ;
+ unsigned char charCode ;
+
+ GetEventParameter( event, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(rawEvent), NULL, &rawEvent ) ;
+ GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charCode );
+ GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
+ GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers );
+ GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point );
+
+ UInt32 message = (keyCode << 8) + charCode;
+
+ // An IME input event may return several characters, but we need to send one char at a time to
+ // EVT_CHAR
+ for (int pos=0 ; pos < numChars ; pos++)
+ {
+ WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
+ WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
+ wxTheApp->MacSetCurrentEvent( event , handler ) ;
+
+ if ( wxTheApp->MacSendCharEvent(
+ focus , message , modifiers , when , point.h , point.v , uniChars[pos] ) )
+ {
+ result = noErr ;
+ }
+
+ wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
+ }
+ }
+ break;
+ default:
+ break ;
+ }
+
+ delete [] uniChars ;
+ if ( charBuf != buf )
+ delete [] charBuf ;
+
+ return result ;
+}
+
+static pascal OSStatus wxMacWindowCommandEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
+{
+ OSStatus result = eventNotHandledErr ;
+ wxWindowMac* focus = (wxWindowMac*) data ;
+
+ HICommand command ;
+
+ wxMacCarbonEvent cEvent( event ) ;
+ cEvent.GetParameter<HICommand>(kEventParamDirectObject,typeHICommand,&command) ;
+
+ wxMenuItem* item = NULL ;
+ wxMenu* itemMenu = wxFindMenuFromMacCommand( command , item ) ;
+ int id = wxMacCommandToId( command.commandID ) ;
+
+ if ( item )
+ {
+ wxASSERT( itemMenu != NULL ) ;
+
+ switch ( cEvent.GetKind() )
+ {
+ case kEventProcessCommand :
+ {
+ if (item->IsCheckable())
+ item->Check( !item->IsChecked() ) ;
+
+ if ( itemMenu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) )
+ result = noErr ;
+ else
+ {
+ wxCommandEvent event(wxEVT_COMMAND_MENU_SELECTED , id);
+ event.SetEventObject(focus);
+ event.SetInt(item->IsCheckable() ? item->IsChecked() : -1);
+
+ if ( focus->GetEventHandler()->ProcessEvent(event) )
+ result = noErr ;
+ }
+ }
+ break ;
+
+ case kEventCommandUpdateStatus:
+ {
+ wxUpdateUIEvent event(id);
+ event.SetEventObject( itemMenu );
+
+ bool processed = false;
+
+ // Try the menu's event handler
+ {
+ wxEvtHandler *handler = itemMenu->GetEventHandler();
+ if ( handler )
+ processed = handler->ProcessEvent(event);
+ }
+
+ // Try the window the menu was popped up from
+ // (and up through the hierarchy)
+ if ( !processed )
+ {
+ const wxMenuBase *menu = itemMenu;
+ while ( menu )
+ {
+ wxWindow *win = menu->GetInvokingWindow();
+ if ( win )
+ {
+ processed = win->GetEventHandler()->ProcessEvent(event);
+ break;
+ }
+
+ menu = menu->GetParent();
+ }
+ }
+
+ if ( !processed )
+ {
+ processed = focus->GetEventHandler()->ProcessEvent(event);
+ }
+
+ if ( processed )
+ {
+ // if anything changed, update the changed attribute
+ if (event.GetSetText())
+ itemMenu->SetLabel(id, event.GetText());
+ if (event.GetSetChecked())
+ itemMenu->Check(id, event.GetChecked());
+ if (event.GetSetEnabled())
+ itemMenu->Enable(id, event.GetEnabled());
+
+ result = noErr ;
+ }
+ }
+ break ;
+
+ default :
+ break ;
+ }
+ }
+ return result ;
+}
+
pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
{
EventRef formerEvent = (EventRef) wxTheApp->MacGetCurrentEvent() ;
switch ( GetEventClass( event ) )
{
+ case kEventClassCommand :
+ result = wxMacWindowCommandEventHandler( handler , event , data ) ;
+ break ;
+
case kEventClassControl :
result = wxMacWindowControlEventHandler( handler, event, data ) ;
break ;
result = wxMacWindowServiceEventHandler( handler, event , data ) ;
break ;
+ case kEventClassTextInput :
+ result = wxMacUnicodeTextEventHandler( handler , event , data ) ;
+ break ;
+
default :
break ;
}
int x = 0 , y = 0;
RgnHandle rgn = NewRgn() ;
GetClip( rgn ) ;
- MacWindowToRootWindow( &x,&y ) ;
+ MacWindowToRootWindow( &x, &y ) ;
OffsetRgn( rgn , -x , -y ) ;
wxMacWindowStateSaver sv( this ) ;
SectRgn( rgn , (RgnHandle) MacGetVisibleRegion().GetWXHRGN() , rgn ) ;
{
m_peer = NULL ;
m_frozenness = 0 ;
-#if WXWIN_COMPATIBILITY_2_4
- m_backgroundTransparent = false;
-#endif
+ m_macAlpha = 255 ;
#if wxMAC_USE_CORE_GRAPHICS
m_cgContextRef = NULL ;
wxWindowBase::SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
}
-// Destructor
wxWindowMac::~wxWindowMac()
{
SendDestroyEvent();
break;
}
}
-#endif // __WXUNIVERSAL__
+#endif
// destroy children before destroying this window itself
DestroyChildren();
// wxRemoveMacControlAssociation( this ) ;
// If we delete an item, we should initialize the parent panel,
// because it could now be invalid.
- wxWindow *parent = GetParent() ;
- if ( parent )
+ wxTopLevelWindow *tlw = wxDynamicCast(wxGetTopLevelParent(this), wxTopLevelWindow);
+ if ( tlw )
{
- if (parent->GetDefaultItem() == (wxButton*) this)
- parent->SetDefaultItem(NULL);
+ if ( tlw->GetDefaultItem() == (wxButton*) this)
+ tlw->SetDefaultItem(NULL);
}
if ( m_peer && m_peer->Ok() )
return (WXWidget) m_peer->GetControlRef() ;
}
-
void wxWindowMac::MacInstallEventHandler( WXWidget control )
{
- wxAssociateControlWithMacControl( (ControlRef) control , this ) ;
- InstallControlEventHandler( (ControlRef) control , GetwxMacWindowEventHandlerUPP(),
+ wxAssociateControlWithMacControl( (ControlRef) control , this ) ;
+ InstallControlEventHandler( (ControlRef)control , GetwxMacWindowEventHandlerUPP(),
GetEventTypeCount(eventList), eventList, this,
(EventHandlerRef *)&m_macControlEventHandler);
#if !TARGET_API_MAC_OSX
if ( (ControlRef) control == m_peer->GetControlRef() )
{
- m_peer->SetData<ControlUserPaneDrawUPP>(kControlEntireControl,kControlUserPaneDrawProcTag,GetwxMacControlUserPaneDrawProc()) ;
- m_peer->SetData<ControlUserPaneHitTestUPP>(kControlEntireControl,kControlUserPaneHitTestProcTag,GetwxMacControlUserPaneHitTestProc()) ;
- m_peer->SetData<ControlUserPaneTrackingUPP>(kControlEntireControl,kControlUserPaneTrackingProcTag,GetwxMacControlUserPaneTrackingProc()) ;
- m_peer->SetData<ControlUserPaneIdleUPP>(kControlEntireControl,kControlUserPaneIdleProcTag,GetwxMacControlUserPaneIdleProc()) ;
- m_peer->SetData<ControlUserPaneKeyDownUPP>(kControlEntireControl,kControlUserPaneKeyDownProcTag,GetwxMacControlUserPaneKeyDownProc()) ;
- m_peer->SetData<ControlUserPaneActivateUPP>(kControlEntireControl,kControlUserPaneActivateProcTag,GetwxMacControlUserPaneActivateProc()) ;
- m_peer->SetData<ControlUserPaneFocusUPP>(kControlEntireControl,kControlUserPaneFocusProcTag,GetwxMacControlUserPaneFocusProc()) ;
- m_peer->SetData<ControlUserPaneBackgroundUPP>(kControlEntireControl,kControlUserPaneBackgroundProcTag,GetwxMacControlUserPaneBackgroundProc()) ;
+ m_peer->SetData<ControlUserPaneDrawUPP>(kControlEntireControl, kControlUserPaneDrawProcTag, GetwxMacControlUserPaneDrawProc()) ;
+ m_peer->SetData<ControlUserPaneHitTestUPP>(kControlEntireControl, kControlUserPaneHitTestProcTag, GetwxMacControlUserPaneHitTestProc()) ;
+ m_peer->SetData<ControlUserPaneTrackingUPP>(kControlEntireControl, kControlUserPaneTrackingProcTag, GetwxMacControlUserPaneTrackingProc()) ;
+ m_peer->SetData<ControlUserPaneIdleUPP>(kControlEntireControl, kControlUserPaneIdleProcTag, GetwxMacControlUserPaneIdleProc()) ;
+ m_peer->SetData<ControlUserPaneKeyDownUPP>(kControlEntireControl, kControlUserPaneKeyDownProcTag, GetwxMacControlUserPaneKeyDownProc()) ;
+ m_peer->SetData<ControlUserPaneActivateUPP>(kControlEntireControl, kControlUserPaneActivateProcTag, GetwxMacControlUserPaneActivateProc()) ;
+ m_peer->SetData<ControlUserPaneFocusUPP>(kControlEntireControl, kControlUserPaneFocusProcTag, GetwxMacControlUserPaneFocusProc()) ;
+ m_peer->SetData<ControlUserPaneBackgroundUPP>(kControlEntireControl, kControlUserPaneBackgroundProcTag, GetwxMacControlUserPaneBackgroundProc()) ;
}
#endif
}
// Constructor
-bool wxWindowMac::Create(wxWindowMac *parent, wxWindowID id,
- const wxPoint& pos,
- const wxSize& size,
- long style,
- const wxString& name)
+bool wxWindowMac::Create(wxWindowMac *parent,
+ wxWindowID id,
+ const wxPoint& pos,
+ const wxSize& size,
+ long style,
+ const wxString& name)
{
wxCHECK_MSG( parent, false, wxT("can't create wxWindowMac without parent") );
| kControlHandlesTracking
| kControlSupportsFocus
| kControlWantsActivate
- | kControlWantsIdle
- ;
+ | kControlWantsIdle ;
m_peer = new wxMacControl(this) ;
- ::CreateUserPaneControl( MAC_WXHWND(GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , m_peer->GetControlRefAddr() );
-
+ OSStatus err =::CreateUserPaneControl( MAC_WXHWND(GetParent()->MacGetTopLevelWindowRef()) , &bounds, features , m_peer->GetControlRefAddr() );
+ verify_noerr( err );
- MacPostControlCreate(pos,size) ;
+ MacPostControlCreate(pos, size) ;
}
+
#ifndef __WXUNIVERSAL__
// Don't give scrollbars to wxControls unless they ask for them
- if ( (! IsKindOf(CLASSINFO(wxControl)) && ! IsKindOf(CLASSINFO(wxStatusBar))) ||
- (IsKindOf(CLASSINFO(wxControl)) && ( style & wxHSCROLL || style & wxVSCROLL)))
+ if ( (! IsKindOf(CLASSINFO(wxControl)) && ! IsKindOf(CLASSINFO(wxStatusBar)))
+ || (IsKindOf(CLASSINFO(wxControl)) && ((style & wxHSCROLL) || (style & wxVSCROLL))))
{
MacCreateScrollBars( style ) ;
}
{
wxASSERT_MSG( m_peer != NULL && m_peer->Ok() , wxT("No valid mac control") ) ;
- m_peer->SetReference( (long) this ) ;
- GetParent()->AddChild(this);
+ m_peer->SetReference( (URefCon) this ) ;
+ GetParent()->AddChild( this );
MacInstallEventHandler( (WXWidget) m_peer->GetControlRef() );
// adjust font, controlsize etc
DoSetWindowVariant( m_windowVariant ) ;
- m_peer->SetLabel( wxStripMenuCodes(m_label) ) ;
+ m_peer->SetLabel( wxStripMenuCodes(m_label, wxStrip_Mnemonics) ) ;
if (!m_macIsUserPane)
- SetInitialBestSize(size);
+ SetInitialSize(size);
SetCursor( *wxSTANDARD_CURSOR ) ;
}
break ;
}
- m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag,&size ) ;
+ m_peer->SetData<ControlSize>(kControlEntireControl, kControlSizeTag, &size ) ;
wxFont font ;
font.MacCreateThemeFont( themeFont ) ;
bool wxWindowMac::SetFont(const wxFont& font)
{
- bool retval = wxWindowBase::SetFont( font ) ;
+ bool retval = wxWindowBase::SetFont( font );
MacUpdateControlFont() ;
bool wxWindowMac::SetForegroundColour(const wxColour& col )
{
- if ( !wxWindowBase::SetForegroundColour(col) )
- return false ;
+ bool retval = wxWindowBase::SetForegroundColour( col );
- MacUpdateControlFont() ;
+ if (retval)
+ MacUpdateControlFont();
- return true ;
+ return retval;
}
bool wxWindowMac::SetBackgroundColour(const wxColour& col )
wxBrush brush ;
wxColour newCol(GetBackgroundColour());
- if ( newCol == wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE) )
+
+ if ( newCol == wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOW ) )
brush.MacSetTheme( kThemeBrushDocumentWindowBackground ) ;
- else if ( newCol == wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE ) )
+ else if ( newCol == wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) )
brush.MacSetTheme( kThemeBrushDialogBackgroundActive ) ;
else
brush.SetColour( newCol ) ;
MacSetBackgroundBrush( brush ) ;
-
MacUpdateControlFont() ;
return true ;
bool wxWindowMac::MacCanFocus() const
{
- // there is currently no way to determine whether the window is running in full keyboard
- // access mode, therefore we cannot rely on these features, yet the only other way would be
- // to issue a SetKeyboardFocus event and verify after whether it succeeded, this would risk problems
- // in event handlers...
- UInt32 features = 0 ;
- m_peer->GetFeatures( & features ) ;
+ // TODO : evaluate performance hits by looking up this value, eventually cache the results for a 1 sec or so
+ // CAUTION : the value returned currently is 0 or 2, I've also found values of 1 having the same meaning,
+ // but the value range is nowhere documented
+ Boolean keyExistsAndHasValidFormat ;
+ CFIndex fullKeyboardAccess = CFPreferencesGetAppIntegerValue( CFSTR("AppleKeyboardUIMode" ) ,
+ kCFPreferencesCurrentApplication, &keyExistsAndHasValidFormat );
- return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
+ if ( keyExistsAndHasValidFormat && fullKeyboardAccess > 0 )
+ {
+ return true ;
+ }
+ else
+ {
+ UInt32 features = 0 ;
+ m_peer->GetFeatures( &features ) ;
+
+ return features & ( kControlSupportsFocus | kControlGetsFocusOnClick ) ;
+ }
}
void wxWindowMac::SetFocus()
if ( err == errCouldntSetFocus )
return ;
- // enable for patch 1376506 - perhaps? (Stefan's version)
-#if 0
SetUserFocusWindow( (WindowRef)MacGetTopLevelWindowRef() );
-#endif
#if !TARGET_API_MAC_OSX
// emulate carbon events when running under CarbonLib where they are not natively available
if ( former )
{
EventRef evRef = NULL ;
- verify_noerr( MacCreateEvent( NULL , kEventClassControl , kEventControlSetFocusPart , TicksToEventTime( TickCount() ) , kEventAttributeUserEvent ,
- &evRef ) );
+
+ err = MacCreateEvent(
+ NULL , kEventClassControl , kEventControlSetFocusPart , TicksToEventTime( TickCount() ) ,
+ kEventAttributeUserEvent , &evRef );
+ verify_noerr( err );
wxMacCarbonEvent cEvent( evRef ) ;
cEvent.SetParameter<ControlRef>( kEventParamDirectObject , (ControlRef) former->GetHandle() ) ;
cEvent.SetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode , kControlFocusNoPart ) ;
wxMacWindowEventHandler( NULL , evRef , former ) ;
- ReleaseEvent(evRef) ;
+ ReleaseEvent( evRef ) ;
}
// send new focus event
{
EventRef evRef = NULL ;
- verify_noerr( MacCreateEvent( NULL , kEventClassControl , kEventControlSetFocusPart , TicksToEventTime( TickCount() ) , kEventAttributeUserEvent ,
- &evRef ) );
+
+ err = MacCreateEvent(
+ NULL , kEventClassControl , kEventControlSetFocusPart , TicksToEventTime( TickCount() ) ,
+ kEventAttributeUserEvent , &evRef );
+ verify_noerr( err );
wxMacCarbonEvent cEvent( evRef ) ;
cEvent.SetParameter<ControlRef>( kEventParamDirectObject , (ControlRef) GetHandle() ) ;
cEvent.SetParameter<ControlPartCode>(kEventParamControlPart , typeControlPartCode , kControlFocusNextPart ) ;
wxMacWindowEventHandler( NULL , evRef , this ) ;
- ReleaseEvent(evRef) ;
+ ReleaseEvent( evRef ) ;
}
#endif
}
wxApp::s_captureWindow = this ;
}
-wxWindow* wxWindowBase::GetCapture()
+wxWindow * wxWindowBase::GetCapture()
{
return wxApp::s_captureWindow ;
}
m_dropTarget = pDropTarget;
if ( m_dropTarget != NULL )
{
- // TODO
+ // TODO:
}
}
#endif
-// Old style file-manager drag&drop
+// Old-style File Manager Drag & Drop
void wxWindowMac::DragAcceptFiles(bool accept)
{
- // TODO
+ // TODO:
}
// Returns the size of the native control. In the case of the toplevel window
void wxWindowMac::MacGetPositionAndSizeFromControl(int& x, int& y,
int& w, int& h) const
{
- wxFAIL_MSG( wxT("Not supported anymore") ) ;
+ wxFAIL_MSG( wxT("Not currently supported") ) ;
}
// From a wx position / size calculate the appropriate size of the native control
-bool wxWindowMac::MacGetBoundsForControl(const wxPoint& pos,
- const wxSize& size,
- int& x, int& y,
- int& w, int& h , bool adjustOrigin ) const
+bool wxWindowMac::MacGetBoundsForControl(
+ const wxPoint& pos,
+ const wxSize& size,
+ int& x, int& y,
+ int& w, int& h , bool adjustOrigin ) const
{
- bool isCompositing = MacGetTopLevelWindow()->MacUsesCompositing() ;
-
// the desired size, minus the border pixels gives the correct size of the control
-
x = (int)pos.x;
y = (int)pos.y;
- // todo the default calls may be used as soon as PostCreateControl Is moved here
- w = wxMax(size.x,0) ; // WidthDefault( size.x );
- h = wxMax(size.y,0) ; // HeightDefault( size.y ) ;
- if ( !isCompositing )
- GetParent()->MacWindowToRootWindow( &x , &y ) ;
+ // TODO: the default calls may be used as soon as PostCreateControl Is moved here
+ w = wxMax(size.x, 0) ; // WidthDefault( size.x );
+ h = wxMax(size.y, 0) ; // HeightDefault( size.y ) ;
x += MacGetLeftBorderSize() ;
y += MacGetTopBorderSize() ;
void wxWindowMac::DoScreenToClient(int *x, int *y) const
{
WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
+ wxCHECK_RET( window , wxT("TopLevel Window missing") ) ;
- wxCHECK_RET( window , wxT("TopLevel Window Missing") ) ;
+ Point localwhere = { 0, 0 } ;
- {
- Point localwhere = {0, 0} ;
-
- if (x)
- localwhere.h = *x ;
- if (y)
- localwhere.v = *y ;
+ if (x)
+ localwhere.h = *x ;
+ if (y)
+ localwhere.v = *y ;
- QDGlobalToLocalPoint( GetWindowPort( window ) , &localwhere ) ;
+ wxMacGlobalToLocal( window , &localwhere ) ;
- if (x)
- *x = localwhere.h ;
- if (y)
- *y = localwhere.v ;
- }
+ if (x)
+ *x = localwhere.h ;
+ if (y)
+ *y = localwhere.v ;
MacRootWindowToWindow( x , y ) ;
void wxWindowMac::DoClientToScreen(int *x, int *y) const
{
WindowRef window = (WindowRef) MacGetTopLevelWindowRef() ;
- wxCHECK_RET( window , wxT("TopLevel Window Missing") ) ;
+ wxCHECK_RET( window , wxT("TopLevel window missing") ) ;
wxPoint origin = GetClientAreaOrigin() ;
if (x)
MacWindowToRootWindow( x , y ) ;
- {
- Point localwhere = { 0,0 };
- if (x)
- localwhere.h = * x ;
- if (y)
- localwhere.v = * y ;
+ Point localwhere = { 0, 0 };
+ if (x)
+ localwhere.h = *x ;
+ if (y)
+ localwhere.v = *y ;
- QDLocalToGlobalPoint( GetWindowPort( window ) , &localwhere ) ;
+ wxMacLocalToGlobal( window, &localwhere ) ;
- if (x)
- *x = localwhere.h ;
- if (y)
- *y = localwhere.v ;
- }
+ if (x)
+ *x = localwhere.h ;
+ if (y)
+ *y = localwhere.v ;
}
void wxWindowMac::MacClientToRootWindow( int *x , int *y ) const
void wxWindowMac::MacWindowToRootWindow( int *x , int *y ) const
{
wxPoint pt ;
+
if (x)
pt.x = *x ;
if (y)
void wxWindowMac::MacGetContentAreaInset( int &left , int &top , int &right , int &bottom )
{
RgnHandle rgn = NewRgn() ;
+
if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
{
- Rect structure ;
- Rect content ;
+ Rect structure, content ;
+
GetRegionBounds( rgn , &content ) ;
m_peer->GetRect( &structure ) ;
OffsetRect( &structure, -structure.left , -structure.top ) ;
left = content.left - structure.left ;
- top = content.top - structure.top ;
+ top = content.top - structure.top ;
right = structure.right - content.right ;
bottom = structure.bottom - content.bottom ;
}
{
left = top = right = bottom = 0 ;
}
+
DisposeRgn( rgn ) ;
}
RgnHandle rgn = NewRgn() ;
if ( m_peer->GetRegion( kControlContentMetaPart , rgn ) == noErr )
{
- Rect content ;
- Rect structure ;
+ Rect content, structure ;
GetRegionBounds( rgn , &content ) ;
-
m_peer->GetRect( &structure ) ;
+
// structure is in parent coordinates, but we only need width and height, so it's ok
sizeTotal.x += (structure.right - structure.left) - (content.right - content.left) ;
- sizeTotal.y += (structure.bottom - structure.top) - (content.bottom - content.top ) ;
+ sizeTotal.y += (structure.bottom - structure.top) - (content.bottom - content.top) ;
}
+
DisposeRgn( rgn ) ;
sizeTotal.x += MacGetLeftBorderSize() + MacGetRightBorderSize() ;
*x = ww;
if (y)
*y = hh;
-
}
bool wxWindowMac::SetCursor(const wxCursor& cursor)
{
- if (m_cursor == cursor)
+ if (m_cursor.IsSameAs(cursor))
return false;
- if (wxNullCursor == cursor)
+ if (!cursor.IsOk())
{
if ( ! wxWindowBase::SetCursor( *wxSTANDARD_CURSOR ) )
return false ;
{
wxTopLevelWindowMac *tlw = MacGetTopLevelWindow() ;
WindowRef window = (WindowRef) ( tlw ? tlw->MacGetWindowRef() : 0 ) ;
+
+ ControlPartCode part ;
+ ControlRef control ;
+ Point pt ;
+ #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
+ HIPoint hiPoint ;
+ HIGetMousePosition(kHICoordSpaceWindow, window, &hiPoint);
+ pt.h = hiPoint.x;
+ pt.v = hiPoint.y;
+ #else
CGrafPtr savePort ;
Boolean swapped = QDSwapPort( GetWindowPort( window ) , &savePort ) ;
- // TODO If we ever get a GetCurrentEvent.. replacement for the mouse
- // position, use it...
+ // TODO: If we ever get a GetCurrentEvent... replacement
+ // for the mouse position, use it...
+
- Point pt ;
GetMouse( &pt ) ;
- ControlPartCode part ;
- ControlRef control ;
+#endif
control = wxMacFindControlUnderMouse( tlw , pt , window , &part ) ;
if ( control )
mouseWin = wxFindControlFromMacControl( control ) ;
- if ( swapped )
+#if MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5
+ if ( swapped )
QDSwapPort( savePort , NULL ) ;
+#endif
}
if ( mouseWin == this && !wxIsBusy() )
menu->SetInvokingWindow(this);
menu->UpdateUI();
- if ( x == -1 && y == -1 )
+ if ( x == wxDefaultCoord && y == wxDefaultCoord )
{
wxPoint mouse = wxGetMousePosition();
- x = mouse.x; y = mouse.y;
+ x = mouse.x;
+ y = mouse.y;
}
else
{
}
menu->MacBeforeDisplay( true ) ;
- long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() ,y,x, 0) ;
+ long menuResult = ::PopUpMenuSelect((MenuHandle) menu->GetHMenu() , y, x, 0) ;
if ( HiWord(menuResult) != 0 )
{
- MenuCommand id ;
- GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &id ) ;
+ MenuCommand macid;
+ GetMenuItemCommandID( GetMenuHandle(HiWord(menuResult)) , LoWord(menuResult) , &macid );
+ int id = wxMacCommandToId( macid );
wxMenuItem* item = NULL ;
wxMenu* realmenu ;
- item = menu->FindItem(id, &realmenu) ;
- if (item->IsCheckable())
- item->Check( !item->IsChecked() ) ;
+ item = menu->FindItem( id, &realmenu ) ;
+ if ( item )
+ {
+ if (item->IsCheckable())
+ item->Check( !item->IsChecked() ) ;
- menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+ menu->SendEvent( id , item->IsCheckable() ? item->IsChecked() : -1 ) ;
+ }
}
- menu->MacAfterDisplay( true ) ;
- menu->SetInvokingWindow(NULL);
+ menu->MacAfterDisplay( true ) ;
+ menu->SetInvokingWindow( NULL );
return true;
}
m_tooltip->SetWindow(this);
}
-#endif // wxUSE_TOOLTIPS
+#endif
void wxWindowMac::MacInvalidateBorders()
{
// now we know that we have something to do at all
// as the borders are drawn on the parent we have to properly invalidate all these areas
- RgnHandle updateInner = NewRgn() ,
- updateOuter = NewRgn() ;
+ RgnHandle updateInner , updateOuter;
+ Rect rect ;
// this rectangle is in HIViewCoordinates under OSX and in Window Coordinates under Carbon
- Rect rect ;
+ updateInner = NewRgn() ;
+ updateOuter = NewRgn() ;
+
m_peer->GetRect( &rect ) ;
- RectRgn( updateInner , &rect ) ;
+ RectRgn( updateInner, &rect ) ;
InsetRect( &rect , -outerBorder , -outerBorder ) ;
- RectRgn( updateOuter , &rect ) ;
- DiffRgn( updateOuter , updateInner ,updateOuter ) ;
+ RectRgn( updateOuter, &rect ) ;
+ DiffRgn( updateOuter, updateInner , updateOuter ) ;
#ifdef __WXMAC_OSX__
GetParent()->m_peer->SetNeedsDisplay( updateOuter ) ;
InvalWindowRgn( tlw , updateOuter ) ;
#endif
- DisposeRgn(updateOuter) ;
- DisposeRgn(updateInner) ;
-
-#if 0
- RgnHandle updateInner = NewRgn() , updateOuter = NewRgn() ;
- RectRgn( updateInner , &rect ) ;
- InsetRect( &rect , -4 , -4 ) ;
- RectRgn( updateOuter , &rect ) ;
- DiffRgn( updateOuter , updateInner ,updateOuter ) ;
- wxPoint parent(0,0);
- GetParent()->MacWindowToRootWindow( &parent.x , &parent.y ) ;
- parent -= GetParent()->GetClientAreaOrigin() ;
- OffsetRgn( updateOuter , -parent.x , -parent.y ) ;
- GetParent()->m_peer->SetNeedsDisplay( true , updateOuter ) ;
- DisposeRgn(updateOuter) ;
- DisposeRgn(updateInner) ;
-#endif
-
-#if 0
- if ( m_peer )
- {
- // deleting a window while it is shown invalidates the region occupied by border or
- // focus
-
- if ( IsShown() && ( outerBorder > 0 ) )
- {
- // as the borders are drawn on the parent we have to properly invalidate all these areas
- RgnHandle updateInner = NewRgn() , updateOuter = NewRgn() , updateTotal = NewRgn() ;
-
- Rect rect ;
-
- m_peer->GetRect( &rect ) ;
- RectRgn( updateInner , &rect ) ;
- InsetRect( &rect , -outerBorder , -outerBorder ) ;
- RectRgn( updateOuter , &rect ) ;
- DiffRgn( updateOuter , updateInner ,updateOuter ) ;
- wxPoint parent(0,0);
- GetParent()->MacWindowToRootWindow( &parent.x , &parent.y ) ;
- parent -= GetParent()->GetClientAreaOrigin() ;
- OffsetRgn( updateOuter , -parent.x , -parent.y ) ;
- CopyRgn( updateOuter , updateTotal ) ;
-
- GetParent()->m_peer->SetNeedsDisplay( true , updateTotal ) ;
- DisposeRgn(updateOuter) ;
- DisposeRgn(updateInner) ;
- DisposeRgn(updateTotal) ;
- }
- }
-#endif
-
-#if 0
- Rect r = wxMacGetBoundsForControl(this , wxPoint( actualX,actualY), wxSize( actualWidth, actualHeight ) , false ) ;
-
- int outerBorder = MacGetLeftBorderSize() ;
- if ( m_peer->NeedsFocusRect() && m_peer->HasFocus() )
- outerBorder += 4 ;
-
- if ( vis && ( outerBorder > 0 ) )
- {
- // as the borders are drawn on the parent we have to properly invalidate all these areas
- RgnHandle updateInner = NewRgn() , updateOuter = NewRgn() , updateTotal = NewRgn() ;
-
- Rect rect ;
-
- m_peer->GetRect( &rect ) ;
- RectRgn( updateInner , &rect ) ;
- InsetRect( &rect , -outerBorder , -outerBorder ) ;
- RectRgn( updateOuter , &rect ) ;
- DiffRgn( updateOuter , updateInner ,updateOuter ) ;
- /*
- wxPoint parent(0,0);
-#if TARGET_API_MAC_OSX
- // no offsetting needed when compositing
-#else
- GetParent()->MacWindowToRootWindow( &parent.x , &parent.y ) ;
- parent -= GetParent()->GetClientAreaOrigin() ;
- OffsetRgn( updateOuter , -parent.x , -parent.y ) ;
-#endif
- */
- CopyRgn( updateOuter , updateTotal ) ;
-
- rect = r ;
- RectRgn( updateInner , &rect ) ;
- InsetRect( &rect , -outerBorder , -outerBorder ) ;
- RectRgn( updateOuter , &rect ) ;
- DiffRgn( updateOuter , updateInner ,updateOuter ) ;
-/*
- OffsetRgn( updateOuter , -parent.x , -parent.y ) ;
-*/
- UnionRgn( updateOuter , updateTotal , updateTotal ) ;
-
- GetParent()->m_peer->SetNeedsDisplay( updateTotal ) ;
- DisposeRgn(updateOuter) ;
- DisposeRgn(updateInner) ;
- DisposeRgn(updateTotal) ;
- }
-#endif
+ DisposeRgn( updateOuter ) ;
+ DisposeRgn( updateInner ) ;
}
void wxWindowMac::DoMoveWindow(int x, int y, int width, int height)
if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
actualHeight = m_maxHeight;
- bool doMove = false ;
- bool doResize = false ;
+ bool doMove = false, doResize = false ;
if ( actualX != former_x || actualY != former_y )
doMove = true ;
MacRepositionScrollBars() ;
if ( doMove )
{
- wxPoint point(actualX,actualY);
+ wxPoint point(actualX, actualY);
wxMoveEvent event(point, m_windowId);
event.SetEventObject(this);
GetEventHandler()->ProcessEvent(event) ;
Rect bestsize = { 0 , 0 , 0 , 0 } ;
int bestWidth, bestHeight ;
- m_peer->GetBestRect( &bestsize ) ;
+ m_peer->GetBestRect( &bestsize ) ;
if ( EmptyRect( &bestsize ) )
{
- bestsize.left = bestsize.top = 0 ;
- bestsize.right = 16 ;
+ bestsize.left =
+ bestsize.top = 0 ;
+ bestsize.right =
bestsize.bottom = 16 ;
+
if ( IsKindOf( CLASSINFO( wxScrollBar ) ) )
{
bestsize.bottom = 16 ;
{
bestsize.bottom = 24 ;
}
-#endif // wxUSE_SPINBTN
+#endif
else
{
// return wxWindowBase::DoGetBestSize() ;
{
// get the current size and position...
int currentX, currentY;
- GetPosition(¤tX, ¤tY);
+ int currentW, currentH;
- int currentW,currentH;
+ GetPosition(¤tX, ¤tY);
GetSize(¤tW, ¤tH);
// ... and don't do anything (avoiding flicker) if it's already ok
{
// TODO: REMOVE
MacRepositionScrollBars() ; // we might have a real position shift
+
return;
}
- if ( x == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
- x = currentX;
- if ( y == wxDefaultCoord && !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
- y = currentY;
+ if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
+ {
+ if ( x == wxDefaultCoord )
+ x = currentX;
+ if ( y == wxDefaultCoord )
+ y = currentY;
+ }
- AdjustForParentClientOrigin(x, y, sizeFlags);
+ AdjustForParentClientOrigin( x, y, sizeFlags );
wxSize size = wxDefaultSize;
if ( width == wxDefaultCoord )
if ( sizeFlags & wxSIZE_AUTO_HEIGHT )
{
if ( size.x == wxDefaultCoord )
- {
size = DoGetBestSize();
- }
- //else: already called DoGetBestSize() above
+ // else: already called DoGetBestSize() above
height = size.y;
}
}
}
- DoMoveWindow(x, y, width, height);
+ DoMoveWindow( x, y, width, height );
}
wxPoint wxWindowMac::GetClientAreaOrigin() const
}
else
{
- content.left = content.top = 0 ;
+ content.left =
+ content.top = 0 ;
}
+
DisposeRgn( rgn ) ;
return wxPoint( content.left + MacGetLeftBorderSize() , content.top + MacGetTopBorderSize() );
void wxWindowMac::DoSetClientSize(int clientwidth, int clientheight)
{
- if ( clientheight != wxDefaultCoord || clientheight != wxDefaultCoord )
+ if ( clientwidth != wxDefaultCoord || clientheight != wxDefaultCoord )
{
int currentclientwidth , currentclientheight ;
int currentwidth , currentheight ;
void wxWindowMac::SetLabel(const wxString& title)
{
- m_label = wxStripMenuCodes(title) ;
+ m_label = wxStripMenuCodes(title, wxStrip_Mnemonics) ;
if ( m_peer && m_peer->Ok() )
m_peer->SetLabel( m_label ) ;
if ( !wxWindowBase::Show(show) )
return false;
- // TODO use visibilityChanged Carbon Event for OSX
+ // TODO: use visibilityChanged Carbon Event for OSX
if ( m_peer )
m_peer->SetVisibility( show , true ) ;
if ( former != MacIsReallyShown() )
MacPropagateVisibilityChanged() ;
+
return true;
}
-bool wxWindowMac::Enable(bool enable)
+void wxWindowMac::DoEnable(bool enable)
{
- wxASSERT( m_peer->Ok() ) ;
- bool former = MacIsReallyEnabled() ;
- if ( !wxWindowBase::Enable(enable) )
- return false;
-
m_peer->Enable( enable ) ;
-
- if ( former != MacIsReallyEnabled() )
- MacPropagateEnabledStateChanged() ;
-
- return true;
}
//
#endif
}
-void wxWindowMac::MacPropagateEnabledStateChanged()
+void wxWindowMac::OnEnabled(bool enabled)
{
#if !TARGET_API_MAC_OSX
MacEnabledStateChanged() ;
-
- wxWindowMac *child;
- wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
- while ( node )
- {
- child = node->GetData();
- if ( child->IsEnabled() )
- child->MacPropagateEnabledStateChanged() ;
-
- node = node->GetNext();
- }
#endif
}
while ( node )
{
child = node->GetData();
- // if ( child->IsEnabled() )
+ if (child /* && child->IsEnabled() */)
child->MacPropagateHiliteChanged() ;
node = node->GetNext();
#endif
wxWindow* win = this ;
- while ( win->IsShown() )
+ while ( win->IsShown() )
{
if ( win->IsTopLevel() )
return true ;
if ( rect )
{
Rect r ;
+
wxMacRectToNative( rect , &r ) ;
m_peer->SetNeedsDisplay( &r ) ;
}
void wxWindowMac::Thaw()
{
#if TARGET_API_MAC_OSX
- wxASSERT_MSG( m_frozenness > 0, _T("Thaw() without matching Freeze()") );
+ wxASSERT_MSG( m_frozenness > 0, wxT("Thaw() without matching Freeze()") );
if ( !--m_frozenness )
{
#endif
}
+bool wxWindowMac::IsFrozen() const
+{
+ return m_frozenness != 0;
+}
+
wxWindowMac *wxGetActiveWindow()
{
// actually this is a windows-only concept
}
// Coordinates relative to the window
-void wxWindowMac::WarpPointer (int x_pos, int y_pos)
+void wxWindowMac::WarpPointer(int x_pos, int y_pos)
{
// We really don't move the mouse programmatically under Mac.
}
{
if ( MacGetTopLevelWindow() == NULL )
return ;
+
#if TARGET_API_MAC_OSX
- if ( MacGetTopLevelWindow()->MacUsesCompositing() && (m_macBackgroundBrush.Ok() == false || m_macBackgroundBrush.GetStyle() == wxTRANSPARENT ) )
+ if ( !m_macBackgroundBrush.Ok() || m_macBackgroundBrush.GetStyle() == wxTRANSPARENT )
{
event.Skip() ;
}
bool hasFocus = m_peer->NeedsFocusRect() && m_peer->HasFocus() ;
bool hasBothScrollbars = (m_hScrollBar && m_hScrollBar->IsShown()) && (m_vScrollBar && m_vScrollBar->IsShown()) ;
- m_peer->GetRect( &rect ) ;
// back to the surrounding frame rectangle
+ m_peer->GetRect( &rect ) ;
InsetRect( &rect, -1 , -1 ) ;
-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
- if ( UMAGetSystemVersion() >= 0x1030 )
+#if wxMAC_USE_CORE_GRAPHICS
{
CGRect cgrect = CGRectMake( rect.left , rect.top , rect.right - rect.left ,
rect.bottom - rect.top ) ;
HIThemeFrameDrawInfo info ;
- memset( &info, 0 , sizeof( info ) ) ;
+ memset( &info, 0 , sizeof(info) ) ;
info.version = 0 ;
info.kind = 0 ;
HIThemeDrawGrowBox( &cgpoint , &info , cgContext , kHIThemeOrientationNormal ) ;
}
}
- else
-#endif
+ #else
{
wxTopLevelWindowMac* top = MacGetTopLevelWindow();
if ( top )
// DrawThemeStandaloneNoGrowBox
}
}
+#endif
}
void wxWindowMac::RemoveChild( wxWindowBase *child )
void wxWindowMac::SetScrollbar(int orient, int pos, int thumbVisible,
int range, bool refresh)
{
+ bool showScroller;
+ bool triggerSizeEvent = false;
+
if ( orient == wxHORIZONTAL )
{
if ( m_hScrollBar )
{
- if ( range == 0 || thumbVisible >= range )
- {
- if ( m_hScrollBar->IsShown() )
- m_hScrollBar->Show(false) ;
- }
- else
+ showScroller = ((range != 0) && (range > thumbVisible));
+ if ( m_hScrollBar->IsShown() != showScroller )
{
- if ( !m_hScrollBar->IsShown() )
- m_hScrollBar->Show(true) ;
+ m_hScrollBar->Show( showScroller );
+ triggerSizeEvent = true;
}
m_hScrollBar->SetScrollbar( pos , thumbVisible , range , thumbVisible , refresh ) ;
{
if ( m_vScrollBar )
{
- if ( range == 0 || thumbVisible >= range )
- {
- if ( m_vScrollBar->IsShown() )
- m_vScrollBar->Show(false) ;
- }
- else
+ showScroller = ((range != 0) && (range > thumbVisible));
+ if ( m_vScrollBar->IsShown() != showScroller )
{
- if ( !m_vScrollBar->IsShown() )
- m_vScrollBar->Show(true) ;
+ m_vScrollBar->Show( showScroller ) ;
+ triggerSizeEvent = true;
}
m_vScrollBar->SetScrollbar( pos , thumbVisible , range , thumbVisible , refresh ) ;
}
MacRepositionScrollBars() ;
+ if ( triggerSizeEvent )
+ {
+ wxSizeEvent event(GetSize(), m_windowId);
+ event.SetEventObject(this);
+ GetEventHandler()->ProcessEvent(event);
+ }
}
// Does a physical scroll
void wxWindowMac::ScrollWindow(int dx, int dy, const wxRect *rect)
{
- if ( dx == 0 && dy ==0 )
+ if ( dx == 0 && dy == 0 )
return ;
int width , height ;
GetClientSize( &width , &height ) ;
-#if TARGET_API_MAC_OSX
- if ( true /* m_peer->IsCompositing() */ )
{
// note there currently is a bug in OSX which makes inefficient refreshes in case an entire control
// area is scrolled, this does not occur if width and height are 2 pixels less,
- // TODO write optimal workaround
- wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
+ // TODO: write optimal workaround
+ wxRect scrollrect( MacGetLeftBorderSize() , MacGetTopBorderSize() , width , height ) ;
if ( rect )
scrollrect.Intersect( *rect ) ;
if ( m_peer->GetNeedsDisplay() )
{
- // becuase HIViewScrollRect does not scroll the already invalidated area we have two options
+ // because HIViewScrollRect does not scroll the already invalidated area we have two options:
// either immediate redraw or full invalidate
#if 1
// is the better overall solution, as it does not slow down scrolling
// this would be the preferred version for fast drawing controls
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
- if ( UMAGetSystemVersion() >= 0x1030 && m_peer->IsCompositing() )
+ if ( UMAGetSystemVersion() >= 0x1030 )
HIViewRender(m_peer->GetControlRef()) ;
else
#endif
// as the native control might be not a 0/0 wx window coordinates, we have to offset
scrollrect.Offset( -MacGetLeftBorderSize() , -MacGetTopBorderSize() ) ;
- m_peer->ScrollRect( (&scrollrect) , dx , dy ) ;
+ m_peer->ScrollRect( &scrollrect , dx , dy ) ;
// becuase HIViewScrollRect does not scroll the already invalidated area we have two options
// either immediate redraw or full invalidate
#else
// this would be the preferred version for fast drawing controls
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
- if ( UMAGetSystemVersion() >= 0x1030 && m_peer->IsCompositing() )
- HIViewRender(m_peer->GetControlRef()) ;
- else
-#endif
- Update() ;
-
+ HIViewRender(m_peer->GetControlRef()) ;
#endif
}
- else
-#endif
- {
-
- wxPoint pos;
- pos.x = pos.y = 0;
-
- Rect scrollrect;
- RgnHandle updateRgn = NewRgn() ;
-
- {
- wxClientDC dc(this) ;
- wxMacPortSetter helper(&dc) ;
-
- m_peer->GetRectInWindowCoords( &scrollrect ) ;
- //scrollrect.top += MacGetTopBorderSize() ;
- //scrollrect.left += MacGetLeftBorderSize() ;
- scrollrect.bottom = scrollrect.top + height ;
- scrollrect.right = scrollrect.left + width ;
-
- if ( rect )
- {
- Rect r = { dc.YLOG2DEVMAC(rect->y) , dc.XLOG2DEVMAC(rect->x) , dc.YLOG2DEVMAC(rect->y + rect->height) ,
- dc.XLOG2DEVMAC(rect->x + rect->width) } ;
- SectRect( &scrollrect , &r , &scrollrect ) ;
- }
-
- ScrollRect( &scrollrect , dx , dy , updateRgn ) ;
-
- // now scroll the former update region as well and add the new update region
- WindowRef rootWindow = (WindowRef) MacGetTopLevelWindowRef() ;
- RgnHandle formerUpdateRgn = NewRgn() ;
- RgnHandle scrollRgn = NewRgn() ;
- RectRgn( scrollRgn , &scrollrect ) ;
- GetWindowUpdateRgn( rootWindow , formerUpdateRgn ) ;
- Point pt = {0,0} ;
- LocalToGlobal( &pt ) ;
- OffsetRgn( formerUpdateRgn , -pt.h , -pt.v ) ;
- SectRgn( formerUpdateRgn , scrollRgn , formerUpdateRgn ) ;
-
- if ( !EmptyRgn( formerUpdateRgn ) )
- {
- MacOffsetRgn( formerUpdateRgn , dx , dy ) ;
- SectRgn( formerUpdateRgn , scrollRgn , formerUpdateRgn ) ;
- InvalWindowRgn( rootWindow, formerUpdateRgn ) ;
- }
-
- InvalWindowRgn(rootWindow , updateRgn ) ;
- DisposeRgn( updateRgn ) ;
- DisposeRgn( formerUpdateRgn ) ;
- DisposeRgn( scrollRgn ) ;
- }
-
- Update() ;
- }
wxWindowMac *child;
int x, y, w, h;
//wxChildFocusEvent eventFocus(this);
//(void)GetEventHandler()->ProcessEvent(eventFocus);
- bool bIsFocusEvent = (event.GetEventType() == wxEVT_SET_FOCUS);
-
- // enable for patch 1376506 - perhaps?
-#if 0
- if ( bIsFocusEvent )
- SetUserFocusWindow( GetControlOwner( GetPeer()->GetControlRef() ) );
- else
- SetUserFocusWindow( kUserFocusAuto );
-#endif
-
if ( MacGetTopLevelWindow() && m_peer->NeedsFocusRect() )
{
#if wxMAC_USE_CORE_GRAPHICS
Rect rect ;
m_peer->GetRect( &rect ) ;
- // auf den umgebenden Rahmen zur\9fck
+ // auf den umgebenden Rahmen zurÂ\9fck
InsetRect( &rect, -1 , -1 ) ;
wxTopLevelWindowMac* top = MacGetTopLevelWindow();
if ( top )
{
- wxPoint pt(0,0) ;
+ wxPoint pt(0, 0) ;
wxMacControl::Convert( &pt , GetParent()->m_peer , top->m_peer ) ;
rect.left += pt.x ;
rect.right += pt.x ;
rect.bottom += pt.y ;
}
+ bool bIsFocusEvent = (event.GetEventType() == wxEVT_SET_FOCUS);
DrawThemeFocusRect( &rect , bIsFocusEvent ) ;
if ( !bIsFocusEvent )
{
const wxRegion& wxWindowMac::MacGetVisibleRegion( bool includeOuterStructures )
{
static wxRegion emptyrgn ;
+
if ( !m_isBeingDeleted && MacIsReallyShown() /*m_peer->IsVisible() */ )
{
MacUpdateClippedRects() ;
wxSize size ;
const wxWindow* child = this ;
const wxWindow* parent = NULL ;
+
while ( !child->IsTopLevel() && ( parent = child->GetParent() ) != NULL )
{
if ( parent->MacIsChildOfClientArea(child) )
eventNc.SetEventObject( child );
if ( !child->GetEventHandler()->ProcessEvent( eventNc ) )
{
-#if wxMAC_USE_CORE_GRAPHICS && MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_3
- if ( UMAGetSystemVersion() >= 0x1030 )
- {
- child->MacPaintBorders(0, 0) ;
- }
- else
-#endif
+#if wxMAC_USE_CORE_GRAPHICS
+ child->MacPaintBorders(0, 0) ;
+#else
{
wxWindowDC dc(this) ;
dc.SetClippingRegion(wxRegion(updatergn));
wxMacPortSetter helper(&dc) ;
- child->MacPaintBorders(0, 0) ;
+ child->MacPaintBorders(0, 0) ;
}
+#endif
}
}
}
iter = iter->GetParent() ;
}
- wxASSERT_MSG( 1 , wxT("No valid mac root window") ) ;
-
return NULL ;
}
{
bool hasBoth = ( style & wxVSCROLL ) && ( style & wxHSCROLL ) ;
int scrlsize = MAC_SCROLLBAR_SIZE ;
- wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL ;
if ( GetWindowVariant() == wxWINDOW_VARIANT_SMALL || GetWindowVariant() == wxWINDOW_VARIANT_MINI )
{
scrlsize = MAC_SMALL_SCROLLBAR_SIZE ;
- variant = wxWINDOW_VARIANT_SMALL ;
}
int adjust = hasBoth ? scrlsize - 1: 0 ;
int width, height ;
GetClientSize( &width , &height ) ;
- wxPoint vPoint(width-scrlsize, 0) ;
+ wxPoint vPoint(width - scrlsize, 0) ;
wxSize vSize(scrlsize, height - adjust) ;
- wxPoint hPoint(0 , height-scrlsize ) ;
- wxSize hSize( width - adjust, scrlsize) ;
+ wxPoint hPoint(0, height - scrlsize) ;
+ wxSize hSize(width - adjust, scrlsize) ;
if ( style & wxVSCROLL )
m_vScrollBar = new wxScrollBar(this, wxID_ANY, vPoint, vSize , wxVERTICAL);
bool wxWindowMac::MacIsChildOfClientArea( const wxWindow* child ) const
{
- if ( child != NULL && ( child == m_hScrollBar || child == m_vScrollBar ) )
- return false ;
- else
- return true ;
+ bool result = ((child == NULL) || ((child != m_hScrollBar) && (child != m_vScrollBar)));
+
+ return result ;
}
void wxWindowMac::MacRepositionScrollBars()
if (HasFlag(wxRAISED_BORDER) || HasFlag( wxSUNKEN_BORDER) || HasFlag(wxDOUBLE_BORDER))
{
+ // this metric is only the 'outset' outside the simple frame rect
GetThemeMetric( kThemeMetricEditTextFrameOutset , &border ) ;
- border += 1 ; // the metric above is only the 'outset' outside the simple frame rect
+ border += 1 ;
}
else if (HasFlag(wxSIMPLE_BORDER))
{
+ // this metric is only the 'outset' outside the simple frame rect
GetThemeMetric( kThemeMetricListBoxFrameOutset , &border ) ;
- border += 1 ; // the metric above is only the 'outset' outside the simple frame rect
+ border += 1 ;
}
return border ;
if ( event.GetEventType() == wxEVT_RIGHT_DOWN )
{
// copied from wxGTK : CS
+ // VZ: shouldn't we move this to base class then?
+
// generate a "context menu" event: this is similar to wxEVT_RIGHT_DOWN
// except that:
//
{
int x, y, w, h ;
- window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin) ;
- Rect bounds = { y, x, y + h, x + w };
+ window->MacGetBoundsForControl( pos , size , x , y, w, h , adjustForOrigin ) ;
+ Rect bounds = { y, x, y + h, x + w };
return bounds ;
}
bool wxWindowMac::Reparent(wxWindowBase *newParentBase)
{
wxWindowMac *newParent = (wxWindowMac *)newParentBase;
-
if ( !wxWindowBase::Reparent(newParent) )
return false;
return true;
}
+
+bool wxWindowMac::SetTransparent(wxByte alpha)
+{
+#if wxMAC_USE_CORE_GRAPHICS
+ if ( alpha != m_macAlpha )
+ {
+ m_macAlpha = alpha ;
+ Refresh() ;
+ }
+ return true ;
+#else
+ return false ;
+#endif
+}
+
+
+bool wxWindowMac::CanSetTransparent()
+{
+#if wxMAC_USE_CORE_GRAPHICS
+ return true ;
+#else
+ return false ;
+#endif
+}
+
+wxByte wxWindowMac::GetTransparent() const
+{
+ return m_macAlpha ;
+}
projects / wxWidgets.git / blobdiff