1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 
27 #include "MasterPageDescriptor.hxx"
28 
29 #include "DocumentHelper.hxx"
30 #include "sdpage.hxx"
31 #include <tools/urlobj.hxx>
32 
33 namespace sd { namespace toolpanel { namespace controls {
34 
35 
36 //===== MasterPageDescriptor ==================================================
37 
38 MasterPageDescriptor::MasterPageDescriptor (
39     MasterPageContainer::Origin eOrigin,
40     const sal_Int32 nTemplateIndex,
41     const String& rsURL,
42     const String& rsPageName,
43     const String& rsStyleName,
44     const bool bIsPrecious,
45     const ::boost::shared_ptr<PageObjectProvider>& rpPageObjectProvider,
46     const ::boost::shared_ptr<PreviewProvider>& rpPreviewProvider)
47     : maToken(MasterPageContainer::NIL_TOKEN),
48       meOrigin(eOrigin),
49       msURL(INetURLObject(rsURL).GetMainURL(INetURLObject::DECODE_UNAMBIGUOUS)),
50       msPageName(rsPageName),
51       msStyleName(rsStyleName),
52       mbIsPrecious(bIsPrecious),
53       mpMasterPage(NULL),
54       mpSlide(NULL),
55       maSmallPreview(),
56       maLargePreview(),
57       mpPreviewProvider(rpPreviewProvider),
58       mpPageObjectProvider(rpPageObjectProvider),
59       mnTemplateIndex(nTemplateIndex),
60       meURLClassification(URLCLASS_UNDETERMINED),
61       mnUseCount(0)
62 {
63 }
64 
65 
66 
67 
68 MasterPageDescriptor::MasterPageDescriptor (const MasterPageDescriptor& rDescriptor)
69     : maToken(rDescriptor.maToken),
70       meOrigin(rDescriptor.meOrigin),
71       msURL(rDescriptor.msURL),
72       msPageName(rDescriptor.msPageName),
73       msStyleName(rDescriptor.msStyleName),
74       mbIsPrecious(rDescriptor.mbIsPrecious),
75       mpMasterPage(rDescriptor.mpMasterPage),
76       mpSlide(rDescriptor.mpSlide),
77       maSmallPreview(rDescriptor.maSmallPreview),
78       maLargePreview(rDescriptor.maLargePreview),
79       mpPreviewProvider(rDescriptor.mpPreviewProvider),
80       mpPageObjectProvider(rDescriptor.mpPageObjectProvider),
81       mnTemplateIndex(rDescriptor.mnTemplateIndex),
82       meURLClassification(rDescriptor.meURLClassification),
83       mnUseCount(rDescriptor.mnUseCount)
84 {
85 }
86 
87 
88 
89 
90 MasterPageDescriptor::~MasterPageDescriptor (void)
91 {
92 }
93 
94 
95 
96 
97 void MasterPageDescriptor::SetToken (MasterPageContainer::Token aToken)
98 {
99     maToken = aToken;
100 }
101 
102 
103 
104 
105 Image MasterPageDescriptor::GetPreview (MasterPageContainer::PreviewSize eSize)
106 {
107     if (eSize == MasterPageContainer::SMALL)
108         return maSmallPreview;
109     else
110         return maLargePreview;
111 }
112 
113 
114 
115 
116 ::std::auto_ptr<std::vector<MasterPageContainerChangeEvent::EventType> >
117     MasterPageDescriptor::Update (
118         const MasterPageDescriptor& rDescriptor)
119 {
120     bool bDataChanged (false);
121     bool bIndexChanged (false);
122     bool bPreviewChanged (false);
123 
124     if (meOrigin==MasterPageContainer::UNKNOWN
125         && rDescriptor.meOrigin!=MasterPageContainer::UNKNOWN)
126     {
127         meOrigin = rDescriptor.meOrigin;
128         bIndexChanged = true;
129     }
130 
131     if (msURL.getLength()==0 && rDescriptor.msURL.getLength()!=0)
132     {
133         msURL = rDescriptor.msURL;
134         bDataChanged = true;
135     }
136 
137     if (msPageName.getLength()==0 && rDescriptor.msPageName.getLength()!=0)
138     {
139         msPageName = rDescriptor.msPageName;
140         bDataChanged = true;
141     }
142 
143     if (msStyleName.getLength()==0 && rDescriptor.msStyleName.getLength()!=0)
144     {
145         msStyleName = rDescriptor.msStyleName;
146         bDataChanged = true;
147     }
148 
149     if (mpPageObjectProvider.get()==NULL && rDescriptor.mpPageObjectProvider.get()!=NULL)
150     {
151         mpPageObjectProvider = rDescriptor.mpPageObjectProvider;
152         bDataChanged = true;
153     }
154 
155      if (mpPreviewProvider.get()==NULL && rDescriptor.mpPreviewProvider.get()!=NULL)
156      {
157          mpPreviewProvider = rDescriptor.mpPreviewProvider;
158          bPreviewChanged = true;
159      }
160 
161      if (mnTemplateIndex<0 && rDescriptor.mnTemplateIndex>=0)
162      {
163          mnTemplateIndex = rDescriptor.mnTemplateIndex;
164          bIndexChanged = true;
165      }
166 
167      // Prepare the list of event types that will be returned.
168      ::std::auto_ptr<std::vector<MasterPageContainerChangeEvent::EventType> > pResult;
169      if (bDataChanged || bIndexChanged || bPreviewChanged)
170      {
171          pResult.reset(new std::vector<MasterPageContainerChangeEvent::EventType>());
172          if (bDataChanged)
173              pResult->push_back(MasterPageContainerChangeEvent::DATA_CHANGED);
174          if (bIndexChanged)
175              pResult->push_back(MasterPageContainerChangeEvent::INDEX_CHANGED);
176          if (bPreviewChanged)
177              pResult->push_back(MasterPageContainerChangeEvent::PREVIEW_CHANGED);
178      }
179 
180      return pResult;
181 }
182 
183 
184 
185 
186 bool MasterPageDescriptor::UpdatePageObject (
187     sal_Int32 nCostThreshold,
188     SdDrawDocument* pDocument)
189 {
190     bool bModified (false);
191 
192     // Update the page object when that is not yet known.
193     if (mpMasterPage == NULL
194         && mpPageObjectProvider.get()!=NULL
195         && (nCostThreshold<0 || mpPageObjectProvider->GetCostIndex()<=nCostThreshold))
196     {
197         // Note that pDocument may be NULL.
198 
199         SdPage* pPage = (*mpPageObjectProvider)(pDocument);
200         if (meOrigin == MasterPageContainer::MASTERPAGE)
201         {
202             mpMasterPage = pPage;
203             if (mpMasterPage != NULL)
204                 mpMasterPage->SetPrecious(mbIsPrecious);
205         }
206         else
207         {
208             // Master pages from templates are copied into the local document.
209             if (pDocument != NULL)
210                 mpMasterPage = DocumentHelper::CopyMasterPageToLocalDocument(*pDocument,pPage);
211             mpSlide = DocumentHelper::GetSlideForMasterPage(mpMasterPage);
212         }
213 
214         if (mpMasterPage != NULL)
215         {
216             // Update page name and style name.
217             if (msPageName.getLength() == 0)
218                 msPageName = mpMasterPage->GetName();
219             msStyleName = mpMasterPage->GetName();
220 
221             // Delete an existing substitution. The next request for a preview
222             // will create the real one.
223             maSmallPreview = Image();
224             maLargePreview = Image();
225             mpPreviewProvider = ::boost::shared_ptr<PreviewProvider>(new PagePreviewProvider());
226         }
227         else
228         {
229             DBG_ASSERT(false, "UpdatePageObject: master page is NULL");
230         }
231 
232         bModified = true;
233     }
234 
235     return bModified;
236 }
237 
238 
239 
240 
241 bool MasterPageDescriptor::UpdatePreview (
242     sal_Int32 nCostThreshold,
243     const Size& rSmallSize,
244     const Size& rLargeSize,
245     ::sd::PreviewRenderer& rRenderer)
246 {
247     bool bModified (false);
248 
249     // Update the preview when that is not yet known.
250     if (maLargePreview.GetSizePixel().Width()==0
251         && mpPreviewProvider.get()!=NULL
252         && (nCostThreshold<0 || mpPreviewProvider->GetCostIndex()<=nCostThreshold))
253     {
254         SdPage* pPage = mpSlide;
255         if (pPage == NULL)
256         {
257             pPage = mpMasterPage;
258         }
259         maLargePreview = (*mpPreviewProvider)(
260             rLargeSize.Width(),
261             pPage,
262             rRenderer);
263         if (maLargePreview.GetSizePixel().Width() > 0)
264         {
265             // Create the small preview by scaling the large one down.
266             maSmallPreview = rRenderer.ScaleBitmap(
267                 maLargePreview.GetBitmapEx(),
268                 rSmallSize.Width());
269             // The large preview may not have the desired width.  Scale it
270             // accrodingly.
271             if (maLargePreview.GetSizePixel().Width() != rLargeSize.Width())
272                 maLargePreview = rRenderer.ScaleBitmap(
273                     maLargePreview.GetBitmapEx(),
274                     rLargeSize.Width());
275             bModified = true;
276         }
277     }
278 
279     return bModified;
280 }
281 
282 
283 
284 
285 MasterPageDescriptor::URLClassification MasterPageDescriptor::GetURLClassification (void)
286 {
287     if (meURLClassification == URLCLASS_UNDETERMINED)
288     {
289         if (msURL.getLength() == 0)
290             meURLClassification = URLCLASS_UNKNOWN;
291         else if (msURL.indexOf(::rtl::OUString::createFromAscii("presnt"))>=0)
292         {
293             meURLClassification = URLCLASS_PRESENTATION;
294         }
295         else if (msURL.indexOf(::rtl::OUString::createFromAscii("layout"))>=0)
296         {
297             meURLClassification = URLCLASS_LAYOUT;
298         }
299         else if (msURL.indexOf(::rtl::OUString::createFromAscii("educate"))>=0)
300         {
301             meURLClassification = URLCLASS_OTHER;
302         }
303         else
304         {
305             meURLClassification = URLCLASS_USER;
306         }
307     }
308 
309     return meURLClassification;
310 }
311 
312 
313 
314 //===== URLComparator =========================================================
315 
316 MasterPageDescriptor::URLComparator::URLComparator (const ::rtl::OUString& sURL)
317     : msURL(sURL)
318 {
319 }
320 
321 
322 
323 
324 bool MasterPageDescriptor::URLComparator::operator() (
325     const SharedMasterPageDescriptor& rDescriptor)
326 {
327     if (rDescriptor.get() == NULL)
328         return false;
329     else
330         return rDescriptor->msURL.equals(msURL);
331 }
332 
333 
334 
335 
336 // ===== StyleNameComparator ==================================================
337 
338 MasterPageDescriptor::StyleNameComparator::StyleNameComparator (const ::rtl::OUString& sStyleName)
339     : msStyleName(sStyleName)
340 {
341 }
342 
343 
344 
345 
346 bool MasterPageDescriptor::StyleNameComparator::operator() (
347     const SharedMasterPageDescriptor& rDescriptor)
348 {
349     if (rDescriptor.get() == NULL)
350         return false;
351     else
352         return rDescriptor->msStyleName.equals(msStyleName);
353 }
354 
355 
356 
357 
358 //===== PageObjectComparator ==================================================
359 
360 MasterPageDescriptor::PageObjectComparator::PageObjectComparator (const SdPage* pPageObject)
361     : mpMasterPage(pPageObject)
362 {
363 }
364 
365 
366 
367 
368 bool MasterPageDescriptor::PageObjectComparator::operator() (
369     const SharedMasterPageDescriptor& rDescriptor)
370 {
371     if (rDescriptor.get() == NULL)
372         return false;
373     else
374         return rDescriptor->mpMasterPage==mpMasterPage;
375 }
376 
377 
378 
379 
380 //===== AllComparator =========================================================
381 
382 MasterPageDescriptor::AllComparator::AllComparator(const SharedMasterPageDescriptor& rDescriptor)
383     : mpDescriptor(rDescriptor)
384 {
385 }
386 
387 
388 
389 
390 bool MasterPageDescriptor::AllComparator::operator() (const SharedMasterPageDescriptor&rDescriptor)
391 {
392     if (rDescriptor.get() == NULL)
393         return false;
394     else
395     {
396         // Take URL, page name, style name, and page object into account
397         // when comparing two descriptors.  When two descriptors are
398         // identical in any of these values then their are thought of as
399         // equivalent.  Only the Origin has to be the same in both
400         // descriptors.
401         return
402             mpDescriptor->meOrigin == rDescriptor->meOrigin
403             && (
404                 (mpDescriptor->msURL.getLength()>0
405                     && mpDescriptor->msURL.equals(rDescriptor->msURL))
406                 || (mpDescriptor->msPageName.getLength()>0
407                     && mpDescriptor->msPageName.equals(rDescriptor->msPageName))
408                 || (mpDescriptor->msStyleName.getLength()>0
409                     && mpDescriptor->msStyleName.equals(rDescriptor->msStyleName))
410                 || (mpDescriptor->mpMasterPage!=NULL
411                     && mpDescriptor->mpMasterPage==rDescriptor->mpMasterPage)
412                 || (mpDescriptor->mpPageObjectProvider.get()!=NULL
413                     && rDescriptor->mpPageObjectProvider.get()!=NULL
414                     && mpDescriptor->mpPageObjectProvider==rDescriptor->mpPageObjectProvider));
415     }
416 }
417 
418 
419 } } } // end of namespace ::sd::toolpanel::controls
420