vcl/osx/salinst.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_features.h>
  21
  22 #include <stdio.h>
  23
  24 #include <comphelper/solarmutex.hxx>
  25
  26 #include "comphelper/lok.hxx"
  27
  28 #include "osl/process.h"
  29
  30 #include "rtl/ustrbuf.hxx"
  31
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/window.hxx>
  34 #include <vcl/idle.hxx>
  35 #include <vcl/svmain.hxx>
  36 #include <vcl/opengl/OpenGLContext.hxx>
  37
  38 #include "osx/saldata.hxx"
  39 #include "osx/salinst.h"
  40 #include "osx/salframe.h"
  41 #include "osx/salobj.h"
  42 #include "osx/salsys.h"
  43 #include "quartz/salvd.h"
  44 #include "quartz/salbmp.h"
  45 #include "quartz/utils.h"
  46 #include "osx/salprn.h"
  47 #include "osx/saltimer.h"
  48 #include "osx/vclnsapp.h"
  49
  50 #include "print.h"
  51 #include "impbmp.hxx"
  52 #include "salimestatus.hxx"
  53
  54 #include <comphelper/processfactory.hxx>
  55
  56 #include <com/sun/star/uri/XExternalUriReferenceTranslator.hpp>
  57 #include <com/sun/star/uri/ExternalUriReferenceTranslator.hpp>
  58 #include <com/sun/star/uno/XComponentContext.hpp>
  59
  60 #include "premac.h"
  61 #include <Foundation/Foundation.h>
  62 #include <ApplicationServices/ApplicationServices.h>
  63 #import "apple_remote/RemoteMainController.h"
  64 #include "apple_remote/RemoteControl.h"
  65 #include "postmac.h"
  66
  67 extern "C" {
  68 #include <crt_externs.h>
  69 }
  70
  71 using namespace std;
  72 using namespace ::com::sun::star;
  73
  74 static int* gpnInit = nullptr;
  75 static NSMenu* pDockMenu = nil;
  76 static bool bNoSVMain = true;
  77 static bool bLeftMain = false;
  78
  79 class AquaDelayedSettingsChanged : public Idle
  80 {
  81     bool            mbInvalidate;
  82     public:
  83     AquaDelayedSettingsChanged( bool bInvalidate ) :
  84         mbInvalidate( bInvalidate )
  85     {
  86     }
  87
  88     virtual void Invoke() override
  89     {
  90         SalData* pSalData = GetSalData();
  91         if( ! pSalData->maFrames.empty() )
  92             pSalData->maFrames.front()->CallCallback( SalEvent::SettingsChanged, nullptr );
  93
  94         if( mbInvalidate )
  95         {
  96             for( std::list< AquaSalFrame* >::iterator it = pSalData->maFrames.begin();
  97                 it != pSalData->maFrames.end(); ++it )
  98             {
  99                 if( (*it)->mbShown )
 100                     (*it)->SendPaintEvent();
 101             }
 102         }
 103         Stop();
 104         delete this;
 105     }
 106 };
 107
 108 void AquaSalInstance::delayedSettingsChanged( bool bInvalidate )
 109 {
 110     osl::Guard< comphelper::SolarMutex > aGuard( *mpSalYieldMutex );
 111     AquaDelayedSettingsChanged* pIdle = new AquaDelayedSettingsChanged( bInvalidate );
 112     pIdle->SetPriority( TaskPriority::MEDIUM );
 113     pIdle->Start();
 114 }
 115
 116 // the std::list<const ApplicationEvent*> must be available before any SalData/SalInst/etc. objects are ready
 117 std::list<const ApplicationEvent*> AquaSalInstance::aAppEventList;
 118
 119 NSMenu* AquaSalInstance::GetDynamicDockMenu()
 120 {
 121     if( ! pDockMenu && ! bLeftMain )
 122         pDockMenu = [[NSMenu alloc] initWithTitle: @""];
 123     return pDockMenu;
 124 }
 125
 126 bool AquaSalInstance::isOnCommandLine( const OUString& rArg )
 127 {
 128     sal_uInt32 nArgs = osl_getCommandArgCount();
 129     for( sal_uInt32 i = 0; i < nArgs; i++ )
 130     {
 131         OUString aArg;
 132         osl_getCommandArg( i, &aArg.pData );
 133         if( aArg.equals( rArg ) )
 134             return true;
 135     }
 136     return false;
 137 }
 138
 139 // initialize the cocoa VCL_NSApplication object
 140 // returns an NSAutoreleasePool that must be released when the event loop begins
 141 static void initNSApp()
 142 {
 143     // create our cocoa NSApplication
 144     [VCL_NSApplication sharedApplication];
 145
 146     SalData::ensureThreadAutoreleasePool();
 147
 148     // put cocoa into multithreaded mode
 149     [NSThread detachNewThreadSelector:@selector(enableCocoaThreads:) toTarget:[[CocoaThreadEnabler alloc] init] withObject:nil];
 150
 151     // activate our delegate methods
 152     [NSApp setDelegate: NSApp];
 153
 154     [[NSNotificationCenter defaultCenter] addObserver: NSApp
 155                                           selector: @selector(systemColorsChanged:)
 156                                           name: NSSystemColorsDidChangeNotification
 157                                           object: nil ];
 158     [[NSNotificationCenter defaultCenter] addObserver: NSApp
 159                                           selector: @selector(screenParametersChanged:)
 160                                           name: NSApplicationDidChangeScreenParametersNotification
 161                                           object: nil ];
 162     // add observers for some settings changes that affect vcl's settings
 163     // scrollbar variant
 164     [[NSDistributedNotificationCenter defaultCenter] addObserver: NSApp
 165                                           selector: @selector(scrollbarVariantChanged:)
 166                                           name: @"AppleAquaScrollBarVariantChanged"
 167                                           object: nil ];
 168     // scrollbar page behavior ("jump to here" or not)
 169     [[NSDistributedNotificationCenter defaultCenter] addObserver: NSApp
 170                                           selector: @selector(scrollbarSettingsChanged:)
 171                                           name: @"AppleNoRedisplayAppearancePreferenceChanged"
 172                                           object: nil ];
 173 #if !HAVE_FEATURE_MACOSX_SANDBOX
 174     // Initialize Apple Remote
 175     GetSalData()->mpAppleRemoteMainController = [[AppleRemoteMainController alloc] init];
 176
 177     [[NSDistributedNotificationCenter defaultCenter] addObserver: NSApp
 178                                            selector: @selector(applicationWillBecomeActive:)
 179                                            name: @"AppleRemoteWillBecomeActive"
 180                                            object: nil ];
 181
 182     [[NSDistributedNotificationCenter defaultCenter] addObserver: NSApp
 183                                            selector: @selector(applicationWillResignActive:)
 184                                            name: @"AppleRemoteWillResignActive"
 185                                            object: nil ];
 186 #endif
 187 }
 188
 189 bool ImplSVMainHook( int * pnInit )
 190 {
 191     if (comphelper::LibreOfficeKit::isActive())
 192         return false;
 193
 194     NSAutoreleasePool * pool = [ [ NSAutoreleasePool alloc ] init ];
 195     unlink([[NSString stringWithFormat:@"%@/Library/Saved Application State/%s.savedState/restorecount.plist", NSHomeDirectory(), MACOSX_BUNDLE_IDENTIFIER] UTF8String]);
 196     unlink([[NSString stringWithFormat:@"%@/Library/Saved Application State/%s.savedState/restorecount.txt", NSHomeDirectory(), MACOSX_BUNDLE_IDENTIFIER] UTF8String]);
 197     [ pool drain ];
 198
 199     gpnInit = pnInit;
 200
 201     bNoSVMain = false;
 202     initNSApp();
 203
 204     OUString aExeURL, aExe;
 205     osl_getExecutableFile( &aExeURL.pData );
 206     osl_getSystemPathFromFileURL( aExeURL.pData, &aExe.pData );
 207     OString aByteExe( OUStringToOString( aExe, osl_getThreadTextEncoding() ) );
 208
 209 #ifdef DEBUG
 210     aByteExe += OString ( " NSAccessibilityDebugLogLevel 1" );
 211     const char* pArgv[] = { aByteExe.getStr(), NULL };
 212     NSApplicationMain( 3, pArgv );
 213 #else
 214     const char* pArgv[] = { aByteExe.getStr(), nullptr };
 215     NSApplicationMain( 1, pArgv );
 216 #endif
 217
 218     return TRUE;   // indicate that ImplSVMainHook is implemented
 219 }
 220
 221 void SalAbort( const OUString& rErrorText, bool bDumpCore )
 222 {
 223     if( rErrorText.isEmpty() )
 224         fprintf( stderr, "Application Error " );
 225     else
 226         fprintf( stderr, "%s ",
 227             OUStringToOString( rErrorText, osl_getThreadTextEncoding() ).getStr() );
 228     if( bDumpCore )
 229         abort();
 230     else
 231         _exit(1);
 232 }
 233
 234 void InitSalData()
 235 {
 236     SalData *pSalData = new SalData;
 237     SetSalData( pSalData );
 238 }
 239
 240 const OUString& SalGetDesktopEnvironment()
 241 {
 242     static OUString aDesktopEnvironment( "MacOSX" );
 243     return aDesktopEnvironment;
 244 }
 245
 246 void DeInitSalData()
 247 {
 248     SalData *pSalData = GetSalData();
 249     if( pSalData->mpStatusItem )
 250     {
 251         [pSalData->mpStatusItem release];
 252         pSalData->mpStatusItem = nil;
 253     }
 254     delete pSalData;
 255     SetSalData( nullptr );
 256 }
 257
 258 void InitSalMain()
 259 {
 260 }
 261
 262 SalYieldMutex::SalYieldMutex()
 263 {
 264     mnCount  = 0;
 265     mnThreadId  = 0;
 266 }
 267
 268 void SalYieldMutex::acquire()
 269 {
 270     m_mutex.acquire();
 271     mnThreadId = osl::Thread::getCurrentIdentifier();
 272     mnCount++;
 273 }
 274
 275 void SalYieldMutex::release()
 276 {
 277     if ( mnThreadId == osl::Thread::getCurrentIdentifier() )
 278     {
 279         if ( mnCount == 1 )
 280         {
 281             // TODO: add OpenGLContext::prepareForYield with vcl OpenGL support
 282             mnThreadId = 0;
 283         }
 284         mnCount--;
 285     }
 286     m_mutex.release();
 287 }
 288
 289 bool SalYieldMutex::tryToAcquire()
 290 {
 291     if ( m_mutex.tryToAcquire() )
 292     {
 293         mnThreadId = osl::Thread::getCurrentIdentifier();
 294         mnCount++;
 295         return true;
 296     }
 297     else
 298         return false;
 299 }
 300
 301 // some convenience functions regarding the yield mutex, aka solar mutex
 302
 303 bool ImplSalYieldMutexTryToAcquire()
 304 {
 305     AquaSalInstance* pInst = GetSalData()->mpFirstInstance;
 306     if ( pInst )
 307         return pInst->mpSalYieldMutex->tryToAcquire();
 308     else
 309         return FALSE;
 310 }
 311
 312 void ImplSalYieldMutexRelease()
 313 {
 314     AquaSalInstance* pInst = GetSalData()->mpFirstInstance;
 315     if ( pInst )
 316         pInst->mpSalYieldMutex->release();
 317 }
 318
 319 SalInstance* CreateSalInstance()
 320 {
 321     // this is the case for not using SVMain
 322     // not so good
 323     if( bNoSVMain )
 324         initNSApp();
 325
 326     SalData* pSalData = GetSalData();
 327     SAL_WARN_IF( pSalData->mpFirstInstance != nullptr, "vcl", "more than one instance created" );
 328     AquaSalInstance* pInst = new AquaSalInstance;
 329
 330     // init instance (only one instance in this version !!!)
 331     pSalData->mpFirstInstance = pInst;
 332     // this one is for outside AquaSalInstance::Yield
 333     SalData::ensureThreadAutoreleasePool();
 334     // no focus rects on NWF
 335     ImplGetSVData()->maNWFData.mbNoFocusRects = true;
 336     ImplGetSVData()->maNWFData.mbNoActiveTabTextRaise = true;
 337     ImplGetSVData()->maNWFData.mbCenteredTabs = true;
 338     ImplGetSVData()->maNWFData.mbProgressNeedsErase = true;
 339     ImplGetSVData()->maNWFData.mbCheckBoxNeedsErase = true;
 340     ImplGetSVData()->maNWFData.mnStatusBarLowerRightOffset = 10;
 341
 342     return pInst;
 343 }
 344
 345 void DestroySalInstance( SalInstance* pInst )
 346 {
 347     delete pInst;
 348 }
 349
 350 AquaSalInstance::AquaSalInstance()
 351  : maUserEventListMutex()
 352  , maWaitingYieldCond()
 353 {
 354     mpSalYieldMutex = new SalYieldMutex;
 355     mpSalYieldMutex->acquire();
 356     ::comphelper::SolarMutex::setSolarMutex( mpSalYieldMutex );
 357     maMainThread = osl::Thread::getCurrentIdentifier();
 358     mbWaitingYield = false;
 359     mnActivePrintJobs = 0;
 360 }
 361
 362 AquaSalInstance::~AquaSalInstance()
 363 {
 364     ::comphelper::SolarMutex::setSolarMutex( nullptr );
 365     mpSalYieldMutex->release();
 366     delete mpSalYieldMutex;
 367 }
 368
 369 void AquaSalInstance::wakeupYield()
 370 {
 371     // wakeup :Yield
 372     if( mbWaitingYield )
 373     {
 374         SalData::ensureThreadAutoreleasePool();
 375 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 376     // 'NSApplicationDefined' is deprecated: first deprecated in macOS 10.12
 377         NSEvent* pEvent = [NSEvent otherEventWithType: NSApplicationDefined
 378                                    location: NSZeroPoint
 379                                    modifierFlags: 0
 380                                    timestamp: 0
 381                                    windowNumber: 0
 382                                    context: nil
 383                                    subtype: AquaSalInstance::YieldWakeupEvent
 384                                    data1: 0
 385                                    data2: 0 ];
 386 SAL_WNODEPRECATED_DECLARATIONS_POP
 387         if( pEvent )
 388             [NSApp postEvent: pEvent atStart: NO];
 389     }
 390 }
 391
 392 void AquaSalInstance::PostUserEvent( AquaSalFrame* pFrame, SalEvent nType, void* pData )
 393 {
 394     {
 395         osl::MutexGuard g( maUserEventListMutex );
 396         maUserEvents.push_back( SalUserEvent( pFrame, pData, nType ) );
 397     }
 398     // notify main loop that an event has arrived
 399     wakeupYield();
 400 }
 401
 402 comphelper::SolarMutex* AquaSalInstance::GetYieldMutex()
 403 {
 404     return mpSalYieldMutex;
 405 }
 406
 407 sal_uLong AquaSalInstance::ReleaseYieldMutex()
 408 {
 409     SalYieldMutex* pYieldMutex = mpSalYieldMutex;
 410     if ( pYieldMutex->GetThreadId() ==
 411          osl::Thread::getCurrentIdentifier() )
 412     {
 413         sal_uLong nCount = pYieldMutex->GetAcquireCount();
 414         sal_uLong n = nCount;
 415         while ( n )
 416         {
 417             pYieldMutex->release();
 418             n--;
 419         }
 420
 421         return nCount;
 422     }
 423     else
 424         return 0;
 425 }
 426
 427 void AquaSalInstance::AcquireYieldMutex( sal_uLong nCount )
 428 {
 429     SalYieldMutex* pYieldMutex = mpSalYieldMutex;
 430     while ( nCount )
 431     {
 432         pYieldMutex->acquire();
 433         nCount--;
 434     }
 435 }
 436
 437 bool AquaSalInstance::CheckYieldMutex()
 438 {
 439     bool bRet = true;
 440
 441     SalYieldMutex* pYieldMutex = mpSalYieldMutex;
 442     if ( pYieldMutex->GetThreadId() != osl::Thread::getCurrentIdentifier())
 443     {
 444         bRet = false;
 445     }
 446
 447     return bRet;
 448 }
 449
 450 bool AquaSalInstance::isNSAppThread() const
 451 {
 452     return osl::Thread::getCurrentIdentifier() == maMainThread;
 453 }
 454
 455 void AquaSalInstance::handleAppDefinedEvent( NSEvent* pEvent )
 456 {
 457     int nSubtype = [pEvent subtype];
 458     switch( nSubtype )
 459     {
 460     case AppStartTimerEvent:
 461         AquaSalTimer::handleStartTimerEvent( pEvent );
 462         break;
 463     case AppEndLoopEvent:
 464         [NSApp stop: NSApp];
 465         break;
 466     case AppExecuteSVMain:
 467     {
 468         int nResult = ImplSVMain();
 469         if( gpnInit )
 470             *gpnInit = nResult;
 471         [NSApp stop: NSApp];
 472         bLeftMain = true;
 473         if( pDockMenu )
 474         {
 475             [pDockMenu release];
 476             pDockMenu = nil;
 477         }
 478     }
 479     break;
 480 #if !HAVE_FEATURE_MACOSX_SANDBOX
 481     case AppleRemoteControlEvent: // Defined in <apple_remote/RemoteMainController.h>
 482     {
 483         MediaCommand nCommand;
 484         SalData* pSalData = GetSalData();
 485         bool bIsFullScreenMode = false;
 486
 487         std::list<AquaSalFrame*>::iterator it = pSalData->maFrames.begin();
 488         while( it != pSalData->maFrames.end() )
 489         {
 490             if ( (*it) && (*it)->mbFullScreen )
 491                 bIsFullScreenMode = true;
 492             ++it;
 493         }
 494
 495         switch ([pEvent data1])
 496         {
 497             case kRemoteButtonPlay:
 498                 nCommand = bIsFullScreenMode ? MediaCommand::PlayPause : MediaCommand::Play;
 499                 break;
 500
 501             // kept for experimentation purpose (scheduled for future implementation)
 502             // case kRemoteButtonMenu:         nCommand = MediaCommand::Menu; break;
 503
 504             case kRemoteButtonPlus:         nCommand = MediaCommand::VolumeUp; break;
 505
 506             case kRemoteButtonMinus:        nCommand = MediaCommand::VolumeDown; break;
 507
 508             case kRemoteButtonRight:        nCommand = MediaCommand::NextTrack; break;
 509
 510             case kRemoteButtonRight_Hold:   nCommand = MediaCommand::NextTrackHold; break;
 511
 512             case kRemoteButtonLeft:         nCommand = MediaCommand::PreviousTrack; break;
 513
 514             case kRemoteButtonLeft_Hold:    nCommand = MediaCommand::Rewind; break;
 515
 516             case kRemoteButtonPlay_Hold:    nCommand = MediaCommand::PlayHold; break;
 517
 518             case kRemoteButtonMenu_Hold:    nCommand = MediaCommand::Stop; break;
 519
 520             // FIXME : not detected
 521             case kRemoteButtonPlus_Hold:
 522             case kRemoteButtonMinus_Hold:
 523                 break;
 524
 525             default:
 526                 break;
 527         }
 528         AquaSalFrame* pFrame = pSalData->maFrames.front();
 529         vcl::Window* pWindow = pFrame ? pFrame->GetWindow() : nullptr;
 530
 531         if( pWindow )
 532         {
 533             const Point aPoint;
 534             CommandMediaData aMediaData(nCommand);
 535             CommandEvent aCEvt( aPoint, CommandEventId::Media, FALSE, &aMediaData );
 536             NotifyEvent aNCmdEvt( MouseNotifyEvent::COMMAND, pWindow, &aCEvt );
 537
 538             if ( !ImplCallPreNotify( aNCmdEvt ) )
 539                 pWindow->Command( aCEvt );
 540         }
 541
 542     }
 543     break;
 544 #endif
 545
 546     case YieldWakeupEvent:
 547         // do nothing, fall out of Yield
 548     break;
 549
 550     default:
 551         OSL_FAIL( "unhandled NSApplicationDefined event" );
 552         break;
 553     };
 554 }
 555
 556 class ReleasePoolHolder
 557 {
 558     NSAutoreleasePool* mpPool;
 559     public:
 560     ReleasePoolHolder() : mpPool( [[NSAutoreleasePool alloc] init] ) {}
 561     ~ReleasePoolHolder() { [mpPool release]; }
 562 };
 563
 564 SalYieldResult AquaSalInstance::DoYield(bool bWait, bool bHandleAllCurrentEvents, sal_uLong const nReleased)
 565 {
 566     (void) nReleased;
 567     assert(nReleased == 0); // not implemented
 568
 569     // ensure that the per thread autorelease pool is top level and
 570     // will therefore not be destroyed by cocoa implicitly
 571     SalData::ensureThreadAutoreleasePool();
 572
 573     // NSAutoreleasePool documentation suggests we should have
 574     // an own pool for each yield level
 575     ReleasePoolHolder aReleasePool;
 576
 577     // Release all locks so that we don't deadlock when we pull pending
 578     // events from the event queue
 579     bool bDispatchUser = true;
 580     while( bDispatchUser )
 581     {
 582         sal_uLong nCount = ReleaseYieldMutex();
 583
 584         // get one user event
 585         SalUserEvent aEvent( nullptr, nullptr, SalEvent::NONE );
 586         {
 587             osl::MutexGuard g( maUserEventListMutex );
 588             if( ! maUserEvents.empty() )
 589             {
 590                 aEvent = maUserEvents.front();
 591                 maUserEvents.pop_front();
 592             }
 593             else
 594                 bDispatchUser = false;
 595         }
 596         AcquireYieldMutex( nCount );
 597
 598         // dispatch it
 599         if( aEvent.mpFrame && AquaSalFrame::isAlive( aEvent.mpFrame ) )
 600         {
 601             aEvent.mpFrame->CallCallback( aEvent.mnType, aEvent.mpData );
 602             maWaitingYieldCond.set();
 603             // return if only one event is asked for
 604             if( ! bHandleAllCurrentEvents )
 605                 return SalYieldResult::EVENT;
 606         }
 607     }
 608
 609     // handle cocoa event queue
 610     // cocoa events may be only handled in the thread the NSApp was created
 611     bool bHadEvent = false;
 612     if( isNSAppThread() && mnActivePrintJobs == 0 )
 613     {
 614         // we need to be woken up by a cocoa-event
 615         // if a user event should be posted by the event handling below
 616         bool bOldWaitingYield = mbWaitingYield;
 617         mbWaitingYield = bWait;
 618
 619         // handle available events
 620         NSEvent* pEvent = nil;
 621         do
 622         {
 623             sal_uLong nCount = ReleaseYieldMutex();
 624
 625 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 626     // 'NSAnyEventMask' is deprecated: first deprecated in macOS 10.12
 627             pEvent = [NSApp nextEventMatchingMask: NSAnyEventMask untilDate: nil
 628 SAL_WNODEPRECATED_DECLARATIONS_POP
 629                             inMode: NSDefaultRunLoopMode dequeue: YES];
 630             if( pEvent )
 631             {
 632                 [NSApp sendEvent: pEvent];
 633                 bHadEvent = true;
 634             }
 635             [NSApp updateWindows];
 636
 637             AcquireYieldMutex( nCount );
 638         } while( bHandleAllCurrentEvents && pEvent );
 639
 640         // if we had no event yet, wait for one if requested
 641         if( bWait && ! bHadEvent )
 642         {
 643             sal_uLong nCount = ReleaseYieldMutex();
 644
 645             NSDate* pDt = AquaSalTimer::pRunningTimer ? [AquaSalTimer::pRunningTimer fireDate] : [NSDate distantFuture];
 646 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 647     // 'NSAnyEventMask' is deprecated: first deprecated in macOS 10.12
 648             pEvent = [NSApp nextEventMatchingMask: NSAnyEventMask untilDate: pDt
 649 SAL_WNODEPRECATED_DECLARATIONS_POP
 650                             inMode: NSDefaultRunLoopMode dequeue: YES];
 651             if( pEvent )
 652                 [NSApp sendEvent: pEvent];
 653             [NSApp updateWindows];
 654
 655             AcquireYieldMutex( nCount );
 656
 657             // #i86581#
 658             // FIXME: sometimes the NSTimer will never fire. Firing it by hand then
 659             // fixes the problem even seems to set the correct next firing date
 660             // Why oh why?
 661             if( ! pEvent && AquaSalTimer::pRunningTimer )
 662             {
 663                 // this cause crashes on MacOSX 10.4
 664                 // [AquaSalTimer::pRunningTimer fire];
 665                 if (ImplGetSVData()->mpSalTimer != nullptr)
 666                 {
 667                     bool idle = true; // TODO
 668                     ImplGetSVData()->mpSalTimer->CallCallback( idle );
 669                 }
 670             }
 671         }
 672
 673         mbWaitingYield = bOldWaitingYield;
 674
 675         // collect update rectangles
 676         const std::list< AquaSalFrame* > rFrames( GetSalData()->maFrames );
 677         for( std::list< AquaSalFrame* >::const_iterator it = rFrames.begin(); it != rFrames.end(); ++it )
 678         {
 679             if( (*it)->mbShown && ! (*it)->maInvalidRect.IsEmpty() )
 680             {
 681                 (*it)->Flush( (*it)->maInvalidRect );
 682                 (*it)->maInvalidRect.SetEmpty();
 683             }
 684         }
 685         maWaitingYieldCond.set();
 686     }
 687     else if( bWait )
 688     {
 689         // #i103162#
 690         // wait until any thread (most likely the main thread)
 691         // has dispatched an event, cop out at 200 ms
 692         maWaitingYieldCond.reset();
 693         TimeValue aVal = { 0, 200000000 };
 694         sal_uLong nCount = ReleaseYieldMutex();
 695         maWaitingYieldCond.wait( &aVal );
 696         AcquireYieldMutex( nCount );
 697     }
 698
 699     // we get some apple events way too early
 700     // before the application is ready to handle them,
 701     // so their corresponding application events need to be delayed
 702     // now is a good time to handle at least one of them
 703     if( bWait && !aAppEventList.empty() && ImplGetSVData()->maAppData.mbInAppExecute )
 704     {
 705         // make sure that only one application event is active at a time
 706         static bool bInAppEvent = false;
 707         if( !bInAppEvent )
 708         {
 709             bInAppEvent = true;
 710             // get the next delayed application event
 711             const ApplicationEvent* pAppEvent = aAppEventList.front();
 712             aAppEventList.pop_front();
 713             // handle one application event (no recursion)
 714             const ImplSVData* pSVData = ImplGetSVData();
 715             pSVData->mpApp->AppEvent( *pAppEvent );
 716             delete pAppEvent;
 717             // allow the next delayed application event
 718             bInAppEvent = false;
 719         }
 720     }
 721
 722     return bHadEvent ? SalYieldResult::EVENT : SalYieldResult::TIMEOUT;
 723 }
 724
 725 bool AquaSalInstance::AnyInput( VclInputFlags nType )
 726 {
 727     if( nType & VclInputFlags::APPEVENT )
 728     {
 729         if( ! aAppEventList.empty() )
 730             return true;
 731         if( nType == VclInputFlags::APPEVENT )
 732             return false;
 733     }
 734
 735     if( nType & VclInputFlags::TIMER )
 736     {
 737         if( AquaSalTimer::pRunningTimer )
 738         {
 739             NSDate* pDt = [AquaSalTimer::pRunningTimer fireDate];
 740             if( pDt && [pDt timeIntervalSinceNow] < 0 )
 741             {
 742                 return true;
 743             }
 744         }
 745     }
 746
 747     if (![NSThread isMainThread])
 748         return false;
 749
 750     unsigned/*NSUInteger*/ nEventMask = 0;
 751 SAL_WNODEPRECATED_DECLARATIONS_PUSH
 752         // 'NSFlagsChangedMask' is deprecated: first deprecated in macOS 10.12
 753         // 'NSKeyDownMask' is deprecated: first deprecated in macOS 10.12
 754         // 'NSKeyUpMask' is deprecated: first deprecated in macOS 10.12
 755         // 'NSLeftMouseDownMask' is deprecated: first deprecated in macOS 10.12
 756         // 'NSLeftMouseDraggedMask' is deprecated: first deprecated in macOS 10.12
 757         // 'NSLeftMouseUpMask' is deprecated: first deprecated in macOS 10.12
 758         // 'NSMouseEnteredMask' is deprecated: first deprecated in macOS 10.12
 759         // 'NSMouseExitedMask' is deprecated: first deprecated in macOS 10.12
 760         // 'NSOtherMouseDownMask' is deprecated: first deprecated in macOS 10.12
 761         // 'NSOtherMouseDraggedMask' is deprecated: first deprecated in macOS 10.12
 762         // 'NSOtherMouseUpMask' is deprecated: first deprecated in macOS 10.12
 763         // 'NSRightMouseDownMask' is deprecated: first deprecated in macOS 10.12
 764         // 'NSRightMouseDraggedMask' is deprecated: first deprecated in macOS 10.12
 765         // 'NSRightMouseUpMask' is deprecated: first deprecated in macOS 10.12
 766         // 'NSScrollWheelMask' is deprecated: first deprecated in macOS 10.12
 767         // 'NSTabletPoint' is deprecated: first deprecated in macOS 10.12
 768     if( nType & VclInputFlags::MOUSE)
 769         nEventMask |=
 770             NSLeftMouseDownMask    | NSRightMouseDownMask    | NSOtherMouseDownMask |
 771             NSLeftMouseUpMask      | NSRightMouseUpMask      | NSOtherMouseUpMask |
 772             NSLeftMouseDraggedMask | NSRightMouseDraggedMask | NSOtherMouseDraggedMask |
 773             NSScrollWheelMask |
 774             // NSMouseMovedMask |
 775             NSMouseEnteredMask | NSMouseExitedMask;
 776     if( nType & VclInputFlags::KEYBOARD)
 777         nEventMask |= NSKeyDownMask | NSKeyUpMask | NSFlagsChangedMask;
 778     if( nType & VclInputFlags::OTHER)
 779         nEventMask |= NSTabletPoint;
 780 SAL_WNODEPRECATED_DECLARATIONS_POP
 781     // TODO: VclInputFlags::PAINT / more VclInputFlags::OTHER
 782     if( !bool(nType) )
 783         return false;
 784
 785     NSEvent* pEvent = [NSApp nextEventMatchingMask: nEventMask untilDate: nil
 786                             inMode: NSDefaultRunLoopMode dequeue: NO];
 787     return (pEvent != nullptr);
 788 }
 789
 790 SalFrame* AquaSalInstance::CreateChildFrame( SystemParentData*, SalFrameStyleFlags /*nSalFrameStyle*/ )
 791 {
 792     return nullptr;
 793 }
 794
 795 SalFrame* AquaSalInstance::CreateFrame( SalFrame* pParent, SalFrameStyleFlags nSalFrameStyle )
 796 {
 797     SalData::ensureThreadAutoreleasePool();
 798
 799     SalFrame* pFrame = new AquaSalFrame( pParent, nSalFrameStyle );
 800     return pFrame;
 801 }
 802
 803 void AquaSalInstance::DestroyFrame( SalFrame* pFrame )
 804 {
 805     delete pFrame;
 806 }
 807
 808 SalObject* AquaSalInstance::CreateObject( SalFrame* pParent, SystemWindowData* pWindowData, bool /* bShow */ )
 809 {
 810     AquaSalObject *pObject = nullptr;
 811
 812     if ( pParent )
 813         pObject = new AquaSalObject( static_cast<AquaSalFrame*>(pParent), pWindowData );
 814
 815     return pObject;
 816 }
 817
 818 void AquaSalInstance::DestroyObject( SalObject* pObject )
 819 {
 820     delete ( pObject );
 821 }
 822
 823 SalPrinter* AquaSalInstance::CreatePrinter( SalInfoPrinter* pInfoPrinter )
 824 {
 825     return new AquaSalPrinter( dynamic_cast<AquaSalInfoPrinter*>(pInfoPrinter) );
 826 }
 827
 828 void AquaSalInstance::DestroyPrinter( SalPrinter* pPrinter )
 829 {
 830     delete pPrinter;
 831 }
 832
 833 void AquaSalInstance::GetPrinterQueueInfo( ImplPrnQueueList* pList )
 834 {
 835     NSArray* pNames = [NSPrinter printerNames];
 836     NSArray* pTypes = [NSPrinter printerTypes];
 837     unsigned int nNameCount = pNames ? [pNames count] : 0;
 838     unsigned int nTypeCount = pTypes ? [pTypes count] : 0;
 839     SAL_WARN_IF( nTypeCount != nNameCount, "vcl", "type count not equal to printer count" );
 840     for( unsigned int i = 0; i < nNameCount; i++ )
 841     {
 842         NSString* pName = [pNames objectAtIndex: i];
 843         NSString* pType = i < nTypeCount ? [pTypes objectAtIndex: i] : nil;
 844         if( pName )
 845         {
 846             SalPrinterQueueInfo* pInfo = new SalPrinterQueueInfo;
 847             pInfo->maPrinterName    = GetOUString( pName );
 848             if( pType )
 849                 pInfo->maDriver     = GetOUString( pType );
 850             pInfo->mnStatus         = PrintQueueFlags::NONE;
 851             pInfo->mnJobs           = 0;
 852             pInfo->mpSysData        = nullptr;
 853
 854             pList->Add( pInfo );
 855         }
 856     }
 857 }
 858
 859 void AquaSalInstance::GetPrinterQueueState( SalPrinterQueueInfo* )
 860 {
 861 }
 862
 863 void AquaSalInstance::DeletePrinterQueueInfo( SalPrinterQueueInfo* pInfo )
 864 {
 865     delete pInfo;
 866 }
 867
 868 OUString AquaSalInstance::GetDefaultPrinter()
 869 {
 870     // #i113170# may not be the main thread if called from UNO API
 871     SalData::ensureThreadAutoreleasePool();
 872
 873     if( maDefaultPrinter.isEmpty() )
 874     {
 875         NSPrintInfo* pPI = [NSPrintInfo sharedPrintInfo];
 876         SAL_WARN_IF( !pPI, "vcl", "no print info" );
 877         if( pPI )
 878         {
 879             NSPrinter* pPr = [pPI printer];
 880             SAL_WARN_IF( !pPr, "vcl", "no printer in default info" );
 881             if( pPr )
 882             {
 883                 NSString* pDefName = [pPr name];
 884                 SAL_WARN_IF( !pDefName, "vcl", "printer has no name" );
 885                 maDefaultPrinter = GetOUString( pDefName );
 886             }
 887         }
 888     }
 889     return maDefaultPrinter;
 890 }
 891
 892 SalInfoPrinter* AquaSalInstance::CreateInfoPrinter( SalPrinterQueueInfo* pQueueInfo,
 893                                                     ImplJobSetup* pSetupData )
 894 {
 895     // #i113170# may not be the main thread if called from UNO API
 896     SalData::ensureThreadAutoreleasePool();
 897
 898     SalInfoPrinter* pNewInfoPrinter = nullptr;
 899     if( pQueueInfo )
 900     {
 901         pNewInfoPrinter = new AquaSalInfoPrinter( *pQueueInfo );
 902         if( pSetupData )
 903             pNewInfoPrinter->SetPrinterData( pSetupData );
 904     }
 905
 906     return pNewInfoPrinter;
 907 }
 908
 909 void AquaSalInstance::DestroyInfoPrinter( SalInfoPrinter* pPrinter )
 910 {
 911     // #i113170# may not be the main thread if called from UNO API
 912     SalData::ensureThreadAutoreleasePool();
 913
 914     delete pPrinter;
 915 }
 916
 917 OUString AquaSalInstance::GetConnectionIdentifier()
 918 {
 919     return OUString();
 920 }
 921
 922 // We need to re-encode file urls because osl_getFileURLFromSystemPath converts
 923 // to UTF-8 before encoding non ascii characters, which is not what other apps expect.
 924 static OUString translateToExternalUrl(const OUString& internalUrl)
 925 {
 926     uno::Reference< uno::XComponentContext > context(
 927         comphelper::getProcessComponentContext());
 928     return uri::ExternalUriReferenceTranslator::create(context)->translateToExternal(internalUrl);
 929 }
 930
 931 // #i104525# many versions of OSX have problems with some URLs:
 932 // when an app requests OSX to add one of these URLs to the "Recent Items" list
 933 // then this app gets killed (TextEdit, Preview, etc. and also OOo)
 934 static bool isDangerousUrl( const OUString& rUrl )
 935 {
 936     // use a heuristic that detects all known cases since there is no official comment
 937     // on the exact impact and root cause of the OSX bug
 938     const int nLen = rUrl.getLength();
 939     const sal_Unicode* p = rUrl.getStr();
 940     for( int i = 0; i < nLen-3; ++i, ++p ) {
 941         if( p[0] != '%' )
 942             continue;
 943         // escaped percent?
 944         if( (p[1] == '2') && (p[2] == '5') )
 945             return true;
 946         // escapes are considered to be UTF-8 encoded
 947         // => check for invalid UTF-8 leading byte
 948         if( (p[1] != 'f') && (p[1] != 'F') )
 949             continue;
 950         int cLowNibble = p[2];
 951         if( (cLowNibble >= '0' ) && (cLowNibble <= '9'))
 952             return false;
 953         if( cLowNibble >= 'a' )
 954             cLowNibble -= 'a' - 'A';
 955         if( (cLowNibble < 'A') || (cLowNibble >= 'C'))
 956             return true;
 957     }
 958
 959     return false;
 960 }
 961
 962 void AquaSalInstance::AddToRecentDocumentList(const OUString& rFileUrl, const OUString& /*rMimeType*/, const OUString& /*rDocumentService*/)
 963 {
 964     // Convert file URL for external use (see above)
 965     OUString externalUrl = translateToExternalUrl(rFileUrl);
 966     if( externalUrl.isEmpty() )
 967         externalUrl = rFileUrl;
 968
 969     if( !externalUrl.isEmpty() && !isDangerousUrl( externalUrl ) )
 970     {
 971         NSString* pString = CreateNSString( externalUrl );
 972         NSURL* pURL = [NSURL URLWithString: pString];
 973
 974         if( pURL )
 975         {
 976             NSDocumentController* pCtrl = [NSDocumentController sharedDocumentController];
 977             [pCtrl noteNewRecentDocumentURL: pURL];
 978         }
 979         if( pString )
 980             [pString release];
 981     }
 982 }
 983
 984 SalTimer* AquaSalInstance::CreateSalTimer()
 985 {
 986     return new AquaSalTimer();
 987 }
 988
 989 SalSystem* AquaSalInstance::CreateSalSystem()
 990 {
 991     return new AquaSalSystem();
 992 }
 993
 994 SalBitmap* AquaSalInstance::CreateSalBitmap()
 995 {
 996     return new QuartzSalBitmap();
 997 }
 998
 999 SalSession* AquaSalInstance::CreateSalSession()
1000 {
1001     return nullptr;
1002 }
1003
1004 OUString AquaSalInstance::getOSVersion()
1005 {
1006     NSString * versionString = nullptr;
1007     NSString * sysVersionDictionaryPath = @"/System/Library/CoreServices/SystemVersion.plist";
1008     NSDictionary * sysVersionDict = [ NSDictionary dictionaryWithContentsOfFile: sysVersionDictionaryPath ];
1009     if ( sysVersionDict )
1010         versionString = [ sysVersionDict valueForKey: @"ProductVersion" ];
1011
1012     OUString aVersion = "Mac OS X ";
1013     if ( versionString )
1014         aVersion += OUString::fromUtf8( [ versionString UTF8String ] );
1015     else
1016         aVersion += "(unknown)";
1017
1018     return aVersion;
1019 }
1020
1021 // YieldMutexReleaser
1022 YieldMutexReleaser::YieldMutexReleaser() : mnCount( 0 )
1023 {
1024     SalData* pSalData = GetSalData();
1025     if( ! pSalData->mpFirstInstance->isNSAppThread() )
1026     {
1027         SalData::ensureThreadAutoreleasePool();
1028         mnCount = pSalData->mpFirstInstance->ReleaseYieldMutex();
1029     }
1030 }
1031
1032 YieldMutexReleaser::~YieldMutexReleaser()
1033 {
1034     if( mnCount != 0 )
1035         GetSalData()->mpFirstInstance->AcquireYieldMutex( mnCount );
1036 }
1037
1038 CGImageRef CreateCGImage( const Image& rImage )
1039 {
1040     BitmapEx aBmpEx( rImage.GetBitmapEx() );
1041     Bitmap aBmp( aBmpEx.GetBitmap() );
1042
1043     if( ! aBmp || ! aBmp.ImplGetImpBitmap() )
1044         return nullptr;
1045
1046     // simple case, no transparency
1047     QuartzSalBitmap* pSalBmp = static_cast<QuartzSalBitmap*>(aBmp.ImplGetImpBitmap()->ImplGetSalBitmap());
1048
1049     if( ! pSalBmp )
1050         return nullptr;
1051
1052     CGImageRef xImage = nullptr;
1053     if( ! (aBmpEx.IsAlpha() || aBmpEx.IsTransparent() ) )
1054         xImage = pSalBmp->CreateCroppedImage( 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight );
1055     else if( aBmpEx.IsAlpha() )
1056     {
1057         AlphaMask aAlphaMask( aBmpEx.GetAlpha() );
1058         Bitmap aMask( aAlphaMask.GetBitmap() );
1059         QuartzSalBitmap* pMaskBmp = static_cast<QuartzSalBitmap*>(aMask.ImplGetImpBitmap()->ImplGetSalBitmap());
1060         if( pMaskBmp )
1061             xImage = pSalBmp->CreateWithMask( *pMaskBmp, 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight );
1062         else
1063             xImage = pSalBmp->CreateCroppedImage( 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight );
1064     }
1065     else if( aBmpEx.GetTransparentType() == TransparentType::Bitmap )
1066     {
1067         Bitmap aMask( aBmpEx.GetMask() );
1068         QuartzSalBitmap* pMaskBmp = static_cast<QuartzSalBitmap*>(aMask.ImplGetImpBitmap()->ImplGetSalBitmap());
1069         if( pMaskBmp )
1070             xImage = pSalBmp->CreateWithMask( *pMaskBmp, 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight );
1071         else
1072             xImage = pSalBmp->CreateCroppedImage( 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight );
1073     }
1074     else if( aBmpEx.GetTransparentType() == TransparentType::Color )
1075     {
1076         Color aTransColor( aBmpEx.GetTransparentColor() );
1077         SalColor nTransColor = MAKE_SALCOLOR( aTransColor.GetRed(), aTransColor.GetGreen(), aTransColor.GetBlue() );
1078         xImage = pSalBmp->CreateColorMask( 0, 0, pSalBmp->mnWidth, pSalBmp->mnHeight, nTransColor );
1079     }
1080
1081     return xImage;
1082 }
1083
1084 NSImage* CreateNSImage( const Image& rImage )
1085 {
1086     CGImageRef xImage = CreateCGImage( rImage );
1087
1088     if( ! xImage )
1089         return nil;
1090
1091     Size aSize( rImage.GetSizePixel() );
1092     NSImage* pImage = [[NSImage alloc] initWithSize: NSMakeSize( aSize.Width(), aSize.Height() )];
1093     if( pImage )
1094     {
1095         [pImage lockFocusFlipped:YES];
1096         NSGraphicsContext* pContext = [NSGraphicsContext currentContext];
1097         CGContextRef rCGContext = static_cast<CGContextRef>([pContext graphicsPort]);
1098
1099         const CGRect aDstRect = { {0, 0}, { static_cast<CGFloat>(aSize.Width()), static_cast<CGFloat>(aSize.Height()) } };
1100         CGContextDrawImage( rCGContext, aDstRect, xImage );
1101
1102         [pImage unlockFocus];
1103     }
1104
1105     CGImageRelease( xImage );
1106
1107     return pImage;
1108 }
1109
1110
1111 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */