]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/toplevel.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Always use XPMs in this sample
[wxWidgets.git] / src / mac / toplevel.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: mac/toplevel.cpp
3// Purpose: implements wxTopLevelWindow for MSW
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 24.09.01
7// RCS-ID: $Id$
8// Copyright: (c) 2001 SciTech Software, Inc. (www.scitechsoft.com)
9// License: wxWindows licence
10///////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#ifdef __GNUG__
21 #pragma implementation "toplevel.h"
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
28 #pragma hdrstop
29#endif
30
31#ifndef WX_PRECOMP
32 #include "wx/app.h"
33 #include "wx/toplevel.h"
34 #include "wx/frame.h"
35 #include "wx/string.h"
36 #include "wx/log.h"
37 #include "wx/intl.h"
38#endif //WX_PRECOMP
39
40#include "wx/mac/uma.h"
41#include "wx/mac/aga.h"
42#include "wx/app.h"
43#include "wx/tooltip.h"
44#include "wx/dnd.h"
45
46#include "ToolUtils.h"
47
48
49#define wxMAC_DEBUG_REDRAW 0
50#ifndef wxMAC_DEBUG_REDRAW
51#define wxMAC_DEBUG_REDRAW 0
52#endif
53
54// ----------------------------------------------------------------------------
55// globals
56// ----------------------------------------------------------------------------
57
58// list of all frames and modeless dialogs
59wxWindowList wxModelessWindows;
60
61// double click testing
62static Point gs_lastWhere;
63static long gs_lastWhen = 0;
64
65
66#if TARGET_CARBON
67static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param);
68#endif
69
70// ============================================================================
71// wxTopLevelWindowMac implementation
72// ============================================================================
73
74// ---------------------------------------------------------------------------
75// Carbon Events
76// ---------------------------------------------------------------------------
77
78#if TARGET_CARBON
79
80extern long wxMacTranslateKey(unsigned char key, unsigned char code) ;
81
82static const EventTypeSpec eventList[] =
83{
84 { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent } ,
85
86 { kEventClassKeyboard, kEventRawKeyDown } ,
87 { kEventClassKeyboard, kEventRawKeyRepeat } ,
88 { kEventClassKeyboard, kEventRawKeyUp } ,
89 { kEventClassKeyboard, kEventRawKeyModifiersChanged } ,
90
91 { kEventClassWindow , kEventWindowUpdate } ,
92 { kEventClassWindow , kEventWindowActivated } ,
93 { kEventClassWindow , kEventWindowDeactivated } ,
94 { kEventClassWindow , kEventWindowBoundsChanging } ,
95 { kEventClassWindow , kEventWindowBoundsChanged } ,
96 { kEventClassWindow , kEventWindowClose } ,
97
98 { kEventClassMouse , kEventMouseDown } ,
99 { kEventClassMouse , kEventMouseUp } ,
100 { kEventClassMouse , kEventMouseWheelMoved } ,
101 { kEventClassMouse , kEventMouseMoved } ,
102 { kEventClassMouse , kEventMouseDragged } ,
103
104} ;
105
106static pascal OSStatus TextInputEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
107{
108 OSStatus result = eventNotHandledErr ;
109
110 wxWindow* focus = wxWindow::FindFocus() ;
111 char charCode ;
112 UInt32 keyCode ;
113 UInt32 modifiers ;
114 Point point ;
115
116 EventRef rawEvent ;
117
118 GetEventParameter( event , kEventParamTextInputSendKeyboardEvent ,typeEventRef,NULL,sizeof(rawEvent),NULL,&rawEvent ) ;
119
120 GetEventParameter( rawEvent, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
121 GetEventParameter( rawEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
122 GetEventParameter( rawEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
123 GetEventParameter( rawEvent, kEventParamMouseLocation, typeQDPoint, NULL,
124 sizeof( Point ), NULL, &point );
125
126 switch ( GetEventKind( event ) )
127 {
128 case kEventTextInputUnicodeForKeyEvent :
129 // this is only called when no default handler has jumped in, eg a wxControl on a floater window does not
130 // get its own kEventTextInputUnicodeForKeyEvent, so we route back the
131 wxControl* control = wxDynamicCast( focus , wxControl ) ;
132 if ( control )
133 {
134 ControlHandle macControl = (ControlHandle) control->GetMacControl() ;
135 if ( macControl )
136 {
137 ::HandleControlKey( macControl , keyCode , charCode , modifiers ) ;
138 result = noErr ;
139 }
140 }
141 /*
142 // this may lead to double events sent to a window in case all handlers have skipped the key down event
143 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
144 UInt32 message = (keyCode << 8) + charCode;
145
146 if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
147 focus , message , modifiers , when , point.h , point.v ) )
148 {
149 result = noErr ;
150 }
151 */
152 break ;
153 }
154
155 return result ;
156}
157
158static pascal OSStatus KeyboardEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
159{
160 OSStatus result = eventNotHandledErr ;
161
162 wxWindow* focus = wxWindow::FindFocus() ;
163 char charCode ;
164 UInt32 keyCode ;
165 UInt32 modifiers ;
166 Point point ;
167 UInt32 when = EventTimeToTicks( GetEventTime( event ) ) ;
168
169 GetEventParameter( event, kEventParamKeyMacCharCodes, typeChar, NULL,sizeof(char), NULL,&charCode );
170 GetEventParameter( event, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &keyCode );
171 GetEventParameter(event, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers);
172 GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
173 sizeof( Point ), NULL, &point );
174
175 UInt32 message = (keyCode << 8) + charCode;
176 switch( GetEventKind( event ) )
177 {
178 case kEventRawKeyRepeat :
179 case kEventRawKeyDown :
180 {
181 WXEVENTREF formerEvent = wxTheApp->MacGetCurrentEvent() ;
182 WXEVENTHANDLERCALLREF formerHandler = wxTheApp->MacGetCurrentEventHandlerCallRef() ;
183 wxTheApp->MacSetCurrentEvent( event , handler ) ;
184 if ( (focus != NULL) && wxTheApp->MacSendKeyDownEvent(
185 focus , message , modifiers , when , point.h , point.v ) )
186 {
187 result = noErr ;
188 }
189 wxTheApp->MacSetCurrentEvent( formerEvent , formerHandler ) ;
190 }
191 break ;
192 case kEventRawKeyUp :
193 if ( (focus != NULL) && wxTheApp->MacSendKeyUpEvent(
194 focus , message , modifiers , when , point.h , point.v ) )
195 {
196 result = noErr ;
197 }
198 break ;
199 case kEventRawKeyModifiersChanged :
200 {
201 wxKeyEvent event(wxEVT_KEY_DOWN);
202
203 event.m_shiftDown = modifiers & shiftKey;
204 event.m_controlDown = modifiers & controlKey;
205 event.m_altDown = modifiers & optionKey;
206 event.m_metaDown = modifiers & cmdKey;
207
208 event.m_x = point.h;
209 event.m_y = point.v;
210 event.m_timeStamp = when;
211 wxWindow* focus = wxWindow::FindFocus() ;
212 event.SetEventObject(focus);
213
214 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & controlKey )
215 {
216 event.m_keyCode = WXK_CONTROL ;
217 event.SetEventType( ( modifiers & controlKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
218 focus->GetEventHandler()->ProcessEvent( event ) ;
219 }
220 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & shiftKey )
221 {
222 event.m_keyCode = WXK_SHIFT ;
223 event.SetEventType( ( modifiers & shiftKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
224 focus->GetEventHandler()->ProcessEvent( event ) ;
225 }
226 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & optionKey )
227 {
228 event.m_keyCode = WXK_ALT ;
229 event.SetEventType( ( modifiers & optionKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
230 focus->GetEventHandler()->ProcessEvent( event ) ;
231 }
232 if ( focus && (modifiers ^ wxTheApp->s_lastModifiers ) & cmdKey )
233 {
234 event.m_keyCode = WXK_COMMAND ;
235 event.SetEventType( ( modifiers & cmdKey ) ? wxEVT_KEY_DOWN : wxEVT_KEY_UP ) ;
236 focus->GetEventHandler()->ProcessEvent( event ) ;
237 }
238 wxTheApp->s_lastModifiers = modifiers ;
239 }
240 break ;
241 }
242
243 return result ;
244}
245
246pascal OSStatus MouseEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
247{
248 OSStatus result = eventNotHandledErr ;
249
250 wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
251 Point point ;
252 UInt32 modifiers = 0;
253 EventMouseButton button = 0 ;
254 UInt32 click = 0 ;
255
256 GetEventParameter( event, kEventParamMouseLocation, typeQDPoint, NULL,
257 sizeof( Point ), NULL, &point );
258 GetEventParameter( event, kEventParamKeyModifiers, typeUInt32, NULL,
259 sizeof( UInt32 ), NULL, &modifiers );
260 GetEventParameter( event, kEventParamMouseButton, typeMouseButton, NULL,
261 sizeof( EventMouseButton ), NULL, &button );
262 GetEventParameter( event, kEventParamClickCount, typeUInt32, NULL,
263 sizeof( UInt32 ), NULL, &click );
264
265 if ( button == 0 || GetEventKind( event ) == kEventMouseUp )
266 modifiers += btnState ;
267
268 // temporary hack to support true two button mouse
269 if ( button == kEventMouseButtonSecondary )
270 {
271 modifiers |= controlKey ;
272 }
273 WindowRef window ;
274 short windowPart = ::FindWindow(point, &window);
275
276 // either we really are active or we are capturing mouse events
277
278 if ( (IsWindowActive(window) && windowPart == inContent) ||
279 (wxTheApp->s_captureWindow && wxTheApp->s_captureWindow->MacGetTopLevelWindow() == toplevelWindow) )
280 {
281 switch ( GetEventKind( event ) )
282 {
283 case kEventMouseDown :
284 toplevelWindow->MacFireMouseEvent( mouseDown , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
285 result = noErr ;
286 break ;
287 case kEventMouseUp :
288 toplevelWindow->MacFireMouseEvent( mouseUp , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
289 result = noErr ;
290 break ;
291 case kEventMouseMoved :
292 wxTheApp->MacHandleMouseMovedEvent( point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
293 result = noErr ;
294 break ;
295 case kEventMouseDragged :
296 toplevelWindow->MacFireMouseEvent( nullEvent , point.h , point.v , modifiers , EventTimeToTicks( GetEventTime( event ) ) ) ;
297 result = noErr ;
298 break ;
299 case kEventMouseWheelMoved :
300 {
301 //bClearTooltip = false;
302 EventMouseWheelAxis axis = kEventMouseWheelAxisY;
303 SInt32 delta = 0;
304 Point mouseLoc = {0, 0};
305 if (::GetEventParameter(event, kEventParamMouseWheelAxis, typeMouseWheelAxis,
306 NULL, sizeof(EventMouseWheelAxis), NULL, &axis) == noErr &&
307 ::GetEventParameter(event, kEventParamMouseWheelDelta, typeLongInteger,
308 NULL, sizeof(SInt32), NULL, &delta) == noErr &&
309 ::GetEventParameter(event, kEventParamMouseLocation, typeQDPoint,
310 NULL, sizeof(Point), NULL, &mouseLoc) == noErr)
311 {
312 wxMouseEvent wheelEvent(wxEVT_MOUSEWHEEL);
313
314 wheelEvent.m_x = mouseLoc.h;
315 wheelEvent.m_y = mouseLoc.v;
316
317 wheelEvent.m_wheelRotation = delta;
318 wheelEvent.m_wheelDelta = 1;
319 wheelEvent.m_linesPerAction = 1;
320
321 wxWindow* currentMouseWindow = NULL;
322 wxWindow::MacGetWindowFromPoint(wxPoint(mouseLoc.h, mouseLoc.v), &currentMouseWindow);
323
324 if (currentMouseWindow)
325 {
326 currentMouseWindow->GetEventHandler()->ProcessEvent(wheelEvent);
327 result = noErr;
328 }
329 }
330 }
331 break ;
332 default :
333 break ;
334 }
335 }
336
337 return result ;
338
339
340}
341static pascal OSStatus WindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
342{
343 OSStatus result = eventNotHandledErr ;
344 OSStatus err = noErr ;
345
346 UInt32 attributes;
347 WindowRef windowRef ;
348 wxTopLevelWindowMac* toplevelWindow = (wxTopLevelWindowMac*) data ;
349
350 GetEventParameter( event, kEventParamDirectObject, typeWindowRef, NULL,
351 sizeof( WindowRef ), NULL, &windowRef );
352
353 switch( GetEventKind( event ) )
354 {
355 case kEventWindowUpdate :
356 if ( !wxPendingDelete.Member(toplevelWindow) )
357 toplevelWindow->MacUpdate( EventTimeToTicks( GetEventTime( event ) ) ) ;
358 result = noErr ;
359 break ;
360 case kEventWindowActivated :
361 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , true) ;
362 result = noErr ;
363 break ;
364 case kEventWindowDeactivated :
365 toplevelWindow->MacActivate( EventTimeToTicks( GetEventTime( event ) ) , false) ;
366 result = noErr ;
367 break ;
368 case kEventWindowClose :
369 toplevelWindow->Close() ;
370 result = noErr ;
371 break ;
372 case kEventWindowBoundsChanged :
373 err = GetEventParameter( event, kEventParamAttributes, typeUInt32,
374 NULL, sizeof( UInt32 ), NULL, &attributes );
375 if ( err == noErr )
376 {
377 Rect newContentRect ;
378
379 GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL,
380 sizeof( newContentRect ), NULL, &newContentRect );
381
382 toplevelWindow->SetSize( newContentRect.left , newContentRect.top ,
383 newContentRect.right - newContentRect.left ,
384 newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
385
386 result = noErr;
387 }
388 break ;
389 case kEventWindowBoundsChanging :
390 err = GetEventParameter( event, kEventParamAttributes, typeUInt32,
391 NULL, sizeof( UInt32 ), NULL, &attributes );
392 if ( err == noErr )
393 {
394 Rect newContentRect ;
395
396 GetEventParameter( event, kEventParamCurrentBounds, typeQDRectangle, NULL,
397 sizeof( newContentRect ), NULL, &newContentRect );
398
399 wxSize formerSize = toplevelWindow->GetSize() ;
400
401 if ( (attributes & kWindowBoundsChangeSizeChanged ) ||
402 ( attributes & kWindowBoundsChangeOriginChanged ) )
403 toplevelWindow->SetSize( newContentRect.left , newContentRect.top ,
404 newContentRect.right - newContentRect.left ,
405 newContentRect.bottom - newContentRect.top, wxSIZE_USE_EXISTING);
406
407 int x , y , w , h ;
408 toplevelWindow->GetPosition( &x , &y ) ;
409 toplevelWindow->GetSize( &w , &h ) ;
410 Rect adjustedRect = { y , x , y + h , x + w } ;
411
412 if ( !EqualRect( &newContentRect , &adjustedRect ) )
413 {
414 SetEventParameter( event , kEventParamCurrentBounds , typeQDRectangle, sizeof( adjustedRect ) , &adjustedRect ) ;
415 }
416
417 if ( toplevelWindow->GetSize() != formerSize )
418 toplevelWindow->Update() ;
419
420 result = noErr ;
421 }
422 break ;
423 default :
424 break ;
425 }
426 return result ;
427}
428
429pascal OSStatus wxMacWindowEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
430{
431 OSStatus result = eventNotHandledErr ;
432
433 switch ( GetEventClass( event ) )
434 {
435 case kEventClassKeyboard :
436 result = KeyboardEventHandler( handler, event , data ) ;
437 break ;
438 case kEventClassTextInput :
439 result = TextInputEventHandler( handler, event , data ) ;
440 break ;
441 case kEventClassWindow :
442 result = WindowEventHandler( handler, event , data ) ;
443 break ;
444 case kEventClassMouse :
445 result = MouseEventHandler( handler, event , data ) ;
446 break ;
447 default :
448 break ;
449 }
450 return result ;
451}
452
453DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacWindowEventHandler )
454
455#endif
456
457// ---------------------------------------------------------------------------
458// wxWindowMac utility functions
459// ---------------------------------------------------------------------------
460
461// Find an item given the Macintosh Window Reference
462
463wxList *wxWinMacWindowList = NULL;
464wxTopLevelWindowMac *wxFindWinFromMacWindow(WXWindow inWindowRef)
465{
466 if ( wxWinMacWindowList == NULL )
467 return NULL ;
468 wxNode *node = wxWinMacWindowList->Find((long)inWindowRef);
469 if (!node)
470 return NULL;
471 return (wxTopLevelWindowMac *)node->GetData();
472}
473
474void wxAssociateWinWithMacWindow(WXWindow inWindowRef, wxTopLevelWindowMac *win)
475{
476 // adding NULL WindowRef is (first) surely a result of an error and
477 // (secondly) breaks menu command processing
478 wxCHECK_RET( inWindowRef != (WindowRef) NULL, wxT("attempt to add a NULL WindowRef to window list") );
479
480 if ( !wxWinMacWindowList->Find((long)inWindowRef) )
481 wxWinMacWindowList->Append((long)inWindowRef, win);
482}
483
484void wxRemoveMacWindowAssociation(wxTopLevelWindowMac *win)
485{
486 wxWinMacWindowList->DeleteObject(win);
487}
488
489
490// ----------------------------------------------------------------------------
491// wxTopLevelWindowMac creation
492// ----------------------------------------------------------------------------
493
494WXHWND wxTopLevelWindowMac::s_macWindowInUpdate = NULL;
495wxTopLevelWindowMac *wxTopLevelWindowMac::s_macDeactivateWindow = NULL;
496
497void wxTopLevelWindowMac::Init()
498{
499 m_iconized =
500 m_maximizeOnShow = FALSE;
501 m_macNoEraseUpdateRgn = NewRgn() ;
502 m_macNeedsErasing = false ;
503 m_macWindow = NULL ;
504#if TARGET_CARBON
505 m_macEventHandler = NULL ;
506 #endif
507}
508
509class wxMacDeferredWindowDeleter : public wxObject
510{
511public :
512 wxMacDeferredWindowDeleter( WindowRef windowRef )
513 {
514 m_macWindow = windowRef ;
515 }
516 virtual ~wxMacDeferredWindowDeleter()
517 {
518 UMADisposeWindow( (WindowRef) m_macWindow ) ;
519 }
520 protected :
521 WindowRef m_macWindow ;
522} ;
523
524bool wxTopLevelWindowMac::Create(wxWindow *parent,
525 wxWindowID id,
526 const wxString& title,
527 const wxPoint& pos,
528 const wxSize& size,
529 long style,
530 const wxString& name)
531{
532 // init our fields
533 Init();
534
535 m_windowStyle = style;
536
537 SetName(name);
538
539 m_windowId = id == -1 ? NewControlId() : id;
540
541 wxTopLevelWindows.Append(this);
542
543 if ( parent )
544 parent->AddChild(this);
545
546 return TRUE;
547}
548
549wxTopLevelWindowMac::~wxTopLevelWindowMac()
550{
551 if ( m_macWindow )
552 {
553 wxToolTip::NotifyWindowDelete(m_macWindow) ;
554 wxPendingDelete.Append( new wxMacDeferredWindowDeleter( (WindowRef) m_macWindow ) ) ;
555 }
556
557#if TARGET_CARBON
558 if ( m_macEventHandler )
559 {
560 ::RemoveEventHandler((EventHandlerRef) m_macEventHandler);
561 m_macEventHandler = NULL ;
562 }
563#endif
564
565 wxRemoveMacWindowAssociation( this ) ;
566
567 if ( wxModelessWindows.Find(this) )
568 wxModelessWindows.DeleteObject(this);
569
570 DisposeRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
571}
572
573
574// ----------------------------------------------------------------------------
575// wxTopLevelWindowMac maximize/minimize
576// ----------------------------------------------------------------------------
577
578void wxTopLevelWindowMac::Maximize(bool maximize)
579{
580 ZoomWindow( (WindowRef)m_macWindow , maximize ? inZoomOut : inZoomIn , false ) ;
581
582 Rect tempRect ;
583 GrafPtr port ;
584 GetPort( &port ) ;
585 Point pt = { 0, 0 } ;
586 SetPortWindowPort((WindowRef)m_macWindow) ;
587 LocalToGlobal( &pt ) ;
588 SetPort( port ) ;
589
590 GetWindowPortBounds((WindowRef)m_macWindow, &tempRect ) ;
591 SetSize( pt.h , pt.v , tempRect.right-tempRect.left ,
592 tempRect.bottom-tempRect.top, wxSIZE_USE_EXISTING);
593}
594
595bool wxTopLevelWindowMac::IsMaximized() const
596{
597 return IsWindowInStandardState( (WindowRef)m_macWindow , NULL , NULL ) ;
598}
599
600void wxTopLevelWindowMac::Iconize(bool iconize)
601{
602 if ( IsWindowCollapsable((WindowRef)m_macWindow) )
603 CollapseWindow((WindowRef)m_macWindow , iconize ) ;
604}
605
606bool wxTopLevelWindowMac::IsIconized() const
607{
608 return IsWindowCollapsed((WindowRef)m_macWindow ) ;
609}
610
611void wxTopLevelWindowMac::Restore()
612{
613 // not available on mac
614}
615
616// ----------------------------------------------------------------------------
617// wxTopLevelWindowMac misc
618// ----------------------------------------------------------------------------
619
620void wxTopLevelWindowMac::SetIcon(const wxIcon& icon)
621{
622 // this sets m_icon
623 wxTopLevelWindowBase::SetIcon(icon);
624}
625
626void wxTopLevelWindowMac::MacCreateRealWindow( const wxString& title,
627 const wxPoint& pos,
628 const wxSize& size,
629 long style,
630 const wxString& name )
631{
632 OSStatus err = noErr ;
633 SetName(name);
634 m_windowStyle = style;
635 m_isShown = FALSE;
636
637 // create frame.
638
639 Rect theBoundsRect;
640
641 m_x = (int)pos.x;
642 m_y = (int)pos.y;
643 if ( m_y < 50 )
644 m_y = 50 ;
645 if ( m_x < 20 )
646 m_x = 20 ;
647
648 m_width = size.x;
649 if (m_width == -1)
650 m_width = 20;
651 m_height = size.y;
652 if (m_height == -1)
653 m_height = 20;
654
655 ::SetRect(&theBoundsRect, m_x, m_y , m_x + m_width, m_y + m_height);
656
657 // translate the window attributes in the appropriate window class and attributes
658
659 WindowClass wclass = 0;
660 WindowAttributes attr = kWindowNoAttributes ;
661
662 if ( HasFlag( wxFRAME_TOOL_WINDOW) )
663 {
664 if (
665 HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
666 HasFlag( wxSYSTEM_MENU ) || HasFlag( wxCAPTION ) ||
667 HasFlag(wxTINY_CAPTION_HORIZ) || HasFlag(wxTINY_CAPTION_VERT)
668 )
669 {
670 wclass = kFloatingWindowClass ;
671 if ( HasFlag(wxTINY_CAPTION_VERT) )
672 {
673 attr |= kWindowSideTitlebarAttribute ;
674 }
675 }
676 else
677 {
678#if TARGET_CARBON
679 wclass = kPlainWindowClass ;
680#else
681 wclass = kFloatingWindowClass ;
682#endif
683 }
684 }
685 else if ( HasFlag( wxCAPTION ) )
686 {
687 wclass = kDocumentWindowClass ;
688 }
689 else
690 {
691 if ( HasFlag( wxMINIMIZE_BOX ) || HasFlag( wxMAXIMIZE_BOX ) ||
692 HasFlag( wxCLOSE_BOX ) || HasFlag( wxSYSTEM_MENU ) )
693 {
694 wclass = kDocumentWindowClass ;
695 }
696 else
697 {
698#if TARGET_CARBON
699 wclass = kPlainWindowClass ;
700#else
701 wclass = kModalWindowClass ;
702#endif
703 }
704 }
705
706 if ( HasFlag( wxMINIMIZE_BOX ) )
707 {
708 attr |= kWindowCollapseBoxAttribute ;
709 }
710 if ( HasFlag( wxMAXIMIZE_BOX ) )
711 {
712 attr |= kWindowFullZoomAttribute ;
713 }
714 if ( HasFlag( wxRESIZE_BORDER ) )
715 {
716 attr |= kWindowResizableAttribute ;
717 }
718 if ( HasFlag( wxCLOSE_BOX) )
719 {
720 attr |= kWindowCloseBoxAttribute ;
721 }
722
723#if TARGET_CARBON
724#if 0 // having problems right now with that
725 if (HasFlag(wxSTAY_ON_TOP))
726 wclass = kUtilityWindowClass;
727#endif
728#endif
729
730#if TARGET_CARBON
731 if ( HasFlag(wxFRAME_SHAPED) )
732 {
733 WindowDefSpec customWindowDefSpec;
734 customWindowDefSpec.defType = kWindowDefProcPtr;
735 customWindowDefSpec.u.defProc = NewWindowDefUPP(wxShapedMacWindowDef);
736
737 err = ::CreateCustomWindow( &customWindowDefSpec, wclass,
738 attr, &theBoundsRect,
739 (WindowRef*) &m_macWindow);
740 }
741 else
742#endif
743 {
744 err = ::CreateNewWindow( wclass , attr , &theBoundsRect , (WindowRef*)&m_macWindow ) ;
745 }
746
747 wxCHECK_RET( err == noErr, wxT("Mac OS error when trying to create new window") );
748 wxAssociateWinWithMacWindow( m_macWindow , this ) ;
749 UMASetWTitle( (WindowRef)m_macWindow , title ) ;
750 ::CreateRootControl( (WindowRef)m_macWindow , (ControlHandle*)&m_macRootControl ) ;
751#if TARGET_CARBON
752 InstallStandardEventHandler( GetWindowEventTarget(MAC_WXHWND(m_macWindow)) ) ;
753 InstallWindowEventHandler(MAC_WXHWND(m_macWindow), GetwxMacWindowEventHandlerUPP(),
754 GetEventTypeCount(eventList), eventList, this, (EventHandlerRef *)&m_macEventHandler);
755#endif
756 m_macFocus = NULL ;
757
758
759#if TARGET_CARBON
760 if ( HasFlag(wxFRAME_SHAPED) )
761 {
762 // default shape matches the window size
763 wxRegion rgn(0, 0, m_width, m_height);
764 SetShape(rgn);
765 }
766#endif
767}
768
769void wxTopLevelWindowMac::MacGetPortParams(WXPOINTPTR localOrigin, WXRECTPTR clipRect, WXHWND *window , wxWindowMac** rootwin)
770{
771 ((Point*)localOrigin)->h = 0;
772 ((Point*)localOrigin)->v = 0;
773 ((Rect*)clipRect)->left = 0;
774 ((Rect*)clipRect)->top = 0;
775 ((Rect*)clipRect)->right = m_width;
776 ((Rect*)clipRect)->bottom = m_height;
777 *window = m_macWindow ;
778 *rootwin = this ;
779}
780
781void wxTopLevelWindowMac::ClearBackground()
782{
783 wxWindow::ClearBackground() ;
784}
785
786WXWidget wxTopLevelWindowMac::MacGetContainerForEmbedding()
787{
788 return m_macRootControl ;
789}
790
791
792void wxTopLevelWindowMac::MacUpdate( long timestamp)
793{
794 wxMacPortStateHelper help( (GrafPtr) GetWindowPort( (WindowRef) m_macWindow) ) ;
795
796 RgnHandle visRgn = NewRgn() ;
797 GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), visRgn );
798 BeginUpdate( (WindowRef)m_macWindow ) ;
799
800 RgnHandle updateRgn = NewRgn();
801 RgnHandle diffRgn = NewRgn() ;
802
803 if ( updateRgn && diffRgn )
804 {
805#if 1
806 // macos internal control redraws clean up areas we'd like to redraw ourselves
807 // therefore we pick the boundary rect and make sure we can redraw it
808 // this has to be intersected by the visRgn in order to avoid drawing over its own
809 // boundaries
810 RgnHandle trueUpdateRgn = NewRgn() ;
811 Rect trueUpdateRgnBoundary ;
812 GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), trueUpdateRgn );
813 GetRegionBounds( trueUpdateRgn , &trueUpdateRgnBoundary ) ;
814 RectRgn( updateRgn , &trueUpdateRgnBoundary ) ;
815 SectRgn( updateRgn , visRgn , updateRgn ) ;
816 if ( trueUpdateRgn )
817 DisposeRgn( trueUpdateRgn ) ;
818 SetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn ) ;
819#else
820 GetPortVisibleRegion( GetWindowPort( (WindowRef)m_macWindow ), updateRgn );
821#endif
822 DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
823 if ( !EmptyRgn( updateRgn ) )
824 {
825 MacRedraw( updateRgn , timestamp , m_macNeedsErasing || !EmptyRgn( diffRgn ) ) ;
826 }
827 }
828 if ( updateRgn )
829 DisposeRgn( updateRgn );
830 if ( diffRgn )
831 DisposeRgn( diffRgn );
832 if ( visRgn )
833 DisposeRgn( visRgn ) ;
834
835 EndUpdate( (WindowRef)m_macWindow ) ;
836 SetEmptyRgn( (RgnHandle) m_macNoEraseUpdateRgn ) ;
837 m_macNeedsErasing = false ;
838}
839
840
841// Raise the window to the top of the Z order
842void wxTopLevelWindowMac::Raise()
843{
844 ::SelectWindow( (WindowRef)m_macWindow ) ;
845}
846
847// Lower the window to the bottom of the Z order
848void wxTopLevelWindowMac::Lower()
849{
850 ::SendBehind( (WindowRef)m_macWindow , NULL ) ;
851}
852
853void wxTopLevelWindowMac::MacFireMouseEvent(
854 wxUint16 kind , wxInt32 x , wxInt32 y ,wxUint32 modifiers , long timestamp )
855{
856 wxMouseEvent event(wxEVT_LEFT_DOWN);
857 bool isDown = !(modifiers & btnState) ; // 1 is for up
858 bool controlDown = modifiers & controlKey ; // for simulating right mouse
859
860 event.m_leftDown = isDown && !controlDown;
861
862 event.m_middleDown = FALSE;
863 event.m_rightDown = isDown && controlDown;
864
865 if ( kind == mouseDown )
866 {
867 if ( controlDown )
868 event.SetEventType(wxEVT_RIGHT_DOWN ) ;
869 else
870 event.SetEventType(wxEVT_LEFT_DOWN ) ;
871 }
872 else if ( kind == mouseUp )
873 {
874 if ( controlDown )
875 event.SetEventType(wxEVT_RIGHT_UP ) ;
876 else
877 event.SetEventType(wxEVT_LEFT_UP ) ;
878 }
879 else
880 {
881 event.SetEventType(wxEVT_MOTION ) ;
882 }
883
884 event.m_shiftDown = modifiers & shiftKey;
885 event.m_controlDown = modifiers & controlKey;
886 event.m_altDown = modifiers & optionKey;
887 event.m_metaDown = modifiers & cmdKey;
888
889 Point localwhere ;
890 localwhere.h = x ;
891 localwhere.v = y ;
892
893 GrafPtr port ;
894 ::GetPort( &port ) ;
895 ::SetPort( UMAGetWindowPort( (WindowRef)m_macWindow ) ) ;
896 ::GlobalToLocal( &localwhere ) ;
897 ::SetPort( port ) ;
898
899 if ( kind == mouseDown )
900 {
901 if ( timestamp - gs_lastWhen <= (long) GetDblTime() )
902 {
903 if ( abs( localwhere.h - gs_lastWhere.h ) < 3 && abs( localwhere.v - gs_lastWhere.v ) < 3 )
904 {
905 // This is not right if the second mouse down
906 // event occured in a differen window. We
907 // correct this in MacDispatchMouseEvent.
908 if ( controlDown )
909 event.SetEventType(wxEVT_RIGHT_DCLICK ) ;
910 else
911 event.SetEventType(wxEVT_LEFT_DCLICK ) ;
912 }
913 gs_lastWhen = 0 ;
914 }
915 else
916 {
917 gs_lastWhen = timestamp ;
918 }
919 gs_lastWhere = localwhere ;
920 }
921
922 event.m_x = localwhere.h;
923 event.m_y = localwhere.v;
924 event.m_x += m_x;
925 event.m_y += m_y;
926
927 event.m_timeStamp = timestamp;
928 event.SetEventObject(this);
929 if ( wxTheApp->s_captureWindow )
930 {
931 int x = event.m_x ;
932 int y = event.m_y ;
933 wxTheApp->s_captureWindow->ScreenToClient( &x , &y ) ;
934 event.m_x = x ;
935 event.m_y = y ;
936 event.SetEventObject( wxTheApp->s_captureWindow ) ;
937 wxTheApp->s_captureWindow->GetEventHandler()->ProcessEvent( event ) ;
938
939 if ( kind == mouseUp )
940 {
941 wxTheApp->s_captureWindow = NULL ;
942 if ( !wxIsBusy() )
943 {
944 m_cursor.MacInstall() ;
945 }
946 }
947 }
948 else
949 {
950 MacDispatchMouseEvent( event ) ;
951 }
952}
953
954#if !TARGET_CARBON
955
956void wxTopLevelWindowMac::MacMouseDown( WXEVENTREF ev , short part)
957{
958 MacFireMouseEvent( mouseDown , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
959 ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
960}
961
962void wxTopLevelWindowMac::MacMouseUp( WXEVENTREF ev , short part)
963{
964 switch (part)
965 {
966 case inContent:
967 {
968 MacFireMouseEvent( mouseUp , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
969 ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
970 }
971 break ;
972 }
973}
974
975void wxTopLevelWindowMac::MacMouseMoved( WXEVENTREF ev , short part)
976{
977 switch (part)
978 {
979 case inContent:
980 {
981 MacFireMouseEvent( nullEvent /*moved*/ , ((EventRecord*)ev)->where.h , ((EventRecord*)ev)->where.v ,
982 ((EventRecord*)ev)->modifiers , ((EventRecord*)ev)->when ) ;
983 }
984 break ;
985 }
986}
987
988#endif
989
990void wxTopLevelWindowMac::MacDelayedDeactivation(long timestamp)
991{
992 if(s_macDeactivateWindow)
993 {
994 wxLogDebug(wxT("Doing delayed deactivation of %p"),s_macDeactivateWindow);
995 s_macDeactivateWindow->MacActivate(timestamp, false);
996 }
997}
998
999void wxTopLevelWindowMac::MacActivate( long timestamp , bool inIsActivating )
1000{
1001 // wxLogDebug(wxT("TopLevel=%p::MacActivate"),this);
1002
1003 if(s_macDeactivateWindow==this)
1004 s_macDeactivateWindow=NULL;
1005 MacDelayedDeactivation(timestamp);
1006 wxActivateEvent event(wxEVT_ACTIVATE, inIsActivating , m_windowId);
1007 event.m_timeStamp = timestamp ;
1008 event.SetEventObject(this);
1009
1010 GetEventHandler()->ProcessEvent(event);
1011
1012 UMAHighlightAndActivateWindow( (WindowRef)m_macWindow , inIsActivating ) ;
1013
1014 // Early versions of MacOS X don't refresh backgrounds properly,
1015 // so refresh the whole window on activation and deactivation.
1016 long osVersion = UMAGetSystemVersion();
1017 if (osVersion >= 0x1000 && osVersion < 0x1020 )
1018 {
1019 Refresh(TRUE);
1020 }
1021 else
1022 {
1023 // for the moment we have to resolve some redrawing issues like this
1024 // the OS is stealing some redrawing areas as soon as it draws a control
1025 Refresh(TRUE);
1026 }
1027}
1028
1029#if !TARGET_CARBON
1030
1031void wxTopLevelWindowMac::MacKeyDown( WXEVENTREF ev )
1032{
1033}
1034
1035#endif
1036
1037void wxTopLevelWindowMac::SetTitle(const wxString& title)
1038{
1039 wxWindow::SetTitle( title ) ;
1040 UMASetWTitle( (WindowRef)m_macWindow , title ) ;
1041}
1042
1043bool wxTopLevelWindowMac::Show(bool show)
1044{
1045 if ( !wxWindow::Show(show) )
1046 return FALSE;
1047
1048 if (show)
1049 {
1050 ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowShowTransitionAction,nil);
1051 ::SelectWindow( (WindowRef)m_macWindow ) ;
1052 // no need to generate events here, they will get them triggered by macos
1053 // actually they should be , but apparently they are not
1054 wxSize size(m_width, m_height);
1055 wxSizeEvent event(size, m_windowId);
1056 event.SetEventObject(this);
1057 GetEventHandler()->ProcessEvent(event);
1058 }
1059 else
1060 {
1061 ::TransitionWindow((WindowRef)m_macWindow,kWindowZoomTransitionEffect,kWindowHideTransitionAction,nil);
1062 }
1063
1064 if ( !show )
1065 {
1066 }
1067 else
1068 {
1069 Refresh() ;
1070 }
1071
1072 return TRUE;
1073}
1074
1075void wxTopLevelWindowMac::DoMoveWindow(int x, int y, int width, int height)
1076{
1077 int former_x = m_x ;
1078 int former_y = m_y ;
1079 int former_w = m_width ;
1080 int former_h = m_height ;
1081
1082 int actualWidth = width;
1083 int actualHeight = height;
1084 int actualX = x;
1085 int actualY = y;
1086
1087 if ((m_minWidth != -1) && (actualWidth < m_minWidth))
1088 actualWidth = m_minWidth;
1089 if ((m_minHeight != -1) && (actualHeight < m_minHeight))
1090 actualHeight = m_minHeight;
1091 if ((m_maxWidth != -1) && (actualWidth > m_maxWidth))
1092 actualWidth = m_maxWidth;
1093 if ((m_maxHeight != -1) && (actualHeight > m_maxHeight))
1094 actualHeight = m_maxHeight;
1095
1096 bool doMove = false ;
1097 bool doResize = false ;
1098
1099 if ( actualX != former_x || actualY != former_y )
1100 {
1101 doMove = true ;
1102 }
1103 if ( actualWidth != former_w || actualHeight != former_h )
1104 {
1105 doResize = true ;
1106 }
1107
1108 if ( doMove || doResize )
1109 {
1110 m_x = actualX ;
1111 m_y = actualY ;
1112
1113 if ( doMove )
1114 ::MoveWindow((WindowRef)m_macWindow, m_x, m_y , false); // don't make frontmost
1115
1116 m_width = actualWidth ;
1117 m_height = actualHeight ;
1118
1119 if ( doResize )
1120 ::SizeWindow((WindowRef)m_macWindow, m_width, m_height , true);
1121
1122 // the OS takes care of invalidating and erasing the new area so we only have to
1123 // take care of refreshing for full repaints
1124
1125 if ( doResize && HasFlag(wxFULL_REPAINT_ON_RESIZE) )
1126 Refresh() ;
1127
1128
1129 if ( IsKindOf( CLASSINFO( wxFrame ) ) )
1130 {
1131 wxFrame* frame = (wxFrame*) this ;
1132#if wxUSE_STATUSBAR
1133 frame->PositionStatusBar();
1134#endif
1135#if wxUSE_TOOLBAR
1136 frame->PositionToolBar();
1137#endif
1138 }
1139 if ( doMove )
1140 wxWindowMac::MacTopLevelWindowChangedPosition() ; // like this only children will be notified
1141
1142 MacRepositionScrollBars() ;
1143 if ( doMove )
1144 {
1145 wxPoint point(m_x, m_y);
1146 wxMoveEvent event(point, m_windowId);
1147 event.SetEventObject(this);
1148 GetEventHandler()->ProcessEvent(event) ;
1149 }
1150 if ( doResize )
1151 {
1152 MacRepositionScrollBars() ;
1153 wxSize size(m_width, m_height);
1154 wxSizeEvent event(size, m_windowId);
1155 event.SetEventObject(this);
1156 GetEventHandler()->ProcessEvent(event);
1157 }
1158 }
1159
1160}
1161
1162/*
1163 * Invalidation Mechanism
1164 *
1165 * The update mechanism reflects exactely the windows mechanism
1166 * the rect gets added to the window invalidate region, if the eraseBackground flag
1167 * has been true for any part of the update rgn the background is erased in the entire region
1168 * not just in the specified rect.
1169 *
1170 * In order to achive this, we also have an internal m_macNoEraseUpdateRgn, all rects that have
1171 * the eraseBackground flag set to false are also added to this rgn. upon receiving an update event
1172 * the update rgn is compared to the m_macNoEraseUpdateRgn and in case they differ, every window
1173 * will get the eraseBackground event first
1174 */
1175
1176void wxTopLevelWindowMac::MacInvalidate( const WXRECTPTR rect, bool eraseBackground )
1177{
1178 GrafPtr formerPort ;
1179 GetPort( &formerPort ) ;
1180 SetPortWindowPort( (WindowRef)m_macWindow ) ;
1181
1182 m_macNeedsErasing |= eraseBackground ;
1183
1184 // if we already know that we will have to erase, there's no need to track the rest
1185 if ( !m_macNeedsErasing)
1186 {
1187 // we end only here if eraseBackground is false
1188 // if we already have a difference between m_macNoEraseUpdateRgn and UpdateRgn
1189 // we will have to erase anyway
1190
1191 RgnHandle updateRgn = NewRgn();
1192 RgnHandle diffRgn = NewRgn() ;
1193 if ( updateRgn && diffRgn )
1194 {
1195 GetWindowUpdateRgn( (WindowRef)m_macWindow , updateRgn );
1196 Point pt = {0,0} ;
1197 LocalToGlobal( &pt ) ;
1198 OffsetRgn( updateRgn , -pt.h , -pt.v ) ;
1199 DiffRgn( updateRgn , (RgnHandle) m_macNoEraseUpdateRgn , diffRgn ) ;
1200 if ( !EmptyRgn( diffRgn ) )
1201 {
1202 m_macNeedsErasing = true ;
1203 }
1204 }
1205 if ( updateRgn )
1206 DisposeRgn( updateRgn );
1207 if ( diffRgn )
1208 DisposeRgn( diffRgn );
1209
1210 if ( !m_macNeedsErasing )
1211 {
1212 RgnHandle rectRgn = NewRgn() ;
1213 SetRectRgn( rectRgn , ((Rect*)rect)->left , ((Rect*)rect)->top , ((Rect*)rect)->right , ((Rect*)rect)->bottom ) ;
1214 UnionRgn( (RgnHandle) m_macNoEraseUpdateRgn , rectRgn , (RgnHandle) m_macNoEraseUpdateRgn ) ;
1215 DisposeRgn( rectRgn ) ;
1216 }
1217 }
1218 InvalWindowRect( (WindowRef)m_macWindow , (Rect*)rect ) ;
1219 // turn this on to debug the refreshing cycle
1220#if wxMAC_DEBUG_REDRAW
1221 PaintRect( rect ) ;
1222#endif
1223 SetPort( formerPort ) ;
1224}
1225
1226
1227bool wxTopLevelWindowMac::SetShape(const wxRegion& region)
1228{
1229 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), FALSE,
1230 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1231
1232#if TARGET_CARBON
1233 // The empty region signifies that the shape should be removed from the
1234 // window.
1235 if ( region.IsEmpty() )
1236 {
1237 wxSize sz = GetClientSize();
1238 wxRegion rgn(0, 0, sz.x, sz.y);
1239 return SetShape(rgn);
1240 }
1241
1242 // Make a copy of the region
1243 RgnHandle shapeRegion = NewRgn();
1244 CopyRgn( (RgnHandle)region.GetWXHRGN(), shapeRegion );
1245
1246 // Dispose of any shape region we may already have
1247 RgnHandle oldRgn = (RgnHandle)GetWRefCon( (WindowRef)MacGetWindowRef() );
1248 if ( oldRgn )
1249 DisposeRgn(oldRgn);
1250
1251 // Save the region so we can use it later
1252 SetWRefCon((WindowRef)MacGetWindowRef(), (SInt32)shapeRegion);
1253
1254 // Tell the window manager that the window has changed shape
1255 ReshapeCustomWindow((WindowRef)MacGetWindowRef());
1256 return TRUE;
1257#else
1258 return FALSE;
1259#endif
1260}
1261
1262// ---------------------------------------------------------------------------
1263// Support functions for shaped windows, based on Apple's CustomWindow sample at
1264// http://developer.apple.com/samplecode/Sample_Code/Human_Interface_Toolbox/Mac_OS_High_Level_Toolbox/CustomWindow.htm
1265// ---------------------------------------------------------------------------
1266
1267#if TARGET_CARBON
1268
1269static void wxShapedMacWindowGetPos(WindowRef window, Rect* inRect)
1270{
1271 GetWindowPortBounds(window, inRect);
1272 Point pt = {inRect->left, inRect->top};
1273 SetPort((GrafPtr) GetWindowPort(window));
1274 LocalToGlobal(&pt);
1275 inRect->top = pt.v;
1276 inRect->left = pt.h;
1277 inRect->bottom += pt.v;
1278 inRect->right += pt.h;
1279}
1280
1281
1282static SInt32 wxShapedMacWindowGetFeatures(WindowRef window, SInt32 param)
1283{
1284 /*------------------------------------------------------
1285 Define which options your custom window supports.
1286 --------------------------------------------------------*/
1287 //just enable everything for our demo
1288 *(OptionBits*)param=//kWindowCanGrow|
1289 //kWindowCanZoom|
1290 //kWindowCanCollapse|
1291 //kWindowCanGetWindowRegion|
1292 //kWindowHasTitleBar|
1293 //kWindowSupportsDragHilite|
1294 kWindowCanDrawInCurrentPort|
1295 //kWindowCanMeasureTitle|
1296 kWindowWantsDisposeAtProcessDeath|
1297 kWindowSupportsSetGrowImageRegion|
1298 kWindowDefSupportsColorGrafPort;
1299 return 1;
1300}
1301
1302// The content region is left as a rectangle matching the window size, this is
1303// so the origin in the paint event, and etc. still matches what the
1304// programmer expects.
1305static void wxShapedMacWindowContentRegion(WindowRef window, RgnHandle rgn)
1306{
1307 SetEmptyRgn(rgn);
1308 wxTopLevelWindowMac* win = wxFindWinFromMacWindow(window);
1309 if (win)
1310 {
1311 wxRect r = win->GetRect();
1312 SetRectRgn(rgn, r.GetLeft(), r.GetTop(), r.GetRight(), r.GetBottom());
1313 }
1314}
1315
1316// The structure region is set to the shape given to the SetShape method.
1317static void wxShapedMacWindowStructureRegion(WindowRef window, RgnHandle rgn)
1318{
1319 RgnHandle cachedRegion = (RgnHandle) GetWRefCon(window);
1320
1321 SetEmptyRgn(rgn);
1322 if (cachedRegion)
1323 {
1324 Rect windowRect;
1325 wxShapedMacWindowGetPos(window, &windowRect); //how big is the window
1326 CopyRgn(cachedRegion, rgn); //make a copy of our cached region
1327 OffsetRgn(rgn, windowRect.left, windowRect.top); // position it over window
1328 //MapRgn(rgn, &mMaskSize, &windowRect); //scale it to our actual window size
1329 }
1330}
1331
1332
1333
1334static SInt32 wxShapedMacWindowGetRegion(WindowRef window, SInt32 param)
1335{
1336 GetWindowRegionPtr rgnRec=(GetWindowRegionPtr)param;
1337
1338 switch(rgnRec->regionCode)
1339 {
1340 case kWindowStructureRgn:
1341 wxShapedMacWindowStructureRegion(window, rgnRec->winRgn);
1342 break;
1343 case kWindowContentRgn:
1344 wxShapedMacWindowContentRegion(window, rgnRec->winRgn);
1345 break;
1346 default:
1347 SetEmptyRgn(rgnRec->winRgn);
1348 } //switch
1349
1350 return noErr;
1351}
1352
1353
1354static SInt32 wxShapedMacWindowHitTest(WindowRef window,SInt32 param)
1355{
1356 /*------------------------------------------------------
1357 Determine the region of the window which was hit
1358 --------------------------------------------------------*/
1359 Point hitPoint;
1360 static RgnHandle tempRgn=nil;
1361
1362 if(!tempRgn)
1363 tempRgn=NewRgn();
1364
1365 SetPt(&hitPoint,LoWord(param),HiWord(param));//get the point clicked
1366
1367 //Mac OS 8.5 or later
1368 wxShapedMacWindowStructureRegion(window, tempRgn);
1369 if (PtInRgn(hitPoint, tempRgn)) //in window content region?
1370 return wInContent;
1371
1372 return wNoHit;//no significant area was hit.
1373}
1374
1375
1376static pascal long wxShapedMacWindowDef(short varCode, WindowRef window, SInt16 message, SInt32 param)
1377{
1378 switch(message)
1379 {
1380 case kWindowMsgHitTest:
1381 return wxShapedMacWindowHitTest(window,param);
1382
1383 case kWindowMsgGetFeatures:
1384 return wxShapedMacWindowGetFeatures(window,param);
1385
1386 // kWindowMsgGetRegion is sent during CreateCustomWindow and ReshapeCustomWindow
1387 case kWindowMsgGetRegion:
1388 return wxShapedMacWindowGetRegion(window,param);
1389 }
1390
1391 return 0;
1392}
1393
1394#endif
1395// ---------------------------------------------------------------------------
1396
wxWidgets (Impactor)