| /************************************************************** |
| * |
| * 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 <hintids.hxx> |
| #include <com/sun/star/util/SearchOptions.hpp> |
| #include <com/sun/star/util/SearchFlags.hpp> |
| #include <com/sun/star/i18n/TransliterationModules.hpp> |
| #include <com/sun/star/ui/dialogs/TemplateDescription.hpp> |
| #include <unotools/tempfile.hxx> |
| #include <tools/urlobj.hxx> |
| #include <vcl/print.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <vcl/wrkwin.hxx> |
| #include <vcl/metric.hxx> |
| #include <svtools/ctrltool.hxx> |
| #include <svl/intitem.hxx> |
| #include <svl/stritem.hxx> |
| #include <unotools/pathoptions.hxx> |
| #include <svl/undo.hxx> |
| #include <svtools/txtcmp.hxx> |
| #include <svl/eitem.hxx> |
| #include <svl/whiter.hxx> |
| #include <unotools/saveopt.hxx> |
| #include <svtools/transfer.hxx> |
| #include <svtools/svtools.hrc> |
| #include <svtools/svtdata.hxx> |
| #include <svx/svxids.hrc> |
| #include <svtools/htmlcfg.hxx> |
| #include <sfx2/app.hxx> |
| #include <sfx2/objface.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <sfx2/bindings.hxx> |
| #include <sfx2/docfilt.hxx> |
| #include <sfx2/fcontnr.hxx> |
| #include <sfx2/request.hxx> |
| #include <sfx2/prnmon.hxx> |
| #include <sfx2/docfile.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <svx/srchdlg.hxx> |
| #include <svl/srchitem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <editeng/flstitem.hxx> |
| #include "editeng/unolingu.hxx" |
| #include <sfx2/sfxhtml.hxx> |
| #include <swtypes.hxx> |
| #include <swmodule.hxx> |
| #include <docsh.hxx> |
| #include <wdocsh.hxx> |
| #include <srcview.hxx> |
| #include <viewfunc.hxx> |
| #include <doc.hxx> |
| #include <sfx2/msg.hxx> |
| #include <shellio.hxx> |
| |
| #include <cmdid.h> // FN_ ... |
| #include <helpid.h> |
| #include <globals.hrc> |
| #include <shells.hrc> |
| #include <popup.hrc> |
| #include <web.hrc> |
| #include <view.hrc> |
| #include <com/sun/star/ui/dialogs/XFilePicker.hpp> |
| #include <com/sun/star/ui/dialogs/XFilterManager.hpp> |
| #include <sfx2/filedlghelper.hxx> |
| #define SwSrcView |
| #include "swslots.hxx" |
| |
| #include <unomid.h> |
| |
| #include <com/sun/star/document/XDocumentProperties.hpp> |
| #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::i18n; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::ui::dialogs; |
| using namespace ::com::sun::star::i18n; |
| using namespace ::com::sun::star::lang; |
| using namespace ::sfx2; |
| using ::rtl::OUString; |
| using ::com::sun::star::util::SearchOptions; |
| |
| |
| #define SWSRCVIEWFLAGS ( SFX_VIEW_CAN_PRINT|\ |
| SFX_VIEW_NO_NEWWINDOW ) |
| |
| #define SRC_SEARCHOPTIONS (0xFFFF & ~(SEARCH_OPTIONS_FORMAT|SEARCH_OPTIONS_FAMILIES|SEARCH_OPTIONS_SEARCH_ALL)) |
| |
| // Druckraender -> wie Basic - Ide |
| #define LMARGPRN 1700 |
| #define RMARGPRN 900 |
| #define TMARGPRN 2000 |
| #define BMARGPRN 1000 |
| #define BORDERPRN 300 |
| |
| SFX_IMPL_NAMED_VIEWFACTORY(SwSrcView, "SourceView") |
| { |
| SFX_VIEW_REGISTRATION(SwWebDocShell); |
| } |
| |
| SFX_IMPL_INTERFACE( SwSrcView, SfxViewShell, SW_RES(0) ) |
| { |
| SFX_POPUPMENU_REGISTRATION(SW_RES(MN_SRCVIEW_POPUPMENU)); |
| SFX_OBJECTBAR_REGISTRATION( SFX_OBJECTBAR_TOOLS| |
| SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_SERVER, |
| SW_RES(RID_WEBTOOLS_TOOLBOX) ); |
| SFX_CHILDWINDOW_REGISTRATION(SvxSearchDialogWrapper::GetChildWindowId()); |
| } |
| |
| TYPEINIT1(SwSrcView, SfxViewShell) |
| |
| /*-----------------18.11.96 08.05------------------- |
| |
| --------------------------------------------------*/ |
| |
| |
| void lcl_PrintHeader( OutputDevice &rOutDev, sal_uInt16 nPages, sal_uInt16 nCurPage, const String& rTitle ) |
| { |
| short nLeftMargin = LMARGPRN; |
| Size aSz = rOutDev.GetOutputSize(); |
| short nBorder = BORDERPRN; |
| |
| Color aOldFillColor( rOutDev.GetFillColor() ); |
| Font aOldFont( rOutDev.GetFont() ); |
| |
| rOutDev.SetFillColor( Color(COL_TRANSPARENT) ); |
| |
| Font aFont( aOldFont ); |
| aFont.SetWeight( WEIGHT_BOLD ); |
| aFont.SetAlign( ALIGN_BOTTOM ); |
| rOutDev.SetFont( aFont ); |
| |
| long nFontHeight = rOutDev.GetTextHeight(); |
| |
| // 1.Border => Strich, 2+3 Border = Freiraum. |
| long nYTop = TMARGPRN-3*nBorder-nFontHeight; |
| |
| long nXLeft = nLeftMargin-nBorder; |
| long nXRight = aSz.Width()-RMARGPRN+nBorder; |
| |
| rOutDev.DrawRect( Rectangle( |
| Point( nXLeft, nYTop ), |
| Size( nXRight-nXLeft, aSz.Height() - nYTop - BMARGPRN + nBorder ) ) ); |
| |
| |
| long nY = TMARGPRN-2*nBorder; |
| Point aPos( nLeftMargin, nY ); |
| rOutDev.DrawText( aPos, rTitle ); |
| if ( nPages != 1 ) |
| { |
| aFont.SetWeight( WEIGHT_NORMAL ); |
| rOutDev.SetFont( aFont ); |
| String aPageStr( C2S(" [") ); |
| aPageStr += String( SW_RES( STR_PAGE ) ); |
| aPageStr += ' '; |
| aPageStr += String::CreateFromInt32( nCurPage ); |
| aPageStr += ']'; |
| aPos.X() += rOutDev.GetTextWidth( rTitle ); |
| rOutDev.DrawText( aPos, aPageStr ); |
| } |
| |
| |
| nY = TMARGPRN-nBorder; |
| |
| rOutDev.DrawLine( Point( nXLeft, nY ), Point( nXRight, nY ) ); |
| |
| rOutDev.SetFont( aOldFont ); |
| rOutDev.SetFillColor( aOldFillColor ); |
| } |
| /* -----------------13.11.2003 16:24----------------- |
| |
| --------------------------------------------------*/ |
| rtl_TextEncoding lcl_GetStreamCharSet(rtl_TextEncoding eLoadEncoding) |
| { |
| rtl_TextEncoding eRet = eLoadEncoding; |
| if(RTL_TEXTENCODING_DONTKNOW == eRet) |
| { |
| SvxHtmlOptions* pHtmlOptions = SvxHtmlOptions::Get(); |
| const sal_Char *pCharSet = |
| rtl_getBestMimeCharsetFromTextEncoding( pHtmlOptions->GetTextEncoding() ); |
| eRet = rtl_getTextEncodingFromMimeCharset( pCharSet ); |
| } |
| return eRet; |
| } |
| /*-----------------18.11.96 08.21------------------- |
| |
| --------------------------------------------------*/ |
| |
| void lcl_ConvertTabsToSpaces( String& rLine ) |
| { |
| if ( rLine.Len() ) |
| { |
| sal_uInt16 nPos = 0; |
| sal_uInt16 nMax = rLine.Len(); |
| while ( nPos < nMax ) |
| { |
| if ( rLine.GetChar(nPos) == '\t' ) |
| { |
| // Nicht 4 Blanks, sondern an 4er TabPos: |
| String aBlanker; |
| aBlanker.Fill( ( 4 - ( nPos % 4 ) ), ' ' ); |
| rLine.Erase( nPos, 1 ); |
| rLine.Insert( aBlanker, nPos ); |
| nMax = rLine.Len(); |
| } |
| nPos++; // Nicht optimal, falls Tab, aber auch nicht verkehrt... |
| } |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| SwSrcView::SwSrcView(SfxViewFrame* pViewFrame, SfxViewShell*) : |
| SfxViewShell( pViewFrame, SWSRCVIEWFLAGS ), |
| aEditWin( &pViewFrame->GetWindow(), this ), |
| pSearchItem(0), |
| bSourceSaved(sal_False), |
| eLoadEncoding(RTL_TEXTENCODING_DONTKNOW) |
| { |
| Init(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| SwSrcView::~SwSrcView() |
| { |
| SwDocShell* pDocShell = GetDocShell(); |
| DBG_ASSERT(PTR_CAST(SwWebDocShell, pDocShell), "Wieso keine WebDocShell?"); |
| const TextSelection& rSel = aEditWin.GetTextView()->GetSelection(); |
| ((SwWebDocShell*)pDocShell)->SetSourcePara( static_cast< sal_uInt16 >( rSel.GetStart().GetPara() ) ); |
| |
| uno::Reference<document::XDocumentPropertiesSupplier> xDPS( |
| pDocShell->GetModel(), uno::UNO_QUERY_THROW); |
| uno::Reference<document::XDocumentProperties> xDocProps |
| = xDPS->getDocumentProperties(); |
| ::rtl::OUString url = xDocProps->getAutoloadURL(); |
| sal_Int32 delay = xDocProps->getAutoloadSecs(); |
| pDocShell->SetAutoLoad(INetURLObject(url), delay, |
| (delay != 0) || !url.equalsAscii("")); |
| // EndListening(*GetViewFrame()); |
| EndListening(*pDocShell); |
| delete pSearchItem; |
| } |
| |
| /*-----------------24.04.97 10:37------------------- |
| |
| --------------------------------------------------*/ |
| void SwSrcView::SaveContentTo(SfxMedium& rMed) |
| { |
| SvStream* pOutStream = rMed.GetOutStream(); |
| pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(eLoadEncoding)); |
| aEditWin.Write( *pOutStream );//, EE_FORMAT_TEXT); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::Init() |
| { |
| SetHelpId(SW_SRC_VIEWSHELL); |
| SetName(C2S("Source")); |
| SetWindow( &aEditWin ); |
| SwDocShell* pDocShell = GetDocShell(); |
| // wird das Doc noch geladen, dann muss die DocShell das Load |
| // anwerfen, wenn das Laden abgeschlossen ist |
| if(!pDocShell->IsLoading()) |
| Load(pDocShell); |
| else |
| { |
| aEditWin.SetReadonly(sal_True); |
| } |
| |
| SetNewWindowAllowed( sal_False ); |
| StartListening(*pDocShell,sal_True); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| SwDocShell* SwSrcView::GetDocShell() |
| { |
| SfxObjectShell* pObjShell = GetViewFrame()->GetObjectShell(); |
| return PTR_CAST(SwDocShell, pObjShell); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::SaveContent(const String& rTmpFile) |
| { |
| SfxMedium aMedium( rTmpFile, STREAM_WRITE, sal_True); |
| SvStream* pOutStream = aMedium.GetOutStream(); |
| pOutStream->SetStreamCharSet( lcl_GetStreamCharSet(eLoadEncoding) ); |
| aEditWin.Write(*pOutStream);//, EE_FORMAT_TEXT); |
| aMedium.Commit(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::Execute(SfxRequest& rReq) |
| { |
| sal_uInt16 nSlot = rReq.GetSlot(); |
| TextView* pTextView = aEditWin.GetTextView(); |
| switch( nSlot ) |
| { |
| case SID_SAVEASDOC: |
| { |
| SvtPathOptions aPathOpt; |
| // filesave dialog with autoextension |
| FileDialogHelper aDlgHelper( |
| TemplateDescription::FILESAVE_AUTOEXTENSION, |
| TemplateDescription::FILESAVE_SIMPLE ); |
| uno::Reference < XFilePicker > xFP = aDlgHelper.GetFilePicker(); |
| // pFileDlg->SetHelpId(HID_FILEDLG_SRCVIEW); |
| uno::Reference<XFilterManager> xFltMgr(xFP, UNO_QUERY); |
| |
| // search for an html filter for export |
| SfxFilterContainer* pFilterCont = GetObjectShell()->GetFactory().GetFilterContainer(); |
| const SfxFilter* pFilter = |
| pFilterCont->GetFilter4Extension( C2S("html"), SFX_FILTER_EXPORT ); |
| if ( pFilter ) |
| { |
| // filter found -> use its uiname and wildcard |
| const String& rUIName = pFilter->GetUIName(); |
| const WildCard& rCard = pFilter->GetWildcard(); |
| xFltMgr->appendFilter( rUIName, rCard() ); |
| xFltMgr->setCurrentFilter( rUIName ) ; |
| } |
| else |
| { |
| // filter not found |
| String sHtml(C2S("HTML")); |
| xFltMgr->appendFilter( sHtml, C2S("*.html;*.htm") ); |
| xFltMgr->setCurrentFilter( sHtml ) ; |
| } |
| |
| xFP->setDisplayDirectory( aPathOpt.GetWorkPath() ); |
| if( aDlgHelper.Execute() == ERRCODE_NONE) |
| { |
| SfxMedium aMedium( xFP->getFiles().getConstArray()[0], |
| STREAM_WRITE | STREAM_SHARE_DENYNONE, |
| sal_False ); |
| SvStream* pOutStream = aMedium.GetOutStream(); |
| pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(eLoadEncoding)); |
| aEditWin.Write( *pOutStream ); |
| aMedium.Commit(); |
| } |
| } |
| break; |
| case SID_SAVEDOC: |
| { |
| SwDocShell* pDocShell = GetDocShell(); |
| SfxMedium* pMed = 0; |
| if(pDocShell->HasName()) |
| pMed = pDocShell->GetMedium(); |
| else |
| { |
| SfxBoolItem* pItem = (SfxBoolItem*)pDocShell->ExecuteSlot(rReq, pDocShell->GetInterface()); |
| if(pItem && pItem->GetValue()) |
| pMed = pDocShell->GetMedium(); |
| } |
| if(pMed) |
| { |
| SvStream* pOutStream = pMed->GetOutStream(); |
| pOutStream->Seek(0); |
| pOutStream->SetStreamSize(0); |
| pOutStream->SetStreamCharSet(lcl_GetStreamCharSet(eLoadEncoding)); |
| aEditWin.Write( *pOutStream ); |
| pMed->CloseOutStream(); |
| pMed->Commit(); |
| pDocShell->GetDoc()->ResetModified(); |
| SourceSaved(); |
| aEditWin.ClearModifyFlag(); |
| } |
| } |
| break; |
| case FID_SEARCH_NOW: |
| { |
| const SfxItemSet* pTmpArgs = rReq.GetArgs(); |
| |
| sal_uInt16 nWhich = pTmpArgs->GetWhichByPos( 0 ); |
| DBG_ASSERT( nWhich, "Wich fuer SearchItem ?" ); |
| const SfxPoolItem& rItem = pTmpArgs->Get( nWhich ); |
| SetSearchItem( (const SvxSearchItem&)rItem); |
| StartSearchAndReplace( (const SvxSearchItem&)rItem, sal_False, rReq.IsAPI() ); |
| if(aEditWin.IsModified()) |
| GetDocShell()->GetDoc()->SetModified(); |
| } |
| break; |
| case FN_REPEAT_SEARCH: |
| { |
| SvxSearchItem* pSrchItem = GetSearchItem(); |
| if(pSrchItem) |
| { |
| StartSearchAndReplace( *pSrchItem, sal_False, rReq.IsAPI() ); |
| if(aEditWin.IsModified()) |
| GetDocShell()->GetDoc()->SetModified(); |
| } |
| } |
| break; |
| case SID_PRINTDOC: |
| case SID_PRINTDOCDIRECT: |
| { |
| SfxViewShell::ExecuteSlot( rReq, SfxViewShell::GetInterface() ); |
| } |
| break; |
| case SID_UNDO: |
| pTextView->Undo(); |
| GetViewFrame()->GetBindings().InvalidateAll(sal_False); |
| break; |
| case SID_REDO: |
| pTextView->Redo(); |
| GetViewFrame()->GetBindings().InvalidateAll(sal_False); |
| break; |
| case SID_REPEAT: |
| break; |
| case SID_CUT: |
| if(pTextView->HasSelection()) |
| pTextView->Cut(); |
| break; |
| case SID_COPY: |
| if(pTextView->HasSelection()) |
| pTextView->Copy(); |
| break; |
| case SID_PASTE: |
| pTextView->Paste(); |
| break; |
| case SID_SELECTALL: |
| pTextView->SetSelection( TextSelection( TextPaM( 0, 0 ), TextPaM( 0xFFFFFFFF, 0xFFFF ) ) ); |
| break; |
| } |
| aEditWin.Invalidate(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::GetState(SfxItemSet& rSet) |
| { |
| SfxWhichIter aIter(rSet); |
| sal_uInt16 nWhich = aIter.FirstWhich(); |
| TextView* pTextView = aEditWin.GetTextView(); |
| |
| while(nWhich) |
| { |
| switch(nWhich) |
| { |
| case SID_SAVEASDOC: |
| rSet.Put(SfxStringItem(nWhich, String(SW_RES(STR_SAVEAS_SRC)))); |
| break; |
| case SID_SAVEDOC: |
| { |
| SwDocShell* pDocShell = GetDocShell(); |
| if(!pDocShell->IsModified()) |
| rSet.DisableItem(nWhich); |
| } |
| break; |
| case SID_PRINTDOC: |
| case SID_PRINTDOCDIRECT: |
| break; |
| case SID_TABLE_CELL: |
| { |
| String aPos( SW_RES(STR_SRCVIEW_ROW) ); |
| TextSelection aSel = pTextView->GetSelection(); |
| aPos += String::CreateFromInt32( aSel.GetEnd().GetPara()+1 ); |
| aPos +=C2S(" : "); |
| aPos += String(SW_RES(STR_SRCVIEW_COL)); |
| aPos += String::CreateFromInt32( aSel.GetEnd().GetIndex()+1 ); |
| SfxStringItem aItem( nWhich, aPos ); |
| rSet.Put( aItem ); |
| } |
| break; |
| case SID_SEARCH_OPTIONS: |
| { |
| sal_uInt16 nOpt = SRC_SEARCHOPTIONS; |
| if(GetDocShell()->IsReadOnly()) |
| nOpt &= ~(SEARCH_OPTIONS_REPLACE|SEARCH_OPTIONS_REPLACE_ALL); |
| |
| rSet.Put( SfxUInt16Item( SID_SEARCH_OPTIONS, nOpt) ); |
| } |
| break; |
| case SID_SEARCH_ITEM: |
| { |
| String sSelected; |
| if ( !pTextView->HasSelection() ) |
| { |
| const TextSelection& rSel = pTextView->GetSelection(); |
| sSelected = aEditWin.GetTextEngine()->GetWord( rSel.GetStart()); |
| } |
| else |
| { |
| sSelected = pTextView->GetSelected(); |
| } |
| SvxSearchItem * pSrchItem = GetSearchItem(); |
| pSrchItem->SetSearchString( sSelected ); |
| rSet.Put( *pSrchItem ); |
| } |
| break; |
| case FN_REPEAT_SEARCH: |
| { |
| if(!GetSearchItem()) |
| rSet.DisableItem(nWhich); |
| }; |
| break; |
| case SID_UNDO: |
| case SID_REDO: |
| { |
| ::svl::IUndoManager& rMgr = pTextView->GetTextEngine()->GetUndoManager(); |
| sal_uInt16 nCount = 0; |
| if(nWhich == SID_UNDO) |
| { |
| nCount = rMgr.GetUndoActionCount(); |
| if(nCount) |
| { |
| String aStr(SvtResId( STR_UNDO));; |
| aStr += rMgr.GetUndoActionComment(--nCount); |
| rSet.Put(SfxStringItem(nWhich, aStr)); |
| } |
| else |
| rSet.DisableItem(nWhich); |
| } |
| else |
| { |
| nCount = rMgr.GetRedoActionCount(); |
| if(nCount) |
| { |
| String aStr(SvtResId( STR_REDO));; |
| aStr += rMgr.GetRedoActionComment(--nCount); |
| rSet.Put(SfxStringItem(nWhich,aStr)); |
| } |
| else |
| rSet.DisableItem(nWhich); |
| } |
| } |
| break; |
| case SID_MAIL_SENDDOCASPDF: |
| case SID_MAIL_SENDDOC : |
| case SID_EXPORTDOCASPDF: |
| case SID_DIRECTEXPORTDOCASPDF: |
| case SID_EXPORTDOC: |
| case SID_REPEAT: |
| case SID_BROWSER_MODE: |
| case FN_PRINT_LAYOUT: |
| rSet.DisableItem(nWhich); |
| break; |
| case SID_CUT: |
| case SID_COPY: |
| if(!pTextView->HasSelection()) |
| rSet.DisableItem(nWhich); |
| break; |
| case SID_PASTE: |
| { |
| TransferableDataHelper aDataHelper( |
| TransferableDataHelper::CreateFromSystemClipboard( |
| &aEditWin) ); |
| sal_Bool bDisable = !aDataHelper.GetXTransferable().is() || |
| 0 == aDataHelper.GetFormatCount(); |
| if( bDisable ) |
| rSet.DisableItem(nWhich); |
| } |
| break; |
| } |
| nWhich = aIter.NextWhich(); |
| } |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| SvxSearchItem* SwSrcView::GetSearchItem() |
| { |
| if(!pSearchItem) |
| { |
| pSearchItem = new SvxSearchItem(SID_SEARCH_ITEM); |
| } |
| return pSearchItem; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::SetSearchItem( const SvxSearchItem& rItem ) |
| { |
| delete pSearchItem; |
| pSearchItem = (SvxSearchItem*)rItem.Clone(); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| sal_uInt16 SwSrcView::StartSearchAndReplace(const SvxSearchItem& rSearchItem, |
| sal_Bool bFromStart, |
| sal_Bool bApi, |
| sal_Bool bRecursive) |
| { |
| ExtTextView* pTextView = aEditWin.GetTextView(); |
| TextSelection aSel; |
| TextPaM aPaM; |
| |
| sal_Bool bForward = !rSearchItem.GetBackward(); |
| sal_Bool bAtStart = pTextView->GetSelection() == TextSelection( aPaM, aPaM ); |
| |
| if( !bForward ) |
| aPaM = TextPaM( (sal_uLong)-1, (sal_uInt16)-1 ); |
| |
| if( bFromStart ) |
| { |
| aSel = pTextView->GetSelection(); |
| pTextView->SetSelection( TextSelection( aPaM, aPaM )); |
| } |
| |
| util::SearchOptions aSearchOpt( rSearchItem.GetSearchOptions() ); |
| aSearchOpt.Locale = SvxCreateLocale( |
| static_cast< LanguageType >( GetAppLanguage() ) ); |
| |
| sal_uInt16 nFound; |
| sal_Bool bAll = sal_False; |
| switch( rSearchItem.GetCommand() ) |
| { |
| case SVX_SEARCHCMD_FIND: |
| case SVX_SEARCHCMD_FIND_ALL: |
| nFound = pTextView->Search( aSearchOpt, bForward ); |
| break; |
| |
| case SVX_SEARCHCMD_REPLACE_ALL: bAll = sal_True; |
| case SVX_SEARCHCMD_REPLACE: |
| nFound = pTextView->Replace( aSearchOpt, bAll, bForward ); |
| break; |
| |
| default: |
| nFound = 0; |
| } |
| |
| if( !nFound ) |
| { |
| sal_Bool bNotFoundMessage = sal_False; |
| if(!bRecursive) |
| { |
| if(!bFromStart) |
| { |
| bNotFoundMessage = bAtStart; |
| } |
| else |
| { |
| bNotFoundMessage = sal_True; |
| pTextView->SetSelection( aSel ); |
| } |
| } |
| else if(bAtStart) |
| { |
| bNotFoundMessage = sal_True; |
| } |
| |
| |
| if(!bApi) |
| { |
| if(bNotFoundMessage) |
| { |
| InfoBox( 0, SW_RES(MSG_NOT_FOUND)).Execute(); |
| } |
| else if(!bRecursive && RET_YES == |
| QueryBox(0, SW_RES( bForward ? MSG_SEARCH_END |
| : MSG_SEARCH_START)).Execute()) |
| { |
| pTextView->SetSelection( TextSelection( aPaM, aPaM ) ); |
| StartSearchAndReplace( rSearchItem, sal_False, sal_False, sal_True ); |
| } |
| } |
| } |
| return nFound; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| sal_uInt16 SwSrcView::SetPrinter(SfxPrinter* pNew, sal_uInt16 nDiffFlags, bool ) |
| { |
| SwDocShell* pDocSh = GetDocShell(); |
| if ( (SFX_PRINTER_JOBSETUP | SFX_PRINTER_PRINTER) & nDiffFlags ) |
| { |
| pDocSh->GetDoc()->setPrinter( pNew, true, true ); |
| if ( nDiffFlags & SFX_PRINTER_PRINTER ) |
| pDocSh->SetModified(); |
| } |
| if ( nDiffFlags & SFX_PRINTER_OPTIONS ) |
| ::SetPrinter( pDocSh->getIDocumentDeviceAccess(), pNew, sal_True ); |
| |
| const sal_Bool bChgOri = nDiffFlags & SFX_PRINTER_CHG_ORIENTATION ? sal_True : sal_False; |
| const sal_Bool bChgSize= nDiffFlags & SFX_PRINTER_CHG_SIZE ? sal_True : sal_False; |
| if ( bChgOri || bChgSize ) |
| { |
| pDocSh->SetModified(); |
| } |
| return 0; |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| SfxPrinter* SwSrcView::GetPrinter( sal_Bool bCreate ) |
| { |
| return GetDocShell()->GetDoc()->getPrinter( bCreate ); |
| } |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| sal_Int32 SwSrcView::PrintSource( |
| OutputDevice *pOutDev, |
| sal_Int32 nPage, |
| bool bCalcNumPagesOnly ) |
| { |
| if (!pOutDev || nPage <= 0) |
| return 0; |
| |
| //! this a lgorithm for printing the n-th page is very poor since it |
| //! needs to go over the text of all previous pages to get to the correct one. |
| //! But since HTML source code is expected to be just a small number of pages |
| //! even this poor algorithm should be enough... |
| |
| pOutDev->Push(); |
| |
| TextEngine* pTextEngine = aEditWin.GetTextEngine(); |
| pOutDev->SetMapMode( MAP_100TH_MM ); |
| Font aFont( aEditWin.GetOutWin()->GetFont() ); |
| Size aSize( aFont.GetSize() ); |
| aSize = aEditWin.GetOutWin()->PixelToLogic( aSize, MAP_100TH_MM ); |
| aFont.SetSize( aSize ); |
| aFont.SetColor( COL_BLACK ); |
| pOutDev->SetFont( aFont ); |
| |
| String aTitle( GetViewFrame()->GetWindow().GetText() ); |
| |
| sal_uInt16 nLineHeight = (sal_uInt16) pOutDev->GetTextHeight(); // etwas mehr. |
| sal_uInt16 nParaSpace = 10; |
| |
| Size aPaperSz = pOutDev->GetOutputSize(); |
| aPaperSz.Width() -= (LMARGPRN + RMARGPRN); |
| aPaperSz.Height() -= (TMARGPRN + BMARGPRN); |
| |
| // nLinepPage stimmt nicht, wenn Zeilen umgebrochen werden muessen... |
| sal_uInt16 nLinespPage = (sal_uInt16) (aPaperSz.Height() / nLineHeight); |
| sal_uInt16 nCharspLine = (sal_uInt16) (aPaperSz.Width() / pOutDev->GetTextWidth( 'X' )); |
| sal_uInt16 nParas = static_cast< sal_uInt16 >( pTextEngine->GetParagraphCount() ); |
| |
| sal_uInt16 nPages = (sal_uInt16) (nParas / nLinespPage + 1 ); |
| sal_uInt16 nCurPage = 1; |
| |
| // Header drucken... |
| if (!bCalcNumPagesOnly && nPage == nCurPage) |
| lcl_PrintHeader( *pOutDev, nPages, nCurPage, aTitle ); |
| const Point aStartPos( LMARGPRN, TMARGPRN ); |
| Point aPos( aStartPos ); |
| for ( sal_uInt16 nPara = 0; nPara < nParas; ++nPara ) |
| { |
| String aLine( pTextEngine->GetText( nPara ) ); |
| lcl_ConvertTabsToSpaces( aLine ); |
| sal_uInt16 nLines = aLine.Len() / nCharspLine + 1; |
| for ( sal_uInt16 nLine = 0; nLine < nLines; ++nLine ) |
| { |
| String aTmpLine( aLine, nLine * nCharspLine, nCharspLine ); |
| aPos.Y() += nLineHeight; |
| if ( aPos.Y() > ( aPaperSz.Height() + TMARGPRN - nLineHeight/2 ) ) |
| { |
| ++nCurPage; |
| if (!bCalcNumPagesOnly && nPage == nCurPage) |
| lcl_PrintHeader( *pOutDev, nPages, nCurPage, aTitle ); |
| aPos = aStartPos; |
| } |
| if (!bCalcNumPagesOnly && nPage == nCurPage) |
| pOutDev->DrawText( aPos, aTmpLine ); |
| } |
| aPos.Y() += nParaSpace; |
| } |
| |
| pOutDev->Pop(); |
| |
| DBG_ASSERT( bCalcNumPagesOnly || nPage <= nCurPage, "page number out of range" ); |
| return nCurPage; |
| } |
| |
| |
| /*-------------------------------------------------------------------- |
| Beschreibung: |
| --------------------------------------------------------------------*/ |
| |
| |
| void SwSrcView::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) |
| { |
| if ( rHint.ISA(SfxSimpleHint) && |
| ( |
| ((SfxSimpleHint&) rHint).GetId() == SFX_HINT_MODECHANGED || |
| ( |
| ((SfxSimpleHint&) rHint).GetId() == SFX_HINT_TITLECHANGED && |
| !GetDocShell()->IsReadOnly() && aEditWin.IsReadonly() |
| ) |
| ) |
| ) |
| { |
| // Broadcast kommt nur einmal! |
| const SwDocShell* pDocSh = GetDocShell(); |
| const sal_Bool bReadonly = pDocSh->IsReadOnly(); |
| aEditWin.SetReadonly(bReadonly); |
| } |
| SfxViewShell::Notify(rBC, rHint); |
| } |
| |
| /*-----------------19.04.97 10:19------------------- |
| |
| --------------------------------------------------*/ |
| void SwSrcView::Load(SwDocShell* pDocShell) |
| { |
| SvxHtmlOptions* pHtmlOptions = SvxHtmlOptions::Get(); |
| const sal_Char *pCharSet = |
| rtl_getBestMimeCharsetFromTextEncoding( pHtmlOptions->GetTextEncoding() ); |
| rtl_TextEncoding eDestEnc = rtl_getTextEncodingFromMimeCharset( pCharSet ); |
| |
| aEditWin.SetReadonly(pDocShell->IsReadOnly()); |
| aEditWin.SetTextEncoding(eDestEnc); |
| SfxMedium* pMedium = pDocShell->GetMedium(); |
| |
| const SfxFilter* pFilter = pMedium->GetFilter(); |
| sal_Bool bHtml = pFilter && pFilter->GetUserData().EqualsAscii("HTML"); |
| sal_Bool bDocModified = pDocShell->IsModified(); |
| if(bHtml && !bDocModified && pDocShell->HasName()) |
| { |
| SvStream* pStream = pMedium->GetInStream(); |
| if(pStream && 0 == pStream->GetError() ) |
| { |
| rtl_TextEncoding eHeaderEnc = |
| SfxHTMLParser::GetEncodingByHttpHeader( |
| pDocShell->GetHeaderAttributes() ); |
| if( RTL_TEXTENCODING_DONTKNOW == eHeaderEnc ) |
| { |
| const sal_Char *pTmpCharSet = |
| rtl_getBestMimeCharsetFromTextEncoding( RTL_TEXTENCODING_ISO_8859_1 ); |
| eHeaderEnc = rtl_getTextEncodingFromMimeCharset( pTmpCharSet ); |
| } |
| if( RTL_TEXTENCODING_DONTKNOW != eHeaderEnc && |
| eDestEnc != eHeaderEnc ) |
| { |
| eDestEnc = eHeaderEnc; |
| aEditWin.SetTextEncoding(eDestEnc); |
| } |
| pStream->SetStreamCharSet( eDestEnc ); |
| pStream->Seek(0); |
| TextEngine* pTextEngine = aEditWin.GetTextEngine(); |
| pTextEngine->EnableUndo(sal_False); |
| aEditWin.Read(*pStream);//, EE_FORMAT_TEXT); |
| pTextEngine->EnableUndo(sal_True); |
| } |
| else |
| { |
| Window *pTmpWindow = &GetViewFrame()->GetWindow(); |
| InfoBox(pTmpWindow, SW_RES(MSG_ERR_SRCSTREAM)).Execute(); |
| } |
| } |
| else |
| { |
| utl::TempFile aTempFile; |
| aTempFile.EnableKillingFile(); |
| String sFileURL( aTempFile.GetURL() ); |
| SvtSaveOptions aOpt; |
| |
| { |
| SfxMedium aMedium( sFileURL,STREAM_READWRITE, sal_True ); |
| SwWriter aWriter( aMedium, *pDocShell->GetDoc() ); |
| WriterRef xWriter; |
| ::GetHTMLWriter(aEmptyStr, aMedium.GetBaseURL( true ), xWriter); |
| String sWriteName = pDocShell->HasName() ? |
| pMedium->GetName() : |
| (const String&) sFileURL; |
| sal_uLong nRes = aWriter.Write(xWriter, &sWriteName); |
| if(nRes) |
| { |
| ErrorHandler::HandleError(ErrCode(nRes)); |
| aEditWin.SetReadonly(sal_True); |
| } |
| aMedium.Commit(); |
| SvStream* pInStream = aMedium.GetInStream(); |
| pInStream->Seek(0); |
| pInStream->SetStreamCharSet( eDestEnc ); |
| |
| |
| aEditWin.Read(*pInStream);//, EE_FORMAT_TEXT); |
| } |
| } |
| aEditWin.ClearModifyFlag(); |
| |
| eLoadEncoding = eDestEnc; |
| |
| if(bDocModified) |
| pDocShell->SetModified();// das Flag wird zwischendurch zurueckgesetzt |
| // AutoLoad abschalten |
| pDocShell->SetAutoLoad(INetURLObject(), 0, sal_False); |
| DBG_ASSERT(PTR_CAST(SwWebDocShell, pDocShell), "Wieso keine WebDocShell?"); |
| sal_uInt16 nLine = ((SwWebDocShell*)pDocShell)->GetSourcePara(); |
| aEditWin.SetStartLine(nLine); |
| aEditWin.GetTextEngine()->ResetUndo(); |
| aEditWin.GetOutWin()->GrabFocus(); |
| } |
| |
| |