fpicker/source/win32/filepicker/asynceventnotifier.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: asynceventnotifier.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_fpicker.hxx"
  33
  34 //------------------------------------------------------------------------
  35 // includes
  36 //------------------------------------------------------------------------
  37 #include <osl/diagnose.h>
  38 #include "asynceventnotifier.hxx"
  39 #include <com/sun/star/uno/RuntimeException.hpp>
  40 #include <com/sun/star/ui/dialogs/XFilePickerListener.hpp>
  41
  42 #include <process.h>
  43 #include <memory>
  44 #include "SolarMutex.hxx"
  45
  46 //------------------------------------------------
  47 //
  48 //------------------------------------------------
  49
  50 using namespace com::sun::star;
  51 using ::com::sun::star::ui::dialogs::XFilePickerListener;
  52
  53 //------------------------------------------------
  54 //
  55 //------------------------------------------------
  56
  57 CAsyncEventNotifier::CAsyncEventNotifier(cppu::OBroadcastHelper& rBroadcastHelper) :
  58     m_hThread(0),
  59     m_bRun(false),
  60     m_ThreadId(0),
  61     m_rBroadcastHelper(rBroadcastHelper),
  62     m_NotifyEvent(m_hEvents[0]),
  63     m_ResumeNotifying(m_hEvents[1])
  64 {
  65     // m_NotifyEvent
  66     m_hEvents[0] = CreateEvent(0,               /* no security */
  67                                true,    /* manual reset */
  68                                false,   /* initial state not signaled */
  69                                0);          /* automatic name */
  70
  71     // m_ResumeNotifying
  72     m_hEvents[1] = CreateEvent(0,               /* no security */
  73                                true,    /* manual reset */
  74                                false,   /* initial state not signaled */
  75                                0);          /* automatic name */
  76 }
  77
  78 //------------------------------------------------
  79 //
  80 //------------------------------------------------
  81
  82 CAsyncEventNotifier::~CAsyncEventNotifier()
  83 {
  84     OSL_ENSURE(0 == m_hThread,"Thread not stopped, destroying this instance leads to desaster");
  85
  86     CloseHandle(m_hEvents[0]);
  87     CloseHandle(m_hEvents[1]);
  88 }
  89
  90 //------------------------------------------------
  91 //
  92 //------------------------------------------------
  93
  94 void SAL_CALL CAsyncEventNotifier::addListener(const uno::Type&                         aType    ,
  95                                                const uno::Reference< uno::XInterface >& xListener)
  96 {
  97     if ( m_rBroadcastHelper.bDisposed )
  98         throw lang::DisposedException(
  99             ::rtl::OUString::createFromAscii( "FilePicker is already disposed" ),
 100             uno::Reference< uno::XInterface >() );
 101
 102     if ( m_rBroadcastHelper.bInDispose )
 103         throw lang::DisposedException(
 104             ::rtl::OUString::createFromAscii( "FilePicker will be disposed now." ),
 105             uno::Reference< uno::XInterface >() );
 106
 107     m_rBroadcastHelper.aLC.addInterface( aType, xListener );
 108 }
 109
 110 //------------------------------------------------
 111 //
 112 //------------------------------------------------
 113
 114 void SAL_CALL CAsyncEventNotifier::removeListener(const uno::Type&                         aType    ,
 115                                                   const uno::Reference< uno::XInterface >& xListener)
 116 {
 117     if ( m_rBroadcastHelper.bDisposed )
 118         throw lang::DisposedException(
 119             ::rtl::OUString::createFromAscii( "FilePicker is already disposed." ),
 120             uno::Reference< uno::XInterface >() );
 121
 122     m_rBroadcastHelper.aLC.removeInterface( aType, xListener );
 123 }
 124
 125 //------------------------------------------------
 126 //
 127 //------------------------------------------------
 128
 129 bool SAL_CALL CAsyncEventNotifier::startup(bool bCreateSuspended)
 130 {
 131     osl::MutexGuard aGuard(m_Mutex);
 132
 133     // m_bRun may already be false because of a
 134     // call to stop but the thread did not yet
 135     // terminate so m_hEventNotifierThread is
 136     // yet a valid thread handle that should
 137     // not be overwritten
 138     if (!m_bRun)
 139     {
 140         if (!bCreateSuspended)
 141             SetEvent(m_ResumeNotifying);
 142
 143         m_hThread = (HANDLE)_beginthreadex(
 144             NULL, 0, CAsyncEventNotifier::ThreadProc, this, 0, &m_ThreadId);
 145
 146         OSL_ASSERT(0 != m_hThread);
 147
 148         if (m_hThread)
 149             m_bRun = true;
 150     }
 151
 152     OSL_POSTCOND(m_bRun,"Could not start event notifier!");
 153
 154     return m_bRun;
 155 }
 156
 157 //------------------------------------------------
 158 //
 159 //------------------------------------------------
 160
 161 void SAL_CALL CAsyncEventNotifier::shutdown()
 162 {
 163     unsigned nThreadId = GetCurrentThreadId();
 164
 165     OSL_PRECOND(nThreadId != m_ThreadId, "Method called in wrong thread context!");
 166
 167     osl::ResettableMutexGuard aGuard(m_Mutex);
 168
 169     OSL_PRECOND(m_bRun,"Event notifier does not run!");
 170
 171     m_bRun = false;
 172     m_EventList.clear();
 173
 174     // awake the the notifier thread
 175     SetEvent(m_ResumeNotifying);
 176     SetEvent(m_NotifyEvent);
 177
 178     // releas the mutex here because the event
 179     // notifier thread may need it to finish
 180     aGuard.clear();
 181
 182     // we are waiting infinite, so error will
 183     // be better detected in form of deadlocks
 184     if (WaitForSingleObject(m_hThread, INFINITE) == WAIT_FAILED) {
 185         OSL_ENSURE(false, "Waiting for thread termination failed!");
 186     }
 187
 188     // lock mutex again to reset m_hThread
 189     // and prevent a race with start()
 190     aGuard.reset();
 191
 192     CloseHandle(m_hThread);
 193     m_hThread = 0;
 194 }
 195
 196 //------------------------------------------------
 197 //
 198 //------------------------------------------------
 199
 200 void CAsyncEventNotifier::suspend()
 201 {
 202     ResetEvent(m_ResumeNotifying);
 203 }
 204
 205 //------------------------------------------------
 206 //
 207 //------------------------------------------------
 208
 209 void CAsyncEventNotifier::resume()
 210 {
 211     SetEvent(m_ResumeNotifying);
 212 }
 213
 214 //------------------------------------------------
 215 //
 216 //------------------------------------------------
 217
 218 void SAL_CALL CAsyncEventNotifier::notifyEvent(CEventNotification* EventNotification)
 219 {
 220     osl::MutexGuard aGuard(m_Mutex);
 221
 222     OSL_ENSURE(m_bRun,"Event notifier is not running!");
 223
 224     if (m_bRun)
 225     {
 226         m_EventList.push_back(EventNotification);
 227         SetEvent(m_NotifyEvent);
 228     }
 229 }
 230
 231 //------------------------------------------------
 232 //
 233 //------------------------------------------------
 234
 235 size_t SAL_CALL CAsyncEventNotifier::getEventListSize()
 236 {
 237     osl::MutexGuard aGuard(m_Mutex);
 238     return m_EventList.size();
 239 }
 240
 241 //------------------------------------------------
 242 //
 243 //------------------------------------------------
 244
 245 void SAL_CALL CAsyncEventNotifier::resetNotifyEvent()
 246 {
 247     osl::MutexGuard aGuard(m_Mutex);
 248     if (0 == m_EventList.size())
 249         ResetEvent(m_NotifyEvent);
 250 }
 251
 252 //------------------------------------------------
 253 //
 254 //------------------------------------------------
 255
 256 CEventNotification* SAL_CALL CAsyncEventNotifier::getNextEventRecord()
 257 {
 258     osl::MutexGuard aGuard(m_Mutex);
 259     return m_EventList.front();
 260 }
 261
 262 //------------------------------------------------
 263 //
 264 //------------------------------------------------
 265
 266 void SAL_CALL CAsyncEventNotifier::removeNextEventRecord()
 267 {
 268     osl::MutexGuard aGuard(m_Mutex);
 269     m_EventList.pop_front();
 270 }
 271
 272 //------------------------------------------------
 273 //
 274 //------------------------------------------------
 275
 276 void SAL_CALL CAsyncEventNotifier::run()
 277 {
 278     while (m_bRun)
 279     {
 280         WaitForMultipleObjects(2, m_hEvents, true, INFINITE);
 281
 282         if (m_bRun)
 283         {
 284             while (getEventListSize() > 0)
 285             {
 286                 std::auto_ptr<CEventNotification> EventNotification(getNextEventRecord());
 287                 removeNextEventRecord();
 288
 289                 ::cppu::OInterfaceContainerHelper* pICHelper =
 290                     m_rBroadcastHelper.getContainer(getCppuType((uno::Reference<XFilePickerListener>*)0));
 291
 292                 if (pICHelper)
 293                 {
 294                     ::cppu::OInterfaceIteratorHelper iter(*pICHelper);
 295
 296                     while(iter.hasMoreElements())
 297                     {
 298                         try
 299                         {
 300                             EventNotification->notifyEventListener(iter.next());
 301                         }
 302                         catch(uno::RuntimeException&)
 303                         {
 304                             OSL_ENSURE(sal_False,"RuntimeException during event dispatching");
 305                         }
 306                     }
 307                 }
 308
 309             } // while(getEventListSize() > 0)
 310
 311             resetNotifyEvent();
 312
 313         } // if (m_bRun)
 314
 315     } // while(m_bRun)
 316 }
 317
 318 //------------------------------------------------
 319 //
 320 //------------------------------------------------
 321
 322 unsigned int WINAPI CAsyncEventNotifier::ThreadProc(LPVOID pParam)
 323 {
 324     CAsyncEventNotifier* pInst = reinterpret_cast< CAsyncEventNotifier* >(pParam);
 325     OSL_ASSERT(pInst);
 326
 327     pInst->run();
 328
 329     return 0;
 330 }