desktop/inc/lib/init.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
  10 #pragma once
  11
  12 #include <map>
  13 #include <unordered_map>
  14 #include <memory>
  15 #include <mutex>
  16 #include <string_view>
  17
  18 #include <boost/property_tree/ptree.hpp>
  19 #include <boost/variant.hpp>
  20
  21 #include <osl/thread.h>
  22 #include <rtl/ref.hxx>
  23 #include <vcl/idle.hxx>
  24 #include <LibreOfficeKit/LibreOfficeKit.h>
  25 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  26 #include <com/sun/star/beans/PropertyValue.hpp>
  27 #include <com/sun/star/lang/XComponent.hpp>
  28 #include <tools/gen.hxx>
  29 #include <sfx2/lokcallback.hxx>
  30 #include <sfx2/lokhelper.hxx>
  31
  32 #include <desktop/dllapi.h>
  33
  34 class LOKInteractionHandler;
  35
  36 namespace desktop {
  37
  38     /// Represents an invalidated rectangle inside a given document part.
  39     struct RectangleAndPart
  40     {
  41         tools::Rectangle m_aRectangle;
  42         int m_nPart;
  43
  44         RectangleAndPart()
  45             : m_nPart(INT_MIN)  // -1 is reserved to mean "all parts".
  46         {
  47         }
  48
  49         RectangleAndPart(const tools::Rectangle* pRect, int nPart)
  50             : m_aRectangle( pRect ? *pRect : tools::Rectangle(0, 0, SfxLokHelper::MaxTwips, SfxLokHelper::MaxTwips))
  51             , m_nPart(nPart)
  52         {
  53         }
  54
  55         OString toString() const
  56         {
  57             if (m_nPart >= -1)
  58                 return m_aRectangle.toString() + ", " + OString::number(m_nPart);
  59             else
  60                 return m_aRectangle.toString();
  61         }
  62
  63         /// Infinite Rectangle is both sides are
  64         /// equal or longer than SfxLokHelper::MaxTwips.
  65         bool isInfinite() const
  66         {
  67             return m_aRectangle.GetWidth() >= SfxLokHelper::MaxTwips &&
  68                    m_aRectangle.GetHeight() >= SfxLokHelper::MaxTwips;
  69         }
  70
  71         /// Empty Rectangle is when it has zero dimensions.
  72         bool isEmpty() const
  73         {
  74             return m_aRectangle.IsEmpty();
  75         }
  76
  77         static RectangleAndPart Create(const std::string& rPayload);
  78     };
  79
  80     class DESKTOP_DLLPUBLIC CallbackFlushHandler final : public Idle, public SfxLokCallbackInterface
  81     {
  82     public:
  83         explicit CallbackFlushHandler(LibreOfficeKitDocument* pDocument, LibreOfficeKitCallback pCallback, void* pData);
  84         virtual ~CallbackFlushHandler() override;
  85         virtual void Invoke() override;
  86         // TODO This should be dropped and the binary libreOfficeKitViewCallback() variants should be called?
  87         void queue(const int type, const char* data);
  88
  89         /// Disables callbacks on this handler. Must match with identical count
  90         /// of enableCallbacks. Used during painting and changing views.
  91         void disableCallbacks() { ++m_nDisableCallbacks; }
  92         /// Enables callbacks on this handler. Must match with identical count
  93         /// of disableCallbacks. Used during painting and changing views.
  94         void enableCallbacks() { --m_nDisableCallbacks; }
  95         /// Returns true iff callbacks are disabled.
  96         bool callbacksDisabled() const { return m_nDisableCallbacks != 0; }
  97
  98         void addViewStates(int viewId);
  99         void removeViewStates(int viewId);
 100
 101         void setViewId( int viewId ) { m_viewId = viewId; }
 102
 103         // SfxLockCallbackInterface
 104         virtual void libreOfficeKitViewCallback(int nType, const char* pPayload) override;
 105         virtual void libreOfficeKitViewCallback(int nType, const char* pPayload, int nViewId) override;
 106         virtual void libreOfficeKitViewInvalidateTilesCallback(const tools::Rectangle* pRect, int nPart) override;
 107
 108     private:
 109         struct CallbackData
 110         {
 111             CallbackData(const char* payload)
 112                 : PayloadString(payload ? payload : "(nil)")
 113             {
 114             }
 115
 116             CallbackData(const char* payload, int viewId)
 117                 : PayloadString(payload ? payload : "(nil)")
 118                 , PayloadObject(viewId)
 119             {
 120             }
 121
 122             CallbackData(const tools::Rectangle* pRect, int viewId)
 123                 : PayloadObject(RectangleAndPart(pRect, viewId))
 124             { // PayloadString will be done on demand
 125             }
 126
 127             const std::string& getPayload() const;
 128             /// Update a RectangleAndPart object and update PayloadString if necessary.
 129             void updateRectangleAndPart(const RectangleAndPart& rRectAndPart);
 130             /// Return the parsed RectangleAndPart instance.
 131             const RectangleAndPart& getRectangleAndPart() const;
 132             /// Parse and set the JSON object and return it. Clobbers PayloadString.
 133             boost::property_tree::ptree& setJson(const std::string& payload);
 134             /// Set a Json object and update PayloadString.
 135             void setJson(const boost::property_tree::ptree& rTree);
 136             /// Return the parsed JSON instance.
 137             const boost::property_tree::ptree& getJson() const;
 138
 139             int getViewId() const;
 140
 141             bool isEmpty() const
 142             {
 143                 return PayloadString.empty() && PayloadObject.which() == 0;
 144             }
 145             void clear()
 146             {
 147                 PayloadString.clear();
 148                 PayloadObject = boost::blank();
 149             }
 150
 151             /// Validate that the payload and parsed object match.
 152             bool validate() const;
 153
 154             /// Returns true iff there is cached data.
 155             bool isCached() const { return PayloadObject.which() != 0; }
 156
 157         private:
 158             mutable std::string PayloadString;
 159
 160             /// The parsed payload cache. Update validate() when changing this.
 161             mutable boost::variant<boost::blank, RectangleAndPart, boost::property_tree::ptree, int> PayloadObject;
 162         };
 163
 164         typedef std::vector<int> queue_type1;
 165         typedef std::vector<CallbackData> queue_type2;
 166
 167         bool removeAll(int type);
 168         bool removeAll(int type, const std::function<bool (const CallbackData&)>& rTestFunc);
 169         bool processInvalidateTilesEvent(int type, CallbackData& aCallbackData);
 170         bool processWindowEvent(int type, CallbackData& aCallbackData);
 171         queue_type2::iterator toQueue2(queue_type1::iterator);
 172         queue_type2::reverse_iterator toQueue2(queue_type1::reverse_iterator);
 173         void queue(const int type, CallbackData& data);
 174
 175         /** we frequently want to scan the queue, and mostly when we do so, we only care about the element type
 176             so we split the queue in 2 to make the scanning cache friendly. */
 177         queue_type1 m_queue1;
 178         queue_type2 m_queue2;
 179         std::map<int, std::string> m_states;
 180         std::unordered_map<int, std::unordered_map<int, std::string>> m_viewStates;
 181         LibreOfficeKitDocument* m_pDocument;
 182         int m_viewId = -1; // view id of the associated SfxViewShell
 183         LibreOfficeKitCallback m_pCallback;
 184         void *m_pData;
 185         int m_nDisableCallbacks;
 186         std::mutex m_mutex;
 187         class TimeoutIdle : public Timer
 188         {
 189         public:
 190             TimeoutIdle( CallbackFlushHandler* handler );
 191             virtual void Invoke() override;
 192         private:
 193             CallbackFlushHandler* mHandler;
 194         };
 195         TimeoutIdle m_TimeoutIdle;
 196     };
 197
 198     struct DESKTOP_DLLPUBLIC LibLODocument_Impl : public _LibreOfficeKitDocument
 199     {
 200         css::uno::Reference<css::lang::XComponent> mxComponent;
 201         std::shared_ptr< LibreOfficeKitDocumentClass > m_pDocumentClass;
 202         std::map<size_t, std::shared_ptr<CallbackFlushHandler>> mpCallbackFlushHandlers;
 203         const int mnDocumentId;
 204
 205         explicit LibLODocument_Impl(const css::uno::Reference<css::lang::XComponent>& xComponent,
 206                                     int nDocumentId);
 207         ~LibLODocument_Impl();
 208     };
 209
 210     struct DESKTOP_DLLPUBLIC LibLibreOffice_Impl : public _LibreOfficeKit
 211     {
 212         OUString maLastExceptionMsg;
 213         std::shared_ptr< LibreOfficeKitClass > m_pOfficeClass;
 214         oslThread maThread;
 215         LibreOfficeKitCallback mpCallback;
 216         void *mpCallbackData;
 217         int64_t mOptionalFeatures;
 218         std::map<OString, rtl::Reference<LOKInteractionHandler>> mInteractionMap;
 219
 220         LibLibreOffice_Impl();
 221         ~LibLibreOffice_Impl();
 222
 223         bool hasOptionalFeature(LibreOfficeKitOptionalFeatures const feature)
 224         {
 225             return (mOptionalFeatures & feature) != 0;
 226         }
 227     };
 228
 229     /// Helper function to extract the value from parameters delimited by
 230     /// comma, like: Name1=Value1,Name2=Value2,Name3=Value3.
 231     /// @param rOptions When extracted, the Param=Value is removed from it.
 232     DESKTOP_DLLPUBLIC OUString extractParameter(OUString& aOptions, std::u16string_view rName);
 233
 234     /// Helper function to convert JSON to a vector of PropertyValues.
 235     /// Public to be unit-test-able.
 236     DESKTOP_DLLPUBLIC std::vector<com::sun::star::beans::PropertyValue> jsonToPropertyValuesVector(const char* pJSON);
 237 }
 238
 239 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */