1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26
27 #include "DrawDocShell.hxx"
28 #include <com/sun/star/document/PrinterIndependentLayout.hpp>
29 #include <tools/urlobj.hxx>
30 #include <sfx2/progress.hxx>
31 #include <vcl/waitobj.hxx>
32 #ifndef _SVXIDS_HRC
33 #include <svx/svxids.hrc>
34 #endif
35 #include <editeng/flstitem.hxx>
36 #include <editeng/eeitem.hxx>
37 #include <svl/aeitem.hxx>
38 #include <svl/flagitem.hxx>
39 #include <sot/storage.hxx>
40 #include <sfx2/docfile.hxx>
41 #include <sfx2/docfilt.hxx>
42 #ifndef _DISPATCH_HXX //autogen
43 #include <sfx2/dispatch.hxx>
44 #endif
45 #include <svx/svdotext.hxx>
46 #include <svl/style.hxx>
47 #include <sfx2/printer.hxx>
48 #include <svtools/ctrltool.hxx>
49 #ifndef _SFX_ECODE_HXX //autogen
50 #include <svtools/sfxecode.hxx>
51 #endif
52 #include <sot/clsids.hxx>
53 #include <sot/formats.hxx>
54 #include <sfx2/request.hxx>
55 #ifdef TF_STARONE
56 #include "unomodel.hxx"
57 #endif
58
59 #include <unotools/fltrcfg.hxx>
60 #include <sfx2/frame.hxx>
61 #include <sfx2/viewfrm.hxx>
62 //#include <svx/svxmsbas.hxx>
63 #include <unotools/saveopt.hxx>
64 #include <com/sun/star/drawing/XDrawPage.hpp>
65 #include <com/sun/star/drawing/XDrawView.hpp>
66 #include <comphelper/processfactory.hxx>
67
68 #include "app.hrc"
69 #include "glob.hrc"
70 #include "strings.hrc"
71 #include "strmname.h"
72 #ifndef SD_FRAMW_VIEW_HXX
73 #include "FrameView.hxx"
74 #endif
75 #include "optsitem.hxx"
76 #include "Outliner.hxx"
77 #include "sdattr.hxx"
78 #include "drawdoc.hxx"
79 #include "ViewShell.hxx"
80 #include "app.hxx"
81 #include "View.hxx"
82 #include "sdpage.hxx"
83 #include "sdresid.hxx"
84 #include "DrawViewShell.hxx"
85 #include "ViewShellBase.hxx"
86 #include "Window.hxx"
87 #include "sdmod.hxx"
88 #include "OutlineViewShell.hxx"
89 #include "sdxmlwrp.hxx"
90 #include "sdpptwrp.hxx"
91 #include "sdcgmfilter.hxx"
92 #include "sdgrffilter.hxx"
93 #include "sdhtmlfilter.hxx"
94 #include "framework/FrameworkHelper.hxx"
95
96 #include <sfx2/viewfrm.hxx>
97 #include "SdUnoDrawView.hxx"
98 using namespace ::com::sun::star;
99 using namespace ::com::sun::star::uno;
100 using ::sd::framework::FrameworkHelper;
101
102
103 namespace sd {
104
105 /*************************************************************************
106 |*
107 |* SfxPrinter ggf. erzeugen und zurueckgeben
108 |*
109 \************************************************************************/
110
GetPrinter(sal_Bool bCreate)111 SfxPrinter* DrawDocShell::GetPrinter(sal_Bool bCreate)
112 {
113 if (bCreate && !mpPrinter)
114 {
115 // ItemSet mit speziellem Poolbereich anlegen
116 SfxItemSet* pSet = new SfxItemSet( GetPool(),
117 SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN,
118 SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC,
119 ATTR_OPTIONS_PRINT, ATTR_OPTIONS_PRINT,
120 0 );
121 // PrintOptionsSet setzen
122 SdOptionsPrintItem aPrintItem( ATTR_OPTIONS_PRINT,
123 SD_MOD()->GetSdOptions(mpDoc->GetDocumentType()));
124 SfxFlagItem aFlagItem( SID_PRINTER_CHANGESTODOC );
125 sal_uInt16 nFlags = 0;
126
127 nFlags = (aPrintItem.GetOptionsPrint().IsWarningSize() ? SFX_PRINTER_CHG_SIZE : 0) |
128 (aPrintItem.GetOptionsPrint().IsWarningOrientation() ? SFX_PRINTER_CHG_ORIENTATION : 0);
129 aFlagItem.SetValue( nFlags );
130
131 pSet->Put( aPrintItem );
132 pSet->Put( SfxBoolItem( SID_PRINTER_NOTFOUND_WARN, aPrintItem.GetOptionsPrint().IsWarningPrinter() ) );
133 pSet->Put( aFlagItem );
134
135 mpPrinter = new SfxPrinter(pSet);
136 mbOwnPrinter = sal_True;
137
138 // Ausgabequalitaet setzen
139 sal_uInt16 nQuality = aPrintItem.GetOptionsPrint().GetOutputQuality();
140
141 sal_uLong nMode = DRAWMODE_DEFAULT;
142
143 if( nQuality == 1 )
144 nMode = DRAWMODE_GRAYLINE | DRAWMODE_GRAYFILL | DRAWMODE_BLACKTEXT | DRAWMODE_GRAYBITMAP | DRAWMODE_GRAYGRADIENT;
145 else if( nQuality == 2 )
146 nMode = DRAWMODE_BLACKLINE | DRAWMODE_BLACKTEXT | DRAWMODE_WHITEFILL | DRAWMODE_GRAYBITMAP | DRAWMODE_WHITEGRADIENT;
147
148 mpPrinter->SetDrawMode( nMode );
149
150 MapMode aMM (mpPrinter->GetMapMode());
151 aMM.SetMapUnit(MAP_100TH_MM);
152 mpPrinter->SetMapMode(aMM);
153 UpdateRefDevice();
154 }
155 return mpPrinter;
156 }
157
158 /*************************************************************************
159 |*
160 |* neuen SfxPrinter setzen (Eigentuemeruebergang)
161 |*
162 \************************************************************************/
163
SetPrinter(SfxPrinter * pNewPrinter)164 void DrawDocShell::SetPrinter(SfxPrinter *pNewPrinter)
165 {
166 if ( mpViewShell )
167 {
168 ::sd::View* pView = mpViewShell->GetView();
169 if ( pView->IsTextEdit() )
170 pView->SdrEndTextEdit();
171 }
172
173 if ( mpPrinter && mbOwnPrinter && (mpPrinter != pNewPrinter) )
174 {
175 delete mpPrinter;
176 }
177
178 mpPrinter = pNewPrinter;
179 mbOwnPrinter = sal_True;
180 if ( mpDoc->GetPrinterIndependentLayout() == ::com::sun::star::document::PrinterIndependentLayout::DISABLED )
181 UpdateFontList();
182 UpdateRefDevice();
183 }
184
UpdateFontList()185 void DrawDocShell::UpdateFontList()
186 {
187 delete mpFontList;
188 OutputDevice* pRefDevice = NULL;
189 if ( mpDoc->GetPrinterIndependentLayout() == ::com::sun::star::document::PrinterIndependentLayout::DISABLED )
190 pRefDevice = GetPrinter(sal_True);
191 else
192 pRefDevice = SD_MOD()->GetVirtualRefDevice();
193 mpFontList = new FontList( pRefDevice, NULL, sal_False );
194 SvxFontListItem aFontListItem( mpFontList, SID_ATTR_CHAR_FONTLIST );
195 PutItem( aFontListItem );
196 }
197
198 /*************************************************************************
199 |*
200 |*
201 |*
202 \************************************************************************/
GetDocumentPrinter()203 Printer* DrawDocShell::GetDocumentPrinter()
204 {
205 return GetPrinter(sal_False);
206 }
207
208 /*************************************************************************
209 |*
210 |*
211 |*
212 \************************************************************************/
OnDocumentPrinterChanged(Printer * pNewPrinter)213 void DrawDocShell::OnDocumentPrinterChanged(Printer* pNewPrinter)
214 {
215 // if we already have a printer, see if its the same
216 if( mpPrinter )
217 {
218 // easy case
219 if( mpPrinter == pNewPrinter )
220 return;
221
222 // compare if its the same printer with the same job setup
223 if( (mpPrinter->GetName() == pNewPrinter->GetName()) &&
224 (mpPrinter->GetJobSetup() == pNewPrinter->GetJobSetup()))
225 return;
226 }
227
228 // if (mpPrinter->IsA(SfxPrinter))
229 {
230 // Da kein RTTI verfuegbar, wird hart gecasted (...)
231 SetPrinter((SfxPrinter*) pNewPrinter);
232
233 // Printer gehoert dem Container
234 mbOwnPrinter = sal_False;
235 }
236 }
237
238 /*************************************************************************
239 |*
240 |*
241 |*
242 \************************************************************************/
UpdateRefDevice()243 void DrawDocShell::UpdateRefDevice()
244 {
245 if( mpDoc )
246 {
247 // Determine the device for which the output will be formatted.
248 OutputDevice* pRefDevice = NULL;
249 switch (mpDoc->GetPrinterIndependentLayout())
250 {
251 case ::com::sun::star::document::PrinterIndependentLayout::DISABLED:
252 pRefDevice = mpPrinter;
253 break;
254
255 case ::com::sun::star::document::PrinterIndependentLayout::ENABLED:
256 pRefDevice = SD_MOD()->GetVirtualRefDevice();
257 break;
258
259 default:
260 // We are confronted with an invalid or un-implemented
261 // layout mode. Use the printer as formatting device
262 // as a fall-back.
263 DBG_ASSERT(false, "DrawDocShell::UpdateRefDevice(): Unexpected printer layout mode");
264
265 pRefDevice = mpPrinter;
266 break;
267 }
268 mpDoc->SetRefDevice( pRefDevice );
269
270 ::sd::Outliner* pOutl = mpDoc->GetOutliner( sal_False );
271
272 if( pOutl )
273 pOutl->SetRefDevice( pRefDevice );
274
275 ::sd::Outliner* pInternalOutl = mpDoc->GetInternalOutliner( sal_False );
276
277 if( pInternalOutl )
278 pInternalOutl->SetRefDevice( pRefDevice );
279 }
280 }
281
282 /*************************************************************************
283 |*
284 |* InitNew, (Dokument wird neu erzeugt): Streams oeffnen
285 |*
286 \************************************************************************/
287
InitNew(const::com::sun::star::uno::Reference<::com::sun::star::embed::XStorage> & xStorage)288 sal_Bool DrawDocShell::InitNew( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage )
289 {
290 sal_Bool bRet = sal_False;
291
292 bRet = SfxObjectShell::InitNew( xStorage );
293
294 Rectangle aVisArea( Point(0, 0), Size(14100, 10000) );
295 SetVisArea(aVisArea);
296
297 if (bRet)
298 {
299 if( !mbSdDataObj )
300 mpDoc->NewOrLoadCompleted(NEW_DOC); // otherwise calling
301 // NewOrLoadCompleted(NEW_LOADED) in
302 // SdDrawDocument::AllocModel()
303 }
304 return bRet;
305 }
306
307 /*************************************************************************
308 |*
309 |* Load: Pools und Dokument laden
310 |*
311 \************************************************************************/
312
Load(SfxMedium & rMedium)313 sal_Bool DrawDocShell::Load( SfxMedium& rMedium )
314 {
315 mbNewDocument = sal_False;
316
317 sal_Bool bRet = sal_False;
318 bool bStartPresentation = false;
319 ErrCode nError = ERRCODE_NONE;
320
321 SfxItemSet* pSet = rMedium.GetItemSet();
322
323
324 if( pSet )
325 {
326 if( ( SFX_ITEM_SET == pSet->GetItemState(SID_PREVIEW ) ) && ( (SfxBoolItem&) ( pSet->Get( SID_PREVIEW ) ) ).GetValue() )
327 {
328 mpDoc->SetStarDrawPreviewMode( sal_True );
329 }
330
331 if( SFX_ITEM_SET == pSet->GetItemState(SID_DOC_STARTPRESENTATION)&&
332 ( (SfxBoolItem&) ( pSet->Get( SID_DOC_STARTPRESENTATION ) ) ).GetValue() )
333 {
334 bStartPresentation = true;
335 mpDoc->SetStartWithPresentation( true );
336 }
337 }
338
339 bRet = SfxObjectShell::Load( rMedium );
340 if( bRet )
341 {
342 bRet = SdXMLFilter( rMedium, *this, sal_True, SDXMLMODE_Normal, SotStorage::GetVersion( rMedium.GetStorage() ) ).Import( nError );
343 }
344
345 if( bRet )
346 {
347 UpdateTablePointers();
348
349 // #108451# If we're an embedded OLE object, use tight bounds
350 // for our visArea. No point in showing the user lots of empty
351 // space. Had to remove the check for empty VisArea below,
352 // since XML load always sets a VisArea before.
353 //TODO/LATER: looks a little bit strange!
354 if( ( GetCreateMode() == SFX_CREATE_MODE_EMBEDDED ) && SfxObjectShell::GetVisArea( ASPECT_CONTENT ).IsEmpty() )
355 {
356 SdPage* pPage = mpDoc->GetSdPage( 0, PK_STANDARD );
357
358 if( pPage )
359 SetVisArea( Rectangle( pPage->GetAllObjBoundRect() ) );
360 }
361
362 FinishedLoading( SFX_LOADED_ALL );
363
364 const INetURLObject aUrl;
365 SfxObjectShell::SetAutoLoad( aUrl, 0, sal_False );
366 }
367 else
368 {
369 if( nError == ERRCODE_IO_BROKENPACKAGE )
370 SetError( ERRCODE_IO_BROKENPACKAGE, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
371
372 // TODO/LATER: correct error handling?!
373 //pStore->SetError( SVSTREAM_WRONGVERSION, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
374 else
375 SetError( ERRCODE_ABORT, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
376 }
377
378 // tell SFX to change viewshell when in preview mode
379 if( IsPreview() || bStartPresentation )
380 {
381 SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
382 if( pMediumSet )
383 pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, bStartPresentation ? 1 : 5 ) );
384 }
385
386 return bRet;
387 }
388
389 /*************************************************************************
390 |*
391 |* LoadFrom: Inhalte fuer Organizer laden
392 |*
393 \************************************************************************/
394
LoadFrom(SfxMedium & rMedium)395 sal_Bool DrawDocShell::LoadFrom( SfxMedium& rMedium )
396 {
397 mbNewDocument = sal_False;
398
399 WaitObject* pWait = NULL;
400 if( mpViewShell )
401 pWait = new WaitObject( (Window*) mpViewShell->GetActiveWindow() );
402
403 sal_Bool bRet = sal_False;
404
405 /*
406 // #90691# return to old behaviour (before #80365#): construct own medium
407 SfxMedium aMedium(xStorage);
408
409 // #90691# for having a progress bar nonetheless for XML copy it
410 // from the local DocShell medium (GetMedium()) to the constructed one
411 SfxMedium* pLocalMedium = GetMedium();
412 if(pLocalMedium)
413 {
414 SfxItemSet* pLocalItemSet = pLocalMedium->GetItemSet();
415 SfxItemSet* pDestItemSet = aMedium.GetItemSet();
416
417 if(pLocalItemSet && pDestItemSet)
418 {
419 const SfxUnoAnyItem* pItem = static_cast<
420 const SfxUnoAnyItem*>(
421 pLocalItemSet->GetItem(SID_PROGRESS_STATUSBAR_CONTROL));
422
423 if(pItem)
424 {
425 pDestItemSet->Put(*pItem);
426 }
427 }
428 } */
429
430 mpDoc->NewOrLoadCompleted( NEW_DOC );
431 mpDoc->CreateFirstPages();
432 mpDoc->StopWorkStartupDelay();
433
434 // TODO/LATER: nobody is interested in the error code?!
435 ErrCode nError = ERRCODE_NONE;
436 bRet = SdXMLFilter( rMedium, *this, sal_True, SDXMLMODE_Organizer, SotStorage::GetVersion( rMedium.GetStorage() ) ).Import( nError );
437
438
439 // tell SFX to change viewshell when in preview mode
440 if( IsPreview() )
441 {
442 SfxItemSet *pSet = GetMedium()->GetItemSet();
443
444 if( pSet )
445 pSet->Put( SfxUInt16Item( SID_VIEW_ID, 5 ) );
446 }
447
448 delete pWait;
449
450 return bRet;
451 }
452
453 /*************************************************************************
454 |*
455 |* ConvertFrom: aus Fremdformat laden
456 |*
457 \************************************************************************/
458
ConvertFrom(SfxMedium & rMedium)459 sal_Bool DrawDocShell::ConvertFrom( SfxMedium& rMedium )
460 {
461 mbNewDocument = sal_False;
462
463 const String aFilterName( rMedium.GetFilter()->GetFilterName() );
464 sal_Bool bRet = sal_False;
465 bool bStartPresentation = false;
466
467 SetWaitCursor( sal_True );
468
469 SfxItemSet* pSet = rMedium.GetItemSet();
470 if( pSet )
471 {
472 if( ( SFX_ITEM_SET == pSet->GetItemState(SID_PREVIEW ) ) && ( (SfxBoolItem&) ( pSet->Get( SID_PREVIEW ) ) ).GetValue() )
473 {
474 mpDoc->SetStarDrawPreviewMode( sal_True );
475 }
476
477 if( SFX_ITEM_SET == pSet->GetItemState(SID_DOC_STARTPRESENTATION)&&
478 ( (SfxBoolItem&) ( pSet->Get( SID_DOC_STARTPRESENTATION ) ) ).GetValue() )
479 {
480 bStartPresentation = true;
481 mpDoc->SetStartWithPresentation( true );
482 }
483 }
484
485 if( aFilterName == pFilterPowerPoint97 || aFilterName == pFilterPowerPoint97Template)
486 {
487 mpDoc->StopWorkStartupDelay();
488 bRet = SdPPTFilter( rMedium, *this, sal_True ).Import();
489 }
490 else if (aFilterName.SearchAscii("impress8" ) != STRING_NOTFOUND ||
491 aFilterName.SearchAscii("draw8") != STRING_NOTFOUND )
492 {
493 // TODO/LATER: nobody is interested in the error code?!
494 mpDoc->CreateFirstPages();
495 mpDoc->StopWorkStartupDelay();
496 ErrCode nError = ERRCODE_NONE;
497 bRet = SdXMLFilter( rMedium, *this, sal_True ).Import( nError );
498
499 }
500 else if (aFilterName.SearchAscii("StarOffice XML (Draw)" ) != STRING_NOTFOUND || aFilterName.SearchAscii("StarOffice XML (Impress)") != STRING_NOTFOUND )
501 {
502 // TODO/LATER: nobody is interested in the error code?!
503 mpDoc->CreateFirstPages();
504 mpDoc->StopWorkStartupDelay();
505 ErrCode nError = ERRCODE_NONE;
506 bRet = SdXMLFilter( rMedium, *this, sal_True, SDXMLMODE_Normal, SOFFICE_FILEFORMAT_60 ).Import( nError );
507 }
508 else if( aFilterName.EqualsAscii( "CGM - Computer Graphics Metafile" ) )
509 {
510 mpDoc->CreateFirstPages();
511 mpDoc->StopWorkStartupDelay();
512 bRet = SdCGMFilter( rMedium, *this, sal_True ).Import();
513 }
514 else
515 {
516 mpDoc->CreateFirstPages();
517 mpDoc->StopWorkStartupDelay();
518 bRet = SdGRFFilter( rMedium, *this ).Import();
519 }
520
521 FinishedLoading( SFX_LOADED_MAINDOCUMENT | SFX_LOADED_IMAGES );
522
523 // tell SFX to change viewshell when in preview mode
524 if( IsPreview() )
525 {
526 SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
527
528 if( pMediumSet )
529 pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, 5 ) );
530 }
531 SetWaitCursor( sal_False );
532
533 // tell SFX to change viewshell when in preview mode
534 if( IsPreview() || bStartPresentation )
535 {
536 SfxItemSet *pMediumSet = GetMedium()->GetItemSet();
537 if( pMediumSet )
538 pMediumSet->Put( SfxUInt16Item( SID_VIEW_ID, bStartPresentation ? 1 : 5 ) );
539 }
540
541 return bRet;
542 }
543
544 /*************************************************************************
545 |*
546 |* Save: Pools und Dokument in die offenen Streams schreiben
547 |*
548 \************************************************************************/
549
Save()550 sal_Bool DrawDocShell::Save()
551 {
552 mpDoc->StopWorkStartupDelay();
553
554 //TODO/LATER: why this?!
555 if( GetCreateMode() == SFX_CREATE_MODE_STANDARD )
556 SfxObjectShell::SetVisArea( Rectangle() );
557
558 sal_Bool bRet = SfxObjectShell::Save();
559
560 if( bRet )
561 {
562 // #86834# Call UpdateDocInfoForSave() before export
563 UpdateDocInfoForSave();
564
565 bRet = SdXMLFilter( *GetMedium(), *this, sal_True, SDXMLMODE_Normal, SotStorage::GetVersion( GetMedium()->GetStorage() ) ).Export();
566 }
567
568 return bRet;
569 }
570
571 /*************************************************************************
572 |*
573 |* SaveAs: Pools und Dokument in den angegebenen Storage sichern
574 |*
575 \************************************************************************/
576
SaveAs(SfxMedium & rMedium)577 sal_Bool DrawDocShell::SaveAs( SfxMedium& rMedium )
578 {
579 mpDoc->setDocAccTitle(String());
580 SfxViewFrame* pFrame1 = SfxViewFrame::GetFirst( this );
581 if (pFrame1)
582 {
583 ::Window* pWindow = &pFrame1->GetWindow();
584 if ( pWindow )
585 {
586 ::Window* pSysWin = pWindow->GetSystemWindow();
587 if ( pSysWin )
588 {
589 pSysWin->SetAccessibleName(String());
590 }
591 }
592 }
593 mpDoc->StopWorkStartupDelay();
594
595 //TODO/LATER: why this?!
596 if( GetCreateMode() == SFX_CREATE_MODE_STANDARD )
597 SfxObjectShell::SetVisArea( Rectangle() );
598
599 sal_uInt32 nVBWarning = ERRCODE_NONE;
600 sal_Bool bRet = SfxObjectShell::SaveAs( rMedium );
601
602 if( bRet )
603 {
604 // #86834# Call UpdateDocInfoForSave() before export
605 UpdateDocInfoForSave();
606 bRet = SdXMLFilter( rMedium, *this, sal_True, SDXMLMODE_Normal, SotStorage::GetVersion( rMedium.GetStorage() ) ).Export();
607 }
608
609 if( GetError() == ERRCODE_NONE )
610 SetError( nVBWarning, ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) ) );
611
612 return bRet;
613 }
614
615 /*************************************************************************
616 |*
617 |* ConvertTo: im Fremdformat speichern
618 |*
619 \************************************************************************/
620
ConvertTo(SfxMedium & rMedium)621 sal_Bool DrawDocShell::ConvertTo( SfxMedium& rMedium )
622 {
623 sal_Bool bRet = sal_False;
624
625 if( mpDoc->GetPageCount() )
626 {
627 const SfxFilter* pMediumFilter = rMedium.GetFilter();
628 const String aTypeName( pMediumFilter->GetTypeName() );
629 SdFilter* pFilter = NULL;
630
631 if( aTypeName.SearchAscii( "graphic_HTML" ) != STRING_NOTFOUND )
632 {
633 pFilter = new SdHTMLFilter( rMedium, *this, sal_True );
634 }
635 else if( aTypeName.SearchAscii( "MS_PowerPoint_97" ) != STRING_NOTFOUND )
636 {
637 pFilter = new SdPPTFilter( rMedium, *this, sal_True );
638 ((SdPPTFilter*)pFilter)->PreSaveBasic();
639 }
640 else if ( aTypeName.SearchAscii( "CGM_Computer_Graphics_Metafile" ) != STRING_NOTFOUND )
641 {
642 pFilter = new SdCGMFilter( rMedium, *this, sal_True );
643 }
644 else if( ( aTypeName.SearchAscii( "draw8" ) != STRING_NOTFOUND ) ||
645 ( aTypeName.SearchAscii( "impress8" ) != STRING_NOTFOUND ) )
646 {
647 pFilter = new SdXMLFilter( rMedium, *this, sal_True );
648 UpdateDocInfoForSave();
649 }
650 else if( ( aTypeName.SearchAscii( "StarOffice_XML_Impress" ) != STRING_NOTFOUND ) ||
651 ( aTypeName.SearchAscii( "StarOffice_XML_Draw" ) != STRING_NOTFOUND ) )
652 {
653 pFilter = new SdXMLFilter( rMedium, *this, sal_True, SDXMLMODE_Normal, SOFFICE_FILEFORMAT_60 );
654 UpdateDocInfoForSave();
655 }
656 else
657 {
658 pFilter = new SdGRFFilter( rMedium, *this );
659 }
660
661 if( pFilter )
662 {
663 const sal_uLong nOldSwapMode = mpDoc->GetSwapGraphicsMode();
664
665 mpDoc->SetSwapGraphicsMode( SDR_SWAPGRAPHICSMODE_TEMP );
666
667 bRet = pFilter->Export();
668 if( !bRet )
669 mpDoc->SetSwapGraphicsMode( nOldSwapMode );
670
671 delete pFilter;
672 }
673 }
674
675 return bRet;
676 }
677
678 /*************************************************************************
679 |*
680 |* SaveCompleted: die eigenen Streams wieder oeffnen, damit kein anderer
681 |* sie "besetzt"
682 |*
683 \************************************************************************/
684
SaveCompleted(const::com::sun::star::uno::Reference<::com::sun::star::embed::XStorage> & xStorage)685 sal_Bool DrawDocShell::SaveCompleted( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& xStorage )
686 {
687 sal_Bool bRet = sal_False;
688
689 if( SfxObjectShell::SaveCompleted(xStorage) )
690 {
691 mpDoc->NbcSetChanged( sal_False );
692
693 if( mpViewShell )
694 {
695 if( mpViewShell->ISA( OutlineViewShell ) )
696 static_cast<OutlineView*>(mpViewShell->GetView())
697 ->GetOutliner()->ClearModifyFlag();
698
699 SdrOutliner* pOutl = mpViewShell->GetView()->GetTextEditOutliner();
700 if( pOutl )
701 {
702 SdrObject* pObj = mpViewShell->GetView()->GetTextEditObject();
703 if( pObj )
704 pObj->NbcSetOutlinerParaObject( pOutl->CreateParaObject() );
705
706 pOutl->ClearModifyFlag();
707 }
708 }
709
710 bRet = sal_True;
711
712 SfxViewFrame* pFrame = ( mpViewShell && mpViewShell->GetViewFrame() ) ?
713 mpViewShell->GetViewFrame() :
714 SfxViewFrame::Current();
715
716 if( pFrame )
717 pFrame->GetBindings().Invalidate( SID_NAVIGATOR_STATE, sal_True, sal_False );
718 }
719 return bRet;
720 }
721
722 /*************************************************************************
723 |*
724 |* Referenz auf Dokument
725 |*
726 \************************************************************************/
727
GetDoc()728 SdDrawDocument* DrawDocShell::GetDoc()
729 {
730 return mpDoc;
731 }
732
733 /*************************************************************************
734 |*
735 |* Referenz auf Dokument
736 |*
737 \************************************************************************/
738
GetStyleSheetPool()739 SfxStyleSheetBasePool* DrawDocShell::GetStyleSheetPool()
740 {
741 return( (SfxStyleSheetBasePool*) mpDoc->GetStyleSheetPool() );
742 }
743
744 /*************************************************************************
745 |*
746 |* Sprung zu Bookmark
747 |*
748 \************************************************************************/
749
GotoBookmark(const String & rBookmark)750 sal_Bool DrawDocShell::GotoBookmark(const String& rBookmark)
751 {
752 sal_Bool bFound = sal_False;
753
754 if (mpViewShell && mpViewShell->ISA(DrawViewShell))
755 {
756 DrawViewShell* pDrawViewShell = static_cast<DrawViewShell*>(mpViewShell);
757 ViewShellBase& rBase (mpViewShell->GetViewShellBase());
758
759 sal_Bool bIsMasterPage = sal_False;
760 sal_uInt16 nPageNumber = SDRPAGE_NOTFOUND;
761 SdrObject* pObj = NULL;
762
763 rtl::OUString sBookmark( rBookmark );
764 const rtl::OUString sInteraction( RTL_CONSTASCII_USTRINGPARAM( "action?" ) );
765 if ( sBookmark.match( sInteraction ) )
766 {
767 const rtl::OUString sJump( RTL_CONSTASCII_USTRINGPARAM( "jump=" ) );
768 if ( sBookmark.match( sJump, sInteraction.getLength() ) )
769 {
770 rtl::OUString aDestination( sBookmark.copy( sInteraction.getLength() + sJump.getLength() ) );
771 if ( aDestination.match( String( RTL_CONSTASCII_USTRINGPARAM( "firstslide" ) ) ) )
772 {
773 nPageNumber = 1;
774 }
775 else if ( aDestination.match( String( RTL_CONSTASCII_USTRINGPARAM( "lastslide" ) ) ) )
776 {
777 nPageNumber = mpDoc->GetPageCount() - 2;
778 }
779 else if ( aDestination.match( String( RTL_CONSTASCII_USTRINGPARAM( "previousslide" ) ) ) )
780 {
781 SdPage* pPage = pDrawViewShell->GetActualPage();
782 nPageNumber = pPage->GetPageNum();
783 nPageNumber = nPageNumber > 2 ? nPageNumber - 2 : SDRPAGE_NOTFOUND;
784 }
785 else if ( aDestination.match( String( RTL_CONSTASCII_USTRINGPARAM( "nextslide" ) ) ) )
786 {
787 SdPage* pPage = pDrawViewShell->GetActualPage();
788 nPageNumber = pPage->GetPageNum() + 2;
789 if ( nPageNumber >= mpDoc->GetPageCount() )
790 nPageNumber = SDRPAGE_NOTFOUND;
791 }
792 }
793 }
794 else
795 {
796 String aBookmark( rBookmark );
797
798 // Ist das Bookmark eine Seite?
799 nPageNumber = mpDoc->GetPageByName( aBookmark, bIsMasterPage );
800
801 if (nPageNumber == SDRPAGE_NOTFOUND)
802 {
803 // Ist das Bookmark ein Objekt?
804 pObj = mpDoc->GetObj(aBookmark);
805
806 if (pObj)
807 {
808 nPageNumber = pObj->GetPage()->GetPageNum();
809 }
810 }
811 }
812 if (nPageNumber != SDRPAGE_NOTFOUND)
813 {
814 // Jump to the bookmarked page. This is done in three steps.
815
816 bFound = sal_True;
817 SdPage* pPage;
818 if (bIsMasterPage)
819 pPage = (SdPage*) mpDoc->GetMasterPage(nPageNumber);
820 else
821 pPage = (SdPage*) mpDoc->GetPage(nPageNumber);
822
823 // 1.) Change the view shell to the edit view, the notes view,
824 // or the handout view.
825 PageKind eNewPageKind = pPage->GetPageKind();
826
827 if( (eNewPageKind != PK_STANDARD) && (mpDoc->GetDocumentType() == DOCUMENT_TYPE_DRAW) )
828 return sal_False;
829
830 if (eNewPageKind != pDrawViewShell->GetPageKind())
831 {
832 // Arbeitsbereich wechseln
833 GetFrameView()->SetPageKind(eNewPageKind);
834 ::rtl::OUString sViewURL;
835 switch (eNewPageKind)
836 {
837 case PK_STANDARD:
838 sViewURL = FrameworkHelper::msImpressViewURL;
839 break;
840 case PK_NOTES:
841 sViewURL = FrameworkHelper::msNotesViewURL;
842 break;
843 case PK_HANDOUT:
844 sViewURL = FrameworkHelper::msHandoutViewURL;
845 break;
846 default:
847 break;
848 }
849 if (sViewURL.getLength() > 0)
850 {
851 ::boost::shared_ptr<FrameworkHelper> pHelper (
852 FrameworkHelper::Instance(rBase));
853 pHelper->RequestView(
854 sViewURL,
855 FrameworkHelper::msCenterPaneURL);
856 pHelper->WaitForUpdate();
857
858 // Get the new DrawViewShell.
859 mpViewShell = pHelper->GetViewShell(FrameworkHelper::msCenterPaneURL).get();
860 pDrawViewShell = dynamic_cast<sd::DrawViewShell*>(mpViewShell);
861 }
862 else
863 {
864 pDrawViewShell = NULL;
865 }
866 }
867
868 if (pDrawViewShell != NULL)
869 {
870 // Set the edit mode to either the normal edit mode or the
871 // master page mode.
872 EditMode eNewEditMode = EM_PAGE;
873 if (bIsMasterPage)
874 {
875 eNewEditMode = EM_MASTERPAGE;
876 }
877
878 if (eNewEditMode != pDrawViewShell->GetEditMode())
879 {
880 // EditMode setzen
881 pDrawViewShell->ChangeEditMode(eNewEditMode, sal_False);
882 }
883
884 // Make the bookmarked page the current page. This is done
885 // by using the API because this takes care of all the
886 // little things to be done. Especially writing the view
887 // data to the frame view (see bug #107803#).
888 sal_uInt16 nSdPgNum = (nPageNumber - 1) / 2;
889 Reference<drawing::XDrawView> xController (rBase.GetController(), UNO_QUERY);
890 if (xController.is())
891 {
892 Reference<drawing::XDrawPage> xDrawPage (pPage->getUnoPage(), UNO_QUERY);
893 xController->setCurrentPage (xDrawPage);
894 }
895 else
896 {
897 // As a fall back switch to the page via the core.
898 DBG_ASSERT (xController.is(),
899 "DrawDocShell::GotoBookmark: can't switch page via API");
900 pDrawViewShell->SwitchPage(nSdPgNum);
901 }
902
903 if (pObj != NULL)
904 {
905 // Objekt einblenden und selektieren
906 pDrawViewShell->MakeVisible(pObj->GetLogicRect(),
907 *pDrawViewShell->GetActiveWindow());
908 pDrawViewShell->GetView()->UnmarkAll();
909 pDrawViewShell->GetView()->MarkObj(
910 pObj,
911 pDrawViewShell->GetView()->GetSdrPageView(), sal_False);
912 }
913 }
914 }
915
916 SfxBindings& rBindings = (pDrawViewShell->GetViewFrame()!=NULL
917 ? pDrawViewShell->GetViewFrame()
918 : SfxViewFrame::Current() )->GetBindings();
919
920 rBindings.Invalidate(SID_NAVIGATOR_STATE, sal_True, sal_False);
921 rBindings.Invalidate(SID_NAVIGATOR_PAGENAME);
922 }
923
924 return (bFound);
925 }
926
927 //Solution: If object is marked , return true , else return false .
IsMarked(SdrObject * pObject)928 sal_Bool DrawDocShell::IsMarked( SdrObject* pObject )
929 {
930 sal_Bool bisMarked =sal_False;
931
932 if (mpViewShell && mpViewShell->ISA(DrawViewShell))
933 {
934 DrawViewShell* pDrViewSh = (DrawViewShell*) mpViewShell;
935 if (pObject )
936 {
937 bisMarked = pDrViewSh->GetView()->IsObjMarked(pObject);
938 }
939 }
940 return bisMarked;
941 }
942 //Solution: If object is marked , return true , else return false .
GetObjectIsmarked(const String & rBookmark)943 sal_Bool DrawDocShell::GetObjectIsmarked(const String& rBookmark)
944 {
945 OSL_TRACE("GotoBookmark %s",
946 ::rtl::OUStringToOString(rBookmark, RTL_TEXTENCODING_UTF8).getStr());
947 sal_Bool bUnMark = sal_False;
948
949 if (mpViewShell && mpViewShell->ISA(DrawViewShell))
950 {
951 DrawViewShell* pDrViewSh = (DrawViewShell*) mpViewShell;
952
953 String aBookmark( rBookmark );
954
955 if( rBookmark.Len() && rBookmark.GetChar( 0 ) == sal_Unicode('#') )
956 aBookmark = rBookmark.Copy( 1 );
957
958 // Ist das Bookmark eine Seite?
959 sal_Bool bIsMasterPage;
960 sal_uInt16 nPgNum = mpDoc->GetPageByName( aBookmark, bIsMasterPage );
961 SdrObject* pObj = NULL;
962
963 if (nPgNum == SDRPAGE_NOTFOUND)
964 {
965 // Ist das Bookmark ein Objekt?
966 pObj = mpDoc->GetObj(aBookmark);
967
968 if (pObj)
969 {
970 nPgNum = pObj->GetPage()->GetPageNum();
971 }
972 }
973
974 if (nPgNum != SDRPAGE_NOTFOUND)
975 {
976 /**********************************************************
977 * Zur Seite springen
978 **********************************************************/
979
980 SdPage* pPage = (SdPage*) mpDoc->GetPage(nPgNum);
981
982 PageKind eNewPageKind = pPage->GetPageKind();
983
984 if (eNewPageKind != pDrViewSh->GetPageKind())
985 {
986 // Arbeitsbereich wechseln
987 GetFrameView()->SetPageKind(eNewPageKind);
988 ( ( mpViewShell && mpViewShell->GetViewFrame() ) ?
989 mpViewShell->GetViewFrame() : SfxViewFrame::Current() )->
990 GetDispatcher()->Execute( SID_VIEWSHELL0, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD );
991
992 // Die aktuelle ViewShell hat sich geaendert!
993 pDrViewSh = (DrawViewShell*) mpViewShell;
994 }
995
996 EditMode eNewEditMode = EM_PAGE;
997
998 if( bIsMasterPage )
999 {
1000 eNewEditMode = EM_MASTERPAGE;
1001 }
1002
1003 if (eNewEditMode != pDrViewSh->GetEditMode())
1004 {
1005 // EditMode setzen
1006 pDrViewSh->ChangeEditMode(eNewEditMode, sal_False);
1007 }
1008
1009 // Jump to the page. This is done by using the API because this
1010 // takes care of all the little things to be done. Especially
1011 // writing the view data to the frame view (see bug #107803#).
1012 sal_uInt16 nSdPgNum = (nPgNum - 1) / 2;
1013 SdUnoDrawView* pUnoDrawView = new SdUnoDrawView (
1014 pDrViewSh->GetViewShellBase().GetDrawController(),
1015 *pDrViewSh,
1016 *pDrViewSh->GetView());
1017 if (pUnoDrawView != NULL)
1018 {
1019 ::com::sun::star::uno::Reference<
1020 ::com::sun::star::drawing::XDrawPage> xDrawPage (
1021 pPage->getUnoPage(), ::com::sun::star::uno::UNO_QUERY);
1022 pUnoDrawView->setCurrentPage (xDrawPage);
1023 }
1024 else
1025 {
1026 // As a fall back switch to the page via the core.
1027 DBG_ASSERT (pUnoDrawView!=NULL,
1028 "SdDrawDocShell::GotoBookmark: can't switch page via API");
1029 pDrViewSh->SwitchPage(nSdPgNum);
1030 }
1031 delete pUnoDrawView;
1032
1033
1034 if (pObj)
1035 {
1036 // Objekt einblenden und selektieren
1037 pDrViewSh->MakeVisible(pObj->GetLogicRect(),
1038 *pDrViewSh->GetActiveWindow());
1039
1040 bUnMark = pDrViewSh->GetView()->IsObjMarked(pObj);
1041
1042
1043 }
1044 }
1045 }
1046
1047 return ( bUnMark);
1048 }
1049 //Solution: realize multi-selection of objects
GotoTreeBookmark(const String & rBookmark)1050 sal_Bool DrawDocShell::GotoTreeBookmark(const String& rBookmark)
1051 {
1052 OSL_TRACE("GotoBookmark %s",
1053 ::rtl::OUStringToOString(rBookmark, RTL_TEXTENCODING_UTF8).getStr());
1054 sal_Bool bFound = sal_False;
1055
1056 if (mpViewShell && mpViewShell->ISA(DrawViewShell))
1057 {
1058 DrawViewShell* pDrViewSh = (DrawViewShell*) mpViewShell;
1059
1060 String aBookmark( rBookmark );
1061
1062 if( rBookmark.Len() && rBookmark.GetChar( 0 ) == sal_Unicode('#') )
1063 aBookmark = rBookmark.Copy( 1 );
1064
1065 // Ist das Bookmark eine Seite?
1066 sal_Bool bIsMasterPage;
1067 sal_uInt16 nPgNum = mpDoc->GetPageByName( aBookmark, bIsMasterPage );
1068 SdrObject* pObj = NULL;
1069
1070 if (nPgNum == SDRPAGE_NOTFOUND)
1071 {
1072 // Ist das Bookmark ein Objekt?
1073 pObj = mpDoc->GetObj(aBookmark);
1074
1075 if (pObj)
1076 {
1077 nPgNum = pObj->GetPage()->GetPageNum();
1078 }
1079 }
1080
1081 if (nPgNum != SDRPAGE_NOTFOUND)
1082 {
1083 /**********************************************************
1084 * Zur Seite springen
1085 **********************************************************/
1086 bFound = sal_True;
1087 SdPage* pPage = (SdPage*) mpDoc->GetPage(nPgNum);
1088
1089 PageKind eNewPageKind = pPage->GetPageKind();
1090
1091 if (eNewPageKind != pDrViewSh->GetPageKind())
1092 {
1093 // Arbeitsbereich wechseln
1094 GetFrameView()->SetPageKind(eNewPageKind);
1095 ( ( mpViewShell && mpViewShell->GetViewFrame() ) ?
1096 mpViewShell->GetViewFrame() : SfxViewFrame::Current() )->
1097 GetDispatcher()->Execute( SID_VIEWSHELL0, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD );
1098
1099 // Die aktuelle ViewShell hat sich geaendert!
1100 pDrViewSh = (DrawViewShell*) mpViewShell;
1101 }
1102
1103 EditMode eNewEditMode = EM_PAGE;
1104
1105 if( bIsMasterPage )
1106 {
1107 eNewEditMode = EM_MASTERPAGE;
1108 }
1109
1110 if (eNewEditMode != pDrViewSh->GetEditMode())
1111 {
1112 // EditMode setzen
1113 pDrViewSh->ChangeEditMode(eNewEditMode, sal_False);
1114 }
1115
1116 // Jump to the page. This is done by using the API because this
1117 // takes care of all the little things to be done. Especially
1118 // writing the view data to the frame view (see bug #107803#).
1119 sal_uInt16 nSdPgNum = (nPgNum - 1) / 2;
1120 SdUnoDrawView* pUnoDrawView = new SdUnoDrawView (
1121 pDrViewSh->GetViewShellBase().GetDrawController(),
1122 *pDrViewSh,
1123 *pDrViewSh->GetView());
1124 if (pUnoDrawView != NULL)
1125 {
1126 ::com::sun::star::uno::Reference<
1127 ::com::sun::star::drawing::XDrawPage> xDrawPage (
1128 pPage->getUnoPage(), ::com::sun::star::uno::UNO_QUERY);
1129 pUnoDrawView->setCurrentPage (xDrawPage);
1130 }
1131 else
1132 {
1133 // As a fall back switch to the page via the core.
1134 DBG_ASSERT (pUnoDrawView!=NULL,
1135 "SdDrawDocShell::GotoBookmark: can't switch page via API");
1136 pDrViewSh->SwitchPage(nSdPgNum);
1137 }
1138 delete pUnoDrawView;
1139
1140
1141 if (pObj)
1142 {
1143 // Objekt einblenden und selektieren
1144 pDrViewSh->MakeVisible(pObj->GetLogicRect(),
1145 *pDrViewSh->GetActiveWindow());
1146 sal_Bool bUnMark = pDrViewSh->GetView()->IsObjMarked(pObj);
1147 pDrViewSh->GetView()->MarkObj(pObj, pDrViewSh->GetView()->GetSdrPageView(), bUnMark);
1148 }
1149 }
1150
1151 SfxBindings& rBindings = ( ( mpViewShell && mpViewShell->GetViewFrame() ) ?
1152 mpViewShell->GetViewFrame() : SfxViewFrame::Current() )->GetBindings();
1153
1154 rBindings.Invalidate(SID_NAVIGATOR_STATE, sal_True, sal_False);
1155 rBindings.Invalidate(SID_NAVIGATOR_PAGENAME);
1156 }
1157
1158 return (bFound);
1159 }
1160 /*************************************************************************
1161 |*
1162 |* SaveAsOwnFormat: wenn es eine Dokumentvorlage werden soll,
1163 |*
1164 \************************************************************************/
1165 #include <tools/urlobj.hxx>
1166
SaveAsOwnFormat(SfxMedium & rMedium)1167 sal_Bool DrawDocShell::SaveAsOwnFormat( SfxMedium& rMedium )
1168 {
1169
1170 const SfxFilter* pFilter = rMedium.GetFilter();
1171
1172 if (pFilter->IsOwnTemplateFormat())
1173 {
1174 // jetzt die StarDraw-Spezialitaeten:
1175 // die Layoutvorlagen der ersten Seite werden mit dem jetzt
1176 // bekannten Layoutnamen versehen, die Layoutnamen der betroffenen
1177 // Masterpages und Seiten werden gesetzt;
1178 // alle Textobjekte der betroffenen Standard-, Notiz- und
1179 // Masterpages werden ueber die Namensaenderung informiert
1180
1181 String aLayoutName;
1182
1183 SfxStringItem* pLayoutItem;
1184 if( rMedium.GetItemSet()->GetItemState(SID_TEMPLATE_NAME, sal_False, (const SfxPoolItem**) & pLayoutItem ) == SFX_ITEM_SET )
1185 {
1186 aLayoutName = pLayoutItem->GetValue();
1187 }
1188 else
1189 {
1190 INetURLObject aURL( rMedium.GetName() );
1191 aURL.removeExtension();
1192 aLayoutName = aURL.getName();
1193 }
1194
1195 if( aLayoutName.Len() )
1196 {
1197 sal_uInt32 nCount = mpDoc->GetMasterSdPageCount(PK_STANDARD);
1198 for(sal_uInt32 i = 0; i < nCount; i++)
1199 {
1200 String aOldPageLayoutName = mpDoc->GetMasterSdPage(i, PK_STANDARD)->GetLayoutName();
1201 String aNewLayoutName = aLayoutName;
1202 // Don't add suffix for the first master page
1203 if( i > 0 )
1204 aNewLayoutName += String::CreateFromInt32(i);
1205
1206 mpDoc->RenameLayoutTemplate(aOldPageLayoutName, aNewLayoutName);
1207 }
1208 }
1209 }
1210
1211 return SfxObjectShell::SaveAsOwnFormat(rMedium);
1212 }
1213
1214 /*************************************************************************
1215 |*
1216 |* FillClass
1217 |*
1218 \************************************************************************/
1219
FillClass(SvGlobalName * pClassName,sal_uInt32 * pFormat,String *,String * pFullTypeName,String * pShortTypeName,sal_Int32 nFileFormat,sal_Bool bTemplate) const1220 void DrawDocShell::FillClass(SvGlobalName* pClassName,
1221 sal_uInt32* pFormat,
1222 String* ,
1223 String* pFullTypeName,
1224 String* pShortTypeName,
1225 sal_Int32 nFileFormat,
1226 sal_Bool bTemplate /* = sal_False */) const
1227 {
1228 if (nFileFormat == SOFFICE_FILEFORMAT_60)
1229 {
1230 if ( meDocType == DOCUMENT_TYPE_DRAW )
1231 {
1232 *pClassName = SvGlobalName(SO3_SDRAW_CLASSID_60);
1233 *pFormat = SOT_FORMATSTR_ID_STARDRAW_60;
1234 *pFullTypeName = String(SdResId(STR_GRAPHIC_DOCUMENT_FULLTYPE_60));
1235 }
1236 else
1237 {
1238 *pClassName = SvGlobalName(SO3_SIMPRESS_CLASSID_60);
1239 *pFormat = SOT_FORMATSTR_ID_STARIMPRESS_60;
1240 *pFullTypeName = String(SdResId(STR_IMPRESS_DOCUMENT_FULLTYPE_60));
1241 }
1242 }
1243 else if (nFileFormat == SOFFICE_FILEFORMAT_8)
1244 {
1245 if ( meDocType == DOCUMENT_TYPE_DRAW )
1246 {
1247 *pClassName = SvGlobalName(SO3_SDRAW_CLASSID_60);
1248 *pFormat = bTemplate ? SOT_FORMATSTR_ID_STARDRAW_8_TEMPLATE : SOT_FORMATSTR_ID_STARDRAW_8;
1249 *pFullTypeName = String(RTL_CONSTASCII_USTRINGPARAM("Draw 8")); // HACK: method will be removed with new storage API
1250 }
1251 else
1252 {
1253 *pClassName = SvGlobalName(SO3_SIMPRESS_CLASSID_60);
1254 *pFormat = bTemplate ? SOT_FORMATSTR_ID_STARIMPRESS_8_TEMPLATE : SOT_FORMATSTR_ID_STARIMPRESS_8;
1255 *pFullTypeName = String(RTL_CONSTASCII_USTRINGPARAM("Impress 8")); // HACK: method will be removed with new storage API
1256 }
1257 }
1258
1259 *pShortTypeName = String(SdResId( (meDocType == DOCUMENT_TYPE_DRAW) ?
1260 STR_GRAPHIC_DOCUMENT : STR_IMPRESS_DOCUMENT ));
1261 }
1262
GetDocumentRefDev(void)1263 OutputDevice* DrawDocShell::GetDocumentRefDev (void)
1264 {
1265 OutputDevice* pReferenceDevice = SfxObjectShell::GetDocumentRefDev ();
1266 // Only when our parent does not have a reference device then we return
1267 // our own.
1268 if (pReferenceDevice == NULL && mpDoc != NULL)
1269 pReferenceDevice = mpDoc->GetRefDevice ();
1270 return pReferenceDevice;
1271 }
1272
1273 /** executes the SID_OPENDOC slot to let the framework open a document
1274 with the given URL and this document as a referer */
OpenBookmark(const String & rBookmarkURL)1275 void DrawDocShell::OpenBookmark( const String& rBookmarkURL )
1276 {
1277 SfxStringItem aStrItem( SID_FILE_NAME, rBookmarkURL );
1278 SfxStringItem aReferer( SID_REFERER, GetMedium()->GetName() );
1279 const SfxPoolItem* ppArgs[] = { &aStrItem, &aReferer, 0 };
1280 ( mpViewShell ? mpViewShell->GetViewFrame() : SfxViewFrame::Current() )->GetBindings().Execute( SID_OPENHYPERLINK, ppArgs );
1281 }
1282
setDocAccTitle(const String & rTitle)1283 void DrawDocShell::setDocAccTitle( const String& rTitle )
1284 {
1285 if (mpDoc )
1286 {
1287 mpDoc->setDocAccTitle( rTitle );
1288 }
1289 }
getDocAccTitle() const1290 const String DrawDocShell::getDocAccTitle() const
1291 {
1292 String sRet;
1293 if (mpDoc)
1294 {
1295 sRet = mpDoc->getDocAccTitle();
1296 }
1297
1298 return sRet;
1299 }
setDocReadOnly(sal_Bool bReadOnly)1300 void DrawDocShell::setDocReadOnly( sal_Bool bReadOnly)
1301 {
1302 if (mpDoc )
1303 {
1304 mpDoc->setDocReadOnly( bReadOnly );
1305 }
1306 }
getDocReadOnly() const1307 sal_Bool DrawDocShell::getDocReadOnly() const
1308 {
1309 if (mpDoc)
1310 {
1311 return mpDoc->getDocReadOnly();
1312 }
1313
1314 return sal_False;
1315 }
1316 } // end of namespace sd
1317