?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / vcl / aqua / source / window / salframe.cxx
blobff635ffd82b39a235fdb55ab46b41cec0e67f3f5
1 /************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: salframe.cxx,v $
10 * $Revision: 1.69 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_vcl.hxx"
33
34 #include <string>
35
36 #include "saldata.hxx"
37 #include "salgdi.h"
38 #include "salframe.h"
39 #include "salmenu.h"
40 #include "saltimer.h"
41 #include "salinst.h"
42 #include "salframeview.h"
43 #include "aqua11yfactory.h"
44 #include "vcl/salwtype.hxx"
45 #include "vcl/window.hxx"
46 #include "vcl/timer.hxx"
47
48 #include "premac.h"
49 // needed for theming
50 // FIXME: move theming code to salnativewidgets.cxx
51 #include <Carbon/Carbon.h>
52 #include "postmac.h"
53
54 #include "boost/assert.hpp"
55 #include "vcl/svapp.hxx"
56 #include "rtl/ustrbuf.hxx"
57
58 #include <premac.h>
59 #include <CoreFoundation/CoreFoundation.h>
60 #include <postmac.h>
61
62 using namespace std;
63
64 // =======================================================================
65
66 AquaSalFrame* AquaSalFrame::s_pCaptureFrame = NULL;
67
68 // =======================================================================
69
70 AquaSalFrame::AquaSalFrame( SalFrame* pParent, ULONG salFrameStyle ) :
71 mpWindow(nil),
72 mpView(nil),
73 mpDockMenuEntry(nil),
74 mpGraphics(NULL),
75 mpParent(NULL),
76 mnMinWidth(0),
77 mnMinHeight(0),
78 mnMaxWidth(0),
79 mnMaxHeight(0),
80 mbGraphics(false),
81 mbFullScreen( false ),
82 mbShown(false),
83 mbInitShow(true),
84 mbPositioned(false),
85 mbSized(false),
86 mbPresentation( false ),
87 mnStyle( salFrameStyle ),
88 mnStyleMask( 0 ),
89 mnLastEventTime( 0 ),
90 mnLastModifierFlags( 0 ),
91 mpMenu( NULL ),
92 mnExtStyle( 0 ),
93 mePointerStyle( POINTER_ARROW ),
94 mnTrackingRectTag( 0 ),
95 mrClippingPath( 0 ),
96 mnICOptions( 0 )
97 {
98 maSysData.nSize = sizeof( SystemEnvData );
99
100 mpParent = dynamic_cast<AquaSalFrame*>(pParent);
101
102 initWindowAndView();
103
104 SalData* pSalData = GetSalData();
105 pSalData->maFrames.push_front( this );
106 pSalData->maFrameCheck.insert( this );
107 }
108
109 // -----------------------------------------------------------------------
110
111 AquaSalFrame::~AquaSalFrame()
112 {
113 // if the frame is destroyed and has the current menubar
114 // set the default menubar
115 if( mpMenu && mpMenu->mbMenuBar && AquaSalMenu::pCurrentMenuBar == mpMenu )
116 AquaSalMenu::setDefaultMenu();
117
118 // cleanup clipping stuff
119 ResetClipRegion();
120
121 [SalFrameView unsetMouseFrame: this];
122
123 SalData* pSalData = GetSalData();
124 pSalData->maFrames.remove( this );
125 pSalData->maFrameCheck.erase( this );
126
127 DBG_ASSERT( this != s_pCaptureFrame, "capture frame destroyed" );
128 if( this == s_pCaptureFrame )
129 s_pCaptureFrame = NULL;
130
131 if ( mpGraphics )
132 delete mpGraphics;
133
134 if( mpDockMenuEntry )
135 // life cycle comment: the menu has ownership of the item, so no release
136 [AquaSalInstance::GetDynamicDockMenu() removeItem: mpDockMenuEntry];
137 if ( mpView ) {
138 [AquaA11yFactory revokeView: mpView];
139 [mpView release];
140 }
141 if ( mpWindow )
142 [mpWindow release];
143 }
144
145 // -----------------------------------------------------------------------
146
147 void AquaSalFrame::initWindowAndView()
148 {
149 // initialize mirroring parameters
150 // FIXME: screens changing
151 NSScreen * pScreen = [mpWindow screen];
152 if( pScreen == nil )
153 pScreen = [NSScreen mainScreen];
154 maScreenRect = [pScreen frame];
155
156 // calculate some default geometry
157 NSRect aVisibleRect = [pScreen visibleFrame];
158 CocoaToVCL( aVisibleRect );
159
160 maGeometry.nX = static_cast<int>(aVisibleRect.origin.x + aVisibleRect.size.width / 10);
161 maGeometry.nY = static_cast<int>(aVisibleRect.origin.y + aVisibleRect.size.height / 10);
162 maGeometry.nWidth = static_cast<unsigned int>(aVisibleRect.size.width * 0.8);
163 maGeometry.nHeight = static_cast<unsigned int>(aVisibleRect.size.height * 0.8);
164
165 // calculate style mask
166 if( (mnStyle & SAL_FRAME_STYLE_FLOAT) ||
167 (mnStyle & SAL_FRAME_STYLE_OWNERDRAWDECORATION) )
168 mnStyleMask = NSBorderlessWindowMask;
169 else if( mnStyle & SAL_FRAME_STYLE_DEFAULT )
170 {
171 mnStyleMask = NSTitledWindowMask |
172 NSMiniaturizableWindowMask |
173 NSResizableWindowMask |
174 NSClosableWindowMask;
175 // make default window "maximized"
176 maGeometry.nX = static_cast<int>(aVisibleRect.origin.x);
177 maGeometry.nY = static_cast<int>(aVisibleRect.origin.y);
178 maGeometry.nWidth = static_cast<int>(aVisibleRect.size.width);
179 maGeometry.nHeight = static_cast<int>(aVisibleRect.size.height);
180 mbPositioned = mbSized = true;
181 }
182 else
183 {
184 if( (mnStyle & SAL_FRAME_STYLE_MOVEABLE) )
185 {
186 mnStyleMask |= NSTitledWindowMask;
187 if( mpParent == NULL )
188 mnStyleMask |= NSMiniaturizableWindowMask;
189 }
190 if( (mnStyle & SAL_FRAME_STYLE_SIZEABLE) )
191 mnStyleMask |= NSResizableWindowMask;
192 if( (mnStyle & SAL_FRAME_STYLE_CLOSEABLE) )
193 mnStyleMask |= NSClosableWindowMask;
194 // documentation says anything other than NSBorderlessWindowMask (=0)
195 // should also include NSTitledWindowMask;
196 if( mnStyleMask != 0 )
197 mnStyleMask |= NSTitledWindowMask;
198 }
199
200 mpWindow = [[SalFrameWindow alloc] initWithSalFrame: this];
201 mpView = [[SalFrameView alloc] initWithSalFrame: this];
202 if( (mnStyle & SAL_FRAME_STYLE_TOOLTIP) )
203 [mpWindow setIgnoresMouseEvents: YES];
204 else
205 [mpWindow setAcceptsMouseMovedEvents: YES];
206 [mpWindow setHasShadow: YES];
207 [mpWindow setDelegate: mpWindow];
208
209 NSRect aRect = { { 0,0 }, { maGeometry.nWidth, maGeometry.nHeight } };
210 mnTrackingRectTag = [mpView addTrackingRect: aRect owner: mpView userData: nil assumeInside: NO];
211
212 maSysData.pView = mpView;
213
214 UpdateFrameGeometry();
215
216 // setContentView causes a display; in multithreaded use this can deadlock
217 //YieldMutexReleaser aRel;
218 [mpWindow setContentView: mpView];
219 }
220
221 // -----------------------------------------------------------------------
222
223 void AquaSalFrame::CocoaToVCL( NSRect& io_rRect, bool bRelativeToScreen )
224 {
225 if( bRelativeToScreen )
226 io_rRect.origin.y = maScreenRect.size.height - (io_rRect.origin.y+io_rRect.size.height);
227 else
228 io_rRect.origin.y = maGeometry.nHeight - (io_rRect.origin.y+io_rRect.size.height);
229 }
230
231 void AquaSalFrame::VCLToCocoa( NSRect& io_rRect, bool bRelativeToScreen )
232 {
233 if( bRelativeToScreen )
234 io_rRect.origin.y = maScreenRect.size.height - (io_rRect.origin.y+io_rRect.size.height);
235 else
236 io_rRect.origin.y = maGeometry.nHeight - (io_rRect.origin.y+io_rRect.size.height);
237 }
238
239 void AquaSalFrame::CocoaToVCL( NSPoint& io_rPoint, bool bRelativeToScreen )
240 {
241 if( bRelativeToScreen )
242 io_rPoint.y = maScreenRect.size.height - io_rPoint.y;
243 else
244 io_rPoint.y = maGeometry.nHeight - io_rPoint.y;
245 }
246
247 void AquaSalFrame::VCLToCocoa( NSPoint& io_rPoint, bool bRelativeToScreen )
248 {
249 if( bRelativeToScreen )
250 io_rPoint.y = maScreenRect.size.height - io_rPoint.y;
251 else
252 io_rPoint.y = maGeometry.nHeight - io_rPoint.y;
253 }
254
255 // -----------------------------------------------------------------------
256
257 void AquaSalFrame::screenParametersChanged()
258 {
259 UpdateFrameGeometry();
260
261 if( mpGraphics )
262 mpGraphics->updateResolution();
263 CallCallback( SALEVENT_DISPLAYCHANGED, 0 );
264 }
265
266 // -----------------------------------------------------------------------
267
268 SalGraphics* AquaSalFrame::GetGraphics()
269 {
270 if ( mbGraphics )
271 return NULL;
272
273 if ( !mpGraphics )
274 {
275 mpGraphics = new AquaSalGraphics;
276 mpGraphics->SetWindowGraphics( this );
277 }
278
279 mbGraphics = TRUE;
280 return mpGraphics;
281 }
282
283 // -----------------------------------------------------------------------
284
285 void AquaSalFrame::ReleaseGraphics( SalGraphics *pGraphics )
286 {
287 DBG_ASSERT( pGraphics == mpGraphics, "graphics released on wrong frame" );
288 mbGraphics = FALSE;
289 }
290
291 // -----------------------------------------------------------------------
292
293 BOOL AquaSalFrame::PostEvent( void *pData )
294 {
295 GetSalData()->mpFirstInstance->PostUserEvent( this, SALEVENT_USEREVENT, pData );
296 return TRUE;
297 }
298
299 // -----------------------------------------------------------------------
300 void AquaSalFrame::SetTitle(const XubString& rTitle)
301 {
302 NSString* pTitle = CreateNSString( rTitle );
303 [mpWindow setTitle: pTitle];
304
305 // create an entry in the dock menu
306 const ULONG nAppWindowStyle = (SAL_FRAME_STYLE_CLOSEABLE | SAL_FRAME_STYLE_MOVEABLE);
307 if( mpParent == NULL &&
308 (mnStyle & nAppWindowStyle) == nAppWindowStyle )
309 {
310 if( mpDockMenuEntry == NULL )
311 {
312 NSMenu* pDock = AquaSalInstance::GetDynamicDockMenu();
313 mpDockMenuEntry = [pDock insertItemWithTitle: pTitle
314 action: @selector(dockMenuItemTriggered:)
315 keyEquivalent: @""
316 atIndex: 0];
317 [mpDockMenuEntry setTarget: mpWindow];
318
319 // TODO: image (either the generic window image or an icon
320 // check mark (for "main" window ?)
321 }
322 else
323 [mpDockMenuEntry setTitle: pTitle];
324 }
325
326 if (pTitle)
327 [pTitle release];
328 }
329
330 // -----------------------------------------------------------------------
331
332 void AquaSalFrame::SetIcon( USHORT nIcon )
333 {
334 }
335
336 // -----------------------------------------------------------------------
337
338 void AquaSalFrame::initShow()
339 {
340 mbInitShow = false;
341 if( ! mbPositioned && ! mbFullScreen )
342 {
343 Rectangle aScreenRect;
344 GetWorkArea( aScreenRect );
345 if( mpParent ) // center relative to parent
346 {
347 // center on parent
348 long nNewX = mpParent->maGeometry.nX + (mpParent->maGeometry.nWidth - maGeometry.nWidth)/2;
349 if( nNewX < aScreenRect.Left() )
350 nNewX = aScreenRect.Left();
351 if( long(nNewX + maGeometry.nWidth) > aScreenRect.Right() )
352 nNewX = aScreenRect.Right() - maGeometry.nWidth-1;
353 long nNewY = mpParent->maGeometry.nY + (mpParent->maGeometry.nHeight - maGeometry.nHeight)/2;
354 if( nNewY < aScreenRect.Top() )
355 nNewY = aScreenRect.Top();
356 if( nNewY > aScreenRect.Bottom() )
357 nNewY = aScreenRect.Bottom() - maGeometry.nHeight-1;
358 SetPosSize( nNewX - mpParent->maGeometry.nX,
359 nNewY - mpParent->maGeometry.nY,
360 0, 0, SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y );
361 }
362 else if( ! (mnStyle & SAL_FRAME_STYLE_SIZEABLE) )
363 {
364 // center on screen
365 long nNewX = (aScreenRect.GetWidth() - maGeometry.nWidth)/2;
366 long nNewY = (aScreenRect.GetHeight() - maGeometry.nHeight)/2;
367 SetPosSize( nNewX, nNewY, 0, 0, SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y );
368 }
369 }
370
371 // make sure the view is present in the wrapper list before any children receive focus
372 [AquaA11yFactory registerView: mpView];
373 }
374
375 void AquaSalFrame::SendPaintEvent( const Rectangle* pRect )
376 {
377 SalPaintEvent aPaintEvt( 0, 0, maGeometry.nWidth, maGeometry.nHeight, true );
378 if( pRect )
379 {
380 aPaintEvt.mnBoundX = pRect->Left();
381 aPaintEvt.mnBoundY = pRect->Top();
382 aPaintEvt.mnBoundWidth = pRect->GetWidth();
383 aPaintEvt.mnBoundHeight = pRect->GetHeight();
384 }
385
386 CallCallback(SALEVENT_PAINT, &aPaintEvt);
387 }
388
389 // -----------------------------------------------------------------------
390
391 void AquaSalFrame::Show(BOOL bVisible, BOOL bNoActivate)
392 {
393 mbShown = bVisible;
394 if(bVisible)
395 {
396 if( mbInitShow )
397 initShow();
398
399 CallCallback(SALEVENT_RESIZE, 0);
400 // trigger filling our backbuffer
401 SendPaintEvent();
402
403 //YieldMutexReleaser aRel;
404
405 if( bNoActivate || [mpWindow canBecomeKeyWindow] == NO )
406 [mpWindow orderFront: NSApp];
407 else
408 [mpWindow makeKeyAndOrderFront: NSApp];
409
410 if( mpParent )
411 {
412 /* #i92674# #i96433# we do not want an invisible parent to show up (which adding a visible
413 child implicitly does). However we also do not want a parentless toolbar.
414
415 HACK: try to decide when we should not insert a child to its parent
416 floaters and ownerdraw windows have not yet shown up in cases where
417 we don't want the parent to become visible
418 */
419 if( mpParent->mbShown || (mnStyle & (SAL_FRAME_STYLE_OWNERDRAWDECORATION | SAL_FRAME_STYLE_FLOAT) ) )
420 {
421 [mpParent->mpWindow addChildWindow: mpWindow ordered: NSWindowAbove];
422 }
423 }
424
425 if( mbPresentation )
426 [mpWindow makeMainWindow];
427 }
428 else
429 {
430 // if the frame holding the current menubar gets hidden
431 // show the default menubar
432 if( mpMenu && mpMenu->mbMenuBar && AquaSalMenu::pCurrentMenuBar == mpMenu )
433 AquaSalMenu::setDefaultMenu();
434
435 //YieldMutexReleaser aRel;
436
437 // #i90440# #i94443# work around the focus going back to some other window
438 // if a child gets hidden for a parent window
439 if( mpParent && mpParent->mbShown && [mpWindow isKeyWindow] )
440 [mpParent->mpWindow makeKeyAndOrderFront: NSApp];
441
442 [SalFrameView unsetMouseFrame: this];
443 if( mpParent && [mpWindow parentWindow] == mpParent->mpWindow )
444 [mpParent->mpWindow removeChildWindow: mpWindow];
445
446 [mpWindow orderOut: NSApp];
447 }
448 }
449
450 // -----------------------------------------------------------------------
451
452 void AquaSalFrame::Enable( BOOL bEnable )
453 {
454 }
455
456 // -----------------------------------------------------------------------
457
458 void AquaSalFrame::SetMinClientSize( long nWidth, long nHeight )
459 {
460 mnMinWidth = nWidth;
461 mnMinHeight = nHeight;
462
463 if( mpWindow )
464 {
465 // Always add the decoration as the dimension concerns only
466 // the content rectangle
467 nWidth += maGeometry.nLeftDecoration + maGeometry.nRightDecoration;
468 nHeight += maGeometry.nTopDecoration + maGeometry.nBottomDecoration;
469
470 NSSize aSize = { nWidth, nHeight };
471
472 // Size of full window (content+structure) although we only
473 // have the client size in arguments
474 [mpWindow setMinSize: aSize];
475 }
476 }
477
478 // -----------------------------------------------------------------------
479
480 void AquaSalFrame::SetMaxClientSize( long nWidth, long nHeight )
481 {
482 mnMaxWidth = nWidth;
483 mnMaxHeight = nHeight;
484
485 if( mpWindow )
486 {
487 // Always add the decoration as the dimension concerns only
488 // the content rectangle
489 nWidth += maGeometry.nLeftDecoration + maGeometry.nRightDecoration;
490 nHeight += maGeometry.nTopDecoration + maGeometry.nBottomDecoration;
491
492 // Carbon windows can't have a size greater than 32767x32767
493 if (nWidth>32767) nWidth=32767;
494 if (nHeight>32767) nHeight=32767;
495
496 NSSize aSize = { nWidth, nHeight };
497
498 // Size of full window (content+structure) although we only
499 // have the client size in arguments
500 [mpWindow setMaxSize: aSize];
501 }
502 }
503
504 // -----------------------------------------------------------------------
505
506 void AquaSalFrame::SetClientSize( long nWidth, long nHeight )
507 {
508 if( mpWindow )
509 {
510 NSSize aSize = { nWidth, nHeight };
511
512 [mpWindow setContentSize: aSize];
513 UpdateFrameGeometry();
514 if( mbShown )
515 // trigger filling our backbuffer
516 SendPaintEvent();
517 }
518 }
519
520 // -----------------------------------------------------------------------
521
522 void AquaSalFrame::GetClientSize( long& rWidth, long& rHeight )
523 {
524 if( mbShown || mbInitShow )
525 {
526 rWidth = maGeometry.nWidth;
527 rHeight = maGeometry.nHeight;
528 }
529 else
530 {
531 rWidth = 0;
532 rHeight = 0;
533 }
534 }
535
536 // -----------------------------------------------------------------------
537
538 void AquaSalFrame::SetWindowState( const SalFrameState* pState )
539 {
540 // set normal state
541 NSRect aStateRect = [mpWindow frame];
542 aStateRect = [NSWindow contentRectForFrameRect: aStateRect styleMask: mnStyleMask];
543 CocoaToVCL( aStateRect );
544 if( pState->mnMask & SAL_FRAMESTATE_MASK_X )
545 aStateRect.origin.x = float(pState->mnX);
546 if( pState->mnMask & SAL_FRAMESTATE_MASK_Y )
547 aStateRect.origin.y = float(pState->mnY);
548 if( pState->mnMask & SAL_FRAMESTATE_MASK_WIDTH )
549 aStateRect.size.width = float(pState->mnWidth);
550 if( pState->mnMask & SAL_FRAMESTATE_MASK_HEIGHT )
551 aStateRect.size.height = float(pState->mnHeight);
552 VCLToCocoa( aStateRect );
553 aStateRect = [NSWindow frameRectForContentRect: aStateRect styleMask: mnStyleMask];
554
555 // relase and acquire mutex again since this call can block waiting for an internal lock
556 {
557 //YieldMutexReleaser aRel;
558 [mpWindow setFrame: aStateRect display: NO];
559 }
560
561 // FIXME: HTH maximized state ?
562
563 // get new geometry
564 UpdateFrameGeometry();
565
566 USHORT nEvent = 0;
567 if( pState->mnMask & (SAL_FRAMESTATE_MASK_X | SAL_FRAMESTATE_MASK_X) )
568 {
569 mbPositioned = true;
570 nEvent = SALEVENT_MOVE;
571 }
572
573 if( pState->mnMask & (SAL_FRAMESTATE_MASK_WIDTH | SAL_FRAMESTATE_MASK_HEIGHT) )
574 {
575 mbSized = true;
576 nEvent = (nEvent == SALEVENT_MOVE) ? SALEVENT_MOVERESIZE : SALEVENT_RESIZE;
577 }
578 // send event that we were moved/sized
579 if( nEvent )
580 CallCallback( nEvent, NULL );
581
582 if( mbShown )
583 {
584 // trigger filling our backbuffer
585 SendPaintEvent();
586
587 // tell the system the views need to be updated
588 //YieldMutexReleaser aRel;
589
590 [mpWindow display];
591 }
592 }
593
594 // -----------------------------------------------------------------------
595
596 BOOL AquaSalFrame::GetWindowState( SalFrameState* pState )
597 {
598 pState->mnMask = SAL_FRAMESTATE_MASK_X |
599 SAL_FRAMESTATE_MASK_Y |
600 SAL_FRAMESTATE_MASK_WIDTH |
601 SAL_FRAMESTATE_MASK_HEIGHT |
602 #if 0
603 SAL_FRAMESTATE_MASK_MAXIMIZED_X |
604 SAL_FRAMESTATE_MASK_MAXIMIZED_Y |
605 SAL_FRAMESTATE_MASK_MAXIMIZED_WIDTH |
606 SAL_FRAMESTATE_MASK_MAXIMIZED_HEIGHT |
607 #endif
608 SAL_FRAMESTATE_MASK_STATE;
609
610 NSRect aStateRect = [mpWindow frame];
611 aStateRect = [NSWindow contentRectForFrameRect: aStateRect styleMask: mnStyleMask];
612 CocoaToVCL( aStateRect );
613 pState->mnX = long(aStateRect.origin.x);
614 pState->mnY = long(aStateRect.origin.y);
615 pState->mnWidth = long(aStateRect.size.width);
616 pState->mnHeight = long(aStateRect.size.height);
617
618 // FIXME: HTH maximized state ?
619
620 if( [mpWindow isMiniaturized] )
621 pState->mnState = SAL_FRAMESTATE_MINIMIZED;
622 else if( ! [mpWindow isZoomed] )
623 pState->mnState = SAL_FRAMESTATE_NORMAL;
624 else
625 pState->mnState = SAL_FRAMESTATE_MAXIMIZED;
626
627 return TRUE;
628 }
629
630 // -----------------------------------------------------------------------
631
632 void AquaSalFrame::SetScreenNumber(unsigned int nScreen)
633 {
634 NSArray* pScreens = [NSScreen screens];
635 Rectangle aRet;
636 NSScreen* pScreen = nil;
637 if( pScreens && nScreen < [pScreens count] )
638 {
639 // get new screen frame
640 pScreen = [pScreens objectAtIndex: nScreen];
641 NSRect aNewScreen = [pScreen frame];
642
643 // get current screen frame
644 pScreen = [mpWindow screen];
645 if( pScreen )
646 {
647 NSRect aCurScreen = [pScreen frame];
648 if( aCurScreen.origin.x != aNewScreen.origin.x ||
649 aCurScreen.origin.y != aNewScreen.origin.y )
650 {
651 NSRect aFrameRect = [mpWindow frame];
652 aFrameRect.origin.x += aNewScreen.origin.x - aCurScreen.origin.x;
653 aFrameRect.origin.y += aNewScreen.origin.y - aCurScreen.origin.y;
654 [mpWindow setFrame: aFrameRect display: NO];
655 UpdateFrameGeometry();
656 }
657 }
658 }
659 }
660
661 // -----------------------------------------------------------------------
662
663 void AquaSalFrame::ShowFullScreen( BOOL bFullScreen, sal_Int32 nDisplay )
664 {
665 if( mbFullScreen == bFullScreen )
666 return;
667
668 mbFullScreen = bFullScreen;
669 if( bFullScreen )
670 {
671 // hide the dock and the menubar if we are on the menu screen
672 // which is always on index 0 according to documentation
673 bool bHideMenu = (nDisplay == 0);
674
675 NSRect aNewContentRect = { { 0, 0 }, { 0, 0 } };
676 // get correct screen
677 NSScreen* pScreen = nil;
678 NSArray* pScreens = [NSScreen screens];
679 if( pScreens )
680 {
681 if( nDisplay >= 0 && (unsigned int)nDisplay < [pScreens count] )
682 pScreen = [pScreens objectAtIndex: nDisplay];
683 else
684 {
685 // this means span all screens
686 bHideMenu = true;
687 NSEnumerator* pEnum = [pScreens objectEnumerator];
688 while( (pScreen = [pEnum nextObject]) != nil )
689 {
690 NSRect aScreenRect = [pScreen frame];
691 if( aScreenRect.origin.x < aNewContentRect.origin.x )
692 {
693 aNewContentRect.size.width += aNewContentRect.origin.x - aScreenRect.origin.x;
694 aNewContentRect.origin.x = aScreenRect.origin.x;
695 }
696 if( aScreenRect.origin.y < aNewContentRect.origin.y )
697 {
698 aNewContentRect.size.height += aNewContentRect.origin.y - aScreenRect.origin.y;
699 aNewContentRect.origin.y = aScreenRect.origin.y;
700 }
701 if( aScreenRect.origin.x + aScreenRect.size.width > aNewContentRect.origin.x + aNewContentRect.size.width )
702 aNewContentRect.size.width = aScreenRect.origin.x + aScreenRect.size.width - aNewContentRect.origin.x;
703 if( aScreenRect.origin.y + aScreenRect.size.height > aNewContentRect.origin.y + aNewContentRect.size.height )
704 aNewContentRect.size.height = aScreenRect.origin.y + aScreenRect.size.height - aNewContentRect.origin.y;
705 }
706 }
707 }
708 if( aNewContentRect.size.width == 0 && aNewContentRect.size.height == 0 )
709 {
710 if( pScreen == nil )
711 pScreen = [mpWindow screen];
712 if( pScreen == nil )
713 pScreen = [NSScreen mainScreen];
714
715 aNewContentRect = [pScreen frame];
716 }
717
718 if( bHideMenu )
719 [NSMenu setMenuBarVisible:NO];
720
721 maFullScreenRect = [mpWindow frame];
722 {
723 //YieldMutexReleaser aRel;
724 [mpWindow setFrame: [NSWindow frameRectForContentRect: aNewContentRect styleMask: mnStyleMask] display: mbShown ? YES : NO];
725 }
726
727 UpdateFrameGeometry();
728
729 if( mbShown )
730 CallCallback( SALEVENT_MOVERESIZE, NULL );
731 }
732 else
733 {
734 {
735 //YieldMutexReleaser aRel;
736 [mpWindow setFrame: maFullScreenRect display: mbShown ? YES : NO];
737 }
738 UpdateFrameGeometry();
739
740 if( mbShown )
741 CallCallback( SALEVENT_MOVERESIZE, NULL );
742
743 // show the dock and the menubar
744 [NSMenu setMenuBarVisible:YES];
745 }
746 if( mbShown )
747 // trigger filling our backbuffer
748 SendPaintEvent();
749 }
750
751 // -----------------------------------------------------------------------
752
753 class PreventSleepTimer : public AutoTimer
754 {
755 public:
756 PreventSleepTimer()
757 {
758 SetTimeout( 30000 );
759 Start();
760 }
761
762 virtual ~PreventSleepTimer()
763 {
764 }
765
766 virtual void Timeout()
767 {
768 UpdateSystemActivity(OverallAct);
769 }
770 };
771
772 void AquaSalFrame::StartPresentation( BOOL bStart )
773 {
774 if( bStart )
775 {
776 mpActivityTimer.reset( new PreventSleepTimer() );
777 [mpWindow setLevel: NSScreenSaverWindowLevel];
778 if( mbShown )
779 [mpWindow makeMainWindow];
780 }
781 else
782 {
783 mpActivityTimer.reset();
784 [mpWindow setLevel: NSNormalWindowLevel];
785 }
786 }
787
788 // -----------------------------------------------------------------------
789
790 void AquaSalFrame::SetAlwaysOnTop( BOOL bOnTop )
791 {
792 }
793
794 // -----------------------------------------------------------------------
795
796 void AquaSalFrame::ToTop(USHORT nFlags)
797 {
798 if( ! (nFlags & SAL_FRAME_TOTOP_RESTOREWHENMIN) )
799 {
800 if( ! [mpWindow isVisible] || [mpWindow isMiniaturized] )
801 return;
802 }
803 if( nFlags & SAL_FRAME_TOTOP_GRABFOCUS )
804 [mpWindow makeKeyAndOrderFront: NSApp];
805 else
806 [mpWindow orderFront: NSApp];
807 }
808
809 // -----------------------------------------------------------------------
810
811 NSCursor* AquaSalFrame::getCurrentCursor() const
812 {
813 NSCursor* pCursor = nil;
814 switch( mePointerStyle )
815 {
816 case POINTER_TEXT: pCursor = [NSCursor IBeamCursor]; break;
817 case POINTER_CROSS: pCursor = [NSCursor crosshairCursor]; break;
818 case POINTER_HAND:
819 case POINTER_MOVE: pCursor = [NSCursor openHandCursor]; break;
820 case POINTER_NSIZE: pCursor = [NSCursor resizeUpCursor]; break;
821 case POINTER_SSIZE: pCursor = [NSCursor resizeDownCursor]; break;
822 case POINTER_ESIZE: pCursor = [NSCursor resizeRightCursor]; break;
823 case POINTER_WSIZE: pCursor = [NSCursor resizeLeftCursor]; break;
824 case POINTER_ARROW: pCursor = [NSCursor arrowCursor]; break;
825 case POINTER_VSPLIT:
826 case POINTER_VSIZEBAR:
827 case POINTER_WINDOW_NSIZE:
828 case POINTER_WINDOW_SSIZE:
829 pCursor = [NSCursor resizeUpDownCursor]; break;
830 case POINTER_HSPLIT:
831 case POINTER_HSIZEBAR:
832 case POINTER_WINDOW_ESIZE:
833 case POINTER_WINDOW_WSIZE:
834 pCursor = [NSCursor resizeLeftRightCursor]; break;
835 case POINTER_REFHAND: pCursor = [NSCursor pointingHandCursor]; break;
836
837 default:
838 pCursor = GetSalData()->getCursor( mePointerStyle );
839 if( pCursor == nil )
840 {
841 DBG_ERROR( "unmapped cursor" );
842 pCursor = [NSCursor arrowCursor];
843 }
844 break;
845 }
846 return pCursor;
847 }
848
849 void AquaSalFrame::SetPointer( PointerStyle ePointerStyle )
850 {
851 if( ePointerStyle >= POINTER_COUNT || ePointerStyle == mePointerStyle )
852 return;
853 mePointerStyle = ePointerStyle;
854
855 [mpWindow invalidateCursorRectsForView: mpView];
856 }
857
858 // -----------------------------------------------------------------------
859
860 void AquaSalFrame::SetPointerPos( long nX, long nY )
861 {
862 // FIXME: use Cocoa functions
863
864 // FIXME: multiscreen support
865 CGPoint aPoint = { nX + maGeometry.nX, nY + maGeometry.nY };
866 CGDirectDisplayID mainDisplayID = CGMainDisplayID();
867 CGDisplayMoveCursorToPoint( mainDisplayID, aPoint );
868 }
869
870 // -----------------------------------------------------------------------
871
872 void AquaSalFrame::Flush( void )
873 {
874 if( !(mbGraphics && mpGraphics && mpView && mbShown) )
875 return;
876
877 [mpView setNeedsDisplay: YES];
878
879 // outside of the application's event loop (e.g. IntroWindow)
880 // nothing would trigger paint event handling
881 // => fall back to synchronous painting
882 if( ImplGetSVData()->maAppData.mnDispatchLevel <= 0 )
883 {
884 [mpView display];
885 }
886 }
887
888 // -----------------------------------------------------------------------
889
890 void AquaSalFrame::Flush( const Rectangle& rRect )
891 {
892 if( !(mbGraphics && mpGraphics && mpView && mbShown) )
893 return;
894
895 NSRect aNSRect = { {rRect.Left(), rRect.Top()}, { rRect.GetWidth(), rRect.GetHeight() } };
896 VCLToCocoa( aNSRect, false );
897 [mpView setNeedsDisplayInRect: aNSRect];
898
899 // outside of the application's event loop (e.g. IntroWindow)
900 // nothing would trigger paint event handling
901 // => fall back to synchronous painting
902 if( ImplGetSVData()->maAppData.mnDispatchLevel <= 0 )
903 {
904 [mpView display];
905 }
906 }
907
908 // -----------------------------------------------------------------------
909
910 void AquaSalFrame::Sync()
911 {
912 if( mbGraphics && mpGraphics && mpView && mbShown )
913 {
914 //YieldMutexReleaser aRel;
915
916 [mpView setNeedsDisplay: YES];
917 [mpView display];
918 }
919 }
920
921 // -----------------------------------------------------------------------
922
923 void AquaSalFrame::SetInputContext( SalInputContext* pContext )
924 {
925 if (!pContext)
926 {
927 mnICOptions = 0;
928 return;
929 }
930
931 mnICOptions = pContext->mnOptions;
932
933 if(!(pContext->mnOptions & SAL_INPUTCONTEXT_TEXT))
934 return;
935 }
936
937 // -----------------------------------------------------------------------
938
939 void AquaSalFrame::EndExtTextInput( USHORT nFlags )
940 {
941 }
942
943 // -----------------------------------------------------------------------
944
945 XubString AquaSalFrame::GetKeyName( USHORT nKeyCode )
946 {
947 static std::map< USHORT, rtl::OUString > aKeyMap;
948 if( aKeyMap.empty() )
949 {
950 USHORT i;
951 for( i = KEY_A; i <= KEY_Z; i++ )
952 aKeyMap[ i ] = rtl::OUString( sal_Unicode( 'A' + (i - KEY_A) ) );
953 for( i = KEY_0; i <= KEY_9; i++ )
954 aKeyMap[ i ] = rtl::OUString( sal_Unicode( '0' + (i - KEY_0) ) );
955 for( i = KEY_F1; i <= KEY_F26; i++ )
956 {
957 rtl::OUStringBuffer aKey( 3 );
958 aKey.append( sal_Unicode( 'F' ) );
959 aKey.append( sal_Int32( i - KEY_F1 + 1 ) );
960 aKeyMap[ i ] = aKey.makeStringAndClear();
961 }
962
963 aKeyMap[ KEY_DOWN ] = rtl::OUString( sal_Unicode( 0x21e3 ) );
964 aKeyMap[ KEY_UP ] = rtl::OUString( sal_Unicode( 0x21e1 ) );
965 aKeyMap[ KEY_LEFT ] = rtl::OUString( sal_Unicode( 0x21e0 ) );
966 aKeyMap[ KEY_RIGHT ] = rtl::OUString( sal_Unicode( 0x21e2 ) );
967 aKeyMap[ KEY_HOME ] = rtl::OUString( sal_Unicode( 0x2196 ) );
968 aKeyMap[ KEY_END ] = rtl::OUString( sal_Unicode( 0x2198 ) );
969 aKeyMap[ KEY_PAGEUP ] = rtl::OUString( sal_Unicode( 0x21de ) );
970 aKeyMap[ KEY_PAGEDOWN ] = rtl::OUString( sal_Unicode( 0x21df ) );
971 aKeyMap[ KEY_RETURN ] = rtl::OUString( sal_Unicode( 0x21a9 ) );
972 aKeyMap[ KEY_ESCAPE ] = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "esc" ) );
973 aKeyMap[ KEY_TAB ] = rtl::OUString( sal_Unicode( 0x21e5 ) );
974 aKeyMap[ KEY_BACKSPACE ]= rtl::OUString( sal_Unicode( 0x232b ) );
975 aKeyMap[ KEY_SPACE ] = rtl::OUString( sal_Unicode( 0x2423 ) );
976 aKeyMap[ KEY_DELETE ] = rtl::OUString( sal_Unicode( 0x2326 ) );
977 aKeyMap[ KEY_ADD ] = rtl::OUString( sal_Unicode( '+' ) );
978 aKeyMap[ KEY_SUBTRACT ] = rtl::OUString( sal_Unicode( '-' ) );
979 aKeyMap[ KEY_DIVIDE ] = rtl::OUString( sal_Unicode( '/' ) );
980 aKeyMap[ KEY_MULTIPLY ] = rtl::OUString( sal_Unicode( '*' ) );
981 aKeyMap[ KEY_POINT ] = rtl::OUString( sal_Unicode( '.' ) );
982 aKeyMap[ KEY_COMMA ] = rtl::OUString( sal_Unicode( ',' ) );
983 aKeyMap[ KEY_LESS ] = rtl::OUString( sal_Unicode( '<' ) );
984 aKeyMap[ KEY_GREATER ] = rtl::OUString( sal_Unicode( '>' ) );
985 aKeyMap[ KEY_EQUAL ] = rtl::OUString( sal_Unicode( '=' ) );
986 aKeyMap[ KEY_OPEN ] = rtl::OUString( sal_Unicode( 0x23cf ) );
987
988 /* yet unmapped KEYCODES:
989 aKeyMap[ KEY_INSERT ] = rtl::OUString( sal_Unicode( ) );
990 aKeyMap[ KEY_CUT ] = rtl::OUString( sal_Unicode( ) );
991 aKeyMap[ KEY_COPY ] = rtl::OUString( sal_Unicode( ) );
992 aKeyMap[ KEY_PASTE ] = rtl::OUString( sal_Unicode( ) );
993 aKeyMap[ KEY_UNDO ] = rtl::OUString( sal_Unicode( ) );
994 aKeyMap[ KEY_REPEAT ] = rtl::OUString( sal_Unicode( ) );
995 aKeyMap[ KEY_FIND ] = rtl::OUString( sal_Unicode( ) );
996 aKeyMap[ KEY_PROPERTIES ] = rtl::OUString( sal_Unicode( ) );
997 aKeyMap[ KEY_FRONT ] = rtl::OUString( sal_Unicode( ) );
998 aKeyMap[ KEY_CONTEXTMENU ] = rtl::OUString( sal_Unicode( ) );
999 aKeyMap[ KEY_MENU ] = rtl::OUString( sal_Unicode( ) );
1000 aKeyMap[ KEY_HELP ] = rtl::OUString( sal_Unicode( ) );
1001 aKeyMap[ KEY_HANGUL_HANJA ] = rtl::OUString( sal_Unicode( ) );
1002 aKeyMap[ KEY_DECIMAL ] = rtl::OUString( sal_Unicode( ) );
1003 aKeyMap[ KEY_TILDE ] = rtl::OUString( sal_Unicode( ) );
1004 aKeyMap[ KEY_QUOTELEFT ]= rtl::OUString( sal_Unicode( ) );
1005 */
1006
1007 }
1008
1009 rtl::OUStringBuffer aResult( 16 );
1010
1011 USHORT nUnmodifiedCode = (nKeyCode & KEY_CODE);
1012 std::map< USHORT, rtl::OUString >::const_iterator it = aKeyMap.find( nUnmodifiedCode );
1013 if( it != aKeyMap.end() )
1014 {
1015 if( (nKeyCode & KEY_SHIFT) != 0 )
1016 aResult.append( sal_Unicode( 0x21e7 ) );
1017 if( (nKeyCode & KEY_MOD1) != 0 )
1018 aResult.append( sal_Unicode( 0x2318 ) );
1019 // we do not really handle Alt (see below)
1020 // we map it to MOD3, whichis actually Command
1021 if( (nKeyCode & (KEY_MOD2|KEY_MOD3)) != 0 )
1022 aResult.append( sal_Unicode( 0x2303 ) );
1023
1024 aResult.append( it->second );
1025 }
1026
1027 return aResult.makeStringAndClear();
1028 }
1029
1030 // -----------------------------------------------------------------------
1031
1032 XubString AquaSalFrame::GetSymbolKeyName( const XubString&, USHORT nKeyCode )
1033 {
1034 return GetKeyName( nKeyCode );
1035 }
1036
1037 // -----------------------------------------------------------------------
1038
1039 static void getAppleScrollBarVariant(void)
1040 {
1041 bool bIsScrollbarDoubleMax = true; // default is DoubleMax
1042
1043 CFStringRef AppleScrollBarType = CFSTR("AppleScrollBarVariant");
1044 if( AppleScrollBarType )
1045 {
1046 CFStringRef ScrollBarVariant = ((CFStringRef)CFPreferencesCopyAppValue( AppleScrollBarType, kCFPreferencesCurrentApplication ));
1047 if( ScrollBarVariant )
1048 {
1049 if( CFGetTypeID( ScrollBarVariant ) == CFStringGetTypeID() )
1050 {
1051 // TODO: check for the less important variants "DoubleMin" and "DoubleBoth" too
1052 CFStringRef DoubleMax = CFSTR("DoubleMax");
1053 if (DoubleMax)
1054 {
1055 if ( !CFStringCompare(ScrollBarVariant, DoubleMax, kCFCompareCaseInsensitive) )
1056 bIsScrollbarDoubleMax = true;
1057 else
1058 bIsScrollbarDoubleMax = false;
1059 CFRelease(DoubleMax);
1060 }
1061 }
1062 CFRelease( ScrollBarVariant );
1063 }
1064 CFRelease(AppleScrollBarType);
1065 }
1066
1067 GetSalData()->mbIsScrollbarDoubleMax = bIsScrollbarDoubleMax;
1068
1069 CFStringRef jumpScroll = CFSTR("AppleScrollerPagingBehavior");
1070 if( jumpScroll )
1071 {
1072 CFBooleanRef jumpStr = ((CFBooleanRef)CFPreferencesCopyAppValue( jumpScroll, kCFPreferencesCurrentApplication ));
1073 if( jumpStr )
1074 {
1075 if( CFGetTypeID( jumpStr ) == CFBooleanGetTypeID() )
1076 ImplGetSVData()->maNWFData.mbScrollbarJumpPage = (jumpStr == kCFBooleanTrue);
1077 CFRelease( jumpStr );
1078 }
1079 CFRelease( jumpScroll );
1080 }
1081 }
1082
1083 static Color getColor( NSColor* pSysColor, const Color& rDefault, NSWindow* pWin )
1084 {
1085 Color aRet( rDefault );
1086 if( pSysColor )
1087 {
1088 // transform to RGB
1089 NSColor* pRBGColor = [pSysColor colorUsingColorSpaceName: NSDeviceRGBColorSpace device: [pWin deviceDescription]];
1090 if( pRBGColor )
1091 {
1092 float r = 0, g = 0, b = 0, a = 0;
1093 [pRBGColor getRed: &r green: &g blue: &b alpha: &a];
1094 aRet = Color( int(r*255.999), int(g*255.999), int(b*255.999) );
1095 /*
1096 do not release here; leads to duplicate free in yield
1097 it seems the converted color comes out autoreleased, although this
1098 is not documented
1099 [pRBGColor release];
1100 */
1101 }
1102 }
1103 return aRet;
1104 }
1105
1106 static Font getFont( NSFont* pFont, long nDPIY, const Font& rDefault )
1107 {
1108 Font aResult( rDefault );
1109 if( pFont )
1110 {
1111 aResult.SetName( GetOUString( [pFont familyName] ) );
1112 aResult.SetHeight( static_cast<int>(([pFont pointSize] * 72.0 / (float)nDPIY)+0.5) );
1113 aResult.SetItalic( ([pFont italicAngle] != 0.0) ? ITALIC_NORMAL : ITALIC_NONE );
1114 // FIMXE: bold ?
1115 }
1116
1117 return aResult;
1118 }
1119
1120 // on OSX-Aqua the style settings are independent of the frame, so it does
1121 // not really belong here. Since the connection to the Appearance_Manager
1122 // is currently done in salnativewidgets.cxx this would be a good place.
1123 // On the other hand VCL's platform independent code currently only asks
1124 // SalFrames for system settings anyway, so moving the code somewhere else
1125 // doesn't make the anything cleaner for now
1126 void AquaSalFrame::UpdateSettings( AllSettings& rSettings )
1127 {
1128 [mpView lockFocus];
1129
1130 StyleSettings aStyleSettings = rSettings.GetStyleSettings();
1131
1132 // Background Color
1133 Color aBackgroundColor = Color( 0xEC, 0xEC, 0xEC );
1134 aStyleSettings.Set3DColors( aBackgroundColor );
1135 aStyleSettings.SetFaceColor( aBackgroundColor );
1136 Color aInactiveTabColor( aBackgroundColor );
1137 aInactiveTabColor.DecreaseLuminance( 32 );
1138 aStyleSettings.SetInactiveTabColor( aInactiveTabColor );
1139
1140 aStyleSettings.SetDialogColor( aBackgroundColor );
1141 aStyleSettings.SetLightBorderColor( aBackgroundColor );
1142 Color aShadowColor( aStyleSettings.GetShadowColor() );
1143 aStyleSettings.SetDarkShadowColor( aShadowColor );
1144 aShadowColor.IncreaseLuminance( 32 );
1145 aStyleSettings.SetShadowColor( aShadowColor );
1146
1147 // get the system font settings
1148 Font aAppFont = aStyleSettings.GetAppFont();
1149 if( ! mpGraphics )
1150 {
1151 GetGraphics();
1152 ReleaseGraphics( mpGraphics );
1153 }
1154 long nDPIX = 72, nDPIY = 72;
1155 mpGraphics->GetResolution( nDPIX, nDPIY );
1156 aAppFont = getFont( [NSFont systemFontOfSize: 0], nDPIY, aAppFont );
1157
1158 // TODO: better mapping of aqua<->ooo font settings
1159 aStyleSettings.SetAppFont( aAppFont );
1160 aStyleSettings.SetHelpFont( aAppFont );
1161 aStyleSettings.SetPushButtonFont( aAppFont );
1162
1163 Font aTitleFont( getFont( [NSFont titleBarFontOfSize: 0], nDPIY, aAppFont ) );
1164 aStyleSettings.SetTitleFont( aTitleFont );
1165 aStyleSettings.SetFloatTitleFont( aTitleFont );
1166
1167 Font aMenuFont( getFont( [NSFont menuFontOfSize: 0], nDPIY, aAppFont ) );
1168 aStyleSettings.SetMenuFont( aMenuFont );
1169
1170 aStyleSettings.SetToolFont( aAppFont );
1171
1172 Font aLabelFont( getFont( [NSFont labelFontOfSize: 0], nDPIY, aAppFont ) );
1173 aStyleSettings.SetLabelFont( aLabelFont );
1174 aStyleSettings.SetInfoFont( aLabelFont );
1175 aStyleSettings.SetRadioCheckFont( aLabelFont );
1176 aStyleSettings.SetFieldFont( aLabelFont );
1177 aStyleSettings.SetGroupFont( aLabelFont );
1178 aStyleSettings.SetIconFont( aLabelFont );
1179
1180 Color aHighlightColor( getColor( [NSColor selectedTextBackgroundColor],
1181 aStyleSettings.GetHighlightColor(), mpWindow ) );
1182 aStyleSettings.SetHighlightColor( aHighlightColor );
1183 Color aHighlightTextColor( getColor( [NSColor selectedTextColor],
1184 aStyleSettings.GetHighlightTextColor(), mpWindow ) );
1185 aStyleSettings.SetHighlightTextColor( aHighlightTextColor );
1186
1187 Color aMenuHighlightColor( getColor( [NSColor selectedMenuItemColor],
1188 aStyleSettings.GetMenuHighlightColor(), mpWindow ) );
1189 aStyleSettings.SetMenuHighlightColor( aMenuHighlightColor );
1190 Color aMenuHighlightTextColor( getColor( [NSColor selectedMenuItemTextColor],
1191 aStyleSettings.GetMenuHighlightTextColor(), mpWindow ) );
1192 aStyleSettings.SetMenuHighlightTextColor( aMenuHighlightTextColor );
1193
1194 aStyleSettings.SetMenuColor( aBackgroundColor );
1195 Color aMenuTextColor( getColor( [NSColor textColor],
1196 aStyleSettings.GetMenuTextColor(), mpWindow ) );
1197 aStyleSettings.SetMenuTextColor( aMenuTextColor );
1198 aStyleSettings.SetMenuBarTextColor( aMenuTextColor );
1199
1200 aStyleSettings.SetCursorBlinkTime( 500 );
1201
1202 // no mnemonics on aqua
1203 aStyleSettings.SetOptions( aStyleSettings.GetOptions() | STYLE_OPTION_NOMNEMONICS );
1204
1205 getAppleScrollBarVariant();
1206
1207 // set scrollbar size
1208 aStyleSettings.SetScrollBarSize( static_cast<long int>([NSScroller scrollerWidth]) );
1209
1210 // images in menus false for MacOSX
1211 aStyleSettings.SetUseImagesInMenus( false );
1212
1213 rSettings.SetStyleSettings( aStyleSettings );
1214
1215 [mpView unlockFocus];
1216 }
1217
1218 // -----------------------------------------------------------------------
1219
1220 const SystemEnvData* AquaSalFrame::GetSystemData() const
1221 {
1222 return &maSysData;
1223 }
1224
1225 // -----------------------------------------------------------------------
1226
1227 void AquaSalFrame::Beep( SoundType eSoundType )
1228 {
1229 switch( eSoundType )
1230 {
1231 case SOUND_DISABLE:
1232 // don't beep
1233 break;
1234 default:
1235 NSBeep();
1236 break;
1237 }
1238 }
1239
1240 // -----------------------------------------------------------------------
1241
1242 void AquaSalFrame::SetPosSize(long nX, long nY, long nWidth, long nHeight, USHORT nFlags)
1243 {
1244 USHORT nEvent = 0;
1245
1246 if( [mpWindow isMiniaturized] )
1247 [mpWindow deminiaturize: NSApp]; // expand the window
1248
1249 if (nFlags & (SAL_FRAME_POSSIZE_X | SAL_FRAME_POSSIZE_Y))
1250 {
1251 mbPositioned = true;
1252 nEvent = SALEVENT_MOVE;
1253 }
1254
1255 if (nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT))
1256 {
1257 mbSized = true;
1258 nEvent = (nEvent == SALEVENT_MOVE) ? SALEVENT_MOVERESIZE : SALEVENT_RESIZE;
1259 }
1260
1261 NSRect aFrameRect = [mpWindow frame];
1262 NSRect aContentRect = [NSWindow contentRectForFrameRect: aFrameRect styleMask: mnStyleMask];
1263
1264 // position is always relative to parent frame
1265 NSRect aParentContentRect;
1266
1267 if( mpParent )
1268 {
1269 if( Application::GetSettings().GetLayoutRTL() )
1270 {
1271 if( (nFlags & SAL_FRAME_POSSIZE_WIDTH) != 0 )
1272 nX = mpParent->maGeometry.nWidth - nWidth-1 - nX;
1273 else
1274 nX = mpParent->maGeometry.nWidth - static_cast<long int>( aContentRect.size.width-1) - nX;
1275 }
1276 NSRect aParentFrameRect = [mpParent->mpWindow frame];
1277 aParentContentRect = [NSWindow contentRectForFrameRect: aParentFrameRect styleMask: mpParent->mnStyleMask];
1278 }
1279 else
1280 aParentContentRect = maScreenRect; // use screen if no parent
1281
1282 CocoaToVCL( aContentRect );
1283 CocoaToVCL( aParentContentRect );
1284
1285 bool bPaint = false;
1286 if( (nFlags & (SAL_FRAME_POSSIZE_WIDTH | SAL_FRAME_POSSIZE_HEIGHT)) != 0 )
1287 {
1288 if( nWidth != aContentRect.size.width || nHeight != aContentRect.size.height )
1289 bPaint = true;
1290 }
1291
1292 // use old window pos if no new pos requested
1293 if( (nFlags & SAL_FRAME_POSSIZE_X) != 0 )
1294 aContentRect.origin.x = nX + aParentContentRect.origin.x;
1295 if( (nFlags & SAL_FRAME_POSSIZE_Y) != 0)
1296 aContentRect.origin.y = nY + aParentContentRect.origin.y;
1297
1298 // use old size if no new size requested
1299 if( (nFlags & SAL_FRAME_POSSIZE_WIDTH) != 0 )
1300 aContentRect.size.width = nWidth;
1301 if( (nFlags & SAL_FRAME_POSSIZE_HEIGHT) != 0)
1302 aContentRect.size.height = nHeight;
1303
1304 VCLToCocoa( aContentRect );
1305
1306 // do not display yet, we need to update our backbuffer
1307 {
1308 //YieldMutexReleaser aRel;
1309 [mpWindow setFrame: [NSWindow frameRectForContentRect: aContentRect styleMask: mnStyleMask] display: NO];
1310 }
1311
1312 UpdateFrameGeometry();
1313
1314 if (nEvent)
1315 CallCallback(nEvent, NULL);
1316
1317 if( mbShown && bPaint )
1318 {
1319 // trigger filling our backbuffer
1320 SendPaintEvent();
1321
1322 // now inform the system that the views need to be drawn
1323 //YieldMutexReleaser aRel;
1324 [mpWindow display];
1325 }
1326 }
1327
1328 void AquaSalFrame::GetWorkArea( Rectangle& rRect )
1329 {
1330 NSScreen* pScreen = [mpWindow screen];
1331 if( pScreen == nil )
1332 pScreen = [NSScreen mainScreen];
1333 NSRect aRect = [pScreen visibleFrame];
1334 CocoaToVCL( aRect );
1335 rRect.nLeft = static_cast<long>(aRect.origin.x);
1336 rRect.nTop = static_cast<long>(aRect.origin.y);
1337 rRect.nRight = static_cast<long>(aRect.origin.x + aRect.size.width - 1);
1338 rRect.nBottom = static_cast<long>(aRect.origin.y + aRect.size.height - 1);
1339 }
1340
1341 SalPointerState AquaSalFrame::GetPointerState()
1342 {
1343 SalPointerState state;
1344
1345 // get position
1346 NSPoint aPt = [mpWindow mouseLocationOutsideOfEventStream];
1347 CocoaToVCL( aPt, false );
1348 state.maPos = Point(static_cast<long>(aPt.x), static_cast<long>(aPt.y));
1349
1350 // FIXME: replace Carbon by Cocoa
1351 // Cocoa does not have an equivalent for GetCurrentEventButtonState
1352 // and GetCurrentEventKeyModifiers.
1353 // we could try to get away with tracking all events for modifierKeys
1354 // and all mouse events for button state in VCL_NSApllication::sendEvent,
1355 // but it is unclear whether this will get us the same result.
1356 // leave in GetCurrentEventButtonState and GetCurrentEventKeyModifiers for now
1357
1358 // fill in button state
1359 UInt32 nState = GetCurrentEventButtonState();
1360 state.mnState = 0;
1361 if( nState & 1 )
1362 state.mnState |= MOUSE_LEFT; // primary button
1363 if( nState & 2 )
1364 state.mnState |= MOUSE_RIGHT; // secondary button
1365 if( nState & 4 )
1366 state.mnState |= MOUSE_MIDDLE; // tertiary button
1367
1368 // fill in modifier state
1369 nState = GetCurrentEventKeyModifiers();
1370 if( nState & shiftKey )
1371 state.mnState |= KEY_SHIFT;
1372 if( nState & controlKey )
1373 state.mnState |= KEY_MOD3;
1374 if( nState & optionKey )
1375 state.mnState |= KEY_MOD2;
1376 if( nState & cmdKey )
1377 state.mnState |= KEY_MOD1;
1378
1379 return state;
1380 }
1381
1382 SalFrame::SalIndicatorState AquaSalFrame::GetIndicatorState()
1383 {
1384 SalIndicatorState aState;
1385 aState.mnState = 0;
1386 return aState;
1387 }
1388
1389 void AquaSalFrame::SimulateKeyPress( USHORT /*nKeyCode*/ )
1390 {
1391 }
1392
1393 bool AquaSalFrame::SetPluginParent( SystemParentData* pNewParent )
1394 {
1395 // plugin parent may be killed unexpectedly by
1396 // plugging process;
1397
1398 //TODO: implement
1399 return sal_False;
1400 }
1401
1402 BOOL AquaSalFrame::MapUnicodeToKeyCode( sal_Unicode , LanguageType , KeyCode& )
1403 {
1404 // not supported yet
1405 return FALSE;
1406 }
1407
1408 LanguageType AquaSalFrame::GetInputLanguage()
1409 {
1410 //TODO: implement
1411 return LANGUAGE_DONTKNOW;
1412 }
1413
1414 void AquaSalFrame::DrawMenuBar()
1415 {
1416 }
1417
1418 void AquaSalFrame::SetMenu( SalMenu* pSalMenu )
1419 {
1420 AquaSalMenu* pMenu = static_cast<AquaSalMenu*>(pSalMenu);
1421 DBG_ASSERT( ! pMenu || pMenu->mbMenuBar, "setting non menubar on frame" );
1422 mpMenu = pMenu;
1423 if( mpMenu )
1424 mpMenu->setMainMenu();
1425 }
1426
1427 void AquaSalFrame::SetExtendedFrameStyle( SalExtStyle nStyle )
1428 {
1429 if( (mnExtStyle & SAL_FRAME_EXT_STYLE_DOCMODIFIED) != (nStyle & SAL_FRAME_EXT_STYLE_DOCMODIFIED) )
1430 [mpWindow setDocumentEdited: (nStyle & SAL_FRAME_EXT_STYLE_DOCMODIFIED) ? YES : NO];
1431 mnExtStyle = nStyle;
1432 }
1433
1434 void AquaSalFrame::SetBackgroundBitmap( SalBitmap* )
1435 {
1436 //TODO: implement
1437 }
1438
1439 SalBitmap* AquaSalFrame::SnapShot()
1440 {
1441 return mpGraphics ? mpGraphics->getBitmap( 0, 0, maGeometry.nWidth, maGeometry.nHeight ) : NULL;
1442 }
1443
1444 SalFrame* AquaSalFrame::GetParent() const
1445 {
1446 return mpParent;
1447 }
1448
1449 void AquaSalFrame::SetParent( SalFrame* pNewParent )
1450 {
1451 bool bShown = mbShown;
1452 // remove from child list
1453 Show( FALSE );
1454 mpParent = (AquaSalFrame*)pNewParent;
1455 // insert to correct parent and paint
1456 Show( bShown );
1457 }
1458
1459 void AquaSalFrame::UpdateFrameGeometry()
1460 {
1461 // keep in mind that view and window coordinates are lower left
1462 // whereas vcl's are upper left
1463
1464 // update screen rect
1465 NSScreen * pScreen = [mpWindow screen];
1466 if( pScreen )
1467 {
1468 maScreenRect = [pScreen frame];
1469 NSArray* pScreens = [NSScreen screens];
1470 if( pScreens )
1471 maGeometry.nScreenNumber = [pScreens indexOfObject: pScreen];
1472 }
1473
1474 NSRect aFrameRect = [mpWindow frame];
1475 NSRect aContentRect = [NSWindow contentRectForFrameRect: aFrameRect styleMask: mnStyleMask];
1476
1477 // release old track rect
1478 [mpView removeTrackingRect: mnTrackingRectTag];
1479 // install the new track rect
1480 NSRect aTrackRect = { { 0, 0 }, aContentRect.size };
1481 mnTrackingRectTag = [mpView addTrackingRect: aTrackRect owner: mpView userData: nil assumeInside: NO];
1482
1483 // convert to vcl convention
1484 CocoaToVCL( aFrameRect );
1485 CocoaToVCL( aContentRect );
1486
1487 maGeometry.nX = static_cast<int>(aContentRect.origin.x);
1488 maGeometry.nY = static_cast<int>(aContentRect.origin.y);
1489
1490 maGeometry.nLeftDecoration = static_cast<unsigned int>(aContentRect.origin.x - aFrameRect.origin.x);
1491 maGeometry.nRightDecoration = static_cast<unsigned int>((aFrameRect.origin.x + aFrameRect.size.width) -
1492 (aContentRect.origin.x + aContentRect.size.width));
1493
1494 maGeometry.nTopDecoration = static_cast<unsigned int>(aContentRect.origin.y - aFrameRect.origin.y);
1495 maGeometry.nBottomDecoration = static_cast<unsigned int>((aFrameRect.origin.y + aFrameRect.size.height) -
1496 (aContentRect.origin.y + aContentRect.size.height));
1497
1498 maGeometry.nWidth = static_cast<unsigned int>(aContentRect.size.width);
1499 maGeometry.nHeight = static_cast<unsigned int>(aContentRect.size.height);
1500 }
1501
1502 // -----------------------------------------------------------------------
1503
1504 void AquaSalFrame::CaptureMouse( BOOL bCapture )
1505 {
1506 /* Remark:
1507 we'll try to use a pidgin version of capture mouse
1508 on MacOSX (neither carbon nor cocoa) there is a
1509 CaptureMouse equivalent (in Carbon there is TrackMouseLocation
1510 but this is useless to use since it is blocking)
1511
1512 However on cocoa the active frame seems to get mouse events
1513 also outside the window, so we'll try to forward mouse events
1514 to the capture frame in the hope that one of our frames
1515 gets a mouse event.
1516
1517 This will break as soon as the user activates another app, but
1518 a mouse click will normally lead to a release of the mouse anyway.
1519
1520 Let's see how far we get this way. Alternatively we could use one
1521 large overlay window like we did for the carbon implementation,
1522 however that is resource intensive.
1523 */
1524
1525 if( bCapture )
1526 s_pCaptureFrame = this;
1527 else if( ! bCapture && s_pCaptureFrame == this )
1528 s_pCaptureFrame = NULL;
1529 }
1530
1531 void AquaSalFrame::ResetClipRegion()
1532 {
1533 // release old path and indicate no clipping
1534 CGPathRelease( mrClippingPath );
1535 mrClippingPath = NULL;
1536
1537 if( mpView && mbShown )
1538 [mpView setNeedsDisplay: YES];
1539 if( mpWindow )
1540 {
1541 [mpWindow setOpaque: YES];
1542 [mpWindow invalidateShadow];
1543 }
1544 }
1545
1546 void AquaSalFrame::BeginSetClipRegion( ULONG nRects )
1547 {
1548 // release old path
1549 if( mrClippingPath )
1550 {
1551 CGPathRelease( mrClippingPath );
1552 mrClippingPath = NULL;
1553 }
1554
1555 if( maClippingRects.size() > SAL_CLIPRECT_COUNT && nRects < maClippingRects.size() )
1556 {
1557 std::vector<CGRect> aEmptyVec;
1558 maClippingRects.swap( aEmptyVec );
1559 }
1560 maClippingRects.clear();
1561 maClippingRects.reserve( nRects );
1562 }
1563
1564 void AquaSalFrame::UnionClipRegion( long nX, long nY, long nWidth, long nHeight )
1565 {
1566 if( nWidth && nHeight )
1567 {
1568 NSRect aRect = { { nX, nY }, { nWidth, nHeight } };
1569 VCLToCocoa( aRect, false );
1570 maClippingRects.push_back( CGRectMake(aRect.origin.x, aRect.origin.y, aRect.size.width, aRect.size.height) );
1571 }
1572 }
1573
1574 void AquaSalFrame::EndSetClipRegion()
1575 {
1576 if( ! maClippingRects.empty() )
1577 {
1578 mrClippingPath = CGPathCreateMutable();
1579 CGPathAddRects( mrClippingPath, NULL, &maClippingRects[0], maClippingRects.size() );
1580 }
1581 if( mpView && mbShown )
1582 [mpView setNeedsDisplay: YES];
1583 if( mpWindow )
1584 {
1585 [mpWindow setOpaque: (mrClippingPath != NULL) ? NO : YES];
1586 [mpWindow setBackgroundColor: [NSColor clearColor]];
1587 // shadow is invalidated when view gets drawn again
1588 }
1589 }
1590
vba interoperability for OOo