| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sw.hxx" |
| |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/frame/XDispatchHelper.hpp> |
| |
| #include <comphelper/processfactory.hxx> |
| |
| #include <hintids.hxx> |
| #include <tools/urlobj.hxx> |
| #include <unotools/tempfile.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svl/lckbitem.hxx> |
| #include <svl/eitem.hxx> |
| #include <svl/zforlist.hxx> |
| #include <svl/zformat.hxx> |
| #include <unotools/pathoptions.hxx> |
| #include <svtools/transfer.hxx> |
| #include <sfx2/dialogs.hrc> |
| #include <sfx2/dinfdlg.hxx> |
| #include <sfx2/request.hxx> |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/new.hxx> |
| #include <sfx2/filedlghelper.hxx> |
| #include <sfx2/printer.hxx> |
| #include <sfx2/evntconf.hxx> |
| #include <svtools/sfxecode.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <sfx2/docfilt.hxx> |
| #include <svx/svxids.hrc> |
| #include <svx/drawitem.hxx> |
| #include <editeng/svxacorr.hxx> |
| #include <editeng/langitem.hxx> |
| #include <svx/fmshell.hxx> |
| |
| #include <svtools/htmlcfg.hxx> |
| //#include <svx/paletteitem.hxx> |
| #include <SwSmartTagMgr.hxx> |
| #include <sfx2/app.hxx> |
| #include <basic/sbstar.hxx> |
| #include <basic/basmgr.hxx> |
| #include <sot/storage.hxx> |
| #include <sot/clsids.hxx> |
| #include <swunodef.hxx> |
| #include <fmtcol.hxx> |
| #include <swevent.hxx> |
| #include <view.hxx> // fuer die aktuelle Sicht |
| #include <docsh.hxx> // Dokumenterzeugung |
| #include <wrtsh.hxx> |
| #include <fldbas.hxx> |
| #include <viewopt.hxx> |
| #include <globdoc.hxx> |
| #include <fldwrap.hxx> |
| #include <redlndlg.hxx> |
| #include <docstyle.hxx> |
| #include <doc.hxx> |
| #include <IDocumentUndoRedo.hxx> |
| #include <pagedesc.hxx> |
| #include <shellio.hxx> |
| #include <pview.hxx> |
| #include <srcview.hxx> |
| #include <poolfmt.hxx> |
| #include <usrpref.hxx> |
| #include <wdocsh.hxx> |
| #include <unotxdoc.hxx> |
| #include <acmplwrd.hxx> |
| #include <swmodule.hxx> |
| #include <unobaseclass.hxx> |
| #include <swwait.hxx> |
| #include <swcli.hxx> |
| |
| #include <cmdid.h> |
| #include <globals.h> |
| #include <helpid.h> |
| #include <app.hrc> |
| #include <poolfmt.hrc> |
| #include <globals.hrc> |
| #include <com/sun/star/ui/dialogs/XFilePicker.hpp> |
| #include <com/sun/star/ui/dialogs/XFilterManager.hpp> |
| #include <com/sun/star/ui/dialogs/XFilePickerControlAccess.hpp> |
| #include <com/sun/star/ui/dialogs/ExtendedFilePickerElementIds.hpp> |
| #include <com/sun/star/ui/dialogs/ListboxControlActions.hpp> |
| #include <com/sun/star/ui/dialogs/CommonFilePickerElementIds.hpp> |
| #include "com/sun/star/ui/dialogs/TemplateDescription.hpp" |
| #ifdef FUTURE_VBA |
| #include <com/sun/star/script/vba/XVBAEventProcessor.hpp> |
| #include <com/sun/star/script/vba/VBAEventId.hpp> |
| #endif |
| #include <editeng/acorrcfg.hxx> |
| #include <SwStyleNameMapper.hxx> |
| |
| #include <sfx2/fcontnr.hxx> |
| |
| #include "swabstdlg.hxx" |
| #include "dialog.hrc" |
| #include "swabstdlg.hxx" |
| |
| #include <ndtxt.hxx> //#outline level,add by zhaojianwei |
| |
| using namespace ::com::sun::star::ui::dialogs; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star; |
| using ::rtl::OUString; |
| using namespace ::sfx2; |
| extern sal_Bool FindPhyStyle( SwDoc& , const String& , SfxStyleFamily ); |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: DocInfo kreieren (virtuell) |
| --------------------------------------------------------------------*/ |
| |
| SfxDocumentInfoDialog* SwDocShell::CreateDocumentInfoDialog( |
| Window *pParent, const SfxItemSet &rSet) |
| { |
| SfxDocumentInfoDialog* pDlg = new SfxDocumentInfoDialog(pParent, rSet); |
| //nur mit Statistik, wenn dieses Doc auch angezeigt wird, nicht |
| //aus dem Doc-Manager |
| SwDocShell* pDocSh = (SwDocShell*) SfxObjectShell::Current(); |
| if( pDocSh == this ) |
| { |
| //Nicht fuer SourceView. |
| SfxViewShell *pVSh = SfxViewShell::Current(); |
| if ( pVSh && !pVSh->ISA(SwSrcView) ) |
| { |
| SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!"); |
| pDlg->AddTabPage(TP_DOC_STAT, SW_RESSTR(STR_DOC_STAT),pFact->GetTabPageCreatorFunc( TP_DOC_STAT ),0); |
| } |
| } |
| return pDlg; |
| } |
| |
| // Disable "multiple layout" |
| |
| void SwDocShell::ToggleBrowserMode(sal_Bool bSet, SwView* _pView ) |
| { |
| GetDoc()->set(IDocumentSettingAccess::BROWSE_MODE, bSet ); |
| UpdateFontList(); |
| SwView* pTempView = _pView ? _pView : (SwView*)GetView(); |
| if( pTempView ) |
| { |
| pTempView->GetViewFrame()->GetBindings().Invalidate(FN_SHADOWCURSOR); |
| if( !GetDoc()->getPrinter( false ) ) |
| pTempView->SetPrinter( GetDoc()->getPrinter( false ), SFX_PRINTER_PRINTER | SFX_PRINTER_JOBSETUP ); |
| GetDoc()->CheckDefaultPageFmt(); |
| SfxViewFrame *pTmpFrm = SfxViewFrame::GetFirst(this, sal_False); |
| do { |
| if( pTmpFrm != pTempView->GetViewFrame() ) |
| { |
| pTmpFrm->DoClose(); |
| pTmpFrm = SfxViewFrame::GetFirst(this, sal_False); |
| } |
| else |
| pTmpFrm = pTmpFrm->GetNext(*pTmpFrm, this, sal_False); |
| |
| } while ( pTmpFrm ); |
| const SwViewOption& rViewOptions = *pTempView->GetWrtShell().GetViewOptions(); |
| pTempView->GetWrtShell().CheckBrowseView( sal_True ); |
| pTempView->CheckVisArea(); |
| if( bSet ) |
| { |
| const SvxZoomType eType = (SvxZoomType)rViewOptions.GetZoomType(); |
| if ( SVX_ZOOM_PERCENT != eType) |
| ((SwView*)GetView())->SetZoom( eType ); |
| } |
| pTempView->InvalidateBorder(); |
| pTempView->SetNewWindowAllowed(!bSet); |
| } |
| } |
| // End of disabled "multiple layout" |
| |
| /// update text fields on document properties changes |
| void SwDocShell::DoFlushDocInfo() |
| { |
| if ( !mpDoc ) return; |
| |
| bool bUnlockView(true); |
| if ( mpWrtShell ) { |
| bUnlockView = !mpWrtShell->IsViewLocked(); |
| mpWrtShell->LockView( sal_True ); // lock visible section |
| mpWrtShell->StartAllAction(); |
| } |
| |
| mpDoc->DocInfoChgd(); |
| |
| if ( mpWrtShell ) { |
| mpWrtShell->EndAllAction(); |
| if ( bUnlockView ) { |
| mpWrtShell->LockView( sal_False ); |
| } |
| } |
| } |
| |
| #ifdef FUTURE_VBA |
| void lcl_processCompatibleSfxHint( const uno::Reference< script::vba::XVBAEventProcessor >& xVbaEvents, const SfxHint& rHint ) |
| { |
| using namespace com::sun::star::script::vba::VBAEventId; |
| if ( rHint.ISA( SfxEventHint ) ) |
| { |
| uno::Sequence< uno::Any > aArgs; |
| sal_uLong nEventId = ((SfxEventHint&)rHint).GetEventId(); |
| switch( nEventId ) |
| { |
| case SFX_EVENT_CREATEDOC: |
| xVbaEvents->processVbaEvent( DOCUMENT_NEW, aArgs ); |
| break; |
| case SFX_EVENT_OPENDOC: |
| xVbaEvents->processVbaEvent( DOCUMENT_OPEN, aArgs ); |
| break; |
| } |
| } |
| } |
| #endif |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Benachrichtigung bei geaenderter DocInfo |
| --------------------------------------------------------------------*/ |
| |
| void SwDocShell::Notify( SfxBroadcaster&, const SfxHint& rHint ) |
| { |
| if( !mpDoc ) |
| { |
| return ; |
| } |
| |
| #ifdef FUTURE_VBA |
| uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents = mpDoc->GetVbaEventProcessor(); |
| if( xVbaEvents.is() ) |
| lcl_processCompatibleSfxHint( xVbaEvents, rHint ); |
| #endif |
| |
| sal_uInt16 nAction = 0; |
| if( rHint.ISA(SfxSimpleHint) ) |
| { |
| // swithc for more actions |
| switch( ((SfxSimpleHint&) rHint).GetId() ) |
| { |
| case SFX_HINT_TITLECHANGED: |
| if( GetMedium() ) |
| nAction = 2; |
| break; |
| } |
| } |
| else if( rHint.ISA(SfxEventHint) && |
| ((SfxEventHint&) rHint).GetEventId() == SFX_EVENT_LOADFINISHED ) |
| { |
| nAction = 3; |
| } |
| |
| if( nAction ) |
| { |
| sal_Bool bUnlockView = sal_True; //initializing prevents warning |
| if( mpWrtShell ) |
| { |
| bUnlockView = !mpWrtShell->IsViewLocked(); |
| mpWrtShell->LockView( sal_True ); //lock visible section |
| mpWrtShell->StartAllAction(); |
| } |
| switch( nAction ) |
| { |
| case 2: |
| mpDoc->GetSysFldType( RES_FILENAMEFLD )->UpdateFlds(); |
| break; |
| |
| // own action for event LOADFINISHED in order to avoid a modified document. |
| // Also for the instance of <SwDoc> it has to be assured, that it's not modified. |
| // Perform the same as for action id 1, but disable <SetModified>. |
| case 3: |
| { |
| const bool bResetModified = IsEnableSetModified(); |
| if ( bResetModified ) |
| EnableSetModified( sal_False ); |
| const bool bIsDocModified = mpDoc->IsModified(); |
| |
| mpDoc->DocInfoChgd( ); |
| |
| if ( !bIsDocModified ) |
| mpDoc->ResetModified(); |
| if ( bResetModified ) |
| EnableSetModified( sal_True ); |
| } |
| break; |
| } |
| |
| if( mpWrtShell ) |
| { |
| mpWrtShell->EndAllAction(); |
| if( bUnlockView ) |
| mpWrtShell->LockView( sal_False ); |
| } |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Benachrichtigung Doc schliessen |
| --------------------------------------------------------------------*/ |
| |
| sal_uInt16 SwDocShell::PrepareClose( sal_Bool bUI, sal_Bool bForBrowsing ) |
| { |
| sal_uInt16 nRet = SfxObjectShell::PrepareClose( bUI, bForBrowsing ); |
| |
| if( sal_True == nRet ) //Unbedingt auf sal_True abfragen! (RET_NEWTASK) |
| EndListening( *this ); |
| |
| #ifdef FUTURE_VBA |
| if( mpDoc && IsInPrepareClose() ) |
| { |
| uno::Reference< script::vba::XVBAEventProcessor > xVbaEvents = mpDoc->GetVbaEventProcessor(); |
| if( xVbaEvents.is() ) |
| { |
| using namespace com::sun::star::script::vba::VBAEventId; |
| uno::Sequence< uno::Any > aArgs; |
| xVbaEvents->processVbaEvent( DOCUMENT_CLOSE, aArgs ); |
| } |
| } |
| #endif |
| return nRet; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Organizer |
| --------------------------------------------------------------------*/ |
| |
| sal_Bool SwDocShell::Insert( SfxObjectShell &rSource, |
| sal_uInt16 nSourceIdx1, // SourcePool: oberste Inhaltsebene (Vorlagen/Makros) |
| sal_uInt16 nSourceIdx2, // Index in den Inhalt |
| sal_uInt16 nSourceIdx3, // Index in die Inhaltsebene |
| sal_uInt16 &rIdx1, // und das gleiche fuer den DestinationPool |
| sal_uInt16 &rIdx2, // "" |
| sal_uInt16 &rIdx3, // "" |
| sal_uInt16 &rRemovedIdx ) // falls doppelte geloescht werden, Pos zurueck |
| { |
| // --> OD 2005-05-10 #i48949# - actions aren't undoable. Thus, allow no undo |
| // actions |
| // Note: The undo action stack is cleared at the end of this method. |
| ::sw::UndoGuard const undoGuard(GetDoc()->GetIDocumentUndoRedo()); |
| // <-- |
| |
| sal_Bool bRet = sal_False; |
| |
| if (INDEX_IGNORE == rIdx1 && CONTENT_STYLE == nSourceIdx1) |
| rIdx1 = CONTENT_STYLE; |
| |
| if (CONTENT_STYLE == nSourceIdx1 && CONTENT_STYLE == rIdx1) |
| { |
| SfxStyleSheetBasePool* pHisPool = rSource.GetStyleSheetPool(); |
| SwDocStyleSheetPool* pMyPool = |
| (SwDocStyleSheetPool*)GetStyleSheetPool(); |
| |
| // wir koennen nicht in uns selbst hin und her moven |
| if( pHisPool == pMyPool ) |
| return sal_False; |
| |
| if( INDEX_IGNORE == rIdx2 ) |
| rIdx2 = pMyPool->Count(); |
| |
| // erstmal auf die Such-Maske "positionieren" |
| pHisPool->First(); |
| SfxStyleSheetBase* pHisSheet = (*pHisPool)[nSourceIdx2]; |
| |
| // wenn so eine Vorlage schon existiert: loeschen! |
| const String& rOldName = pHisSheet->GetName(); |
| SfxStyleFamily eOldFamily( pHisSheet->GetFamily() ); |
| |
| // dflt. PageDesc und StandardZeichenvorlage nie loeschen !!! |
| if( ( SFX_STYLE_FAMILY_PAGE == eOldFamily && |
| const_cast<const SwDoc *>(mpDoc)->GetPageDesc(0).GetName() == |
| rOldName ) || |
| ( SFX_STYLE_FAMILY_CHAR == eOldFamily && |
| rOldName == *SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD - |
| RES_POOLCOLL_TEXT_BEGIN ] )) |
| return sal_False; |
| |
| SfxStyleFamily eMyOldFamily( pMyPool->GetSearchFamily() ); |
| sal_uInt16 nMySrchMask = pMyPool->GetSearchMask(); |
| |
| SfxStyleSheetBase* pExist; |
| if( ::FindPhyStyle( *mpDoc, rOldName, eOldFamily ) ) |
| { |
| // Bug 20365: nur uebernehmen, wenn das gewuenscht ist! |
| if( ERRCODE_BUTTON_OK != ErrorHandler::HandleError( |
| *new MessageInfo( ERRCODE_SFXMSG_STYLEREPLACE, rOldName )) ) |
| { |
| return sal_False; |
| } |
| |
| // Da Replace den aStyleSheet-Member selbst benoetigt, muss |
| // das Ergebnis vom Find kopiert werden (s.u.)) |
| rtl::Reference< SwDocStyleSheet > xExist( new SwDocStyleSheet( |
| *(SwDocStyleSheet*)pMyPool->Find( rOldName, eOldFamily ) ) ); |
| pMyPool->Replace( *pHisSheet, *xExist.get() ); |
| |
| // An der Reihenfolge der Vorlagen im Pool aendert sich nichts. |
| rIdx2 = rIdx1 = INDEX_IGNORE; |
| |
| GetDoc()->SetModified(); |
| |
| return sal_True; |
| } |
| |
| pMyPool->SetSearchMask( eOldFamily, nMySrchMask ); |
| |
| // MIB 18.12.98: SwDocStyleSheetPool::Make liefert einen |
| // Pointer auf SwDocStyleSheetPool::aStyleSheet zurueck. |
| // Der gleiche Member von SwDocStyleSheetPool::Find benutzt. |
| // Deshalb muss hier mit einer Kopie gearbeitet werden. |
| // Vorsicht: SfxStyleSheetBase::SetFollow ruft seinerseits |
| // ein SwDocStyleSheetPool::Find auf, do dass es nicht genuegt |
| // die Find-Aufrufe in dieser Methode zu eleminieren. |
| |
| rtl::Reference< SwDocStyleSheet > xNewSheet( new SwDocStyleSheet( (SwDocStyleSheet&)pMyPool |
| ->Make(rOldName, eOldFamily, pHisSheet->GetMask() ) ) ); |
| if( SFX_STYLE_FAMILY_PAGE == eOldFamily && rSource.ISA(SwDocShell) ) |
| { |
| // gesondert behandeln!! |
| SwPageDesc* pDestDsc = (SwPageDesc*)xNewSheet->GetPageDesc(); |
| SwPageDesc* pCpyDsc = (SwPageDesc*)((SwDocStyleSheet*)pHisSheet)->GetPageDesc(); |
| mpDoc->CopyPageDesc( *pCpyDsc, *pDestDsc ); |
| } |
| else |
| // die neue Vorlage mit den Attributen fuellen |
| xNewSheet->SetItemSet( pHisSheet->GetItemSet() ); |
| |
| pMyPool->SetSearchMask( SFX_STYLE_FAMILY_ALL, nMySrchMask ); |
| |
| if( xNewSheet->IsUserDefined() || xNewSheet->IsUsed() ) |
| { |
| // Benutzte und Benutzer-definierte Vorlagen werden angezeigt. |
| // Dshalb muss hier der Index der neuen Vorlage im Pool |
| // ermittelt werden. |
| pExist = pMyPool->First(); |
| sal_uInt16 nIdx = 0; |
| while( pExist ) |
| { |
| if( pExist->GetName() == rOldName && |
| eOldFamily == pExist->GetFamily() ) |
| { |
| rIdx2 = nIdx; |
| break; |
| } |
| pExist = pMyPool->Next(); |
| nIdx++; |
| } |
| } |
| else |
| { |
| // Andere Vorlagen werden nicht angezeigt. |
| rIdx1 = rIdx2 = INDEX_IGNORE; |
| } |
| |
| /* pMyPool->Count(); //interne Liste neu fuellen lassen!!!!! |
| |
| // suchen, um die richige Insert-Position returnen zu koennen |
| pMyPool->Find( rOldName, SFX_STYLE_FAMILY_ALL, nMySrchMask ); |
| rIdx2 = pMyPool->GetFindPos();*/ |
| |
| // wer bekommt den Neuen als Parent? wer benutzt den Neuen als Follow? |
| // (immer nur ueber die Instanziierten!!!) |
| pMyPool->SetSearchMask( eOldFamily, nMySrchMask ); |
| pMyPool->SetOrganizerMode( sal_True ); |
| SfxStyleSheetBase* pTestSheet = pMyPool->First(); |
| while (pTestSheet) |
| { |
| if (pTestSheet->GetFamily() == eOldFamily && |
| pTestSheet->HasParentSupport() && |
| pTestSheet->GetParent() == rOldName) |
| { |
| pTestSheet->SetParent(rOldName); // Verknuepfung neu aufbauen |
| } |
| |
| if (pTestSheet->GetFamily() == eOldFamily && |
| pTestSheet->HasFollowSupport() && |
| pTestSheet->GetFollow() == rOldName) |
| { |
| pTestSheet->SetFollow(rOldName); // Verknuepfung neu aufbauen |
| } |
| |
| pTestSheet = pMyPool->Next(); |
| } |
| pMyPool->SetOrganizerMode( SFX_CREATE_MODE_ORGANIZER == GetCreateMode() ); |
| |
| // hat der Neue einen Parent? wenn ja, mit gleichem Namen bei uns suchen |
| if (pHisSheet->HasParentSupport()) |
| { |
| const String& rParentName = pHisSheet->GetParent(); |
| if (0 != rParentName.Len()) |
| { |
| SfxStyleSheetBase* pParentOfNew = pMyPool->Find(rParentName, |
| eOldFamily); |
| if (pParentOfNew) |
| { |
| xNewSheet->SetParent(rParentName); |
| } |
| pMyPool->SetSearchMask( eOldFamily, nMySrchMask ); |
| } |
| } |
| |
| // hat der Neue einen Follow? wenn ja, mit gleichem Namen bei uns suchen |
| if (pHisSheet->HasFollowSupport()) |
| { |
| const String& rFollowName = pHisSheet->GetFollow(); |
| if (0 != rFollowName.Len()) |
| { |
| SfxStyleSheetBase* pFollowOfNew = pMyPool->Find(rFollowName, |
| eOldFamily); |
| if (pFollowOfNew) |
| { |
| xNewSheet->SetFollow(rFollowName); |
| } |
| pMyPool->SetSearchMask( eOldFamily, nMySrchMask ); |
| } |
| } |
| |
| // Bug 27347: alte Einstellung wieder setzen |
| pMyPool->SetSearchMask( eMyOldFamily, nMySrchMask ); |
| |
| // Model geaendert |
| ASSERT(mpDoc, "Doc fehlt"); |
| GetDoc()->SetModified(); |
| |
| bRet = sal_True; |
| } |
| else |
| bRet = SfxObjectShell::Insert( rSource, |
| nSourceIdx1, |
| nSourceIdx2, |
| nSourceIdx3, |
| rIdx1, |
| rIdx2, |
| rIdx3, |
| rRemovedIdx); |
| |
| // --> OD 2005-05-10 #i48949# - actions aren't undoable and could have change |
| // the document node array. Thus, clear the undo action stack. |
| if (undoGuard.UndoWasEnabled()) |
| { |
| GetDoc()->GetIDocumentUndoRedo().DelAllUndoObj(); |
| } |
| // <-- |
| |
| return bRet; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: Vorlagen Remove |
| --------------------------------------------------------------------*/ |
| |
| sal_Bool SwDocShell::Remove(sal_uInt16 nIdx1, // siehe Insert |
| sal_uInt16 nIdx2, |
| sal_uInt16 nIdx3) |
| { |
| sal_Bool bRet = sal_False; |
| |
| if (CONTENT_STYLE == nIdx1) |
| { |
| SwDocStyleSheetPool* pMyPool = (SwDocStyleSheetPool*)GetStyleSheetPool(); |
| |
| pMyPool->First(); // vorm Zugriff Pool aktualisieren!! |
| SfxStyleSheetBase* pMySheet = (*pMyPool)[nIdx2]; |
| |
| String aName( pMySheet->GetName() ); |
| SfxStyleFamily eFamily( pMySheet->GetFamily() ); |
| |
| // dflt. PageDesc und StandardZeichenvorlage nie loeschen !!! |
| if( ( SFX_STYLE_FAMILY_PAGE == eFamily && |
| const_cast<const SwDoc *>(mpDoc)->GetPageDesc(0).GetName() |
| == aName ) || |
| ( SFX_STYLE_FAMILY_CHAR == eFamily && |
| aName == *SwStyleNameMapper::GetTextUINameArray()[ RES_POOLCOLL_STANDARD - |
| RES_POOLCOLL_TEXT_BEGIN ] )) |
| return sal_False; |
| |
| // also loeschen |
| pMyPool->Remove( pMySheet ); |
| |
| // jetzt noch die Parents/Follows aller Instanziierten korrigieren |
| pMyPool->SetOrganizerMode( sal_True ); |
| SfxStyleSheetBase* pTestSheet = pMyPool->First(); |
| while (pTestSheet) |
| { |
| if (pTestSheet->GetFamily() == eFamily && |
| pTestSheet->HasParentSupport() && |
| pTestSheet->GetParent() == aName) |
| { |
| pTestSheet->SetParent( aEmptyStr ); // Verknuepfung aufloesen |
| } |
| |
| if (pTestSheet->GetFamily() == eFamily && |
| pTestSheet->HasFollowSupport() && |
| pTestSheet->GetFollow() == aName) |
| { |
| pTestSheet->SetFollow( aEmptyStr ); // Verknuepfung aufloesen |
| } |
| |
| pTestSheet = pMyPool->Next(); |
| } |
| pMyPool->SetOrganizerMode( SFX_CREATE_MODE_ORGANIZER == GetCreateMode() ); |
| |
| bRet = sal_True; |
| } |
| else |
| bRet = SfxObjectShell::Remove( nIdx1, |
| nIdx2, |
| nIdx3 ); |
| |
| |
| // Model geaendert |
| ASSERT(mpDoc, "Doc fehlt"); |
| GetDoc()->SetModified(); |
| |
| return bRet; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwDocShell::Execute(SfxRequest& rReq) |
| { |
| const SfxItemSet* pArgs = rReq.GetArgs(); |
| const SfxPoolItem* pItem; |
| sal_uInt16 nWhich = rReq.GetSlot(); |
| sal_Bool bDone = sal_False; |
| switch ( nWhich ) |
| { |
| case SID_AUTO_CORRECT_DLG: |
| { |
| SvxSwAutoFmtFlags* pAFlags = &SvxAutoCorrCfg::Get()->GetAutoCorrect()->GetSwFlags(); |
| SwAutoCompleteWord& rACW = SwDoc::GetAutoCompleteWords(); |
| |
| sal_Bool bOldLocked = rACW.IsLockWordLstLocked(), |
| bOldAutoCmpltCollectWords = pAFlags->bAutoCmpltCollectWords; |
| |
| rACW.SetLockWordLstLocked( sal_True ); |
| |
| SvStringsISortDtor aTmpLst; |
| aTmpLst.Insert( &rACW.GetWordList() ); |
| pAFlags->pAutoCmpltList = &aTmpLst; |
| |
| SfxApplication* pApp = SFX_APP(); |
| SfxRequest aAppReq(SID_AUTO_CORRECT_DLG, SFX_CALLMODE_SYNCHRON, pApp->GetPool()); |
| SfxBoolItem aSwOptions( SID_AUTO_CORRECT_DLG, sal_True ); |
| aAppReq.AppendItem(aSwOptions); |
| |
| // SMARTTAGS |
| pAFlags->pSmartTagMgr = &SwSmartTagMgr::Get(); |
| |
| //pApp->ExecuteSlot(aAppReq); |
| |
| SfxItemSet aSet( pApp->GetPool(), SID_AUTO_CORRECT_DLG, SID_AUTO_CORRECT_DLG, SID_OPEN_SMARTTAGOPTIONS, SID_OPEN_SMARTTAGOPTIONS, 0 ); |
| aSet.Put( aSwOptions ); |
| |
| const SfxPoolItem* pOpenSmartTagOptionsItem = 0; |
| if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( SID_OPEN_SMARTTAGOPTIONS, sal_False, &pOpenSmartTagOptionsItem ) ) |
| aSet.Put( *static_cast<const SfxBoolItem*>(pOpenSmartTagOptionsItem) ); |
| |
| SfxAbstractDialogFactory* pFact = SfxAbstractDialogFactory::Create(); |
| SfxAbstractTabDialog* pDlg = pFact->CreateTabDialog( RID_OFA_AUTOCORR_DLG, NULL, &aSet, NULL ); |
| pDlg->Execute(); |
| delete pDlg; |
| |
| rACW.SetLockWordLstLocked( bOldLocked ); |
| |
| SwEditShell::SetAutoFmtFlags( pAFlags ); |
| rACW.SetMinWordLen( pAFlags->nAutoCmpltWordLen ); |
| rACW.SetMaxCount( pAFlags->nAutoCmpltListLen ); |
| if( pAFlags->pAutoCmpltList ) // any changes? |
| { |
| rACW.CheckChangedList( aTmpLst ); |
| // clear the temp WordList pointer |
| pAFlags->pAutoCmpltList = 0; |
| } |
| // remove all pointer we never delete the strings |
| aTmpLst.Remove( (sal_uInt16)0, aTmpLst.Count() ); |
| |
| if( !bOldAutoCmpltCollectWords && bOldAutoCmpltCollectWords != |
| pAFlags->bAutoCmpltCollectWords ) |
| { |
| // call on all Docs the idle formatter to start |
| // the collection of Words |
| TypeId aType = TYPE(SwDocShell); |
| for( SwDocShell *pDocSh = (SwDocShell*)SfxObjectShell::GetFirst(&aType); |
| pDocSh; |
| pDocSh = (SwDocShell*)SfxObjectShell::GetNext( *pDocSh, &aType ) ) |
| { |
| SwDoc* pTmp = pDocSh->GetDoc(); |
| if ( pTmp->GetCurrentViewShell() ) //swmod 071108//swmod 071225 |
| pTmp->InvalidateAutoCompleteFlag(); |
| } |
| } |
| } |
| break; |
| |
| case SID_PRINTPREVIEW: |
| { |
| sal_Bool bSet = sal_False, bFound = sal_False, bOnly = sal_True; |
| SfxViewFrame *pTmpFrm = SfxViewFrame::GetFirst(this); |
| SfxViewShell* pViewShell = SfxViewShell::Current(); |
| SwView* pCurrView = dynamic_cast< SwView *> ( pViewShell ); |
| sal_Bool bCurrent = IS_TYPE( SwPagePreView, pViewShell ); |
| |
| while( pTmpFrm ) // search PreView |
| { |
| if( IS_TYPE( SwView, pTmpFrm->GetViewShell()) ) |
| bOnly = sal_False; |
| else if( IS_TYPE( SwPagePreView, pTmpFrm->GetViewShell())) |
| { |
| pTmpFrm->GetFrame().Appear(); |
| bFound = sal_True; |
| } |
| if( bFound && !bOnly ) |
| break; |
| pTmpFrm = pTmpFrm->GetNext(*pTmpFrm, this); |
| } |
| |
| if( pArgs && SFX_ITEM_SET == |
| pArgs->GetItemState( SID_PRINTPREVIEW, sal_False, &pItem )) |
| bSet = ((SfxBoolItem*)pItem)->GetValue(); |
| else |
| bSet = !bCurrent; |
| |
| sal_uInt16 nSlotId = 0; |
| if( bSet && !bFound ) // Keine gefunden, daher neue Preview anlegen |
| nSlotId = SID_VIEWSHELL1; |
| else if( bFound && !bSet ) |
| nSlotId = bOnly ? SID_VIEWSHELL0 : SID_VIEWSHELL1; |
| |
| if( nSlotId ) |
| { |
| //JP 23.8.2001: Bug 91360 - PagePreView in the WebDocShell |
| // is found under Id ViewShell2. |
| if( ISA(SwWebDocShell) && SID_VIEWSHELL1 == nSlotId ) |
| nSlotId = SID_VIEWSHELL2; |
| |
| if( pCurrView && pCurrView->GetDocShell() == this ) |
| pTmpFrm = pCurrView->GetViewFrame(); |
| else |
| pTmpFrm = SfxViewFrame::GetFirst( this ); |
| |
| pTmpFrm->GetDispatcher()->Execute( nSlotId, 0, 0, SFX_CALLMODE_ASYNCHRON ); |
| } |
| |
| rReq.SetReturnValue(SfxBoolItem(SID_PRINTPREVIEW, bSet )); |
| } |
| break; |
| case SID_TEMPLATE_LOAD: |
| { |
| String aFileName; |
| static sal_Bool bText = sal_True; |
| static sal_Bool bFrame = sal_False; |
| static sal_Bool bPage = sal_False; |
| static sal_Bool bNum = sal_False; |
| static sal_Bool bMerge = sal_False; |
| sal_uInt16 nRet = USHRT_MAX; |
| |
| sal_uInt16 nFlags = bFrame ? SFX_LOAD_FRAME_STYLES : 0; |
| if(bPage) |
| nFlags|= SFX_LOAD_PAGE_STYLES; |
| if(bNum) |
| nFlags|= SFX_LOAD_NUM_STYLES; |
| if(!nFlags || bText) |
| nFlags|= SFX_LOAD_TEXT_STYLES; |
| if(bMerge) |
| nFlags|= SFX_MERGE_STYLES; |
| |
| if ( pArgs ) |
| { |
| SFX_REQUEST_ARG( rReq, pTemplateItem, SfxStringItem, SID_TEMPLATE_NAME, sal_False ); |
| if ( pTemplateItem ) |
| { |
| aFileName = pTemplateItem->GetValue(); |
| SFX_REQUEST_ARG( rReq, pFlagsItem, SfxInt32Item, SID_TEMPLATE_LOAD, sal_False ); |
| if ( pFlagsItem ) |
| nFlags = (sal_uInt16) pFlagsItem->GetValue(); |
| } |
| } |
| |
| if ( !aFileName.Len() ) |
| { |
| SvtPathOptions aPathOpt; |
| SfxNewFileDialog* pNewFileDlg = |
| new SfxNewFileDialog(&GetView()->GetViewFrame()->GetWindow(), SFXWB_LOAD_TEMPLATE); |
| pNewFileDlg->SetTemplateFlags(nFlags); |
| |
| nRet = pNewFileDlg->Execute(); |
| if(RET_TEMPLATE_LOAD == nRet) |
| { |
| FileDialogHelper aDlgHelper( TemplateDescription::FILEOPEN_SIMPLE, 0 ); |
| uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker(); |
| |
| xFP->setDisplayDirectory( aPathOpt.GetWorkPath() ); |
| |
| SfxObjectFactory &rFact = GetFactory(); |
| SfxFilterMatcher aMatcher( String::CreateFromAscii(rFact.GetShortName()) ); |
| SfxFilterMatcherIter aIter( &aMatcher ); |
| uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY); |
| const SfxFilter* pFlt = aIter.First(); |
| while( pFlt ) |
| { |
| // --> OD #i117339# |
| // if( pFlt && pFlt->IsAllowedAsTemplate() ) |
| if( pFlt && pFlt->IsAllowedAsTemplate() && |
| ( pFlt->GetUserData().EqualsAscii("CXML") || |
| pFlt->GetUserData().EqualsAscii("CXMLV") ) ) |
| { |
| const String sWild = ((WildCard&)pFlt->GetWildcard()).GetWildCard(); |
| xFltMgr->appendFilter( pFlt->GetUIName(), sWild ); |
| } |
| pFlt = aIter.Next(); |
| } |
| sal_Bool bWeb = 0 != dynamic_cast< SwWebDocShell *>( this ); |
| const SfxFilter *pOwnFlt = |
| SwDocShell::Factory().GetFilterContainer()-> |
| GetFilter4FilterName(String::CreateFromAscii("writer8")); |
| |
| //#b6439685# make sure the default file format is also available |
| if(bWeb) |
| { |
| const String sWild = ((WildCard&)pOwnFlt->GetWildcard()).GetWildCard(); |
| xFltMgr->appendFilter( pOwnFlt->GetUIName(), sWild ); |
| } |
| |
| bool bError = false; |
| //#b6439685# catch expception if wrong filter is selected - should not happen anymore |
| try |
| { |
| xFltMgr->setCurrentFilter( pOwnFlt->GetUIName() ); |
| } |
| catch( const uno::Exception& ) |
| { |
| bError = true; |
| } |
| |
| if( !bError && ERRCODE_NONE == aDlgHelper.Execute() ) |
| { |
| aFileName = xFP->getFiles().getConstArray()[0]; |
| } |
| } |
| else if( RET_OK == nRet) |
| { |
| aFileName = pNewFileDlg->GetTemplateFileName(); |
| } |
| |
| nFlags = pNewFileDlg->GetTemplateFlags(); |
| rReq.AppendItem( SfxStringItem( SID_TEMPLATE_NAME, aFileName ) ); |
| rReq.AppendItem( SfxInt32Item( SID_TEMPLATE_LOAD, (long) nFlags ) ); |
| delete pNewFileDlg; |
| } |
| |
| if( aFileName.Len() ) |
| { |
| SwgReaderOption aOpt; |
| aOpt.SetTxtFmts( bText = (0 != (nFlags&SFX_LOAD_TEXT_STYLES) )); |
| aOpt.SetFrmFmts( bFrame = (0 != (nFlags&SFX_LOAD_FRAME_STYLES))); |
| aOpt.SetPageDescs( bPage = (0 != (nFlags&SFX_LOAD_PAGE_STYLES ))); |
| aOpt.SetNumRules( bNum = (0 != (nFlags&SFX_LOAD_NUM_STYLES ))); |
| //different meaning between SFX_MERGE_STYLES and aOpt.SetMerge! |
| bMerge = 0 != (nFlags&SFX_MERGE_STYLES); |
| aOpt.SetMerge( !bMerge ); |
| |
| SetError( LoadStylesFromFile( aFileName, aOpt, sal_False ), ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( OSL_LOG_PREFIX ) )); |
| if ( !GetError() ) |
| rReq.Done(); |
| } |
| } |
| break; |
| case SID_SOURCEVIEW: |
| { |
| SfxViewShell* pViewShell = GetView() |
| ? (SfxViewShell*)GetView() |
| : SfxViewShell::Current(); |
| SfxViewFrame* pViewFrm = pViewShell->GetViewFrame(); |
| SwSrcView* pSrcView = dynamic_cast< SwSrcView *>( pViewShell ); |
| if(!pSrcView) |
| { |
| // 3 possible state: |
| // 1 - file unsaved -> save as HTML |
| // 2 - file modified and HTML filter active -> save |
| // 3 - file saved in non-HTML -> QueryBox to save as HTML |
| const SfxFilter* pHtmlFlt = |
| SwIoSystem::GetFilterOfFormat( |
| String::CreateFromAscii("HTML"), |
| SwWebDocShell::Factory().GetFilterContainer() ); |
| sal_Bool bLocalHasName = HasName(); |
| if(bLocalHasName) |
| { |
| //check for filter type |
| const SfxFilter* pFlt = GetMedium()->GetFilter(); |
| if(!pFlt || pFlt->GetUserData() != pHtmlFlt->GetUserData()) |
| { |
| QueryBox aQuery(&pViewFrm->GetWindow(), SW_RES(MSG_SAVEAS_HTML_QUERY)); |
| if(RET_YES == aQuery.Execute()) |
| bLocalHasName = sal_False; |
| else |
| break; |
| } |
| } |
| if(!bLocalHasName) |
| { |
| FileDialogHelper aDlgHelper( TemplateDescription::FILESAVE_AUTOEXTENSION, 0 ); |
| aDlgHelper.AddFilter( pHtmlFlt->GetFilterName(), pHtmlFlt->GetDefaultExtension() ); |
| aDlgHelper.SetCurrentFilter( pHtmlFlt->GetFilterName() ); |
| if( ERRCODE_NONE != aDlgHelper.Execute()) |
| { |
| break; |
| } |
| String sPath = aDlgHelper.GetPath(); |
| SfxStringItem aName(SID_FILE_NAME, sPath); |
| SfxStringItem aFilter(SID_FILTER_NAME, pHtmlFlt->GetName()); |
| const SfxBoolItem* pBool = (const SfxBoolItem*) |
| pViewFrm->GetDispatcher()->Execute( |
| SID_SAVEASDOC, SFX_CALLMODE_SYNCHRON, &aName, &aFilter, 0L ); |
| if(!pBool || !pBool->GetValue()) |
| break; |
| } |
| } |
| #ifdef DBG_UTIL |
| { |
| sal_Bool bWeb = 0 != dynamic_cast<SwWebDocShell*>(this); |
| DBG_ASSERT(bWeb == sal_True, "SourceView nur in der WebDocShell"); |
| } |
| #endif |
| // die SourceView ist fuer die SwWebDocShell die 1 |
| sal_uInt16 nSlot = SID_VIEWSHELL1; |
| sal_Bool bSetModified = sal_False; |
| SfxPrinter* pSavePrinter = 0; |
| if( 0 != pSrcView) |
| { |
| SfxPrinter* pTemp = GetDoc()->getPrinter( false ); |
| if(pTemp) |
| pSavePrinter = new SfxPrinter(*pTemp); |
| bSetModified = IsModified() || pSrcView->IsModified(); |
| if(pSrcView->IsModified()||pSrcView->HasSourceSaved()) |
| { |
| utl::TempFile aTempFile; |
| aTempFile.EnableKillingFile(); |
| pSrcView->SaveContent(aTempFile.GetURL()); |
| bDone = sal_True; |
| SvxMacro aMac(aEmptyStr, aEmptyStr, STARBASIC); |
| SfxEventConfiguration::ConfigureEvent(GlobalEventConfig::GetEventName( STR_EVENT_OPENDOC ), aMac, this); |
| SfxEventConfiguration::ConfigureEvent(GlobalEventConfig::GetEventName( STR_EVENT_PREPARECLOSEDOC ), aMac, this); |
| SfxEventConfiguration::ConfigureEvent(GlobalEventConfig::GetEventName( STR_EVENT_ACTIVATEDOC ), aMac, this); |
| SfxEventConfiguration::ConfigureEvent(GlobalEventConfig::GetEventName( STR_EVENT_DEACTIVATEDOC ), aMac, this); |
| ReloadFromHtml(aTempFile.GetURL(), pSrcView); |
| nSlot = 0; |
| } |
| else |
| { |
| nSlot = SID_VIEWSHELL0; |
| } |
| } |
| /* OS 10.04.97 14.20: Im Web-Writer gibt es keinen Unterschied zwischen |
| Export in den SourceMode und dem Speichern des Docs |
| else if(IsModified()) |
| { |
| sal_uInt16 nRet = QueryBox( SFX_APPWINDOW ,SW_RES(MSG_SAVE_HTML_QUERY)).Execute(); |
| if(RET_YES == nRet) |
| { |
| S F X _DISPATCHER().Execute(SID_SAVEDOC, |
| SFX_CALLMODE_SYNCHRON); |
| // der ReturnValue von SID_SAVEDOC ist etwas schwer verstaendlich |
| if(IsModified()) |
| nSlot = 0; |
| } |
| else if( RET_CANCEL == nRet ) |
| { |
| nSlot = 0; |
| } |
| }*/ |
| if(nSlot) |
| pViewFrm->GetDispatcher()->Execute(nSlot, SFX_CALLMODE_SYNCHRON); |
| if(bSetModified) |
| GetDoc()->SetModified(); |
| if(pSavePrinter) |
| { |
| GetDoc()->setPrinter( pSavePrinter, true, true); |
| //pSavePrinter darf nicht wieder geloescht werden |
| } |
| pViewFrm->GetBindings().SetState(SfxBoolItem(SID_SOURCEVIEW, nSlot == SID_VIEWSHELL2)); |
| pViewFrm->GetBindings().Invalidate( SID_NEWWINDOW ); |
| pViewFrm->GetBindings().Invalidate( SID_BROWSER_MODE ); |
| pViewFrm->GetBindings().Invalidate( FN_PRINT_LAYOUT ); |
| } |
| break; |
| case SID_GET_COLORTABLE: |
| { |
| const SvxColorTableItem* pColItem = static_cast< const SvxColorTableItem* >(GetItem(SID_COLOR_TABLE)); |
| XColorListSharedPtr aTable = pColItem->GetColorTable(); |
| |
| rReq.SetReturnValue(SvxColorTableItem(aTable, SID_GET_COLORTABLE)); |
| } |
| break; |
| case FN_ABSTRACT_STARIMPRESS: |
| case FN_ABSTRACT_NEWDOC: |
| { |
| SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create(); |
| DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!"); |
| |
| AbstractSwInsertAbstractDlg* pDlg = pFact->CreateSwInsertAbstractDlg(0, DLG_INSERT_ABSTRACT ); |
| DBG_ASSERT(pDlg, "Dialogdiet fail!"); |
| if(RET_OK == pDlg->Execute()) |
| { |
| sal_uInt8 nLevel = pDlg->GetLevel(); |
| sal_uInt8 nPara = pDlg->GetPara(); |
| SwDoc* pSmryDoc = new SwDoc(); |
| SfxObjectShellLock xDocSh( new SwDocShell( pSmryDoc, SFX_CREATE_MODE_STANDARD)); |
| xDocSh->DoInitNew( 0 ); |
| |
| sal_Bool bImpress = FN_ABSTRACT_STARIMPRESS == nWhich; |
| mpDoc->Summary( pSmryDoc, nLevel, nPara, bImpress ); |
| if( bImpress ) |
| { |
| WriterRef xWrt; |
| // mba: looks as if relative URLs don't make sense here |
| ::GetRTFWriter( aEmptyStr, String(), xWrt ); |
| SvMemoryStream *pStrm = new SvMemoryStream(); |
| pStrm->SetBufferSize( 16348 ); |
| SwWriter aWrt( *pStrm, *pSmryDoc ); |
| ErrCode eErr = aWrt.Write( xWrt ); |
| if( !ERRCODE_TOERROR( eErr ) ) |
| { |
| uno::Reference< lang::XMultiServiceFactory > xORB = ::comphelper::getProcessServiceFactory(); |
| uno::Reference< frame::XDispatchProvider > xProv( |
| xORB->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.drawing.ModuleDispatcher")), UNO_QUERY ); |
| if ( xProv.is() ) |
| { |
| ::rtl::OUString aCmd = ::rtl::OUString::createFromAscii( "SendOutlineToImpress" ); |
| uno::Reference< frame::XDispatchHelper > xHelper( |
| xORB->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.frame.DispatchHelper")), UNO_QUERY ); |
| if ( xHelper.is() ) |
| { |
| pStrm->Seek( STREAM_SEEK_TO_END ); |
| *pStrm << '\0'; |
| pStrm->Seek( STREAM_SEEK_TO_BEGIN ); |
| |
| // Transfer ownership of stream to a lockbytes object |
| SvLockBytes aLockBytes( pStrm, sal_True ); |
| SvLockBytesStat aStat; |
| if ( aLockBytes.Stat( &aStat, SVSTATFLAG_DEFAULT ) == ERRCODE_NONE ) |
| { |
| sal_uInt32 nLen = aStat.nSize; |
| sal_uLong nRead = 0; |
| uno::Sequence< sal_Int8 > aSeq( nLen ); |
| aLockBytes.ReadAt( 0, aSeq.getArray(), nLen, &nRead ); |
| |
| uno::Sequence< beans::PropertyValue > aArgs(1); |
| aArgs[0].Name = ::rtl::OUString::createFromAscii("RtfOutline"); |
| aArgs[0].Value <<= aSeq; |
| xHelper->executeDispatch( xProv, aCmd, ::rtl::OUString(), 0, aArgs ); |
| } |
| } |
| } |
| } |
| else |
| ErrorHandler::HandleError(ErrCode( eErr )); |
| } |
| else |
| { |
| // Neues Dokument erzeugen. |
| SfxViewFrame *pFrame = SfxViewFrame::LoadDocument( *xDocSh, 0 ); |
| SwView *pCurrView = (SwView*) pFrame->GetViewShell(); |
| |
| // Dokumenttitel setzen |
| String aTmp( SW_RES(STR_ABSTRACT_TITLE) ); |
| aTmp += GetTitle(); |
| xDocSh->SetTitle( aTmp ); |
| pCurrView->GetWrtShell().SetNewDoc(); |
| pFrame->Show(); |
| pSmryDoc->SetModified(); |
| } |
| |
| } |
| delete pDlg; |
| } |
| break; |
| case FN_OUTLINE_TO_CLIPBOARD: |
| case FN_OUTLINE_TO_IMPRESS: |
| { |
| sal_Bool bEnable = IsEnableSetModified(); |
| EnableSetModified( sal_False ); |
| WriterRef xWrt; |
| // mba: looks as if relative URLs don't make sense here |
| ::GetRTFWriter( 'O', String(), xWrt ); |
| SvMemoryStream *pStrm = new SvMemoryStream(); |
| pStrm->SetBufferSize( 16348 ); |
| SwWriter aWrt( *pStrm, *GetDoc() ); |
| ErrCode eErr = aWrt.Write( xWrt ); |
| EnableSetModified( bEnable ); |
| if( !ERRCODE_TOERROR( eErr ) ) |
| { |
| pStrm->Seek( STREAM_SEEK_TO_END ); |
| *pStrm << '\0'; |
| pStrm->Seek( STREAM_SEEK_TO_BEGIN ); |
| if ( nWhich == FN_OUTLINE_TO_IMPRESS ) |
| { |
| uno::Reference< lang::XMultiServiceFactory > xORB = ::comphelper::getProcessServiceFactory(); |
| uno::Reference< frame::XDispatchProvider > xProv( |
| xORB->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.drawing.ModuleDispatcher")), UNO_QUERY ); |
| if ( xProv.is() ) |
| { |
| ::rtl::OUString aCmd = ::rtl::OUString::createFromAscii( "SendOutlineToImpress" ); |
| uno::Reference< frame::XDispatchHelper > xHelper( |
| xORB->createInstance( ::rtl::OUString::createFromAscii("com.sun.star.frame.DispatchHelper")), UNO_QUERY ); |
| if ( xHelper.is() ) |
| { |
| pStrm->Seek( STREAM_SEEK_TO_END ); |
| *pStrm << '\0'; |
| pStrm->Seek( STREAM_SEEK_TO_BEGIN ); |
| |
| // Transfer ownership of stream to a lockbytes object |
| SvLockBytes aLockBytes( pStrm, sal_True ); |
| SvLockBytesStat aStat; |
| if ( aLockBytes.Stat( &aStat, SVSTATFLAG_DEFAULT ) == ERRCODE_NONE ) |
| { |
| sal_uInt32 nLen = aStat.nSize; |
| sal_uLong nRead = 0; |
| uno::Sequence< sal_Int8 > aSeq( nLen ); |
| aLockBytes.ReadAt( 0, aSeq.getArray(), nLen, &nRead ); |
| |
| uno::Sequence< beans::PropertyValue > aArgs(1); |
| aArgs[0].Name = ::rtl::OUString::createFromAscii("RtfOutline"); |
| aArgs[0].Value <<= aSeq; |
| xHelper->executeDispatch( xProv, aCmd, ::rtl::OUString(), 0, aArgs ); |
| } |
| } |
| } |
| } |
| else |
| { |
| TransferDataContainer* pClipCntnr = |
| new TransferDataContainer; |
| STAR_REFERENCE( datatransfer::XTransferable ) |
| xRef( pClipCntnr ); |
| |
| pClipCntnr->CopyAnyData( FORMAT_RTF, (sal_Char*) |
| pStrm->GetData(), pStrm->GetEndOfData() ); |
| pClipCntnr->CopyToClipboard( |
| GetView()? (Window*)&GetView()->GetEditWin() : 0 ); |
| delete pStrm; |
| } |
| } |
| else |
| ErrorHandler::HandleError(ErrCode( eErr )); |
| } |
| break; |
| case SID_SPELLCHECKER_CHANGED: |
| //! sal_False, sal_True, sal_True is on the save side but a probably overdone |
| SW_MOD()->CheckSpellChanges(sal_False, sal_True, sal_True, sal_False ); |
| break; |
| |
| case SID_MAIL_PREPAREEXPORT: |
| { |
| //pWrtShell is not set in page preview |
| if(mpWrtShell) |
| mpWrtShell->StartAllAction(); |
| mpDoc->UpdateFlds( NULL, false ); |
| mpDoc->EmbedAllLinks(); |
| mpDoc->RemoveInvisibleContent(); |
| if(mpWrtShell) |
| mpWrtShell->EndAllAction(); |
| } |
| break; |
| |
| case SID_MAIL_EXPORT_FINISHED: |
| { |
| if(mpWrtShell) |
| mpWrtShell->StartAllAction(); |
| //try to undo the removal of invisible content |
| mpDoc->RestoreInvisibleContent(); |
| if(mpWrtShell) |
| mpWrtShell->EndAllAction(); |
| } |
| break; |
| case FN_NEW_HTML_DOC: |
| case FN_NEW_GLOBAL_DOC: |
| { |
| bDone = sal_False; |
| sal_Bool bCreateHtml = FN_NEW_HTML_DOC == nWhich; |
| |
| sal_Bool bCreateByOutlineLevel = false; //#outline level,add by zhaojianwei |
| sal_Int32 nTemplateOutlineLevel = 0 ; //#outline level,add by zhaojianwei |
| |
| String aFileName, aTemplateName; |
| if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nWhich, sal_False, &pItem ) ) |
| { |
| aFileName = ((const SfxStringItem*)pItem)->GetValue(); |
| SFX_ITEMSET_ARG( pArgs, pTemplItem, SfxStringItem, SID_TEMPLATE_NAME, sal_False ); |
| if ( pTemplItem ) |
| aTemplateName = pTemplItem->GetValue(); |
| } |
| bool bError = false; |
| if ( !aFileName.Len() ) |
| { |
| FileDialogHelper aDlgHelper( TemplateDescription::FILESAVE_AUTOEXTENSION_TEMPLATE, 0 ); |
| |
| const sal_Int16 nControlIds[] = { |
| CommonFilePickerElementIds::PUSHBUTTON_OK, |
| CommonFilePickerElementIds::PUSHBUTTON_CANCEL, |
| CommonFilePickerElementIds::LISTBOX_FILTER, |
| CommonFilePickerElementIds::CONTROL_FILEVIEW, |
| CommonFilePickerElementIds::EDIT_FILEURL, |
| ExtendedFilePickerElementIds::CHECKBOX_AUTOEXTENSION, |
| ExtendedFilePickerElementIds::LISTBOX_TEMPLATE, |
| 0 |
| }; |
| |
| const char* aHTMLHelpIds[] = |
| { |
| HID_SEND_HTML_CTRL_PUSHBUTTON_OK, |
| HID_SEND_HTML_CTRL_PUSHBUTTON_CANCEL, |
| HID_SEND_HTML_CTRL_LISTBOX_FILTER, |
| HID_SEND_HTML_CTRL_CONTROL_FILEVIEW, |
| HID_SEND_HTML_CTRL_EDIT_FILEURL, |
| HID_SEND_HTML_CTRL_CHECKBOX_AUTOEXTENSION, |
| HID_SEND_HTML_CTRL_LISTBOX_TEMPLATE, |
| "" |
| }; |
| |
| const char* aMasterHelpIds[] = |
| { |
| HID_SEND_MASTER_CTRL_PUSHBUTTON_OK, |
| HID_SEND_MASTER_CTRL_PUSHBUTTON_CANCEL, |
| HID_SEND_MASTER_CTRL_LISTBOX_FILTER, |
| HID_SEND_MASTER_CTRL_CONTROL_FILEVIEW, |
| HID_SEND_MASTER_CTRL_EDIT_FILEURL, |
| HID_SEND_MASTER_CTRL_CHECKBOX_AUTOEXTENSION, |
| HID_SEND_MASTER_CTRL_LISTBOX_TEMPLATE, |
| "" |
| }; |
| |
| const char** pHelpIds = bCreateHtml ? aHTMLHelpIds : aMasterHelpIds; |
| aDlgHelper.SetControlHelpIds( nControlIds, pHelpIds ); |
| uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker(); |
| |
| const SfxFilter* pFlt; |
| sal_uInt16 nStrId; |
| |
| if( bCreateHtml ) |
| { |
| // fuer HTML gibts es nur einen Filter!! |
| pFlt = SwIoSystem::GetFilterOfFormat( |
| String::CreateFromAscii("HTML"), |
| SwWebDocShell::Factory().GetFilterContainer() ); |
| nStrId = STR_LOAD_HTML_DOC; |
| } |
| else |
| { |
| // Fuer Global-Dokumente bieten wir jetzt auch nur |
| // noch den aktuellen an. |
| pFlt = SwGlobalDocShell::Factory().GetFilterContainer()-> |
| GetFilter4Extension( String::CreateFromAscii("odm") ); |
| nStrId = STR_LOAD_GLOBAL_DOC; |
| } |
| |
| if( pFlt ) |
| { |
| uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY); |
| const String sWild = ((WildCard&)pFlt->GetWildcard()).GetWildCard(); |
| xFltMgr->appendFilter( pFlt->GetUIName(), sWild ); |
| try |
| { |
| xFltMgr->setCurrentFilter( pFlt->GetUIName() ) ; |
| } |
| catch( const uno::Exception& ) |
| { |
| bError = true; |
| } |
| } |
| if(!bError) |
| { |
| uno::Reference<XFilePickerControlAccess> xCtrlAcc(xFP, UNO_QUERY); |
| |
| //#removed by zhaojianwei |
| |
| // const sal_uInt16 nCount = pDoc->GetTxtFmtColls()->Count(); |
| // Sequence<OUString> aListBoxEntries(nCount); |
| // OUString* pEntries = aListBoxEntries.getArray(); |
| // sal_Int32 nIdx = 0; |
| // sal_Int16 nSelect = 0; |
| // OUString sStartTemplate; |
| // SwTxtFmtColl *pFnd = 0, *pAny = 0; |
| // for(sal_uInt16 i = 0; i < nCount; ++i) |
| // { |
| // SwTxtFmtColl &rTxtColl = |
| // *pDoc->GetTxtFmtColls()->GetObject( i ); |
| // if( !rTxtColl.IsDefault() && rTxtColl.IsAtDocNodeSet() ) |
| // { |
| // //if( MAXLEVEL >= rTxtColl.GetOutlineLevel() && ( !pFnd || //#outline level,zhaojianwei |
| //if( rTxtColl.IsAssignedToListLevelOfOutlineStyle() && ( !pFnd || //<-end,zhaojianwei |
| // pFnd->GetAssignedOutlineStyleLevel() > rTxtColl.GetAssignedOutlineStyleLevel() )) |
| // { |
| // nSelect = (sal_Int16)nIdx; |
| // pFnd = &rTxtColl; |
| // sStartTemplate = rTxtColl.GetName(); |
| // } |
| // else if( !pAny ) |
| // pAny = &rTxtColl; |
| // //pEntries[nIdx++] = rTxtColl.GetName(); //#outline level,remove by zhaojianwei |
| // pEntries[nIdx++] = sStyles + rTxtColl.GetName(); //#outline level,add by zhaojianwei |
| // } |
| // } |
| // if(!sStartTemplate.getLength() && pAny) |
| // sStartTemplate = pAny->GetName(); |
| // aListBoxEntries.realloc(nIdx); |
| //<-end,zhaojianwei |
| |
| |
| //#outline level,add by zhaojianwei |
| ///////////////////////////////////////////////////////////////////// |
| |
| bool bOutline[MAXLEVEL] = {false}; |
| const SwOutlineNodes& rOutlNds = mpDoc->GetNodes().GetOutLineNds(); |
| if( rOutlNds.Count() ) |
| { |
| int nLevel; |
| for(sal_uInt16 n = 0; n < rOutlNds.Count(); ++n ) |
| if( ( nLevel = rOutlNds[n]->GetTxtNode()->GetAttrOutlineLevel()) > 0 && |
| ! bOutline[nLevel-1] ) |
| { |
| bOutline[nLevel-1] = true; |
| } |
| } |
| |
| const sal_uInt16 nStyleCount = mpDoc->GetTxtFmtColls()->Count(); |
| Sequence<OUString> aListBoxEntries( MAXLEVEL + nStyleCount); |
| OUString* pEntries = aListBoxEntries.getArray(); |
| sal_Int32 nIdx = 0 ; |
| |
| OUString sOutline( SW_RESSTR(STR_FDLG_OUTLINE_LEVEL) ); |
| for( sal_uInt16 i = 0; i < MAXLEVEL; ++i ) |
| { |
| if( bOutline[i] ) |
| pEntries[nIdx++] = sOutline + String::CreateFromInt32( i+1 ); |
| } |
| |
| OUString sStyle( SW_RESSTR(STR_FDLG_STYLE) ); |
| for(sal_uInt16 i = 0; i < nStyleCount; ++i) |
| { |
| SwTxtFmtColl &rTxtColl = |
| *mpDoc->GetTxtFmtColls()->GetObject( i ); |
| if( !rTxtColl.IsDefault() && rTxtColl.IsAtDocNodeSet() ) |
| { |
| pEntries[nIdx++] = sStyle + rTxtColl.GetName(); |
| } |
| } |
| |
| aListBoxEntries.realloc(nIdx); |
| sal_Int16 nSelect = 0; |
| ///////////////////////////////////////////////////////////////////// |
| //<-end,zhaojianwei |
| |
| try |
| { |
| Any aTemplates(&aListBoxEntries, ::getCppuType(&aListBoxEntries)); |
| |
| xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_TEMPLATE, |
| ListboxControlActions::ADD_ITEMS , aTemplates ); |
| Any aSelectPos(&nSelect, ::getCppuType(&nSelect)); |
| xCtrlAcc->setValue( ExtendedFilePickerElementIds::LISTBOX_TEMPLATE, |
| ListboxControlActions::SET_SELECT_ITEM, aSelectPos ); |
| xCtrlAcc->setLabel( ExtendedFilePickerElementIds::LISTBOX_TEMPLATE, |
| String(SW_RES( STR_FDLG_TEMPLATE_NAME ))); |
| } |
| catch(Exception& ) |
| { |
| DBG_ERROR("control acces failed"); |
| } |
| |
| xFP->setTitle( SW_RESSTR( nStrId )); |
| SvtPathOptions aPathOpt; |
| xFP->setDisplayDirectory( aPathOpt.GetWorkPath() ); |
| if( ERRCODE_NONE == aDlgHelper.Execute()) |
| { |
| aFileName = xFP->getFiles().getConstArray()[0]; |
| Any aTemplateValue = xCtrlAcc->getValue( |
| ExtendedFilePickerElementIds::LISTBOX_TEMPLATE, |
| ListboxControlActions::GET_SELECTED_ITEM ); |
| OUString sTmpl; |
| aTemplateValue >>= sTmpl; |
| //aTemplateName = sTmpl; //#outline level,removed by zhaojianwei |
| //#outline level,add by zhaojianwei |
| |
| sal_Int32 nColonPos = sTmpl.indexOf( sal_Unicode(':') ); |
| OUString sPrefix = sTmpl.copy( 0L, nColonPos ); |
| if( sPrefix.equalsAscii("Style")) |
| { |
| aTemplateName = sTmpl.copy( 7L ); //get string behind "Style: " |
| } |
| else if( sPrefix.equalsAscii("Outline")) |
| { |
| nTemplateOutlineLevel = ( sTmpl.copy( 15L )).toInt32(); //get string behind "Outline: Leve "; |
| bCreateByOutlineLevel = true; |
| } |
| //<-end,zhaojianwei |
| |
| if ( aFileName.Len() ) |
| { |
| rReq.AppendItem( SfxStringItem( nWhich, aFileName ) ); |
| if( aTemplateName.Len() ) |
| rReq.AppendItem( SfxStringItem( SID_TEMPLATE_NAME, aTemplateName ) ); |
| } |
| } |
| } |
| } |
| |
| //const SwTxtFmtColl* pSplitColl = 0; //#outline level,removed by zhaojianwei |
| // if ( aTemplateName.Len() ) |
| // pSplitColl = pDoc->FindTxtFmtCollByName(aTemplateName); |
| //<-end,zhaojianwei |
| if( aFileName.Len() ) |
| { |
| if( PrepareClose( sal_False ) ) |
| { |
| SwWait aWait( *this, true ); |
| |
| //bDone = bCreateHtml //#outline level,removed by zhaojianwei |
| // ? pDoc->GenerateHTMLDoc( aFileName, pSplitColl ) |
| // : pDoc->GenerateGlobalDoc( aFileName, pSplitColl ); |
| if ( bCreateByOutlineLevel ) //add by zhaojianwei |
| { |
| bDone = bCreateHtml //#outline level,removed by zhaojianwei |
| ? mpDoc->GenerateHTMLDoc( aFileName, nTemplateOutlineLevel ) |
| : mpDoc->GenerateGlobalDoc( aFileName, nTemplateOutlineLevel ); |
| } |
| else |
| { |
| const SwTxtFmtColl* pSplitColl = 0; |
| if ( aTemplateName.Len() ) |
| pSplitColl = mpDoc->FindTxtFmtCollByName(aTemplateName); |
| bDone = bCreateHtml //#outline level,removed by zhaojianwei |
| ? mpDoc->GenerateHTMLDoc( aFileName, pSplitColl ) |
| : mpDoc->GenerateGlobalDoc( aFileName, pSplitColl ); |
| } |
| //<-end,zhaojianwei |
| if( bDone ) |
| { |
| SfxStringItem aName( SID_FILE_NAME, aFileName ); |
| SfxStringItem aReferer( SID_REFERER, aEmptyStr ); |
| SfxViewShell* pViewShell = SfxViewShell::GetFirst(); |
| while(pViewShell) |
| { |
| //search for the view that created the call |
| if(pViewShell->GetObjectShell() == this && pViewShell->GetDispatcher()) |
| { |
| SfxFrameItem* pFrameItem = new SfxFrameItem( SID_DOCFRAME, |
| pViewShell->GetViewFrame() ); |
| SfxDispatcher* pDispatch = pViewShell->GetDispatcher(); |
| pDispatch->Execute( |
| SID_OPENDOC, |
| SFX_CALLMODE_ASYNCHRON, |
| &aName, |
| &aReferer, |
| pFrameItem, 0L ); |
| |
| delete pFrameItem; |
| break; |
| } |
| pViewShell = SfxViewShell::GetNext(*pViewShell); |
| } |
| } |
| } |
| if( !bDone && !rReq.IsAPI() ) |
| { |
| InfoBox( 0, SW_RESSTR( STR_CANTCREATE )).Execute(); |
| } |
| } |
| } |
| rReq.SetReturnValue(SfxBoolItem( nWhich, bDone )); |
| if (bDone) |
| rReq.Done(); |
| else |
| rReq.Ignore(); |
| break; |
| |
| case SID_ATTR_YEAR2000: |
| if ( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nWhich , sal_False, &pItem )) |
| { |
| DBG_ASSERT(pItem->ISA(SfxUInt16Item), "falsches Item"); |
| sal_uInt16 nYear2K = ((SfxUInt16Item*)pItem)->GetValue(); |
| //ueber Views iterieren und den State an den FormShells setzen |
| |
| SfxViewFrame* pVFrame = SfxViewFrame::GetFirst( this ); |
| SfxViewShell* pViewShell = pVFrame ? pVFrame->GetViewShell() : 0; |
| SwView* pCurrView = dynamic_cast< SwView* >( pViewShell ); |
| while(pCurrView) |
| { |
| FmFormShell* pFormShell = pCurrView->GetFormShell(); |
| if(pFormShell) |
| pFormShell->SetY2KState(nYear2K); |
| pVFrame = SfxViewFrame::GetNext( *pVFrame, this ); |
| pViewShell = pVFrame ? pVFrame->GetViewShell() : 0; |
| pCurrView = dynamic_cast<SwView*>( pViewShell ); |
| } |
| mpDoc->GetNumberFormatter(sal_True)->SetYear2000(nYear2K); |
| } |
| break; |
| |
| default: DBG_ERROR("falscher Dispatcher"); |
| } |
| } |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| long SwDocShell::DdeGetData( const String& rItem, const String& rMimeType, |
| uno::Any & rValue ) |
| { |
| return mpDoc->GetData( rItem, rMimeType, rValue ); |
| } |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| long SwDocShell::DdeSetData( const String& rItem, const String& rMimeType, |
| const uno::Any & rValue ) |
| { |
| return mpDoc->SetData( rItem, rMimeType, rValue ); |
| } |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| ::sfx2::SvLinkSource* SwDocShell::DdeCreateLinkSource( const String& rItem ) |
| { |
| return mpDoc->CreateLinkSource( rItem ); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwDocShell::FillClass( SvGlobalName * pClassName, |
| sal_uInt32 * pClipFormat, |
| String * /*pAppName*/, |
| String * pLongUserName, |
| String * pUserName, |
| sal_Int32 nVersion, |
| sal_Bool bTemplate /* = sal_False */) const |
| { |
| if (nVersion == SOFFICE_FILEFORMAT_60) |
| { |
| *pClassName = SvGlobalName( SO3_SW_CLASSID_60 ); |
| *pClipFormat = SOT_FORMATSTR_ID_STARWRITER_60; |
| *pLongUserName = SW_RESSTR(STR_WRITER_DOCUMENT_FULLTYPE); |
| } |
| else if (nVersion == SOFFICE_FILEFORMAT_8) |
| { |
| *pClassName = SvGlobalName( SO3_SW_CLASSID_60 ); |
| *pClipFormat = bTemplate ? SOT_FORMATSTR_ID_STARWRITER_8_TEMPLATE : SOT_FORMATSTR_ID_STARWRITER_8; |
| *pLongUserName = SW_RESSTR(STR_WRITER_DOCUMENT_FULLTYPE); |
| } |
| |
| *pUserName = SW_RESSTR(STR_HUMAN_SWDOC_NAME); |
| } |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwDocShell::SetModified( sal_Bool bSet ) |
| { |
| SfxObjectShell::SetModified( bSet ); |
| if( IsEnableSetModified()) |
| { |
| if (!mpDoc->IsInCallModified() ) |
| { |
| EnableSetModified( sal_False ); |
| if( bSet ) |
| { |
| sal_Bool bOld = mpDoc->IsModified(); |
| mpDoc->SetModified(); |
| if( !bOld ) |
| { |
| mpDoc->GetIDocumentUndoRedo().SetUndoNoResetModified(); |
| } |
| } |
| else |
| mpDoc->ResetModified(); |
| |
| EnableSetModified( sal_True ); |
| } |
| |
| UpdateChildWindows(); |
| Broadcast(SfxSimpleHint(SFX_HINT_DOCCHANGED)); |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| void SwDocShell::UpdateChildWindows() |
| { |
| // Flddlg ggf neu initialisieren (z.B. fuer TYP_SETVAR) |
| if(!GetView()) |
| return; |
| SfxViewFrame* pVFrame = GetView()->GetViewFrame(); |
| SwFldDlgWrapper *pWrp = (SwFldDlgWrapper*)pVFrame-> |
| GetChildWindow( SwFldDlgWrapper::GetChildWindowId() ); |
| if( pWrp ) |
| pWrp->ReInitDlg( this ); |
| |
| // RedlineDlg ggf neu initialisieren |
| SwRedlineAcceptChild *pRed = (SwRedlineAcceptChild*)pVFrame-> |
| GetChildWindow( SwRedlineAcceptChild::GetChildWindowId() ); |
| if( pRed ) |
| pRed->ReInitDlg( this ); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| // --> OD 2005-08-02 #i48748# |
| class SwReloadFromHtmlReader : public SwReader |
| { |
| public: |
| SwReloadFromHtmlReader( SfxMedium& _rTmpMedium, |
| const String& _rFilename, |
| SwDoc* _pDoc ) |
| : SwReader( _rTmpMedium, _rFilename, _pDoc ) |
| { |
| SetBaseURL( _rFilename ); |
| } |
| }; |
| // <-- |
| void SwDocShell::ReloadFromHtml( const String& rStreamName, SwSrcView* pSrcView ) |
| { |
| sal_Bool bModified = IsModified(); |
| |
| // MIB 23.6.97: Die HTTP-Header-Felder muessen geloescht werden, |
| // sonst gibt es welche aus Meta-Tags hinter doppelt und dreifach. |
| ClearHeaderAttributesForSourceViewHack(); |
| |
| // MIB 24.07.97: Das Dokument-Basic muss auch noch d'ran glauben ... |
| SvxHtmlOptions* pHtmlOptions = SvxHtmlOptions::Get(); |
| //#59620# HasBasic() zeigt an, dass es schon einen BasicManager an der DocShell |
| // gibt. Der wurde im HTML-Import immer angelegt, wenn Macros im Quelltext |
| // vorhanden sind. |
| if( pHtmlOptions && pHtmlOptions->IsStarBasic() && HasBasic()) |
| { |
| BasicManager *pBasicMan = GetBasicManager(); |
| if( pBasicMan && (pBasicMan != SFX_APP()->GetBasicManager()) ) |
| { |
| sal_uInt16 nLibCount = pBasicMan->GetLibCount(); |
| while( nLibCount ) |
| { |
| StarBASIC *pBasic = pBasicMan->GetLib( --nLibCount ); |
| if( pBasic ) |
| { |
| // Die IDE benachrichtigen |
| SfxUsrAnyItem aShellItem( SID_BASICIDE_ARG_DOCUMENT_MODEL, makeAny( GetModel() ) ); |
| String aLibName( pBasic->GetName() ); |
| SfxStringItem aLibNameItem( SID_BASICIDE_ARG_LIBNAME, aLibName ); |
| pSrcView->GetViewFrame()->GetDispatcher()->Execute( |
| SID_BASICIDE_LIBREMOVED, |
| SFX_CALLMODE_SYNCHRON, |
| &aShellItem, &aLibNameItem, 0L ); |
| |
| // Aus der Standard-Lib werden nur die Module geloescht |
| if( nLibCount ) |
| pBasicMan->RemoveLib( nLibCount, sal_True ); |
| else |
| pBasic->Clear(); |
| } |
| } |
| |
| ASSERT( pBasicMan->GetLibCount() <= 1, |
| "Loschen des Basics hat nicht geklappt" ); |
| } |
| } |
| sal_Bool bWasBrowseMode = mpDoc->get(IDocumentSettingAccess::BROWSE_MODE); |
| RemoveLink(); |
| |
| //jetzt muss auch das UNO-Model ueber das neue Doc informiert werden #51535# |
| uno::Reference<text::XTextDocument> xDoc(GetBaseModel(), uno::UNO_QUERY); |
| text::XTextDocument* pxDoc = xDoc.get(); |
| ((SwXTextDocument*)pxDoc)->InitNewDoc(); |
| |
| AddLink(); |
| //#116402# update font list when new document is created |
| UpdateFontList(); |
| mpDoc->set(IDocumentSettingAccess::BROWSE_MODE, bWasBrowseMode); |
| pSrcView->SetPool(&GetPool()); |
| |
| |
| const String& rMedname = GetMedium()->GetName(); |
| |
| // fix #51032#: Die HTML-Vorlage muss noch gesetzt werden |
| SetHTMLTemplate( *GetDoc() ); //Styles aus HTML.vor |
| |
| SfxViewShell* pViewShell = GetView() ? (SfxViewShell*)GetView() |
| : SfxViewShell::Current(); |
| SfxViewFrame* pViewFrm = pViewShell->GetViewFrame(); |
| pViewFrm->GetDispatcher()->Execute( SID_VIEWSHELL0, SFX_CALLMODE_SYNCHRON ); |
| |
| SubInitNew(); |
| |
| SfxMedium aMed( rStreamName, STREAM_READ, sal_False ); |
| // --> OD 2005-08-01 #i48748# - use class <SwReloadFromHtmlReader>, because |
| // the base URL has to be set to the filename of the document <rMedname> |
| // and not to the base URL of the temporary file <aMed> in order to get |
| // the URLs of the linked graphics correctly resolved. |
| SwReloadFromHtmlReader aReader( aMed, rMedname, mpDoc ); |
| // <-- |
| aReader.Read( *ReadHTML ); |
| |
| const SwView* pCurrView = GetView(); |
| //in print layout the first page(s) may have been formatted as a mix of browse |
| //and print layout |
| if(!bWasBrowseMode && pCurrView) |
| { |
| SwWrtShell& rWrtSh = pCurrView->GetWrtShell(); |
| if( rWrtSh.GetLayout()) |
| rWrtSh.CheckBrowseView( sal_True ); |
| } |
| |
| |
| // MIB 23.6.97: Die HTTP-Header-Attribute wieder in die DokInfo |
| // uebernehmen. Die Base-URL ist hier egal, da TLX zum absolutieren die |
| // vom Dokument nimmt. |
| SetHeaderAttributesForSourceViewHack(); |
| |
| if(bModified && !IsReadOnly()) |
| SetModified(); |
| else |
| mpDoc->ResetModified(); |
| } |
| |
| sal_uLong SwDocShell::LoadStylesFromFile( const String& rURL, |
| SwgReaderOption& rOpt, sal_Bool bUnoCall ) |
| { |
| sal_uLong nErr = 0; |
| |
| // Create a URL from filename |
| INetURLObject aURLObj( rURL ); |
| String sURL( aURLObj.GetMainURL( INetURLObject::NO_DECODE ) ); |
| |
| // Filter bestimmen: |
| // const SfxFilter* pFlt = SwIoSystem::GetFileFilter( rURL, aEmptyStr ); |
| String sFactory(String::CreateFromAscii(SwDocShell::Factory().GetShortName())); |
| SfxFilterMatcher aMatcher( sFactory ); |
| |
| //#b6445961# search for filter in WebDocShell, too |
| SfxMedium aMed( rURL, STREAM_STD_READ, sal_False ); |
| const SfxFilter* pFlt = 0; |
| aMatcher.DetectFilter( aMed, &pFlt, sal_False, sal_False ); |
| if(!pFlt) |
| { |
| String sWebFactory(String::CreateFromAscii(SwWebDocShell::Factory().GetShortName())); |
| SfxFilterMatcher aWebMatcher( sWebFactory ); |
| aWebMatcher.DetectFilter( aMed, &pFlt, sal_False, sal_False ); |
| } |
| // --> OD #i117339# - trigger import only for own formats |
| // if( aMed.IsStorage() ) |
| bool bImport( false ); |
| { |
| if ( aMed.IsStorage() ) |
| { |
| // As <SfxMedium.GetFilter().IsOwnFormat() resp. IsOwnTemplateFormat() |
| // does not work correct (e.g., MS Word 2007 XML Template), |
| // use workaround provided by MAV. |
| uno::Reference< embed::XStorage > xStorage = aMed.GetStorage(); |
| if ( xStorage.is() ) |
| { |
| // use <try-catch> on retrieving <MediaType> in order to check, |
| // if the storage is one of our own ones. |
| try |
| { |
| uno::Reference< beans::XPropertySet > xProps( xStorage, uno::UNO_QUERY_THROW ); |
| const ::rtl::OUString aMediaTypePropName( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ); |
| xProps->getPropertyValue( aMediaTypePropName ); |
| bImport = true; |
| } |
| catch( const uno::Exception& ) |
| { |
| bImport = false; |
| } |
| } |
| } |
| } |
| if ( bImport ) |
| // <-- |
| { |
| DBG_ASSERT((pFlt ? pFlt->GetVersion() : 0) >= SOFFICE_FILEFORMAT_60, "which file version?"); |
| SwRead pRead = ReadXML; |
| SwReader* pReader = 0; |
| SwPaM* pPam = 0; |
| // the SW3IO - Reader need the pam/wrtshell, because only then he |
| // insert the styles! |
| if( bUnoCall ) |
| { |
| SwNodeIndex aIdx( mpDoc->GetNodes().GetEndOfContent(), -1 ); |
| pPam = new SwPaM( aIdx ); |
| pReader = new SwReader( aMed, rURL, *pPam ); |
| } |
| else |
| { |
| pReader = new SwReader( aMed, rURL, *mpWrtShell->GetCrsr() ); |
| } |
| |
| pRead->GetReaderOpt().SetTxtFmts( rOpt.IsTxtFmts() ); |
| pRead->GetReaderOpt().SetFrmFmts( rOpt.IsFrmFmts() ); |
| pRead->GetReaderOpt().SetPageDescs( rOpt.IsPageDescs() ); |
| pRead->GetReaderOpt().SetNumRules( rOpt.IsNumRules() ); |
| pRead->GetReaderOpt().SetMerge( rOpt.IsMerge() ); |
| |
| if( bUnoCall ) |
| { |
| UnoActionContext aAction( mpDoc ); |
| nErr = pReader->Read( *pRead ); |
| } |
| else |
| { |
| mpWrtShell->StartAllAction(); |
| nErr = pReader->Read( *pRead ); |
| mpWrtShell->EndAllAction(); |
| } |
| delete pPam; |
| delete pReader; |
| } |
| |
| return nErr; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Get a client for an embedded object if possible. |
| --------------------------------------------------------------------*/ |
| SfxInPlaceClient* SwDocShell::GetIPClient( const ::svt::EmbeddedObjectRef& xObjRef ) |
| { |
| SfxInPlaceClient* pResult = NULL; |
| |
| SwWrtShell* pShell = GetWrtShell(); |
| if ( pShell ) |
| { |
| pResult = pShell->GetView().FindIPClient( xObjRef.GetObject(), (Window*)&pShell->GetView().GetEditWin() ); |
| if ( !pResult ) |
| pResult = new SwOleClient( &pShell->GetView(), &pShell->GetView().GetEditWin(), xObjRef ); |
| } |
| |
| return pResult; |
| } |
| |
