?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sd / source / ui / unoidl / unopage.cxx
blobe703853ae5e8865bf9fc45304ee13d7f697db99b
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: unopage.cxx,v $
10 * $Revision: 1.96 $
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 #include <com/sun/star/lang/DisposedException.hpp>
34 #include <com/sun/star/presentation/ClickAction.hpp>
35 #include <com/sun/star/presentation/FadeEffect.hpp>
36 #include <com/sun/star/presentation/AnimationEffect.hpp>
37 #include <com/sun/star/presentation/PresentationRange.hpp>
38 #include <com/sun/star/presentation/AnimationSpeed.hpp>
39 #include <com/sun/star/view/PaperOrientation.hpp>
40 #include <com/sun/star/animations/AnimationNodeType.hpp>
41 #include <com/sun/star/presentation/EffectNodeType.hpp>
42 #include <com/sun/star/lang/DisposedException.hpp>
43 #include <comphelper/processfactory.hxx>
44 #include <rtl/ustrbuf.hxx>
45 #include <vcl/bitmapex.hxx>
46 #include <vcl/metaact.hxx>
47 #ifndef _TOOLKIT_UNOIFACE_HXX
48 #include <toolkit/unohlp.hxx>
49 #endif
50 #include <vcl/svapp.hxx>
51 #include <vcl/settings.hxx>
52 #include <unomodel.hxx>
53 #include <unopage.hxx>
54 #ifndef _SVX_SVXIDS_HRC
55 #include <svx/svxids.hrc>
56 #endif
57 #include <svtools/itemset.hxx>
58 #include <svx/svdmodel.hxx>
59 #include <sdresid.hxx>
60 #include <glob.hrc>
61 #ifndef _SD_PAGE_HXX //autogen
62 #include <sdpage.hxx>
63 #endif
64 #include <unoprnms.hxx>
65 #include <sdattr.hxx>
66 #include <drawdoc.hxx>
67 #include <svx/unoshape.hxx>
68 #include <com/sun/star/style/XStyle.hpp>
69 #include <svx/svdorect.hxx>
70 #include <vos/mutex.hxx>
71 #include <svtools/style.hxx>
72 #include <rtl/uuid.h>
73 #include <rtl/memory.h>
74
75 #include <comphelper/extract.hxx>
76 #include <list>
77 #include <svx/svditer.hxx>
78 #include <svtools/wmf.hxx>
79 #include <svx/svdoole2.hxx>
80
81 #include <svx/svdview.hxx>
82 #include "misc.hxx"
83 #include "View.hxx"
84 #ifndef SVX_LIGHT
85 #ifndef SD_DRAW_DOC_SHELL_HXX
86 #include "DrawDocShell.hxx"
87 #endif
88 #endif
89 #include "ViewShell.hxx"
90 #include "DrawViewShell.hxx"
91 #include "unoobj.hxx"
92 #include "res_bmp.hrc"
93 #include "unokywds.hxx"
94 #include "unopback.hxx"
95 #include "unohelp.hxx"
96
97 using ::com::sun::star::animations::XAnimationNode;
98 using ::com::sun::star::animations::XAnimationNodeSupplier;
99 using ::rtl::OUString;
100 using ::rtl::OUStringBuffer;
101
102 using namespace ::vos;
103 using namespace ::osl;
104 using namespace ::com::sun::star;
105 using namespace ::com::sun::star::uno;
106 using namespace ::com::sun::star::lang;
107 using namespace ::com::sun::star::container;
108 using namespace ::com::sun::star::drawing;
109
110 /* this are the ids for page properties */
111 enum WID_PAGE
112 {
113 WID_PAGE_LEFT, WID_PAGE_RIGHT, WID_PAGE_TOP, WID_PAGE_BOTTOM, WID_PAGE_WIDTH,
114 WID_PAGE_HEIGHT, WID_PAGE_EFFECT, WID_PAGE_CHANGE, WID_PAGE_SPEED, WID_PAGE_NUMBER,
115 WID_PAGE_ORIENT, WID_PAGE_LAYOUT, WID_PAGE_DURATION, WID_PAGE_LDNAME, WID_PAGE_LDBITMAP,
116 WID_PAGE_BACK, WID_PAGE_PREVIEW, WID_PAGE_PREVIEWBITMAP, WID_PAGE_VISIBLE, WID_PAGE_SOUNDFILE, WID_PAGE_BACKFULL,
117 WID_PAGE_BACKVIS, WID_PAGE_BACKOBJVIS, WID_PAGE_USERATTRIBS, WID_PAGE_BOOKMARK, WID_PAGE_ISDARK,
118 WID_PAGE_HEADERVISIBLE, WID_PAGE_HEADERTEXT, WID_PAGE_FOOTERVISIBLE, WID_PAGE_FOOTERTEXT,
119 WID_PAGE_PAGENUMBERVISIBLE, WID_PAGE_DATETIMEVISIBLE, WID_PAGE_DATETIMEFIXED,
120 WID_PAGE_DATETIMETEXT, WID_PAGE_DATETIMEFORMAT, WID_TRANSITION_TYPE, WID_TRANSITION_SUBTYPE,
121 WID_TRANSITION_DIRECTION, WID_TRANSITION_FADE_COLOR, WID_TRANSITION_DURATION, WID_LOOP_SOUND,
122 WID_NAVORDER
123 };
124
125 #ifndef SEQTYPE
126 #if defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500)
127 #define SEQTYPE(x) (new ::com::sun::star::uno::Type( x ))
128 #else
129 #define SEQTYPE(x) &(x)
130 #endif
131 #endif
132
133 static sal_Char __FAR_DATA sEmptyPageName[sizeof("page")] = "page";
134
135 /** this function stores the property maps for draw pages in impress and draw */
136 const SvxItemPropertySet* ImplGetDrawPagePropertySet( sal_Bool bImpress, PageKind ePageKind )
137 {
138 static const SfxItemPropertyMapEntry aDrawPagePropertyMap_Impl[] =
139 {
140 { MAP_CHAR_LEN(UNO_NAME_PAGE_BACKGROUND), WID_PAGE_BACK, &ITYPE( beans::XPropertySet ), beans::PropertyAttribute::MAYBEVOID,0},
141 { MAP_CHAR_LEN(UNO_NAME_PAGE_BOTTOM), WID_PAGE_BOTTOM, &::getCppuType((const sal_Int32*)0), 0, 0},
142 { MAP_CHAR_LEN(UNO_NAME_PAGE_LEFT), WID_PAGE_LEFT, &::getCppuType((const sal_Int32*)0), 0, 0},
143 { MAP_CHAR_LEN(UNO_NAME_PAGE_RIGHT), WID_PAGE_RIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
144 { MAP_CHAR_LEN(UNO_NAME_PAGE_TOP), WID_PAGE_TOP, &::getCppuType((const sal_Int32*)0), 0, 0},
145 { MAP_CHAR_LEN(UNO_NAME_PAGE_CHANGE), WID_PAGE_CHANGE, &::getCppuType((const sal_Int32*)0), 0, 0},
146 { MAP_CHAR_LEN(UNO_NAME_PAGE_DURATION), WID_PAGE_DURATION, &::getCppuType((const sal_Int32*)0), 0, 0},
147 { MAP_CHAR_LEN(UNO_NAME_PAGE_EFFECT), WID_PAGE_EFFECT, &::getCppuType((const presentation::FadeEffect*)0), 0, 0},
148 { MAP_CHAR_LEN(UNO_NAME_PAGE_HEIGHT), WID_PAGE_HEIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
149 { MAP_CHAR_LEN(UNO_NAME_PAGE_LAYOUT), WID_PAGE_LAYOUT, &::getCppuType((const sal_Int16*)0), 0, 0},
150 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYBITMAP), WID_PAGE_LDBITMAP, &ITYPE( awt::XBitmap), beans::PropertyAttribute::READONLY, 0},
151 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYNAME), WID_PAGE_LDNAME, &::getCppuType((const OUString*)0), beans::PropertyAttribute::READONLY, 0},
152 { MAP_CHAR_LEN(UNO_NAME_PAGE_NUMBER), WID_PAGE_NUMBER, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0},
153 { MAP_CHAR_LEN(UNO_NAME_PAGE_ORIENTATION), WID_PAGE_ORIENT, &::getCppuType((const view::PaperOrientation*)0),0, 0},
154 { MAP_CHAR_LEN(UNO_NAME_PAGE_SPEED), WID_PAGE_SPEED, &::getCppuType((const presentation::AnimationSpeed*)0), 0, 0},
155 { MAP_CHAR_LEN(UNO_NAME_PAGE_WIDTH), WID_PAGE_WIDTH, &::getCppuType((const sal_Int32*)0), 0, 0},
156 { MAP_CHAR_LEN(UNO_NAME_PAGE_PREVIEW), WID_PAGE_PREVIEW, SEQTYPE(::getCppuType((::com::sun::star::uno::Sequence<sal_Int8>*)0)), ::com::sun::star::beans::PropertyAttribute::READONLY, 0},
157 { MAP_CHAR_LEN(UNO_NAME_PAGE_PREVIEWBITMAP), WID_PAGE_PREVIEWBITMAP, SEQTYPE(::getCppuType((::com::sun::star::uno::Sequence<sal_Int8>*)0)), ::com::sun::star::beans::PropertyAttribute::READONLY, 0},
158 { MAP_CHAR_LEN(UNO_NAME_PAGE_VISIBLE), WID_PAGE_VISIBLE, &::getBooleanCppuType(), 0, 0},
159 { MAP_CHAR_LEN(UNO_NAME_OBJ_SOUNDFILE), WID_PAGE_SOUNDFILE, &::getCppuType((const Any*)0), 0, 0},
160 { MAP_CHAR_LEN(sUNO_Prop_IsBackgroundVisible), WID_PAGE_BACKVIS, &::getBooleanCppuType(), 0, 0},
161 { MAP_CHAR_LEN(sUNO_Prop_IsBackgroundObjectsVisible), WID_PAGE_BACKOBJVIS, &::getBooleanCppuType(), 0, 0},
162 { MAP_CHAR_LEN(sUNO_Prop_UserDefinedAttributes),WID_PAGE_USERATTRIBS, &::getCppuType((const Reference< ::com::sun::star::container::XNameContainer >*)0) , 0, 0},
163 { MAP_CHAR_LEN(sUNO_Prop_BookmarkURL), WID_PAGE_BOOKMARK, &::getCppuType((const OUString*)0), 0, 0},
164 { MAP_CHAR_LEN("IsBackgroundDark" ), WID_PAGE_ISDARK, &::getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0},
165 { MAP_CHAR_LEN("IsFooterVisible"), WID_PAGE_FOOTERVISIBLE, &::getBooleanCppuType(), 0, 0},
166 { MAP_CHAR_LEN("FooterText"), WID_PAGE_FOOTERTEXT, &::getCppuType((const OUString*)0), 0, 0},
167 { MAP_CHAR_LEN("IsPageNumberVisible"), WID_PAGE_PAGENUMBERVISIBLE, &::getBooleanCppuType(), 0, 0},
168 { MAP_CHAR_LEN("IsDateTimeVisible"), WID_PAGE_DATETIMEVISIBLE, &::getBooleanCppuType(), 0, 0},
169 { MAP_CHAR_LEN("IsDateTimeFixed"), WID_PAGE_DATETIMEFIXED, &::getBooleanCppuType(), 0, 0},
170 { MAP_CHAR_LEN("DateTimeText"), WID_PAGE_DATETIMETEXT, &::getCppuType((const OUString*)0), 0, 0},
171 { MAP_CHAR_LEN("DateTimeFormat"), WID_PAGE_DATETIMEFORMAT, &::getCppuType((const sal_Int32*)0), 0, 0},
172 { MAP_CHAR_LEN("TransitionType"), WID_TRANSITION_TYPE, &::getCppuType((const sal_Int16*)0), 0, 0},
173 { MAP_CHAR_LEN("TransitionSubtype"), WID_TRANSITION_SUBTYPE, &::getCppuType((const sal_Int16*)0), 0, 0},
174 { MAP_CHAR_LEN("TransitionDirection"), WID_TRANSITION_DIRECTION, &::getCppuType((const sal_Bool*)0), 0, 0},
175 { MAP_CHAR_LEN("TransitionFadeColor"), WID_TRANSITION_FADE_COLOR, &::getCppuType((const sal_Int32*)0), 0, 0},
176 { MAP_CHAR_LEN("TransitionDuration"), WID_TRANSITION_DURATION, &::getCppuType((const double*)0), 0, 0},
177 { MAP_CHAR_LEN("LoopSound"), WID_LOOP_SOUND, &::getBooleanCppuType(), 0, 0},
178 { MAP_CHAR_LEN("NavigationOrder"), WID_NAVORDER, &::com::sun::star::container::XIndexAccess::static_type(),0, 0},
179 {0,0,0,0,0,0}
180 };
181
182 #define DRAW_PAGE_NOTES_PROPERTIES \
183 { MAP_CHAR_LEN(UNO_NAME_PAGE_BOTTOM), WID_PAGE_BOTTOM, &::getCppuType((const sal_Int32*)0), 0, 0}, \
184 { MAP_CHAR_LEN(UNO_NAME_PAGE_LEFT), WID_PAGE_LEFT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
185 { MAP_CHAR_LEN(UNO_NAME_PAGE_RIGHT), WID_PAGE_RIGHT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
186 { MAP_CHAR_LEN(UNO_NAME_PAGE_TOP), WID_PAGE_TOP, &::getCppuType((const sal_Int32*)0), 0, 0}, \
187 { MAP_CHAR_LEN(UNO_NAME_PAGE_HEIGHT), WID_PAGE_HEIGHT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
188 { MAP_CHAR_LEN(UNO_NAME_PAGE_LAYOUT), WID_PAGE_LAYOUT, &::getCppuType((const sal_Int16*)0), 0, 0}, \
189 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYBITMAP), WID_PAGE_LDBITMAP, &ITYPE( awt::XBitmap), beans::PropertyAttribute::READONLY, 0}, \
190 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYNAME), WID_PAGE_LDNAME, &::getCppuType((const OUString*)0), beans::PropertyAttribute::READONLY, 0}, \
191 { MAP_CHAR_LEN(UNO_NAME_PAGE_NUMBER), WID_PAGE_NUMBER, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0}, \
192 { MAP_CHAR_LEN(UNO_NAME_PAGE_ORIENTATION), WID_PAGE_ORIENT, &::getCppuType((const view::PaperOrientation*)0),0, 0}, \
193 { MAP_CHAR_LEN(UNO_NAME_PAGE_WIDTH), WID_PAGE_WIDTH, &::getCppuType((const sal_Int32*)0), 0, 0}, \
194 { MAP_CHAR_LEN(sUNO_Prop_UserDefinedAttributes),WID_PAGE_USERATTRIBS, &::getCppuType((const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameContainer >*)0) , 0, 0},\
195 { MAP_CHAR_LEN("IsHeaderVisible"), WID_PAGE_HEADERVISIBLE, &::getBooleanCppuType(), 0, 0}, \
196 { MAP_CHAR_LEN("HeaderText"), WID_PAGE_HEADERTEXT, &::getCppuType((const OUString*)0), 0, 0}, \
197 { MAP_CHAR_LEN("IsBackgroundDark" ), WID_PAGE_ISDARK, &::getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0}, \
198 { MAP_CHAR_LEN("IsFooterVisible"), WID_PAGE_FOOTERVISIBLE, &::getBooleanCppuType(), 0, 0}, \
199 { MAP_CHAR_LEN("FooterText"), WID_PAGE_FOOTERTEXT, &::getCppuType((const OUString*)0), 0, 0}, \
200 { MAP_CHAR_LEN("IsPageNumberVisible"), WID_PAGE_PAGENUMBERVISIBLE, &::getBooleanCppuType(), 0, 0}, \
201 { MAP_CHAR_LEN("IsDateTimeVisible"), WID_PAGE_DATETIMEVISIBLE, &::getBooleanCppuType(), 0, 0}, \
202 { MAP_CHAR_LEN("IsDateTimeFixed"), WID_PAGE_DATETIMEFIXED, &::getBooleanCppuType(), 0, 0}, \
203 { MAP_CHAR_LEN("DateTimeText"), WID_PAGE_DATETIMETEXT, &::getCppuType((const OUString*)0), 0, 0}, \
204 { MAP_CHAR_LEN("DateTimeFormat"), WID_PAGE_DATETIMEFORMAT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
205 { MAP_CHAR_LEN("NavigationOrder"), WID_NAVORDER, &::com::sun::star::container::XIndexAccess::static_type(),0, 0}, \
206 {0,0,0,0,0,0}
207
208 static const SfxItemPropertyMapEntry aDrawPageNotesHandoutPropertyMap_Impl[] =
209 {
210 // this must be the first two entries so they can be excluded for PK_STANDARD
211 { MAP_CHAR_LEN(UNO_NAME_PAGE_BACKGROUND), WID_PAGE_BACK, &ITYPE( beans::XPropertySet ), beans::PropertyAttribute::MAYBEVOID,0},
212 DRAW_PAGE_NOTES_PROPERTIES
213 };
214 static const SfxItemPropertyMapEntry aDrawPageNotesHandoutPropertyNoBackMap_Impl[] =
215 {
216 DRAW_PAGE_NOTES_PROPERTIES
217 };
218
219 #define GRAPHIC_PAGE_PROPERTIES \
220 { MAP_CHAR_LEN(UNO_NAME_PAGE_BOTTOM), WID_PAGE_BOTTOM, &::getCppuType((const sal_Int32*)0), 0, 0}, \
221 { MAP_CHAR_LEN(UNO_NAME_PAGE_LEFT), WID_PAGE_LEFT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
222 { MAP_CHAR_LEN(UNO_NAME_PAGE_RIGHT), WID_PAGE_RIGHT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
223 { MAP_CHAR_LEN(UNO_NAME_PAGE_TOP), WID_PAGE_TOP, &::getCppuType((const sal_Int32*)0), 0, 0}, \
224 { MAP_CHAR_LEN(UNO_NAME_PAGE_HEIGHT), WID_PAGE_HEIGHT, &::getCppuType((const sal_Int32*)0), 0, 0}, \
225 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYBITMAP), WID_PAGE_LDBITMAP, &ITYPE(awt::XBitmap), beans::PropertyAttribute::READONLY, 0}, \
226 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYNAME), WID_PAGE_LDNAME, &::getCppuType((const OUString*)0), beans::PropertyAttribute::READONLY, 0}, \
227 { MAP_CHAR_LEN(UNO_NAME_PAGE_NUMBER), WID_PAGE_NUMBER, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0}, \
228 { MAP_CHAR_LEN(UNO_NAME_PAGE_ORIENTATION), WID_PAGE_ORIENT, &::getCppuType((const view::PaperOrientation*)0),0, 0}, \
229 { MAP_CHAR_LEN(UNO_NAME_PAGE_WIDTH), WID_PAGE_WIDTH, &::getCppuType((const sal_Int32*)0), 0, 0}, \
230 { MAP_CHAR_LEN(UNO_NAME_PAGE_PREVIEW), WID_PAGE_PREVIEW, SEQTYPE(::getCppuType((::com::sun::star::uno::Sequence<sal_Int8>*)0)), ::com::sun::star::beans::PropertyAttribute::READONLY, 0}, \
231 { MAP_CHAR_LEN(UNO_NAME_PAGE_PREVIEWBITMAP), WID_PAGE_PREVIEWBITMAP, SEQTYPE(::getCppuType((::com::sun::star::uno::Sequence<sal_Int8>*)0)), ::com::sun::star::beans::PropertyAttribute::READONLY, 0},\
232 { MAP_CHAR_LEN(sUNO_Prop_UserDefinedAttributes),WID_PAGE_USERATTRIBS, &::getCppuType((const Reference< ::com::sun::star::container::XNameContainer >*)0) , 0, 0}, \
233 { MAP_CHAR_LEN(sUNO_Prop_BookmarkURL), WID_PAGE_BOOKMARK, &::getCppuType((const OUString*)0), 0, 0}, \
234 { MAP_CHAR_LEN("IsBackgroundDark" ), WID_PAGE_ISDARK, &::getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0}, \
235 { MAP_CHAR_LEN("NavigationOrder"), WID_NAVORDER, &::com::sun::star::container::XIndexAccess::static_type(),0, 0}, \
236 {0,0,0,0,0,0}
237
238 static const SfxItemPropertyMapEntry aGraphicPagePropertyMap_Impl[] =
239 {
240 { MAP_CHAR_LEN(UNO_NAME_PAGE_BACKGROUND), WID_PAGE_BACK, &ITYPE( beans::XPropertySet), beans::PropertyAttribute::MAYBEVOID,0},
241 GRAPHIC_PAGE_PROPERTIES
242 };
243 static const SfxItemPropertyMapEntry aGraphicPagePropertyNoBackMap_Impl[] =
244 {
245 GRAPHIC_PAGE_PROPERTIES
246 };
247
248 //
249 bool bWithoutBackground = ePageKind != PK_STANDARD && ePageKind != PK_HANDOUT;
250 const SvxItemPropertySet* pRet = 0;
251 if( bImpress )
252 {
253 if( ePageKind == PK_STANDARD )
254 {
255 //PK_STANDARD always has a background property
256 static SvxItemPropertySet aDrawPagePropertySet_Impl( aDrawPagePropertyMap_Impl );
257 pRet = &aDrawPagePropertySet_Impl;
258 }
259 else
260 {
261 if(bWithoutBackground)
262 {
263 static SvxItemPropertySet aDrawPageNotesHandoutPropertyNoBackSet_Impl( aDrawPageNotesHandoutPropertyNoBackMap_Impl );
264 pRet = &aDrawPageNotesHandoutPropertyNoBackSet_Impl;
265 }
266 else
267 {
268 static SvxItemPropertySet aDrawPageNotesHandoutPropertySet_Impl( aDrawPageNotesHandoutPropertyMap_Impl );
269 pRet = &aDrawPageNotesHandoutPropertySet_Impl;
270 }
271 }
272 }
273 else
274 {
275 if(bWithoutBackground)
276 {
277 static SvxItemPropertySet aGraphicPagePropertyNoBackSet_Impl( aGraphicPagePropertyNoBackMap_Impl );
278 pRet = &aGraphicPagePropertyNoBackSet_Impl;
279 }
280 else
281 {
282 static SvxItemPropertySet aGraphicPagePropertySet_Impl( aGraphicPagePropertyMap_Impl );
283 pRet = &aGraphicPagePropertySet_Impl;
284 }
285 }
286 return pRet;
287 }
288
289 /** this function stores the property map for master pages in impress and draw */
290 const SvxItemPropertySet* ImplGetMasterPagePropertySet( PageKind ePageKind )
291 {
292 static const SfxItemPropertyMapEntry aMasterPagePropertyMap_Impl[] =
293 {
294 { MAP_CHAR_LEN(UNO_NAME_PAGE_BACKGROUND), WID_PAGE_BACK, &ITYPE(beans::XPropertySet), 0, 0},
295 { MAP_CHAR_LEN(UNO_NAME_PAGE_BOTTOM), WID_PAGE_BOTTOM, &::getCppuType((const sal_Int32*)0), 0, 0},
296 { MAP_CHAR_LEN(UNO_NAME_PAGE_LEFT), WID_PAGE_LEFT, &::getCppuType((const sal_Int32*)0), 0, 0},
297 { MAP_CHAR_LEN(UNO_NAME_PAGE_RIGHT), WID_PAGE_RIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
298 { MAP_CHAR_LEN(UNO_NAME_PAGE_TOP), WID_PAGE_TOP, &::getCppuType((const sal_Int32*)0), 0, 0},
299 { MAP_CHAR_LEN(UNO_NAME_PAGE_HEIGHT), WID_PAGE_HEIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
300 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYBITMAP), WID_PAGE_LDBITMAP, &ITYPE(awt::XBitmap), beans::PropertyAttribute::READONLY, 0},
301 { MAP_CHAR_LEN(UNO_NAME_LINKDISPLAYNAME), WID_PAGE_LDNAME, &::getCppuType((const OUString*)0), beans::PropertyAttribute::READONLY, 0},
302 { MAP_CHAR_LEN(UNO_NAME_PAGE_NUMBER), WID_PAGE_NUMBER, &::getCppuType((const sal_Int16*)0), beans::PropertyAttribute::READONLY, 0},
303 { MAP_CHAR_LEN(UNO_NAME_PAGE_ORIENTATION), WID_PAGE_ORIENT, &::getCppuType((const view::PaperOrientation*)0),0, 0},
304 { MAP_CHAR_LEN(UNO_NAME_PAGE_WIDTH), WID_PAGE_WIDTH, &::getCppuType((const sal_Int32*)0), 0, 0},
305 { MAP_CHAR_LEN("BackgroundFullSize"), WID_PAGE_BACKFULL, &::getBooleanCppuType(), 0, 0},
306 { MAP_CHAR_LEN(sUNO_Prop_UserDefinedAttributes),WID_PAGE_USERATTRIBS, &::getCppuType((const Reference< ::com::sun::star::container::XNameContainer >*)0) , 0, 0},
307 { MAP_CHAR_LEN("IsBackgroundDark" ), WID_PAGE_ISDARK, &::getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0},
308 {0,0,0,0,0,0}
309 };
310
311 static const SfxItemPropertyMapEntry aHandoutMasterPagePropertyMap_Impl[] =
312 {
313 { MAP_CHAR_LEN(UNO_NAME_PAGE_BOTTOM), WID_PAGE_BOTTOM, &::getCppuType((const sal_Int32*)0), 0, 0},
314 { MAP_CHAR_LEN(UNO_NAME_PAGE_LEFT), WID_PAGE_LEFT, &::getCppuType((const sal_Int32*)0), 0, 0},
315 { MAP_CHAR_LEN(UNO_NAME_PAGE_RIGHT), WID_PAGE_RIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
316 { MAP_CHAR_LEN(UNO_NAME_PAGE_TOP), WID_PAGE_TOP, &::getCppuType((const sal_Int32*)0), 0, 0},
317 { MAP_CHAR_LEN(UNO_NAME_PAGE_HEIGHT), WID_PAGE_HEIGHT, &::getCppuType((const sal_Int32*)0), 0, 0},
318 { MAP_CHAR_LEN(UNO_NAME_PAGE_ORIENTATION), WID_PAGE_ORIENT, &::getCppuType((const view::PaperOrientation*)0),0, 0},
319 { MAP_CHAR_LEN(UNO_NAME_PAGE_WIDTH), WID_PAGE_WIDTH, &::getCppuType((const sal_Int32*)0), 0, 0},
320 { MAP_CHAR_LEN(UNO_NAME_PAGE_LAYOUT), WID_PAGE_LAYOUT, &::getCppuType((const sal_Int16*)0), 0, 0},
321 { MAP_CHAR_LEN(sUNO_Prop_UserDefinedAttributes),WID_PAGE_USERATTRIBS, &::getCppuType((const Reference< ::com::sun::star::container::XNameContainer >*)0) , 0, 0},
322 { MAP_CHAR_LEN("IsBackgroundDark" ), WID_PAGE_ISDARK, &::getBooleanCppuType(), beans::PropertyAttribute::READONLY, 0},
323 { MAP_CHAR_LEN("IsHeaderVisible"), WID_PAGE_HEADERVISIBLE, &::getBooleanCppuType(), 0, 0},
324 { MAP_CHAR_LEN("HeaderText"), WID_PAGE_HEADERTEXT, &::getCppuType((const OUString*)0), 0, 0},
325 { MAP_CHAR_LEN("IsFooterVisible"), WID_PAGE_FOOTERVISIBLE, &::getBooleanCppuType(), 0, 0},
326 { MAP_CHAR_LEN("FooterText"), WID_PAGE_FOOTERTEXT, &::getCppuType((const OUString*)0), 0, 0},
327 { MAP_CHAR_LEN("IsPageNumberVisible"), WID_PAGE_PAGENUMBERVISIBLE, &::getBooleanCppuType(), 0, 0},
328 { MAP_CHAR_LEN("IsDateTimeVisible"), WID_PAGE_DATETIMEVISIBLE, &::getBooleanCppuType(), 0, 0},
329 { MAP_CHAR_LEN("IsDateTimeFixed"), WID_PAGE_DATETIMEFIXED, &::getBooleanCppuType(), 0, 0},
330 { MAP_CHAR_LEN("DateTimeText"), WID_PAGE_DATETIMETEXT, &::getCppuType((const OUString*)0), 0, 0},
331 { MAP_CHAR_LEN("DateTimeFormat"), WID_PAGE_DATETIMEFORMAT, &::getCppuType((const sal_Int32*)0), 0, 0},
332 {0,0,0,0,0,0}
333 };
334
335 const SvxItemPropertySet* pRet = 0;
336 if( ePageKind == PK_HANDOUT )
337 {
338 static SvxItemPropertySet aHandoutMasterPagePropertySet_Impl( aHandoutMasterPagePropertyMap_Impl );
339 pRet = &aHandoutMasterPagePropertySet_Impl;
340 }
341 else
342 {
343 static SvxItemPropertySet aMasterPagePropertySet_Impl( aMasterPagePropertyMap_Impl );
344 pRet = &aMasterPagePropertySet_Impl;
345 }
346 return pRet;
347 }
348
349 UNO3_GETIMPLEMENTATION2_IMPL( SdGenericDrawPage, SvxFmDrawPage );
350
351 /***********************************************************************
352 * *
353 ***********************************************************************/
354 SdGenericDrawPage::SdGenericDrawPage( SdXImpressDocument* _pModel, SdPage* pInPage, const SvxItemPropertySet* _pSet ) throw()
355 : SvxFmDrawPage( (SdrPage*) pInPage ),
356 SdUnoSearchReplaceShape(this),
357 mpModel ( _pModel ),
358 mpSdrModel(0),
359 mpPropSet ( _pSet ),
360 mbHasBackgroundObject(sal_False),
361 mbIsImpressDocument(false)
362 {
363 mpSdrModel = SvxFmDrawPage::mpModel;
364 if( mpModel )
365 mbIsImpressDocument = mpModel->IsImpressDocument() ? true : false;
366
367 }
368
369 SdGenericDrawPage::~SdGenericDrawPage() throw()
370 {
371 }
372
373 void SdGenericDrawPage::throwIfDisposed() const throw (::com::sun::star::uno::RuntimeException )
374 {
375 if( (SvxFmDrawPage::mpModel == 0) || (mpModel == 0) || (SvxFmDrawPage::mpPage == 0) )
376 throw lang::DisposedException();
377 }
378
379 SdXImpressDocument* SdGenericDrawPage::GetModel() const
380 {
381 if( mpSdrModel != SvxFmDrawPage::mpModel )
382 {
383 const_cast< SdGenericDrawPage* >(this)->mpSdrModel = SvxFmDrawPage::mpModel;
384 if( mpSdrModel )
385 {
386 uno::Reference< uno::XInterface > xModel( SvxFmDrawPage::mpModel->getUnoModel() );
387 const_cast< SdGenericDrawPage*>(this)->mpModel = SdXImpressDocument::getImplementation( xModel );
388 if( mpModel )
389 const_cast< SdGenericDrawPage*>(this)->mbIsImpressDocument = mpModel->IsImpressDocument() ? true : false;
390 }
391 else
392 {
393 const_cast< SdGenericDrawPage* >(this)->mpModel = 0;
394 }
395 }
396
397 return mpModel;
398 }
399
400 // this is called whenever a SdrObject must be created for a empty api shape wrapper
401 SdrObject * SdGenericDrawPage::_CreateSdrObject( const Reference< drawing::XShape >& xShape ) throw()
402 {
403 if( NULL == SvxFmDrawPage::mpPage || !xShape.is() )
404 return NULL;
405
406 String aType( xShape->getShapeType() );
407 const String aPrefix( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.") );
408 if(aType.CompareTo( aPrefix, aPrefix.Len() ) != 0)
409 {
410 SdrObject* pObj = SvxFmDrawPage::_CreateSdrObject( xShape );
411 if( pObj && ( (pObj->GetObjInventor() != SdrInventor) || (pObj->GetObjIdentifier() != OBJ_PAGE) ) )
412 {
413 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
414 if( pDoc )
415 pObj->NbcSetStyleSheet( pDoc->GetDefaultStyleSheet(), sal_True );
416 }
417 return pObj;
418 }
419
420 aType = aType.Copy( aPrefix.Len() );
421
422 PresObjKind eObjKind = PRESOBJ_NONE;
423
424 if( aType.EqualsAscii( "TitleTextShape" ) )
425 {
426 eObjKind = PRESOBJ_TITLE;
427 }
428 else if( aType.EqualsAscii( "OutlinerShape" ) )
429 {
430 eObjKind = PRESOBJ_OUTLINE;
431 }
432 else if( aType.EqualsAscii( "SubtitleShape" ) )
433 {
434 eObjKind = PRESOBJ_TEXT;
435 }
436 else if( aType.EqualsAscii( "OLE2Shape" ) )
437 {
438 eObjKind = PRESOBJ_OBJECT;
439 }
440 else if( aType.EqualsAscii( "ChartShape" ) )
441 {
442 eObjKind = PRESOBJ_CHART;
443 }
444 else if( aType.EqualsAscii( "TableShape" ) )
445 {
446 eObjKind = PRESOBJ_TABLE;
447 }
448 else if( aType.EqualsAscii( "GraphicObjectShape" ) )
449 {
450 #ifdef STARIMAGE_AVAILABLE
451 eObjKind = PRESOBJ_IMAGE;
452 #else
453 eObjKind = PRESOBJ_GRAPHIC;
454 #endif
455 }
456 else if( aType.EqualsAscii( "OrgChartShape" ) )
457 {
458 eObjKind = PRESOBJ_ORGCHART;
459 }
460 else if( aType.EqualsAscii( "PageShape" ) )
461 {
462 if( GetPage()->GetPageKind() == PK_NOTES && GetPage()->IsMasterPage() )
463 eObjKind = PRESOBJ_TITLE;
464 else
465 eObjKind = PRESOBJ_PAGE;
466 }
467 else if( aType.EqualsAscii( "NotesShape" ) )
468 {
469 eObjKind = PRESOBJ_NOTES;
470 }
471 else if( aType.EqualsAscii( "HandoutShape" ) )
472 {
473 eObjKind = PRESOBJ_HANDOUT;
474 }
475 else if( aType.EqualsAscii( "FooterShape" ) )
476 {
477 eObjKind = PRESOBJ_FOOTER;
478 }
479 else if( aType.EqualsAscii( "HeaderShape" ) )
480 {
481 eObjKind = PRESOBJ_HEADER;
482 }
483 else if( aType.EqualsAscii( "SlideNumberShape" ) )
484 {
485 eObjKind = PRESOBJ_SLIDENUMBER;
486 }
487 else if( aType.EqualsAscii( "DateTimeShape" ) )
488 {
489 eObjKind = PRESOBJ_DATETIME;
490 }
491
492 Rectangle aRect( eObjKind == PRESOBJ_TITLE ? GetPage()->GetTitleRect() : GetPage()->GetLayoutRect() );
493
494 const awt::Point aPos( aRect.Left(), aRect.Top() );
495 xShape->setPosition( aPos );
496
497 const awt::Size aSize( aRect.GetWidth(), aRect.GetHeight() );
498 xShape->setSize( aSize );
499
500 SdrObject *pPresObj = GetPage()->CreatePresObj( eObjKind, FALSE, aRect, sal_True );
501
502 if( pPresObj )
503 pPresObj->SetUserCall( GetPage() );
504
505 return pPresObj;
506 }
507
508 // XInterface
509 Any SAL_CALL SdGenericDrawPage::queryInterface( const uno::Type & rType )
510 throw(uno::RuntimeException)
511 {
512 Any aAny;
513
514 QUERYINT( beans::XPropertySet );
515 else QUERYINT( container::XNamed );
516 else QUERYINT( util::XReplaceable );
517 else QUERYINT( util::XSearchable );
518 else QUERYINT( document::XLinkTargetSupplier );
519 else QUERYINT( drawing::XShapeCombiner );
520 else QUERYINT( drawing::XShapeBinder );
521 else QUERYINT( beans::XMultiPropertySet );
522 else if( rType == ITYPE( XAnimationNodeSupplier ) )
523 {
524 if( mbIsImpressDocument )
525 {
526 const PageKind ePageKind = GetPage() ? GetPage()->GetPageKind() : PK_STANDARD;
527
528 if( ePageKind == PK_STANDARD )
529 return makeAny( Reference< XAnimationNodeSupplier >( this ) );
530 }
531 }
532 else
533 return SvxDrawPage::queryInterface( rType );
534
535 return aAny;
536 }
537
538 // XPropertySet
539 Reference< beans::XPropertySetInfo > SAL_CALL SdGenericDrawPage::getPropertySetInfo()
540 throw(uno::RuntimeException)
541 {
542 OGuard aGuard( Application::GetSolarMutex() );
543 throwIfDisposed();
544 return mpPropSet->getPropertySetInfo();
545 }
546
547 void SAL_CALL SdGenericDrawPage::setPropertyValue( const OUString& aPropertyName, const Any& aValue )
548 throw(beans::UnknownPropertyException, beans::PropertyVetoException, lang::IllegalArgumentException, lang::WrappedTargetException, uno::RuntimeException)
549 {
550 OGuard aGuard( Application::GetSolarMutex() );
551
552 throwIfDisposed();
553
554 const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(aPropertyName);
555
556 switch( pEntry ? pEntry->nWID : -1 )
557 {
558 case WID_NAVORDER:
559 setNavigationOrder( aValue );
560 break;
561 case WID_PAGE_LEFT:
562 case WID_PAGE_RIGHT:
563 case WID_PAGE_TOP:
564 case WID_PAGE_BOTTOM:
565 case WID_PAGE_LAYOUT:
566 case WID_PAGE_DURATION:
567 case WID_PAGE_CHANGE:
568 {
569 sal_Int32 nValue = 0;
570 if(!(aValue >>= nValue))
571 throw lang::IllegalArgumentException();
572
573 switch( pEntry->nWID )
574 {
575 case WID_PAGE_LEFT:
576 SetLftBorder(nValue);
577 break;
578 case WID_PAGE_RIGHT:
579 SetRgtBorder( nValue );
580 break;
581 case WID_PAGE_TOP:
582 SetUppBorder( nValue );
583 break;
584 case WID_PAGE_BOTTOM:
585 SetLwrBorder( nValue );
586 break;
587 case WID_PAGE_CHANGE:
588 GetPage()->SetPresChange( (PresChange)nValue );
589 break;
590 case WID_PAGE_LAYOUT:
591 GetPage()->SetAutoLayout( (AutoLayout)nValue, sal_True );
592 break;
593 case WID_PAGE_DURATION:
594 GetPage()->SetTime((sal_uInt32)nValue);
595 break;
596 }
597 break;
598 }
599 case WID_PAGE_WIDTH:
600 {
601 sal_Int32 nWidth = 0;
602 if(!(aValue >>= nWidth))
603 throw lang::IllegalArgumentException();
604
605 SetWidth( nWidth );
606 break;
607 }
608 case WID_PAGE_HEIGHT:
609 {
610 sal_Int32 nHeight = 0;
611 if(!(aValue >>= nHeight))
612 throw lang::IllegalArgumentException();
613
614 SetHeight( nHeight );
615 break;
616 }
617 case WID_PAGE_ORIENT:
618 {
619 sal_Int32 nEnum = 0;
620 if(!::cppu::enum2int( nEnum, aValue ))
621 throw lang::IllegalArgumentException();
622
623 Orientation eOri = (((view::PaperOrientation)nEnum) == view::PaperOrientation_PORTRAIT)?ORIENTATION_PORTRAIT:ORIENTATION_LANDSCAPE;
624
625 if( eOri != GetPage()->GetOrientation() )
626 {
627 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
628 const PageKind ePageKind = GetPage()->GetPageKind();
629
630 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
631 for (i = 0; i < nPageCnt; i++)
632 {
633 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
634 pPage->SetOrientation( eOri );
635 }
636
637 nPageCnt = pDoc->GetSdPageCount(ePageKind);
638
639 for (i = 0; i < nPageCnt; i++)
640 {
641 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
642 pPage->SetOrientation( eOri );
643 }
644 }
645 break;
646 }
647 case WID_PAGE_EFFECT:
648 {
649 sal_Int32 nEnum = 0;
650 if(!::cppu::enum2int( nEnum, aValue ))
651 throw lang::IllegalArgumentException();
652
653 GetPage()->SetFadeEffect( (presentation::FadeEffect)nEnum );
654 break;
655 }
656 case WID_PAGE_BACK:
657 setBackground( aValue );
658 break;
659 case WID_PAGE_SPEED:
660 {
661 sal_Int32 nEnum = 0;
662 if(!::cppu::enum2int( nEnum, aValue ))
663 throw lang::IllegalArgumentException();
664
665 GetPage()->setTransitionDuration( nEnum == 0 ? 3.0 : (nEnum == 1 ? 2.0 : 1.0 ) );
666 break;
667 }
668 case WID_PAGE_VISIBLE :
669 {
670 sal_Bool bVisible = sal_False;
671 if( ! ( aValue >>= bVisible ) )
672 throw lang::IllegalArgumentException();
673 GetPage()->SetExcluded( bVisible == FALSE );
674 break;
675 }
676 case WID_PAGE_SOUNDFILE :
677 {
678 OUString aURL;
679 if( aValue >>= aURL )
680 {
681 GetPage()->SetSoundFile( aURL );
682 GetPage()->SetSound( aURL.getLength() != 0 ? sal_True : sal_False );
683 break;
684 }
685 else
686 {
687 sal_Bool bStopSound = sal_False;
688 if( aValue >>= bStopSound )
689 {
690 GetPage()->SetStopSound( bStopSound ? true : false );
691 break;
692 }
693 }
694
695
696 throw lang::IllegalArgumentException();
697 }
698 case WID_LOOP_SOUND:
699 {
700 sal_Bool bLoop = sal_False;
701 if( ! (aValue >>= bLoop) )
702 throw lang::IllegalArgumentException();
703
704 GetPage()->SetLoopSound( bLoop ? true : false );
705 break;
706 }
707 case WID_PAGE_BACKFULL:
708 {
709 sal_Bool bFullSize = sal_False;
710 if( ! ( aValue >>= bFullSize ) )
711 throw lang::IllegalArgumentException();
712 GetPage()->SetBackgroundFullSize( bFullSize );
713 break;
714 }
715 case WID_PAGE_BACKVIS:
716 {
717 sal_Bool bVisible = sal_False;
718 if( ! ( aValue >>= bVisible ) )
719 throw lang::IllegalArgumentException();
720
721 SdrPage* pPage = GetPage();
722 if( pPage )
723 {
724 SdDrawDocument* pDoc = (SdDrawDocument*)pPage->GetModel();
725 if( pDoc->GetMasterPageCount() )
726 {
727 SdrLayerAdmin& rLayerAdmin = pDoc->GetLayerAdmin();
728 SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
729 aVisibleLayers.Set(rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE), bVisible);
730 pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
731 }
732 }
733 break;
734 }
735 case WID_PAGE_BACKOBJVIS:
736 {
737 sal_Bool bVisible = sal_False;
738 if( ! ( aValue >>= bVisible ) )
739 throw lang::IllegalArgumentException();
740
741 SdrPage* pPage = GetPage();
742 if( pPage )
743 {
744 SdDrawDocument* pDoc = (SdDrawDocument*)pPage->GetModel();
745 if( pDoc->GetMasterPageCount() )
746 {
747 SdrLayerAdmin& rLayerAdmin = pDoc->GetLayerAdmin();
748 SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
749 aVisibleLayers.Set(rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE), bVisible);
750 pPage->TRG_SetMasterPageVisibleLayers(aVisibleLayers);
751 }
752 }
753
754 break;
755 }
756 case WID_PAGE_USERATTRIBS:
757 {
758 if( !GetPage()->setAlienAttributes( aValue ) )
759 throw lang::IllegalArgumentException();
760 break;
761 }
762 case WID_PAGE_BOOKMARK:
763 {
764 OUString aBookmarkURL;
765 if( ! ( aValue >>= aBookmarkURL ) )
766 throw lang::IllegalArgumentException();
767
768 setBookmarkURL( aBookmarkURL );
769 break;
770 }
771
772 case WID_PAGE_HEADERVISIBLE:
773 case WID_PAGE_HEADERTEXT:
774 case WID_PAGE_FOOTERVISIBLE:
775 case WID_PAGE_FOOTERTEXT:
776 case WID_PAGE_PAGENUMBERVISIBLE:
777 case WID_PAGE_DATETIMEVISIBLE:
778 case WID_PAGE_DATETIMEFIXED:
779 case WID_PAGE_DATETIMETEXT:
780 case WID_PAGE_DATETIMEFORMAT:
781 {
782 sd::HeaderFooterSettings aHeaderFooterSettings( GetPage()->getHeaderFooterSettings() );
783
784 switch( pEntry->nWID )
785 {
786 case WID_PAGE_HEADERVISIBLE:
787 {
788 sal_Bool bVisible = sal_False;
789 if( ! ( aValue >>= bVisible ) )
790 throw lang::IllegalArgumentException();
791
792 aHeaderFooterSettings.mbHeaderVisible = bVisible;
793 break;
794 }
795 case WID_PAGE_HEADERTEXT:
796 {
797 OUString aText;
798 if( ! ( aValue >>= aText ) )
799 throw lang::IllegalArgumentException();
800
801 aHeaderFooterSettings.maHeaderText = aText;
802 break;
803 }
804 case WID_PAGE_FOOTERVISIBLE:
805 {
806 sal_Bool bVisible = sal_False;
807 if( ! ( aValue >>= bVisible ) )
808 throw lang::IllegalArgumentException();
809
810 aHeaderFooterSettings.mbFooterVisible = bVisible;
811 break;
812 }
813 case WID_PAGE_FOOTERTEXT:
814 {
815 OUString aText;
816 if( ! ( aValue >>= aText ) )
817 throw lang::IllegalArgumentException();
818
819 aHeaderFooterSettings.maFooterText = aText;
820 break;
821 }
822 case WID_PAGE_PAGENUMBERVISIBLE:
823 {
824 sal_Bool bVisible = sal_False;
825 if( ! ( aValue >>= bVisible ) )
826 throw lang::IllegalArgumentException();
827
828 aHeaderFooterSettings.mbSlideNumberVisible = bVisible;
829 break;
830 }
831 case WID_PAGE_DATETIMEVISIBLE:
832 {
833 sal_Bool bVisible = sal_False;
834 if( ! ( aValue >>= bVisible ) )
835 throw lang::IllegalArgumentException();
836
837 aHeaderFooterSettings.mbDateTimeVisible = bVisible;
838 break;
839 }
840 case WID_PAGE_DATETIMEFIXED:
841 {
842 sal_Bool bVisible = sal_False;
843 if( ! ( aValue >>= bVisible ) )
844 throw lang::IllegalArgumentException();
845
846 aHeaderFooterSettings.mbDateTimeIsFixed = bVisible;
847 break;
848 }
849 case WID_PAGE_DATETIMETEXT:
850 {
851 OUString aText;
852 if( ! ( aValue >>= aText ) )
853 throw lang::IllegalArgumentException();
854
855 aHeaderFooterSettings.maDateTimeText = aText;
856 break;
857 }
858 case WID_PAGE_DATETIMEFORMAT:
859 {
860 sal_Int32 nValue = 0;
861 if( ! ( aValue >>= nValue ) )
862 throw lang::IllegalArgumentException();
863
864 aHeaderFooterSettings.meDateTimeFormat = nValue;
865 break;
866 }
867 }
868
869 if( !(aHeaderFooterSettings == GetPage()->getHeaderFooterSettings()) )
870 GetPage()->setHeaderFooterSettings( aHeaderFooterSettings );
871
872 break;
873 }
874
875 case WID_PAGE_LDBITMAP:
876 case WID_PAGE_LDNAME:
877 case WID_PAGE_NUMBER:
878 case WID_PAGE_ISDARK:
879 throw beans::PropertyVetoException();
880
881 case WID_TRANSITION_TYPE:
882 {
883 sal_Int16 nValue = 0;
884 if( ! ( aValue >>= nValue ) )
885 throw lang::IllegalArgumentException();
886
887 GetPage()->setTransitionType( nValue );
888 break;
889 }
890
891 case WID_TRANSITION_SUBTYPE:
892 {
893 sal_Int16 nValue = 0;
894 if( ! ( aValue >>= nValue ) )
895 throw lang::IllegalArgumentException();
896
897 GetPage()->setTransitionSubtype( nValue );
898 break;
899 }
900
901 case WID_TRANSITION_DIRECTION:
902 {
903 sal_Bool bValue = sal_False;
904 if( ! ( aValue >>= bValue ) )
905 throw lang::IllegalArgumentException();
906
907 GetPage()->setTransitionDirection( bValue );
908 break;
909 }
910
911 case WID_TRANSITION_FADE_COLOR:
912 {
913 sal_Int32 nValue = 0;
914 if( ! ( aValue >>= nValue ) )
915 throw lang::IllegalArgumentException();
916
917 GetPage()->setTransitionFadeColor( nValue );
918 break;
919 }
920
921 case WID_TRANSITION_DURATION:
922 {
923 double fValue = 0.0;
924 if( ! ( aValue >>= fValue ) )
925 throw lang::IllegalArgumentException();
926
927 GetPage()->setTransitionDuration( fValue );
928 break;
929 }
930
931 default:
932 throw beans::UnknownPropertyException();
933 }
934
935 GetModel()->SetModified();
936 }
937
938 /***********************************************************************
939 * *
940 ***********************************************************************/
941 Any SAL_CALL SdGenericDrawPage::getPropertyValue( const OUString& PropertyName )
942 throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException)
943 {
944 OGuard aGuard( Application::GetSolarMutex() );
945
946 throwIfDisposed();
947
948 uno::Any aAny;
949
950 const SfxItemPropertySimpleEntry* pEntry = mpPropSet->getPropertyMapEntry(PropertyName);
951
952 switch( pEntry ? pEntry->nWID : -1 )
953 {
954 case WID_NAVORDER:
955 aAny = getNavigationOrder();
956 break;
957 case WID_PAGE_LEFT:
958 aAny <<= (sal_Int32)( GetPage()->GetLftBorder() );
959 break;
960 case WID_PAGE_RIGHT:
961 aAny <<= (sal_Int32)( GetPage()->GetRgtBorder() );
962 break;
963 case WID_PAGE_TOP:
964 aAny <<= (sal_Int32)( GetPage()->GetUppBorder() );
965 break;
966 case WID_PAGE_BOTTOM:
967 aAny <<= (sal_Int32)( GetPage()->GetLwrBorder() );
968 break;
969 case WID_PAGE_WIDTH:
970 aAny <<= (sal_Int32)( GetPage()->GetSize().getWidth() );
971 break;
972 case WID_PAGE_HEIGHT:
973 aAny <<= (sal_Int32)( GetPage()->GetSize().getHeight() );
974 break;
975 case WID_PAGE_ORIENT:
976 aAny = ::cppu::int2enum( (sal_Int32)((GetPage()->GetOrientation() == ORIENTATION_PORTRAIT)? view::PaperOrientation_PORTRAIT: view::PaperOrientation_LANDSCAPE), ::getCppuType((const view::PaperOrientation*)0) );
977 break;
978 case WID_PAGE_EFFECT:
979 aAny = ::cppu::int2enum( (sal_Int32)GetPage()->GetFadeEffect(), ::getCppuType((const presentation::FadeEffect*)0) );
980 break;
981 case WID_PAGE_CHANGE:
982 aAny <<= (sal_Int32)( GetPage()->GetPresChange() );
983 break;
984 case WID_PAGE_SPEED:
985 {
986 const double fDuration = GetPage()->getTransitionDuration();
987 aAny = ::cppu::int2enum( fDuration < 2.0 ? 2 : (fDuration > 2.0 ? 0 : 1), ::getCppuType((const presentation::AnimationSpeed*)0) );
988 }
989 break;
990 case WID_PAGE_LAYOUT:
991 aAny <<= (sal_Int16)( GetPage()->GetAutoLayout() );
992 break;
993 case WID_PAGE_NUMBER:
994 aAny <<= (sal_Int16)((sal_uInt16)((GetPage()->GetPageNum()-1)>>1) + 1);
995 break;
996 case WID_PAGE_DURATION:
997 aAny <<= (sal_Int32)(GetPage()->GetTime());
998 break;
999 case WID_PAGE_LDNAME:
1000 {
1001 const OUString aName( GetPage()->GetName() );
1002 aAny <<= aName;
1003 break;
1004 }
1005 case WID_PAGE_LDBITMAP:
1006 {
1007 BOOL bHC = Application::GetSettings().GetStyleSettings().GetWindowColor().IsDark();
1008 Reference< awt::XBitmap > xBitmap(
1009 VCLUnoHelper::CreateBitmap( BitmapEx( SdResId( bHC ? BMP_PAGE_H : BMP_PAGE ) ) ) );
1010 aAny <<= xBitmap;
1011 }
1012 break;
1013 case WID_PAGE_BACK:
1014 getBackground( aAny );
1015 break;
1016 case WID_PAGE_PREVIEW :
1017 {
1018 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1019 if ( pDoc )
1020 {
1021 ::sd::DrawDocShell* pDocShell = pDoc->GetDocSh();
1022 if ( pDocShell )
1023 {
1024 sal_uInt16 nPgNum = 0;
1025 sal_uInt16 nPageCount = pDoc->GetSdPageCount( PK_STANDARD );
1026 sal_uInt16 nPageNumber = (sal_uInt16)( ( GetPage()->GetPageNum() - 1 ) >> 1 );
1027 while( nPgNum < nPageCount )
1028 {
1029 pDoc->SetSelected( pDoc->GetSdPage( nPgNum, PK_STANDARD ), nPgNum == nPageNumber );
1030 nPgNum++;
1031 }
1032 ::boost::shared_ptr<GDIMetaFile> pMetaFile =
1033 pDocShell->GetPreviewMetaFile();
1034 if ( pMetaFile )
1035 {
1036 Point aPoint;
1037 Size aSize( GetPage()->GetSize() );
1038 pMetaFile->AddAction( (MetaAction*) new MetaFillColorAction( COL_WHITE, TRUE ), 0 );
1039 pMetaFile->AddAction( (MetaAction*) new MetaRectAction( Rectangle( aPoint, aSize ) ), 1 );
1040 pMetaFile->SetPrefMapMode( MAP_100TH_MM );
1041 pMetaFile->SetPrefSize( aSize );
1042
1043 SvMemoryStream aDestStrm( 65535, 65535 );
1044 ConvertGDIMetaFileToWMF( *pMetaFile, aDestStrm, NULL, sal_False );
1045 Sequence<sal_Int8> aSeq( (sal_Int8*)aDestStrm.GetData(), aDestStrm.Tell() );
1046 aAny <<= aSeq;
1047 }
1048 }
1049 }
1050 }
1051 break;
1052
1053 case WID_PAGE_PREVIEWBITMAP :
1054 {
1055 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1056 if ( pDoc )
1057 {
1058 ::sd::DrawDocShell* pDocShell = pDoc->GetDocSh();
1059 if ( pDocShell )
1060 {
1061 sal_uInt16 nPgNum = 0;
1062 sal_uInt16 nPageCount = pDoc->GetSdPageCount( PK_STANDARD );
1063 sal_uInt16 nPageNumber = (sal_uInt16)( ( GetPage()->GetPageNum() - 1 ) >> 1 );
1064 while( nPgNum < nPageCount )
1065 {
1066 pDoc->SetSelected( pDoc->GetSdPage( nPgNum, PK_STANDARD ), nPgNum == nPageNumber );
1067 nPgNum++;
1068 }
1069 ::boost::shared_ptr<GDIMetaFile> pMetaFile =
1070 pDocShell->GetPreviewMetaFile();
1071 BitmapEx aBitmap;
1072 if ( pMetaFile && pMetaFile->CreateThumbnail( 160, /* magic value taken from GraphicHelper::getThumbnailFormatFromGDI_Impl() */
1073 aBitmap ) )
1074 {
1075 SvMemoryStream aMemStream;
1076 aBitmap.GetBitmap().Write( aMemStream, FALSE, FALSE );
1077 uno::Sequence<sal_Int8> aSeq( (sal_Int8*)aMemStream.GetData(), aMemStream.Tell() );
1078 aAny <<= aSeq;
1079 }
1080 }
1081 }
1082 }
1083 break;
1084
1085 case WID_PAGE_VISIBLE :
1086 {
1087 sal_Bool bVisible = GetPage()->IsExcluded() == FALSE;
1088 aAny <<= Any( &bVisible, ::getBooleanCppuType() );
1089 break;
1090 }
1091
1092 case WID_PAGE_SOUNDFILE :
1093 {
1094 if( GetPage()->IsStopSound() )
1095 {
1096 aAny <<= sal_True;
1097 }
1098 else
1099 {
1100 OUString aURL;
1101 if( GetPage()->IsSoundOn() )
1102 aURL = GetPage()->GetSoundFile();
1103 aAny <<= aURL;
1104 }
1105 break;
1106 }
1107 case WID_LOOP_SOUND:
1108 {
1109 aAny <<= (sal_Bool)GetPage()->IsLoopSound();
1110 break;
1111 }
1112 case WID_PAGE_BACKFULL:
1113 {
1114 sal_Bool bFullSize = GetPage()->IsBackgroundFullSize();
1115 aAny = Any( &bFullSize, ::getBooleanCppuType() );
1116 break;
1117 }
1118 case WID_PAGE_BACKVIS:
1119 {
1120 SdrPage* pPage = GetPage();
1121 if( pPage )
1122 {
1123 SdDrawDocument* pDoc = (SdDrawDocument*)pPage->GetModel();
1124 if( pDoc->GetMasterPageCount() )
1125 {
1126 SdrLayerAdmin& rLayerAdmin = pDoc->GetLayerAdmin();
1127 SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
1128 aAny <<= (sal_Bool)aVisibleLayers.IsSet(rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRND)), FALSE));
1129 }
1130 else
1131 {
1132 aAny <<= (sal_Bool)sal_False;
1133 }
1134 }
1135 break;
1136 }
1137 case WID_PAGE_BACKOBJVIS:
1138 {
1139 SdrPage* pPage = GetPage();
1140 if( pPage )
1141 {
1142 SdDrawDocument* pDoc = (SdDrawDocument*)pPage->GetModel();
1143 if( pDoc->GetMasterPageCount() )
1144 {
1145 SdrLayerAdmin& rLayerAdmin = pDoc->GetLayerAdmin();
1146 SetOfByte aVisibleLayers = pPage->TRG_GetMasterPageVisibleLayers();
1147 aAny <<= (sal_Bool)aVisibleLayers.IsSet(rLayerAdmin.GetLayerID(String(SdResId(STR_LAYER_BCKGRNDOBJ)), FALSE));
1148 }
1149 else
1150 {
1151 aAny <<= (sal_Bool)sal_False;
1152 }
1153 }
1154 break;
1155 }
1156 case WID_PAGE_USERATTRIBS:
1157 {
1158 GetPage()->getAlienAttributes( aAny );
1159 break;
1160 }
1161 case WID_PAGE_BOOKMARK:
1162 {
1163 aAny <<= getBookmarkURL();
1164 break;
1165 }
1166 case WID_PAGE_ISDARK:
1167 {
1168 aAny <<= (sal_Bool)GetPage()->GetPageBackgroundColor().IsDark();
1169 break;
1170 }
1171 case WID_PAGE_HEADERVISIBLE:
1172 aAny <<= (sal_Bool)GetPage()->getHeaderFooterSettings().mbHeaderVisible;
1173 break;
1174 case WID_PAGE_HEADERTEXT:
1175 {
1176 const OUString aText( GetPage()->getHeaderFooterSettings().maHeaderText );
1177 aAny <<= aText;
1178 }
1179 break;
1180 case WID_PAGE_FOOTERVISIBLE:
1181 aAny <<= (sal_Bool)GetPage()->getHeaderFooterSettings().mbFooterVisible;
1182 break;
1183 case WID_PAGE_FOOTERTEXT:
1184 {
1185 const OUString aText( GetPage()->getHeaderFooterSettings().maFooterText );
1186 aAny <<= aText;
1187 }
1188 break;
1189 case WID_PAGE_PAGENUMBERVISIBLE:
1190 aAny <<= (sal_Bool)GetPage()->getHeaderFooterSettings().mbSlideNumberVisible;
1191 break;
1192 case WID_PAGE_DATETIMEVISIBLE:
1193 aAny <<= (sal_Bool)GetPage()->getHeaderFooterSettings().mbDateTimeVisible;
1194 break;
1195 case WID_PAGE_DATETIMEFIXED:
1196 aAny <<= (sal_Bool)GetPage()->getHeaderFooterSettings().mbDateTimeIsFixed;
1197 break;
1198 case WID_PAGE_DATETIMETEXT:
1199 {
1200 const OUString aText( GetPage()->getHeaderFooterSettings().maDateTimeText );
1201 aAny <<= aText;
1202 }
1203 break;
1204 case WID_PAGE_DATETIMEFORMAT:
1205 aAny <<= (sal_Int32)GetPage()->getHeaderFooterSettings().meDateTimeFormat;
1206 break;
1207
1208 case WID_TRANSITION_TYPE:
1209 aAny <<= GetPage()->getTransitionType();
1210 break;
1211
1212 case WID_TRANSITION_SUBTYPE:
1213 aAny <<= GetPage()->getTransitionSubtype();
1214 break;
1215
1216 case WID_TRANSITION_DIRECTION:
1217 aAny <<= GetPage()->getTransitionDirection();
1218 break;
1219
1220 case WID_TRANSITION_FADE_COLOR:
1221 aAny <<= GetPage()->getTransitionFadeColor();
1222 break;
1223
1224 case WID_TRANSITION_DURATION:
1225 aAny <<= GetPage()->getTransitionDuration();
1226 break;
1227
1228 default:
1229 throw beans::UnknownPropertyException();
1230 }
1231 return aAny;
1232 }
1233
1234 void SAL_CALL SdGenericDrawPage::addPropertyChangeListener( const OUString& , const Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1235 void SAL_CALL SdGenericDrawPage::removePropertyChangeListener( const OUString& , const Reference< beans::XPropertyChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1236 void SAL_CALL SdGenericDrawPage::addVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1237 void SAL_CALL SdGenericDrawPage::removeVetoableChangeListener( const OUString& , const Reference< beans::XVetoableChangeListener >& ) throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException) {}
1238
1239 // XMultiPropertySet
1240 void SAL_CALL SdGenericDrawPage::setPropertyValues( const Sequence< OUString >& aPropertyNames, const Sequence< Any >& aValues ) throw (beans::PropertyVetoException, ::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::lang::WrappedTargetException, RuntimeException )
1241 {
1242 if( aPropertyNames.getLength() != aValues.getLength() )
1243 throw lang::IllegalArgumentException();
1244
1245 const OUString* pNames = aPropertyNames.getConstArray();
1246 const Any* pValues = aValues.getConstArray();
1247 sal_uInt32 nCount = aValues.getLength();
1248 while( nCount-- )
1249 {
1250 try
1251 {
1252 setPropertyValue( *pNames++, *pValues++ );
1253 }
1254 catch( beans::UnknownPropertyException& )
1255 {
1256 // ignore for multi property set
1257 // todo: optimize this!
1258 }
1259 }
1260 }
1261
1262 Sequence< Any > SAL_CALL SdGenericDrawPage::getPropertyValues( const Sequence< OUString >& aPropertyNames ) throw (RuntimeException)
1263 {
1264 const OUString* pNames = aPropertyNames.getConstArray();
1265 sal_uInt32 nCount = aPropertyNames.getLength();
1266 Sequence< Any > aValues( nCount );
1267 Any* pValues = aValues.getArray();
1268 while( nCount-- )
1269 {
1270 Any aValue;
1271 try
1272 {
1273 aValue = getPropertyValue( *pNames++ );
1274 }
1275 catch( beans::UnknownPropertyException& )
1276 {
1277 // ignore for multi property set
1278 // todo: optimize this!
1279 }
1280 *pValues++ = aValue;
1281 }
1282 return aValues;
1283 }
1284
1285 void SAL_CALL SdGenericDrawPage::addPropertiesChangeListener( const Sequence< OUString >& , const Reference< beans::XPropertiesChangeListener >& ) throw (RuntimeException)
1286 {
1287 }
1288
1289 void SAL_CALL SdGenericDrawPage::removePropertiesChangeListener( const Reference< beans::XPropertiesChangeListener >& ) throw (RuntimeException)
1290 {
1291 }
1292
1293 void SAL_CALL SdGenericDrawPage::firePropertiesChangeEvent( const Sequence< OUString >& , const Reference< beans::XPropertiesChangeListener >& ) throw (RuntimeException)
1294 {
1295 }
1296
1297 Reference< drawing::XShape > SdGenericDrawPage::_CreateShape( SdrObject *pObj ) const throw()
1298 {
1299 DBG_ASSERT( GetPage(), "SdGenericDrawPage::_CreateShape(), can't create shape for disposed page!" );
1300 DBG_ASSERT( pObj, "SdGenericDrawPage::_CreateShape(), invalid call with pObj == 0!" );
1301
1302 if( GetPage() && pObj )
1303 {
1304 PresObjKind eKind = GetPage()->GetPresObjKind(pObj);
1305
1306 SvxShape* pShape = NULL;
1307
1308 if(pObj->GetObjInventor() == SdrInventor)
1309 {
1310 sal_uInt32 nInventor = pObj->GetObjIdentifier();
1311 switch( nInventor )
1312 {
1313 case OBJ_TITLETEXT:
1314 pShape = new SvxShapeText( pObj );
1315 if( GetPage()->GetPageKind() == PK_NOTES && GetPage()->IsMasterPage() )
1316 {
1317 // fake a empty PageShape if its a title shape on the master page
1318 pShape->SetShapeType(OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.PageShape")));
1319 }
1320 else
1321 {
1322 pShape->SetShapeType(OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.TitleTextShape")));
1323 }
1324 eKind = PRESOBJ_NONE;
1325 break;
1326 case OBJ_OUTLINETEXT:
1327 pShape = new SvxShapeText( pObj );
1328 pShape->SetShapeType(OUString( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation.OutlinerShape")));
1329 eKind = PRESOBJ_NONE;
1330 break;
1331 }
1332 }
1333
1334 Reference< drawing::XShape > xShape( pShape );
1335
1336 if(!xShape.is())
1337 xShape = SvxFmDrawPage::_CreateShape( pObj );
1338
1339
1340 if( eKind != PRESOBJ_NONE )
1341 {
1342 String aShapeType( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.presentation."));
1343
1344 switch( eKind )
1345 {
1346 case PRESOBJ_TITLE:
1347 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("TitleTextShape") );
1348 break;
1349 case PRESOBJ_OUTLINE:
1350 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("OutlinerShape") );
1351 break;
1352 case PRESOBJ_TEXT:
1353 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("SubtitleShape") );
1354 break;
1355 case PRESOBJ_GRAPHIC:
1356 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("GraphicObjectShape") );
1357 break;
1358 case PRESOBJ_OBJECT:
1359 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("OLE2Shape") );
1360 break;
1361 case PRESOBJ_CHART:
1362 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("ChartShape") );
1363 break;
1364 case PRESOBJ_ORGCHART:
1365 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("OrgChartShape") );
1366 break;
1367 case PRESOBJ_TABLE:
1368 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("TableShape") );
1369 break;
1370 case PRESOBJ_BACKGROUND:
1371 DBG_ASSERT( sal_False, "Danger! Someone got hold of the horrible background shape!" );
1372 break;
1373 case PRESOBJ_PAGE:
1374 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("PageShape") );
1375 break;
1376 case PRESOBJ_HANDOUT:
1377 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("HandoutShape") );
1378 break;
1379 case PRESOBJ_NOTES:
1380 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("NotesShape") );
1381 break;
1382 case PRESOBJ_FOOTER:
1383 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("FooterShape") );
1384 break;
1385 case PRESOBJ_HEADER:
1386 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("HeaderShape") );
1387 break;
1388 case PRESOBJ_SLIDENUMBER:
1389 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("SlideNumberShape") );
1390 break;
1391 case PRESOBJ_DATETIME:
1392 aShapeType += String( RTL_CONSTASCII_USTRINGPARAM("DateTimeShape") );
1393 break;
1394 case PRESOBJ_NONE:
1395 case PRESOBJ_IMAGE:
1396 case PRESOBJ_MAX:
1397 break;
1398 }
1399
1400 if( !pShape )
1401 pShape = SvxShape::getImplementation( xShape );
1402
1403 if( pShape )
1404 pShape->SetShapeType( aShapeType );
1405 }
1406
1407 // SdXShape aggregiert SvxShape
1408 new SdXShape( SvxShape::getImplementation( xShape ), GetModel() );
1409 return xShape;
1410 }
1411 else
1412 {
1413 return SvxFmDrawPage::_CreateShape( pObj );
1414 }
1415
1416 }
1417
1418 //----------------------------------------------------------------------
1419
1420 // XServiceInfo
1421 Sequence< OUString > SAL_CALL SdGenericDrawPage::getSupportedServiceNames()
1422 throw(uno::RuntimeException)
1423 {
1424 Sequence< OUString > aSeq( SvxFmDrawPage::getSupportedServiceNames() );
1425 SvxServiceInfoHelper::addToSequence( aSeq, 3, "com.sun.star.drawing.GenericDrawPage",
1426 "com.sun.star.document.LinkTarget",
1427 "com.sun.star.document.LinkTargetSupplier");
1428 return aSeq;
1429 }
1430
1431 //----------------------------------------------------------------------
1432
1433 // XLinkTargetSupplier
1434 Reference< container::XNameAccess > SAL_CALL SdGenericDrawPage::getLinks( )
1435 throw(uno::RuntimeException)
1436 {
1437 return new SdPageLinkTargets( (SdGenericDrawPage*)this );
1438 }
1439
1440 //----------------------------------------------------------------------
1441
1442 void SdGenericDrawPage::setBackground( const Any& ) throw(lang::IllegalArgumentException)
1443 {
1444 DBG_ERROR( "Don't call me, I'm useless!" );
1445 }
1446
1447 //----------------------------------------------------------------------
1448
1449 void SdGenericDrawPage::getBackground( Any& ) throw()
1450 {
1451 DBG_ERROR( "Don't call me, I'm useless!" );
1452 }
1453
1454 //----------------------------------------------------------------------
1455
1456 OUString SdGenericDrawPage::getBookmarkURL() const
1457 {
1458 OUStringBuffer aRet;
1459 if( SvxFmDrawPage::mpPage )
1460 {
1461 OUString aFileName( static_cast<SdPage*>(SvxFmDrawPage::mpPage)->GetFileName() );
1462 if( aFileName.getLength() )
1463 {
1464 const OUString aBookmarkName( SdDrawPage::getPageApiNameFromUiName( static_cast<SdPage*>(SvxFmDrawPage::mpPage)->GetBookmarkName() ) );
1465 aRet.append( aFileName );
1466 aRet.append( (sal_Unicode)'#' );
1467 aRet.append( aBookmarkName );
1468 }
1469 }
1470
1471 return aRet.makeStringAndClear();
1472 }
1473
1474 //----------------------------------------------------------------------
1475 void SdGenericDrawPage::setBookmarkURL( rtl::OUString& rURL )
1476 {
1477 if( SvxFmDrawPage::mpPage )
1478 {
1479 sal_Int32 nIndex = rURL.indexOf( (sal_Unicode)'#' );
1480 if( nIndex != -1 )
1481 {
1482 const String aFileName( rURL.copy( 0, nIndex ) );
1483 const String aBookmarkName( SdDrawPage::getUiNameFromPageApiName( rURL.copy( nIndex+1 ) ) );
1484
1485 if( aFileName.Len() && aBookmarkName.Len() )
1486 {
1487 static_cast<SdPage*>(SvxFmDrawPage::mpPage)->DisconnectLink();
1488 static_cast<SdPage*>(SvxFmDrawPage::mpPage)->SetFileName( aFileName );
1489 static_cast<SdPage*>(SvxFmDrawPage::mpPage)->SetBookmarkName( aBookmarkName );
1490 static_cast<SdPage*>(SvxFmDrawPage::mpPage)->ConnectLink();
1491 }
1492 }
1493 }
1494 }
1495
1496 //----------------------------------------------------------------------
1497 Reference< drawing::XShape > SAL_CALL SdGenericDrawPage::combine( const Reference< drawing::XShapes >& xShapes )
1498 throw( uno::RuntimeException )
1499 {
1500 OGuard aGuard( Application::GetSolarMutex() );
1501
1502 throwIfDisposed();
1503
1504 DBG_ASSERT(SvxFmDrawPage::mpPage,"SdrPage ist NULL! [CL]");
1505 DBG_ASSERT(mpView, "SdrView ist NULL! [CL]");
1506
1507 Reference< drawing::XShape > xShape;
1508 if(mpView==NULL||!xShapes.is()||GetPage()==NULL)
1509 return xShape;
1510
1511 SdrPageView* pPageView = mpView->ShowSdrPage( GetPage() );
1512
1513 _SelectObjectsInView( xShapes, pPageView );
1514
1515 mpView->CombineMarkedObjects( sal_False );
1516
1517 mpView->AdjustMarkHdl();
1518 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1519 if( rMarkList.GetMarkCount() == 1 )
1520 {
1521 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
1522 if( pObj )
1523 xShape = Reference< drawing::XShape >::query( pObj->getUnoShape() );
1524 }
1525
1526 mpView->HideSdrPage();
1527
1528 GetModel()->SetModified();
1529
1530 return xShape;
1531 }
1532
1533 //----------------------------------------------------------------------
1534 void SAL_CALL SdGenericDrawPage::split( const Reference< drawing::XShape >& xGroup )
1535 throw( uno::RuntimeException )
1536 {
1537 OGuard aGuard( Application::GetSolarMutex() );
1538
1539 throwIfDisposed();
1540
1541 if(mpView==NULL||!xGroup.is()||GetPage()==NULL)
1542 return;
1543
1544 SdrPageView* pPageView = mpView->ShowSdrPage( GetPage() );
1545 _SelectObjectInView( xGroup, pPageView );
1546 mpView->DismantleMarkedObjects( sal_False );
1547 mpView->HideSdrPage();
1548
1549 GetModel()->SetModified();
1550 }
1551
1552 //----------------------------------------------------------------------
1553 Reference< drawing::XShape > SAL_CALL SdGenericDrawPage::bind( const Reference< drawing::XShapes >& xShapes )
1554 throw( uno::RuntimeException )
1555 {
1556 OGuard aGuard( Application::GetSolarMutex() );
1557
1558 throwIfDisposed();
1559
1560 uno::Reference< drawing::XShape > xShape;
1561 if(mpView==NULL||!xShapes.is()||GetPage()==NULL)
1562 return xShape;
1563
1564 SdrPageView* pPageView = mpView->ShowSdrPage( GetPage() );
1565
1566 _SelectObjectsInView( xShapes, pPageView );
1567
1568 mpView->CombineMarkedObjects( sal_True );
1569
1570 mpView->AdjustMarkHdl();
1571 const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1572 if( rMarkList.GetMarkCount() == 1 )
1573 {
1574 SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
1575 if( pObj )
1576 xShape = Reference< drawing::XShape >::query( pObj->getUnoShape() );
1577 }
1578
1579 mpView->HideSdrPage();
1580
1581 GetModel()->SetModified();
1582
1583 return xShape;
1584 }
1585
1586 //----------------------------------------------------------------------
1587 void SAL_CALL SdGenericDrawPage::unbind( const Reference< drawing::XShape >& xShape )
1588 throw( uno::RuntimeException )
1589 {
1590 OGuard aGuard( Application::GetSolarMutex() );
1591
1592 throwIfDisposed();
1593
1594 if(mpView==NULL||!xShape.is()||GetPage()==NULL)
1595 return;
1596
1597 SdrPageView* pPageView = mpView->ShowSdrPage( GetPage() );
1598 _SelectObjectInView( xShape, pPageView );
1599 mpView->DismantleMarkedObjects( sal_True );
1600 mpView->HideSdrPage();
1601
1602 GetModel()->SetModified();
1603 }
1604
1605 void SdGenericDrawPage::SetLftBorder( sal_Int32 nValue )
1606 {
1607 if( nValue != GetPage()->GetLftBorder() )
1608 {
1609 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1610 const PageKind ePageKind = GetPage()->GetPageKind();
1611
1612 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1613 for (i = 0; i < nPageCnt; i++)
1614 {
1615 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1616 pPage->SetLftBorder( nValue );
1617 }
1618
1619 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1620
1621 for (i = 0; i < nPageCnt; i++)
1622 {
1623 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1624 pPage->SetLftBorder( nValue );
1625 }
1626 }
1627 }
1628
1629 void SdGenericDrawPage::SetRgtBorder( sal_Int32 nValue )
1630 {
1631 if( nValue != GetPage()->GetRgtBorder() )
1632 {
1633 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1634 const PageKind ePageKind = GetPage()->GetPageKind();
1635
1636 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1637 for (i = 0; i < nPageCnt; i++)
1638 {
1639 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1640 pPage->SetRgtBorder( nValue );
1641 }
1642
1643 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1644
1645 for (i = 0; i < nPageCnt; i++)
1646 {
1647 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1648 pPage->SetRgtBorder( nValue );
1649 }
1650 }
1651 }
1652
1653 void SdGenericDrawPage::SetUppBorder( sal_Int32 nValue )
1654 {
1655 if( nValue != GetPage()->GetUppBorder() )
1656 {
1657 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1658 const PageKind ePageKind = GetPage()->GetPageKind();
1659
1660 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1661 for (i = 0; i < nPageCnt; i++)
1662 {
1663 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1664 pPage->SetUppBorder( nValue );
1665 }
1666
1667 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1668
1669 for (i = 0; i < nPageCnt; i++)
1670 {
1671 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1672 pPage->SetUppBorder( nValue );
1673 }
1674 }
1675 }
1676
1677 void SdGenericDrawPage::SetLwrBorder( sal_Int32 nValue )
1678 {
1679 if( nValue != GetPage()->GetLwrBorder() )
1680 {
1681 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1682 const PageKind ePageKind = GetPage()->GetPageKind();
1683
1684 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1685 for (i = 0; i < nPageCnt; i++)
1686 {
1687 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1688 pPage->SetLwrBorder( nValue );
1689 }
1690
1691 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1692
1693 for (i = 0; i < nPageCnt; i++)
1694 {
1695 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1696 pPage->SetLwrBorder( nValue );
1697 }
1698 }
1699 }
1700
1701 static void refreshpage( SdDrawDocument* pDoc, const PageKind ePageKind )
1702 {
1703 ::sd::DrawDocShell* pDocShell = pDoc->GetDocSh();
1704 if ( pDocShell )
1705 {
1706 ::sd::ViewShell* pViewSh = pDocShell->GetViewShell();
1707
1708 if( pViewSh )
1709 {
1710 if( pViewSh->ISA(::sd::DrawViewShell ) )
1711 static_cast< ::sd::DrawViewShell*>(pViewSh)->ResetActualPage();
1712
1713 Size aPageSize = pDoc->GetSdPage(0, ePageKind)->GetSize();
1714 const long nWidth = aPageSize.Width();
1715 const long nHeight = aPageSize.Height();
1716
1717 Point aPageOrg = Point(nWidth, nHeight / 2);
1718 Size aViewSize = Size(nWidth * 3, nHeight * 2);
1719
1720 pDoc->SetMaxObjSize(aViewSize);
1721
1722 pViewSh->InitWindows(aPageOrg, aViewSize, Point(-1, -1), TRUE);
1723
1724 pViewSh->UpdateScrollBars();
1725 }
1726 }
1727 }
1728
1729 void SdGenericDrawPage::SetWidth( sal_Int32 nWidth )
1730 {
1731 Size aSize( GetPage()->GetSize() );
1732 if( aSize.getWidth() != nWidth )
1733 {
1734 aSize.setWidth( nWidth );
1735
1736 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1737 const PageKind ePageKind = GetPage()->GetPageKind();
1738
1739 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1740 for (i = 0; i < nPageCnt; i++)
1741 {
1742 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1743 pPage->SetSize(aSize);
1744 }
1745
1746 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1747
1748 for (i = 0; i < nPageCnt; i++)
1749 {
1750 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1751 pPage->SetSize(aSize);
1752 }
1753
1754 refreshpage( pDoc, ePageKind );
1755 }
1756 }
1757
1758 void SdGenericDrawPage::SetHeight( sal_Int32 nHeight )
1759 {
1760 Size aSize( GetPage()->GetSize() );
1761 if( aSize.getHeight() != nHeight )
1762 {
1763 aSize.setHeight( nHeight );
1764
1765 SdDrawDocument* pDoc = (SdDrawDocument*)GetPage()->GetModel();
1766 const PageKind ePageKind = GetPage()->GetPageKind();
1767
1768 USHORT i, nPageCnt = pDoc->GetMasterSdPageCount(ePageKind);
1769 for (i = 0; i < nPageCnt; i++)
1770 {
1771 SdPage* pPage = pDoc->GetMasterSdPage(i, ePageKind);
1772 pPage->SetSize(aSize);
1773 }
1774
1775 nPageCnt = pDoc->GetSdPageCount(ePageKind);
1776
1777 for (i = 0; i < nPageCnt; i++)
1778 {
1779 SdPage* pPage = pDoc->GetSdPage(i, ePageKind);
1780 pPage->SetSize(aSize);
1781 }
1782
1783 refreshpage( pDoc, ePageKind );
1784 }
1785 }
1786
1787 // XInterface
1788 void SdGenericDrawPage::release() throw()
1789 {
1790
1791 OWeakAggObject::release();
1792 }
1793
1794 // XComponent
1795 void SdGenericDrawPage::disposing() throw()
1796 {
1797 mpModel = 0;
1798 SvxFmDrawPage::disposing();
1799 }
1800
1801 // XAnimationNodeSupplier
1802 Reference< XAnimationNode > SAL_CALL SdGenericDrawPage::getAnimationNode() throw (uno::RuntimeException)
1803 {
1804 OGuard aGuard( Application::GetSolarMutex() );
1805
1806 throwIfDisposed();
1807
1808 SdPage *pSdPage = static_cast<SdPage*>(SvxFmDrawPage::mpPage);
1809
1810
1811 return pSdPage->getAnimationNode();
1812 }
1813
1814 //========================================================================
1815 // SdPageLinkTargets
1816 //========================================================================
1817
1818 SdPageLinkTargets::SdPageLinkTargets( SdGenericDrawPage* pUnoPage ) throw()
1819 {
1820 mxPage = pUnoPage;
1821 mpUnoPage = pUnoPage;
1822 }
1823
1824 SdPageLinkTargets::~SdPageLinkTargets() throw()
1825 {
1826 }
1827
1828 // XElementAccess
1829 uno::Type SAL_CALL SdPageLinkTargets::getElementType()
1830 throw(uno::RuntimeException)
1831 {
1832 return ITYPE(beans::XPropertySet);
1833 }
1834
1835 sal_Bool SAL_CALL SdPageLinkTargets::hasElements()
1836 throw(uno::RuntimeException)
1837 {
1838 OGuard aGuard( Application::GetSolarMutex() );
1839
1840 SdPage* pPage = mpUnoPage->GetPage();
1841 if( pPage != NULL )
1842 {
1843 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1844
1845 while( aIter.IsMore() )
1846 {
1847 SdrObject* pObj = aIter.Next();
1848 String aStr( pObj->GetName() );
1849 if( !aStr.Len() && pObj->ISA( SdrOle2Obj ) )
1850 aStr = static_cast< const SdrOle2Obj* >( pObj )->GetPersistName();
1851 if( aStr.Len() )
1852 return sal_True;
1853 }
1854 }
1855
1856 return sal_False;
1857 }
1858
1859 // container::XNameAccess
1860
1861 // XNameAccess
1862 Any SAL_CALL SdPageLinkTargets::getByName( const OUString& aName )
1863 throw(container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException)
1864 {
1865 OGuard aGuard( Application::GetSolarMutex() );
1866
1867 SdPage* pPage = mpUnoPage->GetPage();
1868 if( pPage != NULL )
1869 {
1870 SdrObject* pObj = FindObject( aName );
1871 if( pObj )
1872 {
1873 Reference< beans::XPropertySet > aRef( pObj->getUnoShape(), uno::UNO_QUERY );
1874 return makeAny( aRef );
1875 }
1876 }
1877
1878 throw container::NoSuchElementException();
1879 }
1880
1881 Sequence< OUString > SAL_CALL SdPageLinkTargets::getElementNames()
1882 throw(uno::RuntimeException)
1883 {
1884 OGuard aGuard( Application::GetSolarMutex() );
1885
1886 sal_uInt32 nObjCount = 0;
1887
1888 SdPage* pPage = mpUnoPage->GetPage();
1889 if( pPage != NULL )
1890 {
1891 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1892 while( aIter.IsMore() )
1893 {
1894 SdrObject* pObj = aIter.Next();
1895 String aStr( pObj->GetName() );
1896 if( !aStr.Len() && pObj->ISA( SdrOle2Obj ) )
1897 aStr = static_cast< const SdrOle2Obj* >( pObj )->GetPersistName();
1898 if( aStr.Len() )
1899 nObjCount++;
1900 }
1901 }
1902
1903 Sequence< OUString > aSeq( nObjCount );
1904 if( nObjCount > 0 )
1905 {
1906 OUString* pStr = aSeq.getArray();
1907
1908 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1909 while( aIter.IsMore() )
1910 {
1911 SdrObject* pObj = aIter.Next();
1912 String aStr( pObj->GetName() );
1913 if( !aStr.Len() && pObj->ISA( SdrOle2Obj ) )
1914 aStr = static_cast< const SdrOle2Obj* >( pObj )->GetPersistName();
1915 if( aStr.Len() )
1916 *pStr++ = aStr;
1917 }
1918 }
1919
1920 return aSeq;
1921 }
1922
1923 sal_Bool SAL_CALL SdPageLinkTargets::hasByName( const OUString& aName )
1924 throw(uno::RuntimeException)
1925 {
1926 OGuard aGuard( Application::GetSolarMutex() );
1927
1928 return FindObject( aName ) != NULL;
1929 }
1930
1931 /***********************************************************************
1932 * *
1933 ***********************************************************************/
1934 SdrObject* SdPageLinkTargets::FindObject( const String& rName ) const throw()
1935 {
1936 SdPage* pPage = mpUnoPage->GetPage();
1937 if( pPage == NULL )
1938 return NULL;
1939
1940 SdrObjListIter aIter( *pPage, IM_DEEPWITHGROUPS );
1941
1942 while( aIter.IsMore() )
1943 {
1944 SdrObject* pObj = aIter.Next();
1945 String aStr( pObj->GetName() );
1946 if( !aStr.Len() && pObj->ISA( SdrOle2Obj ) )
1947 aStr = static_cast< const SdrOle2Obj* >( pObj )->GetPersistName();
1948 if( aStr.Len() && (aStr == rName) )
1949 return pObj;
1950 }
1951
1952 return NULL;
1953 }
1954
1955 // XServiceInfo
1956 OUString SAL_CALL SdPageLinkTargets::getImplementationName()
1957 throw(uno::RuntimeException)
1958 {
1959 return OUString( RTL_CONSTASCII_USTRINGPARAM("SdPageLinkTargets") );
1960 }
1961
1962 sal_Bool SAL_CALL SdPageLinkTargets::supportsService( const OUString& ServiceName )
1963 throw(uno::RuntimeException)
1964 {
1965 return SvxServiceInfoHelper::supportsService( ServiceName, getSupportedServiceNames() );
1966 }
1967
1968 Sequence< OUString > SAL_CALL SdPageLinkTargets::getSupportedServiceNames()
1969 throw(uno::RuntimeException)
1970 {
1971 const OUString aSN( RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.LinkTargets") );
1972 Sequence< OUString > aSeq( &aSN, 1);
1973 return aSeq;
1974 }
1975
1976 //========================================================================
1977 // SdDrawPage
1978 //========================================================================
1979
1980 SdDrawPage::SdDrawPage( SdXImpressDocument* pModel, SdPage* pPage ) throw()
1981 : SdGenericDrawPage( pModel, pPage, ImplGetDrawPagePropertySet( pModel->IsImpressDocument(), pPage->GetPageKind() ) )
1982 {
1983 }
1984
1985 SdDrawPage::~SdDrawPage() throw()
1986 {
1987 }
1988
1989 // XInterface
1990 Any SAL_CALL SdDrawPage::queryInterface( const uno::Type & rType )
1991 throw(uno::RuntimeException)
1992 {
1993 if( rType == ITYPE( drawing::XMasterPageTarget ) )
1994 {
1995 return makeAny( Reference< drawing::XMasterPageTarget >( this ) );
1996 }
1997 else
1998 {
1999 if( mbIsImpressDocument )
2000 {
2001 const PageKind ePageKind = GetPage() ? GetPage()->GetPageKind() : PK_STANDARD;
2002
2003 if( ePageKind != PK_HANDOUT && rType == ITYPE( presentation::XPresentationPage ) )
2004 {
2005 return makeAny( Reference< presentation::XPresentationPage >( this ) );
2006 }
2007 }
2008 }
2009
2010 return SdGenericDrawPage::queryInterface( rType );
2011 }
2012
2013 void SAL_CALL SdDrawPage::acquire() throw()
2014 {
2015 SvxDrawPage::acquire();
2016 }
2017
2018 void SAL_CALL SdDrawPage::release() throw()
2019 {
2020 SvxDrawPage::release();
2021 }
2022
2023 UNO3_GETIMPLEMENTATION2_IMPL( SdDrawPage, SdGenericDrawPage );
2024
2025 // XTypeProvider
2026 Sequence< uno::Type > SAL_CALL SdDrawPage::getTypes() throw(uno::RuntimeException)
2027 {
2028 OGuard aGuard( Application::GetSolarMutex() );
2029
2030 throwIfDisposed();
2031
2032 if( maTypeSequence.getLength() == 0 )
2033 {
2034 const PageKind ePageKind = GetPage() ? GetPage()->GetPageKind() : PK_STANDARD;
2035 sal_Bool bPresPage = mbIsImpressDocument && ePageKind != PK_HANDOUT;
2036
2037 // Collect the types of this class.
2038 ::std::vector<uno::Type> aTypes;
2039 aTypes.reserve(11);
2040 aTypes.push_back(ITYPE(drawing::XDrawPage));
2041 aTypes.push_back(ITYPE(beans::XPropertySet));
2042 aTypes.push_back(ITYPE(container::XNamed));
2043 aTypes.push_back(ITYPE(drawing::XMasterPageTarget));
2044 aTypes.push_back(ITYPE(lang::XServiceInfo));
2045 aTypes.push_back(ITYPE(util::XReplaceable));
2046 aTypes.push_back(ITYPE(document::XLinkTargetSupplier));
2047 aTypes.push_back(ITYPE( drawing::XShapeCombiner ));
2048 aTypes.push_back(ITYPE( drawing::XShapeBinder ));
2049 aTypes.push_back(ITYPE( beans::XMultiPropertySet ));
2050 if( bPresPage )
2051 aTypes.push_back(ITYPE(presentation::XPresentationPage));
2052 if( bPresPage && ePageKind == PK_STANDARD )
2053 aTypes.push_back(ITYPE(XAnimationNodeSupplier));
2054
2055 // Get types of base class.
2056 const Sequence< uno::Type > aBaseTypes( SdGenericDrawPage::getTypes() );
2057 const sal_Int32 nBaseTypes = aBaseTypes.getLength();
2058 const uno::Type* pBaseTypes = aBaseTypes.getConstArray();
2059
2060 // Join those types in a sequence.
2061 maTypeSequence.realloc(aTypes.size() + nBaseTypes);
2062 uno::Type* pTypes = maTypeSequence.getArray();
2063 ::std::vector<uno::Type>::const_iterator iType;
2064 for (iType=aTypes.begin(); iType!=aTypes.end(); ++iType)
2065 *pTypes++ = *iType;
2066 for( sal_Int32 nType = 0; nType < nBaseTypes; nType++ )
2067 *pTypes++ = *pBaseTypes++;
2068 }
2069
2070 return maTypeSequence;
2071 }
2072
2073 Sequence< sal_Int8 > SAL_CALL SdDrawPage::getImplementationId() throw(uno::RuntimeException)
2074 {
2075 OGuard aGuard( Application::GetSolarMutex() );
2076
2077 throwIfDisposed();
2078
2079 static Sequence< sal_Int8 > aId;
2080 if( aId.getLength() == 0 )
2081 {
2082 aId.realloc( 16 );
2083 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
2084 }
2085 return aId;
2086 }
2087
2088 OUString SdDrawPage::getPageApiName( SdPage* pPage )
2089 {
2090 return ::getPageApiName( pPage );
2091 }
2092
2093 OUString getPageApiName( SdPage* pPage )
2094 {
2095 OUString aPageName;
2096
2097 if(pPage)
2098 {
2099 aPageName = pPage->GetRealName();
2100
2101 if( aPageName.getLength() == 0 )
2102 {
2103 OUStringBuffer sBuffer;
2104 sBuffer.appendAscii( RTL_CONSTASCII_STRINGPARAM( sEmptyPageName ) );
2105 const sal_Int32 nPageNum = ( ( pPage->GetPageNum() - 1 ) >> 1 ) + 1;
2106 sBuffer.append( nPageNum );
2107 aPageName = sBuffer.makeStringAndClear();
2108 }
2109 }
2110
2111 return aPageName;
2112 }
2113
2114
2115 OUString getPageApiNameFromUiName( const String& rUIName )
2116 {
2117 OUString aApiName;
2118
2119 String aDefPageName(SdResId(STR_PAGE));
2120 aDefPageName += sal_Unicode( ' ' );
2121
2122 if( rUIName.Equals( aDefPageName, 0, aDefPageName.Len() ) )
2123 {
2124 aApiName = OUString( RTL_CONSTASCII_USTRINGPARAM( sEmptyPageName ) );
2125 aApiName += rUIName.Copy( aDefPageName.Len() );
2126 }
2127 else
2128 {
2129 aApiName = rUIName;
2130 }
2131
2132 return aApiName;
2133 }
2134
2135 OUString SdDrawPage::getPageApiNameFromUiName( const String& rUIName )
2136 {
2137 return ::getPageApiNameFromUiName( rUIName );
2138 }
2139
2140 String getUiNameFromPageApiNameImpl( const OUString& rApiName )
2141 {
2142 const String aDefPageName(RTL_CONSTASCII_USTRINGPARAM( sEmptyPageName ));
2143 if( rApiName.compareTo( aDefPageName, aDefPageName.Len() ) == 0 )
2144 {
2145 OUString aNumber( rApiName.copy( sizeof( sEmptyPageName ) - 1 ) );
2146
2147 // create the page number
2148 sal_Int32 nPageNumber = aNumber.toInt32();
2149
2150 // check if there are non number characters in the number part
2151 const sal_Int32 nChars = aNumber.getLength();
2152 const sal_Unicode* pString = aNumber.getStr();
2153 sal_Int32 nChar;
2154 for( nChar = 0; nChar < nChars; nChar++, pString++ )
2155 {
2156 if((*pString < sal_Unicode('0')) || (*pString > sal_Unicode('9')))
2157 {
2158 // found a non number character, so this is not the default
2159 // name for this page
2160 nPageNumber = -1;
2161 break;
2162 }
2163 }
2164
2165 if( nPageNumber != -1)
2166 {
2167 OUStringBuffer sBuffer;
2168 sBuffer.append( String(SdResId(STR_PAGE)) );
2169 sBuffer.append( sal_Unicode( ' ' ) );
2170 sBuffer.append( aNumber );
2171 return sBuffer.makeStringAndClear();
2172 }
2173 }
2174
2175 return rApiName;
2176 }
2177
2178 String SdDrawPage::getUiNameFromPageApiName( const OUString& rApiName )
2179 {
2180 return getUiNameFromPageApiNameImpl( rApiName );
2181 }
2182
2183 // XServiceInfo
2184 OUString SAL_CALL SdDrawPage::getImplementationName() throw(uno::RuntimeException)
2185 {
2186 return OUString( RTL_CONSTASCII_USTRINGPARAM("SdDrawPage") );
2187 }
2188
2189 Sequence< OUString > SAL_CALL SdDrawPage::getSupportedServiceNames() throw(uno::RuntimeException)
2190 {
2191 OGuard aGuard( Application::GetSolarMutex() );
2192
2193 throwIfDisposed();
2194
2195 Sequence< OUString > aSeq( SdGenericDrawPage::getSupportedServiceNames() );
2196 SvxServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.drawing.DrawPage" );
2197
2198 if( mbIsImpressDocument )
2199 SvxServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.presentation.DrawPage" );
2200
2201 return aSeq;
2202 }
2203
2204 sal_Bool SAL_CALL SdDrawPage::supportsService( const OUString& ServiceName )
2205 throw(uno::RuntimeException)
2206 {
2207 return SdGenericDrawPage::supportsService( ServiceName );
2208 }
2209
2210 // XNamed
2211 void SAL_CALL SdDrawPage::setName( const OUString& rName )
2212 throw(uno::RuntimeException)
2213 {
2214 OGuard aGuard( Application::GetSolarMutex() );
2215
2216 throwIfDisposed();
2217
2218 DBG_ASSERT( GetPage() && !GetPage()->IsMasterPage(), "Don't call base implementation for masterpages!" );
2219
2220 OUString aName( rName );
2221
2222 if(GetPage() && GetPage()->GetPageKind() != PK_NOTES)
2223 {
2224 // check if this is the default 'page1234' name
2225 if(aName.compareToAscii( sEmptyPageName, sizeof( sEmptyPageName ) - 1 ) == 0)
2226 {
2227 // ok, it maybe is, first get the number part after 'page'
2228 OUString aNumber( aName.copy( sizeof( sEmptyPageName ) - 1 ) );
2229
2230 // create the page number
2231 sal_Int32 nPageNumber = aNumber.toInt32();
2232
2233 // check if there are non number characters in the number part
2234 const sal_Int32 nChars = aNumber.getLength();
2235 const sal_Unicode* pString = aNumber.getStr();
2236 sal_Int32 nChar;
2237 for( nChar = 0; nChar < nChars; nChar++, pString++ )
2238 {
2239 if((*pString < '0') || (*pString > '9'))
2240 {
2241 // found a non number character, so this is not the default
2242 // name for this page
2243 nPageNumber = -1;
2244 break;
2245 }
2246 }
2247
2248 if( nPageNumber == ( ( GetPage()->GetPageNum() - 1 ) >> 1 ) + 1 )
2249 aName = OUString();
2250 }
2251 else
2252 {
2253 String aDefaultPageName( SdResId(STR_PAGE) );
2254 aDefaultPageName += sal_Unicode( ' ' );
2255 if( aName.compareTo( aDefaultPageName, aDefaultPageName.Len() ) == 0 )
2256 aName = OUString();
2257 }
2258
2259 GetPage()->SetName( aName );
2260
2261 USHORT nNotesPageNum = (GetPage()->GetPageNum()-1)>>1;
2262 if( GetModel()->GetDoc()->GetSdPageCount( PK_NOTES ) > nNotesPageNum )
2263 {
2264 SdPage* pNotesPage = GetModel()->GetDoc()->GetSdPage( nNotesPageNum, PK_NOTES );
2265 if( pNotesPage )
2266 pNotesPage->SetName(aName);
2267 }
2268
2269 // fake a mode change to repaint the page tab bar
2270 ::sd::DrawDocShell* pDocSh = GetModel()->GetDocShell();
2271 ::sd::ViewShell* pViewSh = pDocSh ? pDocSh->GetViewShell() : NULL;
2272 if( pViewSh && pViewSh->ISA(::sd::DrawViewShell))
2273 {
2274 ::sd::DrawViewShell* pDrawViewSh = static_cast<
2275 ::sd::DrawViewShell*>(pViewSh);
2276
2277 EditMode eMode = pDrawViewSh->GetEditMode();
2278 if( eMode == EM_PAGE )
2279 {
2280 BOOL bLayer = pDrawViewSh->IsLayerModeActive();
2281
2282 pDrawViewSh->ChangeEditMode( eMode, !bLayer );
2283 pDrawViewSh->ChangeEditMode( eMode, bLayer );
2284 }
2285 }
2286
2287 GetModel()->SetModified();
2288 }
2289 }
2290
2291 OUString SAL_CALL SdDrawPage::getName()
2292 throw(uno::RuntimeException)
2293 {
2294 OGuard aGuard( Application::GetSolarMutex() );
2295
2296 throwIfDisposed();
2297
2298 return getPageApiName( GetPage() );
2299 }
2300
2301 // XMasterPageTarget
2302 Reference< drawing::XDrawPage > SAL_CALL SdDrawPage::getMasterPage( )
2303 throw(uno::RuntimeException)
2304 {
2305 OGuard aGuard( Application::GetSolarMutex() );
2306
2307 throwIfDisposed();
2308
2309 if(GetPage())
2310 {
2311 Reference< drawing::XDrawPages > xPages( GetModel()->getMasterPages() );
2312 Reference< drawing::XDrawPage > xPage;
2313
2314 if(SvxFmDrawPage::mpPage->TRG_HasMasterPage())
2315 {
2316 SdrPage& rMasterPage = SvxFmDrawPage::mpPage->TRG_GetMasterPage();
2317 xPage = uno::Reference< drawing::XDrawPage >( rMasterPage.getUnoPage(), uno::UNO_QUERY );
2318 }
2319
2320 return xPage;
2321 }
2322 return NULL;
2323 }
2324
2325 void SAL_CALL SdDrawPage::setMasterPage( const Reference< drawing::XDrawPage >& xMasterPage )
2326 throw(uno::RuntimeException)
2327 {
2328 OGuard aGuard( Application::GetSolarMutex() );
2329
2330 throwIfDisposed();
2331
2332 if(SvxFmDrawPage::mpPage)
2333 {
2334 SdMasterPage* pMasterPage = SdMasterPage::getImplementation( xMasterPage );
2335 if( pMasterPage && pMasterPage->isValid() )
2336 {
2337 SvxFmDrawPage::mpPage->TRG_ClearMasterPage();
2338
2339 SdPage* pSdPage = (SdPage*) pMasterPage->GetSdrPage();
2340 SvxFmDrawPage::mpPage->TRG_SetMasterPage(*pSdPage);
2341
2342 SvxFmDrawPage::mpPage->SetBorder(pSdPage->GetLftBorder(),pSdPage->GetUppBorder(),
2343 pSdPage->GetRgtBorder(),pSdPage->GetLwrBorder() );
2344
2345 SvxFmDrawPage::mpPage->SetSize( pSdPage->GetSize() );
2346 SvxFmDrawPage::mpPage->SetOrientation( pSdPage->GetOrientation() );
2347 ((SdPage*)SvxFmDrawPage::mpPage)->SetLayoutName( ( (SdPage*)pSdPage )->GetLayoutName() );
2348
2349 // set notes master also
2350 SdPage* pNotesPage = GetModel()->GetDoc()->GetSdPage( (SvxFmDrawPage::mpPage->GetPageNum()-1)>>1, PK_NOTES );
2351
2352 pNotesPage->TRG_ClearMasterPage();
2353 sal_uInt16 nNum = (SvxFmDrawPage::mpPage->TRG_GetMasterPage()).GetPageNum() + 1;
2354 pNotesPage->TRG_SetMasterPage(*SvxFmDrawPage::mpPage->GetModel()->GetMasterPage(nNum));
2355 pNotesPage->SetLayoutName( ( (SdPage*)pSdPage )->GetLayoutName() );
2356
2357 GetModel()->SetModified();
2358 }
2359
2360 }
2361 }
2362
2363 // XPresentationPage
2364 Reference< drawing::XDrawPage > SAL_CALL SdDrawPage::getNotesPage()
2365 throw(uno::RuntimeException)
2366 {
2367 OGuard aGuard( Application::GetSolarMutex() );
2368
2369 throwIfDisposed();
2370
2371 if(SvxFmDrawPage::mpPage && GetModel()->GetDoc() && SvxFmDrawPage::mpPage->GetPageNum() )
2372 {
2373 SdPage* pNotesPage = GetModel()->GetDoc()->GetSdPage( (SvxFmDrawPage::mpPage->GetPageNum()-1)>>1, PK_NOTES );
2374 if( pNotesPage )
2375 {
2376 Reference< drawing::XDrawPage > xPage( pNotesPage->getUnoPage(), uno::UNO_QUERY );
2377 return xPage;
2378 }
2379 }
2380 return NULL;
2381 }
2382
2383
2384 // XIndexAccess
2385 sal_Int32 SAL_CALL SdDrawPage::getCount()
2386 throw(uno::RuntimeException)
2387 {
2388 return SdGenericDrawPage::getCount();
2389 }
2390
2391 Any SAL_CALL SdDrawPage::getByIndex( sal_Int32 Index )
2392 throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
2393 {
2394 return SdGenericDrawPage::getByIndex( Index );
2395 }
2396
2397 // XElementAccess
2398 uno::Type SAL_CALL SdDrawPage::getElementType()
2399 throw(uno::RuntimeException)
2400 {
2401 return SdGenericDrawPage::getElementType();
2402 }
2403
2404 sal_Bool SAL_CALL SdDrawPage::hasElements()
2405 throw(uno::RuntimeException)
2406 {
2407 return SdGenericDrawPage::hasElements();
2408 }
2409
2410 // XShapes
2411 void SAL_CALL SdDrawPage::add( const Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
2412 {
2413 SdGenericDrawPage::add( xShape );
2414 }
2415
2416 void SAL_CALL SdDrawPage::remove( const Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
2417 {
2418 OGuard aGuard( Application::GetSolarMutex() );
2419
2420 throwIfDisposed();
2421
2422 SvxShape* pShape = SvxShape::getImplementation( xShape );
2423 if( pShape )
2424 {
2425 SdrObject* pObj = pShape->GetSdrObject();
2426 if( pObj )
2427 {
2428 GetPage()->RemovePresObj(pObj);
2429 pObj->SetUserCall(NULL);
2430 }
2431 }
2432
2433 SdGenericDrawPage::remove( xShape );
2434 }
2435
2436 void SdDrawPage::setBackground( const Any& rValue )
2437 throw( lang::IllegalArgumentException )
2438 {
2439 Reference< beans::XPropertySet > xSet;
2440
2441 if( !(rValue >>= xSet) && !rValue.hasValue() )
2442 throw lang::IllegalArgumentException();
2443
2444 if( !xSet.is() )
2445 {
2446 // the easy case, clear the background obj
2447 GetPage()->SetBackgroundObj( NULL );
2448
2449 // #110094#-15
2450 // tell the page that it's visualization has changed
2451 GetPage()->ActionChanged();
2452
2453 return;
2454 }
2455
2456 // prepare background object
2457 SdrObject* pObj = GetPage()->GetBackgroundObj();
2458 if( NULL == pObj )
2459 {
2460 pObj = new SdrRectObj();
2461 GetPage()->SetBackgroundObj( pObj );
2462
2463 // #110094#-15
2464 // tell the page that it's visualization has changed
2465 GetPage()->ActionChanged();
2466 }
2467
2468 const sal_Int32 nLeft = GetPage()->GetLftBorder();
2469 const sal_Int32 nRight = GetPage()->GetRgtBorder();
2470 const sal_Int32 nUpper = GetPage()->GetUppBorder();
2471 const sal_Int32 nLower = GetPage()->GetLwrBorder();
2472
2473 Point aPos ( nLeft, nRight );
2474 Size aSize( GetPage()->GetSize() );
2475 aSize.Width() -= nLeft + nRight - 1;
2476 aSize.Height() -= nUpper + nLower - 1;
2477 Rectangle aRect( aPos, aSize );
2478 pObj->SetLogicRect( aRect );
2479
2480 // is it our own implementation?
2481 SdUnoPageBackground* pBack = SdUnoPageBackground::getImplementation( xSet );
2482
2483 SfxItemSet aSet( GetModel()->GetDoc()->GetPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST );
2484
2485 if( pBack )
2486 {
2487 pBack->fillItemSet( (SdDrawDocument*)GetPage()->GetModel(), aSet );
2488 }
2489 else
2490 {
2491 SdUnoPageBackground* pBackground = new SdUnoPageBackground();
2492
2493 Reference< beans::XPropertySetInfo > xSetInfo( xSet->getPropertySetInfo() );
2494 Reference< beans::XPropertySet > xDestSet( (beans::XPropertySet*)pBackground );
2495 Reference< beans::XPropertySetInfo > xDestSetInfo( xDestSet->getPropertySetInfo() );
2496
2497 Sequence< beans::Property > aProperties( xDestSetInfo->getProperties() );
2498 sal_Int32 nCount = aProperties.getLength();
2499 beans::Property* pProp = aProperties.getArray();
2500
2501 while( nCount-- )
2502 {
2503 const OUString aPropName( pProp->Name );
2504 if( xSetInfo->hasPropertyByName( aPropName ) )
2505 xDestSet->setPropertyValue( aPropName,
2506 xSet->getPropertyValue( aPropName ) );
2507
2508 pProp++;
2509 }
2510
2511 pBackground->fillItemSet( (SdDrawDocument*)GetPage()->GetModel(), aSet );
2512 }
2513
2514 //-/ pObj->NbcSetAttributes( aSet, sal_False );
2515 if( aSet.Count() == 0 )
2516 {
2517 GetPage()->SetBackgroundObj( NULL );
2518 }
2519 else
2520 {
2521 pObj->SetMergedItemSet(aSet);
2522 }
2523
2524 // repaint only
2525 SvxFmDrawPage::mpPage->ActionChanged();
2526 // pPage->SendRepaintBroadcast();
2527 }
2528
2529 void SdDrawPage::getBackground( Any& rValue ) throw()
2530 {
2531 SdrObject* pObj = GetPage()->GetBackgroundObj();
2532 if( NULL == pObj )
2533 {
2534 rValue.clear();
2535 }
2536 else
2537 {
2538 Reference< beans::XPropertySet > xSet( new SdUnoPageBackground( GetModel()->GetDoc(), pObj ) );
2539 rValue <<= xSet;
2540 }
2541 }
2542
2543 void SdGenericDrawPage::setNavigationOrder( const Any& rValue )
2544 {
2545 Reference< XIndexAccess > xIA( rValue, UNO_QUERY );
2546 if( xIA.is() )
2547 {
2548 if( dynamic_cast< SdDrawPage* >( xIA.get() ) == this )
2549 {
2550 if( GetPage()->HasObjectNavigationOrder() )
2551 GetPage()->ClearObjectNavigationOrder();
2552
2553 return;
2554 }
2555 else if( xIA->getCount() == static_cast< sal_Int32 >( GetPage()->GetObjCount() ) )
2556 {
2557 GetPage()->SetNavigationOrder(xIA);
2558 return;
2559 }
2560 }
2561 throw IllegalArgumentException();
2562 }
2563
2564 class NavigationOrderAccess : public ::cppu::WeakImplHelper1< XIndexAccess >
2565 {
2566 public:
2567 NavigationOrderAccess( SdrPage* pPage );
2568
2569 // XIndexAccess
2570 virtual sal_Int32 SAL_CALL getCount( ) throw (RuntimeException);
2571 virtual Any SAL_CALL getByIndex( sal_Int32 Index ) throw (IndexOutOfBoundsException, WrappedTargetException, RuntimeException);
2572
2573 // XElementAccess
2574 virtual Type SAL_CALL getElementType( ) throw (RuntimeException);
2575 virtual sal_Bool SAL_CALL hasElements( ) throw (RuntimeException);
2576
2577 private:
2578 std::vector< Reference< XShape > > maShapes;
2579 };
2580
2581 NavigationOrderAccess::NavigationOrderAccess( SdrPage* pPage )
2582 : maShapes( static_cast< sal_uInt32 >( pPage ? pPage->GetObjCount() : 0 ) )
2583 {
2584 if( pPage )
2585 {
2586 sal_uInt32 nIndex;
2587 const sal_uInt32 nCount = static_cast< sal_uInt32 >( pPage->GetObjCount() );
2588 for( nIndex = 0; nIndex < nCount; ++nIndex )
2589 {
2590 SdrObject* pObj = pPage->GetObj( nIndex );
2591 sal_uInt32 nNavPos = pObj->GetNavigationPosition();
2592 DBG_ASSERT( !maShapes[nNavPos].is(), "sd::NavigationOrderAccess::NavigationOrderAccess(), duplicate navigation positions from core!" );
2593 maShapes[nNavPos] = Reference< XShape >( pObj->getUnoShape(), UNO_QUERY );
2594 }
2595 }
2596 }
2597
2598 // XIndexAccess
2599 sal_Int32 SAL_CALL NavigationOrderAccess::getCount( ) throw (RuntimeException)
2600 {
2601 return static_cast< sal_Int32 >( maShapes.size() );
2602 }
2603
2604 Any SAL_CALL NavigationOrderAccess::getByIndex( sal_Int32 Index ) throw (IndexOutOfBoundsException, WrappedTargetException, RuntimeException)
2605 {
2606 if( (Index < 0) || (Index > getCount()) )
2607 throw IndexOutOfBoundsException();
2608
2609 return Any( maShapes[Index] );
2610 }
2611
2612 // XElementAccess
2613 Type SAL_CALL NavigationOrderAccess::getElementType( ) throw (RuntimeException)
2614 {
2615 return XShape::static_type();
2616 }
2617
2618 sal_Bool SAL_CALL NavigationOrderAccess::hasElements( ) throw (RuntimeException)
2619 {
2620 return maShapes.empty() ? sal_False : sal_True;
2621 }
2622
2623 Any SdGenericDrawPage::getNavigationOrder()
2624 {
2625 if( GetPage()->HasObjectNavigationOrder() )
2626 {
2627 return Any( Reference< XIndexAccess >( new NavigationOrderAccess( GetPage() ) ) );
2628 }
2629 else
2630 {
2631 return Any( Reference< XIndexAccess >( this ) );
2632 }
2633 }
2634
2635 //========================================================================
2636 // class SdMasterPage
2637 //========================================================================
2638
2639 SdMasterPage::SdMasterPage( SdXImpressDocument* pModel, SdPage* pPage ) throw()
2640 : SdGenericDrawPage( pModel, pPage, ImplGetMasterPagePropertySet( pPage ? pPage->GetPageKind() : PK_STANDARD ) )
2641 {
2642 mbHasBackgroundObject = pPage && GetPage()->GetPageKind() == PK_STANDARD;
2643 }
2644
2645 SdMasterPage::~SdMasterPage() throw()
2646 {
2647 }
2648
2649 // XInterface
2650 Any SAL_CALL SdMasterPage::queryInterface( const uno::Type & rType )
2651 throw(uno::RuntimeException)
2652 {
2653 OGuard aGuard( Application::GetSolarMutex() );
2654
2655 throwIfDisposed();
2656
2657 uno::Any aAny;
2658
2659 if( rType == ITYPE( container::XIndexAccess ) )
2660 aAny <<= Reference< container::XIndexAccess >((presentation::XPresentationPage*)(this));
2661 else if( rType == ITYPE( container::XElementAccess ) )
2662 aAny <<= Reference< container::XElementAccess >((presentation::XPresentationPage*)(this));
2663 else if( rType == ITYPE( container::XNamed ) )
2664 aAny <<= Reference< container::XNamed >(this);
2665 else if( rType == ITYPE( presentation::XPresentationPage ) &&
2666 ( mbIsImpressDocument &&
2667 GetPage() && GetPage()->GetPageKind() != PK_HANDOUT) )
2668 aAny <<= Reference< presentation::XPresentationPage >( this );
2669 else
2670 return SdGenericDrawPage::queryInterface( rType );
2671
2672 return aAny;
2673 }
2674
2675 void SAL_CALL SdMasterPage::acquire() throw()
2676 {
2677 SvxDrawPage::acquire();
2678 }
2679
2680 void SAL_CALL SdMasterPage::release() throw()
2681 {
2682 SvxDrawPage::release();
2683 }
2684
2685 UNO3_GETIMPLEMENTATION2_IMPL( SdMasterPage, SdGenericDrawPage );
2686
2687 // XTypeProvider
2688 Sequence< uno::Type > SAL_CALL SdMasterPage::getTypes() throw(uno::RuntimeException)
2689 {
2690 OGuard aGuard( Application::GetSolarMutex() );
2691
2692 throwIfDisposed();
2693
2694 if( maTypeSequence.getLength() == 0 )
2695 {
2696 const PageKind ePageKind = GetPage() ? GetPage()->GetPageKind() : PK_STANDARD;
2697 sal_Bool bPresPage = mbIsImpressDocument && SvxFmDrawPage::mpPage && ePageKind != PK_HANDOUT;
2698
2699 // Collect the types of this class.
2700 ::std::vector<uno::Type> aTypes;
2701 aTypes.reserve(10);
2702 aTypes.push_back(ITYPE(drawing::XDrawPage));
2703 aTypes.push_back(ITYPE(beans::XPropertySet));
2704 aTypes.push_back(ITYPE(container::XNamed));
2705 aTypes.push_back(ITYPE(lang::XServiceInfo));
2706 aTypes.push_back(ITYPE(util::XReplaceable));
2707 aTypes.push_back(ITYPE(document::XLinkTargetSupplier));
2708 aTypes.push_back(ITYPE( drawing::XShapeCombiner ));
2709 aTypes.push_back(ITYPE( drawing::XShapeBinder ));
2710 aTypes.push_back(ITYPE( beans::XMultiPropertySet ));
2711 if( bPresPage )
2712 aTypes.push_back(ITYPE(presentation::XPresentationPage));
2713 if( bPresPage && ePageKind == PK_STANDARD )
2714 aTypes.push_back(ITYPE(XAnimationNodeSupplier));
2715
2716 // Get types of base class.
2717 const Sequence< uno::Type > aBaseTypes( SdGenericDrawPage::getTypes() );
2718 const sal_Int32 nBaseTypes = aBaseTypes.getLength();
2719 const uno::Type* pBaseTypes = aBaseTypes.getConstArray();
2720
2721 // Join those types in a sequence.
2722 maTypeSequence.realloc(aTypes.size() + nBaseTypes);
2723 uno::Type* pTypes = maTypeSequence.getArray();
2724 ::std::vector<uno::Type>::const_iterator iType;
2725 for (iType=aTypes.begin(); iType!=aTypes.end(); ++iType)
2726 *pTypes++ = *iType;
2727 for( sal_Int32 nType = 0; nType < nBaseTypes; nType++ )
2728 *pTypes++ = *pBaseTypes++;
2729 }
2730
2731 return maTypeSequence;
2732 }
2733
2734 Sequence< sal_Int8 > SAL_CALL SdMasterPage::getImplementationId() throw(uno::RuntimeException)
2735 {
2736 OGuard aGuard( Application::GetSolarMutex() );
2737
2738 throwIfDisposed();
2739
2740 static Sequence< sal_Int8 > aId;
2741 if( aId.getLength() == 0 )
2742 {
2743 aId.realloc( 16 );
2744 rtl_createUuid( (sal_uInt8 *)aId.getArray(), 0, sal_True );
2745 }
2746 return aId;
2747 }
2748
2749 // XServiceInfo
2750 OUString SAL_CALL SdMasterPage::getImplementationName() throw(uno::RuntimeException)
2751 {
2752 return OUString( RTL_CONSTASCII_USTRINGPARAM("SdMasterPage") );
2753 }
2754
2755 Sequence< OUString > SAL_CALL SdMasterPage::getSupportedServiceNames() throw(uno::RuntimeException)
2756 {
2757 OGuard aGuard( Application::GetSolarMutex() );
2758
2759 throwIfDisposed();
2760
2761 Sequence< OUString > aSeq( SdGenericDrawPage::getSupportedServiceNames() );
2762 SvxServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.drawing.MasterPage" );
2763
2764 if( SvxFmDrawPage::mpPage && ((SdPage*)SvxFmDrawPage::mpPage)->GetPageKind() == PK_HANDOUT )
2765 SvxServiceInfoHelper::addToSequence( aSeq, 1, "com.sun.star.presentation.HandoutMasterPage" );
2766
2767 return aSeq;
2768 }
2769
2770 sal_Bool SAL_CALL SdMasterPage::supportsService( const OUString& ServiceName )
2771 throw(uno::RuntimeException)
2772 {
2773 return SdGenericDrawPage::supportsService( ServiceName );
2774 }
2775
2776 // XElementAccess
2777 sal_Bool SAL_CALL SdMasterPage::hasElements() throw(uno::RuntimeException)
2778 {
2779 OGuard aGuard( Application::GetSolarMutex() );
2780
2781 throwIfDisposed();
2782
2783 if( SvxFmDrawPage::mpPage == NULL )
2784 return sal_False;
2785
2786 return (SvxFmDrawPage::mpPage->GetObjCount() > 1) || (!mbHasBackgroundObject && SvxFmDrawPage::mpPage->GetObjCount() == 1 );
2787 }
2788
2789 uno::Type SAL_CALL SdMasterPage::getElementType()
2790 throw(uno::RuntimeException)
2791 {
2792 return SdGenericDrawPage::getElementType();
2793 }
2794
2795 // XIndexAccess
2796 sal_Int32 SAL_CALL SdMasterPage::getCount()
2797 throw(uno::RuntimeException)
2798 {
2799 OGuard aGuard( Application::GetSolarMutex() );
2800
2801 throwIfDisposed();
2802
2803 sal_Int32 nCount = SdGenericDrawPage::getCount();
2804 DBG_ASSERT( !mbHasBackgroundObject || (nCount > 0), "possible wrong shape count!" );
2805
2806 if( mbHasBackgroundObject && ( nCount > 0 ) )
2807 nCount--;
2808
2809 return nCount;
2810 }
2811
2812 Any SAL_CALL SdMasterPage::getByIndex( sal_Int32 Index )
2813 throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException)
2814 {
2815 OGuard aGuard( Application::GetSolarMutex() );
2816
2817 throwIfDisposed();
2818
2819 if( mbHasBackgroundObject )
2820 Index++;
2821
2822 return SdGenericDrawPage::getByIndex(Index);
2823 }
2824
2825 // intern
2826 void SdMasterPage::setBackground( const Any& rValue )
2827 throw( lang::IllegalArgumentException )
2828 {
2829 // we need at least an beans::XPropertySet
2830 Reference< beans::XPropertySet > xInputSet( rValue, UNO_QUERY );
2831 if( !xInputSet.is() )
2832 throw lang::IllegalArgumentException();
2833
2834 try
2835 {
2836 if( GetModel() && mbIsImpressDocument )
2837 {
2838 Reference< container::XNameAccess > xFamilies( GetModel()->getStyleFamilies(), UNO_QUERY_THROW );
2839 Reference< container::XNameAccess > xFamily( xFamilies->getByName( getName() ), UNO_QUERY_THROW ) ;
2840 if( xFamily.is() )
2841 {
2842 OUString aStyleName( OUString::createFromAscii(sUNO_PseudoSheet_Background) );
2843
2844 Reference< beans::XPropertySet > xStyleSet( xFamily->getByName( aStyleName ), UNO_QUERY_THROW );
2845
2846 Reference< beans::XPropertySetInfo > xSetInfo( xInputSet->getPropertySetInfo(), UNO_QUERY_THROW );
2847 Reference< beans::XPropertyState > xSetStates( xInputSet, UNO_QUERY );
2848
2849 PropertyEntryVector_t aBackgroundProperties = ImplGetPageBackgroundPropertySet()->getPropertyMap()->getPropertyEntries();
2850 PropertyEntryVector_t::const_iterator aIt = aBackgroundProperties.begin();
2851 while( aIt != aBackgroundProperties.end() )
2852 {
2853 if( xSetInfo->hasPropertyByName( aIt->sName ) )
2854 {
2855 if( !xSetStates.is() || xSetStates->getPropertyState( aIt->sName ) == beans::PropertyState_DIRECT_VALUE )
2856 xStyleSet->setPropertyValue( aIt->sName, xInputSet->getPropertyValue( aIt->sName ) );
2857 else
2858 xSetStates->setPropertyToDefault( aIt->sName );
2859 }
2860
2861 ++aIt;
2862 }
2863 }
2864 }
2865 else
2866 {
2867 // first fill an item set
2868 // is it our own implementation?
2869 SdUnoPageBackground* pBack = SdUnoPageBackground::getImplementation( xInputSet );
2870
2871 SfxItemSet aSet( GetModel()->GetDoc()->GetPool(), XATTR_FILL_FIRST, XATTR_FILL_LAST );
2872
2873 if( pBack )
2874 {
2875 pBack->fillItemSet( (SdDrawDocument*)GetPage()->GetModel(), aSet );
2876 }
2877 else
2878 {
2879 SdUnoPageBackground* pBackground = new SdUnoPageBackground();
2880
2881 Reference< beans::XPropertySetInfo > xInputSetInfo( xInputSet->getPropertySetInfo(), UNO_QUERY_THROW );
2882 Reference< beans::XPropertySet > xDestSet( (beans::XPropertySet*)pBackground );
2883 Reference< beans::XPropertySetInfo > xDestSetInfo( xDestSet->getPropertySetInfo(), UNO_QUERY_THROW );
2884
2885 uno::Sequence< beans::Property> aProperties( xDestSetInfo->getProperties() );
2886 sal_Int32 nCount = aProperties.getLength();
2887 beans::Property* pProp = aProperties.getArray();
2888
2889 while( nCount-- )
2890 {
2891 const OUString aPropName( pProp->Name );
2892 if( xInputSetInfo->hasPropertyByName( aPropName ) )
2893 xDestSet->setPropertyValue( aPropName, xInputSet->getPropertyValue( aPropName ) );
2894
2895 pProp++;
2896 }
2897
2898 pBackground->fillItemSet( (SdDrawDocument*)SvxFmDrawPage::mpPage->GetModel(), aSet );
2899 }
2900
2901 // if we find the background style, copy the set to the background
2902 SdDrawDocument* pDoc = (SdDrawDocument*)SvxFmDrawPage::mpPage->GetModel();
2903 SfxStyleSheetBasePool* pSSPool = (SfxStyleSheetBasePool*)pDoc->GetStyleSheetPool();
2904 if(pSSPool)
2905 {
2906 String aLayoutName( static_cast< SdPage* >( SvxFmDrawPage::mpPage )->GetLayoutName() );
2907 aLayoutName.Erase(aLayoutName.Search(String(RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR)))+4);
2908 aLayoutName += String(SdResId(STR_LAYOUT_BACKGROUND));
2909 SfxStyleSheetBase* pStyleSheet = pSSPool->Find( aLayoutName, SD_STYLE_FAMILY_MASTERPAGE );
2910
2911 if( pStyleSheet )
2912 {
2913 pStyleSheet->GetItemSet().Put( aSet );
2914
2915 // repaint only
2916 SvxFmDrawPage::mpPage->ActionChanged();
2917 return;
2918 }
2919 }
2920
2921
2922 // if no background style is available, try the background object
2923 SdrObject* pObj = GetPage()->GetPresObj(PRESOBJ_BACKGROUND);
2924 if( pObj == NULL )
2925 return;
2926
2927 pObj->SetMergedItemSet(aSet);
2928
2929 // repaint only
2930 SvxFmDrawPage::mpPage->ActionChanged();
2931 }
2932 }
2933 catch( Exception& )
2934 {
2935 DBG_ERROR("sd::SdMasterPage::setBackground(), exception caught!");
2936 }
2937 }
2938
2939 void SdMasterPage::getBackground( Any& rValue ) throw()
2940 {
2941 if( GetModel() ) try
2942 {
2943 if( mbIsImpressDocument )
2944 {
2945 Reference< container::XNameAccess > xFamilies( GetModel()->getStyleFamilies(), UNO_QUERY_THROW );
2946 Reference< container::XNameAccess > xFamily( xFamilies->getByName( getName() ), UNO_QUERY_THROW );
2947
2948 const OUString aStyleName( OUString::createFromAscii(sUNO_PseudoSheet_Background) );
2949 rValue <<= Reference< beans::XPropertySet >( xFamily->getByName( aStyleName ), UNO_QUERY_THROW );
2950 }
2951 else
2952 {
2953 SdDrawDocument* pDoc = (SdDrawDocument*)SvxFmDrawPage::mpPage->GetModel();
2954 SfxStyleSheetBasePool* pSSPool = (SfxStyleSheetBasePool*)pDoc->GetStyleSheetPool();
2955 if(pSSPool)
2956 {
2957 String aLayoutName( static_cast< SdPage* >(SvxFmDrawPage::mpPage)->GetLayoutName() );
2958 aLayoutName.Erase( aLayoutName.Search(String(RTL_CONSTASCII_USTRINGPARAM(SD_LT_SEPARATOR)))+4);
2959 aLayoutName += String(SdResId(STR_LAYOUT_BACKGROUND));
2960 SfxStyleSheetBase* pStyleSheet = pSSPool->Find( aLayoutName, SD_STYLE_FAMILY_MASTERPAGE );
2961
2962 if( pStyleSheet )
2963 {
2964 SfxItemSet aStyleSet( pStyleSheet->GetItemSet());
2965 if( aStyleSet.Count() )
2966 {
2967 rValue <<= Reference< beans::XPropertySet >( new SdUnoPageBackground( pDoc, &aStyleSet ) );
2968 return;
2969 }
2970 }
2971 }
2972
2973 // no stylesheet? try old fashion background rectangle
2974 SdrObject* pObj = NULL;
2975 if( SvxFmDrawPage::mpPage->GetObjCount() >= 1 )
2976 {
2977 pObj = SvxFmDrawPage::mpPage->GetObj(0);
2978 if( pObj->GetObjInventor() != SdrInventor || pObj->GetObjIdentifier() != OBJ_RECT )
2979 pObj = NULL;
2980 }
2981
2982 if( pObj )
2983 {
2984 rValue <<= Reference< beans::XPropertySet >( new SdUnoPageBackground( GetModel()->GetDoc(), pObj ) );
2985 return;
2986 }
2987
2988
2989 rValue.clear();
2990 }
2991 }
2992 catch( Exception& )
2993 {
2994 rValue.clear();
2995 DBG_ERROR("sd::SdMasterPage::getBackground(), exception caught!");
2996 }
2997 }
2998
2999 // XNamed
3000 void SAL_CALL SdMasterPage::setName( const OUString& aName )
3001 throw(uno::RuntimeException)
3002 {
3003 OGuard aGuard( Application::GetSolarMutex() );
3004
3005 throwIfDisposed();
3006
3007 if(SvxFmDrawPage::mpPage && GetPage()->GetPageKind() != PK_NOTES)
3008 {
3009 String aNewName( aName );
3010 GetPage()->SetName( aNewName );
3011
3012 if(GetModel()->GetDoc())
3013 GetModel()->GetDoc()->RenameLayoutTemplate(GetPage()->GetLayoutName(), aNewName);
3014
3015 // fake a mode change to repaint the page tab bar
3016 ::sd::DrawDocShell* pDocSh = GetModel()->GetDocShell();
3017 ::sd::ViewShell* pViewSh = pDocSh ? pDocSh->GetViewShell() : NULL;
3018 if( pViewSh && pViewSh->ISA(::sd::DrawViewShell ) )
3019 {
3020 ::sd::DrawViewShell* pDrawViewSh =
3021 static_cast< ::sd::DrawViewShell*>(pViewSh);
3022
3023 EditMode eMode = pDrawViewSh->GetEditMode();
3024 if( eMode == EM_MASTERPAGE )
3025 {
3026 BOOL bLayer = pDrawViewSh->IsLayerModeActive();
3027
3028 pDrawViewSh->ChangeEditMode( eMode, !bLayer );
3029 pDrawViewSh->ChangeEditMode( eMode, bLayer );
3030 }
3031 }
3032
3033 GetModel()->SetModified();
3034 }
3035 }
3036
3037 OUString SAL_CALL SdMasterPage::getName( )
3038 throw(uno::RuntimeException)
3039 {
3040 OGuard aGuard( Application::GetSolarMutex() );
3041
3042 throwIfDisposed();
3043
3044 if(SvxFmDrawPage::mpPage)
3045 {
3046 String aLayoutName( GetPage()->GetLayoutName() );
3047 aLayoutName = aLayoutName.Erase(aLayoutName.Search( String( RTL_CONSTASCII_USTRINGPARAM((SD_LT_SEPARATOR)))));
3048
3049 return aLayoutName;
3050 }
3051
3052 return OUString();
3053 }
3054
3055 // XPresentationPage
3056 Reference< drawing::XDrawPage > SAL_CALL SdMasterPage::getNotesPage()
3057 throw(uno::RuntimeException)
3058 {
3059 OGuard aGuard( Application::GetSolarMutex() );
3060
3061 throwIfDisposed();
3062
3063 if(SvxFmDrawPage::mpPage && GetModel()->GetDoc() )
3064 {
3065 SdPage* pNotesPage = GetModel()->GetDoc()->GetMasterSdPage( (SvxFmDrawPage::mpPage->GetPageNum()-1)>>1, PK_NOTES );
3066 if( pNotesPage )
3067 {
3068 Reference< drawing::XDrawPage > xPage( pNotesPage->getUnoPage(), uno::UNO_QUERY );
3069 return xPage;
3070 }
3071 }
3072 return NULL;
3073 }
3074
3075 // XShapes
3076 void SAL_CALL SdMasterPage::add( const Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
3077 {
3078 SdGenericDrawPage::add( xShape );
3079 }
3080
3081 void SAL_CALL SdMasterPage::remove( const Reference< drawing::XShape >& xShape ) throw(uno::RuntimeException)
3082 {
3083 OGuard aGuard( Application::GetSolarMutex() );
3084
3085 throwIfDisposed();
3086
3087 SvxShape* pShape = SvxShape::getImplementation( xShape );
3088 if( pShape )
3089 {
3090 SdrObject* pObj = pShape->GetSdrObject();
3091 if( pObj )
3092 {
3093 if( GetPage()->IsPresObj( pObj ) )
3094 GetPage()->RemovePresObj(pObj);
3095 }
3096 }
3097
3098 SdGenericDrawPage::remove( xShape );
3099 }
3100
3101
3102 Reference< uno::XInterface > createUnoPageImpl( SdPage* pPage )
3103 {
3104 Reference< uno::XInterface > xPage;
3105
3106 if( pPage && pPage->GetModel() )
3107 {
3108 SdXImpressDocument* pModel = SdXImpressDocument::getImplementation( pPage->GetModel()->getUnoModel() );
3109 if( pModel )
3110 {
3111 if( pPage->IsMasterPage() )
3112 {
3113 xPage = (::cppu::OWeakObject*)new SdMasterPage( pModel, pPage );
3114 }
3115 else
3116 {
3117 xPage = (::cppu::OWeakObject*)new SdDrawPage( pModel, pPage );
3118 }
3119 }
3120 }
3121
3122 return xPage;
3123 }
vba interoperability for OOo