fpicker/source/win32/filepicker/asyncrequests.hxx

   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: asyncrequests.hxx,v $
  10  * $Revision: 1.3 $
  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 #ifndef FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX
  32 #define FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX
  33
  34 //-----------------------------------------------------------------------------
  35 // includes
  36 //-----------------------------------------------------------------------------
  37
  38 #include <cppuhelper/basemutex.hxx>
  39 #include <comphelper/sequenceashashmap.hxx>
  40 #include <osl/conditn.hxx>
  41 #include <osl/thread.hxx>
  42 #include <osl/time.h>
  43 #include <queue>
  44 #include <boost/shared_ptr.hpp>
  45
  46 //-----------------------------------------------------------------------------
  47 // namespace
  48 //-----------------------------------------------------------------------------
  49
  50 #ifdef css
  51     #error "Clash on using CSS as namespace define."
  52 #else
  53     #define css ::com::sun::star
  54 #endif
  55
  56 namespace fpicker{
  57 namespace win32{
  58 namespace vista{
  59
  60 //-----------------------------------------------------------------------------
  61 /** @todo document me
  62  */
  63 class Request
  64 {
  65     //-------------------------------------------------------------------------
  66     public:
  67
  68         static const ::sal_Int32 WAIT_INFINITE = 0;
  69
  70     //-------------------------------------------------------------------------
  71     // interface
  72     //-------------------------------------------------------------------------
  73
  74     public:
  75
  76         //---------------------------------------------------------------------
  77         explicit Request()
  78             : m_aJoiner   (  )
  79             , m_nRequest  (-1)
  80             , m_lArguments(  )
  81         {
  82             m_aJoiner.reset();
  83         }
  84
  85         //---------------------------------------------------------------------
  86         virtual ~Request() {};
  87
  88         //---------------------------------------------------------------------
  89         void setRequest(::sal_Int32 nRequest)
  90         {
  91             m_nRequest = nRequest;
  92         }
  93
  94         //---------------------------------------------------------------------
  95         ::sal_Int32 getRequest()
  96         {
  97             return m_nRequest;
  98         }
  99
 100         //---------------------------------------------------------------------
 101         void clearArguments()
 102         {
 103             m_lArguments.clear();
 104         }
 105
 106         //---------------------------------------------------------------------
 107         template< class TArgumentType >
 108         void setArgument(const ::rtl::OUString& sName ,
 109                          const TArgumentType&   aValue)
 110         {
 111             m_lArguments[sName] <<= aValue;
 112         }
 113
 114         //---------------------------------------------------------------------
 115         template< class TArgumentType >
 116         TArgumentType getArgumentOrDefault(const ::rtl::OUString& sName   ,
 117                                            const TArgumentType&   aDefault)
 118         {
 119             return m_lArguments.getUnpackedValueOrDefault(sName, aDefault);
 120         }
 121
 122         //---------------------------------------------------------------------
 123         void wait(::sal_Int32 nMilliSeconds = WAIT_INFINITE);
 124
 125         void waitProcessMessages();
 126
 127         //---------------------------------------------------------------------
 128         void notify();
 129
 130     //-------------------------------------------------------------------------
 131     // member
 132     //-------------------------------------------------------------------------
 133
 134     private:
 135
 136         ::osl::Condition m_aJoiner;
 137         ::sal_Int32 m_nRequest;
 138         ::comphelper::SequenceAsHashMap m_lArguments;
 139 };
 140
 141 typedef ::boost::shared_ptr< Request > RequestRef;
 142 typedef ::std::queue< RequestRef >  RequestQueue;
 143
 144 //-----------------------------------------------------------------------------
 145 class RequestHandler
 146 {
 147     public:
 148         virtual void before() = 0;
 149         virtual void doRequest(const RequestRef& rRequest) = 0;
 150         virtual void after() = 0;
 151 };
 152
 153 typedef ::boost::shared_ptr< RequestHandler > RequestHandlerRef;
 154
 155 //-----------------------------------------------------------------------------
 156 /** @todo docuemnt me
 157  */
 158 class AsyncRequests : private ::cppu::BaseMutex
 159                     , public  ::osl::Thread
 160 {
 161     public:
 162         static const ::sal_Int16  PROCESS_MESSAGES = 2;
 163         static const ::sal_Int16  BLOCKED       = 1;
 164         static const ::sal_Int16  NON_BLOCKED   = 0;
 165
 166         //---------------------------------------------------------------------
 167         /** creates the new asynchronous request executor.
 168          */
 169         explicit AsyncRequests(const RequestHandlerRef& rHandler);
 170
 171         void setHandler(const RequestHandlerRef& rHandler)
 172         {
 173             m_rHandler = rHandler;
 174         }
 175
 176         //---------------------------------------------------------------------
 177         /** does nothing special / excepting to make sure our class wont be inline .-)
 178          */
 179         virtual ~AsyncRequests();
 180
 181         //---------------------------------------------------------------------
 182         /** @todo document me
 183          */
 184         void triggerRequestProcessMessages (const RequestRef& rRequest);
 185
 186         //---------------------------------------------------------------------
 187         /** @todo document me
 188          */
 189         void triggerRequestBlocked(const RequestRef& rRequest);
 190
 191         //---------------------------------------------------------------------
 192         /** @todo document me
 193          */
 194         void triggerRequestNonBlocked(const RequestRef& rRequest);
 195
 196         //---------------------------------------------------------------------
 197         /** @todo document me
 198          */
 199         void triggerRequestDirectly(const RequestRef& rRequest);
 200
 201         //---------------------------------------------------------------------
 202         /** @todo document me
 203          */
 204         void triggerRequestThreadAware(const RequestRef& rRequest,
 205                                              ::sal_Int16  nWait   );
 206
 207     private:
 208
 209         //---------------------------------------------------------------------
 210         /** our STA .-)
 211          *  Will run between start() & finish(). Internaly it runs a loop ...
 212          *  waiting for requests. Every request will be executed synchronously
 213          *  in blocked mode.
 214          */
 215         virtual void SAL_CALL run();
 216
 217     private:
 218
 219         ::sal_Bool m_bFinish;
 220         RequestHandlerRef m_rHandler;
 221         RequestQueue m_lRequests;
 222 };
 223
 224 } // namespace vista
 225 } // namespace win32
 226 } // namespace fpicker
 227
 228 #undef css
 229
 230 #endif // FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX