sd/source/ui/toolpanel/controls/MasterPageObserver.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: MasterPageObserver.cxx,v $
  10  * $Revision: 1.10 $
  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_sd.hxx"
  33
  34 #include "MasterPageObserver.hxx"
  35
  36 #include <algorithm>
  37 #include "drawdoc.hxx"
  38 #include "sdpage.hxx"
  39 #include <hash_map>
  40 #include <set>
  41 #include <vector>
  42 #include <svtools/lstner.hxx>
  43 #include <osl/doublecheckedlocking.h>
  44 #include <osl/getglobalmutex.hxx>
  45
  46
  47 namespace sd {
  48
  49 class MasterPageObserver::Implementation
  50     : public SfxListener
  51 {
  52 public:
  53     /** The single instance of this class.  It is created on demand when
  54         Instance() is called for the first time.
  55     */
  56     static MasterPageObserver* mpInstance;
  57
  58     /** The master page observer will listen to events of this document and
  59         detect changes of the use of master pages.
  60     */
  61     void RegisterDocument (SdDrawDocument& rDocument);
  62
  63     /** The master page observer will stop to listen to events of this
  64         document.
  65     */
  66     void UnregisterDocument (SdDrawDocument& rDocument);
  67
  68     /** Add a listener that is informed of master pages that are newly
  69         assigned to slides or become unassigned.
  70         @param rEventListener
  71             The event listener to call for future events.  Call
  72             RemoveEventListener() before the listener is destroyed.
  73     */
  74     void AddEventListener (const Link& rEventListener);
  75
  76     /** Remove the given listener from the list of listeners.
  77         @param rEventListener
  78             After this method returns the given listener is not called back
  79             from this object.  Passing a listener that has not
  80             been registered before is safe and is silently ignored.
  81     */
  82     void RemoveEventListener (const Link& rEventListener);
  83
  84     /** Return a set of the names of master pages for the given document.
  85         This convenience method exists because this set is part of the
  86         internal data structure and thus takes no time to create.
  87     */
  88     inline MasterPageObserver::MasterPageNameSet GetMasterPageNames (
  89         SdDrawDocument& rDocument);
  90
  91 private:
  92     ::std::vector<Link> maListeners;
  93
  94     struct DrawDocHash {
  95         size_t operator()(SdDrawDocument* argument) const
  96         { return reinterpret_cast<unsigned long>(argument); }
  97     };
  98     typedef ::std::hash_map<SdDrawDocument*,
  99                             MasterPageObserver::MasterPageNameSet,
 100                             DrawDocHash>
 101         MasterPageContainer;
 102     MasterPageContainer maUsedMasterPages;
 103
 104     virtual void Notify(
 105         SfxBroadcaster& rBroadcaster,
 106         const SfxHint& rHint);
 107
 108     void AnalyzeUsedMasterPages (SdDrawDocument& rDocument);
 109
 110     void SendEvent (MasterPageObserverEvent& rEvent);
 111 };
 112
 113 MasterPageObserver* MasterPageObserver::Implementation::mpInstance = NULL;
 114
 115
 116
 117 //===== MasterPageObserver ====================================================
 118
 119 MasterPageObserver&  MasterPageObserver::Instance (void)
 120 {
 121     if (Implementation::mpInstance == NULL)
 122     {
 123         ::osl::GetGlobalMutex aMutexFunctor;
 124         ::osl::MutexGuard aGuard (aMutexFunctor());
 125         if (Implementation::mpInstance == NULL)
 126         {
 127             MasterPageObserver* pInstance = new MasterPageObserver ();
 128             SdGlobalResourceContainer::Instance().AddResource (
 129                 ::std::auto_ptr<SdGlobalResource>(pInstance));
 130             OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 131             Implementation::mpInstance = pInstance;
 132         }
 133     }
 134     else
 135     {
 136         OSL_DOUBLE_CHECKED_LOCKING_MEMORY_BARRIER();
 137     }
 138
 139     DBG_ASSERT(Implementation::mpInstance!=NULL,
 140         "MasterPageObserver::Instance(): instance is NULL");
 141     return *Implementation::mpInstance;
 142 }
 143
 144
 145
 146
 147 void MasterPageObserver::RegisterDocument (SdDrawDocument& rDocument)
 148 {
 149     mpImpl->RegisterDocument (rDocument);
 150 }
 151
 152
 153
 154
 155 void MasterPageObserver::UnregisterDocument (SdDrawDocument& rDocument)
 156 {
 157     mpImpl->UnregisterDocument (rDocument);
 158 }
 159
 160
 161
 162
 163 void MasterPageObserver::AddEventListener (const Link& rEventListener)
 164 {
 165
 166     mpImpl->AddEventListener (rEventListener);
 167 }
 168
 169
 170
 171
 172 void MasterPageObserver::RemoveEventListener (const Link& rEventListener)
 173 {
 174     mpImpl->RemoveEventListener (rEventListener);
 175 }
 176
 177
 178
 179
 180 MasterPageObserver::MasterPageObserver (void)
 181     : mpImpl (new Implementation())
 182 {}
 183
 184
 185
 186
 187 MasterPageObserver::~MasterPageObserver (void)
 188 {}
 189
 190
 191
 192
 193 MasterPageObserver::MasterPageNameSet MasterPageObserver::GetMasterPageNames (
 194     SdDrawDocument& rDocument)
 195 {
 196     return mpImpl->GetMasterPageNames (rDocument);
 197 }
 198
 199
 200
 201
 202 //===== MasterPageObserver::Implementation ====================================
 203
 204 void MasterPageObserver::Implementation::RegisterDocument (
 205     SdDrawDocument& rDocument)
 206 {
 207     // Gather the names of all the master pages in the given document.
 208     MasterPageContainer::data_type aMasterPageSet;
 209     USHORT nMasterPageCount = rDocument.GetMasterSdPageCount(PK_STANDARD);
 210     for (USHORT nIndex=0; nIndex<nMasterPageCount; nIndex++)
 211     {
 212         SdPage* pMasterPage = rDocument.GetMasterSdPage (nIndex, PK_STANDARD);
 213         if (pMasterPage != NULL)
 214             aMasterPageSet.insert (pMasterPage->GetName());
 215     }
 216
 217     maUsedMasterPages[&rDocument] = aMasterPageSet;
 218
 219     StartListening (rDocument);
 220 }
 221
 222
 223
 224
 225 void MasterPageObserver::Implementation::UnregisterDocument (
 226     SdDrawDocument& rDocument)
 227 {
 228     EndListening (rDocument);
 229
 230     MasterPageContainer::iterator aMasterPageDescriptor(maUsedMasterPages.find(&rDocument));
 231     if(aMasterPageDescriptor != maUsedMasterPages.end())
 232         maUsedMasterPages.erase(aMasterPageDescriptor);
 233 }
 234
 235
 236
 237
 238 void MasterPageObserver::Implementation::AddEventListener (
 239     const Link& rEventListener)
 240 {
 241     if (::std::find (
 242         maListeners.begin(),
 243         maListeners.end(),
 244         rEventListener) == maListeners.end())
 245     {
 246         maListeners.push_back (rEventListener);
 247
 248         // Tell the new listener about all the master pages that are
 249         // currently in use.
 250         typedef ::std::vector<String> StringList;
 251         StringList aNewMasterPages;
 252         StringList aRemovedMasterPages;
 253         MasterPageContainer::iterator aDocumentIterator;
 254         for (aDocumentIterator=maUsedMasterPages.begin();
 255              aDocumentIterator!=maUsedMasterPages.end();
 256              ++aDocumentIterator)
 257         {
 258             ::std::set<String>::reverse_iterator aNameIterator;
 259             for (aNameIterator=aDocumentIterator->second.rbegin();
 260                  aNameIterator!=aDocumentIterator->second.rend();
 261                  ++aNameIterator)
 262             {
 263               MasterPageObserverEvent aEvent (
 264                   MasterPageObserverEvent::ET_MASTER_PAGE_EXISTS,
 265                   *aDocumentIterator->first,
 266                   *aNameIterator);
 267               SendEvent (aEvent);
 268             }
 269         }
 270     }
 271 }
 272
 273
 274
 275
 276 void MasterPageObserver::Implementation::RemoveEventListener (
 277     const Link& rEventListener)
 278 {
 279     maListeners.erase (
 280         ::std::find (
 281             maListeners.begin(),
 282             maListeners.end(),
 283             rEventListener));
 284 }
 285
 286
 287
 288
 289 MasterPageObserver::MasterPageNameSet
 290     MasterPageObserver::Implementation::GetMasterPageNames (
 291         SdDrawDocument& rDocument)
 292 {
 293     MasterPageContainer::iterator aMasterPageDescriptor (
 294         maUsedMasterPages.find(&rDocument));
 295     if (aMasterPageDescriptor != maUsedMasterPages.end())
 296         return aMasterPageDescriptor->second;
 297     else
 298         // Not found so return an empty set.
 299         return MasterPageObserver::MasterPageNameSet();
 300 }
 301
 302
 303
 304
 305 void MasterPageObserver::Implementation::Notify(
 306     SfxBroadcaster& rBroadcaster,
 307     const SfxHint& rHint)
 308 {
 309     if (rHint.ISA(SdrHint))
 310     {
 311         SdrHint& rSdrHint (*PTR_CAST(SdrHint,&rHint));
 312         switch (rSdrHint.GetKind())
 313         {
 314             case HINT_PAGEORDERCHG:
 315                 // Process the modified set of pages only when the number of
 316                 // standard and notes master pages are equal.  This test
 317                 // filters out events that are sent in between the insertion
 318                 // of a new standard master page and a new notes master
 319                 // page.
 320                 if (rBroadcaster.ISA(SdDrawDocument))
 321                 {
 322                     SdDrawDocument& rDocument (
 323                         static_cast<SdDrawDocument&>(rBroadcaster));
 324                     if (rDocument.GetMasterSdPageCount(PK_STANDARD)
 325                         == rDocument.GetMasterSdPageCount(PK_NOTES))
 326                     {
 327                         AnalyzeUsedMasterPages (rDocument);
 328                     }
 329                 }
 330                 break;
 331
 332             default:
 333                 break;
 334         }
 335     }
 336 }
 337
 338
 339
 340
 341 void MasterPageObserver::Implementation::AnalyzeUsedMasterPages (
 342     SdDrawDocument& rDocument)
 343 {
 344     // Create a set of names of the master pages used by the given document.
 345     USHORT nMasterPageCount = rDocument.GetMasterSdPageCount(PK_STANDARD);
 346     ::std::set<String> aCurrentMasterPages;
 347     for (USHORT nIndex=0; nIndex<nMasterPageCount; nIndex++)
 348     {
 349         SdPage* pMasterPage = rDocument.GetMasterSdPage (nIndex, PK_STANDARD);
 350         if (pMasterPage != NULL)
 351             aCurrentMasterPages.insert (pMasterPage->GetName());
 352         OSL_TRACE("currently used master page %d is %s",
 353             nIndex,
 354             ::rtl::OUStringToOString(pMasterPage->GetName(),
 355                 RTL_TEXTENCODING_UTF8).getStr());
 356     }
 357
 358     typedef ::std::vector<String> StringList;
 359     StringList aNewMasterPages;
 360     StringList aRemovedMasterPages;
 361     MasterPageContainer::iterator aOldMasterPagesDescriptor (
 362         maUsedMasterPages.find(&rDocument));
 363     if (aOldMasterPagesDescriptor != maUsedMasterPages.end())
 364     {
 365         StringList::iterator I;
 366
 367         ::std::set<String>::iterator J;
 368         int i=0;
 369         for (J=aOldMasterPagesDescriptor->second.begin();
 370              J!=aOldMasterPagesDescriptor->second.end();
 371              ++J)
 372             OSL_TRACE("old used master page %d is %s",
 373             i++,
 374             ::rtl::OUStringToOString(*J,
 375                 RTL_TEXTENCODING_UTF8).getStr());
 376
 377         // Send events about the newly used master pages.
 378         ::std::set_difference (
 379             aCurrentMasterPages.begin(),
 380             aCurrentMasterPages.end(),
 381             aOldMasterPagesDescriptor->second.begin(),
 382             aOldMasterPagesDescriptor->second.end(),
 383             ::std::back_insert_iterator<StringList>(aNewMasterPages));
 384         for (I=aNewMasterPages.begin(); I!=aNewMasterPages.end(); ++I)
 385         {
 386             OSL_TRACE("    added master page %s",
 387                 ::rtl::OUStringToOString(*I,
 388                     RTL_TEXTENCODING_UTF8).getStr());
 389
 390             MasterPageObserverEvent aEvent (
 391                 MasterPageObserverEvent::ET_MASTER_PAGE_ADDED,
 392                 rDocument,
 393                 *I);
 394             SendEvent (aEvent);
 395         }
 396
 397         // Send events about master pages that are not used any longer.
 398         ::std::set_difference (
 399             aOldMasterPagesDescriptor->second.begin(),
 400             aOldMasterPagesDescriptor->second.end(),
 401             aCurrentMasterPages.begin(),
 402             aCurrentMasterPages.end(),
 403             ::std::back_insert_iterator<StringList>(aRemovedMasterPages));
 404         for (I=aRemovedMasterPages.begin(); I!=aRemovedMasterPages.end(); ++I)
 405         {
 406             OSL_TRACE("    removed master page %s",
 407                 ::rtl::OUStringToOString(*I,
 408                     RTL_TEXTENCODING_UTF8).getStr());
 409
 410             MasterPageObserverEvent aEvent (
 411                 MasterPageObserverEvent::ET_MASTER_PAGE_REMOVED,
 412                 rDocument,
 413                 *I);
 414             SendEvent (aEvent);
 415         }
 416
 417         // Store the new list of master pages.
 418         aOldMasterPagesDescriptor->second = aCurrentMasterPages;
 419     }
 420 }
 421
 422
 423
 424
 425 void MasterPageObserver::Implementation::SendEvent (
 426     MasterPageObserverEvent& rEvent)
 427 {
 428     ::std::vector<Link>::iterator aLink (maListeners.begin());
 429     ::std::vector<Link>::iterator aEnd (maListeners.end());
 430     while (aLink!=aEnd)
 431     {
 432         aLink->Call (&rEvent);
 433         ++aLink;
 434     }
 435 }
 436
 437
 438 } // end of namespace sd