Merge pull request #1 from saurabhb17/develop

Secondary files

1 files changed, 619 insertions, 0 deletions

diff --git a/common/dialog_shim.cpp b/common/dialog_shim.cpp
new file mode 100644
index 0000000..a05a5b6
--- /dev/null
+++ b/common/dialog_shim.cpp
@@ -0,0 +1,619 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * Copyright (C) 2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
+ * Copyright (C) 2012-2016 KiCad Developers, see AUTHORS.txt for contributors.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, you may find one here:
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
+ * or you may search the http://www.gnu.org website for the version 2 license,
+ * or you may write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
+ */
+
+#include <dialog_shim.h>
+#include <kiway_player.h>
+#include <wx/evtloop.h>
+#include <pgm_base.h>
+
+
+/// Toggle a window's "enable" status to disabled, then enabled on destruction.
+class WDO_ENABLE_DISABLE
+{
+    wxWindow* m_win;
+
+public:
+
+    WDO_ENABLE_DISABLE( wxWindow* aWindow ) :
+        m_win( aWindow )
+    {
+        if( m_win )
+            m_win->Disable();
+    }
+
+    ~WDO_ENABLE_DISABLE()
+    {
+        if( m_win )
+        {
+            m_win->Enable();
+            m_win->SetFocus(); // let's focus back on the parent window
+        }
+    }
+};
+
+
+DIALOG_SHIM::DIALOG_SHIM( wxWindow* aParent, wxWindowID id, const wxString& title,
+        const wxPoint& pos, const wxSize& size, long style, const wxString& name ) :
+    wxDialog( aParent, id, title, pos, size, style, name ),
+    KIWAY_HOLDER( 0 ),
+    m_qmodal_loop( 0 ),
+    m_qmodal_showing( false ),
+    m_qmodal_parent_disabler( 0 )
+{
+    // pray that aParent is either a KIWAY_PLAYER or DIALOG_SHIM derivation.
+    KIWAY_HOLDER* h = dynamic_cast<KIWAY_HOLDER*>( aParent );
+
+    // wxASSERT_MSG( h, wxT( "DIALOG_SHIM's parent is NULL or not derived from KIWAY_PLAYER nor DIALOG_SHIM" ) );
+
+    if( h )
+        SetKiway( this, &h->Kiway() );
+
+    Bind( wxEVT_CLOSE_WINDOW, &DIALOG_SHIM::OnCloseWindow, this );
+    Bind( wxEVT_BUTTON, &DIALOG_SHIM::OnButton, this );
+
+#ifdef __WINDOWS__
+    // On Windows, the app top windows can be brought to the foreground
+    // (at least temporary) in certain circumstances,
+    // for instance when calling an external tool in Eeschema boom generation.
+    // So set the parent KIWAY_PLAYER kicad frame (if exists) to top window
+    // to avoid this annoying behavior
+    KIWAY_PLAYER* parent_kiwayplayer = dynamic_cast<KIWAY_PLAYER*>( aParent );
+
+    if( parent_kiwayplayer )
+        Pgm().App().SetTopWindow( parent_kiwayplayer );
+#endif
+
+#if DLGSHIM_USE_SETFOCUS
+    Connect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( DIALOG_SHIM::onInit ) );
+#endif
+}
+
+
+DIALOG_SHIM::~DIALOG_SHIM()
+{
+    // if the dialog is quasi-modal, this will end its event loop
+    if( IsQuasiModal() )
+        EndQuasiModal( wxID_CANCEL );
+
+    delete m_qmodal_parent_disabler;    // usually NULL by now
+}
+
+void DIALOG_SHIM::FinishDialogSettings()
+{
+    // must be called from the constructor of derived classes,
+    // when all widgets are initialized, and therefore their size fixed
+
+    // SetSizeHints fixes the minimal size of sizers in the dialog
+    // (SetSizeHints calls Fit(), so no need to call it)
+    GetSizer()->SetSizeHints( this );
+
+    // the default position, when calling the first time the dlg
+    Center();
+}
+
+void DIALOG_SHIM::FixOSXCancelButtonIssue()
+{
+#ifdef  __WXMAC__
+    // A ugly hack to fix an issue on OSX: ctrl+c closes the dialog instead of
+    // copying a text if a  button with wxID_CANCEL is used in a wxStdDialogButtonSizer
+    // created by wxFormBuilder: the label is &Cancel, and this accelerator key has priority
+    // to copy text standard accelerator, and the dlg is closed when trying to copy text
+    wxButton* button = dynamic_cast< wxButton* > ( wxWindow::FindWindowById( wxID_CANCEL, this ) );
+
+    if( button )
+        button->SetLabel( _( "Cancel" ) );
+#endif
+}
+
+
+// our hashtable is an implementation secret, don't need or want it in a header file
+#include <hashtables.h>
+#include <base_struct.h>        // EDA_RECT
+#include <typeinfo>
+
+static RECT_MAP class_map;
+
+bool DIALOG_SHIM::Show( bool show )
+{
+    bool        ret;
+    const char* hash_key;
+
+    if( m_hash_key.size() )
+    {
+        // a special case like EDA_LIST_DIALOG, which has multiple uses.
+        hash_key = m_hash_key.c_str();
+    }
+    else
+    {
+        hash_key = typeid(*this).name();
+    }
+
+    // Show or hide the window.  If hiding, save current position and size.
+    // If showing, use previous position and size.
+    if( show )
+    {
+        wxDialog::Raise();  // Needed on OS X and some other window managers (i.e. Unity)
+        ret = wxDialog::Show( show );
+
+        // classname is key, returns a zeroed out default EDA_RECT if none existed before.
+        EDA_RECT r = class_map[ hash_key ];
+
+        if( r.GetSize().x != 0 && r.GetSize().y != 0 )
+            SetSize( r.GetPosition().x, r.GetPosition().y, r.GetSize().x, r.GetSize().y, 0 );
+    }
+    else
+    {
+        // Save the dialog's position & size before hiding, using classname as key
+        EDA_RECT  r( wxDialog::GetPosition(), wxDialog::GetSize() );
+        class_map[ hash_key ] = r;
+
+        ret = wxDialog::Show( show );
+    }
+    return ret;
+}
+
+
+bool DIALOG_SHIM::Enable( bool enable )
+{
+    // so we can do logging of this state change:
+
+#if defined(DEBUG)
+    const char* type_id = typeid( *this ).name();
+    printf( "wxDialog %s: %s\n", type_id, enable ? "enabled" : "disabled" );
+#endif
+
+    return wxDialog::Enable( enable );
+}
+
+
+#if DLGSHIM_USE_SETFOCUS
+
+static bool findWindowRecursively( const wxWindowList& children, const wxWindow* wanted )
+{
+    for( wxWindowList::const_iterator it = children.begin();  it != children.end();  ++it )
+    {
+        const wxWindow* child = *it;
+
+        if( wanted == child )
+            return true;
+        else
+        {
+            if( findWindowRecursively( child->GetChildren(), wanted ) )
+                return true;
+        }
+    }
+
+    return false;
+}
+
+
+static bool findWindowRecursively( const wxWindow* topmost, const wxWindow* wanted )
+{
+    // wanted may be NULL and that is ok.
+
+    if( wanted == topmost )
+        return true;
+
+    return findWindowRecursively( topmost->GetChildren(), wanted );
+}
+
+
+/// Set the focus if it is not already set in a derived constructor to a specific control.
+void DIALOG_SHIM::onInit( wxInitDialogEvent& aEvent )
+{
+    wxWindow* focusWnd = wxWindow::FindFocus();
+
+    // If focusWnd is not already this window or a child of it, then SetFocus().
+    // Otherwise the derived class's constructor SetFocus() already to a specific
+    // child control.
+
+    if( !findWindowRecursively( this, focusWnd ) )
+    {
+        // Linux wxGTK needs this to allow the ESCAPE key to close a wxDialog window.
+        SetFocus();
+    }
+
+    aEvent.Skip();     // derived class's handler should be called too
+}
+#endif
+
+
+/*
+    Quasi-Modal Mode Explained:
+
+    The gtk calls in wxDialog::ShowModal() cause event routing problems if that
+    modal dialog then tries to use KIWAY_PLAYER::ShowModal().  The latter shows up
+    and mostly works but does not respond to the window decoration close button.
+    There is no way to get around this without reversing the gtk calls temporarily.
+
+    Quasi-Modal mode is our own almost modal mode which disables only the parent
+    of the DIALOG_SHIM, leaving other frames operable and while staying captured in the
+    nested event loop.  This avoids the gtk calls and leaves event routing pure
+    and sufficient to operate the KIWAY_PLAYER::ShowModal() properly.  When using
+    ShowQuasiModal() you have to use EndQuasiModal() in your dialogs and not
+    EndModal().  There is also IsQuasiModal() but its value can only be true
+    when the nested event loop is active.  Do not mix the modal and quasi-modal
+    functions.  Use one set or the other.
+
+    You might find this behavior preferable over a pure modal mode, and it was said
+    that only the Mac has this natively, but now other platforms have something
+    similar.  You CAN use it anywhere for any dialog.  But you MUST use it when
+    you want to use KIWAY_PLAYER::ShowModal() from a dialog event.
+*/
+
+
+
+/*
+/// wxEventLoopActivator but with a friend so it
+/// has access to m_evtLoopOld, and it does not SetActive() as that is
+/// done inside base class Run().
+class ELOOP_ACTIVATOR
+{
+    friend class EVENT_LOOP;
+
+public:
+    ELOOP_ACTIVATOR( WX_EVENT_LOOP* evtLoop )
+    {
+        m_evtLoopOld = wxEventLoopBase::GetActive();
+        // wxEventLoopBase::SetActive( evtLoop );
+    }
+
+    ~ELOOP_ACTIVATOR()
+    {
+        // restore the previously active event loop
+        wxEventLoopBase::SetActive( m_evtLoopOld );
+    }
+
+private:
+    WX_EVENT_LOOP* m_evtLoopOld;
+};
+*/
+
+
+class EVENT_LOOP : public WX_EVENT_LOOP
+{
+public:
+
+    EVENT_LOOP()
+    {
+        ;
+    }
+
+    ~EVENT_LOOP()
+    {
+    }
+
+#if 0   // does not work any better than inherited wxGuiEventLoop functions:
+
+    // sets the "should exit" flag and wakes up the loop so that it terminates
+    // soon
+    void ScheduleExit( int rc = 0 )
+    {
+        wxCHECK_RET( IsInsideRun(), wxT("can't call ScheduleExit() if not running") );
+
+        m_exitcode = rc;
+        m_shouldExit = true;
+
+        OnExit();
+
+        // all we have to do to exit from the loop is to (maybe) wake it up so that
+        // it can notice that Exit() had been called
+        //
+        // in particular, do *not* use here calls such as PostQuitMessage() (under
+        // MSW) which terminate the current event loop here because we're not sure
+        // that it is going to be processed by the correct event loop: it would be
+        // possible that another one is started and terminated by mistake if we do
+        // this
+        WakeUp();
+    }
+
+    int Run()
+    {
+        // event loops are not recursive, you need to create another loop!
+        //wxCHECK_MSG( !IsInsideRun(), -1, wxT("can't reenter a message loop") );
+
+        // ProcessIdle() and ProcessEvents() below may throw so the code here should
+        // be exception-safe, hence we must use local objects for all actions we
+        // should undo
+        wxEventLoopActivator activate(this);
+
+        // We might be called again, after a previous call to ScheduleExit(), so
+        // reset this flag.
+        m_shouldExit = false;
+
+        // Set this variable to true for the duration of this method.
+        setInsideRun( true );
+
+        struct SET_FALSE
+        {
+            EVENT_LOOP* m_loop;
+            SET_FALSE( EVENT_LOOP* aLoop ) : m_loop( aLoop ) {}
+            ~SET_FALSE() { m_loop->setInsideRun( false ); }
+        } t( this );
+
+        // Finally really run the loop.
+        return DoRun();
+    }
+
+    bool ProcessEvents()
+    {
+        // process pending wx events first as they correspond to low-level events
+        // which happened before, i.e. typically pending events were queued by a
+        // previous call to Dispatch() and if we didn't process them now the next
+        // call to it might enqueue them again (as happens with e.g. socket events
+        // which would be generated as long as there is input available on socket
+        // and this input is only removed from it when pending event handlers are
+        // executed)
+        if( wxTheApp )
+        {
+            wxTheApp->ProcessPendingEvents();
+
+            // One of the pending event handlers could have decided to exit the
+            // loop so check for the flag before trying to dispatch more events
+            // (which could block indefinitely if no more are coming).
+            if( m_shouldExit )
+                return false;
+        }
+
+        return Dispatch();
+    }
+
+
+    int DoRun()
+    {
+        // we must ensure that OnExit() is called even if an exception is thrown
+        // from inside ProcessEvents() but we must call it from Exit() in normal
+        // situations because it is supposed to be called synchronously,
+        // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
+        // something similar here)
+    #if wxUSE_EXCEPTIONS
+        for( ; ; )
+        {
+            try
+            {
+    #endif // wxUSE_EXCEPTIONS
+
+                // this is the event loop itself
+                for( ; ; )
+                {
+                    // generate and process idle events for as long as we don't
+                    // have anything else to do
+                    while ( !m_shouldExit && !Pending() && ProcessIdle() )
+                        ;
+
+                    if ( m_shouldExit )
+                        break;
+
+                    // a message came or no more idle processing to do, dispatch
+                    // all the pending events and call Dispatch() to wait for the
+                    // next message
+                    if ( !ProcessEvents() )
+                    {
+                        // we got WM_QUIT
+                        break;
+                    }
+                }
+
+                // Process the remaining queued messages, both at the level of the
+                // underlying toolkit level (Pending/Dispatch()) and wx level
+                // (Has/ProcessPendingEvents()).
+                //
+                // We do run the risk of never exiting this loop if pending event
+                // handlers endlessly generate new events but they shouldn't do
+                // this in a well-behaved program and we shouldn't just discard the
+                // events we already have, they might be important.
+                for( ; ; )
+                {
+                    bool hasMoreEvents = false;
+                    if ( wxTheApp && wxTheApp->HasPendingEvents() )
+                    {
+                        wxTheApp->ProcessPendingEvents();
+                        hasMoreEvents = true;
+                    }
+
+                    if ( Pending() )
+                    {
+                        Dispatch();
+                        hasMoreEvents = true;
+                    }
+
+                    if ( !hasMoreEvents )
+                        break;
+                }
+
+    #if wxUSE_EXCEPTIONS
+                // exit the outer loop as well
+                break;
+            }
+            catch ( ... )
+            {
+                try
+                {
+                    if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
+                    {
+                        OnExit();
+                        break;
+                    }
+                    //else: continue running the event loop
+                }
+                catch ( ... )
+                {
+                    // OnException() throwed, possibly rethrowing the same
+                    // exception again: very good, but we still need OnExit() to
+                    // be called
+                    OnExit();
+                    throw;
+                }
+            }
+        }
+    #endif // wxUSE_EXCEPTIONS
+
+        return m_exitcode;
+    }
+
+protected:
+    int     m_exitcode;
+
+    /* this only works if you add
+    friend class EVENT_LOOP
+    to EventLoopBase
+    */
+    void setInsideRun( bool aValue )
+    {
+        m_isInsideRun = aValue;
+    }
+#endif
+};
+
+
+int DIALOG_SHIM::ShowQuasiModal()
+{
+    // This is an exception safe way to zero a pointer before returning.
+    // Yes, even though DismissModal() clears this first normally, this is
+    // here in case there's an exception before the dialog is dismissed.
+    struct NULLER
+    {
+        void*&  m_what;
+        NULLER( void*& aPtr ) : m_what( aPtr ) {}
+        ~NULLER() { m_what = 0; }   // indeed, set it to NULL on destruction
+    } clear_this( (void*&) m_qmodal_loop );
+
+    // release the mouse if it's currently captured as the window having it
+    // will be disabled when this dialog is shown -- but will still keep the
+    // capture making it impossible to do anything in the modal dialog itself
+    wxWindow* win = wxWindow::GetCapture();
+    if( win )
+        win->ReleaseMouse();
+
+    // Get the optimal parent
+    wxWindow* parent = GetParentForModalDialog( GetParent(), GetWindowStyle() );
+
+    // Show the optimal parent
+    DBG( if( parent ) printf( "%s: optimal parent: %s\n", __func__, typeid(*parent).name() );)
+
+    wxASSERT_MSG( !m_qmodal_parent_disabler,
+            wxT( "Caller using ShowQuasiModal() twice on same window?" ) );
+
+    // quasi-modal: disable only my "optimal" parent
+    m_qmodal_parent_disabler = new WDO_ENABLE_DISABLE( parent );
+
+    Show( true );
+
+    m_qmodal_showing = true;
+
+    EVENT_LOOP event_loop;
+
+    m_qmodal_loop = &event_loop;
+
+    event_loop.Run();
+
+    return GetReturnCode();
+}
+
+
+void DIALOG_SHIM::EndQuasiModal( int retCode )
+{
+    // Hook up validator and transfer data from controls handling so quasi-modal dialogs
+    // handle validation in the same way as other dialogs.
+    if( ( retCode == wxID_OK ) && ( !Validate() || !TransferDataFromWindow() ) )
+        return;
+
+    SetReturnCode( retCode );
+
+    if( !IsQuasiModal() )
+    {
+        wxFAIL_MSG( wxT( "either DIALOG_SHIM::EndQuasiModal called twice or ShowQuasiModal wasn't called" ) );
+        return;
+    }
+
+    m_qmodal_showing = false;
+
+    if( m_qmodal_loop )
+    {
+        if( m_qmodal_loop->IsRunning() )
+            m_qmodal_loop->Exit( 0 );
+        else
+            m_qmodal_loop->ScheduleExit( 0 );
+
+        m_qmodal_loop = NULL;
+    }
+
+    delete m_qmodal_parent_disabler;
+    m_qmodal_parent_disabler = 0;
+
+    Show( false );
+}
+
+
+void DIALOG_SHIM::OnCloseWindow( wxCloseEvent& aEvent )
+{
+    if( IsQuasiModal() )
+    {
+        EndQuasiModal( wxID_CANCEL );
+        return;
+    }
+
+    // This is mandatory to allow wxDialogBase::OnCloseWindow() to be called.
+    aEvent.Skip();
+}
+
+
+void DIALOG_SHIM::OnButton( wxCommandEvent& aEvent )
+{
+    if( IsQuasiModal() )
+    {
+        const int id = aEvent.GetId();
+
+        if( id == GetAffirmativeId() )
+        {
+            EndQuasiModal( id );
+        }
+        else if( id == wxID_APPLY )
+        {
+            // Dialogs that provide Apply buttons should make sure data is valid before
+            // allowing a transfer, as there is no other way to indicate failure
+            // (i.e. the dialog can't refuse to close as it might with OK, because it
+            // isn't closing anyway)
+            if( Validate() )
+            {
+                bool success = TransferDataFromWindow();
+                (void) success;
+            }
+        }
+        else if( id == GetEscapeId() ||
+                 (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) )
+        {
+            EndQuasiModal( wxID_CANCEL );
+        }
+        else // not a standard button
+        {
+            aEvent.Skip();
+        }
+
+        return;
+    }
+
+    // This is mandatory to allow wxDialogBase::OnButton() to be called.
+    aEvent.Skip();
+}