From 8a2f7704cd0e43304e54bf2281232335cc0979a3 Mon Sep 17 00:00:00 2001 From: Caolán McNamara Date: Fri, 12 Oct 2018 15:42:59 +0100 Subject: drop LazyDeletor MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I7d2e00466f321994a46b0529d645e342f229c929 Reviewed-on: https://gerrit.libreoffice.org/61718 Tested-by: Jenkins Reviewed-by: Caolán McNamara Tested-by: Caolán McNamara --- include/vcl/lazydelete.hxx | 152 +-------------------------------------------- include/vcl/window.hxx | 8 ++- 2 files changed, 6 insertions(+), 154 deletions(-) (limited to 'include') diff --git a/include/vcl/lazydelete.hxx b/include/vcl/lazydelete.hxx index 89c88cbf4cc2..f7d74573de66 100644 --- a/include/vcl/lazydelete.hxx +++ b/include/vcl/lazydelete.hxx @@ -35,158 +35,8 @@ namespace vcl { - /* Helpers for lazy object deletion - - With vcl it is often necessary to delete objects (especially Windows) - in the right order as well as in a way ensuring that the deleted objects - are not still on the stack (e.g. deleting a Window in its key handler). To - make this easier a helper class is given here which takes care of both - sorting as well as lazy deletion. - - The grisly details: - LazyDelete is a class that LazyDeletor register to. When vcl's event - loop (that is Application::Yield or Application::Reschedule) comes out - of the last level, the LazyDelete::flush is called. This will cause - LazyDelete to delete all registered LazyDeletor objects. - - LazyDeletor is a one instance object that contains a list of - objects to be deleted in sorted order. It is derived from - LazyDeletorBase as to be able to register itself in LazyDelete. - - The user calls the static method LazyDeletor::Delete( T* ) with the - object to be destroyed lazy. The static method creates the LazyDeletor - (which in turn registers itself in LazyDelete) if this is the first time - a T* is to be destroyed lazy. It then inserts the object. When the LazyDeletor - gets delete it will delete the stored objects in a fashion - that will ensure the correct order of deletion via the specialized is_less method - (e.g. if a Window is a child of another Window and therefore should be destroyed - first it is "less" in this sense) - - LazyDelete::flush will be called when the top of the nested event loop is - reached again and will then destroy each registered LazyDeletor which - in turn destroys the objects needed to be destroyed lazily. After this - the state is as before entering the event loop. - - Preconditions: - - The class of which objects are to be destroyed needs a virtual - destructor or must be final, else the wrong type will be destroyed. - - The destructor of should call LazyDeletor::Undelete( this ). This - prevents duplicate deletion in case someone destroys the object prematurely. - */ - - class LazyDeletorBase; - class VCL_DLLPUBLIC LazyDelete - { - public: - /** flush all registered object lists - */ - static void flush(); - /** register an object list to be destroyed - */ - static void addDeletor( LazyDeletorBase* pDeletor ); - }; - - class VCL_DLLPUBLIC LazyDeletorBase - { - friend void LazyDelete::flush(); - protected: - LazyDeletorBase(); - virtual ~LazyDeletorBase(); - }; - - class VCL_DLLPUBLIC LazyDeletor : public LazyDeletorBase - { - static LazyDeletor* s_pOneInstance; - - struct DeleteObjectEntry - { - VclPtr m_pObject; - bool m_bDeleted; - - DeleteObjectEntry( vcl::Window* i_pObject ) : - m_pObject( i_pObject ), - m_bDeleted( false ) - {} - }; - - std::vector< DeleteObjectEntry > m_aObjects; - typedef std::unordered_map< sal_IntPtr, unsigned int > PtrToIndexMap; - PtrToIndexMap m_aPtrToIndex; - - /** strict weak ordering function to bring objects to be destroyed lazily - in correct order, e.g. for Window objects children before parents - */ - static bool is_less( vcl::Window const * left, vcl::Window const * right ); - - LazyDeletor() { LazyDelete::addDeletor( this ); } - virtual ~LazyDeletor() override - { - SAL_INFO("vcl.lazydelete", typeid(*this).name() << std::hex << this << " deleted"); - if( s_pOneInstance == this ) // sanity check - s_pOneInstance = nullptr; - - // do the actual work - unsigned int nCount = m_aObjects.size(); - std::vector< VclPtr < vcl::Window > > aRealDelete; - aRealDelete.reserve( nCount ); - for( unsigned int i = 0; i < nCount; i++ ) - { - if( ! m_aObjects[i].m_bDeleted ) - { - aRealDelete.push_back( m_aObjects[i].m_pObject ); - } - } - // sort the vector of objects to be destroyed - std::sort( aRealDelete.begin(), aRealDelete.end(), is_less ); - nCount = aRealDelete.size(); - for( unsigned int n = 0; n < nCount; n++ ) - { - SAL_INFO("vcl.lazydelete", typeid(*this).name() << " deletes object " << aRealDelete[n] << " of type " - << typeid(*aRealDelete[n]).name()); - // check if the object to be deleted is not already destroyed - // as a side effect of a previous lazily destroyed object - if( ! m_aObjects[ m_aPtrToIndex[ reinterpret_cast(aRealDelete[n].get()) ] ].m_bDeleted ) - aRealDelete[n].disposeAndClear(); - } - } - - public: - /** mark an object for lazy deletion - */ - static void Delete( vcl::Window* i_pObject ) - { - if( s_pOneInstance == nullptr ) - s_pOneInstance = new LazyDeletor(); - - // is this object already in the list ? - // if so mark it as not to be deleted; else insert it - PtrToIndexMap::const_iterator dup = s_pOneInstance->m_aPtrToIndex.find( reinterpret_cast(i_pObject) ); - if( dup != s_pOneInstance->m_aPtrToIndex.end() ) - { - s_pOneInstance->m_aObjects[ dup->second ].m_bDeleted = false; - } - else - { - s_pOneInstance->m_aPtrToIndex[ reinterpret_cast(i_pObject) ] = s_pOneInstance->m_aObjects.size(); - s_pOneInstance->m_aObjects.push_back( DeleteObjectEntry( i_pObject ) ); - } - } - /** unmark an object already marked for lazy deletion - */ - static void Undelete( vcl::Window* i_pObject ) - { - if( s_pOneInstance ) - { - PtrToIndexMap::const_iterator it = s_pOneInstance->m_aPtrToIndex.find( reinterpret_cast(i_pObject) ); - if( it != s_pOneInstance->m_aPtrToIndex.end() ) - s_pOneInstance->m_aObjects[ it->second ].m_bDeleted = true; - } - } - }; - /* - class DeleteOnDeinit matches a similar need as LazyDelete for static objects: - you may not access vcl objects after DeInitVCL has been called this includes their destruction + You may not access vcl objects after DeInitVCL has been called this includes their destruction therefore disallowing the existence of static vcl object like e.g. a static BitmapEx To work around this use DeleteOnDeinit which will allow you to have a static object container, that will have its contents destroyed on DeinitVCL. The single drawback is that you need to check on the diff --git a/include/vcl/window.hxx b/include/vcl/window.hxx index 3227d6d6c038..e1c49f44de5a 100644 --- a/include/vcl/window.hxx +++ b/include/vcl/window.hxx @@ -1571,14 +1571,16 @@ public: // a helper method for a Control's Draw method void PaintToDevice( ::OutputDevice* pDevice, const Point& rPos, const Size& rSize ); - /* mark Window for deletion in top of event queue + /* tdf#119390 set parent to default window. Typically for use in advance of destroying + * a floating windows which has the current focus so focus will revert to the main + * document window and not the first widget in the current parent of the floating + * window. */ - void doLazyDelete(); + void SetParentToDefaultWindow(); // Keyboard access functions - /** Query the states of keyboard indicators - Caps Lock, Num Lock and Scroll Lock. Use the following mask to retrieve the state of each indicator: -- cgit