sd/source/core/annotations/Annotation.cxx

   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 #include <sal/config.h>
  21
  22 #include <Annotation.hxx>
  23 #include <drawdoc.hxx>
  24
  25 #include <com/sun/star/drawing/XDrawPage.hpp>
  26
  27 #include <comphelper/processfactory.hxx>
  28 #include <comphelper/lok.hxx>
  29
  30 #include <unotools/datetime.hxx>
  31
  32 #include <sfx2/viewsh.hxx>
  33 #include <svx/svdundo.hxx>
  34
  35 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
  36
  37 #include <notifydocumentevent.hxx>
  38
  39
  40 using namespace css;
  41
  42 namespace com::sun::star::uno { class XComponentContext; }
  43
  44 namespace sd
  45 {
  46
  47 namespace
  48 {
  49
  50 /** Undo/redo insertion or removal of an annotation to/from the document */
  51 class UndoInsertOrRemoveAnnotation : public SdrUndoAction
  52 {
  53 public:
  54     UndoInsertOrRemoveAnnotation(rtl::Reference<sdr::annotation::Annotation>& xAnnotation, bool bInsert);
  55
  56     virtual void Undo() override;
  57     virtual void Redo() override;
  58
  59 protected:
  60     rtl::Reference<sdr::annotation::Annotation> mxAnnotation;
  61     bool mbInsert;
  62     int mnIndex = 0;
  63 };
  64
  65 }
  66
  67 /** Creates an annotation */
  68 rtl::Reference<sdr::annotation::Annotation> createAnnotation(SdPage* pPage)
  69 {
  70     return rtl::Reference<Annotation>(new Annotation(comphelper::getProcessComponentContext(), pPage));
  71 }
  72
  73 Annotation::Annotation(const uno::Reference<uno::XComponentContext>& context, SdrPage* pPage)
  74     : sdr::annotation::Annotation(context, pPage)
  75 {
  76 }
  77
  78 Annotation::~Annotation()
  79 {}
  80
  81 // com.sun.star.beans.XPropertySet:
  82 uno::Reference<beans::XPropertySetInfo> SAL_CALL Annotation::getPropertySetInfo()
  83 {
  84     return ::cppu::PropertySetMixin<office::XAnnotation>::getPropertySetInfo();
  85 }
  86
  87 void SAL_CALL Annotation::setPropertyValue(const OUString & aPropertyName, const uno::Any & aValue)
  88 {
  89     ::cppu::PropertySetMixin<office::XAnnotation>::setPropertyValue(aPropertyName, aValue);
  90 }
  91
  92 uno::Any SAL_CALL Annotation::getPropertyValue(const OUString & aPropertyName)
  93 {
  94     return ::cppu::PropertySetMixin<office::XAnnotation>::getPropertyValue(aPropertyName);
  95 }
  96
  97 void SAL_CALL Annotation::addPropertyChangeListener(const OUString & aPropertyName, const uno::Reference<beans::XPropertyChangeListener> & xListener)
  98 {
  99     ::cppu::PropertySetMixin<office::XAnnotation>::addPropertyChangeListener(aPropertyName, xListener);
 100 }
 101
 102 void SAL_CALL Annotation::removePropertyChangeListener(const OUString & aPropertyName, const uno::Reference<beans::XPropertyChangeListener> & xListener)
 103 {
 104     ::cppu::PropertySetMixin<office::XAnnotation>::removePropertyChangeListener(aPropertyName, xListener);
 105 }
 106
 107 void SAL_CALL Annotation::addVetoableChangeListener(const OUString & aPropertyName, const uno::Reference<beans::XVetoableChangeListener> & xListener)
 108 {
 109     ::cppu::PropertySetMixin<office::XAnnotation>::addVetoableChangeListener(aPropertyName, xListener);
 110 }
 111
 112 void SAL_CALL Annotation::removeVetoableChangeListener(const OUString & aPropertyName, const uno::Reference<beans::XVetoableChangeListener> & xListener)
 113 {
 114     ::cppu::PropertySetMixin<office::XAnnotation>::removeVetoableChangeListener(aPropertyName, xListener);
 115 }
 116
 117 uno::Any SAL_CALL Annotation::getAnchor()
 118 {
 119     std::unique_lock g(m_aMutex);
 120     uno::Any aRet;
 121     if( mpPage )
 122     {
 123         uno::Reference<drawing::XDrawPage> xPage( mpPage->getUnoPage(), uno::UNO_QUERY );
 124         aRet <<= xPage;
 125     }
 126     return aRet;
 127 }
 128
 129 // css::office::XAnnotation:
 130 geometry::RealPoint2D SAL_CALL Annotation::getPosition()
 131 {
 132     std::unique_lock g(m_aMutex);
 133     return m_Position;
 134 }
 135
 136 void SAL_CALL Annotation::setPosition(const geometry::RealPoint2D & the_value)
 137 {
 138     prepareSet(u"Position"_ustr, uno::Any(), uno::Any(), nullptr);
 139     {
 140         std::unique_lock g(m_aMutex);
 141         createChangeUndoImpl(g);
 142         m_Position = the_value;
 143     }
 144 }
 145
 146 // css::office::XAnnotation:
 147 geometry::RealSize2D SAL_CALL Annotation::getSize()
 148 {
 149     std::unique_lock g(m_aMutex);
 150     return m_Size;
 151 }
 152
 153 void SAL_CALL Annotation::setSize(const geometry::RealSize2D & the_value)
 154 {
 155     prepareSet(u"Size"_ustr, uno::Any(), uno::Any(), nullptr);
 156     {
 157         std::unique_lock g(m_aMutex);
 158         createChangeUndoImpl(g);
 159         m_Size = the_value;
 160     }
 161 }
 162
 163 OUString SAL_CALL Annotation::getAuthor()
 164 {
 165     std::unique_lock g(m_aMutex);
 166     return m_Author;
 167 }
 168
 169 void SAL_CALL Annotation::setAuthor(const OUString & the_value)
 170 {
 171     prepareSet(u"Author"_ustr, uno::Any(), uno::Any(), nullptr);
 172     {
 173         std::unique_lock g(m_aMutex);
 174         createChangeUndoImpl(g);
 175         m_Author = the_value;
 176     }
 177 }
 178
 179 OUString SAL_CALL Annotation::getInitials()
 180 {
 181     std::unique_lock g(m_aMutex);
 182     return m_Initials;
 183 }
 184
 185 void SAL_CALL Annotation::setInitials(const OUString & the_value)
 186 {
 187     prepareSet(u"Initials"_ustr, uno::Any(), uno::Any(), nullptr);
 188     {
 189         std::unique_lock g(m_aMutex);
 190         createChangeUndoImpl(g);
 191         m_Initials = the_value;
 192     }
 193 }
 194
 195 util::DateTime SAL_CALL Annotation::getDateTime()
 196 {
 197     std::unique_lock g(m_aMutex);
 198     return m_DateTime;
 199 }
 200
 201 void SAL_CALL Annotation::setDateTime(const util::DateTime & the_value)
 202 {
 203     prepareSet(u"DateTime"_ustr, uno::Any(), uno::Any(), nullptr);
 204     {
 205         std::unique_lock g(m_aMutex);
 206         createChangeUndoImpl(g);
 207         m_DateTime = the_value;
 208     }
 209 }
 210
 211 void Annotation::createChangeUndo()
 212 {
 213     std::unique_lock g(m_aMutex);
 214     createChangeUndoImpl(g);
 215 }
 216
 217 void Annotation::createChangeUndoImpl(std::unique_lock<std::mutex>& g)
 218 {
 219     SdrModel* pModel = GetModel(); // TTTT should use reference
 220     if( pModel && pModel->IsUndoEnabled() )
 221     {
 222         g.unlock(); // AddUndo calls back into Annotation
 223         pModel->AddUndo(createUndoAnnotation());
 224         g.lock();
 225     }
 226
 227     if( pModel )
 228     {
 229         pModel->SetChanged();
 230         uno::Reference< XInterface > xSource( static_cast<uno::XWeak*>( this ) );
 231         NotifyDocumentEvent(
 232             static_cast< SdDrawDocument& >( *pModel ),
 233             u"OnAnnotationChanged"_ustr ,
 234             xSource );
 235     }
 236 }
 237
 238 rtl::Reference<sdr::annotation::Annotation> Annotation::clone(SdrPage* pTargetPage)
 239 {
 240     rtl::Reference<sdr::annotation::Annotation> aNewAnnotation;
 241     aNewAnnotation = new sd::Annotation(comphelper::getProcessComponentContext(), pTargetPage);
 242     aNewAnnotation->setPosition(getPosition());
 243     aNewAnnotation->setSize(getSize());
 244     aNewAnnotation->setAuthor(getAuthor());
 245     aNewAnnotation->setInitials(getInitials());
 246     aNewAnnotation->setDateTime(getDateTime());
 247     aNewAnnotation->setCreationInfo(getCreationInfo());
 248
 249     uno::Reference<css::text::XTextCopy> xSourceRange (getTextRange(), uno::UNO_QUERY);
 250     uno::Reference<css::text::XTextCopy> xRange (aNewAnnotation->getTextRange(), uno::UNO_QUERY);
 251     if (xSourceRange.is() && xRange.is())
 252         xRange->copyText(xSourceRange);
 253
 254     return aNewAnnotation;
 255 }
 256
 257 std::unique_ptr<SdrUndoAction> CreateUndoInsertOrRemoveAnnotation(rtl::Reference<sdr::annotation::Annotation>& xAnnotation, bool bInsert)
 258 {
 259     if (xAnnotation)
 260     {
 261         return std::make_unique<UndoInsertOrRemoveAnnotation>(xAnnotation, bInsert);
 262     }
 263     else
 264     {
 265         return nullptr;
 266     }
 267 }
 268
 269 UndoInsertOrRemoveAnnotation::UndoInsertOrRemoveAnnotation(rtl::Reference<sdr::annotation::Annotation>& xAnnotation, bool bInsert)
 270     : SdrUndoAction(*xAnnotation->GetModel())
 271     , mxAnnotation(xAnnotation)
 272     , mbInsert(bInsert)
 273 {
 274     SdrPage const* pPage = mxAnnotation->getPage();
 275     if (pPage)
 276     {
 277         sdr::annotation::AnnotationVector const& rVector = pPage->getAnnotations();
 278         auto iterator = std::find(rVector.begin(), rVector.end(), mxAnnotation);
 279         mnIndex += std::distance(rVector.begin(), iterator);
 280     }
 281 }
 282
 283 void UndoInsertOrRemoveAnnotation::Undo()
 284 {
 285     SdrPage* pPage = mxAnnotation->getPage();
 286     SdrModel* pModel = mxAnnotation->GetModel();
 287     if (!pPage || !pModel)
 288         return;
 289
 290     if (mbInsert)
 291     {
 292         pPage->removeAnnotationNoNotify(mxAnnotation);
 293     }
 294     else
 295     {
 296         pPage->addAnnotation(mxAnnotation, mnIndex);
 297         LOKCommentNotifyAll(sdr::annotation::CommentNotificationType::Add, *mxAnnotation);
 298     }
 299 }
 300
 301 void UndoInsertOrRemoveAnnotation::Redo()
 302 {
 303     SdrPage* pPage = mxAnnotation->getPage();
 304     SdrModel* pModel = mxAnnotation->GetModel();
 305     if (!pPage || !pModel)
 306         return;
 307
 308     if (mbInsert)
 309     {
 310         pPage->addAnnotationNoNotify(mxAnnotation, mnIndex);
 311         LOKCommentNotifyAll(sdr::annotation::CommentNotificationType::Add, *mxAnnotation);
 312     }
 313     else
 314     {
 315         pPage->removeAnnotationNoNotify(mxAnnotation);
 316     }
 317 }
 318
 319 } // namespace sd
 320
 321 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */