fpicker/source/win32/filepicker/asyncrequests.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX
  21 #define FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX
  22
  23 #include <cppuhelper/basemutex.hxx>
  24 #include <comphelper/sequenceashashmap.hxx>
  25 #include <osl/conditn.hxx>
  26 #include <osl/thread.hxx>
  27 #include <osl/time.h>
  28 #include <queue>
  29 #include <boost/shared_ptr.hpp>
  30
  31 namespace fpicker{
  32 namespace win32{
  33 namespace vista{
  34
  35 //-----------------------------------------------------------------------------
  36 /** @todo document me
  37  */
  38 class Request
  39 {
  40     //-------------------------------------------------------------------------
  41     public:
  42
  43         static const ::sal_Int32 WAIT_INFINITE = 0;
  44
  45     //-------------------------------------------------------------------------
  46     // interface
  47     //-------------------------------------------------------------------------
  48
  49     public:
  50
  51         //---------------------------------------------------------------------
  52         explicit Request()
  53             : m_aJoiner   (  )
  54             , m_nRequest  (-1)
  55             , m_lArguments(  )
  56         {
  57             m_aJoiner.reset();
  58         }
  59
  60         //---------------------------------------------------------------------
  61         virtual ~Request() {};
  62
  63         //---------------------------------------------------------------------
  64         void setRequest(::sal_Int32 nRequest)
  65         {
  66             m_nRequest = nRequest;
  67         }
  68
  69         //---------------------------------------------------------------------
  70         ::sal_Int32 getRequest()
  71         {
  72             return m_nRequest;
  73         }
  74
  75         //---------------------------------------------------------------------
  76         void clearArguments()
  77         {
  78             m_lArguments.clear();
  79         }
  80
  81         //---------------------------------------------------------------------
  82         template< class TArgumentType >
  83         void setArgument(const OUString& sName ,
  84                          const TArgumentType&   aValue)
  85         {
  86             m_lArguments[sName] <<= aValue;
  87         }
  88
  89         //---------------------------------------------------------------------
  90         template< class TArgumentType >
  91         TArgumentType getArgumentOrDefault(const OUString& sName   ,
  92                                            const TArgumentType&   aDefault)
  93         {
  94             return m_lArguments.getUnpackedValueOrDefault(sName, aDefault);
  95         }
  96
  97         //---------------------------------------------------------------------
  98         void wait(::sal_Int32 nMilliSeconds = WAIT_INFINITE);
  99
 100         void waitProcessMessages();
 101
 102         //---------------------------------------------------------------------
 103         void notify();
 104
 105     //-------------------------------------------------------------------------
 106     // member
 107     //-------------------------------------------------------------------------
 108
 109     private:
 110
 111         ::osl::Condition m_aJoiner;
 112         ::sal_Int32 m_nRequest;
 113         ::comphelper::SequenceAsHashMap m_lArguments;
 114 };
 115
 116 typedef ::boost::shared_ptr< Request > RequestRef;
 117 typedef ::std::queue< RequestRef >  RequestQueue;
 118
 119 //-----------------------------------------------------------------------------
 120 class RequestHandler
 121 {
 122     public:
 123         virtual void before() = 0;
 124         virtual void doRequest(const RequestRef& rRequest) = 0;
 125         virtual void after() = 0;
 126 };
 127
 128 typedef ::boost::shared_ptr< RequestHandler > RequestHandlerRef;
 129
 130 //-----------------------------------------------------------------------------
 131 /** @todo document me
 132  */
 133 class AsyncRequests : private ::cppu::BaseMutex
 134                     , public  ::osl::Thread
 135 {
 136     public:
 137         static const ::sal_Int16  PROCESS_MESSAGES = 2;
 138         static const ::sal_Int16  BLOCKED       = 1;
 139         static const ::sal_Int16  NON_BLOCKED   = 0;
 140
 141         //---------------------------------------------------------------------
 142         /** creates the new asynchronous request executor.
 143          */
 144         explicit AsyncRequests(const RequestHandlerRef& rHandler);
 145
 146         void setHandler(const RequestHandlerRef& rHandler)
 147         {
 148             m_rHandler = rHandler;
 149         }
 150
 151         /// ensure the execution thread gets going.
 152         void triggerJobExecution();
 153
 154         //---------------------------------------------------------------------
 155         /** does nothing special / excepting to make sure our class wont be inline .-)
 156          */
 157         virtual ~AsyncRequests();
 158
 159         //---------------------------------------------------------------------
 160         /** @todo document me
 161          */
 162         void triggerRequestProcessMessages (const RequestRef& rRequest);
 163
 164         //---------------------------------------------------------------------
 165         /** @todo document me
 166          */
 167         void triggerRequestBlocked(const RequestRef& rRequest);
 168
 169         //---------------------------------------------------------------------
 170         /** @todo document me
 171          */
 172         void triggerRequestNonBlocked(const RequestRef& rRequest);
 173
 174         //---------------------------------------------------------------------
 175         /** @todo document me
 176          */
 177         void triggerRequestDirectly(const RequestRef& rRequest);
 178
 179         //---------------------------------------------------------------------
 180         /** @todo document me
 181          */
 182         void triggerRequestThreadAware(const RequestRef& rRequest,
 183                                              ::sal_Int16  nWait   );
 184
 185     private:
 186
 187         //---------------------------------------------------------------------
 188         /** our STA .-)
 189          *  Will run between start() & finish(). Internaly it runs a loop ...
 190          *  waiting for requests. Every request will be executed synchronously
 191          *  in blocked mode.
 192          */
 193         virtual void SAL_CALL run();
 194
 195     private:
 196
 197         ::sal_Bool m_bFinish;
 198         RequestHandlerRef m_rHandler;
 199         RequestQueue m_lRequests;
 200         osl::Condition maWait;
 201 };
 202
 203 } // namespace vista
 204 } // namespace win32
 205 } // namespace fpicker
 206
 207 #endif // FPICKER_WIN32_VISTA_ASYNCREQUESTS_HXX
 208
 209 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */