565         // If Qt is used as a plugin, or just added into a native cocoa

   571         // First, send all previously excluded input events, if any:

   566         // application, we should not run or stop NSApplication;

   572         if (!(flags & QEventLoop::ExcludeUserInputEvents)) {

   567         // This will be done from outside Qt.

   573             while (!d->queuedUserInputEvents.isEmpty()) {

   568         // And if processEvents is called manually (rather than from QEventLoop), we

   574                 event = static_cast<NSEvent *>(d->queuedUserInputEvents.takeFirst());

   569         // cannot enter a tight loop and block the call, but instead return after one flush:

   575                 if (!filterEvent(event)) {

   570         bool canExec_3rdParty = d->nsAppRunCalledByQt || ![NSApp isRunning];

   576                     qt_mac_send_event(flags, event, 0);

   571         bool canExec_Qt = flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec;

   577                     retVal = true;

   578                 }

   579                 [event release];

   580             }

   581         }

   582 

   583         // If Qt is used as a plugin, or as an extension in a native cocoa

   584         // application, we should not run or stop NSApplication; This will be

   585         // done from the application itself. And if processEvents is called

   586         // manually (rather than from a QEventLoop), we cannot enter a tight

   587         // loop and block this call, but instead we need to return after one flush:

   588         const bool canExec_3rdParty = d->nsAppRunCalledByQt || ![NSApp isRunning];

   589         const bool canExec_Qt = flags & QEventLoop::DialogExec || flags & QEventLoop::EventLoopExec;

   575             // interrupted. This is mostly an optimization, but it also allow us

   593             // interrupted. This is mostly an optimization, but it allow us to use

   576             // to use [NSApp run], which is the recommended way of running applications

   594             // [NSApp run], which is the normal code path for cocoa applications.

   577             // in cocoa. [NSApp run] should be called at least once for any cocoa app.

   583                     // INVARIANT: Someone called e.g. [NSApp stopModal:] from outside the event

   601                     // Someone called [NSApp stopModal:] from outside the event

   594         } else do {

   612         } else {

   595             // INVARIANT: We cannot block the thread (and run in a tight loop).

   613             // We cannot block the thread (and run in a tight loop).

   597             bool mustRelease = false;

   615             d->ensureNSAppInitialized();

   598 

   616             if (NSModalSession session = d->currentModalSession()) {

   599             if (!(flags & QEventLoop::ExcludeUserInputEvents) && !d->queuedUserInputEvents.isEmpty()) {

   617                 if (flags & QEventLoop::WaitForMoreEvents)

   600                 // Process a pending user input event

   618                     qt_mac_waitForMoreModalSessionEvents();

   601                 mustRelease = true;

   619                 NSInteger status = [NSApp runModalSession:session];

   602                 event = static_cast<NSEvent *>(d->queuedUserInputEvents.takeFirst());

   620                 if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {

   603             } else {

   621                     // INVARIANT: Someone called [NSApp stopModal:] from outside the event

   604                 if (NSModalSession session = d->currentModalSession()) {

   622                     // dispatcher (e.g to stop a native dialog). But that call wrongly stopped

   605                     if (flags & QEventLoop::WaitForMoreEvents)

   623                     // 'session' as well. As a result, we need to restart all internal sessions:

   606                         qt_mac_waitForMoreModalSessionEvents();

   624                     d->temporarilyStopAllModalSessions();

   607                     NSInteger status = [NSApp runModalSession:session];

   625                 }

   608                     if (status != NSRunContinuesResponse && session == d->currentModalSessionCached) {

   626                 retVal = true;

   609                         // INVARIANT: Someone called e.g. [NSApp stopModal:] from outside the event

   627             } else do {

   610                         // dispatcher (e.g to stop a native dialog). But that call wrongly stopped

   628                 event = [NSApp nextEventMatchingMask:NSAnyEventMask

   611                         // 'session' as well. As a result, we need to restart all internal sessions:

   629                     untilDate:nil

   612                         d->temporarilyStopAllModalSessions();

   630                     inMode:NSDefaultRunLoopMode

   613                     }

   631                     dequeue: YES];

   614                     retVal = true;

   632 

   615                     break;

   633                 if (event) {

   616                 } else {

   634                     if (flags & QEventLoop::ExcludeUserInputEvents) {

   617                     event = [NSApp nextEventMatchingMask:NSAnyEventMask

   635                         if (IsMouseOrKeyEvent(event)) {

   618                         untilDate:nil

   636                             [event retain];

   619                         inMode:NSDefaultRunLoopMode

   637                             d->queuedUserInputEvents.append(event);

   620                         dequeue: YES];

   638                             continue;

   621 

   622                     if (event != nil) {

   623                         if (flags & QEventLoop::ExcludeUserInputEvents) {

   624                             if (IsMouseOrKeyEvent(event)) {

   625                                 // retain event here?

   626                                 [event retain];

   627                                 d->queuedUserInputEvents.append(event);

   628                                 continue;

   629                             }

   633             }

   644             } while (!d->interrupt && event != nil);

   634             if (event) {

   645 

   635                 if (!filterEvent(event) && qt_mac_send_event(flags, event, 0))

   646             // Since the window that holds modality might have changed while processing

   636                     retVal = true;

   647             // events, we we need to interrupt when we return back the previous process

   637                 if (mustRelease)

   648             // event recursion to ensure that we spin the correct modal session.

   638                     [event release];

   649             // We do the interruptLater at the end of the function to ensure that we don't

   639             }

   650             // disturb the 'wait for more events' below (as deleteLater will post an event):

   640         } while(!d->interrupt && event != nil);

   651             interruptLater = true;

   641 

   652         }

   694     // In case we _now_ process events using [NSApp run], we need to stop it to

   713     if (interruptLater)

   695     // ensure that:

   714         QtMacInterruptDispatcherHelp::interruptLater();

   696     //    1. the QEventLoop that called us is still executing, or

   715 #endif

   697     //    2. we have a modal session that needs to be spun instead.

   698     // In case this is a plain call to processEvents (perhaps from a loop) 

   699     // from the application (rather than from a QEventLoop), we delay the

   700     // interrupting until we/ actually enter a lower loop level (hence the

   701     // deffered delete of the object below):

   702     QtMacInterruptDispatcherHelp::interruptLater();

   703 #endif

   704 

   705     if (d->interrupt) {

   706         // We should continue to leave all recursion to processEvents until

   707         // processEvents is called again (e.g. from a QEventLoop that 

   708         // was not yet told to quit:

   709         interrupt();

   710     }

   747 int QEventDispatcherMacPrivate::activeModalSessionCount()

   754 void QEventDispatcherMacPrivate::ensureNSAppInitialized()

   748 {

   755 {

   749     // Returns the number of modal sessions created

   756     // Some elements in Cocoa require NSApplication to be running before

   750     // (and not just pushed onto the stack, pending to be created)

   757     // they get fully initialized, in particular the menu bar. This

   751     int count = 0;

   758     // function is intended for cases where a dialog is told to execute before

   752     for (int i=cocoaModalSessionStack.size()-1; i>=0; --i) {

   759     // QApplication::exec is called, or the application spins the events loop

   753         QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];

   760     // manually rather than calling QApplication:exec.

   754         if (info.session)

   761     // The function makes sure that NSApplication starts running, but stops

   755             ++count;

   762     // it again as soon as the send posted events callback is called. That way

   756     }

   763     // we let Cocoa finish the initialization it seems to need. We'll only

   757     return count;

   764     // apply this trick at most once for any application, and we avoid doing it

   765     // for the common case where main just starts QApplication::exec.

   766     if (nsAppRunCalledByQt || [NSApp isRunning])

   767         return;

   768     nsAppRunCalledByQt = true;

   769     QBoolBlocker block1(interrupt, true);

   770     QBoolBlocker block2(currentExecIsNSAppRun, true);

   771     [NSApp run];

   762     // Stop all created modal session, and as such, make then

   776     // Flush, and Stop, all created modal session, and as

   763     // pending again. The next call to currentModalSession will

   777     // such, make them pending again. The next call to

   764     // recreate the session on top again:

   778     // currentModalSession will recreate them again. The

   779     // reason to stop all session like this is that otherwise

   780     // a call [NSApp stop] would not stop NSApp, but rather

   781     // the current modal session. So if we need to stop NSApp

   782     // we need to stop all the modal session first. To avoid changing

   783     // the stacking order of the windows while doing so, we put

   784     // up a block that is used in QCocoaWindow and QCocoaPanel:

   863     // stopped in endModalSession().

   905     // stopped in cleanupModalSessions()).

   864     QCocoaModalSessionInfo info = {widget, 0};

   906     QCocoaModalSessionInfo info = {widget, 0, 0};

   880         if (info.widget == widget)

   922         if (info.widget == widget) {

   882     }

   924             if (i == stackSize-1) {

   883 

   925                 // The top sessions ended. Interrupt the event dispatcher

   884     // Now we stop, and remove, all sessions marked as pending

   926                 // to start spinning the correct session immidiatly: 

   885     // to be stopped on _top_ of the stack, if any:

   927                 cleanupModalSessionsNeeded = true;

   886     bool needToInterruptEventDispatcher = false;

   928                 QEventDispatcherMac::instance()->interrupt();

   887     bool needToUpdateChildrenWorksWhenModal = false;

   929             }

   888 

   930         }

   889     for (int i=stackSize-1; i>=0; --i) {

   931     }

   890         QCocoaModalSessionInfo &info = cocoaModalSessionStack[i];

   891         if (info.widget)

   892             break;

   893         cocoaModalSessionStack.remove(i);

   894         needToUpdateChildrenWorksWhenModal = true;

   895         currentModalSessionCached = 0;

   896         if (info.session) {

   897             [NSApp endModalSession:info.session];

   898             needToInterruptEventDispatcher = true;

   899         }

   900     }

   901 

   902     if (needToUpdateChildrenWorksWhenModal)

   903         updateChildrenWorksWhenModal();

   904     if (needToInterruptEventDispatcher)

   905         QEventDispatcherMac::instance()->interrupt();

   970     if (blockSendPostedEvents || d->interrupt) {

   995     if (blockSendPostedEvents) {

   996         // We're told to not send posted events (because the event dispatcher

   997         // is currently working on setting up the correct session to run). But

   998         // we still need to make sure that we don't fall asleep until pending events

   999         // are sendt, so we just signal this need, and return:

   972     } else {

  1001         return;

   973         if (!d->threadData->canWait || (d->serialNumber != d->lastSerial)) {

  1002     }

   974             d->lastSerial = d->serialNumber;

  1003 

   975             QApplicationPrivate::sendPostedEvents(0, 0, d->threadData);

  1004 #ifdef QT_MAC_USE_COCOA

   976         }

  1005     if (d->cleanupModalSessionsNeeded)

  1006         d->cleanupModalSessions();

  1007 #endif

  1008 

  1009     if (d->interrupt) {

  1010 #ifdef QT_MAC_USE_COCOA

  1011         if (d->currentExecIsNSAppRun) {

  1012             // The event dispatcher has been interrupted. But since

  1013             // [NSApplication run] is running the event loop, we

  1014             // delayed stopping it until now (to let cocoa process 

  1015             // pending cocoa events first).

  1016             if (d->currentModalSessionCached)

  1017                 d->temporarilyStopAllModalSessions();

  1018             [NSApp stop:NSApp];

  1019             d->cancelWaitForMoreEvents();

  1020         }

  1021 #endif

  1022         return;

  1023     }

  1024 

  1025     if (!d->threadData->canWait || (d->serialNumber != d->lastSerial)) {

  1026         d->lastSerial = d->serialNumber;

  1027         QApplicationPrivate::sendPostedEvents(0, 0, d->threadData);

  1003     QMacCocoaAutoReleasePool pool;

  1069     // We do nothing more here than setting d->interrupt = true, and

  1004     // In case we wait for more events inside

  1070     // poke the event loop if it is sleeping. Actually stopping

  1005     // processEvents (or NSApp run), post a dummy to wake it up:

  1071     // NSApp, or the current modal session, is done inside the send

  1006     static const short NSAppShouldStopForQt = SHRT_MAX;

  1072     // posted events callback. We do this to ensure that all current pending

  1007     [NSApp postEvent:[NSEvent otherEventWithType:NSApplicationDefined location:NSZeroPoint

  1073     // cocoa events gets delivered before we stop. Otherwise, if we now stop

  1008         modifierFlags:0 timestamp:0. windowNumber:0 context:0

  1074     // the last event loop recursion, cocoa will just drop pending posted

  1009         subtype:NSAppShouldStopForQt data1:0 data2:0] atStart:NO];

  1075     // events on the floor before we get a chance to reestablish a new session.

  1010 

  1076     d->cancelWaitForMoreEvents();

  1011     if (d->activeModalSessionCount() == 0) {

  1012         // We should only stop NSApp if we actually started it (and

  1013         // not some 3rd party application, e.g. if we are a plugin).

  1014         if (d->nsAppRunCalledByQt)

  1015             [NSApp stop:NSApp];

  1016     }

  1065     // This is the whole point of encapsulation this code

  1123     // The whole point of this class is that we enable a way to interrupt

  1066     // inside a class; we can make the code (inside destructor)

  1124     // the event dispatcher when returning back to a lower recursion level

  1067     // execute on lower loop level:

  1125     // than where interruptLater was called. This is needed to detect if

  1126     // [NSApp run] should still be running at the recursion level it is at.

  1127     // Since the interrupt is canceled if processEvents is called before

  1128     // this object gets deleted, we also avoid interrupting unnecessary.

  1095 void QtMacInterruptDispatcherHelp::interruptLater() {

  1140 void QtMacInterruptDispatcherHelp::cancelInterruptLater()

  1096     if (instance) {

  1141 {

  1097         instance->cancelled = true;

  1142     if (!instance)

  1098         delete instance;

  1143         return;

  1099     }

  1144     instance->cancelled = true;

  1145     delete instance;

  1146     instance = 0;

  1147 }

  1148 

  1149 void QtMacInterruptDispatcherHelp::interruptLater()

  1150 {

  1151     cancelInterruptLater();