- Moved wxApp::SendIdleEvents and wxApp::ProcessIdle into common code.

- wxWindow::OnInternalIdle is now used in all ports, and ensures that
  user OnIdle events do not interfere with crucial internal processing.
- wxWindow::UpdateWindowUI is now a documented function that
  sends wxUpdateUIEvents, and can be overridden. It has a helper function
  DoUpdateWindowUI for taking appropriate wxUpdateUIEvent action.
- Added functions to wxUpdateUIEvent: Set/GetMode, Set/GetUpdateInterval,
  CanUpdate, to assist with optimising update event frequency.
- Added functions to wxIdleEvent: Set/GetMode, CanSend, to
  determine whether a window should receive idle events.
- Added wxWS_EX_PROCESS_IDLE, wxWS_EX_PROCESS_UI_UPDATES window
  styles for use with conservative idle and update event modes.
- wxMSW and wxGTK now send menu update events only when a menu is
  about to be used.
- Added WM_INITMENU processing instead of WM_ENTERMENULOOP, or
  accelerators don't always get called since menu items may still
  be disabled.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@21789 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/docs/changes.txt b/docs/changes.txt
index 859cdd49e147d32bc85e4a88474d400acecc2fd9..45e927310e7965ca9186c2d1495cf4177cdf6770 100644 (file)
--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -103,6 +103,20 @@ All GUI ports:
 - Added m_ prefix to wxColourData and wxFontData members
 - Added wxHtmlPrintout::AddFilter so HTML printing can be subject to
   custom filters as well as HTML viewing.
 - Added m_ prefix to wxColourData and wxFontData members
 - Added wxHtmlPrintout::AddFilter so HTML printing can be subject to
   custom filters as well as HTML viewing.

+- Moved wxApp::SendIdleEvents and wxApp::ProcessIdle into common code.
+- wxWindow::OnInternalIdle is now used in all ports, and ensures that
+  user OnIdle events do not interfere with crucial internal processing.
+- wxWindow::UpdateWindowUI is now a documented function that
+  sends wxUpdateUIEvents, and can be overridden. It has a helper function
+  DoUpdateWindowUI for taking appropriate wxUpdateUIEvent action.
+- Added functions to wxUpdateUIEvent: Set/GetMode, Set/GetUpdateInterval,
+  CanUpdate, to assist with optimising update event frequency.
+- Added functions to wxIdleEvent: Set/GetMode, CanSend, to
+  determine whether a window should receive idle events.
+- Added wxWS_EX_PROCESS_IDLE, wxWS_EX_PROCESS_UI_UPDATES window
+  styles for use with conservative idle and update event modes.
+- wxMSW and wxGTK now send menu update events only when a menu is
+  about to be used.

 
 Unix:
 
 
 Unix:
 

diff --git a/docs/latex/wx/idleevt.tex b/docs/latex/wx/idleevt.tex
index 5ba984e4810c14c1b6f6edc6056e00b15ce7b16a..329c0b8ef8b35886b4f873a30a47ddfd394e6db2 100644 (file)
--- a/docs/latex/wx/idleevt.tex
+++ b/docs/latex/wx/idleevt.tex
@@ -2,6 +2,15 @@
 
 This class is used for idle events, which are generated when the system is idle.
 
 
 This class is used for idle events, which are generated when the system is idle.
 

+By default, idle events are sent to all windows. If this is causing a significant
+overhead in your application, you can call \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} with
+the value wxIDLE\_PROCESS\_SPECIFIED, and set the wxWS\_EX\_PROCESS\_IDLE extra
+window style for every window which should receive idle events.
+
+The function \helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle} is
+also provided for internal purposes, and cannot be disabled. wxUpdateUIEvents
+are sent from OnInternalIdle.
+

 \wxheading{Derived from}
 
 \helpref{wxEvent}{wxevent}\\
 \wxheading{Derived from}
 
 \helpref{wxEvent}{wxevent}\\


@@ -27,7 +36,8 @@ Idle events can be caught by the wxApp class, or by top-level window classes.
 
 \wxheading{See also}
 
 
 \wxheading{See also}
 

-\helpref{Event handling overview}{eventhandlingoverview}
+\helpref{Event handling overview}{eventhandlingoverview}, \helpref{wxUpdateUIEvent}{wxupdateuievent}, 
+\helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle}

 
 \latexignore{\rtfignore{\wxheading{Members}}}
 
 
 \latexignore{\rtfignore{\wxheading{Members}}}
 


@@ -37,6 +47,33 @@ Idle events can be caught by the wxApp class, or by top-level window classes.
 
 Constructor.
 
 
 Constructor.
 

+\membersection{wxIdleEvent::CanSend}\label{wxidleeventcansend}
+
+\func{static bool}{CanSend}{\param{wxWindow*}{ window}}
+
+Returns {\tt true} if it is appropriate to send idle events to
+this window.
+
+This function looks at the mode used (see \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode}),
+and the wxWS\_EX\_PROCESS\_IDLE style in {\it window} to determine whether idle events should be sent to
+this window now. By default this will always return {\tt true} because
+the update mode is initially wxIDLE\_PROCESS\_ALL. You can change the mode
+to only send idle events to windows with the wxWS\_EX\_PROCESS\_IDLE extra window style set.
+
+\wxheading{See also}
+
+\helpref{wxIdleEvent::SetMode}{wxidlesetmode}
+
+\membersection{wxIdleEvent::GetMode}\label{wxidleeventgetmode}
+
+\func{static wxIdleMode}{GetMode}{\void}
+
+Static function returning a value specifying how wxWindows
+will send idle events: to all windows, or only to those which specify that they
+will process the events.
+
+See \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode}.
+

 \membersection{wxIdleEvent::RequestMore}\label{wxidleeventrequestmore}
 
 \func{void}{RequestMore}{\param{bool}{ needMore = true}}
 \membersection{wxIdleEvent::RequestMore}\label{wxidleeventrequestmore}
 
 \func{void}{RequestMore}{\param{bool}{ needMore = true}}


@@ -61,3 +98,26 @@ Returns true if the OnIdle function processing this event requested more process
 
 \helpref{wxIdleEvent::RequestMore}{wxidleeventrequestmore}
 
 
 \helpref{wxIdleEvent::RequestMore}{wxidleeventrequestmore}
 

+\membersection{wxIdleEvent::SetMode}\label{wxidleeventsetmode}
+
+\func{static void}{SetMode}{\param{wxIdleMode }{mode}}
+
+Static function for specifying how wxWindows will send idle events: to
+all windows, or only to those which specify that they
+will process the events.
+
+{\it mode} can be one of the following values.
+The default is wxIDLE\_PROCESS\_ALL.
+
+\begin{verbatim}
+enum wxIdleMode
+{
+        // Send idle events to all windows
+    wxIDLE_PROCESS_ALL,
+
+        // Send idle events to windows that have
+        // the wxWS_EX_PROCESS_IDLE flag specified
+    wxIDLE_PROCESS_SPECIFIED
+};
+\end{verbatim}
+

diff --git a/docs/latex/wx/upduievt.tex b/docs/latex/wx/upduievt.tex
index a82b4af74c23c70fe86847fe3a109457f6c0ae03..8cb08b8aa59a202d9edb8c4ee2d6f953d091406e 100644 (file)
--- a/docs/latex/wx/upduievt.tex
+++ b/docs/latex/wx/upduievt.tex
@@ -46,6 +46,29 @@ These events will work for popup menus as well as menubars. Just before a menu i
 up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui} is called to process any UI events for
 the window that owns the menu.
 
 up, \helpref{wxMenu::UpdateUI}{wxmenuupdateui} is called to process any UI events for
 the window that owns the menu.
 

+If you find that the overhead of UI update processing is affecting
+your application, you can do one or both of the following:
+
+\begin{enumerate}
+\item Call \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} with
+a value of wxUPDATE\_UI\_PROCESS\_SPECIFIED, and set the extra style
+wxWS\_EX\_PROCESS\_UPDATE\_EVENTS for every window that should receive update events.
+No other windows will receive update events.
+\item Call \helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval} with
+a millisecond value to set the delay between updates. You may need
+to call \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui} at critical
+points, for example when a dialog is about to be shown, in case the user
+sees a slight delay before windows are updated.
+\end{enumerate}
+
+Note that although events are sent in idle time, defining a wxIdleEvent
+handler for a window does not affect this because the events are sent from \helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle} 
+which is {\bf always} called in idle time.
+
+wxWindows tries to optimize update events on some platforms. On Windows
+and GTK+, events for menubar items are only sent when the menu is about
+to be shown, and not in idle time.
+

 \wxheading{See also}
 
 \helpref{Event handling overview}{eventhandlingoverview}
 \wxheading{See also}
 
 \helpref{Event handling overview}{eventhandlingoverview}


@@ -95,6 +118,29 @@ true if the application has set the {\bf m\_text} member.
 Holds the text with which the the application wishes to
 update the UI element.
 
 Holds the text with which the the application wishes to
 update the UI element.
 

+\membersection{wxUpdateUIEvent::CanUpdate}\label{wxupdateuieventcanupdate}
+
+\func{static bool}{CanUpdate}{\param{wxWindow*}{ window}}
+
+Returns {\tt true} if it is appropriate to update (send UI update events to)
+this window.
+
+This function looks at the mode used (see \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode}),
+the wxWS\_EX\_PROCESS\_UPDATE\_EVENTS flag in {\it window},
+the time update events were last sent in idle time, and
+the update interval, to determine whether events should be sent to
+this window now. By default this will always return {\tt true} because
+the update mode is initially wxUPDATE\_UI\_PROCESS\_ALL and
+the interval is set to 0; so update events will be sent as
+often as possible. You can reduce the frequency that events
+are sent by changing the mode and/or setting an update interval.
+
+\wxheading{See also}
+
+\helpref{wxUpdateUIEvent::ResetUpdateTime}{wxupdateuieventresetupdatetime}, 
+\helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval}, 
+\helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode}
+

 \membersection{wxUpdateUIEvent::Check}\label{wxupdateuieventcheck}
 
 \func{void}{Check}{\param{bool}{ check}}
 \membersection{wxUpdateUIEvent::Check}\label{wxupdateuieventcheck}
 
 \func{void}{Check}{\param{bool}{ check}}


@@ -143,9 +189,80 @@ Returns true if the application has called {\bf SetText}. For wxWindows internal
 
 Returns the text that should be set for the UI element.
 
 
 Returns the text that should be set for the UI element.
 

+\membersection{wxUpdateUIEvent::GetMode}\label{wxupdateuieventgetmode}
+
+\func{static wxUpdateUIMode}{GetMode}{\void}
+
+Static function returning a value specifying how wxWindows
+will send update events: to all windows, or only to those which specify that they
+will process the events.
+
+See \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode}.
+
+\membersection{wxUpdateUIEvent::GetUpdateInterval}\label{wxupdateuieventgetupdateinterval}
+
+\func{static long}{GetUpdateInterval}{\void}
+
+Returns the current interval between updates in milliseconds.
+-1 disables updates, 0 updates as frequently as possible.
+
+See \helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval}.
+
+\membersection{wxUpdateUIEvent::ResetUpdateTime}\label{wxupdateuieventresetupdatetime}
+
+\func{static void}{ResetUpdateTime}{\void}
+
+Used internally to reset the last-updated time to the
+current time. It is assumed that update events are
+normally sent in idle time, so this is called at the end of
+idle processing.
+
+\wxheading{See also}
+
+\helpref{wxUpdateUIEvent::CanUpdate}{wxupdateuieventcanupdate}, 
+\helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval}, 
+\helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode}
+
+\membersection{wxUpdateUIEvent::SetMode}\label{wxupdateuieventsetmode}
+
+\func{static void}{SetMode}{\param{wxIdleMode }{mode}}
+
+Specify how wxWindows will send update events: to
+all windows, or only to those which specify that they
+will process the events.
+
+{\it mode} may be one of the following values.
+The default is wxUPDATE\_UI\_PROCESS\_ALL.
+
+\begin{verbatim}
+enum wxUpdateUIMode
+{
+        // Send UI update events to all windows
+    wxUPDATE_UI_PROCESS_ALL,
+
+        // Send UI update events to windows that have
+        // the wxWS_EX_PROCESS_UI_UPDATES flag specified
+    wxUPDATE_UI_PROCESS_SPECIFIED
+};
+\end{verbatim}
+

 \membersection{wxUpdateUIEvent::SetText}\label{wxupdateuieventsettext}
 
 \func{void}{SetText}{\param{const wxString\&}{ text}}
 
 Sets the text for this UI element.
 
 \membersection{wxUpdateUIEvent::SetText}\label{wxupdateuieventsettext}
 
 \func{void}{SetText}{\param{const wxString\&}{ text}}
 
 Sets the text for this UI element.
 

+\membersection{wxUpdateUIEvent::SetUpdateInterval}\label{wxupdateuieventsetupdateinterval}
+
+\func{static void}{SetUpdateInterval}{\param{long }{updateInterval}}
+
+Sets the interval between updates in milliseconds.
+Set to -1 to disable updates, or to 0 to update as frequently as possible.
+The default is 0.
+
+Use this to reduce the overhead of UI update events if your application
+has a lot of windows. If you set the value to -1 or greater than 0,
+you may also need to call \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui} 
+at appropriate points in your application, such as when a dialog
+is about to be shown.
+

diff --git a/docs/latex/wx/window.tex b/docs/latex/wx/window.tex
index 666ffa1dcd9fa0e01fb7a0dade57cdd6087c26a5..752b905bca79cef18dd7fa1eed7aef68553c4db3 100644 (file)
--- a/docs/latex/wx/window.tex
+++ b/docs/latex/wx/window.tex
@@ -57,6 +57,30 @@ repainted, then children being painted over them. Windows only.}
 
 See also \helpref{window styles overview}{windowstyles}.
 
 
 See also \helpref{window styles overview}{windowstyles}.
 

+\wxheading{Extra window styles}
+
+The following are extra styles, set using \helpref{wxWindow::SetExtraStyle}{wxwindowsetextrastyle}.
+
+\twocolwidtha{5cm}%
+\begin{twocollist}\itemsep=0pt
+\twocolitem{\windowstyle{wxWS\_EX\_VALIDATE\_RECURSIVELY}}{By default, Validate/TransferDataTo/FromWindow()
+only work on direct children of the window (compatible behaviour). Set this flag to make them recursively
+descend into all subwindows.}
+\twocolitem{\windowstyle{wxWS\_EX\_BLOCK\_EVENTS}}{wxCommandEvents and the objects of the derived classes are forwarded to the
+parent window and so on recursively by default. Using this flag for the
+given window allows to block this propagation at this window, i.e. prevent
+the events from being propagated further upwards. Dialogs have this
+flag on by default.}
+\twocolitem{\windowstyle{wxWS\_EX\_TRANSIENT}}{Don't use this window as an implicit parent for the other windows: this must
+be used with transient windows as otherwise there is the risk of creating a
+dialog/frame with this window as a parent which would lead to a crash if the
+parent is destroyed before the child.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_IDLE}}{This window should always process idle events, even
+if the mode set by \helpref{wxIdleEvent::SetMode}{wxidleeventsetmode} is wxIDLE\_PROCESS\_SPECIFIED.}
+\twocolitem{\windowstyle{wxWS\_EX\_PROCESS\_UI\_UPDATES}}{This window should always process UI update events,
+even if the mode set by \helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} is wxUPDATE\_UI\_PROCESS\_SPECIFIED.}
+\end{twocollist}
+

 \wxheading{See also}
 
 \helpref{Event handling overview}{eventhandlingoverview}
 \wxheading{See also}
 
 \helpref{Event handling overview}{eventhandlingoverview}


@@ -408,6 +432,31 @@ Disables the window, same as \helpref{Enable({\tt false})}{wxwindowenable}.
 Returns {\tt true} if the window has been disabled, {\tt false} if it had been
 already disabled before the call to this function.
 
 Returns {\tt true} if the window has been disabled, {\tt false} if it had been
 already disabled before the call to this function.
 

+\membersection{wxWindow::DoUpdateWindowUI}\label{wxwindowdoupdatewindowui}
+
+\func{virtual void}{DoUpdateWindowUI}{\param{wxUpdateUIEvent\&}{ event}}
+
+Does the window-specific updating after processing the update event.
+This function is called by \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui} 
+in order to check return values in the \helpref{wxUpdateUIEvent}{wxupdateuievent} and
+act appropriately. For example, to allow frame and dialog title updating, wxWindows
+implements this function as follows:
+
+\begin{verbatim}
+// do the window-specific processing after processing the update event
+void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
+{
+    if ( event.GetSetEnabled() )
+        Enable(event.GetEnabled());
+    
+    if ( event.GetSetText() )
+    {
+        if ( event.GetText() != GetTitle() )
+            SetTitle(event.GetText());
+    }
+}
+\end{verbatim}
+

 \membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
 
 \func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}
 \membersection{wxWindow::DragAcceptFiles}\label{wxwindowdragacceptfiles}
 
 \func{virtual void}{DragAcceptFiles}{\param{bool}{ accept}}


@@ -1684,6 +1733,19 @@ implements the following methods:\par
 %% \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
 %% \helpref{Event handling overview}{eventhandlingoverview}
 
 %% \helpref{wxSysColourChangedEvent}{wxsyscolourchangedevent},\rtfsp
 %% \helpref{Event handling overview}{eventhandlingoverview}
 

+\membersection{wxWindow::OnInternalIdle}\label{wxwindowoninternalidle}
+
+\func{virtual void}{OnInternalIdle}{\void}
+
+This virtual function is normally only used internally, but
+sometimes an application may need it to implement functionality
+that should not be disabled by an application defining an OnIdle
+handler in a derived class.
+
+This function may be used to do delayed painting, for example,
+and most implementations call \helpref{wxWindow::UpdateWindowUI}{wxwindowupdatewindowui} 
+in order to send update events to the window in idle time.
+

 \membersection{wxWindow::PageDown}\label{wxwindowpagedown}
 
 This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(1)$.
 \membersection{wxWindow::PageDown}\label{wxwindowpagedown}
 
 This is just a wrapper for \helpref{ScrollPages()}{wxwindowscrollpages}$(1)$.


@@ -2751,6 +2813,54 @@ nothing if the window hadn't been already repainted. Use
 \helpref{Refresh}{wxwindowrefresh} first if you want to immediately redraw the
 window unconditionally.
 
 \helpref{Refresh}{wxwindowrefresh} first if you want to immediately redraw the
 window unconditionally.
 

+\membersection{wxWindow::UpdateWindowUI}\label{wxwindowupdatewindowui}
+
+\func{virtual void}{UpdateWindowUI}{\param{long}{ flags = wxUPDATE_UI_NONE}}
+
+This function sends \helpref{wxUpdateUIEvents}{wxupdateuievent} to
+the window. The particular implementation depends on the window; for
+example a wxToolBar will send an update UI event for each toolbar button,
+and a wxFrame will send an update UI event for each menubar menu item.
+You can call this function from your application to ensure that your
+UI is up-to-date at this point (as far as your wxUpdateUIEvent handlers
+are concerned). This may be necessary if you have called 
+\helpref{wxUpdateUIEvent::SetMode}{wxupdateuieventsetmode} or 
+\helpref{wxUpdateUIEvent::SetUpdateInterval}{wxupdateuieventsetupdateinterval} to
+limit the overhead that wxWindows incurs by sending update UI events in idle time.
+
+{\it flags} should be a bitlist of one or more of the following values.
+
+\begin{verbatim}
+enum wxUpdateUI
+{
+    wxUPDATE_UI_NONE          = 0x0000, // No particular value
+    wxUPDATE_UI_RECURSE       = 0x0001, // Call the function for descendants
+    wxUPDATE_UI_FROMIDLE      = 0x0002  // Invoked from On(Internal)Idle
+};
+\end{verbatim}
+
+If you are calling this function from an OnInternalIdle or OnIdle
+function, make sure you pass the wxUPDATE\_UI\_FROMIDLE flag, since
+this tells the window to only update the UI elements that need
+to be updated in idle time. Some windows update their elements
+only when necessary, for example when a menu is about to be shown.
+The following is an example of how to call UpdateWindowUI from
+an idle function.
+
+\begin{verbatim}
+void MyWindow::OnInternalIdle()
+{
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
+}
+\end{verbatim}
+
+\wxheading{See also}
+
+\helpref{wxUpdateUIEvent}{wxupdateuievent}, 
+\helpref{wxWindow::DoUpdateWindowUI}{wxwindowdoupdatewindowui}, 
+\helpref{wxWindow::OnInternalIdle}{wxwindowoninternalidle}
+

 \membersection{wxWindow::Validate}\label{wxwindowvalidate}
 
 \func{virtual bool}{Validate}{\void}
 \membersection{wxWindow::Validate}\label{wxwindowvalidate}
 
 \func{virtual bool}{Validate}{\void}

diff --git a/include/wx/app.h b/include/wx/app.h
index c541b9015a7cd182880fdf207eee4b4d6a33a359..c479f17df7e40305b67670fb989551527161388f 100644 (file)
--- a/include/wx/app.h
+++ b/include/wx/app.h
@@ -379,7 +379,15 @@ public:
         // parties
         //
         // it should return TRUE if more idle events are needed, FALSE if not
         // parties
         //
         // it should return TRUE if more idle events are needed, FALSE if not

-    virtual bool ProcessIdle() = 0;
+    virtual bool ProcessIdle() ;
+
+        // Send idle event to all top-level windows.
+        // Returns TRUE if more idle time is requested.
+    virtual bool SendIdleEvents();
+
+        // Send idle event to window and all subwindows
+        // Returns TRUE if more idle time is requested.
+    virtual bool SendIdleEvents(wxWindow* win);

 
 
     // top level window functions
 
 
     // top level window functions

diff --git a/include/wx/cocoa/app.h b/include/wx/cocoa/app.h
index ea155949a90fe9578206fdcb3060b922b7e860a0..02bf4fa5b0776f07667f2e3164ba1ac3cd2286b3 100644 (file)
--- a/include/wx/cocoa/app.h
+++ b/include/wx/cocoa/app.h
@@ -51,18 +51,11 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle() { CocoaRequestIdle(); }
     
     /* Idle Processing */
     void OnIdle(wxIdleEvent& event);
     virtual void WakeUpIdle() { CocoaRequestIdle(); }
     
     /* Idle Processing */
     void OnIdle(wxIdleEvent& event);

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents();
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindowCocoa* win);
-    
+

     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();
     virtual bool CallOnInit();
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();
     virtual bool CallOnInit();

diff --git a/include/wx/defs.h b/include/wx/defs.h
index 50e98c4c471cbec00ba0e434d97e5a6164e20d74..85331769e682aeb29d0f514e6e70219bdf0bd554 100644 (file)
--- a/include/wx/defs.h
+++ b/include/wx/defs.h
@@ -1033,6 +1033,12 @@ enum wxBorder
 // possibly be made to work in the future, at least on Windows
 #define wxWS_EX_THEMED_BACKGROUND       0x00000008
 
 // possibly be made to work in the future, at least on Windows
 #define wxWS_EX_THEMED_BACKGROUND       0x00000008
 

+// this window should always process idle events
+#define wxWS_EX_PROCESS_IDLE            0x00000010
+
+// this window should always process UI update events
+#define wxWS_EX_PROCESS_UI_UPDATES      0x00000020
+

 // Use this style to add a context-sensitive help to the window (currently for
 // Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used)
 #define wxFRAME_EX_CONTEXTHELP  0x00000004
 // Use this style to add a context-sensitive help to the window (currently for
 // Win32 only and it doesn't work if wxMINIMIZE_BOX or wxMAXIMIZE_BOX are used)
 #define wxFRAME_EX_CONTEXTHELP  0x00000004


@@ -1860,6 +1866,17 @@ enum wxPrintMode
     wxPRINT_MODE_PRINTER = 3    // Send to printer
 };
 
     wxPRINT_MODE_PRINTER = 3    // Send to printer
 };
 

+// ----------------------------------------------------------------------------
+// UpdateWindowUI flags
+// ----------------------------------------------------------------------------
+
+enum wxUpdateUI
+{
+    wxUPDATE_UI_NONE          = 0x0000,
+    wxUPDATE_UI_RECURSE       = 0x0001,
+    wxUPDATE_UI_FROMIDLE      = 0x0002 // Invoked from On(Internal)Idle
+};
+

 // ----------------------------------------------------------------------------
 // miscellaneous
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // miscellaneous
 // ----------------------------------------------------------------------------

diff --git a/include/wx/event.h b/include/wx/event.h
index 7287f675fc581b1f5f3e8e3f0cff83faeaa46cda..a61b0a9d42beba7bb71e912ee98a49ad266ed2f8 100644 (file)
--- a/include/wx/event.h
+++ b/include/wx/event.h
@@ -1496,6 +1496,20 @@ private:
  wxEVT_UPDATE_UI
  */
 
  wxEVT_UPDATE_UI
  */
 

+// Whether to always send update events to windows, or
+// to only send update events to those with the
+// wxWS_EX_PROCESS_UI_UPDATES style.
+
+enum wxUpdateUIMode
+{
+        // Send UI update events to all windows
+    wxUPDATE_UI_PROCESS_ALL,
+
+        // Send UI update events to windows that have
+        // the wxWS_EX_PROCESS_UI_UPDATES flag specified
+    wxUPDATE_UI_PROCESS_SPECIFIED
+};
+

 class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
 {
 public:
 class WXDLLIMPEXP_CORE wxUpdateUIEvent : public wxCommandEvent
 {
 public:


@@ -1531,18 +1545,26 @@ public:
 
     // Sets the interval between updates in milliseconds.
     // Set to -1 to disable updates, or to 0 to update as frequently as possible.
 
     // Sets the interval between updates in milliseconds.
     // Set to -1 to disable updates, or to 0 to update as frequently as possible.

-    static void SetUpdateInterval(long updateInterval) { m_updateInterval = updateInterval; }
+    static void SetUpdateInterval(long updateInterval) { sm_updateInterval = updateInterval; }

 
     // Returns the current interval between updates in milliseconds
 
     // Returns the current interval between updates in milliseconds

-    static long GetUpdateInterval() { return m_updateInterval ; }
+    static long GetUpdateInterval() { return sm_updateInterval ; }

 
 

-    // Can we update?
-    static bool CanUpdate() ;
+    // Can we update this window?
+    static bool CanUpdate(wxWindow* win) ;

 
     // Reset the update time to provide a delay until the next
     // time we should update
     static void ResetUpdateTime() ;
 
 
     // Reset the update time to provide a delay until the next
     // time we should update
     static void ResetUpdateTime() ;
 

+    // Specify how wxWindows will send update events: to
+    // all windows, or only to those which specify that they
+    // will process the events.
+    static void SetMode(wxUpdateUIMode mode) { sm_updateMode = mode; }
+
+    // Returns the UI update mode
+    static wxUpdateUIMode GetMode() { return sm_updateMode ; }
+

     virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }
 
 protected:
     virtual wxEvent *Clone() const { return new wxUpdateUIEvent(*this); }
 
 protected:


@@ -1553,9 +1575,10 @@ protected:
     bool          m_setChecked;
     wxString      m_text;
 #if wxUSE_LONGLONG
     bool          m_setChecked;
     wxString      m_text;
 #if wxUSE_LONGLONG

-    static wxLongLong   m_lastUpdate;
+    static wxLongLong       sm_lastUpdate;

 #endif
 #endif

-    static long         m_updateInterval;
+    static long             sm_updateInterval;
+    static wxUpdateUIMode   sm_updateMode;

 
 private:
     DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxUpdateUIEvent)


@@ -1875,6 +1898,20 @@ private:
  wxEVT_IDLE
  */
 
  wxEVT_IDLE
  */
 

+// Whether to always send idle events to windows, or
+// to only send update events to those with the
+// wxWS_EX_PROCESS_IDLE style.
+
+enum wxIdleMode
+{
+        // Send idle events to all windows
+    wxIDLE_PROCESS_ALL,
+
+        // Send idle events to windows that have
+        // the wxWS_EX_PROCESS_IDLE flag specified
+    wxIDLE_PROCESS_SPECIFIED
+};
+

 class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
 {
 public:
 class WXDLLIMPEXP_CORE wxIdleEvent : public wxEvent
 {
 public:


@@ -1892,8 +1929,20 @@ public:
 
     virtual wxEvent *Clone() const { return new wxIdleEvent(*this); }
 
 
     virtual wxEvent *Clone() const { return new wxIdleEvent(*this); }
 

+    // Specify how wxWindows will send idle events: to
+    // all windows, or only to those which specify that they
+    // will process the events.
+    static void SetMode(wxIdleMode mode) { sm_idleMode = mode; }
+
+    // Returns the idle event mode
+    static wxIdleMode GetMode() { return sm_idleMode ; }
+
+    // Can we send an idle event?
+    static bool CanSend(wxWindow* win) ;
+

 protected:
     bool m_requestMore;
 protected:
     bool m_requestMore;

+    static wxIdleMode sm_idleMode;

 
 private:
     DECLARE_DYNAMIC_CLASS(wxIdleEvent)
 
 private:
     DECLARE_DYNAMIC_CLASS(wxIdleEvent)

diff --git a/include/wx/frame.h b/include/wx/frame.h
index 02f03cc71d02b29e30a60e08249e1214dc93d2d6..646cce0a237bf82a8593d095fd4b3e875dad2200 100644 (file)
--- a/include/wx/frame.h
+++ b/include/wx/frame.h
@@ -141,7 +141,6 @@ public:
     // -------------------------------
 
     // event handlers
     // -------------------------------
 
     // event handlers

-    void OnIdle(wxIdleEvent& event);

     void OnMenuOpen(wxMenuEvent& event);
     void OnMenuHighlight(wxMenuEvent& event);
 
     void OnMenuOpen(wxMenuEvent& event);
     void OnMenuHighlight(wxMenuEvent& event);
 


@@ -151,6 +150,12 @@ public:
     void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
 #endif // wxUSE_MENUS
 
     void DoMenuUpdates(wxMenu* menu, wxWindow* focusWin);
 #endif // wxUSE_MENUS
 

+    // do the UI update processing for this window
+    virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
+
+    // Implement internal behaviour (menu updating on some platforms)
+    virtual void OnInternalIdle();
+

     // if there is no real wxTopLevelWindow on this platform we have to define
     // some wxTopLevelWindowBase pure virtual functions here to avoid breaking
     // old ports (wxMotif) which don't define them in wxFrame
     // if there is no real wxTopLevelWindow on this platform we have to define
     // some wxTopLevelWindowBase pure virtual functions here to avoid breaking
     // old ports (wxMotif) which don't define them in wxFrame

diff --git a/include/wx/gtk/app.h b/include/wx/gtk/app.h
index f03e5aa1ff5ed911439e382e3b4de6eb9de528e5..9b6143d1987a14955aab4ebbb0e9bc88cdc9c7a3 100644 (file)
--- a/include/wx/gtk/app.h
+++ b/include/wx/gtk/app.h
@@ -50,13 +50,10 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle();
 
     // implementation only from now on
     void OnIdle( wxIdleEvent &event );
     virtual void WakeUpIdle();
 
     // implementation only from now on
     void OnIdle( wxIdleEvent &event );

-    bool SendIdleEvents();
-    bool SendIdleEvents( wxWindow* win );

 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();
 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();


@@ -90,8 +87,6 @@ private:
     bool m_isInAssert;
 #endif // __WXDEBUG__
 
     bool m_isInAssert;
 #endif // __WXDEBUG__
 

-    bool CallInternalIdle( wxWindow* win );
-

     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()
 };
     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()
 };

diff --git a/include/wx/gtk1/app.h b/include/wx/gtk1/app.h
index f03e5aa1ff5ed911439e382e3b4de6eb9de528e5..9b6143d1987a14955aab4ebbb0e9bc88cdc9c7a3 100644 (file)
--- a/include/wx/gtk1/app.h
+++ b/include/wx/gtk1/app.h
@@ -50,13 +50,10 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle();
 
     // implementation only from now on
     void OnIdle( wxIdleEvent &event );
     virtual void WakeUpIdle();
 
     // implementation only from now on
     void OnIdle( wxIdleEvent &event );

-    bool SendIdleEvents();
-    bool SendIdleEvents( wxWindow* win );

 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();
 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();


@@ -90,8 +87,6 @@ private:
     bool m_isInAssert;
 #endif // __WXDEBUG__
 
     bool m_isInAssert;
 #endif // __WXDEBUG__
 

-    bool CallInternalIdle( wxWindow* win );
-

     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()
 };
     DECLARE_DYNAMIC_CLASS(wxApp)
     DECLARE_EVENT_TABLE()
 };

diff --git a/include/wx/mac/app.h b/include/wx/mac/app.h
index 99556638d1eeb04640fa3daa1b142fd39996cf71..7269c6e0d79c092aa2c14a95e5351ef21d94056a 100644 (file)
--- a/include/wx/mac/app.h
+++ b/include/wx/mac/app.h
@@ -56,7 +56,6 @@ class WXDLLEXPORT wxApp: public wxAppBase
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle();
     
     virtual void SetPrintMode(int mode) { m_printMode = mode; }
     virtual void WakeUpIdle();
     
     virtual void SetPrintMode(int mode) { m_printMode = mode; }


@@ -71,14 +70,6 @@ class WXDLLEXPORT wxApp: public wxAppBase
     void OnEndSession(wxCloseEvent& event);
     void OnQueryEndSession(wxCloseEvent& event);
     
     void OnEndSession(wxCloseEvent& event);
     void OnQueryEndSession(wxCloseEvent& event);
     

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents();
-    
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindowMac* win);
-    

     // Windows only, but for compatibility...
     inline void SetAuto3D(bool flag) { m_auto3D = flag; }
     inline bool GetAuto3D() const { return m_auto3D; }
     // Windows only, but for compatibility...
     inline void SetAuto3D(bool flag) { m_auto3D = flag; }
     inline bool GetAuto3D() const { return m_auto3D; }

diff --git a/include/wx/mac/window.h b/include/wx/mac/window.h
index fad0b98ade1d2a63f0094c8b88f28f18f35b4505..c9dcce20c7f4ab4f4d70d0f119f1ce7c097f76ff 100644 (file)
--- a/include/wx/mac/window.h
+++ b/include/wx/mac/window.h
@@ -173,7 +173,6 @@ public:
     void OnSetFocus(wxFocusEvent& event) ;
     void OnNcPaint(wxNcPaintEvent& event);
     void OnEraseBackground(wxEraseEvent& event);
     void OnSetFocus(wxFocusEvent& event) ;
     void OnNcPaint(wxNcPaintEvent& event);
     void OnEraseBackground(wxEraseEvent& event);

-    void OnIdle(wxIdleEvent& event);

     void OnMouseEvent( wxMouseEvent &event ) ;
 
     void MacOnScroll(wxScrollEvent&event ) ;
     void OnMouseEvent( wxMouseEvent &event ) ;
 
     void MacOnScroll(wxScrollEvent&event ) ;


@@ -181,6 +180,8 @@ public:
     bool AcceptsFocus() const ;
 
 public:
     bool AcceptsFocus() const ;
 
 public:

+    void OnInternalIdle();
+

     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;

diff --git a/include/wx/mgl/app.h b/include/wx/mgl/app.h
index 0fd4f65fde07580c660aacba8f965e99dac84749..27cf02da751113623e1bde8e33ef4e8d833f3219 100644 (file)
--- a/include/wx/mgl/app.h
+++ b/include/wx/mgl/app.h
@@ -47,12 +47,9 @@ public:
     virtual bool Initialized();
     virtual bool Pending();
     virtual void Dispatch();
     virtual bool Initialized();
     virtual bool Pending();
     virtual void Dispatch();

-    virtual bool ProcessIdle();

 
     // implementation only from now on
     void OnIdle(wxIdleEvent &event);
 
     // implementation only from now on
     void OnIdle(wxIdleEvent &event);

-    bool SendIdleEvents();
-    bool SendIdleEvents(wxWindow* win);

 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();
 
     virtual bool Initialize(int& argc, wxChar **argv);
     virtual void CleanUp();

diff --git a/include/wx/mgl/window.h b/include/wx/mgl/window.h
index 7b99981b6c41374b0ed80cb1d8aa27db21ce239d..80a2853909db5291a833649b72512fa64ac3fb49 100644 (file)
--- a/include/wx/mgl/window.h
+++ b/include/wx/mgl/window.h
@@ -135,7 +135,7 @@ protected:
     // themselves inside the given rectangle
     virtual void DoMoveWindow(int x, int y, int width, int height);
     
     // themselves inside the given rectangle
     virtual void DoMoveWindow(int x, int y, int width, int height);
     

-    void OnIdle(wxIdleEvent& event);
+    void OnInternalIdle();

 
 private:
     // common part of all ctors
 
 private:
     // common part of all ctors

diff --git a/include/wx/motif/app.h b/include/wx/motif/app.h
index 246cb618faf21587d49c2cb21ca40259730e10ac..79674e4f89527f16f0dc6a0a87a45bd9b5a4c21e 100644 (file)
--- a/include/wx/motif/app.h
+++ b/include/wx/motif/app.h
@@ -59,7 +59,6 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle(); // implemented in motif/evtloop.cpp
     
     virtual bool OnInitGui();
     virtual void WakeUpIdle(); // implemented in motif/evtloop.cpp
     
     virtual bool OnInitGui();


@@ -69,14 +68,6 @@ public:
     
     void OnIdle(wxIdleEvent& event);
     
     
     void OnIdle(wxIdleEvent& event);
     

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents();
-    
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindow* win);
-    

 protected:
     bool                  m_showOnInit;
     
 protected:
     bool                  m_showOnInit;
     

diff --git a/include/wx/motif/window.h b/include/wx/motif/window.h
index 84d7303a64899cea83d02a3dccb8c15306572a76..70857eb954b06b23becef772d1cb8be28f467b25 100644 (file)
--- a/include/wx/motif/window.h
+++ b/include/wx/motif/window.h
@@ -151,11 +151,11 @@ public:
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;
     // For implementation purposes - sometimes decorations make the client area
     // smaller
     virtual wxPoint GetClientAreaOrigin() const;

+
+    // Process idle (send update events)
+    void OnInternalIdle();

     
 protected:
     
 protected:

-    // event handlers (not virtual by design)
-    void OnIdle(wxIdleEvent& event);
-    

     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
     
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
     

diff --git a/include/wx/msw/app.h b/include/wx/msw/app.h
index 768833038d6cd25c42671679d9415e94d0feac54..17e363b6b351fd549e02c9d54a7a305fff5f9d60 100644 (file)
--- a/include/wx/msw/app.h
+++ b/include/wx/msw/app.h
@@ -46,7 +46,6 @@ public:
     virtual void Dispatch();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Dispatch();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle();
 
     virtual void SetPrintMode(int mode) { m_printMode = mode; }
     virtual void WakeUpIdle();
 
     virtual void SetPrintMode(int mode) { m_printMode = mode; }


@@ -57,14 +56,6 @@ public:
     void OnEndSession(wxCloseEvent& event);
     void OnQueryEndSession(wxCloseEvent& event);
 
     void OnEndSession(wxCloseEvent& event);
     void OnQueryEndSession(wxCloseEvent& event);
 

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents();
-
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindow* win);
-

 protected:
     int    m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
 
 protected:
     int    m_printMode; // wxPRINT_WINDOWS, wxPRINT_POSTSCRIPT
 

diff --git a/include/wx/msw/frame.h b/include/wx/msw/frame.h
index 369f3a3f5663a9d68fdcc1cf46577bb8f70434cf..f559b18ee2fa1e01f8587f8e44431eda90ec167c 100644 (file)
--- a/include/wx/msw/frame.h
+++ b/include/wx/msw/frame.h
@@ -128,6 +128,9 @@ protected:
     // window proc for the frames
     long MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
 
     // window proc for the frames
     long MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
 

+    // handle WM_INITMENU message
+    bool HandleInitMenu();
+

     virtual bool IsMDIChild() const { return FALSE; }
 
     // get default (wxWindows) icon for the frame
     virtual bool IsMDIChild() const { return FALSE; }
 
     // get default (wxWindows) icon for the frame

diff --git a/include/wx/msw/window.h b/include/wx/msw/window.h
index eaf3ff370f7925d1d1070642448f9fe22c7fe4a8..c44f9d908a0ae29fbc0d032ece56bc876225e86a 100644 (file)
--- a/include/wx/msw/window.h
+++ b/include/wx/msw/window.h
@@ -191,7 +191,6 @@ public:
     // --------------
 
     void OnEraseBackground(wxEraseEvent& event);
     // --------------
 
     void OnEraseBackground(wxEraseEvent& event);

-    void OnIdle(wxIdleEvent& event);

     void OnPaint(wxPaintEvent& event);
 
 public:
     void OnPaint(wxPaintEvent& event);
 
 public:


@@ -415,6 +414,10 @@ public:
     // check if mouse is in the window
     bool IsMouseInWindow() const;
 
     // check if mouse is in the window
     bool IsMouseInWindow() const;
 

+    // virtual function for implementing internal idle
+    // behaviour
+    virtual void OnInternalIdle() ;
+

 protected:
     // the window handle
     WXHWND                m_hWnd;
 protected:
     // the window handle
     WXHWND                m_hWnd;

diff --git a/include/wx/os2/app.h b/include/wx/os2/app.h
index 9a26ede018e6b0a358a4b2781587bfaebac15218..048bbc80883a94b3df8e34aa7cfdbeeb74157c94 100644 (file)
--- a/include/wx/os2/app.h
+++ b/include/wx/os2/app.h
@@ -80,7 +80,6 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle(void);

     virtual void WakeUpIdle(void);
 
     virtual void SetPrintMode(int mode) { m_nPrintMode = mode; }
     virtual void WakeUpIdle(void);
 
     virtual void SetPrintMode(int mode) { m_nPrintMode = mode; }


@@ -91,14 +90,6 @@ public:
     void OnEndSession(wxCloseEvent& rEvent);
     void OnQueryEndSession(wxCloseEvent& rEvent);
 
     void OnEndSession(wxCloseEvent& rEvent);
     void OnQueryEndSession(wxCloseEvent& rEvent);
 

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(void);
-
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindow* pWin);
-

     void SetAuto3D(bool bFlag) { m_bAuto3D = bFlag; }
     bool GetAuto3D(void) const { return m_bAuto3D; }
 
     void SetAuto3D(bool bFlag) { m_bAuto3D = bFlag; }
     bool GetAuto3D(void) const { return m_bAuto3D; }
 

diff --git a/include/wx/tbarbase.h b/include/wx/tbarbase.h
index 794859e2154a6633c3f1c12aab51798af55c556b..252e43e6f598b80f48c340a7360155a5bad61de9 100644 (file)
--- a/include/wx/tbarbase.h
+++ b/include/wx/tbarbase.h
@@ -525,10 +525,8 @@ public:
 
     size_t GetToolsCount() const { return m_tools.GetCount(); }
 
 
     size_t GetToolsCount() const { return m_tools.GetCount(); }
 

-    void OnIdle(wxIdleEvent& event);
-

     // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
     // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)

-    virtual void DoToolbarUpdates();
+    virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) ;

 
     // don't want toolbars to accept the focus
     virtual bool AcceptsFocus() const { return FALSE; }
 
     // don't want toolbars to accept the focus
     virtual bool AcceptsFocus() const { return FALSE; }

diff --git a/include/wx/textctrl.h b/include/wx/textctrl.h
index 67373c7db39120266fbdb6c88656ea9feaa07e10..9e12d0a49ddc81aa60e0448e0878b9937ed879b3 100644 (file)
--- a/include/wx/textctrl.h
+++ b/include/wx/textctrl.h
@@ -334,6 +334,9 @@ public:
     wxTextCtrl& operator<<(double d);
     wxTextCtrl& operator<<(const wxChar c);
 
     wxTextCtrl& operator<<(double d);
     wxTextCtrl& operator<<(const wxChar c);
 

+    // do the window-specific processing after processing the update event
+    virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
+

     // obsolete functions
 #if WXWIN_COMPATIBILITY
     bool Modified() const { return IsModified(); }
     // obsolete functions
 #if WXWIN_COMPATIBILITY
     bool Modified() const { return IsModified(); }

diff --git a/include/wx/toplevel.h b/include/wx/toplevel.h
index 10231a6c00d836eab1e7afa9389b35df61ce0252..c6241a97043b6023acdd52c8028b8b86b860ed0a 100644 (file)
--- a/include/wx/toplevel.h
+++ b/include/wx/toplevel.h
@@ -134,6 +134,9 @@ public:
     // so should be there for all platforms
     void OnActivate(wxActivateEvent &WXUNUSED(event)) { }
 
     // so should be there for all platforms
     void OnActivate(wxActivateEvent &WXUNUSED(event)) { }
 

+    // do the window-specific processing after processing the update event
+    virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;
+

 protected:
     // the frame client to screen translation should take account of the
     // toolbar which may shift the origin of the client area
 protected:
     // the frame client to screen translation should take account of the
     // toolbar which may shift the origin of the client area

diff --git a/include/wx/univ/listbox.h b/include/wx/univ/listbox.h
index 01ad0a276c177c6211674338a9f6bdf96de85cdd..72c9fc48aa0b8b2bc72f9b214aca7ab20b5d2923 100644 (file)
--- a/include/wx/univ/listbox.h
+++ b/include/wx/univ/listbox.h
@@ -169,6 +169,8 @@ public:
     // let wxColourScheme choose the right colours for us
     virtual bool IsContainerWindow() const { return TRUE; }
 
     // let wxColourScheme choose the right colours for us
     virtual bool IsContainerWindow() const { return TRUE; }
 

+    // idle processing
+    virtual void OnInternalIdle();

 protected:
     // geometry
     virtual wxSize DoGetBestClientSize() const;
 protected:
     // geometry
     virtual wxSize DoGetBestClientSize() const;


@@ -183,7 +185,6 @@ protected:
     void Init();
 
     // event handlers
     void Init();
 
     // event handlers

-    void OnIdle(wxIdleEvent& event);

     void OnSize(wxSizeEvent& event);
 
     // common part of Clear() and DoSetItems(): clears everything
     void OnSize(wxSizeEvent& event);
 
     // common part of Clear() and DoSetItems(): clears everything

diff --git a/include/wx/univ/scrolbar.h b/include/wx/univ/scrolbar.h
index 50f987813cad211cf3c0ed5dec98916fc5c430d1..af937ebae4725f3f460eb2ba8340b43668a66810 100644 (file)
--- a/include/wx/univ/scrolbar.h
+++ b/include/wx/univ/scrolbar.h
@@ -119,14 +119,14 @@ public:
     // for wxControlRenderer::DrawScrollbar() only
     const wxScrollArrows& GetArrows() const { return m_arrows; }
 
     // for wxControlRenderer::DrawScrollbar() only
     const wxScrollArrows& GetArrows() const { return m_arrows; }
 

+    // idle processing
+    virtual void OnInternalIdle();
+

 protected:
     virtual wxSize DoGetBestClientSize() const;
     virtual void DoDraw(wxControlRenderer *renderer);
     virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
 
 protected:
     virtual wxSize DoGetBestClientSize() const;
     virtual void DoDraw(wxControlRenderer *renderer);
     virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }
 

-    // event handlers
-    void OnIdle(wxIdleEvent& event);
-

     // forces update of thumb's visual appearence (does nothing if m_dirty=FALSE)
     void UpdateThumb();
 
     // forces update of thumb's visual appearence (does nothing if m_dirty=FALSE)
     void UpdateThumb();
 

diff --git a/include/wx/univ/textctrl.h b/include/wx/univ/textctrl.h
index 947a789c81ad4d0e24e03122f336f32d2449ea24..3dbaa38f8ebec9881dff740837f03a73185a23ff 100644 (file)
--- a/include/wx/univ/textctrl.h
+++ b/include/wx/univ/textctrl.h
@@ -455,7 +455,6 @@ protected:
 
     // event handlers
     // --------------
 
     // event handlers
     // --------------

-    void OnIdle(wxIdleEvent& event);

     void OnChar(wxKeyEvent& event);
     void OnSize(wxSizeEvent& event);
 
     void OnChar(wxKeyEvent& event);
     void OnSize(wxSizeEvent& event);
 


@@ -476,6 +475,8 @@ protected:
     bool DoCut();
     bool DoPaste();
 
     bool DoCut();
     bool DoPaste();
 

+    // idle processing
+    virtual void OnInternalIdle();

 private:
     // all these methods are for multiline text controls only
 
 private:
     // all these methods are for multiline text controls only
 

diff --git a/include/wx/window.h b/include/wx/window.h
index 679ceb8067cf6faf3dbb25d66a25e551150435e9..7839127ea9ff45b2b302a77fdfa565c132ec7a59 100644 (file)
--- a/include/wx/window.h
+++ b/include/wx/window.h
@@ -688,7 +688,11 @@ public:
     // get border for the flags of this window
     wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
 
     // get border for the flags of this window
     wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
 

-    void UpdateWindowUI();
+    // send wxUpdateUIEvents to this window, and children if recurse is TRUE
+    virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE);
+
+    // do the window-specific processing after processing the update event
+    virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ;

 
 #if wxUSE_MENUS
     bool PopupMenu( wxMenu *menu, const wxPoint& pos )
 
 #if wxUSE_MENUS
     bool PopupMenu( wxMenu *menu, const wxPoint& pos )


@@ -858,7 +862,14 @@ public:
     void OnHelp(wxHelpEvent& event);
 #endif // wxUSE_HELP
 
     void OnHelp(wxHelpEvent& event);
 #endif // wxUSE_HELP
 

-        // get the haqndle of the window for the underlying window system: this
+        // virtual function for implementing internal idle
+        // behaviour
+        virtual void OnInternalIdle() {}
+
+        // call internal idle recursively
+        void ProcessInternalIdle() ;
+
+        // get the handle of the window for the underlying window system: this

         // is only used for wxWin itself or for user code which wants to call
         // platform-specific APIs
     virtual WXWidget GetHandle() const = 0;
         // is only used for wxWin itself or for user code which wants to call
         // platform-specific APIs
     virtual WXWidget GetHandle() const = 0;

diff --git a/include/wx/x11/app.h b/include/wx/x11/app.h
index f0ca6237eeabb267957e82d5d171343f69933b2c..71a56be26a8a221a2c60b3962f5bab6336944df4 100644 (file)
--- a/include/wx/x11/app.h
+++ b/include/wx/x11/app.h
@@ -59,7 +59,6 @@ public:
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);
     virtual void Exit();
 
     virtual bool Yield(bool onlyIfNeeded = FALSE);

-    virtual bool ProcessIdle();

     virtual void WakeUpIdle();
     
     virtual bool OnInitGui();
     virtual void WakeUpIdle();
     
     virtual bool OnInitGui();


@@ -69,14 +68,6 @@ public:
     
     void OnIdle(wxIdleEvent& event);
     
     
     void OnIdle(wxIdleEvent& event);
     

-    // Send idle event to all top-level windows.
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents();
-    
-    // Send idle event to window and all subwindows
-    // Returns TRUE if more idle time is requested.
-    bool SendIdleEvents(wxWindow* win);
-    

     // Processes an X event.
     virtual bool ProcessXEvent(WXEvent* event);
     
     // Processes an X event.
     virtual bool ProcessXEvent(WXEvent* event);
     

diff --git a/include/wx/x11/textctrl.h b/include/wx/x11/textctrl.h
index 87fdd5b393c115253cce5fd09972c2cabe7f890d..2dd4196a92e6b2b45971b6432841b76b0a325e49 100644 (file)
--- a/include/wx/x11/textctrl.h
+++ b/include/wx/x11/textctrl.h
@@ -248,10 +248,10 @@ public:
     void OnEraseBackground( wxEraseEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnChar( wxKeyEvent &event );
     void OnEraseBackground( wxEraseEvent &event );
     void OnMouse( wxMouseEvent &event );
     void OnChar( wxKeyEvent &event );

-    void OnIdle( wxIdleEvent &event );

     void OnSetFocus( wxFocusEvent& event );
     void OnKillFocus( wxFocusEvent& event );
 
     void OnSetFocus( wxFocusEvent& event );
     void OnKillFocus( wxFocusEvent& event );
 

+    void OnInternalIdle();

     void RefreshLine( int n );
     void RefreshDown( int n );
     void MoveCursor( int new_x, int new_y, bool shift = FALSE, bool centre = FALSE );
     void RefreshLine( int n );
     void RefreshDown( int n );
     void MoveCursor( int new_x, int new_y, bool shift = FALSE, bool centre = FALSE );

diff --git a/include/wx/x11/window.h b/include/wx/x11/window.h
index 16ca8b298e24772d2ae5a53e75463615509ccb87..ef09a5ff93213691a924096001d926163e7e27b7 100644 (file)
--- a/include/wx/x11/window.h
+++ b/include/wx/x11/window.h
@@ -155,9 +155,6 @@ public:
     // OnInternalIdle
     virtual void OnInternalIdle();
     
     // OnInternalIdle
     virtual void OnInternalIdle();
     

-    // For compatibility across platforms (not in event table)
-    void OnIdle(wxIdleEvent& WXUNUSED(event)) {}
-    

 protected:
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);
 protected:
     // Responds to colour changes: passes event on to children.
     void OnSysColourChanged(wxSysColourChangedEvent& event);

diff --git a/src/cocoa/app.mm b/src/cocoa/app.mm
index c9614997a791ecf618b9b6c805fe1ac48a9d89e9..89c16115f36703d223a989702ed2488d0dc12784 100644 (file)
--- a/src/cocoa/app.mm
+++ b/src/cocoa/app.mm
@@ -249,18 +249,6 @@ int wxApp::MainLoop()
     return 0;
 }
 
     return 0;
 }
 

-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
     wxLogDebug("wxApp::ExitMailLoop m_isIdle=%d, isRunning=%d",(int)m_isIdle,(int)[m_cocoaApp isRunning]);
 void wxApp::ExitMainLoop()
 {
     wxLogDebug("wxApp::ExitMailLoop m_isIdle=%d, isRunning=%d",(int)m_isIdle,(int)[m_cocoaApp isRunning]);


@@ -314,48 +302,6 @@ void wxApp::OnIdle(wxIdleEvent& event)
     s_inOnIdle = FALSE;
 }
 
     s_inOnIdle = FALSE;
 }
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-//    wxLogDebug("SendIdleEvents win=%p",win);
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-    win->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowList::Node* node = win->GetChildren().GetFirst();
-    while (node)
-    {
-//        wxLogDebug("child=%p",node->Data());
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore;
-}
-

 // Yield to other processes
 
 bool wxApp::Yield(bool onlyIfNeeded)
 // Yield to other processes
 
 bool wxApp::Yield(bool onlyIfNeeded)

diff --git a/src/common/appcmn.cpp b/src/common/appcmn.cpp
index 845d4ebc44d2f27bb95b15b78e17272bfc46691e..9424db3196fa936343481ae128b43451e64a3318 100644 (file)
--- a/src/common/appcmn.cpp
+++ b/src/common/appcmn.cpp
@@ -205,6 +205,72 @@ void wxAppBase::DeletePendingObjects()
     }
 }
 
     }
 }
 

+// Returns TRUE if more time is needed.
+bool wxAppBase::ProcessIdle()
+{
+    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
+    node = wxTopLevelWindows.GetFirst();
+    while (node)
+    {
+        wxWindow* win = node->GetData();
+        win->ProcessInternalIdle();
+        node = node->GetNext();
+    }
+
+    wxIdleEvent event;
+    event.SetEventObject(this);
+    bool processed = ProcessEvent(event);
+
+    wxUpdateUIEvent::ResetUpdateTime();
+    
+    return processed && event.MoreRequested();
+}
+
+// Send idle event to all top-level windows
+bool wxAppBase::SendIdleEvents()
+{
+    bool needMore = FALSE;
+
+    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
+    while (node)
+    {
+        wxWindow* win = node->GetData();
+        if (SendIdleEvents(win))
+            needMore = TRUE;
+        node = node->GetNext();
+    }
+
+    return needMore;
+}
+
+// Send idle event to window and all subwindows
+bool wxAppBase::SendIdleEvents(wxWindow* win)
+{
+    bool needMore = FALSE;
+    
+    if (wxIdleEvent::CanSend(win))
+    {
+        wxIdleEvent event;
+        event.SetEventObject(win);
+        win->GetEventHandler()->ProcessEvent(event);
+
+        needMore = event.MoreRequested();
+    }
+
+    wxWindowList::Node *node = win->GetChildren().GetFirst();
+    while ( node )
+    {
+        wxWindow *win = node->GetData();
+        if (SendIdleEvents(win))
+            needMore = TRUE;
+
+        node = node->GetNext();
+    }
+
+    return needMore;
+}
+
+

 // ----------------------------------------------------------------------------
 // wxGUIAppTraitsBase
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // wxGUIAppTraitsBase
 // ----------------------------------------------------------------------------

diff --git a/src/common/event.cpp b/src/common/event.cpp
index ff13a801114ca238ebf966f99f7012325642ba36..8474ad0eec2d21b0e459d47a2674e03ea028b566 100644 (file)
--- a/src/common/event.cpp
+++ b/src/common/event.cpp
@@ -370,23 +370,32 @@ wxCommandEvent::wxCommandEvent(wxEventType commandType, int theId)
  */
 
 #if wxUSE_LONGLONG
  */
 
 #if wxUSE_LONGLONG

-wxLongLong wxUpdateUIEvent::m_lastUpdate = 0;
+wxLongLong wxUpdateUIEvent::sm_lastUpdate = 0;

 #endif
 
 #endif
 

-long wxUpdateUIEvent::m_updateInterval = 0;
+long wxUpdateUIEvent::sm_updateInterval = 0;
+
+wxUpdateUIMode wxUpdateUIEvent::sm_updateMode = wxUPDATE_UI_PROCESS_ALL;

 
 // Can we update?
 
 // Can we update?

-bool wxUpdateUIEvent::CanUpdate()
+bool wxUpdateUIEvent::CanUpdate(wxWindow* win)

 {
 {

-    if (m_updateInterval == -1)
+    // Don't update if we've switched global updating off
+    // and this window doesn't support updates.
+    if (win &&
+       (GetMode() == wxUPDATE_UI_PROCESS_SPECIFIED &&
+       ((win->GetExtraStyle() & wxWS_EX_PROCESS_UI_UPDATES) == 0)))
+        return FALSE;
+    
+    if (sm_updateInterval == -1)

         return FALSE;
         return FALSE;

-    else if (m_updateInterval == 0)
+    else if (sm_updateInterval == 0)

         return TRUE;
     else
     {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
         wxLongLong now = wxGetLocalTimeMillis();
         return TRUE;
     else
     {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
         wxLongLong now = wxGetLocalTimeMillis();

-        if (now > (m_lastUpdate + m_updateInterval))
+        if (now > (sm_lastUpdate + sm_updateInterval))

         {
             return TRUE;
         }
         {
             return TRUE;
         }


@@ -404,17 +413,35 @@ bool wxUpdateUIEvent::CanUpdate()
 void wxUpdateUIEvent::ResetUpdateTime()
 {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG
 void wxUpdateUIEvent::ResetUpdateTime()
 {
 #if wxUSE_STOPWATCH && wxUSE_LONGLONG

-    if (m_updateInterval > 0)
+    if (sm_updateInterval > 0)

     {
         wxLongLong now = wxGetLocalTimeMillis();
     {
         wxLongLong now = wxGetLocalTimeMillis();

-        if (now > (m_lastUpdate + m_updateInterval))
+        if (now > (sm_lastUpdate + sm_updateInterval))

         {
         {

-            m_lastUpdate = now;
+            sm_lastUpdate = now;

         }
     }
 #endif
 }
 
         }
     }
 #endif
 }
 

+/*
+ * Idle events
+ */
+ 
+wxIdleMode wxIdleEvent::sm_idleMode = wxIDLE_PROCESS_ALL;
+
+// Can we send an idle event?
+bool wxIdleEvent::CanSend(wxWindow* win)
+{
+    // Don't update if we've switched global updating off
+    // and this window doesn't support updates.
+    if (win &&
+       (GetMode() == wxIDLE_PROCESS_SPECIFIED &&
+       ((win->GetExtraStyle() & wxWS_EX_PROCESS_IDLE) == 0)))
+        return FALSE;
+    
+    return TRUE;
+}

 
 /*
  * Scroll events
 
 /*
  * Scroll events

diff --git a/src/common/framecmn.cpp b/src/common/framecmn.cpp
index 7e64059805190a6de2d7b0c20da236d4018bc723..42669bd92eb7beefff506a2888f02d90dcbaee98 100644 (file)
--- a/src/common/framecmn.cpp
+++ b/src/common/framecmn.cpp
@@ -46,9 +46,6 @@
 // ----------------------------------------------------------------------------
 
 BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)
 // ----------------------------------------------------------------------------
 
 BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)

-#if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
-    EVT_IDLE(wxFrameBase::OnIdle)
-#endif

 #if wxUSE_MENUS && !wxUSE_IDLEMENUUPDATES
     EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
 #endif
 #if wxUSE_MENUS && !wxUSE_IDLEMENUUPDATES
     EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
 #endif


@@ -211,6 +208,34 @@ bool wxFrameBase::ProcessCommand(int id)
 #endif // wxUSE_MENUS/!wxUSE_MENUS
 }
 
 #endif // wxUSE_MENUS/!wxUSE_MENUS
 }
 

+// Do the UI update processing for this window. This is
+// provided for the application to call if it wants to
+// force a UI update, particularly for the menus and toolbar.
+void wxFrameBase::UpdateWindowUI(long flags)
+{
+    wxWindowBase::UpdateWindowUI(flags);
+    
+#if wxUSE_TOOLBAR
+    if (GetToolBar())
+        GetToolBar()->UpdateWindowUI(flags);
+#endif
+
+#if wxUSE_MENUS
+    if (GetMenuBar())
+    {
+        if ((flags & wxUPDATE_UI_FROMIDLE) && !wxUSE_IDLEMENUUPDATES)
+        {
+            // If coming from an idle event, we only
+            // want to update the menus if we're
+            // in the wxUSE_IDLEMENUUPDATES configuration:
+            // so if we're not, do nothing
+        }
+        else
+            DoMenuUpdates();
+    }
+#endif
+}
+

 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------


@@ -222,10 +247,11 @@ void wxFrameBase::OnMenuHighlight(wxMenuEvent& event)
 #endif // wxUSE_STATUSBAR
 }
 
 #endif // wxUSE_STATUSBAR
 }
 

-void wxFrameBase::OnIdle(wxIdleEvent& WXUNUSED(event) )
+// Implement internal behaviour (menu updating on some platforms)
+void wxFrameBase::OnInternalIdle()

 {
 #if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
 {
 #if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES

-    if (wxUpdateUIEvent::CanUpdate())
+    if (wxUpdateUIEvent::CanUpdate(this))

         DoMenuUpdates();
 #endif
 }
         DoMenuUpdates();
 #endif
 }

diff --git a/src/common/tbarbase.cpp b/src/common/tbarbase.cpp
index e53657dea2607a3569a0dbb3a24abd5cd4bb9f21..9b03daccee3159dd2aaede9448ae8605ae5d14fe 100644 (file)
--- a/src/common/tbarbase.cpp
+++ b/src/common/tbarbase.cpp
@@ -47,7 +47,6 @@
 IMPLEMENT_CLASS(wxToolBarBase, wxControl)
 
 BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
 IMPLEMENT_CLASS(wxToolBarBase, wxControl)
 
 BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)

-    EVT_IDLE(wxToolBarBase::OnIdle)

 END_EVENT_TABLE()
 
 #include "wx/listimpl.cpp"
 END_EVENT_TABLE()
 
 #include "wx/listimpl.cpp"


@@ -581,17 +580,11 @@ void wxToolBarBase::OnMouseEnter(int id)
 // UI updates
 // ----------------------------------------------------------------------------
 
 // UI updates
 // ----------------------------------------------------------------------------
 

-void wxToolBarBase::OnIdle(wxIdleEvent& event)
-{
-    if (wxUpdateUIEvent::CanUpdate())
-        DoToolbarUpdates();
-
-    event.Skip();
-}
-

 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)

-void wxToolBarBase::DoToolbarUpdates()
+void wxToolBarBase::UpdateWindowUI(long flags)

 {
 {

+    wxWindowBase::UpdateWindowUI(flags);
+

     wxEvtHandler* evtHandler = GetEventHandler() ;
 
     for ( wxToolBarToolsList::Node* node = m_tools.GetFirst();
     wxEvtHandler* evtHandler = GetEventHandler() ;
 
     for ( wxToolBarToolsList::Node* node = m_tools.GetFirst();

diff --git a/src/common/textcmn.cpp b/src/common/textcmn.cpp
index 57e584a3106e28dfcadea07399fb670537fbaf3f..ff02305ca2ab538caddaf20dd3fbc7795dd34c78 100644 (file)
--- a/src/common/textcmn.cpp
+++ b/src/common/textcmn.cpp
@@ -469,6 +469,20 @@ wxString wxTextCtrlBase::GetRange(long from, long to) const
     return sel;
 }
 
     return sel;
 }
 

+// do the window-specific processing after processing the update event
+void wxTextCtrlBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
+{
+    if ( event.GetSetEnabled() )
+        Enable(event.GetEnabled());
+    
+    if ( event.GetSetText() )
+    {
+        if ( event.GetText() != GetValue() )
+            SetValue(event.GetText());
+    }    
+}
+
+

 #else // !wxUSE_TEXTCTRL
 
 // define this one even if !wxUSE_TEXTCTRL because it is also used by other
 #else // !wxUSE_TEXTCTRL
 
 // define this one even if !wxUSE_TEXTCTRL because it is also used by other

diff --git a/src/common/toplvcmn.cpp b/src/common/toplvcmn.cpp
index 4c640caae444749db900d12be0a23b7a7f6e7911..8768de7360de4fe2f0f4de89663baaaf7637f137 100644 (file)
--- a/src/common/toplvcmn.cpp
+++ b/src/common/toplvcmn.cpp
@@ -215,4 +215,17 @@ bool wxTopLevelWindowBase::SendIconizeEvent(bool iconized)
     return GetEventHandler()->ProcessEvent(event);
 }
 
     return GetEventHandler()->ProcessEvent(event);
 }
 

+// do the window-specific processing after processing the update event
+void wxTopLevelWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
+{
+    if ( event.GetSetEnabled() )
+        Enable(event.GetEnabled());
+    
+    if ( event.GetSetText() )
+    {
+        if ( event.GetText() != GetTitle() )
+            SetTitle(event.GetText());
+    }
+}
+

 // vi:sts=4:sw=4:et
 // vi:sts=4:sw=4:et

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index 810d518d9dc2a58a9aef38026738970ef7c2a9ca..d7492c0a397f02e3209919ffeaadd5efd64aeb90 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -1770,42 +1770,46 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) co
 // do Update UI processing for child controls
 // ----------------------------------------------------------------------------
 
 // do Update UI processing for child controls
 // ----------------------------------------------------------------------------
 

-// TODO: should this be implemented for the child window rather
-// than the parent? Then you can override it e.g. for wxCheckBox
-// to do the Right Thing rather than having to assume a fixed number
-// of control classes.
-void wxWindowBase::UpdateWindowUI()
+void wxWindowBase::UpdateWindowUI(long flags)

 {
 {

-#if wxUSE_CONTROLS

     wxUpdateUIEvent event(GetId());
     event.m_eventObject = this;
 
     if ( GetEventHandler()->ProcessEvent(event) )
     {
     wxUpdateUIEvent event(GetId());
     event.m_eventObject = this;
 
     if ( GetEventHandler()->ProcessEvent(event) )
     {

-        if ( event.GetSetEnabled() )
-            Enable(event.GetEnabled());
+        DoUpdateWindowUI(event);
+    }

 
 

-        if ( event.GetSetText() )
+    if (flags & wxUPDATE_UI_RECURSE)
+    {
+        wxWindowList::Node* node = GetChildren().GetFirst();
+        while (node)

         {
         {

-            wxControl *control = wxDynamicCastThis(wxControl);
-            if ( control )
-            {
-#if wxUSE_TEXTCTRL
-                wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl);
-                if ( text )
-                {
-                       if ( event.GetText() != text->GetValue() )
-                       text->SetValue(event.GetText());
-                }
-                else
-#endif // wxUSE_TEXTCTRL
-                               {
-                                       if ( event.GetText() != control->GetLabel() )
-                       control->SetLabel(event.GetText());
-                }
-            }
+            wxWindow* child = (wxWindow*) node->GetData();
+            child->UpdateWindowUI(flags);
+            node = node->GetNext();

         }
         }

+    }
+}

 
 

+// do the window-specific processing after processing the update event
+// TODO: take specific knowledge out of this function and
+// put in each control's base class. Unfortunately we don't
+// yet have base implementation files for wxCheckBox and wxRadioButton.
+void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event)
+{
+    if ( event.GetSetEnabled() )
+        Enable(event.GetEnabled());
+    
+#if wxUSE_CONTROLS
+    if ( event.GetSetText() )
+    {
+        wxControl *control = wxDynamicCastThis(wxControl);
+        if ( control )
+        {
+            if ( event.GetText() != control->GetLabel() )
+                control->SetLabel(event.GetText());
+        }

 #if wxUSE_CHECKBOX
         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
         if ( checkbox )
 #if wxUSE_CHECKBOX
         wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox);
         if ( checkbox )


@@ -1823,8 +1827,22 @@ void wxWindowBase::UpdateWindowUI()
                 radiobtn->SetValue(event.GetChecked());
         }
 #endif // wxUSE_RADIOBTN
                 radiobtn->SetValue(event.GetChecked());
         }
 #endif // wxUSE_RADIOBTN

+    }    
+#endif
+}
+
+// call internal idle recursively
+void wxWindowBase::ProcessInternalIdle()
+{
+    OnInternalIdle();
+
+    wxWindowList::Node  *node = GetChildren().GetFirst();
+    while (node)
+    {
+        wxWindow *child = node->GetData();
+        child->ProcessInternalIdle();
+        node = node->GetNext();

     }
     }

-#endif // wxUSE_CONTROLS

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1880,10 +1898,15 @@ void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
     }
 }
 

-// the default action is to populate dialog with data when it's created
+// the default action is to populate dialog with data when it's created,
+// and nudge the UI into displaying itself correctly in case
+// we've turned the wxUpdateUIEvents frequency down low.

 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {
     TransferDataToWindow();
 void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
 {
     TransferDataToWindow();

+    
+    // Update the UI at this point
+    UpdateWindowUI(wxUPDATE_UI_RECURSE);

 }
 
 // process Ctrl-Alt-mclick
 }
 
 // process Ctrl-Alt-mclick

diff --git a/src/gtk/app.cpp b/src/gtk/app.cpp
index b598da0307a5ee7877d9a24b2ce01b707f9b6dee..06afb50f124152bf32f60f8d36983211296acb2d 100644 (file)
--- a/src/gtk/app.cpp
+++ b/src/gtk/app.cpp
@@ -534,27 +534,6 @@ GdkVisual *wxApp::GetGdkVisual()
     return visual;
 }
 
     return visual;
 }
 

-bool wxApp::ProcessIdle()
-{
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        CallInternalIdle( win );
-
-        node = node->GetNext();
-    }
-
-    wxIdleEvent event;
-    event.SetEventObject( this );
-    ProcessEvent( event );
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::OnIdle( wxIdleEvent &event )
 {
     static bool s_inOnIdle = FALSE;
 void wxApp::OnIdle( wxIdleEvent &event )
 {
     static bool s_inOnIdle = FALSE;


@@ -581,64 +560,6 @@ void wxApp::OnIdle( wxIdleEvent &event )
     s_inOnIdle = FALSE;
 }
 
     s_inOnIdle = FALSE;
 }
 

-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-bool wxApp::CallInternalIdle( wxWindow* win )
-{
-    win->OnInternalIdle();
-
-    wxWindowList::Node  *node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow    *win = node->GetData();
-
-        CallInternalIdle( win );
-        node = node->GetNext();
-    }
-
-    return TRUE;
-}
-
-bool wxApp::SendIdleEvents( wxWindow* win )
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-
-    win->GetEventHandler()->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowList::Node  *node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow    *win = node->GetData();
-
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-

 int wxApp::MainLoop()
 {
     gtk_main();
 int wxApp::MainLoop()
 {
     gtk_main();

diff --git a/src/gtk/checkbox.cpp b/src/gtk/checkbox.cpp
index 4099d8406f62075c4a024a3a2c1528419e898585..fb6cc16c42240e068f141ca7763061784355a5fc 100644 (file)
--- a/src/gtk/checkbox.cpp
+++ b/src/gtk/checkbox.cpp
@@ -220,8 +220,8 @@ void wxCheckBox::OnInternalIdle()
         }
     }
     
         }
     }
     

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxCheckBox::DoGetBestSize() const
 }
 
 wxSize wxCheckBox::DoGetBestSize() const

diff --git a/src/gtk/frame.cpp b/src/gtk/frame.cpp
index 7e1ed2b2ba6f5eb14136985853d0d7d73d44adec..fd6e17f28a60cb2652bcb7080b62718d322f4d43 100644 (file)
--- a/src/gtk/frame.cpp
+++ b/src/gtk/frame.cpp
@@ -508,7 +508,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 
 void wxFrame::OnInternalIdle()
 {
 
 void wxFrame::OnInternalIdle()
 {

-    wxTopLevelWindow::OnInternalIdle();
+    wxFrameBase::OnInternalIdle();

 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();

diff --git a/src/gtk/listbox.cpp b/src/gtk/listbox.cpp
index 4f166e489e42716fc30948cdfe6bd99092715bbc..da155214957bb0466d8019affdd85445a6f7565b 100644 (file)
--- a/src/gtk/listbox.cpp
+++ b/src/gtk/listbox.cpp
@@ -1039,8 +1039,8 @@ void wxListBox::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxListBox::DoGetBestSize() const
 }
 
 wxSize wxListBox::DoGetBestSize() const

diff --git a/src/gtk/radiobut.cpp b/src/gtk/radiobut.cpp
index a3b09060d5bd208159c408856eb146bbf39e790f..49a6ddb76b338eaf74502482c6c1fad36ce09d6d 100644 (file)
--- a/src/gtk/radiobut.cpp
+++ b/src/gtk/radiobut.cpp
@@ -239,8 +239,8 @@ void wxRadioButton::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxRadioButton::DoGetBestSize() const
 }
 
 wxSize wxRadioButton::DoGetBestSize() const

diff --git a/src/gtk/tbargtk.cpp b/src/gtk/tbargtk.cpp
index 326ff64c769ddee5c241b9614adac0dd9dbcbb43..a5a5b2b946aab6229572150b37fc429b534aefed 100644 (file)
--- a/src/gtk/tbargtk.cpp
+++ b/src/gtk/tbargtk.cpp
@@ -673,8 +673,8 @@ void wxToolBar::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 #endif // wxUSE_TOOLBAR_NATIVE
 }
 
 #endif // wxUSE_TOOLBAR_NATIVE

diff --git a/src/gtk/textctrl.cpp b/src/gtk/textctrl.cpp
index b87712e0c1d1a52f1b969da1f973d7065e69d6e4..23b5a380f2d98c7fd23ebe4ffc382d87cb71f336 100644 (file)
--- a/src/gtk/textctrl.cpp
+++ b/src/gtk/textctrl.cpp
@@ -1591,8 +1591,8 @@ void wxTextCtrl::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxTextCtrl::DoGetBestSize() const
 }
 
 wxSize wxTextCtrl::DoGetBestSize() const

diff --git a/src/gtk/tglbtn.cpp b/src/gtk/tglbtn.cpp
index 9ad3fceec1efc34d1f28aa77176b380a517523e2..f103789376cf232da9588f868a730a2f96a19ac1 100644 (file)
--- a/src/gtk/tglbtn.cpp
+++ b/src/gtk/tglbtn.cpp
@@ -166,8 +166,8 @@ void wxToggleButton::OnInternalIdle()
         gdk_window_set_cursor(win, cursor.GetCursor());
     }
 
         gdk_window_set_cursor(win, cursor.GetCursor());
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // wxSize DoGetBestSize() const
 }
 
 // wxSize DoGetBestSize() const

diff --git a/src/gtk/window.cpp b/src/gtk/window.cpp
index bb9d47217950e28403ca4e81a8bec0cb33157e53..13eda5a41d732b61a8d055f14db806e026bdb474 100644 (file)
--- a/src/gtk/window.cpp
+++ b/src/gtk/window.cpp
@@ -3022,8 +3022,8 @@ void wxWindowGTK::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 void wxWindowGTK::DoGetSize( int *width, int *height ) const
 }
 
 void wxWindowGTK::DoGetSize( int *width, int *height ) const

diff --git a/src/gtk1/app.cpp b/src/gtk1/app.cpp
index b598da0307a5ee7877d9a24b2ce01b707f9b6dee..06afb50f124152bf32f60f8d36983211296acb2d 100644 (file)
--- a/src/gtk1/app.cpp
+++ b/src/gtk1/app.cpp
@@ -534,27 +534,6 @@ GdkVisual *wxApp::GetGdkVisual()
     return visual;
 }
 
     return visual;
 }
 

-bool wxApp::ProcessIdle()
-{
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        CallInternalIdle( win );
-
-        node = node->GetNext();
-    }
-
-    wxIdleEvent event;
-    event.SetEventObject( this );
-    ProcessEvent( event );
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::OnIdle( wxIdleEvent &event )
 {
     static bool s_inOnIdle = FALSE;
 void wxApp::OnIdle( wxIdleEvent &event )
 {
     static bool s_inOnIdle = FALSE;


@@ -581,64 +560,6 @@ void wxApp::OnIdle( wxIdleEvent &event )
     s_inOnIdle = FALSE;
 }
 
     s_inOnIdle = FALSE;
 }
 

-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-bool wxApp::CallInternalIdle( wxWindow* win )
-{
-    win->OnInternalIdle();
-
-    wxWindowList::Node  *node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow    *win = node->GetData();
-
-        CallInternalIdle( win );
-        node = node->GetNext();
-    }
-
-    return TRUE;
-}
-
-bool wxApp::SendIdleEvents( wxWindow* win )
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-
-    win->GetEventHandler()->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowList::Node  *node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow    *win = node->GetData();
-
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-

 int wxApp::MainLoop()
 {
     gtk_main();
 int wxApp::MainLoop()
 {
     gtk_main();

diff --git a/src/gtk1/checkbox.cpp b/src/gtk1/checkbox.cpp
index 4099d8406f62075c4a024a3a2c1528419e898585..fb6cc16c42240e068f141ca7763061784355a5fc 100644 (file)
--- a/src/gtk1/checkbox.cpp
+++ b/src/gtk1/checkbox.cpp
@@ -220,8 +220,8 @@ void wxCheckBox::OnInternalIdle()
         }
     }
     
         }
     }
     

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxCheckBox::DoGetBestSize() const
 }
 
 wxSize wxCheckBox::DoGetBestSize() const

diff --git a/src/gtk1/frame.cpp b/src/gtk1/frame.cpp
index 7e1ed2b2ba6f5eb14136985853d0d7d73d44adec..fd6e17f28a60cb2652bcb7080b62718d322f4d43 100644 (file)
--- a/src/gtk1/frame.cpp
+++ b/src/gtk1/frame.cpp
@@ -508,7 +508,7 @@ void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 
 void wxFrame::OnInternalIdle()
 {
 
 void wxFrame::OnInternalIdle()
 {

-    wxTopLevelWindow::OnInternalIdle();
+    wxFrameBase::OnInternalIdle();

 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
 
 #if wxUSE_MENUS_NATIVE
     if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();

diff --git a/src/gtk1/listbox.cpp b/src/gtk1/listbox.cpp
index 4f166e489e42716fc30948cdfe6bd99092715bbc..da155214957bb0466d8019affdd85445a6f7565b 100644 (file)
--- a/src/gtk1/listbox.cpp
+++ b/src/gtk1/listbox.cpp
@@ -1039,8 +1039,8 @@ void wxListBox::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxListBox::DoGetBestSize() const
 }
 
 wxSize wxListBox::DoGetBestSize() const

diff --git a/src/gtk1/radiobut.cpp b/src/gtk1/radiobut.cpp
index a3b09060d5bd208159c408856eb146bbf39e790f..49a6ddb76b338eaf74502482c6c1fad36ce09d6d 100644 (file)
--- a/src/gtk1/radiobut.cpp
+++ b/src/gtk1/radiobut.cpp
@@ -239,8 +239,8 @@ void wxRadioButton::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxRadioButton::DoGetBestSize() const
 }
 
 wxSize wxRadioButton::DoGetBestSize() const

diff --git a/src/gtk1/tbargtk.cpp b/src/gtk1/tbargtk.cpp
index 326ff64c769ddee5c241b9614adac0dd9dbcbb43..a5a5b2b946aab6229572150b37fc429b534aefed 100644 (file)
--- a/src/gtk1/tbargtk.cpp
+++ b/src/gtk1/tbargtk.cpp
@@ -673,8 +673,8 @@ void wxToolBar::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 #endif // wxUSE_TOOLBAR_NATIVE
 }
 
 #endif // wxUSE_TOOLBAR_NATIVE

diff --git a/src/gtk1/textctrl.cpp b/src/gtk1/textctrl.cpp
index b87712e0c1d1a52f1b969da1f973d7065e69d6e4..23b5a380f2d98c7fd23ebe4ffc382d87cb71f336 100644 (file)
--- a/src/gtk1/textctrl.cpp
+++ b/src/gtk1/textctrl.cpp
@@ -1591,8 +1591,8 @@ void wxTextCtrl::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 wxSize wxTextCtrl::DoGetBestSize() const
 }
 
 wxSize wxTextCtrl::DoGetBestSize() const

diff --git a/src/gtk1/tglbtn.cpp b/src/gtk1/tglbtn.cpp
index 9ad3fceec1efc34d1f28aa77176b380a517523e2..f103789376cf232da9588f868a730a2f96a19ac1 100644 (file)
--- a/src/gtk1/tglbtn.cpp
+++ b/src/gtk1/tglbtn.cpp
@@ -166,8 +166,8 @@ void wxToggleButton::OnInternalIdle()
         gdk_window_set_cursor(win, cursor.GetCursor());
     }
 
         gdk_window_set_cursor(win, cursor.GetCursor());
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // wxSize DoGetBestSize() const
 }
 
 // wxSize DoGetBestSize() const

diff --git a/src/gtk1/window.cpp b/src/gtk1/window.cpp
index bb9d47217950e28403ca4e81a8bec0cb33157e53..13eda5a41d732b61a8d055f14db806e026bdb474 100644 (file)
--- a/src/gtk1/window.cpp
+++ b/src/gtk1/window.cpp
@@ -3022,8 +3022,8 @@ void wxWindowGTK::OnInternalIdle()
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 void wxWindowGTK::DoGetSize( int *width, int *height ) const
 }
 
 void wxWindowGTK::DoGetSize( int *width, int *height ) const

diff --git a/src/mac/app.cpp b/src/mac/app.cpp
index e1e9dba92243d3b7e988bdc3f891a1c8333ba1ec..1af5aa871fc86c6651f16618c7b8d4a55ce34c6d 100644 (file)
--- a/src/mac/app.cpp
+++ b/src/mac/app.cpp
@@ -971,18 +971,6 @@ int wxApp::MainLoop()
     return 0;
 }
 
     return 0;
 }
 

-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
       m_keepGoing = FALSE;
 void wxApp::ExitMainLoop()
 {
       m_keepGoing = FALSE;


@@ -996,7 +984,7 @@ bool wxApp::Pending()
 #else
     EventRecord event ;
 
 #else
     EventRecord event ;
 

-      return EventAvail( everyEvent , &event ) ;
+    return EventAvail( everyEvent , &event ) ;

 #endif
 }
 
 #endif
 }
 


@@ -1044,46 +1032,6 @@ void wxApp::WakeUpIdle()
     wxMacWakeUp() ;
 }
 
     wxMacWakeUp() ;
 }
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-    wxWindowListNode* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-    win->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowListNode* node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore ;
-}
-

 void wxApp::Exit()
 {
     wxApp::CleanUp();
 void wxApp::Exit()
 {
     wxApp::CleanUp();

diff --git a/src/mac/carbon/app.cpp b/src/mac/carbon/app.cpp
index e1e9dba92243d3b7e988bdc3f891a1c8333ba1ec..1af5aa871fc86c6651f16618c7b8d4a55ce34c6d 100644 (file)
--- a/src/mac/carbon/app.cpp
+++ b/src/mac/carbon/app.cpp
@@ -971,18 +971,6 @@ int wxApp::MainLoop()
     return 0;
 }
 
     return 0;
 }
 

-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
       m_keepGoing = FALSE;
 void wxApp::ExitMainLoop()
 {
       m_keepGoing = FALSE;


@@ -996,7 +984,7 @@ bool wxApp::Pending()
 #else
     EventRecord event ;
 
 #else
     EventRecord event ;
 

-      return EventAvail( everyEvent , &event ) ;
+    return EventAvail( everyEvent , &event ) ;

 #endif
 }
 
 #endif
 }
 


@@ -1044,46 +1032,6 @@ void wxApp::WakeUpIdle()
     wxMacWakeUp() ;
 }
 
     wxMacWakeUp() ;
 }
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-    wxWindowListNode* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-    win->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowListNode* node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore ;
-}
-

 void wxApp::Exit()
 {
     wxApp::CleanUp();
 void wxApp::Exit()
 {
     wxApp::CleanUp();

diff --git a/src/mac/carbon/window.cpp b/src/mac/carbon/window.cpp
index a75c421466051632ce0967c55276079e408eb934..ddb8eebf2b898759b80ea6be4385d41cb2652eb2 100644 (file)
--- a/src/mac/carbon/window.cpp
+++ b/src/mac/carbon/window.cpp
@@ -75,7 +75,6 @@ BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
   EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
   EVT_SYS_COLOUR_CHANGED(wxWindowMac::OnSysColourChanged)
   EVT_INIT_DIALOG(wxWindowMac::OnInitDialog)
   EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
   EVT_SYS_COLOUR_CHANGED(wxWindowMac::OnSysColourChanged)
   EVT_INIT_DIALOG(wxWindowMac::OnInitDialog)

-  EVT_IDLE(wxWindowMac::OnIdle)

   EVT_SET_FOCUS(wxWindowMac::OnSetFocus)
   EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
 END_EVENT_TABLE()
   EVT_SET_FOCUS(wxWindowMac::OnSetFocus)
   EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
 END_EVENT_TABLE()


@@ -1367,12 +1366,12 @@ void wxWindowMac::SetupColours()
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 

-void wxWindowMac::OnIdle(wxIdleEvent& event)
+void wxWindowMac::OnInternalIdle()

 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)
 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // Raise the window to the top of the Z order
 }
 
 // Raise the window to the top of the Z order

diff --git a/src/mac/window.cpp b/src/mac/window.cpp
index a75c421466051632ce0967c55276079e408eb934..ddb8eebf2b898759b80ea6be4385d41cb2652eb2 100644 (file)
--- a/src/mac/window.cpp
+++ b/src/mac/window.cpp
@@ -75,7 +75,6 @@ BEGIN_EVENT_TABLE(wxWindowMac, wxWindowBase)
   EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
   EVT_SYS_COLOUR_CHANGED(wxWindowMac::OnSysColourChanged)
   EVT_INIT_DIALOG(wxWindowMac::OnInitDialog)
   EVT_ERASE_BACKGROUND(wxWindowMac::OnEraseBackground)
   EVT_SYS_COLOUR_CHANGED(wxWindowMac::OnSysColourChanged)
   EVT_INIT_DIALOG(wxWindowMac::OnInitDialog)

-  EVT_IDLE(wxWindowMac::OnIdle)

   EVT_SET_FOCUS(wxWindowMac::OnSetFocus)
   EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
 END_EVENT_TABLE()
   EVT_SET_FOCUS(wxWindowMac::OnSetFocus)
   EVT_MOUSE_EVENTS(wxWindowMac::OnMouseEvent)
 END_EVENT_TABLE()


@@ -1367,12 +1366,12 @@ void wxWindowMac::SetupColours()
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 
         SetBackgroundColour(GetParent()->GetBackgroundColour());
 }
 

-void wxWindowMac::OnIdle(wxIdleEvent& event)
+void wxWindowMac::OnInternalIdle()

 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)
 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // Raise the window to the top of the Z order
 }
 
 // Raise the window to the top of the Z order

diff --git a/src/mgl/app.cpp b/src/mgl/app.cpp
index fba01c5b4ba45d46bc14c097c753e6ce50c2ea45..45f77b88ae150d4309768e29ca659f4e2a4da61e 100644 (file)
--- a/src/mgl/app.cpp
+++ b/src/mgl/app.cpp
@@ -272,17 +272,6 @@ bool wxApp::OnInitGui()
     return TRUE;
 }
 
     return TRUE;
 }
 

-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::OnIdle(wxIdleEvent &event)
 {
     static bool s_inOnIdle = FALSE;
 void wxApp::OnIdle(wxIdleEvent &event)
 {
     static bool s_inOnIdle = FALSE;


@@ -312,46 +301,6 @@ void wxApp::OnIdle(wxIdleEvent &event)
     s_inOnIdle = FALSE;
 }
 
     s_inOnIdle = FALSE;
 }
 

-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if ( SendIdleEvents(win) )
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-
-    win->GetEventHandler()->ProcessEvent(event);
-
-    if ( event.MoreRequested() )
-        needMore = TRUE;
-
-    wxNode* node = win->GetChildren().First();
-    while (node)
-    {
-        wxWindow* win = (wxWindow*) node->Data();
-        if ( SendIdleEvents(win) )
-            needMore = TRUE;
-
-        node = node->Next();
-    }
-    return needMore;
-}
-

 int wxApp::MainLoop()
 {
     int rt;
 int wxApp::MainLoop()
 {
     int rt;

diff --git a/src/mgl/evtloop.cpp b/src/mgl/evtloop.cpp
index 34c9c24422fc2582f4839109f5cd5ac6669e8be6..95270cda46789ea59c6195423ce1788e1311b8d1 100644 (file)
--- a/src/mgl/evtloop.cpp
+++ b/src/mgl/evtloop.cpp
@@ -97,13 +97,7 @@ void wxEventLoopImpl::Dispatch()
 
 bool wxEventLoopImpl::SendIdleEvent()
 {
 
 bool wxEventLoopImpl::SendIdleEvent()
 {

-    wxIdleEvent event;
-
-    bool processed = wxTheApp->ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();    
-    
-    return processed && event.MoreRequested();
+    return wxTheApp->ProcessIdle();

 }
 
 // ============================================================================
 }
 
 // ============================================================================

diff --git a/src/mgl/window.cpp b/src/mgl/window.cpp
index bd8fa401a707a57dce9f47222ba24deabe0fe844..60b95bff9933f7c0c0beacea6acc0b6be4412bde 100644 (file)
--- a/src/mgl/window.cpp
+++ b/src/mgl/window.cpp
@@ -524,7 +524,6 @@ static ibool MGLAPI wxWindowKeybHandler(window_t *wnd, event_t *e)
 IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindowMGL, wxWindowBase)
 IMPLEMENT_ABSTRACT_CLASS(wxWindowMGL, wxWindowBase)
 
 BEGIN_EVENT_TABLE(wxWindowMGL, wxWindowBase)

-    EVT_IDLE(wxWindowMGL::OnIdle)

 END_EVENT_TABLE()
 
 // ===========================================================================
 END_EVENT_TABLE()
 
 // ===========================================================================


@@ -1276,8 +1275,8 @@ wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
 // idle events processing
 // ---------------------------------------------------------------------------
 
 // idle events processing
 // ---------------------------------------------------------------------------
 

-void wxWindowMGL::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindowMGL::OnInternalIdle()

 {
 {

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 }

diff --git a/src/motif/app.cpp b/src/motif/app.cpp
index 64758e057258eb54d43825a828cbe9c083457153..c391382b4730324510d6742f78b76e83e7d3b07b 100644 (file)
--- a/src/motif/app.cpp
+++ b/src/motif/app.cpp
@@ -170,19 +170,6 @@ int wxApp::MainLoop()
     return 0;
 }
 
     return 0;
 }
 

-// Processes an idle event.
-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-
-    bool processed = ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return processed && event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
     if( m_eventLoop->IsRunning() )
 void wxApp::ExitMainLoop()
 {
     if( m_eventLoop->IsRunning() )


@@ -255,47 +242,6 @@ void wxApp::OnIdle(wxIdleEvent& event)
     inOnIdle = FALSE;
 }
 
     inOnIdle = FALSE;
 }
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-    win->GetEventHandler()->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowList::Node* node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-    return needMore ;
-}
-

 static char *fallbackResources[] = {
     "*menuBar.marginHeight: 0",
     "*menuBar.shadowThickness: 1",
 static char *fallbackResources[] = {
     "*menuBar.marginHeight: 0",
     "*menuBar.shadowThickness: 1",

diff --git a/src/motif/window.cpp b/src/motif/window.cpp
index 268429955291286c8d8dfbe28553a227b412f12e..d9555d591706e7e4519c9d11dee7b4d9752b3de1 100644 (file)
--- a/src/motif/window.cpp
+++ b/src/motif/window.cpp
@@ -145,7 +145,6 @@ static int str16len(const char *s)
 
     BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)
 
     BEGIN_EVENT_TABLE(wxWindow, wxWindowBase)
         EVT_SYS_COLOUR_CHANGED(wxWindow::OnSysColourChanged)

-        EVT_IDLE(wxWindow::OnIdle)

     END_EVENT_TABLE()
 
 // ============================================================================
     END_EVENT_TABLE()
 
 // ============================================================================


@@ -1683,12 +1682,12 @@ void wxWindow::OnSysColourChanged(wxSysColourChangedEvent& event)
     }
 }
 
     }
 }
 

-void wxWindow::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindow::OnInternalIdle()

 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)
 {
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

diff --git a/src/msw/app.cpp b/src/msw/app.cpp
index 08579d8319220c449efcad9727e3bb84ff2e8a8b..4e58a0bba6c8aa74e4dde9b6c3869ae779c57b3b 100644 (file)
--- a/src/msw/app.cpp
+++ b/src/msw/app.cpp
@@ -684,18 +684,6 @@ int wxApp::MainLoop()
     return s_currentMsg.wParam;
 }
 
     return s_currentMsg.wParam;
 }
 

-// Returns TRUE if more time is needed.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
     // this will set m_keepGoing to FALSE a bit later
 void wxApp::ExitMainLoop()
 {
     // this will set m_keepGoing to FALSE a bit later


@@ -841,45 +829,6 @@ void wxApp::OnIdle(wxIdleEvent& event)
     wxIsInOnIdleFlag = FALSE;
 }
 
     wxIsInOnIdleFlag = FALSE;
 }
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    wxIdleEvent event;
-    event.SetEventObject(win);
-    win->GetEventHandler()->ProcessEvent(event);
-
-    bool needMore = event.MoreRequested();
-
-    wxWindowList::Node *node = win->GetChildren().GetFirst();
-    while ( node )
-    {
-        wxWindow *win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-

 void wxApp::WakeUpIdle()
 {
     // Send the top window a dummy message so idle handler processing will
 void wxApp::WakeUpIdle()
 {
     // Send the top window a dummy message so idle handler processing will

diff --git a/src/msw/evtloop.cpp b/src/msw/evtloop.cpp
index f61cc55e7f0d624fca803d8196a96dad9907923e..86ad5ac4b8a04e186031a07072129ef323afbd85 100644 (file)
--- a/src/msw/evtloop.cpp
+++ b/src/msw/evtloop.cpp
@@ -137,13 +137,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
 
 bool wxEventLoopImpl::SendIdleMessage()
 {
 
 bool wxEventLoopImpl::SendIdleMessage()
 {

-    wxIdleEvent event;
-
-    bool processed = wxTheApp->ProcessEvent(event) ;
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return processed && event.MoreRequested();
+    return wxTheApp->ProcessIdle();

 }
 
 // ============================================================================
 }
 
 // ============================================================================

diff --git a/src/msw/frame.cpp b/src/msw/frame.cpp
index 9c9dc1d35f9e5aaa0aa13bfb2840e8055a8f963d..2e3515e690ad1d80f49cefc5cb4ad73e43d95b6b 100644 (file)
--- a/src/msw/frame.cpp
+++ b/src/msw/frame.cpp
@@ -191,12 +191,7 @@ void wxFrame::DoGetClientSize(int *x, int *y) const
 
 void wxFrame::Raise()
 {
 
 void wxFrame::Raise()
 {

-#ifdef __WIN16__
-    // no SetForegroundWindow() in Win16
-    wxFrameBase::Raise();
-#else // Win32

     ::SetForegroundWindow(GetHwnd());
     ::SetForegroundWindow(GetHwnd());

-#endif // Win16/32

 }
 
 // generate an artificial resize event
 }
 
 // generate an artificial resize event


@@ -749,6 +744,10 @@ long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
             }
             break;
 
             }
             break;
 

+        case WM_INITMENU:
+            processed = HandleInitMenu();
+            break;
+

         case WM_PAINT:
             processed = HandlePaint();
             break;
         case WM_PAINT:
             processed = HandlePaint();
             break;


@@ -763,16 +762,18 @@ long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
                 processed = HandleMenuSelect(item, flags, hmenu);
             }
             break;
                 processed = HandleMenuSelect(item, flags, hmenu);
             }
             break;

-
-#ifndef __WIN16__
+            
+        // We don't need to send the wxEVT_MENU_OPEN
+        // when we get WM_ENTERMENULOOP now, because we send
+        // it when we get WM_INITMENU.
+#if 0

         case WM_ENTERMENULOOP:
             processed = HandleMenuLoop(wxEVT_MENU_OPEN, wParam);
             break;
         case WM_ENTERMENULOOP:
             processed = HandleMenuLoop(wxEVT_MENU_OPEN, wParam);
             break;

-
+#endif

         case WM_EXITMENULOOP:
             processed = HandleMenuLoop(wxEVT_MENU_CLOSE, wParam);
             break;
         case WM_EXITMENULOOP:
             processed = HandleMenuLoop(wxEVT_MENU_CLOSE, wParam);
             break;

-#endif // __WIN16__

 
         case WM_QUERYDRAGICON:
             {
 
         case WM_QUERYDRAGICON:
             {


@@ -792,3 +793,15 @@ long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
     return rc;
 }
 
     return rc;
 }
 

+// handle WM_INITMENU message
+bool wxFrame::HandleInitMenu()
+{
+    wxMenuEvent event(wxEVT_MENU_OPEN, 0);
+    event.SetEventObject(this);
+
+    return GetEventHandler()->ProcessEvent(event);
+    
+    return TRUE;
+}
+
+

diff --git a/src/msw/window.cpp b/src/msw/window.cpp
index 57ebce9a768d76925cccf900d76245a25d6fede0..afba07ad53b60734acc42c4c56d64e43661eddca 100644 (file)
--- a/src/msw/window.cpp
+++ b/src/msw/window.cpp
@@ -233,7 +233,6 @@ BEGIN_EVENT_TABLE(wxWindowMSW, wxWindowBase)
     EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
     EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)
     EVT_ERASE_BACKGROUND(wxWindowMSW::OnEraseBackground)
     EVT_SYS_COLOUR_CHANGED(wxWindowMSW::OnSysColourChanged)
     EVT_INIT_DIALOG(wxWindowMSW::OnInitDialog)

-    EVT_IDLE(wxWindowMSW::OnIdle)

 END_EVENT_TABLE()
 
 // ===========================================================================
 END_EVENT_TABLE()
 
 // ===========================================================================


@@ -1146,7 +1145,7 @@ bool wxWindowMSW::IsMouseInWindow() const
     return hwnd != NULL;
 }
 
     return hwnd != NULL;
 }
 

-void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
+void wxWindowMSW::OnInternalIdle()

 {
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )
 {
     // Check if we need to send a LEAVE event
     if ( m_mouseInWindow )


@@ -1159,7 +1158,7 @@ void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
             m_mouseInWindow = FALSE;
 
             // Unfortunately the mouse button and keyboard state may have
             m_mouseInWindow = FALSE;
 
             // Unfortunately the mouse button and keyboard state may have

-            // changed by the time the OnIdle function is called, so 'state'
+            // changed by the time the OnInternalIdle function is called, so 'state'

             // may be meaningless.
             int state = 0;
             if ( wxIsShiftDown() )
             // may be meaningless.
             int state = 0;
             if ( wxIsShiftDown() )


@@ -1192,8 +1191,8 @@ void wxWindowMSW::OnIdle(wxIdleEvent& WXUNUSED(event))
         }
     }
 
         }
     }
 

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 }
 
 // Set this window to be the child of 'parent'.
 }
 
 // Set this window to be the child of 'parent'.


@@ -1266,7 +1265,7 @@ void wxWindowMSW::Update()
         wxLogLastError(_T("UpdateWindow"));
     }
 
         wxLogLastError(_T("UpdateWindow"));
     }
 

-#if defined(__WIN32__) && !defined(__WXMICROWIN__)
+#if !defined(__WXMICROWIN__)

     // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
     // handler needs to be really drawn right now
     (void)::GdiFlush();
     // just calling UpdateWindow() is not enough, what we did in our WM_PAINT
     // handler needs to be really drawn right now
     (void)::GdiFlush();


@@ -2030,11 +2029,9 @@ bool wxWindowMSW::MSWShouldPreProcessMessage(WXMSG* WXUNUSED(pMsg))
 }
 
 // ---------------------------------------------------------------------------
 }
 
 // ---------------------------------------------------------------------------

-// message params unpackers (different for Win16 and Win32)
+// message params unpackers

 // ---------------------------------------------------------------------------
 
 // ---------------------------------------------------------------------------
 

-#ifdef __WIN32__
-

 void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
                              WORD *id, WXHWND *hwnd, WORD *cmd)
 {
 void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
                              WORD *id, WXHWND *hwnd, WORD *cmd)
 {


@@ -2077,50 +2074,6 @@ void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
     *hmenu = (WXHMENU)lParam;
 }
 
     *hmenu = (WXHMENU)lParam;
 }
 

-#else // Win16
-
-void wxWindowMSW::UnpackCommand(WXWPARAM wParam, WXLPARAM lParam,
-                             WXWORD *id, WXHWND *hwnd, WXWORD *cmd)
-{
-    *id = (WXWORD)wParam;
-    *hwnd = (WXHWND)LOWORD(lParam);
-    *cmd = HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackActivate(WXWPARAM wParam, WXLPARAM lParam,
-                              WXWORD *state, WXWORD *minimized, WXHWND *hwnd)
-{
-    *state = (WXWORD)wParam;
-    *minimized = LOWORD(lParam);
-    *hwnd = (WXHWND)HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackScroll(WXWPARAM wParam, WXLPARAM lParam,
-                            WXWORD *code, WXWORD *pos, WXHWND *hwnd)
-{
-    *code = (WXWORD)wParam;
-    *pos = LOWORD(lParam);
-    *hwnd = (WXHWND)HIWORD(lParam);
-}
-
-void wxWindowMSW::UnpackCtlColor(WXWPARAM wParam, WXLPARAM lParam,
-                              WXWORD *nCtlColor, WXHDC *hdc, WXHWND *hwnd)
-{
-    *hwnd = (WXHWND)LOWORD(lParam);
-    *nCtlColor = (int)HIWORD(lParam);
-    *hdc = (WXHDC)wParam;
-}
-
-void wxWindowMSW::UnpackMenuSelect(WXWPARAM wParam, WXLPARAM lParam,
-                                WXWORD *item, WXWORD *flags, WXHMENU *hmenu)
-{
-    *item = (WXWORD)wParam;
-    *flags = LOWORD(lParam);
-    *hmenu = (WXHMENU)HIWORD(lParam);
-}
-
-#endif // Win32/16
-

 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // Main wxWindows window proc and the window proc for wxWindow
 // ---------------------------------------------------------------------------


@@ -2612,7 +2565,6 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
         // CTLCOLOR messages are sent by children to query the parent for their
         // colors#ifndef __WXMICROWIN__
 #ifndef __WXMICROWIN__
         // CTLCOLOR messages are sent by children to query the parent for their
         // colors#ifndef __WXMICROWIN__
 #ifndef __WXMICROWIN__

-#ifdef __WIN32__

         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:
         case WM_CTLCOLORLISTBOX:
         case WM_CTLCOLORMSGBOX:
         case WM_CTLCOLOREDIT:
         case WM_CTLCOLORLISTBOX:


@@ -2620,9 +2572,6 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
         case WM_CTLCOLORDLG:
         case WM_CTLCOLORSCROLLBAR:
         case WM_CTLCOLORSTATIC:
         case WM_CTLCOLORDLG:
         case WM_CTLCOLORSCROLLBAR:
         case WM_CTLCOLORSTATIC:

-#else // Win16
-        case WM_CTLCOLOR:
-#endif // Win32/16

             {
                 WXWORD nCtlColor;
                 WXHDC hdc;
             {
                 WXWORD nCtlColor;
                 WXHDC hdc;


@@ -2724,7 +2673,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
             }
 #endif
 
             }
 #endif
 

-#if defined(__WIN32__) && defined(WM_HELP)
+#if defined(WM_HELP)

         case WM_HELP:
             {
                 HELPINFO* info = (HELPINFO*) lParam;
         case WM_HELP:
             {
                 HELPINFO* info = (HELPINFO*) lParam;


@@ -2785,7 +2734,7 @@ long wxWindowMSW::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam
                 }
             }
             break;
                 }
             }
             break;

-#endif // __WIN32__
+#endif

     }
 
     if ( !processed )
     }
 
     if ( !processed )


@@ -3356,15 +3305,10 @@ bool wxWindowMSW::HandleSetCursor(WXHWND WXUNUSED(hWnd),
     // first ask the user code - it may wish to set the cursor in some very
     // specific way (for example, depending on the current position)
     POINT pt;
     // first ask the user code - it may wish to set the cursor in some very
     // specific way (for example, depending on the current position)
     POINT pt;

-#ifdef __WIN32__

     if ( !::GetCursorPos(&pt) )
     {
         wxLogLastError(wxT("GetCursorPos"));
     }
     if ( !::GetCursorPos(&pt) )
     {
         wxLogLastError(wxT("GetCursorPos"));
     }

-#else
-    // In WIN16 it doesn't return a value.
-    ::GetCursorPos(&pt);
-#endif

 
     int x = pt.x,
         y = pt.y;
 
     int x = pt.x,
         y = pt.y;


@@ -3769,7 +3713,6 @@ bool wxWindowMSW::HandlePaint()
 //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
 //        return FALSE;
 
 //    if (GetExtraStyle() & wxWS_EX_THEMED_BACKGROUND)
 //        return FALSE;
 

-#ifdef __WIN32__

     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
     if ( !hRegion )
         wxLogLastError(wxT("CreateRectRgn"));
     HRGN hRegion = ::CreateRectRgn(0, 0, 0, 0); // Dummy call to get a handle
     if ( !hRegion )
         wxLogLastError(wxT("CreateRectRgn"));


@@ -3777,14 +3720,6 @@ bool wxWindowMSW::HandlePaint()
         wxLogLastError(wxT("GetUpdateRgn"));
 
     m_updateRegion = wxRegion((WXHRGN) hRegion);
         wxLogLastError(wxT("GetUpdateRgn"));
 
     m_updateRegion = wxRegion((WXHRGN) hRegion);

-#else // Win16
-    RECT updateRect;
-    ::GetUpdateRect(GetHwnd(), &updateRect, FALSE);
-
-    m_updateRegion = wxRegion(updateRect.left, updateRect.top,
-                              updateRect.right - updateRect.left,
-                              updateRect.bottom - updateRect.top);
-#endif // Win32/16

 
     wxPaintEvent event(m_windowId);
     event.SetEventObject(this);
 
     wxPaintEvent event(m_windowId);
     event.SetEventObject(this);


@@ -4120,7 +4055,6 @@ static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //
     HWND hwnd = GetHwndOf(win),
          hwndUnderMouse;
 
     HWND hwnd = GetHwndOf(win),
          hwndUnderMouse;
 

-#ifdef __WIN32__

     hwndUnderMouse = ::ChildWindowFromPointEx
                        (
                         hwnd,
     hwndUnderMouse = ::ChildWindowFromPointEx
                        (
                         hwnd,


@@ -4131,7 +4065,6 @@ static wxWindowMSW *FindWindowForMouseEvent(wxWindowMSW *win, int *x, int *y) //
                        );
 
     if ( !hwndUnderMouse || hwndUnderMouse == hwnd )
                        );
 
     if ( !hwndUnderMouse || hwndUnderMouse == hwnd )

-#endif // __WIN32__

     {
         // now try any child window at all
         hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);
     {
         // now try any child window at all
         hwndUnderMouse = ::ChildWindowFromPoint(hwnd, pt);


@@ -4234,7 +4167,6 @@ bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
     event.m_wheelRotation = (short)HIWORD(wParam);
     event.m_wheelDelta = WHEEL_DELTA;
 
     event.m_wheelRotation = (short)HIWORD(wParam);
     event.m_wheelDelta = WHEEL_DELTA;
 

-#ifdef __WIN32__

     static int s_linesPerRotation = -1;
     if ( s_linesPerRotation == -1 )
     {
     static int s_linesPerRotation = -1;
     if ( s_linesPerRotation == -1 )
     {


@@ -4248,10 +4180,6 @@ bool wxWindowMSW::HandleMouseWheel(WXWPARAM wParam, WXLPARAM lParam)
             s_linesPerRotation = 3;
         }
     }
             s_linesPerRotation = 3;
         }
     }

-#else // Win16
-    // no SystemParametersInfo() under Win16
-    static const int s_linesPerRotation = 3;
-#endif

 
     event.m_linesPerAction = s_linesPerRotation;
     return GetEventHandler()->ProcessEvent(event);
 
     event.m_linesPerAction = s_linesPerRotation;
     return GetEventHandler()->ProcessEvent(event);


@@ -4408,8 +4336,6 @@ bool wxWindowMSW::HandleKeyUp(WXWPARAM wParam, WXLPARAM lParam)
     return FALSE;
 }
 
     return FALSE;
 }
 

-#ifdef __WIN32__
-

 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
 {
     const HMENU hmenu = (HMENU)lParam;
 int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
 {
     const HMENU hmenu = (HMENU)lParam;


@@ -4458,7 +4384,7 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
                 }
             }
         }
                 }
             }
         }

-        else // failed ot get the menu text?
+        else // failed to get the menu text?

         {
             // it's not fatal, so don't show error, but still log
             // it
         {
             // it's not fatal, so don't show error, but still log
             // it


@@ -4469,8 +4395,6 @@ int wxWindowMSW::HandleMenuChar(int chAccel, WXLPARAM lParam)
     return wxNOT_FOUND;
 }
 
     return wxNOT_FOUND;
 }
 

-#endif // __WIN32__
-

 // ---------------------------------------------------------------------------
 // joystick
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 // joystick
 // ---------------------------------------------------------------------------


@@ -4606,7 +4530,6 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
 
     case SB_THUMBPOSITION:
     case SB_THUMBTRACK:
 
     case SB_THUMBPOSITION:
     case SB_THUMBTRACK:

-#ifdef __WIN32__

         // under Win32, the scrollbar range and position are 32 bit integers,
         // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
         // explicitly query the scrollbar for the correct position (this must
         // under Win32, the scrollbar range and position are 32 bit integers,
         // but WM_[HV]SCROLL only carry the low 16 bits of them, so we must
         // explicitly query the scrollbar for the correct position (this must


@@ -4626,7 +4549,6 @@ bool wxWindowMSW::MSWOnScroll(int orientation, WXWORD wParam,
 
             event.SetPosition(scrollInfo.nTrackPos);
         }
 
             event.SetPosition(scrollInfo.nTrackPos);
         }

-#endif // Win32

 
         event.m_eventType = wParam == SB_THUMBPOSITION
                                 ? wxEVT_SCROLLWIN_THUMBRELEASE
 
         event.m_eventType = wParam == SB_THUMBPOSITION
                                 ? wxEVT_SCROLLWIN_THUMBRELEASE


@@ -4874,9 +4796,6 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
         win = wxFindWinFromHandle((WXHWND)hwnd);
         if ( !win )
         {
         win = wxFindWinFromHandle((WXHWND)hwnd);
         if ( !win )
         {

-            // all these hacks only work under Win32 anyhow
-#ifdef __WIN32__
-

 #if wxUSE_RADIOBOX
             // native radiobuttons return DLGC_RADIOBUTTON here and for any
             // wxWindow class which overrides WM_GETDLGCODE processing to
 #if wxUSE_RADIOBOX
             // native radiobuttons return DLGC_RADIOBUTTON here and for any
             // wxWindow class which overrides WM_GETDLGCODE processing to


@@ -4896,8 +4815,6 @@ extern wxWindow *wxGetWindowFromHWND(WXHWND hWnd)
                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
             }
 #endif // wxUSE_SPINCTRL
                 win = wxSpinCtrl::GetSpinForTextCtrl((WXHWND)hwnd);
             }
 #endif // wxUSE_SPINCTRL

-
-#endif // Win32

         }
     }
 
         }
     }
 


@@ -4942,23 +4859,13 @@ void wxSetKeyboardHook(bool doIt)
         wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
         wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
 
         wxTheKeyboardHookProc = MakeProcInstance((FARPROC) wxKeyboardHook, wxGetInstance());
         wxTheKeyboardHook = SetWindowsHookEx(WH_KEYBOARD, (HOOKPROC) wxTheKeyboardHookProc, wxGetInstance(),
 

-#if defined(__WIN32__)

             GetCurrentThreadId()
         //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?
             GetCurrentThreadId()
         //      (DWORD)GetCurrentProcess()); // This is another possibility. Which is right?

-#else
-            GetCurrentTask()
-#endif

             );
     }
     else
     {
         UnhookWindowsHookEx(wxTheKeyboardHook);
             );
     }
     else
     {
         UnhookWindowsHookEx(wxTheKeyboardHook);

-
-        // avoids warning about statement with no effect (FreeProcInstance
-        // doesn't do anything under Win32)
-#if !defined(__WIN32__) && !defined(__NT__)
-        FreeProcInstance(wxTheKeyboardHookProc);
-#endif

     }
 }
 
     }
 }
 


@@ -5066,7 +4973,6 @@ const char *wxGetMessageName(int message)
         case 0x0047: return "WM_WINDOWPOSCHANGED";
         case 0x0048: return "WM_POWER";
 
         case 0x0047: return "WM_WINDOWPOSCHANGED";
         case 0x0048: return "WM_POWER";
 

-#ifdef  __WIN32__

         case 0x004A: return "WM_COPYDATA";
         case 0x004B: return "WM_CANCELJOURNAL";
         case 0x004E: return "WM_NOTIFY";
         case 0x004A: return "WM_COPYDATA";
         case 0x004B: return "WM_CANCELJOURNAL";
         case 0x004E: return "WM_NOTIFY";


@@ -5082,7 +4988,6 @@ const char *wxGetMessageName(int message)
         case 0x007E: return "WM_DISPLAYCHANGE";
         case 0x007F: return "WM_GETICON";
         case 0x0080: return "WM_SETICON";
         case 0x007E: return "WM_DISPLAYCHANGE";
         case 0x007F: return "WM_GETICON";
         case 0x0080: return "WM_SETICON";

-#endif  //WIN32

 
         case 0x0081: return "WM_NCCREATE";
         case 0x0082: return "WM_NCDESTROY";
 
         case 0x0081: return "WM_NCCREATE";
         case 0x0082: return "WM_NCDESTROY";


@@ -5111,11 +5016,9 @@ const char *wxGetMessageName(int message)
         case 0x0107: return "WM_SYSDEADCHAR";
         case 0x0108: return "WM_KEYLAST";
 
         case 0x0107: return "WM_SYSDEADCHAR";
         case 0x0108: return "WM_KEYLAST";
 

-#ifdef  __WIN32__

         case 0x010D: return "WM_IME_STARTCOMPOSITION";
         case 0x010E: return "WM_IME_ENDCOMPOSITION";
         case 0x010F: return "WM_IME_COMPOSITION";
         case 0x010D: return "WM_IME_STARTCOMPOSITION";
         case 0x010E: return "WM_IME_ENDCOMPOSITION";
         case 0x010F: return "WM_IME_COMPOSITION";

-#endif  //WIN32

 
         case 0x0110: return "WM_INITDIALOG";
         case 0x0111: return "WM_COMMAND";
 
         case 0x0110: return "WM_INITDIALOG";
         case 0x0111: return "WM_COMMAND";


@@ -5143,14 +5046,12 @@ const char *wxGetMessageName(int message)
         case 0x0211: return "WM_ENTERMENULOOP";
         case 0x0212: return "WM_EXITMENULOOP";
 
         case 0x0211: return "WM_ENTERMENULOOP";
         case 0x0212: return "WM_EXITMENULOOP";
 

-#ifdef  __WIN32__

         case 0x0213: return "WM_NEXTMENU";
         case 0x0214: return "WM_SIZING";
         case 0x0215: return "WM_CAPTURECHANGED";
         case 0x0216: return "WM_MOVING";
         case 0x0218: return "WM_POWERBROADCAST";
         case 0x0219: return "WM_DEVICECHANGE";
         case 0x0213: return "WM_NEXTMENU";
         case 0x0214: return "WM_SIZING";
         case 0x0215: return "WM_CAPTURECHANGED";
         case 0x0216: return "WM_MOVING";
         case 0x0218: return "WM_POWERBROADCAST";
         case 0x0219: return "WM_DEVICECHANGE";

-#endif  //WIN32

 
         case 0x0220: return "WM_MDICREATE";
         case 0x0221: return "WM_MDIDESTROY";
 
         case 0x0220: return "WM_MDICREATE";
         case 0x0221: return "WM_MDIDESTROY";


@@ -5165,7 +5066,6 @@ const char *wxGetMessageName(int message)
         case 0x0230: return "WM_MDISETMENU";
         case 0x0233: return "WM_DROPFILES";
 
         case 0x0230: return "WM_MDISETMENU";
         case 0x0233: return "WM_DROPFILES";
 

-#ifdef  __WIN32__

         case 0x0281: return "WM_IME_SETCONTEXT";
         case 0x0282: return "WM_IME_NOTIFY";
         case 0x0283: return "WM_IME_CONTROL";
         case 0x0281: return "WM_IME_SETCONTEXT";
         case 0x0282: return "WM_IME_NOTIFY";
         case 0x0283: return "WM_IME_CONTROL";


@@ -5174,7 +5074,6 @@ const char *wxGetMessageName(int message)
         case 0x0286: return "WM_IME_CHAR";
         case 0x0290: return "WM_IME_KEYDOWN";
         case 0x0291: return "WM_IME_KEYUP";
         case 0x0286: return "WM_IME_CHAR";
         case 0x0290: return "WM_IME_KEYDOWN";
         case 0x0291: return "WM_IME_KEYUP";

-#endif  //WIN32

 
         case 0x0300: return "WM_CUT";
         case 0x0301: return "WM_COPY";
 
         case 0x0300: return "WM_CUT";
         case 0x0301: return "WM_COPY";


@@ -5195,7 +5094,6 @@ const char *wxGetMessageName(int message)
         case 0x0310: return "WM_PALETTEISCHANGING";
         case 0x0311: return "WM_PALETTECHANGED";
 
         case 0x0310: return "WM_PALETTEISCHANGING";
         case 0x0311: return "WM_PALETTECHANGED";
 

-#ifdef __WIN32__

         // common controls messages - although they're not strictly speaking
         // standard, it's nice to decode them nevertheless
 
         // common controls messages - although they're not strictly speaking
         // standard, it's nice to decode them nevertheless
 


@@ -5417,8 +5315,6 @@ const char *wxGetMessageName(int message)
         case WM_USER+61: return "TB_GETTEXTROWS";
         case WM_USER+41: return "TB_GETBITMAPFLAGS";
 
         case WM_USER+61: return "TB_GETTEXTROWS";
         case WM_USER+41: return "TB_GETBITMAPFLAGS";
 

-#endif //WIN32
-

         default:
             static char s_szBuf[128];
             sprintf(s_szBuf, "<unknown message = %d>", message);
         default:
             static char s_szBuf[128];
             sprintf(s_szBuf, "<unknown message = %d>", message);

diff --git a/src/os2/app.cpp b/src/os2/app.cpp
index d7539983f91e18ef1222ee639cb34730e44da06b..6ea69bbc90a4eb31006ea0dd7a1aefc3bdff163d 100644 (file)
--- a/src/os2/app.cpp
+++ b/src/os2/app.cpp
@@ -659,19 +659,6 @@ int wxApp::MainLoop()
     return (int)svCurrentMsg.mp1;
 } // end of wxApp::MainLoop
 
     return (int)svCurrentMsg.mp1;
 } // end of wxApp::MainLoop
 

-//
-// Returns TRUE if more time is needed.
-//
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent                     vEvent;
-
-    vEvent.SetEventObject(this);
-    ProcessEvent(vEvent);
-    wxUpdateUIEvent::ResetUpdateTime();    
-    return vEvent.MoreRequested();
-} // end of wxApp::ProcessIdle
-

 void wxApp::ExitMainLoop()
 {
     ::WinPostMsg(NULL, WM_QUIT, 0, 0);
 void wxApp::ExitMainLoop()
 {
     ::WinPostMsg(NULL, WM_QUIT, 0, 0);


@@ -835,52 +822,6 @@ void wxApp::OnIdle(
     gbInOnIdle = FALSE;
 } // end of wxApp::OnIdle
 
     gbInOnIdle = FALSE;
 } // end of wxApp::OnIdle
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool                            bNeedMore = FALSE;
-    wxWindowList::Node*             pNode = wxTopLevelWindows.GetFirst();
-
-    while (pNode)
-    {
-        wxWindow*                   pWin = pNode->GetData();
-
-        if (SendIdleEvents(pWin))
-            bNeedMore = TRUE;
-        pNode = pNode->GetNext();
-    }
-    return bNeedMore;
-} // end of wxApp::SendIdleEvents
-
-//
-// Send idle event to window and all subwindows
-//
-bool wxApp::SendIdleEvents(
-  wxWindow*                         pWin
-)
-{
-    bool                            bNeedMore = FALSE;
-    wxIdleEvent                     vEvent;
-
-    vEvent.SetEventObject(pWin);
-    pWin->GetEventHandler()->ProcessEvent(vEvent);
-
-    if (vEvent.MoreRequested())
-        bNeedMore = TRUE;
-
-    wxNode*                         pNode = pWin->GetChildren().First();
-
-    while (pNode)
-    {
-        wxWindow*                   pWin = (wxWindow*) pNode->Data();
-
-        if (SendIdleEvents(pWin))
-            bNeedMore = TRUE;
-        pNode = pNode->Next();
-    }
-    return bNeedMore;
-} // end of wxApp::SendIdleEvents
-

 void wxApp::OnEndSession(
   wxCloseEvent&                     WXUNUSED(rEvent))
 {
 void wxApp::OnEndSession(
   wxCloseEvent&                     WXUNUSED(rEvent))
 {

diff --git a/src/os2/evtloop.cpp b/src/os2/evtloop.cpp
index e177f38ee0f693997709d692dbea11ebb3680e18..2b72b4088db362a6b77e9908b3f277bdf15f7ee2 100644 (file)
--- a/src/os2/evtloop.cpp
+++ b/src/os2/evtloop.cpp
@@ -138,13 +138,7 @@ bool wxEventLoopImpl::PreProcessMessage(QMSG *msg)
 
 bool wxEventLoopImpl::SendIdleMessage()
 {
 
 bool wxEventLoopImpl::SendIdleMessage()
 {

-    wxIdleEvent event;
-
-    bool processed = wxTheApp->ProcessEvent(event) ;
-
-    wxUpdateUIEvent::ResetUpdateTime();    
-    
-    return processed && event.MoreRequested();
+    return wxTheApp->ProcessIdle() ;

 }
 
 // ============================================================================
 }
 
 // ============================================================================

diff --git a/src/os2/window.cpp b/src/os2/window.cpp
index 7903c10e6c5bf4e28758a0f84e6258c8925cde0a..affeabe47e5588111935250d5a1448f18901c9d7 100644 (file)
--- a/src/os2/window.cpp
+++ b/src/os2/window.cpp
@@ -1364,8 +1364,8 @@ void wxWindowOS2::OnIdle(
             (void)GetEventHandler()->ProcessEvent(rEvent);
         }
     }
             (void)GetEventHandler()->ProcessEvent(rEvent);
         }
     }

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 } // end of wxWindowOS2::OnIdle
 
 //
 } // end of wxWindowOS2::OnIdle
 
 //

diff --git a/src/univ/listbox.cpp b/src/univ/listbox.cpp
index 7ae71b51fe04672cda2ac7e7605abddda5c23165..4612caa01df895d24394c0cef4bc83d017e0b61b 100644 (file)
--- a/src/univ/listbox.cpp
+++ b/src/univ/listbox.cpp
@@ -49,8 +49,6 @@ IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
 
 BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
     EVT_SIZE(wxListBox::OnSize)
 
 BEGIN_EVENT_TABLE(wxListBox, wxListBoxBase)
     EVT_SIZE(wxListBox::OnSize)

-
-    EVT_IDLE(wxListBox::OnIdle)

 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------


@@ -601,7 +599,7 @@ void wxListBox::UpdateItems()
     }
 }
 
     }
 }
 

-void wxListBox::OnIdle(wxIdleEvent& event)
+void wxListBox::OnInternalIdle()

 {
     if ( m_updateScrollbarY || m_updateScrollbarX )
     {
 {
     if ( m_updateScrollbarY || m_updateScrollbarX )
     {


@@ -624,8 +622,6 @@ void wxListBox::OnIdle(wxIdleEvent& event)
 
         m_updateCount = 0;
     }
 
         m_updateCount = 0;
     }

-
-    event.Skip();

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

diff --git a/src/univ/menu.cpp b/src/univ/menu.cpp
index bba605997faaeaad5ebdf24fe0b89f32b0bf7628..a4e117655227f453b38a2058a77cae2f6b32b8ff 100644 (file)
--- a/src/univ/menu.cpp
+++ b/src/univ/menu.cpp
@@ -2463,8 +2463,7 @@ bool wxWindow::DoPopupMenu(wxMenu *menu, int x, int y)
     wxLog::FlushActive();
 
     // some controls update themselves from OnIdle() call - let them do it
     wxLog::FlushActive();
 
     // some controls update themselves from OnIdle() call - let them do it

-    wxIdleEvent event;
-    wxTheApp->ProcessEvent(event);
+    wxTheApp->ProcessIdle();

 
     // if the window hadn't been refreshed yet, the menu can adversely affect
     // its next OnPaint() handler execution - i.e. scrolled window refresh
 
     // if the window hadn't been refreshed yet, the menu can adversely affect
     // its next OnPaint() handler execution - i.e. scrolled window refresh

diff --git a/src/univ/scrolbar.cpp b/src/univ/scrolbar.cpp
index b13034d837d154ee9fd56ed6d3a0fe53c3803c6c..372b3b3fe97a29d586023cf540cc092cccf29685 100644 (file)
--- a/src/univ/scrolbar.cpp
+++ b/src/univ/scrolbar.cpp
@@ -83,7 +83,6 @@ private:
 IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
 
 BEGIN_EVENT_TABLE(wxScrollBar, wxScrollBarBase)
 IMPLEMENT_DYNAMIC_CLASS(wxScrollBar, wxControl)
 
 BEGIN_EVENT_TABLE(wxScrollBar, wxScrollBarBase)

-    EVT_IDLE(wxScrollBar::OnIdle)

 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------
 END_EVENT_TABLE()
 
 // ----------------------------------------------------------------------------


@@ -322,10 +321,9 @@ wxScrollArrows::Arrow wxScrollBar::HitTest(const wxPoint& pt) const
 // drawing
 // ----------------------------------------------------------------------------
 
 // drawing
 // ----------------------------------------------------------------------------
 

-void wxScrollBar::OnIdle(wxIdleEvent& event)
+void wxScrollBar::OnInternalIdle()

 {
     UpdateThumb();
 {
     UpdateThumb();

-    event.Skip();

 }
 
 void wxScrollBar::UpdateThumb()
 }
 
 void wxScrollBar::UpdateThumb()

diff --git a/src/univ/textctrl.cpp b/src/univ/textctrl.cpp
index ae45b1e13ae1d5e3c068be16f89267726e399903..afd8751329814c29f67914d572d6442254bb594f 100644 (file)
--- a/src/univ/textctrl.cpp
+++ b/src/univ/textctrl.cpp
@@ -608,8 +608,6 @@ BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
     EVT_CHAR(wxTextCtrl::OnChar)
 
     EVT_SIZE(wxTextCtrl::OnSize)
     EVT_CHAR(wxTextCtrl::OnChar)
 
     EVT_SIZE(wxTextCtrl::OnSize)

-
-    EVT_IDLE(wxTextCtrl::OnIdle)

 END_EVENT_TABLE()
 
 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)
 END_EVENT_TABLE()
 
 IMPLEMENT_DYNAMIC_CLASS(wxTextCtrl, wxControl)


@@ -3571,7 +3569,7 @@ void wxTextCtrl::UpdateScrollbars()
     MData().m_updateScrollbarY = FALSE;
 }
 
     MData().m_updateScrollbarY = FALSE;
 }
 

-void wxTextCtrl::OnIdle(wxIdleEvent& event)
+void wxTextCtrl::OnInternalIdle()

 {
     // notice that single line text control never has scrollbars
     if ( !IsSingleLine() &&
 {
     // notice that single line text control never has scrollbars
     if ( !IsSingleLine() &&


@@ -3579,8 +3577,6 @@ void wxTextCtrl::OnIdle(wxIdleEvent& event)
     {
         UpdateScrollbars();
     }
     {
         UpdateScrollbars();
     }

-
-    event.Skip();

 }
 
 bool wxTextCtrl::SendAutoScrollEvents(wxScrollWinEvent& event) const
 }
 
 bool wxTextCtrl::SendAutoScrollEvents(wxScrollWinEvent& event) const

diff --git a/src/x11/app.cpp b/src/x11/app.cpp
index 87fcdb4ea1792c699228ddba9c61c00437f1aad2..ff91c2fb6b632ed61baf68fd1c88c8e1ce4e980e 100644 (file)
--- a/src/x11/app.cpp
+++ b/src/x11/app.cpp
@@ -672,20 +672,6 @@ bool wxApp::ProcessXEvent(WXEvent* _event)
     return FALSE;
 }
 
     return FALSE;
 }
 

-// Returns TRUE if more time is needed.
-// Note that this duplicates wxEventLoopImpl::SendIdleEvent
-// but ProcessIdle may be needed by apps, so is kept.
-bool wxApp::ProcessIdle()
-{
-    wxIdleEvent event;
-    event.SetEventObject(this);
-    ProcessEvent(event);
-
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return event.MoreRequested();
-}
-

 void wxApp::ExitMainLoop()
 {
     if (m_mainLoop)
 void wxApp::ExitMainLoop()
 {
     if (m_mainLoop)


@@ -748,51 +734,6 @@ void wxApp::WakeUpIdle()
 }
 
 
 }
 
 

-// Send idle event to all top-level windows
-bool wxApp::SendIdleEvents()
-{
-    bool needMore = FALSE;
-
-    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
-    while (node)
-    {
-        wxWindow* win = node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-        node = node->GetNext();
-    }
-
-    return needMore;
-}
-
-// Send idle event to window and all subwindows
-bool wxApp::SendIdleEvents(wxWindow* win)
-{
-    bool needMore = FALSE;
-
-    wxIdleEvent event;
-    event.SetEventObject(win);
-
-    win->GetEventHandler()->ProcessEvent(event);
-
-    if (event.MoreRequested())
-        needMore = TRUE;
-
-    wxWindowListNode* node = win->GetChildren().GetFirst();
-    while (node)
-    {
-        wxWindow* win = (wxWindow*) node->GetData();
-        if (SendIdleEvents(win))
-            needMore = TRUE;
-
-        node = node->GetNext();
-    }
-
-    win->OnInternalIdle();
-
-    return needMore;
-}
-

 // Create display, and other initialization
 bool wxApp::OnInitGui()
 {
 // Create display, and other initialization
 bool wxApp::OnInitGui()
 {

diff --git a/src/x11/evtloop.cpp b/src/x11/evtloop.cpp
index d236f1afc8f05013593856f7d1ce7d9c7bc2aa03..20da77c3e790b129137dab0a64b9ed38c3f4d2cf 100644 (file)
--- a/src/x11/evtloop.cpp
+++ b/src/x11/evtloop.cpp
@@ -335,14 +335,7 @@ bool wxEventLoopImpl::PreProcessEvent(XEvent *event)
 
 bool wxEventLoopImpl::SendIdleEvent()
 {
 
 bool wxEventLoopImpl::SendIdleEvent()
 {

-    wxIdleEvent event;
-    event.SetEventObject(wxTheApp);
-
-    bool processed = wxTheApp->ProcessEvent(event) ;
-    
-    wxUpdateUIEvent::ResetUpdateTime();
-    
-    return processed && event.MoreRequested();
+    return wxTheApp->ProcessIdle();

 }
 
 // ============================================================================
 }
 
 // ============================================================================

diff --git a/src/x11/textctrl.cpp b/src/x11/textctrl.cpp
index 7381cfef0f7678bb1c60f652d6ec0b51e4b5b1fd..9f69ec1a2105ca416ec3b9854739fb183adee73b 100644 (file)
--- a/src/x11/textctrl.cpp
+++ b/src/x11/textctrl.cpp
@@ -135,7 +135,6 @@ BEGIN_EVENT_TABLE(wxTextCtrl, wxControl)
     EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
     EVT_CHAR(wxTextCtrl::OnChar)
     EVT_MOUSE_EVENTS(wxTextCtrl::OnMouse)
     EVT_ERASE_BACKGROUND(wxTextCtrl::OnEraseBackground)
     EVT_CHAR(wxTextCtrl::OnChar)
     EVT_MOUSE_EVENTS(wxTextCtrl::OnMouse)

-    EVT_IDLE(wxTextCtrl::OnIdle)

     EVT_KILL_FOCUS(wxTextCtrl::OnKillFocus)
     EVT_SET_FOCUS(wxTextCtrl::OnSetFocus)
     
     EVT_KILL_FOCUS(wxTextCtrl::OnKillFocus)
     EVT_SET_FOCUS(wxTextCtrl::OnSetFocus)
     


@@ -1962,14 +1961,12 @@ void wxTextCtrl::OnChar( wxKeyEvent &event )
     event.Skip();
 }
 
     event.Skip();
 }
 

-void wxTextCtrl::OnIdle( wxIdleEvent &event )
+void wxTextCtrl::OnInternalIdle()

 {
     m_ignoreInput = FALSE;
     
     if (m_lang != wxSOURCE_LANG_NONE)
         SearchForBrackets();
 {
     m_ignoreInput = FALSE;
     
     if (m_lang != wxSOURCE_LANG_NONE)
         SearchForBrackets();

-    
-    event.Skip( TRUE );

 }
 
 void wxTextCtrl::Indent()
 }
 
 void wxTextCtrl::Indent()

diff --git a/src/x11/window.cpp b/src/x11/window.cpp
index d787a4eaef50fc07a41ca96117aac7573d6f7961..4ae7c1468bfa0f9db327c5fa42dc47140586107c 100644 (file)
--- a/src/x11/window.cpp
+++ b/src/x11/window.cpp
@@ -1287,8 +1287,8 @@ void wxWindowX11::OnInternalIdle()
 
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)
 
     // This calls the UI-update mechanism (querying windows for
     // menu/toolbar/control state information)

-    if (wxUpdateUIEvent::CanUpdate())
-        UpdateWindowUI();
+    if (wxUpdateUIEvent::CanUpdate(this))
+        UpdateWindowUI(wxUPDATE_UI_FROMIDLE);

 
     // Set the input focus if couldn't do it before
     if (m_needsInputFocus)
 
     // Set the input focus if couldn't do it before
     if (m_needsInputFocus)