| /************************************************************** |
| * |
| * 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_filter.hxx" |
| #include <osl/endian.h> |
| #include <vcl/svapp.hxx> |
| #include <unotools/tempfile.hxx> |
| #include <math.h> |
| #include <editeng/eeitem.hxx> |
| #include <sot/storage.hxx> |
| #include <sot/storinfo.hxx> |
| #include <sot/stg.hxx> |
| #include <com/sun/star/embed/Aspects.hpp> |
| #include <com/sun/star/office/XAnnotation.hpp> |
| #include <com/sun/star/office/XAnnotationAccess.hpp> |
| #include <com/sun/star/text/XText.hpp> |
| #include <com/sun/star/geometry/RealPoint2D.hpp> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <com/sun/star/drawing/BitmapMode.hpp> |
| #include <unotools/streamwrap.hxx> |
| #include <filter/msfilter/svdfppt.hxx> |
| #include <svx/xpoly.hxx> |
| #include <svx/svdtrans.hxx> |
| #include <svx/svdmodel.hxx> |
| #include <svx/svdpage.hxx> |
| #include <svx/svdobj.hxx> |
| #include <svx/svdogrp.hxx> |
| #include <svx/svdorect.hxx> |
| #include <svx/svdopage.hxx> |
| #include <svx/svdograf.hxx> |
| #include <svx/svdopath.hxx> |
| #include <svx/svdocirc.hxx> |
| #include <svx/svdocapt.hxx> |
| #include <svx/svdotable.hxx> |
| #include <editeng/outlobj.hxx> |
| #include <svx/svdattr.hxx> |
| #include "svx/xattr.hxx" |
| #include "svx/svditext.hxx" |
| #include <svx/svdetc.hxx> |
| #include <editeng/bulitem.hxx> |
| #include <svx/polysc3d.hxx> |
| #include <svx/extrud3d.hxx> |
| #include <svx/svdoashp.hxx> |
| #include <editeng/tstpitem.hxx> |
| #include <editeng/unoprnms.hxx> |
| #include <editeng/editids.hrc> |
| |
| #if defined(JOEENV) && defined(JOEDEBUG) |
| #include "impinccv.h" // etwas Testkram |
| #endif |
| |
| #if defined(DBG_EXTRACTOLEOBJECTS) || defined(DBG_EXTRACTFONTMETRICS) |
| #include <tools/urlobj.hxx> |
| #include <unotools/localfilehelper.hxx> |
| #endif |
| |
| #define ITEMVALUE(ItemSet,Id,Cast) ((const Cast&)(ItemSet).Get(Id)).GetValue() |
| #include <editeng/adjitem.hxx> |
| #include <editeng/escpitem.hxx> |
| #include <editeng/colritem.hxx> |
| #include <editeng/fhgtitem.hxx> |
| #include <editeng/wghtitem.hxx> |
| #include <editeng/postitem.hxx> |
| #include <editeng/udlnitem.hxx> |
| #include <editeng/crsditem.hxx> |
| #include <editeng/shdditem.hxx> |
| #include <editeng/charreliefitem.hxx> |
| #include <editeng/fontitem.hxx> |
| #include <svx/svdoutl.hxx> |
| #include <editeng/editeng.hxx> |
| #include <editeng/lspcitem.hxx> |
| #include <editeng/ulspitem.hxx> |
| #include <editeng/lrspitem.hxx> |
| #include <vcl/metric.hxx> |
| #include <vcl/bmpacc.hxx> |
| #include <svx/svditer.hxx> |
| #include <svx/svdoedge.hxx> |
| #include <svx/sxekitm.hxx> |
| #include <editeng/flditem.hxx> |
| #include <svtools/sychconv.hxx> |
| #include <tools/zcodec.hxx> |
| #include <filter/msfilter/svxmsbas.hxx> |
| #include <sfx2/objsh.hxx> |
| #include <editeng/brshitem.hxx> |
| #include <editeng/langitem.hxx> |
| #include <svx/svdoole2.hxx> |
| #include <svx/unoapi.hxx> |
| #include <toolkit/unohlp.hxx> |
| #include <com/sun/star/container/XIndexContainer.hpp> |
| #include <com/sun/star/drawing/XShapes.hpp> |
| #include <com/sun/star/drawing/XControlShape.hpp> |
| #include <com/sun/star/form/XFormComponent.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/drawing/XDrawPagesSupplier.hpp> |
| #include <com/sun/star/drawing/XMasterPagesSupplier.hpp> |
| #include <com/sun/star/drawing/XDrawPageSupplier.hpp> |
| #include <com/sun/star/awt/Size.hpp> |
| #include <com/sun/star/awt/Point.hpp> |
| #include <com/sun/star/drawing/FillStyle.hpp> |
| #include <com/sun/star/drawing/TextVerticalAdjust.hpp> |
| #include <editeng/writingmodeitem.hxx> |
| #include <vcl/print.hxx> |
| #include <editeng/svxfont.hxx> |
| #include <editeng/frmdiritem.hxx> |
| #include <svx/sdtfchim.hxx> |
| #include <unotools/ucbstreamhelper.hxx> |
| #include <editeng/scripttypeitem.hxx> |
| #include "com/sun/star/awt/Gradient.hpp" |
| #include <com/sun/star/table/XMergeableCellRange.hpp> |
| #include <com/sun/star/table/BorderLine.hpp> |
| #include <vcl/virdev.hxx> |
| #include <algorithm> |
| #include <set> |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| // PPT ColorScheme Slots |
| #define PPT_COLSCHEME (0x08000000) |
| #define PPT_COLSCHEME_HINTERGRUND (0x08000000) |
| #define PPT_COLSCHEME_TEXT_UND_ZEILEN (0x08000001) |
| #define PPT_COLSCHEME_SCHATTEN (0x08000002) |
| #define PPT_COLSCHEME_TITELTEXT (0x08000003) |
| #define PPT_COLSCHEME_FUELLBEREICHE (0x08000004) |
| #define PPT_COLSCHEME_AKZENT (0x08000005) |
| #define PPT_COLSCHEME_A_UND_HYPERLINK (0x08000006) |
| #define PPT_COLSCHEME_A_H_GESICHERT (0x08000007) |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #define ANSI_CHARSET 0 |
| #define DEFAULT_CHARSET 1 |
| #define SYMBOL_CHARSET 2 |
| #define SHIFTJIS_CHARSET 128 |
| #define HANGEUL_CHARSET 129 |
| #define CHINESEBIG5_CHARSET 136 |
| #define OEM_CHARSET 255 |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| /* Font Families */ |
| #define FF_DONTCARE 0x00 |
| #define FF_ROMAN 0x10 |
| #define FF_SWISS 0x20 |
| #define FF_MODERN 0x30 |
| #define FF_SCRIPT 0x40 |
| #define FF_DECORATIVE 0x50 |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| #define DEFAULT_PITCH 0x00 |
| #define FIXED_PITCH 0x01 |
| #define VARIABLE_PITCH 0x02 |
| |
| using namespace ::com::sun::star ; |
| using namespace uno ; |
| using namespace beans ; |
| using namespace drawing ; |
| using namespace container ; |
| using namespace table ; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PowerPointImportParam::PowerPointImportParam( SvStream& rDocStrm, sal_uInt32 nFlags, MSFilterTracer* pT ) : |
| rDocStream ( rDocStrm ), |
| nImportFlags ( nFlags ), |
| pTracer ( pT ) |
| { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptCurrentUserAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd; |
| if ( aHd.nRecType == PPT_PST_CurrentUserAtom ) |
| { |
| sal_uInt32 nLen; |
| sal_uInt16 nUserNameLen, nPad; |
| rIn >> nLen |
| >> rAtom.nMagic |
| >> rAtom.nCurrentUserEdit |
| >> nUserNameLen |
| >> rAtom.nDocFileVersion |
| >> rAtom.nMajorVersion |
| >> rAtom.nMinorVersion |
| >> nPad; |
| SvxMSDffManager::MSDFFReadZString( rIn, rAtom.aCurrentUser, nUserNameLen, sal_True ); |
| } |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| void PptSlidePersistAtom::Clear() |
| { |
| nReserved = nPsrReference = nFlags = nNumberTexts = nSlideId = 0; |
| } |
| |
| SvStream& operator>>( SvStream& rIn, PptSlidePersistAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd |
| >> rAtom.nPsrReference |
| >> rAtom.nFlags |
| >> rAtom.nNumberTexts |
| >> rAtom.nSlideId; |
| // >> rAtom.nReserved; |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| SV_IMPL_PTRARR(_PptSlidePersistList,PptSlidePersistEntry*); |
| |
| sal_uInt16 PptSlidePersistList::FindPage(sal_uInt32 nId) const |
| { |
| for ( sal_uInt16 i=0; i < Count(); i++ ) |
| { |
| if (operator[](i)->GetSlideId()==nId) return i; |
| } |
| return PPTSLIDEPERSIST_ENTRY_NOTFOUND; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptInteractiveInfoAtom& rAtom ) |
| { |
| rIn >> rAtom.nSoundRef |
| >> rAtom.nExHyperlinkId |
| >> rAtom.nAction |
| >> rAtom.nOleVerb |
| >> rAtom.nJump |
| >> rAtom.nFlags |
| >> rAtom.nHyperlinkType |
| >> rAtom.nUnknown1 |
| >> rAtom.nUnknown2 |
| >> rAtom.nUnknown3; |
| return rIn; |
| } |
| |
| SvStream& operator>>( SvStream& rIn, PptExOleObjAtom& rAtom ) |
| { |
| rIn >> rAtom.nAspect |
| >> rAtom.nDummy1 |
| >> rAtom.nId |
| >> rAtom.nDummy2 |
| >> rAtom.nPersistPtr |
| >> rAtom.nDummy4; |
| return rIn; |
| } |
| |
| Size PptDocumentAtom::GetPageSize(const Size& rSiz) const |
| { |
| return rSiz; |
| /* |
| Size aRet; |
| switch ( eSlidesPageFormat ) |
| { |
| // Wenn man in Powerpoint als Seitenformat "Bildschirmgroesse" |
| // einstellt, dann zeigt dieser Dialog zwar 24x18cm an, die |
| // angezeigte Seite ist aber anders. Das sieht man, wenn man |
| // ein Rechteck seitenfuellend aufzieht und sich dessen Groesse |
| // ansieht. Die importierten Abmessungen sind auf jeden Fall |
| // die, die auch im Ppt-File stehen. Ich denke, das es sich |
| // hier eher um ein Bug in PowerPoint handelt, das im |
| // Seitenformat-Dialog bei "Bildschirmgroesse" falsche Masse |
| // angezeigt werden (vielleicht ja auch bildschirmabhaengig?). |
| // case PPTPF_SCREEN : aRet.Width()=4082; aRet.Height()=5443; break; |
| case PPTPF_USLETTER: aRet.Width()=4896; aRet.Height()=6336; break; |
| case PPTPF_A4 : aRet.Width()=4762; aRet.Height()=6735; break; |
| // case PPTPF_35MMDIA : aRet.Width()=4082; aRet.Height()=6123; break; |
| // case PPTPF_OVERHEAD: aRet.Width()=4082; aRet.Height()=5443; break; |
| } |
| if ( aRet.Width() ) |
| { |
| if ( rSiz.Width() > rSiz.Height() ) |
| { // Querformat |
| long nMerk = aRet.Width(); |
| aRet.Width() = aRet.Height(); |
| aRet.Height() = nMerk; |
| } |
| } |
| else // CustomFormat oder Unbekannt oder Screen,Dia,Overhead |
| aRet = rSiz; |
| return aRet; |
| */ |
| } |
| |
| SvStream& operator>>(SvStream& rIn, PptDocumentAtom& rAtom) |
| { |
| // Tatsaechliches Format: |
| // 00 aSlidePageSizeXY 8 |
| // 08 aNotesPageSizeXY 8 |
| // 16 aZoomRatio (OLE) 8 |
| // 24 nNotesMasterPersist 4 |
| // 28 nHandoutMasterPersist 4 |
| // 32 n1stPageNumber 2 |
| // 34 ePageFormat 2 |
| // 36 bEmbeddedTrueType 1 |
| // 37 bOmitTitlePlace 1 |
| // 38 bRightToLeft 1 |
| // 39 bShowComments 1 |
| |
| DffRecordHeader aHd; |
| sal_Int32 nSlideX,nSlideY, nNoticeX, nNoticeY, nDummy; |
| sal_uInt16 nSlidePageFormat; |
| sal_Int8 nEmbeddedTrueType, nTitlePlaceHoldersOmitted, nRightToLeft, nShowComments; |
| |
| rIn >> aHd |
| >> nSlideX >> nSlideY |
| >> nNoticeX >> nNoticeY |
| >> nDummy >> nDummy // ZoomRation ueberspringen |
| >> rAtom.nNotesMasterPersist |
| >> rAtom.nHandoutMasterPersist |
| >> rAtom.n1stPageNumber |
| >> nSlidePageFormat |
| >> nEmbeddedTrueType |
| >> nTitlePlaceHoldersOmitted |
| >> nRightToLeft |
| >> nShowComments; |
| rAtom.aSlidesPageSize.Width() = nSlideX; |
| rAtom.aSlidesPageSize.Height() = nSlideY; |
| rAtom.aNotesPageSize.Width() = nNoticeX; |
| rAtom.aNotesPageSize.Height() = nNoticeY; |
| rAtom.eSlidesPageFormat = (PptPageFormat)nSlidePageFormat; |
| rAtom.bEmbeddedTrueType = nEmbeddedTrueType; |
| rAtom.bTitlePlaceholdersOmitted = nTitlePlaceHoldersOmitted; |
| rAtom.bRightToLeft = nRightToLeft; |
| rAtom.bShowComments = nShowComments; |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void PptSlideLayoutAtom::Clear() |
| { |
| eLayout = 0; |
| for ( sal_uInt16 i = 0; i < 8; i++ ) |
| { |
| aPlaceholderId[ i ] = 0; |
| aPlacementId[ i ] = 0; |
| } |
| } |
| |
| SvStream& operator>>( SvStream& rIn, PptSlideLayoutAtom& rAtom ) |
| { |
| rIn >> rAtom.eLayout; |
| rIn.Read( rAtom.aPlaceholderId, 8 ); |
| return rIn; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptSlideAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd |
| >> rAtom.aLayout |
| >> rAtom.nMasterId |
| >> rAtom.nNotesId |
| >> rAtom.nFlags; |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| void PptSlideAtom::Clear() |
| { |
| nMasterId = nNotesId = 0; |
| nFlags = 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptNotesAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd |
| >> rAtom.nSlideId |
| >> rAtom.nFlags; |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| void PptNotesAtom::Clear() |
| { |
| nSlideId = 0; |
| nFlags = 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void PptColorSchemeAtom::Clear() |
| { |
| memset(&aData[0], 0, 32); |
| } |
| |
| Color PptColorSchemeAtom::GetColor( sal_uInt16 nNum ) const |
| { |
| Color aRetval; |
| if ( nNum < 8 ) |
| { |
| nNum <<= 2; |
| aRetval.SetRed( aData[ nNum++ ] ); |
| aRetval.SetGreen( aData[ nNum++ ] ); |
| aRetval.SetBlue( aData[ nNum++ ] ); |
| } |
| return aRetval; |
| } |
| |
| SvStream& operator>>( SvStream& rIn, PptColorSchemeAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd; |
| rIn.Read( rAtom.aData, 32 ); |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptFontEntityAtom& rAtom ) |
| { |
| DffRecordHeader aHd; |
| rIn >> aHd; |
| sal_Unicode nTemp, cData[ 32 ]; |
| rIn.Read( cData, 64 ); |
| |
| sal_uInt8 lfCharset, lfPitchAndFamily; |
| |
| rIn >> lfCharset |
| >> rAtom.lfClipPrecision |
| >> rAtom.lfQuality |
| >> lfPitchAndFamily; |
| |
| switch( lfCharset ) |
| { |
| case SYMBOL_CHARSET : |
| rAtom.eCharSet = RTL_TEXTENCODING_SYMBOL; |
| break; |
| case ANSI_CHARSET : |
| rAtom.eCharSet = RTL_TEXTENCODING_MS_1252; |
| break; |
| |
| // case DEFAULT_CHARSET : |
| // case SHIFTJIS_CHARSET : |
| // case HANGEUL_CHARSET : |
| // case CHINESEBIG5_CHARSET : |
| // case OEM_CHARSET : |
| default : |
| rAtom.eCharSet = gsl_getSystemTextEncoding(); |
| } |
| switch ( lfPitchAndFamily & 0xf0 ) |
| { |
| case FF_ROMAN: |
| rAtom.eFamily = FAMILY_ROMAN; |
| break; |
| |
| case FF_SWISS: |
| rAtom.eFamily = FAMILY_SWISS; |
| break; |
| |
| case FF_MODERN: |
| rAtom.eFamily = FAMILY_MODERN; |
| break; |
| |
| case FF_SCRIPT: |
| rAtom.eFamily = FAMILY_SCRIPT; |
| break; |
| |
| case FF_DECORATIVE: |
| rAtom.eFamily = FAMILY_DECORATIVE; |
| break; |
| |
| default: |
| rAtom.eFamily = FAMILY_DONTKNOW; |
| break; |
| } |
| |
| switch ( lfPitchAndFamily & 0x0f ) |
| { |
| case FIXED_PITCH: |
| rAtom.ePitch = PITCH_FIXED; |
| break; |
| |
| case DEFAULT_PITCH: |
| case VARIABLE_PITCH: |
| default: |
| rAtom.ePitch = PITCH_VARIABLE; |
| break; |
| } |
| sal_uInt16 i; |
| for ( i = 0; i < 32; i++ ) |
| { |
| nTemp = cData[ i ]; |
| if ( !nTemp ) |
| break; |
| #ifdef OSL_BIGENDIAN |
| cData[ i ] = ( nTemp >> 8 ) | ( nTemp << 8 ); |
| #endif |
| } |
| rAtom.aName = String( cData, i ); |
| OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice(); |
| rAtom.bAvailable = pDev->IsFontAvailable( rAtom.aName ); |
| aHd.SeekToEndOfRecord( rIn ); |
| return rIn; |
| } |
| |
| SV_DECL_PTRARR_DEL( PptFontEntityAtomList, PptFontEntityAtom*, 16, 16 ) |
| SV_IMPL_PTRARR( PptFontEntityAtomList, PptFontEntityAtom* ); |
| |
| class PptFontCollection: public PptFontEntityAtomList { |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SvStream& operator>>( SvStream& rIn, PptUserEditAtom& rAtom ) |
| { |
| rIn >> rAtom.aHd |
| >> rAtom.nLastSlideID |
| >> rAtom.nVersion |
| >> rAtom.nOffsetLastEdit |
| >> rAtom.nOffsetPersistDirectory |
| >> rAtom.nDocumentRef |
| >> rAtom.nMaxPersistWritten |
| >> rAtom.eLastViewType; |
| rAtom.aHd.SeekToEndOfRecord(rIn); |
| return rIn; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void PptOEPlaceholderAtom::Clear() |
| { |
| nPlacementId = 0; |
| nPlaceholderSize = nPlaceholderId = 0; |
| } |
| |
| SvStream& operator>>( SvStream& rIn, PptOEPlaceholderAtom& rAtom ) |
| { |
| rIn >> rAtom.nPlacementId |
| >> rAtom.nPlaceholderId |
| >> rAtom.nPlaceholderSize; |
| return rIn; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PptSlidePersistEntry::PptSlidePersistEntry() : |
| pStyleSheet ( NULL ), |
| pHeaderFooterEntry ( NULL ), |
| pSolverContainer ( NULL ), |
| nSlidePersistStartOffset( 0 ), |
| nSlidePersistEndOffset ( 0 ), |
| nBackgroundOffset ( 0 ), |
| nDrawingDgId ( 0xffffffff ), |
| pPresentationObjects ( NULL ), |
| pBObj ( NULL ), |
| bBObjIsTemporary ( sal_True ), |
| ePageKind ( PPT_MASTERPAGE ), |
| bNotesMaster ( sal_False ), |
| bHandoutMaster ( sal_False ), |
| bStarDrawFiller ( sal_False ) |
| { |
| HeaderFooterOfs[ 0 ] = HeaderFooterOfs[ 1 ] = HeaderFooterOfs[ 2 ] = HeaderFooterOfs[ 3 ] = 0; |
| } |
| |
| |
| PptSlidePersistEntry::~PptSlidePersistEntry() |
| { |
| delete pStyleSheet; |
| delete pHeaderFooterEntry; |
| delete pSolverContainer; |
| delete[] pPresentationObjects; |
| }; |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SdrEscherImport::SdrEscherImport( PowerPointImportParam& rParam, const String& rBaseURL ) : |
| SvxMSDffManager ( rParam.rDocStream, rBaseURL, rParam.pTracer ), |
| pFonts ( NULL ), |
| nStreamLen ( 0 ), |
| nTextStylesIndex ( 0xffff ), |
| eCharSetSystem ( gsl_getSystemTextEncoding() ), |
| bWingdingsChecked ( sal_False ), |
| bWingdingsAvailable ( sal_False ), |
| bMonotypeSortsChecked ( sal_False ), |
| bMonotypeSortsAvailable ( sal_False ), |
| bTimesNewRomanChecked ( sal_False ), |
| bTimesNewRomanAvailable ( sal_False ), |
| rImportParam ( rParam ) |
| { |
| } |
| |
| SdrEscherImport::~SdrEscherImport() |
| { |
| void* pPtr; |
| for ( pPtr = aOleObjectList.First(); pPtr; pPtr = aOleObjectList.Next() ) |
| delete (PPTOleEntry*)pPtr; |
| delete pFonts; |
| } |
| |
| const PptSlideLayoutAtom* SdrEscherImport::GetSlideLayoutAtom() const |
| { |
| return NULL; |
| } |
| |
| sal_Bool SdrEscherImport::ReadString( String& rStr ) const |
| { |
| sal_Bool bRet = sal_False; |
| DffRecordHeader aStrHd; |
| rStCtrl >> aStrHd; |
| if (aStrHd.nRecType == PPT_PST_TextBytesAtom |
| || aStrHd.nRecType == PPT_PST_TextCharsAtom |
| || aStrHd.nRecType == PPT_PST_CString) |
| { |
| sal_Bool bUniCode = |
| (aStrHd.nRecType == PPT_PST_TextCharsAtom |
| || aStrHd.nRecType == PPT_PST_CString); |
| bRet=sal_True; |
| sal_uLong nBytes = aStrHd.nRecLen; |
| MSDFFReadZString( rStCtrl, rStr, nBytes, bUniCode ); |
| aStrHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| else |
| aStrHd.SeekToBegOfRecord( rStCtrl ); |
| return bRet; |
| } |
| |
| FASTBOOL SdrEscherImport::GetColorFromPalette(sal_uInt16 /*nNum*/, Color& /*rColor*/) const |
| { |
| return sal_False; |
| } |
| |
| sal_Bool SdrEscherImport::SeekToShape( SvStream& /*rSt*/, void* /*pClientData*/, sal_uInt32 /*nId*/) const |
| { |
| return sal_False; |
| } |
| |
| PptFontEntityAtom* SdrEscherImport::GetFontEnityAtom( sal_uInt32 nNum ) const |
| { |
| PptFontEntityAtom* pRetValue = NULL; |
| if ( pFonts && ( nNum < pFonts->Count() ) ) |
| pRetValue = (*pFonts)[ (sal_uInt16)nNum ]; |
| return pRetValue; |
| } |
| |
| CharSet SdrEscherImport::GetCharSet( sal_uInt32 nNum ) const |
| { |
| CharSet eRetValue( eCharSetSystem ); |
| if ( pFonts && ( nNum < pFonts->Count() ) ) |
| eRetValue = (*pFonts)[ (sal_uInt16)nNum ]->eCharSet; |
| return eRetValue; |
| } |
| |
| sal_Bool SdrEscherImport::IsFontAvailable( sal_uInt32 nNum ) const |
| { |
| sal_Bool bRetValue = sal_False; |
| if ( pFonts && ( nNum < pFonts->Count() ) ) |
| bRetValue = (*pFonts)[ (sal_uInt16)nNum ]->bAvailable; |
| return bRetValue; |
| } |
| |
| SdrObject* SdrEscherImport::ReadObjText( PPTTextObj* /*pTextObj*/, SdrObject* pObj, SdPage* /*pPage*/) const |
| { |
| return pObj; |
| } |
| |
| void SdrEscherImport::ProcessClientAnchor2( SvStream& rSt, DffRecordHeader& rHd, void* /*pData*/, DffObjData& rObj ) |
| { |
| sal_Int32 l, t, r, b; |
| if ( rHd.nRecLen == 16 ) |
| { |
| rSt >> l >> t >> r >> b; |
| } |
| else |
| { |
| sal_Int16 ls, ts, rs, bs; |
| rSt >> ts >> ls >> rs >> bs; // etwas seltsame Koordinatenreihenfolge ... |
| l = ls, t = ts, r = rs, b = bs; |
| } |
| Scale( l ); |
| Scale( t ); |
| Scale( r ); |
| Scale( b ); |
| rObj.aChildAnchor = Rectangle( l, t, r, b ); |
| rObj.bChildAnchor = sal_True; |
| return; |
| }; |
| |
| void SdrEscherImport::RecolorGraphic( SvStream& rSt, sal_uInt32 nRecLen, Graphic& rGraphic ) |
| { |
| if ( rGraphic.GetType() == GRAPHIC_GDIMETAFILE ) |
| { |
| sal_uInt16 nX, nGlobalColorsCount, nFillColorsCount; |
| |
| rSt >> nX |
| >> nGlobalColorsCount |
| >> nFillColorsCount |
| >> nX |
| >> nX |
| >> nX; |
| |
| if ( ( nGlobalColorsCount <= 64 ) && ( nFillColorsCount <= 64 ) ) |
| { |
| if ( (sal_uInt32)( ( nGlobalColorsCount + nFillColorsCount ) * 44 + 12 ) == nRecLen ) |
| { |
| sal_uInt32 OriginalGlobalColors[ 64 ]; |
| sal_uInt32 NewGlobalColors[ 64 ]; |
| sal_uInt32 OriginalFillColors[ 64 ]; |
| sal_uInt32 NewFillColors[ 64 ]; |
| |
| sal_uInt32 i, j, nGlobalColorsChanged, nFillColorsChanged; |
| nGlobalColorsChanged = nFillColorsChanged = 0; |
| |
| sal_uInt32* pCurrentOriginal = OriginalGlobalColors; |
| sal_uInt32* pCurrentNew = NewGlobalColors; |
| sal_uInt32* pCount = &nGlobalColorsChanged; |
| i = nGlobalColorsCount; |
| |
| for ( j = 0; j < 2; j++ ) |
| { |
| for ( ; i > 0; i-- ) |
| { |
| sal_uInt32 nIndex, nPos = rSt.Tell(); |
| sal_uInt8 nDummy, nRed, nGreen, nBlue; |
| sal_uInt16 nChanged; |
| rSt >> nChanged; |
| if ( nChanged & 1 ) |
| { |
| sal_uInt32 nColor = 0; |
| rSt >> nDummy |
| >> nRed |
| >> nDummy |
| >> nGreen |
| >> nDummy |
| >> nBlue |
| >> nIndex; |
| |
| if ( nIndex < 8 ) |
| { |
| Color aColor = MSO_CLR_ToColor( nIndex << 24 ); |
| nRed = aColor.GetRed(); |
| nGreen = aColor.GetGreen(); |
| nBlue = aColor.GetBlue(); |
| } |
| nColor = nRed | ( nGreen << 8 ) | ( nBlue << 16 ); |
| *pCurrentNew++ = nColor; |
| rSt >> nDummy |
| >> nRed |
| >> nDummy |
| >> nGreen |
| >> nDummy |
| >> nBlue; |
| nColor = nRed | ( nGreen << 8 ) | ( nBlue << 16 ); |
| *pCurrentOriginal++ = nColor; |
| (*pCount)++; |
| } |
| rSt.Seek( nPos + 44 ); |
| } |
| pCurrentOriginal = OriginalFillColors; |
| pCurrentNew = NewFillColors; |
| pCount = &nFillColorsChanged; |
| i = nFillColorsCount; |
| } |
| if ( nGlobalColorsChanged || nFillColorsChanged ) |
| { |
| Color* pSearchColors = new Color[ nGlobalColorsChanged ]; |
| Color* pReplaceColors = new Color[ nGlobalColorsChanged ]; |
| |
| for ( j = 0; j < nGlobalColorsChanged; j++ ) |
| { |
| sal_uInt32 nSearch = OriginalGlobalColors[ j ]; |
| sal_uInt32 nReplace = NewGlobalColors[ j ]; |
| |
| pSearchColors[ j ].SetRed( (sal_uInt8)nSearch ); |
| pSearchColors[ j ].SetGreen( (sal_uInt8)( nSearch >> 8 ) ); |
| pSearchColors[ j ].SetBlue( (sal_uInt8)( nSearch >> 16 ) ); |
| |
| pReplaceColors[ j ].SetRed( (sal_uInt8)nReplace ); |
| pReplaceColors[ j ].SetGreen( (sal_uInt8)( nReplace >> 8 ) ); |
| pReplaceColors[ j ].SetBlue( (sal_uInt8)( nReplace >> 16 ) ); |
| } |
| GDIMetaFile aGdiMetaFile( rGraphic.GetGDIMetaFile() ); |
| aGdiMetaFile.ReplaceColors( pSearchColors, pReplaceColors, |
| nGlobalColorsChanged, NULL ); |
| rGraphic = aGdiMetaFile; |
| |
| delete[] pSearchColors; |
| delete[] pReplaceColors; |
| } |
| } |
| } |
| } |
| } |
| |
| /* ProcessObject is called from ImplSdPPTImport::ProcessObj to hanlde all application specific things, |
| such as the import of text, animation effects, header footer and placeholder. |
| |
| The parameter pOriginalObj is the object as it was imported by our general escher import, it must either |
| be deleted or it can be returned to be inserted into the sdr page. |
| */ |
| SdrObject* SdrEscherImport::ProcessObj( SvStream& rSt, DffObjData& rObjData, void* pData, Rectangle& rTextRect, SdrObject* pOriginalObj ) |
| { |
| if ( pOriginalObj && pOriginalObj->ISA( SdrObjCustomShape ) ) |
| pOriginalObj->SetMergedItem( SdrTextFixedCellHeightItem( sal_True ) ); |
| |
| // we are initializing our return value with the object that was imported by our escher import |
| SdrObject* pRet = pOriginalObj; |
| |
| ProcessData& rData = *((ProcessData*)pData); |
| PptSlidePersistEntry& rPersistEntry = rData.rPersistEntry; |
| |
| if ( ! ( rObjData.nSpFlags & SP_FGROUP ) ) // sj: #114758# ... |
| { |
| PptOEPlaceholderAtom aPlaceholderAtom; |
| sal_Int16 nHeaderFooterInstance = -1; |
| |
| if ( maShapeRecords.SeekToContent( rSt, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| DffRecordHeader aClientDataHd; |
| while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < maShapeRecords.Current()->GetRecEndFilePos() ) ) |
| { |
| rSt >> aClientDataHd; |
| switch ( aClientDataHd.nRecType ) |
| { |
| // importing header/footer object from master page |
| case PPT_PST_OEPlaceholderAtom : |
| { |
| rSt >> aPlaceholderAtom; |
| if ( nHeaderFooterInstance == -1 ) |
| { |
| switch ( aPlaceholderAtom.nPlaceholderId ) |
| { |
| case PPT_PLACEHOLDER_MASTERSLIDENUMBER : nHeaderFooterInstance++; |
| case PPT_PLACEHOLDER_MASTERFOOTER : nHeaderFooterInstance++; |
| case PPT_PLACEHOLDER_MASTERHEADER : nHeaderFooterInstance++; |
| case PPT_PLACEHOLDER_MASTERDATE : nHeaderFooterInstance++; break; |
| } |
| if ( ! ( nHeaderFooterInstance & 0xfffc ) ) // is this a valid instance ( 0->3 ) |
| rPersistEntry.HeaderFooterOfs[ nHeaderFooterInstance ] = rObjData.rSpHd.GetRecBegFilePos(); |
| } |
| } |
| break; |
| |
| case PPT_PST_RecolorInfoAtom : |
| { |
| if ( pRet && ( pRet->ISA( SdrGrafObj ) && ((SdrGrafObj*)pRet)->HasGDIMetaFile() ) ) |
| { |
| Graphic aGraphic( ((SdrGrafObj*)pRet)->GetGraphic() ); |
| RecolorGraphic( rSt, aClientDataHd.nRecLen, aGraphic ); |
| ((SdrGrafObj*)pRet)->SetGraphic( aGraphic ); |
| } |
| } |
| break; |
| } |
| aClientDataHd.SeekToEndOfRecord( rSt ); |
| } |
| } |
| if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESSLIDEIMAGE ) && ( rPersistEntry.bNotesMaster == sal_False ) ) |
| { |
| sal_uInt16 nPageNum = pSdrModel->GetPageCount(); |
| if ( nPageNum > 0 ) |
| nPageNum--; |
| |
| // replacing the object which we will return with a SdrPageObj |
| SdrObject::Free( pRet ); |
| pRet = new SdrPageObj( rObjData.aBoundRect, pSdrModel->GetPage( nPageNum - 1 ) ); |
| } |
| else |
| { |
| // try to load some ppt text |
| PPTTextObj aTextObj( rSt, (SdrPowerPointImport&)*this, rPersistEntry, &rObjData ); |
| if ( ( aTextObj.Count() || aTextObj.GetOEPlaceHolderAtom() ) ) |
| { |
| sal_Bool bVerticalText = sal_False; |
| // and if the text object is not empty, it must be applied to pRet, the object we |
| // initially got from our escher import |
| sal_Int32 nTextRotationAngle = 0; |
| if ( IsProperty( DFF_Prop_txflTextFlow ) ) |
| { |
| MSO_TextFlow eTextFlow = (MSO_TextFlow)( GetPropertyValue( DFF_Prop_txflTextFlow ) & 0xFFFF ); |
| switch( eTextFlow ) |
| { |
| case mso_txflBtoT : // Bottom to Top non-@, unten -> oben |
| nTextRotationAngle += 9000; |
| break; |
| case mso_txflTtoBA : /* #68110# */ // Top to Bottom @-font, oben -> unten |
| case mso_txflTtoBN : // Top to Bottom non-@, oben -> unten |
| case mso_txflVertN : // Vertical, non-@, oben -> unten |
| bVerticalText = !bVerticalText; // nTextRotationAngle += 27000; |
| break; |
| // case mso_txflHorzN : // Horizontal non-@, normal |
| // case mso_txflHorzA : // Horizontal @-font, normal |
| default: break; |
| } |
| } |
| sal_Int32 nFontDirection = GetPropertyValue( DFF_Prop_cdirFont, mso_cdir0 ); |
| nTextRotationAngle -= nFontDirection * 9000; |
| if ( ( nFontDirection == 1 ) || ( nFontDirection == 3 ) ) // #104546# |
| { |
| bVerticalText = !bVerticalText; |
| /* |
| sal_Int32 nHalfWidth = ( rTextRect.GetWidth() + 1 ) >> 1; |
| sal_Int32 nHalfHeight = ( rTextRect.GetHeight() + 1 ) >> 1; |
| Point aTopLeft( rTextRect.Left() + nHalfWidth - nHalfHeight, |
| rTextRect.Top() + nHalfHeight - nHalfWidth ); |
| Size aNewSize( rTextRect.GetHeight(), rTextRect.GetWidth() ); |
| Rectangle aNewRect( aTopLeft, aNewSize ); |
| rTextRect = aNewRect; |
| */ |
| } |
| aTextObj.SetVertical( bVerticalText ); |
| if ( pRet ) |
| { |
| sal_Bool bDeleteSource = aTextObj.GetOEPlaceHolderAtom() != 0; |
| if ( bDeleteSource && ( pRet->ISA( SdrGrafObj ) == sal_False ) // we are not allowed to get |
| && ( pRet->ISA( SdrObjGroup ) == sal_False ) // grouped placeholder objects |
| && ( pRet->ISA( SdrOle2Obj ) == sal_False ) ) |
| SdrObject::Free( pRet ); |
| } |
| sal_uInt32 nTextFlags = aTextObj.GetTextFlags(); |
| sal_Int32 nTextLeft = GetPropertyValue( DFF_Prop_dxTextLeft, 25 * 3600 ); // 0.25 cm (emu) |
| sal_Int32 nTextRight = GetPropertyValue( DFF_Prop_dxTextRight, 25 * 3600 ); // 0.25 cm (emu) |
| sal_Int32 nTextTop = GetPropertyValue( DFF_Prop_dyTextTop, 13 * 3600 ); // 0.13 cm (emu) |
| sal_Int32 nTextBottom = GetPropertyValue( DFF_Prop_dyTextBottom, 13 * 3600 ); |
| ScaleEmu( nTextLeft ); |
| ScaleEmu( nTextRight ); |
| ScaleEmu( nTextTop ); |
| ScaleEmu( nTextBottom ); |
| |
| sal_Int32 nMinFrameWidth = 0; |
| sal_Int32 nMinFrameHeight = 0; |
| sal_Bool bAutoGrowWidth, bAutoGrowHeight; |
| |
| SdrTextVertAdjust eTVA; |
| SdrTextHorzAdjust eTHA; |
| |
| nTextFlags &= PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT |
| | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK; |
| |
| if ( bVerticalText ) |
| { |
| eTVA = SDRTEXTVERTADJUST_BLOCK; |
| eTHA = SDRTEXTHORZADJUST_CENTER; |
| |
| // Textverankerung lesen |
| MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop ); |
| |
| switch( eTextAnchor ) |
| { |
| case mso_anchorTop: |
| case mso_anchorTopCentered: |
| case mso_anchorTopBaseline: |
| case mso_anchorTopCenteredBaseline: |
| eTHA = SDRTEXTHORZADJUST_RIGHT; |
| break; |
| |
| case mso_anchorMiddle : |
| case mso_anchorMiddleCentered: |
| eTHA = SDRTEXTHORZADJUST_CENTER; |
| break; |
| |
| case mso_anchorBottom: |
| case mso_anchorBottomCentered: |
| case mso_anchorBottomBaseline: |
| case mso_anchorBottomCenteredBaseline: |
| eTHA = SDRTEXTHORZADJUST_LEFT; |
| break; |
| } |
| // if there is a 100% use of following attributes, the textbox can been aligned also in vertical direction |
| switch ( eTextAnchor ) |
| { |
| case mso_anchorTopCentered : |
| case mso_anchorMiddleCentered : |
| case mso_anchorBottomCentered : |
| case mso_anchorTopCenteredBaseline: |
| case mso_anchorBottomCenteredBaseline: |
| { |
| // check if it is sensible to use the centered alignment |
| sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; |
| if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left and also right aligned pararagraphs |
| eTVA = SDRTEXTVERTADJUST_CENTER; // the text has to be displayed using the full width; |
| } |
| break; |
| |
| default : |
| { |
| if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT ) |
| eTVA = SDRTEXTVERTADJUST_TOP; |
| else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT ) |
| eTVA = SDRTEXTVERTADJUST_BOTTOM; |
| } |
| break; |
| } |
| nMinFrameWidth = rTextRect.GetWidth() - ( nTextLeft + nTextRight ); |
| } |
| else |
| { |
| eTVA = SDRTEXTVERTADJUST_CENTER; |
| eTHA = SDRTEXTHORZADJUST_BLOCK; |
| |
| // Textverankerung lesen |
| MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop ); |
| |
| switch( eTextAnchor ) |
| { |
| case mso_anchorTop: |
| case mso_anchorTopCentered: |
| case mso_anchorTopBaseline: |
| case mso_anchorTopCenteredBaseline: |
| eTVA = SDRTEXTVERTADJUST_TOP; |
| break; |
| |
| case mso_anchorMiddle : |
| case mso_anchorMiddleCentered: |
| eTVA = SDRTEXTVERTADJUST_CENTER; |
| break; |
| |
| case mso_anchorBottom: |
| case mso_anchorBottomCentered: |
| case mso_anchorBottomBaseline: |
| case mso_anchorBottomCenteredBaseline: |
| eTVA = SDRTEXTVERTADJUST_BOTTOM; |
| break; |
| } |
| // if there is a 100% usage of following attributes, the textbox can be aligned also in horizontal direction |
| switch ( eTextAnchor ) |
| { |
| case mso_anchorTopCentered : |
| case mso_anchorMiddleCentered : |
| case mso_anchorBottomCentered : |
| case mso_anchorTopCenteredBaseline: |
| case mso_anchorBottomCenteredBaseline: |
| { |
| // check if it is sensible to use the centered alignment |
| sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; |
| if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left and also right aligned pararagraphs |
| eTHA = SDRTEXTHORZADJUST_CENTER; // the text has to be displayed using the full width; |
| } |
| break; |
| |
| default : |
| { |
| if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT ) |
| eTHA = SDRTEXTHORZADJUST_LEFT; |
| else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT ) |
| eTHA = SDRTEXTHORZADJUST_RIGHT; |
| } |
| break; |
| } |
| nMinFrameHeight = rTextRect.GetHeight() - ( nTextTop + nTextBottom ); |
| } |
| |
| SdrObjKind eTextKind = OBJ_RECT; |
| if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESSLIDEIMAGE ) |
| || ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_MASTERNOTESSLIDEIMAGE ) ) |
| { |
| aTextObj.SetInstance( 2 ); |
| eTextKind = OBJ_TITLETEXT; |
| } |
| else if ( ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_MASTERNOTESBODYIMAGE ) |
| || ( aPlaceholderAtom.nPlaceholderId == PPT_PLACEHOLDER_NOTESBODY ) ) |
| { |
| aTextObj.SetInstance( 2 ); |
| eTextKind = OBJ_TEXT; |
| } |
| |
| sal_uInt32 nDestinationInstance = aTextObj.GetInstance(); |
| if ( rPersistEntry.ePageKind == PPT_MASTERPAGE ) |
| { |
| if ( !rPersistEntry.pPresentationObjects ) |
| { |
| rPersistEntry.pPresentationObjects = new sal_uInt32[ PPT_STYLESHEETENTRYS ]; |
| memset( rPersistEntry.pPresentationObjects, 0, PPT_STYLESHEETENTRYS * 4 ); |
| } |
| if ( !rPersistEntry.pPresentationObjects[ nDestinationInstance ] ) |
| rPersistEntry.pPresentationObjects[ nDestinationInstance ] = rObjData.rSpHd.GetRecBegFilePos(); |
| } |
| switch ( nDestinationInstance ) |
| { |
| case TSS_TYPE_PAGETITLE : |
| case TSS_TYPE_TITLE : |
| { |
| if ( GetSlideLayoutAtom()->eLayout == PPT_LAYOUT_TITLEMASTERSLIDE ) |
| nDestinationInstance = TSS_TYPE_TITLE; |
| else |
| nDestinationInstance = TSS_TYPE_PAGETITLE; |
| } |
| break; |
| case TSS_TYPE_BODY : |
| // case TSS_TYPE_SUBTITLE : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : |
| nDestinationInstance = TSS_TYPE_BODY; |
| break; |
| } |
| aTextObj.SetDestinationInstance( (sal_uInt16)nDestinationInstance ); |
| |
| switch ( aTextObj.GetInstance() ) |
| { |
| case TSS_TYPE_PAGETITLE : |
| case TSS_TYPE_TITLE : eTextKind = OBJ_TITLETEXT; break; |
| case TSS_TYPE_SUBTITLE : eTextKind = OBJ_TEXT; break; |
| case TSS_TYPE_BODY : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : eTextKind = OBJ_OUTLINETEXT; break; |
| } |
| if ( aTextObj.GetDestinationInstance() != TSS_TYPE_TEXT_IN_SHAPE ) |
| { |
| if ( !aTextObj.GetOEPlaceHolderAtom() || !aTextObj.GetOEPlaceHolderAtom()->nPlaceholderId ) |
| { |
| aTextObj.SetDestinationInstance( TSS_TYPE_TEXT_IN_SHAPE ); |
| eTextKind = OBJ_RECT; |
| } |
| } |
| SdrObject* pTObj = NULL; |
| sal_Bool bWordWrap = (MSO_WrapMode)GetPropertyValue( DFF_Prop_WrapText, mso_wrapSquare ) != mso_wrapNone; |
| sal_Bool bFitShapeToText = ( GetPropertyValue( DFF_Prop_FitTextToShape ) & 2 ) != 0; |
| |
| if ( pRet && pRet->ISA( SdrObjCustomShape ) && ( eTextKind == OBJ_RECT ) ) |
| { |
| bAutoGrowHeight = bFitShapeToText; |
| if ( bWordWrap ) |
| bAutoGrowWidth = sal_False; |
| else |
| bAutoGrowWidth = sal_True; |
| pTObj = pRet; |
| pRet = NULL; |
| } |
| else |
| { |
| if ( pRet && pRet->ISA( SdrObjCustomShape ) ) |
| { |
| SdrObject::Free( pRet ); |
| pRet = NULL; |
| } |
| pTObj = new SdrRectObj( eTextKind != OBJ_RECT ? eTextKind : OBJ_TEXT ); |
| pTObj->SetModel( pSdrModel ); |
| SfxItemSet aSet( pSdrModel->GetItemPool() ); |
| if ( !pRet ) |
| ((SdrEscherImport*)this)->ApplyAttributes( rSt, aSet, rObjData ); |
| pTObj->SetMergedItemSet( aSet ); |
| if ( pRet ) |
| { |
| pTObj->SetMergedItem( XLineStyleItem( XLINE_NONE ) ); |
| pTObj->SetMergedItem( XFillStyleItem( XFILL_NONE ) ); |
| } |
| if ( bVerticalText ) |
| { |
| bAutoGrowWidth = bFitShapeToText; |
| bAutoGrowHeight = sal_False; |
| } |
| else |
| { |
| bAutoGrowWidth = sal_False; |
| |
| // #119885# re-activationg bFitShapeToText here, could not find deeper explanations |
| // for it (it was from 2005). Keeping the old commeht here for reference |
| // old comment: // bFitShapeToText; can't be used, because we cut the text if it is too height, |
| bAutoGrowHeight = bFitShapeToText; |
| } |
| } |
| pTObj->SetMergedItem( SvxFrameDirectionItem( bVerticalText ? FRMDIR_VERT_TOP_RIGHT : FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR ) ); |
| |
| if ( !pTObj->ISA( SdrObjCustomShape ) ) |
| { |
| pTObj->SetMergedItem( SdrTextAutoGrowWidthItem( bAutoGrowWidth ) ); |
| pTObj->SetMergedItem( SdrTextAutoGrowHeightItem( bAutoGrowHeight ) ); |
| } |
| else |
| { |
| pTObj->SetMergedItem( SdrTextWordWrapItem( bWordWrap ) ); |
| pTObj->SetMergedItem( SdrTextAutoGrowHeightItem( bFitShapeToText ) ); |
| } |
| |
| pTObj->SetMergedItem( SdrTextVertAdjustItem( eTVA ) ); |
| pTObj->SetMergedItem( SdrTextHorzAdjustItem( eTHA ) ); |
| |
| if ( nMinFrameHeight < 0 ) |
| nMinFrameHeight = 0; |
| if ( !pTObj->ISA( SdrObjCustomShape ) ) |
| pTObj->SetMergedItem( SdrTextMinFrameHeightItem( nMinFrameHeight ) ); |
| |
| if ( nMinFrameWidth < 0 ) |
| nMinFrameWidth = 0; |
| if ( !pTObj->ISA( SdrObjCustomShape ) ) |
| pTObj->SetMergedItem( SdrTextMinFrameWidthItem( nMinFrameWidth ) ); |
| |
| // Abstaende an den Raendern der Textbox setzen |
| pTObj->SetMergedItem( SdrTextLeftDistItem( nTextLeft ) ); |
| pTObj->SetMergedItem( SdrTextRightDistItem( nTextRight ) ); |
| pTObj->SetMergedItem( SdrTextUpperDistItem( nTextTop ) ); |
| pTObj->SetMergedItem( SdrTextLowerDistItem( nTextBottom ) ); |
| pTObj->SetMergedItem( SdrTextFixedCellHeightItem( sal_True ) ); |
| |
| if ( !pTObj->ISA( SdrObjCustomShape ) ) |
| pTObj->SetSnapRect( rTextRect ); |
| pTObj = ReadObjText( &aTextObj, pTObj, rData.pPage ); |
| if ( pTObj ) |
| { |
| /* check if our new snaprect makes trouble, |
| because we do not display the ADJUST_BLOCK |
| properly if the textsize is bigger than the |
| snaprect of the object. Then we will use |
| ADJUST_CENTER instead of ADJUST_BLOCK. |
| */ |
| if ( !pTObj->ISA( SdrObjCustomShape ) && !bFitShapeToText && !bWordWrap ) |
| { |
| SdrTextObj* pText = PTR_CAST( SdrTextObj, pTObj ); |
| if ( pText ) |
| { |
| if ( bVerticalText ) |
| { |
| if ( eTVA == SDRTEXTVERTADJUST_BLOCK ) |
| { |
| Size aTextSize( pText->GetTextSize() ); |
| aTextSize.Width() += nTextLeft + nTextRight; |
| aTextSize.Height() += nTextTop + nTextBottom; |
| if ( rTextRect.GetHeight() < aTextSize.Height() ) |
| pTObj->SetMergedItem( SdrTextVertAdjustItem( SDRTEXTVERTADJUST_CENTER ) ); |
| } |
| } |
| else |
| { |
| if ( eTHA == SDRTEXTHORZADJUST_BLOCK ) |
| { |
| Size aTextSize( pText->GetTextSize() ); |
| aTextSize.Width() += nTextLeft + nTextRight; |
| aTextSize.Height() += nTextTop + nTextBottom; |
| if ( rTextRect.GetWidth() < aTextSize.Width() ) |
| pTObj->SetMergedItem( SdrTextHorzAdjustItem( SDRTEXTHORZADJUST_CENTER ) ); |
| } |
| } |
| } |
| } |
| // rotate text with shape ? |
| sal_Int32 nAngle = ( rObjData.nSpFlags & SP_FFLIPV ) ? -mnFix16Angle : mnFix16Angle; // #72116# vertical flip -> rotate by using the other way |
| nAngle += nTextRotationAngle; |
| |
| if ( pTObj->ISA( SdrObjCustomShape ) ) |
| { |
| /* |
| if ( nTextRotationAngle ) |
| { |
| double fTextRotateAngle = (double)nTextRotationAngle / 100.0; |
| SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)((SdrObjCustomShape*)pTObj)->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ); |
| const rtl::OUString sTextRotateAngle( RTL_CONSTASCII_USTRINGPARAM ( "TextRotateAngle" ) ); |
| PropertyValue aPropValue; |
| aPropValue.Name = sTextRotateAngle; |
| aPropValue.Value <<= fTextRotateAngle; |
| aGeometryItem.SetPropertyValue( aPropValue ); |
| ((SdrObjCustomShape*)pTObj)->SetMergedItem( aGeometryItem ); |
| } |
| */ |
| } |
| else |
| { |
| if ( rObjData.nSpFlags & SP_FFLIPV ) |
| { |
| double a = 18000 * nPi180; |
| pTObj->Rotate( rTextRect.Center(), 18000, sin( a ), cos( a ) ); |
| } |
| if ( rObjData.nSpFlags & SP_FFLIPH ) |
| nAngle = 36000 - nAngle; |
| if ( nAngle ) |
| { |
| double a = nAngle * nPi180; |
| pTObj->NbcRotate( rObjData.aBoundRect.Center(), nAngle, sin( a ), cos( a ) ); |
| } |
| } |
| if ( pRet ) |
| { |
| SdrObject* pGroup = new SdrObjGroup; |
| pGroup->GetSubList()->NbcInsertObject( pRet ); |
| pGroup->GetSubList()->NbcInsertObject( pTObj ); |
| pRet = pGroup; |
| } |
| else |
| pRet = pTObj; |
| } |
| } |
| } |
| } |
| else |
| { |
| if ( maShapeRecords.SeekToContent( rSt, DFF_msofbtUDefProp, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| maShapeRecords.Current()->SeekToBegOfRecord( rSt ); |
| DffPropertyReader aSecPropSet( *this ); |
| aSecPropSet.ReadPropSet( rSt, (ProcessData*)pData ); |
| sal_Int32 nTableProperties = aSecPropSet.GetPropertyValue( DFF_Prop_tableProperties, 0 ); |
| if ( nTableProperties & 3 ) |
| { |
| if ( aSecPropSet.SeekToContent( DFF_Prop_tableRowProperties, rSt ) ) |
| { |
| sal_Int16 i, nRowCount = 0; |
| rSt >> nRowCount >> i >> i; |
| if ( nRowCount ) |
| { |
| sal_uInt32* pTableArry = new sal_uInt32[ nRowCount + 2 ]; |
| pTableArry[ 0 ] = nTableProperties; |
| pTableArry[ 1 ] = nRowCount; |
| for ( i = 0; i < nRowCount; i++ ) |
| rSt >> pTableArry[ i + 2 ]; |
| rData.pTableRowProperties = pTableArry; |
| } |
| } |
| } |
| } |
| } |
| if ( pRet ) // sj: #i38501#, and and taking care of connections to group objects |
| { |
| if ( rObjData.nSpFlags & SP_FBACKGROUND ) |
| { |
| pRet->NbcSetSnapRect( Rectangle( Point(), ((SdrPage*)rData.pPage)->GetSize() ) ); // Groesse setzen |
| } |
| if ( rPersistEntry.pSolverContainer ) |
| { |
| for ( SvxMSDffConnectorRule* pPtr = (SvxMSDffConnectorRule*)rPersistEntry.pSolverContainer->aCList.First(); |
| pPtr; pPtr = (SvxMSDffConnectorRule*)rPersistEntry.pSolverContainer->aCList.Next() ) |
| { |
| if ( rObjData.nShapeId == pPtr->nShapeC ) |
| pPtr->pCObj = pRet; |
| else |
| { |
| SdrObject* pConnectObj = pRet; |
| if ( pOriginalObj && pRet->ISA( SdrObjGroup ) ) |
| { /* check if the original object from the escherimport is part of the group object, |
| if this is the case, we will use the original object to connect to */ |
| SdrObjListIter aIter( *pRet, IM_DEEPWITHGROUPS ); |
| while( aIter.IsMore() ) |
| { |
| SdrObject* pPartObj = aIter.Next(); |
| if ( pPartObj == pOriginalObj ) |
| { |
| pConnectObj = pPartObj; |
| break; |
| } |
| } |
| } |
| if ( rObjData.nShapeId == pPtr->nShapeA ) |
| { |
| pPtr->pAObj = pConnectObj; |
| pPtr->nSpFlagsA = rObjData.nSpFlags; |
| } |
| if ( rObjData.nShapeId == pPtr->nShapeB ) |
| { |
| pPtr->pBObj = pConnectObj; |
| pPtr->nSpFlagsB = rObjData.nSpFlags; |
| } |
| } |
| } |
| } |
| if ( rPersistEntry.ePageKind == PPT_MASTERPAGE ) |
| { // maybe the escher clusterlist is not correct, but we have to got the right page by using the |
| // spMaster property, so we are patching the table |
| if ( rPersistEntry.nDrawingDgId != 0xffffffff ) |
| { |
| sal_uInt32 nSec = ( rObjData.nShapeId >> 10 ) - 1; |
| if ( mpFidcls && ( nSec < mnIdClusters ) ) |
| mpFidcls[ nSec ].dgid = rPersistEntry.nDrawingDgId; // insert the correct drawing id; |
| } |
| } |
| if ( GetPropertyValue( DFF_Prop_fNoFillHitTest ) & 0x10 ) |
| { |
| if ( (MSO_FillType)GetPropertyValue( DFF_Prop_fillType, mso_fillSolid ) == mso_fillBackground ) |
| { |
| if ( !rData.pBackgroundColoredObjects ) |
| rData.pBackgroundColoredObjects = new List; |
| rData.pBackgroundColoredObjects->Insert( pRet, LIST_APPEND ); |
| } |
| } |
| } |
| return pRet; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void SdrEscherImport::CheckWingdings() const |
| { |
| OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice(); |
| ((SdrEscherImport*)this)->bWingdingsAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "WINGDINGS" ) ) ); |
| ((SdrEscherImport*)this)->bWingdingsChecked = sal_True; |
| } |
| |
| void SdrEscherImport::CheckMonotypeSorts() const |
| { |
| OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice(); |
| ((SdrEscherImport*)this)->bMonotypeSortsAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "MONOTYPE SORTS" ) ) ); |
| ((SdrEscherImport*)this)->bMonotypeSortsChecked = sal_True; |
| } |
| |
| void SdrEscherImport::CheckTimesNewRoman() const |
| { |
| OutputDevice* pDev = (OutputDevice*)Application::GetDefaultDevice(); |
| ((SdrEscherImport*)this)->bTimesNewRomanAvailable = pDev->IsFontAvailable( String( RTL_CONSTASCII_USTRINGPARAM( "TIMES NEW ROMAN" ) ) ); |
| ((SdrEscherImport*)this)->bTimesNewRomanChecked = sal_True; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| SdrPowerPointImport::SdrPowerPointImport( PowerPointImportParam& rParam, const String& rBaseURL ) : |
| SdrEscherImport ( rParam, rBaseURL ), |
| bOk ( rStCtrl.GetErrorCode() == SVSTREAM_OK ), |
| pPersistPtr ( NULL ), |
| nPersistPtrAnz ( 0 ), |
| pDefaultSheet ( NULL ), |
| pMasterPages ( NULL ), |
| pSlidePages ( NULL ), |
| pNotePages ( NULL ), |
| nAktPageNum ( 0 ), |
| nDocStreamPos ( 0 ), |
| nPageColorsNum ( 0xFFFF ), |
| ePageColorsKind ( PPT_MASTERPAGE ), |
| eAktPageKind ( PPT_MASTERPAGE ) |
| { |
| DffRecordHeader* pHd; |
| if ( bOk ) |
| { |
| rStCtrl.Seek( STREAM_SEEK_TO_END ); |
| nStreamLen = rStCtrl.Tell(); |
| |
| // try to allocate the UserEditAtom via CurrentUserAtom |
| sal_uInt32 nCurrentUserEdit = rParam.aCurrentUserAtom.nCurrentUserEdit; |
| if ( nCurrentUserEdit ) |
| { |
| rStCtrl.Seek( nCurrentUserEdit ); |
| rStCtrl >> aUserEditAtom; |
| } |
| if ( !aUserEditAtom.nOffsetPersistDirectory ) |
| { // if there is no UserEditAtom try to search the last one |
| |
| rStCtrl.Seek( 0 ); |
| DffRecordManager aPptRecManager; // contains all first level container and atoms |
| aPptRecManager.Consume( rStCtrl, sal_False, nStreamLen ); |
| for ( pHd = aPptRecManager.Last(); pHd; pHd = aPptRecManager.Prev() ) |
| { |
| if ( pHd->nRecType == PPT_PST_UserEditAtom ) |
| { |
| pHd->SeekToBegOfRecord( rStCtrl ); |
| rStCtrl >> aUserEditAtom; |
| break; |
| } |
| } |
| if ( !pHd ) |
| bOk = sal_False; |
| } |
| } |
| if ( rStCtrl.GetError() != 0 ) |
| bOk = sal_False; |
| |
| if ( bOk ) |
| { |
| nPersistPtrAnz = aUserEditAtom.nMaxPersistWritten + 1; |
| if ( ( nPersistPtrAnz >> 2 ) > nStreamLen ) // sj: at least nPersistPtrAnz is not allowed to be greater than filesize |
| bOk = sal_False; // (it should not be greater than the PPT_PST_PersistPtrIncrementalBlock, but |
| // we are reading this block later, so we do not have access yet) |
| |
| if ( bOk && ( nPersistPtrAnz < ( SAL_MAX_UINT32 / sizeof( sal_uInt32 ) ) ) ) |
| pPersistPtr = new (std::nothrow) sal_uInt32[ nPersistPtrAnz ]; |
| if ( !pPersistPtr ) |
| bOk = sal_False; |
| if ( bOk ) |
| { |
| memset( pPersistPtr, 0x00, nPersistPtrAnz * 4 ); |
| |
| // SJ: new search mechanism from bottom to top (Issue 21122) |
| PptUserEditAtom aCurrentEditAtom( aUserEditAtom ); |
| sal_uInt32 nCurrentEditAtomStrmPos = aCurrentEditAtom.aHd.GetRecEndFilePos(); |
| while( nCurrentEditAtomStrmPos ) |
| { |
| sal_uInt32 nPersistIncPos = aCurrentEditAtom.nOffsetPersistDirectory; |
| if ( nPersistIncPos ) |
| { |
| rStCtrl.Seek( nPersistIncPos ); |
| DffRecordHeader aPersistHd; |
| rStCtrl >> aPersistHd; |
| if ( aPersistHd.nRecType == PPT_PST_PersistPtrIncrementalBlock ) |
| { |
| sal_uLong nPibLen = aPersistHd.GetRecEndFilePos(); |
| while ( bOk && ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < nPibLen ) ) |
| { |
| sal_uInt32 nOfs, nAnz; |
| rStCtrl >> nOfs; |
| nAnz = nOfs; |
| nOfs &= 0x000FFFFF; |
| nAnz >>= 20; |
| while ( bOk && ( rStCtrl.GetError() == 0 ) && ( nAnz > 0 ) && ( nOfs <= nPersistPtrAnz ) ) |
| { |
| sal_uInt32 nPt; |
| rStCtrl >> nPt; |
| if ( !pPersistPtr[ nOfs ] ) |
| { |
| pPersistPtr[ nOfs ] = nPt; |
| if ( pPersistPtr[ nOfs ] > nStreamLen ) |
| { |
| bOk = sal_False; |
| DBG_ERROR("SdrPowerPointImport::Ctor(): Ungueltiger Eintrag im Persist-Directory!"); |
| } |
| } |
| nAnz--; |
| nOfs++; |
| } |
| if ( bOk && nAnz > 0 ) |
| { |
| DBG_ERROR("SdrPowerPointImport::Ctor(): Nicht alle Persist-Directory Entraege gelesen!"); |
| bOk = sal_False; |
| } |
| } |
| } |
| } |
| nCurrentEditAtomStrmPos = aCurrentEditAtom.nOffsetLastEdit < nCurrentEditAtomStrmPos ? aCurrentEditAtom.nOffsetLastEdit : 0; |
| if ( nCurrentEditAtomStrmPos ) |
| { |
| rStCtrl.Seek( nCurrentEditAtomStrmPos ); |
| rStCtrl >> aCurrentEditAtom; |
| } |
| } |
| } |
| } |
| if ( rStCtrl.GetError() != 0 ) |
| bOk = sal_False; |
| if ( bOk ) |
| { // Document PersistEntry checken |
| nDocStreamPos = aUserEditAtom.nDocumentRef; |
| if ( nDocStreamPos > nPersistPtrAnz ) |
| { |
| DBG_ERROR("SdrPowerPointImport::Ctor(): aUserEditAtom.nDocumentRef ungueltig!"); |
| bOk = sal_False; |
| } |
| } |
| if ( bOk ) |
| { // Document FilePos checken |
| nDocStreamPos = pPersistPtr[ nDocStreamPos ]; |
| if ( nDocStreamPos >= nStreamLen ) |
| { |
| DBG_ERROR("SdrPowerPointImport::Ctor(): nDocStreamPos >= nStreamLen!"); |
| bOk = sal_False; |
| } |
| } |
| if ( bOk ) |
| { |
| rStCtrl.Seek( nDocStreamPos ); |
| aDocRecManager.Consume( rStCtrl ); |
| |
| DffRecordHeader aDocHd; |
| rStCtrl >> aDocHd; |
| // DocumentAtom lesen |
| DffRecordHeader aDocAtomHd; |
| rStCtrl >> aDocAtomHd; |
| if ( aDocHd.nRecType == PPT_PST_Document && aDocAtomHd.nRecType == PPT_PST_DocumentAtom ) |
| { |
| aDocAtomHd.SeekToBegOfRecord( rStCtrl ); |
| rStCtrl >> aDocAtom; |
| } |
| else |
| bOk = sal_False; |
| |
| if ( bOk ) |
| { |
| if ( !pFonts ) |
| ReadFontCollection(); |
| |
| // reading TxPF, TxSI |
| PPTTextCharacterStyleAtomInterpreter aTxCFStyle; // SJ: ToDo, this atom needs to be interpreted, it contains character default styles for standard objects (instance4) |
| PPTTextParagraphStyleAtomInterpreter aTxPFStyle; |
| PPTTextSpecInfoAtomInterpreter aTxSIStyle; // styles (default language setting ... ) |
| |
| DffRecordHeader* pEnvHd = aDocRecManager.GetRecordHeader( PPT_PST_Environment ); |
| if ( pEnvHd ) |
| { |
| pEnvHd->SeekToContent( rStCtrl ); |
| DffRecordHeader aTxPFStyleRecHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_TxPFStyleAtom, pEnvHd->GetRecEndFilePos(), &aTxPFStyleRecHd ) ) |
| aTxPFStyle.Read( rStCtrl, aTxPFStyleRecHd ); |
| |
| pEnvHd->SeekToContent( rStCtrl ); |
| DffRecordHeader aTxSIStyleRecHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_TxSIStyleAtom, pEnvHd->GetRecEndFilePos(), &aTxSIStyleRecHd ) ) |
| { |
| aTxSIStyle.Read( rStCtrl, aTxSIStyleRecHd, PPT_PST_TxSIStyleAtom ); |
| #ifdef DBG_UTIL |
| if ( !aTxSIStyle.bValid ) |
| { |
| if (!(rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT )) |
| { |
| DBG_ERROR( "SdrTextSpecInfoAtomInterpreter::Ctor(): parsing error, this document needs to be analysed (SJ)" ); |
| } |
| } |
| #endif |
| } |
| } |
| |
| // todo:: PPT_PST_TxPFStyleAtom |
| |
| // SlidePersists Lesen |
| pMasterPages=new PptSlidePersistList; |
| pSlidePages =new PptSlidePersistList; |
| pNotePages =new PptSlidePersistList; |
| |
| // now always creating the handout page, it will be the first in our masterpage list |
| PptSlidePersistEntry* pE = new PptSlidePersistEntry; |
| pE->aPersistAtom.nPsrReference = aDocAtom.nHandoutMasterPersist; |
| pE->bHandoutMaster = sal_True; |
| if ( !aDocAtom.nHandoutMasterPersist ) |
| pE->bStarDrawFiller = sal_True; // this is a dummy master page |
| pMasterPages->C40_INSERT( PptSlidePersistEntry, pE, 0 ); |
| |
| sal_uInt16 nPageListNum = 0; |
| DffRecordHeader* pSlideListWithTextHd = aDocRecManager.GetRecordHeader( PPT_PST_SlideListWithText ); |
| PptSlidePersistEntry* pPreviousPersist = NULL; |
| while ( pSlideListWithTextHd && ( nPageListNum < 3 ) ) |
| { |
| pSlideListWithTextHd->SeekToContent( rStCtrl ); |
| PptSlidePersistList* pPageList = GetPageList( PptPageKind( nPageListNum ) ); |
| sal_uInt32 nSlideListWithTextHdEndOffset = pSlideListWithTextHd->GetRecEndFilePos(); |
| while ( SeekToRec( rStCtrl, PPT_PST_SlidePersistAtom, nSlideListWithTextHdEndOffset ) ) |
| { |
| if ( pPreviousPersist ) |
| pPreviousPersist->nSlidePersistEndOffset = rStCtrl.Tell(); |
| PptSlidePersistEntry* pE2 = new PptSlidePersistEntry; |
| rStCtrl >> pE2->aPersistAtom; |
| pE2->nSlidePersistStartOffset = rStCtrl.Tell(); |
| pE2->ePageKind = PptPageKind( nPageListNum ); |
| pPageList->C40_INSERT( PptSlidePersistEntry, pE2, pPageList->Count() ); |
| pPreviousPersist = pE2; |
| } |
| if ( pPreviousPersist ) |
| pPreviousPersist->nSlidePersistEndOffset = nSlideListWithTextHdEndOffset; |
| pSlideListWithTextHd = aDocRecManager.GetRecordHeader( PPT_PST_SlideListWithText, SEEK_FROM_CURRENT ); |
| nPageListNum++; |
| } |
| |
| // we will ensure that there is at least one master page |
| if ( pMasterPages->Count() == 1 ) // -> there is only a handout page available |
| { |
| PptSlidePersistEntry* pE2 = new PptSlidePersistEntry; |
| pE2->bStarDrawFiller = sal_True; // this is a dummy master page |
| pMasterPages->C40_INSERT( PptSlidePersistEntry, pE2, 1 ); |
| } |
| |
| // now we will insert at least one notes master for each master page |
| sal_uInt16 nMasterPage; |
| sal_uInt16 nMasterPages = pMasterPages->Count() - 1; |
| for ( nMasterPage = 0; nMasterPage < nMasterPages; nMasterPage++ ) |
| { |
| PptSlidePersistEntry* pE2 = new PptSlidePersistEntry; |
| pE2->bNotesMaster = sal_True; |
| pE2->bStarDrawFiller = sal_True; // this is a dummy master page |
| if ( !nMasterPage && aDocAtom.nNotesMasterPersist ) |
| { // special treatment for the first notes master |
| pE2->aPersistAtom.nPsrReference = aDocAtom.nNotesMasterPersist; |
| pE2->bStarDrawFiller = sal_False; // this is a dummy master page |
| } |
| pMasterPages->C40_INSERT( PptSlidePersistEntry, pE2, ( nMasterPage + 1 ) << 1 ); |
| } |
| |
| // Zu jeder Page noch das SlideAtom bzw. NotesAtom lesen, soweit vorhanden |
| nPageListNum = 0; |
| for ( nPageListNum = 0; nPageListNum < 3; nPageListNum++ ) |
| { |
| PptSlidePersistList* pPageList = GetPageList( PptPageKind( nPageListNum ) ); |
| for ( sal_uInt16 nPageNum = 0; nPageNum < pPageList->Count(); nPageNum++ ) |
| { |
| PptSlidePersistEntry* pE2 = (*pPageList)[ nPageNum ]; |
| sal_uLong nPersist = pE2->aPersistAtom.nPsrReference; |
| if ( ( nPersist > 0 ) && ( nPersist < nPersistPtrAnz ) ) |
| { |
| sal_uLong nFPos = pPersistPtr[ nPersist ]; |
| if ( nFPos < nStreamLen ) |
| { |
| rStCtrl.Seek( nFPos ); |
| DffRecordHeader aSlideHd; |
| rStCtrl >> aSlideHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_SlideAtom, aSlideHd.GetRecEndFilePos() ) ) |
| rStCtrl >> pE2->aSlideAtom; |
| else if ( SeekToRec( rStCtrl, PPT_PST_NotesAtom, aSlideHd.GetRecEndFilePos() ) ) |
| rStCtrl >> pE2->aNotesAtom; |
| aSlideHd.SeekToContent( rStCtrl ); |
| |
| DffRecordHeader aPPTDrawingHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_PPDrawing, aSlideHd.GetRecEndFilePos(), &aPPTDrawingHd ) ) |
| { |
| DffRecordHeader aPPTDgContainer; |
| if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, aPPTDrawingHd.GetRecEndFilePos(), &aPPTDgContainer ) ) |
| { |
| if ( SeekToRec( rStCtrl, DFF_msofbtDg, aPPTDrawingHd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aDgRecordHeader; |
| rStCtrl >> aDgRecordHeader; |
| pE2->nDrawingDgId = aDgRecordHeader.nRecInstance; |
| aDgRecordHeader.SeekToEndOfRecord( rStCtrl ); |
| } |
| if ( SeekToRec( rStCtrl, DFF_msofbtSolverContainer, aPPTDgContainer.GetRecEndFilePos() ) ) |
| { |
| pE2->pSolverContainer = new SvxMSDffSolverContainer; |
| rStCtrl >> *( pE2->pSolverContainer ); |
| } |
| aPPTDgContainer.SeekToBegOfRecord( rStCtrl ); |
| SetDgContainer( rStCtrl ); // set this, so that the escherimport is knowing of our drawings |
| } |
| } |
| // office xp is supporting more than one stylesheet |
| if ( ( pE2->ePageKind == PPT_MASTERPAGE ) && ( pE2->aSlideAtom.nMasterId == 0 ) && ( pE2->bNotesMaster == 0 ) ) |
| { |
| PPTTextSpecInfo aTxSI( 0 ); |
| if ( aTxSIStyle.bValid && aTxSIStyle.aList.Count() ) |
| aTxSI = *( ( (PPTTextSpecInfo*)aTxSIStyle.aList.GetObject( 0 ) ) ); |
| |
| pE2->pStyleSheet = new PPTStyleSheet( aSlideHd, rStCtrl, *this, aTxCFStyle, aTxPFStyle, aTxSI ); |
| pDefaultSheet = pE2->pStyleSheet; |
| } |
| if ( SeekToRec( rStCtrl, PPT_PST_ColorSchemeAtom, aSlideHd.GetRecEndFilePos() ) ) |
| rStCtrl >> pE2->aColorScheme; |
| else |
| { |
| DBG_ERROR( "SdrPowerPointImport::Ctor(): could not get SlideColorScheme! (SJ)" ); |
| } |
| } |
| else |
| { |
| DBG_ERROR("SdrPowerPointImport::Ctor(): Persist-Eintrag fehlerhaft! (SJ)"); |
| } |
| } |
| } |
| } |
| DffRecordHeader* pHeadersFootersHd = aDocRecManager.GetRecordHeader( PPT_PST_HeadersFooters, SEEK_FROM_BEGINNING ); |
| if ( pHeadersFootersHd ) |
| { |
| HeaderFooterEntry aNormalMaster, aNotesMaster; |
| for ( ; pHeadersFootersHd; pHeadersFootersHd = aDocRecManager.GetRecordHeader( PPT_PST_HeadersFooters, SEEK_FROM_CURRENT ) ) |
| { |
| if ( pHeadersFootersHd->nRecInstance == 3 ) // normal master |
| ImportHeaderFooterContainer( *pHeadersFootersHd, aNormalMaster ); |
| else if ( pHeadersFootersHd->nRecInstance == 4 ) // notes master |
| ImportHeaderFooterContainer( *pHeadersFootersHd, aNotesMaster ); |
| } |
| for ( sal_uInt16 i = 0; i < pMasterPages->Count(); i++ ) |
| { |
| if ( (*pMasterPages)[ i ]->bNotesMaster ) |
| (*pMasterPages)[ i ]->pHeaderFooterEntry = new HeaderFooterEntry( aNotesMaster ); |
| else |
| (*pMasterPages)[ i ]->pHeaderFooterEntry = new HeaderFooterEntry( aNormalMaster ); |
| } |
| } |
| } |
| } |
| if ( ( rStCtrl.GetError() != 0 ) || ( pDefaultSheet == NULL ) ) |
| bOk = sal_False; |
| pPPTStyleSheet = pDefaultSheet; |
| rStCtrl.Seek( 0 ); |
| } |
| |
| SdrPowerPointImport::~SdrPowerPointImport() |
| { |
| for ( void* pPtr = aHyperList.First(); pPtr; pPtr = aHyperList.Next() ) |
| delete (SdHyperlinkEntry*)pPtr; |
| delete pMasterPages; |
| delete pSlidePages; |
| delete pNotePages; |
| delete[] pPersistPtr; |
| } |
| |
| sal_Bool PPTConvertOCXControls::InsertControl( |
| const com::sun::star::uno::Reference< |
| com::sun::star::form::XFormComponent > &rFComp, |
| const com::sun::star::awt::Size& rSize, |
| com::sun::star::uno::Reference< |
| com::sun::star::drawing::XShape > *pShape, |
| sal_Bool /*bFloatingCtrl*/) |
| { |
| sal_Bool bRetValue = sal_False; |
| try |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape; |
| |
| const ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexContainer > & rFormComps = |
| GetFormComps(); |
| |
| ::com::sun::star::uno::Any aTmp( &rFComp, ::getCppuType((const ::com::sun::star::uno::Reference< |
| com::sun::star::form::XFormComponent >*)0) ); |
| |
| rFormComps->insertByIndex( rFormComps->getCount(), aTmp ); |
| |
| const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rServiceFactory = |
| GetServiceFactory(); |
| if( rServiceFactory.is() ) |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > xCreate = rServiceFactory |
| ->createInstance(String( RTL_CONSTASCII_STRINGPARAM( "com.sun.star.drawing.ControlShape" ) ) ); |
| if( xCreate.is() ) |
| { |
| xShape = ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape >(xCreate, ::com::sun::star::uno::UNO_QUERY); |
| if ( xShape.is() ) |
| { |
| xShape->setSize(rSize); |
| // GetShapes()->add( xShape ); |
| // Das Control-Model am Control-Shape setzen |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XControlShape > xControlShape( xShape, |
| ::com::sun::star::uno::UNO_QUERY ); |
| ::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel > xControlModel( rFComp, |
| ::com::sun::star::uno::UNO_QUERY ); |
| if ( xControlShape.is() && xControlModel.is() ) |
| { |
| xControlShape->setControl( xControlModel ); |
| if (pShape) |
| *pShape = xShape; |
| bRetValue = sal_True; |
| } |
| } |
| } |
| } |
| } |
| catch( ... ) |
| { |
| bRetValue = sal_False; |
| } |
| return bRetValue; |
| }; |
| |
| const ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >& PPTConvertOCXControls::GetDrawPage() |
| { |
| if( !xDrawPage.is() && pDocSh ) |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > xModel( pDocSh->GetModel() ); |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPages > xDrawPages; |
| switch( ePageKind ) |
| { |
| case PPT_SLIDEPAGE : |
| case PPT_NOTEPAGE : |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPagesSupplier > |
| xDrawPagesSupplier( xModel, ::com::sun::star::uno::UNO_QUERY); |
| if ( xDrawPagesSupplier.is() ) |
| xDrawPages = xDrawPagesSupplier->getDrawPages(); |
| } |
| break; |
| |
| case PPT_MASTERPAGE : |
| { |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPagesSupplier > |
| xMasterPagesSupplier( xModel, ::com::sun::star::uno::UNO_QUERY); |
| if ( xMasterPagesSupplier.is() ) |
| xDrawPages = xMasterPagesSupplier->getMasterPages(); |
| } |
| break; |
| } |
| if ( xDrawPages.is() && xDrawPages->getCount() ) |
| { |
| xDrawPages->getCount(); |
| ::com::sun::star::uno::Any aAny( xDrawPages->getByIndex( xDrawPages->getCount() - 1 ) ); |
| aAny >>= xDrawPage; |
| } |
| } |
| return xDrawPage; |
| } |
| |
| sal_Bool SdrPowerPointOLEDecompress( SvStream& rOutput, SvStream& rInput, sal_uInt32 nInputSize ) |
| { |
| sal_uInt32 nOldPos = rInput.Tell(); |
| char* pBuf = new char[ nInputSize ]; |
| rInput.Read( pBuf, nInputSize ); |
| ZCodec aZCodec( 0x8000, 0x8000 ); |
| aZCodec.BeginCompression(); |
| SvMemoryStream aSource( pBuf, nInputSize, STREAM_READ ); |
| aZCodec.Decompress( aSource, rOutput ); |
| const sal_Bool bSuccess(0L != aZCodec.EndCompression()); |
| delete[] pBuf; |
| rInput.Seek( nOldPos ); |
| return bSuccess; |
| } |
| |
| // --> OD 2004-12-14 #i32596# - add new parameter <_nCalledByGroup> |
| SdrObject* SdrPowerPointImport::ImportOLE( long nOLEId, |
| const Graphic& rGraf, |
| const Rectangle& rBoundRect, |
| const Rectangle& rVisArea, |
| const int /*_nCalledByGroup*/, |
| sal_Int64 /*nAspect*/ ) const |
| // <-- |
| { |
| SdrObject* pRet = NULL; |
| |
| sal_uInt32 nOldPos = rStCtrl.Tell(); |
| |
| Graphic aGraphic( rGraf ); |
| |
| if ( ((SdrPowerPointImport*)this)->maShapeRecords.SeekToContent( rStCtrl, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| DffRecordHeader aPlaceHd; |
| while ( ( rStCtrl.GetError() == 0 ) |
| && ( rStCtrl.Tell() < ((SdrPowerPointImport*)this)->maShapeRecords.Current()->GetRecEndFilePos() ) ) |
| { |
| rStCtrl >> aPlaceHd; |
| if ( aPlaceHd.nRecType == PPT_PST_RecolorInfoAtom ) |
| { |
| ((SdrPowerPointImport*)this)->RecolorGraphic( rStCtrl, aPlaceHd.nRecLen, aGraphic ); |
| break; |
| } |
| else |
| aPlaceHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| } |
| |
| PPTOleEntry* pOe; |
| for ( pOe = (PPTOleEntry*)((SdrPowerPointImport*)this)->aOleObjectList.First(); pOe; |
| pOe = (PPTOleEntry*)((SdrPowerPointImport*)this)->aOleObjectList.Next() ) |
| { |
| if ( pOe->nId != (sal_uInt32)nOLEId ) |
| continue; |
| |
| rStCtrl.Seek( pOe->nRecHdOfs ); |
| |
| DffRecordHeader aHd; |
| rStCtrl >> aHd; |
| |
| sal_uInt32 nLen = aHd.nRecLen - 4; |
| if ( (sal_Int32)nLen > 0 ) |
| { |
| sal_Bool bSuccess = sal_False; |
| |
| rStCtrl.SeekRel( 4 ); |
| |
| ::utl::TempFile aTmpFile; |
| aTmpFile.EnableKillingFile( sal_True ); |
| |
| if ( aTmpFile.IsValid() ) |
| { |
| SvStream* pDest = ::utl::UcbStreamHelper::CreateStream( aTmpFile.GetURL(), STREAM_TRUNC | STREAM_WRITE ); |
| if ( pDest ) |
| bSuccess = SdrPowerPointOLEDecompress( *pDest, rStCtrl, nLen ); |
| delete pDest; |
| } |
| if ( bSuccess ) |
| { |
| SvStream* pDest = ::utl::UcbStreamHelper::CreateStream( aTmpFile.GetURL(), STREAM_READ ); |
| Storage* pObjStor = pDest ? new Storage( *pDest, sal_True ) : NULL; |
| if ( pObjStor ) |
| { |
| SotStorageRef xObjStor( new SotStorage( pObjStor ) ); |
| if ( xObjStor.Is() && !xObjStor->GetError() ) |
| { |
| if ( xObjStor->GetClassName() == SvGlobalName() ) |
| { |
| ClsId aId( pObjStor->GetClassId() ); |
| xObjStor->SetClass( SvGlobalName( aId.n1, aId.n2, aId.n3, aId.n4, aId.n5, aId.n6, aId.n7, aId.n8, aId.n9, aId.n10, aId.n11 ), |
| pObjStor->GetFormat(), pObjStor->GetUserName() ); |
| } |
| SotStorageStreamRef xSrcTst = xObjStor->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "\1Ole" ) ) ); |
| if ( xSrcTst.Is() ) |
| { |
| sal_uInt8 aTestA[ 10 ]; |
| sal_Bool bGetItAsOle = ( sizeof( aTestA ) == xSrcTst->Read( aTestA, sizeof( aTestA ) ) ); |
| if ( !bGetItAsOle ) |
| { // maybe there is a contentsstream in here |
| xSrcTst = xObjStor->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "Contents" ) ), STREAM_READWRITE | STREAM_NOCREATE ); |
| bGetItAsOle = ( xSrcTst.Is() && sizeof( aTestA ) == xSrcTst->Read( aTestA, sizeof( aTestA ) ) ); |
| } |
| if ( bGetItAsOle ) |
| { |
| ::rtl::OUString aNm; |
| // if ( nSvxMSDffOLEConvFlags ) |
| { |
| uno::Reference < embed::XStorage > xDestStorage( pOe->pShell->GetStorage() ); |
| uno::Reference < embed::XEmbeddedObject > xObj = |
| CheckForConvertToSOObj( nSvxMSDffOLEConvFlags, *xObjStor, xDestStorage, rGraf, rVisArea ); |
| if( xObj.is() ) |
| { |
| pOe->pShell->getEmbeddedObjectContainer().InsertEmbeddedObject( xObj, aNm ); |
| |
| svt::EmbeddedObjectRef aObj( xObj, pOe->nAspect ); |
| |
| // TODO/LATER: need MediaType for Graphic |
| aObj.SetGraphic( rGraf, ::rtl::OUString() ); |
| pRet = new SdrOle2Obj( aObj, aNm, rBoundRect, sal_False ); |
| } |
| } |
| if ( !pRet && ( pOe->nType == PPT_PST_ExControl ) ) |
| { |
| PPTConvertOCXControls aPPTConvertOCXControls( pOe->pShell, eAktPageKind ); |
| ::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape; |
| if ( aPPTConvertOCXControls.ReadOCXStream( xObjStor, &xShape, sal_False ) ) |
| pRet = GetSdrObjectFromXShape( xShape ); |
| } |
| if ( !pRet ) |
| { |
| aNm = pOe->pShell->getEmbeddedObjectContainer().CreateUniqueObjectName(); |
| ErrCode aErrCode = 0; |
| |
| // object is not an own object |
| SotStorageRef xTarget = SotStorage::OpenOLEStorage( pOe->pShell->GetStorage(), aNm, STREAM_READWRITE ); |
| if ( xObjStor.Is() && xTarget.Is() ) |
| { |
| xObjStor->CopyTo( xTarget ); |
| if( !xTarget->GetError() ) |
| xTarget->Commit(); |
| if( xTarget->GetError() ) |
| aErrCode = xTarget->GetError(); |
| } |
| xTarget.Clear(); |
| |
| uno::Reference < embed::XEmbeddedObject > xObj = |
| pOe->pShell->getEmbeddedObjectContainer().GetEmbeddedObject( aNm ); |
| if ( xObj.is() ) |
| { |
| if ( pOe->nAspect != embed::Aspects::MSOLE_ICON ) |
| { |
| //TODO/LATER: keep on hacking?! |
| // modifiziert wollen wir nicht werden |
| //xInplaceObj->EnableSetModified( sal_False ); |
| if ( rVisArea.IsEmpty() ) |
| { |
| MapUnit aMapUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( pOe->nAspect ) ); |
| Size aSize( OutputDevice::LogicToLogic( aGraphic.GetPrefSize(), |
| aGraphic.GetPrefMapMode(), MapMode( aMapUnit ) ) ); |
| |
| awt::Size aSz; |
| aSz.Width = aSize.Width(); |
| aSz.Height = aSize.Height(); |
| xObj->setVisualAreaSize( pOe->nAspect, aSz ); |
| } |
| else |
| { |
| awt::Size aSize( rVisArea.GetSize().Width(), rVisArea.GetSize().Height() ); |
| xObj->setVisualAreaSize( pOe->nAspect, aSize ); |
| } |
| //xInplaceObj->EnableSetModified( sal_True ); |
| } |
| |
| svt::EmbeddedObjectRef aObj( xObj, pOe->nAspect ); |
| |
| // TODO/LATER: need MediaType for Graphic |
| aObj.SetGraphic( aGraphic, ::rtl::OUString() ); |
| |
| pRet = new SdrOle2Obj( aObj, aNm, rBoundRect, sal_False ); |
| } |
| } |
| } |
| } |
| } |
| } |
| delete pDest; |
| } |
| } |
| } |
| rStCtrl.Seek( nOldPos ); |
| |
| return pRet; |
| } |
| |
| SvMemoryStream* SdrPowerPointImport::ImportExOleObjStg( sal_uInt32 nPersistPtr, sal_uInt32& nOleId ) const |
| { |
| SvMemoryStream* pRet = NULL; |
| if ( nPersistPtr && ( nPersistPtr < nPersistPtrAnz ) ) |
| { |
| sal_uInt32 nOldPos, nOfs = pPersistPtr[ nPersistPtr ]; |
| nOldPos = rStCtrl.Tell(); |
| rStCtrl.Seek( nOfs ); |
| DffRecordHeader aHd; |
| rStCtrl >> aHd; |
| if ( aHd.nRecType == DFF_PST_ExOleObjStg ) |
| { |
| sal_uInt32 nLen = aHd.nRecLen - 4; |
| if ( (sal_Int32)nLen > 0 ) |
| { |
| rStCtrl >> nOleId; |
| pRet = new SvMemoryStream; |
| ZCodec aZCodec( 0x8000, 0x8000 ); |
| aZCodec.BeginCompression(); |
| aZCodec.Decompress( rStCtrl, *pRet ); |
| if ( !aZCodec.EndCompression() ) |
| delete pRet, pRet = NULL; |
| } |
| } |
| rStCtrl.Seek( nOldPos ); |
| } |
| return pRet; |
| } |
| |
| void SdrPowerPointImport::SeekOle( SfxObjectShell* pShell, sal_uInt32 nFilterOptions ) |
| { |
| if ( pShell ) |
| { |
| DffRecordHeader* pHd; |
| |
| sal_uInt32 nOldPos = rStCtrl.Tell(); |
| if ( nFilterOptions & 1 ) |
| { |
| pHd = aDocRecManager.GetRecordHeader( PPT_PST_List, SEEK_FROM_BEGINNING ); |
| if ( pHd ) |
| { |
| // we try to locate the basic atom |
| pHd->SeekToContent( rStCtrl ); |
| if ( SeekToRec( rStCtrl, PPT_PST_VBAInfo, pHd->GetRecEndFilePos(), pHd ) ) |
| { |
| if ( SeekToRec( rStCtrl, PPT_PST_VBAInfoAtom, pHd->GetRecEndFilePos(), pHd ) ) |
| { |
| sal_uInt32 nPersistPtr, nIDoNotKnow1, nIDoNotKnow2; |
| rStCtrl >> nPersistPtr |
| >> nIDoNotKnow1 |
| >> nIDoNotKnow2; |
| |
| sal_uInt32 nOleId; |
| SvMemoryStream* pBas = ImportExOleObjStg( nPersistPtr, nOleId ); |
| if ( pBas ) |
| { |
| SotStorageRef xSource( new SotStorage( pBas, sal_True ) ); |
| SotStorageRef xDest( new SotStorage( new SvMemoryStream(), sal_True ) ); |
| if ( xSource.Is() && xDest.Is() ) |
| { |
| // is this a visual basic storage ? |
| SotStorageRef xSubStorage = xSource->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "VBA" ) ), |
| STREAM_READWRITE | STREAM_NOCREATE | STREAM_SHARE_DENYALL ); |
| if( xSubStorage.Is() && ( SVSTREAM_OK == xSubStorage->GetError() ) ) |
| { |
| SotStorageRef xMacros = xDest->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "MACROS" ) ) ); |
| if ( xMacros.Is() ) |
| { |
| SvStorageInfoList aList; |
| xSource->FillInfoList( &aList ); |
| sal_uInt32 i; |
| |
| sal_Bool bCopied = sal_True; |
| for ( i = 0; i < aList.Count(); i++ ) // copy all entrys |
| { |
| const SvStorageInfo& rInfo = aList[ i ]; |
| if ( !xSource->CopyTo( rInfo.GetName(), xMacros, rInfo.GetName() ) ) |
| bCopied = sal_False; |
| } |
| if ( i && bCopied ) |
| { |
| SvxImportMSVBasic aMSVBas( *pShell, *xDest, sal_True, sal_False ); |
| //int nSuccess = aMSVBas.Import( String( RTL_CONSTASCII_USTRINGPARAM( "MACROS" ) ), |
| // String( RTL_CONSTASCII_USTRINGPARAM( "VBA" ) ), TRUE, FALSE ); |
| |
| uno::Reference < embed::XStorage > xDoc( pShell->GetStorage() ); |
| if ( xDoc.is() ) |
| { |
| SotStorageRef xVBA = SotStorage::OpenOLEStorage( xDoc, String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Macros" ) ) ); |
| if ( xVBA.Is() && ( xVBA->GetError() == SVSTREAM_OK ) ) |
| { |
| SotStorageRef xSubVBA = xVBA->OpenSotStorage( String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Overhead" ) ) ); |
| if ( xSubVBA.Is() && ( xSubVBA->GetError() == SVSTREAM_OK ) ) |
| { |
| SotStorageStreamRef xOriginal = xSubVBA->OpenSotStream( String( RTL_CONSTASCII_USTRINGPARAM( "_MS_VBA_Overhead2" ) ) ); |
| if ( xOriginal.Is() && ( xOriginal->GetError() == SVSTREAM_OK ) ) |
| { |
| if ( nPersistPtr && ( nPersistPtr < nPersistPtrAnz ) ) |
| { |
| rStCtrl.Seek( pPersistPtr[ nPersistPtr ] ); |
| rStCtrl >> *pHd; |
| |
| *xOriginal << nIDoNotKnow1 |
| << nIDoNotKnow2; |
| |
| sal_uInt32 nSource, nToCopy, nBufSize; |
| nSource = rStCtrl.Tell(); |
| nToCopy = pHd->nRecLen; |
| sal_uInt8* pBuf = new sal_uInt8[ 0x40000 ]; // 256KB Buffer |
| if ( pBuf ) |
| { |
| while ( nToCopy ) |
| { |
| nBufSize = ( nToCopy >= 0x40000 ) ? 0x40000 : nToCopy; |
| rStCtrl.Read( pBuf, nBufSize ); |
| xOriginal->Write( pBuf, nBufSize ); |
| nToCopy -= nBufSize; |
| } |
| delete[] pBuf; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| pHd = aDocRecManager.GetRecordHeader( PPT_PST_ExObjList, SEEK_FROM_BEGINNING ); |
| if ( pHd ) |
| { |
| DffRecordManager* pExObjListManager = NULL; |
| DffRecordHeader* pExEmbed = NULL; |
| |
| pHd->SeekToBegOfRecord( rStCtrl ); |
| pExObjListManager = new DffRecordManager( rStCtrl ); |
| sal_uInt16 i, nRecType(PPT_PST_ExEmbed); |
| |
| for ( i = 0; i < 2; i++ ) |
| { |
| switch ( i ) |
| { |
| case 0 : nRecType = PPT_PST_ExEmbed; break; |
| case 1 : nRecType = PPT_PST_ExControl; break; |
| } |
| for ( pExEmbed = pExObjListManager->GetRecordHeader( nRecType, SEEK_FROM_BEGINNING ); |
| pExEmbed; pExEmbed = pExObjListManager->GetRecordHeader( nRecType, SEEK_FROM_CURRENT ) ) |
| { |
| pExEmbed->SeekToContent( rStCtrl ); |
| |
| DffRecordHeader aExOleAtHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_ExOleObjAtom, pExEmbed->GetRecEndFilePos(), &aExOleAtHd ) ) |
| { |
| PptExOleObjAtom aAt; |
| rStCtrl >> aAt; |
| |
| if ( aAt.nPersistPtr && ( aAt.nPersistPtr < nPersistPtrAnz ) ) |
| { |
| sal_uInt32 nId; |
| rStCtrl.Seek( pPersistPtr[ aAt.nPersistPtr ] ); |
| DffRecordHeader aHd; |
| rStCtrl >> aHd; |
| if ( aHd.nRecType == DFF_PST_ExOleObjStg ) |
| { |
| rStCtrl >> nId; |
| aOleObjectList.Insert( |
| new PPTOleEntry( aAt.nId, aHd.nFilePos, pShell, nRecType, aAt.nAspect ) ); |
| } |
| } |
| } |
| } |
| } |
| delete pExObjListManager; |
| } |
| rStCtrl.Seek( nOldPos ); |
| } |
| } |
| |
| sal_Bool SdrPowerPointImport::ReadFontCollection() |
| { |
| sal_Bool bRet = sal_False; |
| DffRecordHeader* pEnvHd = aDocRecManager.GetRecordHeader( PPT_PST_Environment ); |
| if ( pEnvHd ) |
| { |
| sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration |
| pEnvHd->SeekToContent( rStCtrl ); |
| DffRecordHeader aListHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_FontCollection, pEnvHd->GetRecEndFilePos(), &aListHd ) ) |
| { |
| sal_uInt16 nCount2 = 0; |
| VirtualDevice* pVDev = NULL; |
| while ( SeekToRec( rStCtrl, PPT_PST_FontEntityAtom, aListHd.GetRecEndFilePos() ) ) |
| { |
| bRet = sal_True; |
| if ( !pFonts ) |
| pFonts = new PptFontCollection; |
| PptFontEntityAtom* pFont = new PptFontEntityAtom; |
| rStCtrl >> *pFont; |
| |
| Font aFont; |
| aFont.SetCharSet( pFont->eCharSet ); |
| aFont.SetName( pFont->aName ); |
| aFont.SetFamily( pFont->eFamily ); |
| aFont.SetPitch( pFont->ePitch ); |
| aFont.SetHeight( 100 ); |
| |
| if ( mbTracing && !pFont->bAvailable ) |
| mpTracer->Trace( rtl::OUString::createFromAscii( "sd1000" ), pFont->aName ); |
| |
| #ifdef DBG_EXTRACTFONTMETRICS |
| |
| SvxFont aTmpFont( aFont ); |
| |
| if ( !pVDev ) |
| pVDev = new VirtualDevice; |
| aTmpFont.SetPhysFont( pVDev ); |
| FontMetric aMetric( pVDev->GetFontMetric() ); |
| sal_uInt16 nTxtHeight = (sal_uInt16)aMetric.GetAscent() + (sal_uInt16)aMetric.GetDescent(); |
| |
| String aFileURLStr; |
| if( ::utl::LocalFileHelper::ConvertPhysicalNameToURL( Application::GetAppFileName(), aFileURLStr ) ) |
| { |
| INetURLObject aURL( aFileURLStr ); |
| aURL.SetName( String( RTL_CONSTASCII_STRINGPARAM( "dbgfontmetrics.txt" ) ) ); |
| |
| SvStream* pDbgOut = ::utl::UcbStreamHelper::CreateStream( aURL.GetMainURL( INetURLObject::NO_DECODE ), STREAM_WRITE ); |
| if( pDbgOut ) |
| { |
| pDbgOut->Seek( STREAM_SEEK_TO_END ); |
| |
| Printer* pPrinter = NULL; |
| if ( pSdrModel->GetRefDevice() && pSdrModel->GetRefDevice()->GetOutDevType() == OUTDEV_PRINTER ) |
| pPrinter = (Printer*)pSdrModel->GetRefDevice(); |
| if ( pPrinter ) |
| { |
| Font aOldFont( pPrinter->GetFont() ); |
| aFont.SetKerning( sal_True ); |
| pPrinter->SetFont( aFont ); |
| aMetric = pPrinter->GetFontMetric(); |
| pPrinter->SetFont( aOldFont ); |
| } |
| |
| if ( ( pPrinter == NULL ) || ( aMetric.GetIntLeading() == 0 ) ) |
| { |
| VirtualDevice aVirDev( 1 ); |
| aVirDev.SetFont( aFont ); |
| aMetric = aVirDev.GetFontMetric(); |
| } |
| ByteString aFontName( aFont.GetName(), RTL_TEXTENCODING_UTF8 ); |
| ByteString aHeight( ByteString::CreateFromInt32( aMetric.GetLineHeight() ) ); |
| ByteString aAscent( ByteString::CreateFromInt32( aMetric.GetAscent() ) ); |
| ByteString aDescent( ByteString::CreateFromInt32( aMetric.GetDescent() ) ); |
| ByteString aLeading( ByteString::CreateFromInt32( aMetric.GetIntLeading() ) ); |
| ByteString aPhysHeight( ByteString::CreateFromInt32( nTxtHeight ) ); |
| |
| *pDbgOut << (sal_uInt8)0xa |
| << "FontName : " << aFontName.GetBuffer() << (sal_uInt8)0xa |
| << " Height: " << aHeight.GetBuffer() << (sal_uInt8)0xa |
| << " Ascent: " << aAscent.GetBuffer() << (sal_uInt8)0xa |
| << " Descent:" << aDescent.GetBuffer() << (sal_uInt8)0xa |
| << " Leading:" << aLeading.GetBuffer() << (sal_uInt8)0xa |
| << "PhysHeight :" << aPhysHeight.GetBuffer()<< (sal_uInt8)0xa; |
| } |
| delete pDbgOut; |
| } |
| #endif |
| // following block is necessary, because our old PowerPoint export did not set the |
| // correct charset |
| if ( pFont->aName.EqualsIgnoreCaseAscii( "Wingdings" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "Wingdings 2" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "Wingdings 3" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "Monotype Sorts" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "Monotype Sorts 2" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "Webdings" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "StarBats" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "StarMath" ) || |
| pFont->aName.EqualsIgnoreCaseAscii( "ZapfDingbats" ) ) |
| { |
| pFont->eCharSet = RTL_TEXTENCODING_SYMBOL; |
| }; |
| pFonts->C40_INSERT( PptFontEntityAtom, pFont, nCount2++ ); |
| } |
| delete pVDev; |
| } |
| rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren |
| } |
| return bRet; |
| } |
| |
| PptSlidePersistList* SdrPowerPointImport::GetPageList(PptPageKind ePageKind) const |
| { |
| if ( ePageKind == PPT_MASTERPAGE ) |
| return pMasterPages; |
| if ( ePageKind == PPT_SLIDEPAGE ) |
| return pSlidePages; |
| if ( ePageKind == PPT_NOTEPAGE ) |
| return pNotePages; |
| return NULL; |
| } |
| |
| SdrOutliner* SdrPowerPointImport::GetDrawOutliner( SdrTextObj* pSdrText ) const |
| { |
| if ( !pSdrText ) |
| return NULL; |
| else |
| return &pSdrText->ImpGetDrawOutliner(); |
| } |
| |
| |
| SdrObject* SdrPowerPointImport::ReadObjText( PPTTextObj* pTextObj, SdrObject* pSdrObj, SdPage* pPage ) const |
| { |
| SdrTextObj* pText = PTR_CAST( SdrTextObj, pSdrObj ); |
| if ( pText ) |
| { |
| if ( !ApplyTextObj( pTextObj, pText, pPage, NULL, NULL ) ) |
| pSdrObj = NULL; |
| } |
| return pSdrObj; |
| } |
| |
| |
| SdrObject* SdrPowerPointImport::ApplyTextObj( PPTTextObj* pTextObj, SdrTextObj* pSdrText, SdPage* /*pPage*/, |
| SfxStyleSheet* pSheet, SfxStyleSheet** ppStyleSheetAry ) const |
| { |
| SdrTextObj* pText = pSdrText; |
| if ( pTextObj->Count() ) |
| { |
| sal_uInt32 nDestinationInstance = pTextObj->GetDestinationInstance() ; |
| SdrOutliner& rOutliner = pText->ImpGetDrawOutliner(); |
| if ( ( pText->GetObjInventor() == SdrInventor ) && ( pText->GetObjIdentifier() == OBJ_TITLETEXT ) ) // Outliner-Style fuer Titel-Textobjekt?!? (->von DL) |
| rOutliner.Init( OUTLINERMODE_TITLEOBJECT ); // Outliner reset |
| |
| sal_Bool bOldUpdateMode = rOutliner.GetUpdateMode(); |
| rOutliner.SetUpdateMode( sal_False ); |
| if ( pSheet ) |
| { |
| if ( rOutliner.GetStyleSheet( 0 ) != pSheet ) |
| rOutliner.SetStyleSheet( 0, pSheet ); |
| } |
| rOutliner.SetVertical( pTextObj->GetVertical() ); |
| const PPTParagraphObj* pPreviousParagraph = NULL; |
| for ( PPTParagraphObj* pPara = pTextObj->First(); pPara; pPara = pTextObj->Next() ) |
| { |
| sal_uInt32 nTextSize = pPara->GetTextSize(); |
| if ( ! ( nTextSize & 0xffff0000 ) ) |
| { |
| PPTPortionObj* pPortion; |
| sal_Unicode* pParaText = new sal_Unicode[ nTextSize ]; |
| sal_uInt32 nCurrentIndex = 0; |
| for ( pPortion = pPara->First(); pPortion; pPortion = pPara->Next() ) |
| { |
| if ( pPortion->mpFieldItem ) |
| pParaText[ nCurrentIndex++ ] = ' '; |
| else |
| { |
| sal_uInt32 nCharacters = pPortion->Count(); |
| const sal_Unicode* pSource = pPortion->maString.GetBuffer(); |
| sal_Unicode* pDest = pParaText + nCurrentIndex; |
| |
| sal_uInt32 nFont; |
| pPortion->GetAttrib( PPT_CharAttr_Font, nFont, pTextObj->GetInstance() ); |
| PptFontEntityAtom* pFontEnityAtom = GetFontEnityAtom( nFont ); |
| if ( pFontEnityAtom && ( pFontEnityAtom->eCharSet == RTL_TEXTENCODING_SYMBOL ) ) |
| { |
| sal_uInt32 i; |
| sal_Unicode nUnicode; |
| for ( i = 0; i < nCharacters; i++ ) |
| { |
| nUnicode = pSource[ i ]; |
| if ( ! ( nUnicode & 0xff00 ) ) |
| nUnicode |= 0xf000; |
| pDest[ i ] = nUnicode; |
| } |
| } |
| else |
| memcpy( pDest, pSource, nCharacters << 1 ); |
| nCurrentIndex += nCharacters; |
| } |
| } |
| sal_uInt16 nParaIndex = (sal_uInt16)pTextObj->GetCurrentIndex(); |
| SfxStyleSheet* pS = ( ppStyleSheetAry ) ? ppStyleSheetAry[ pPara->pParaSet->mnDepth ] : pSheet; |
| |
| ESelection aSelection( nParaIndex, 0, nParaIndex, 0 ); |
| rOutliner.Insert( String(), nParaIndex, pPara->pParaSet->mnDepth ); |
| rOutliner.QuickInsertText( String( pParaText, (sal_uInt16)nCurrentIndex ), aSelection ); |
| rOutliner.SetParaAttribs( nParaIndex, rOutliner.GetEmptyItemSet() ); |
| if ( pS ) |
| rOutliner.SetStyleSheet( nParaIndex, pS ); |
| |
| for ( pPortion = pPara->First(); pPortion; pPortion = pPara->Next() ) |
| { |
| SfxItemSet aPortionAttribs( rOutliner.GetEmptyItemSet() ); |
| SvxFieldItem* pFieldItem = pPortion->GetTextField(); |
| if ( pFieldItem ) |
| { |
| rOutliner.QuickInsertField( *pFieldItem, ESelection( nParaIndex, aSelection.nEndPos, nParaIndex, aSelection.nEndPos + 1 ) ); |
| aSelection.nEndPos++; |
| delete pFieldItem; |
| } |
| else |
| { |
| const sal_Unicode *pF, *pPtr = pPortion->maString.GetBuffer(); |
| const sal_Unicode *pMax = pPtr + pPortion->maString.Len(); |
| sal_Int32 nLen; |
| for ( pF = pPtr; pPtr < pMax; pPtr++ ) |
| { |
| if ( *pPtr == 0xb ) |
| { |
| nLen = pPtr - pF; |
| if ( nLen ) |
| aSelection.nEndPos = |
| sal::static_int_cast< sal_uInt16 >( |
| aSelection.nEndPos + nLen ); |
| pF = pPtr + 1; |
| rOutliner.QuickInsertLineBreak( ESelection( nParaIndex, aSelection.nEndPos, nParaIndex, aSelection.nEndPos + 1 ) ); |
| aSelection.nEndPos++; |
| } |
| } |
| nLen = pPtr - pF; |
| if ( nLen ) |
| aSelection.nEndPos = sal::static_int_cast< sal_uInt16 >( |
| aSelection.nEndPos + nLen ); |
| } |
| pPortion->ApplyTo( aPortionAttribs, (SdrPowerPointImport&)*this, nDestinationInstance, pTextObj ); |
| rOutliner.QuickSetAttribs( aPortionAttribs, aSelection ); |
| aSelection.nStartPos = aSelection.nEndPos; |
| } |
| boost::optional< sal_Int16 > oStartNumbering; |
| SfxItemSet aParagraphAttribs( rOutliner.GetEmptyItemSet() ); |
| pPara->ApplyTo( aParagraphAttribs, oStartNumbering, (SdrPowerPointImport&)*this, nDestinationInstance, pPreviousParagraph ); |
| |
| sal_uInt32 nIsBullet2 = 0; //, nInstance = nDestinationInstance != 0xffffffff ? nDestinationInstance : pTextObj->GetInstance(); |
| pPara->GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet2, nDestinationInstance ); |
| if ( !nIsBullet2 ) |
| aParagraphAttribs.Put( SfxBoolItem( EE_PARA_BULLETSTATE, sal_False ) ); |
| |
| |
| pPreviousParagraph = pPara; |
| if ( !aSelection.nStartPos ) // in PPT empty paragraphs never gets a bullet |
| { |
| aParagraphAttribs.Put( SfxBoolItem( EE_PARA_BULLETSTATE, sal_False ) ); |
| // rOutliner.SetDepth( rOutliner.GetParagraph( nParaIndex ), -1 ); |
| } |
| aSelection.nStartPos = 0; |
| rOutliner.QuickSetAttribs( aParagraphAttribs, aSelection ); |
| delete[] pParaText; |
| } |
| } |
| OutlinerParaObject* pNewText = rOutliner.CreateParaObject(); |
| rOutliner.Clear(); |
| rOutliner.SetUpdateMode( bOldUpdateMode ); |
| pText->SetOutlinerParaObject( pNewText ); |
| } |
| return pText; |
| } |
| |
| sal_Bool SdrPowerPointImport::SeekToDocument( DffRecordHeader* pRecHd ) const |
| { |
| sal_Bool bRet; |
| sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer ggf. spaetere Restauration |
| rStCtrl.Seek( nDocStreamPos ); |
| DffRecordHeader aDocHd; |
| rStCtrl >> aDocHd; |
| bRet = aDocHd.nRecType == PPT_PST_Document; |
| if ( bRet ) |
| { |
| if ( pRecHd ) |
| *pRecHd = aDocHd; |
| else |
| aDocHd.SeekToBegOfRecord( rStCtrl ); |
| } |
| if ( !bRet ) |
| rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren |
| return bRet; |
| } |
| |
| sal_Bool SdrPowerPointImport::SeekToContentOfProgTag( sal_Int32 nVersion, SvStream& rSt, |
| const DffRecordHeader& rSourceHd, DffRecordHeader& rContentHd ) |
| { |
| sal_Bool bRetValue = sal_False; |
| sal_uInt32 nOldPos = rSt.Tell(); |
| |
| DffRecordHeader aProgTagsHd, aProgTagBinaryDataHd; |
| rSourceHd.SeekToContent( rSt ); |
| sal_Bool bFound = rSourceHd.nRecType == PPT_PST_ProgTags; |
| if ( !bFound ) |
| bFound = SeekToRec( rSt, PPT_PST_ProgTags, rSourceHd.GetRecEndFilePos(), &aProgTagsHd ); |
| if ( bFound ) |
| { |
| while( SeekToRec( rSt, PPT_PST_ProgBinaryTag, aProgTagsHd.GetRecEndFilePos(), &aProgTagBinaryDataHd ) ) |
| { |
| rSt >> rContentHd; |
| if ( rContentHd.nRecType == PPT_PST_CString ) |
| { |
| sal_uInt16 n = 6; |
| sal_uInt32 i = rContentHd.nRecLen >> 1; |
| if ( i > n ) |
| { |
| String aPre, aSuf; |
| sal_Unicode *pTmp = aPre.AllocBuffer( n ); |
| while ( n-- ) |
| rSt >> *pTmp++; |
| n = (sal_uInt16)( i - 6 ); |
| pTmp = aSuf.AllocBuffer( n ); |
| while ( n-- ) |
| rSt >> *pTmp++; |
| sal_Int32 nV = aSuf.ToInt32(); |
| if ( ( nV == nVersion ) && ( aPre == String( RTL_CONSTASCII_USTRINGPARAM( "___PPT" ) ) ) ) |
| { |
| rContentHd.SeekToEndOfRecord( rSt ); |
| rSt >> rContentHd; |
| if ( rContentHd.nRecType == PPT_PST_BinaryTagData ) |
| { |
| bRetValue = sal_True; |
| break; |
| } |
| } |
| } |
| } |
| aProgTagBinaryDataHd.SeekToEndOfRecord( rSt ); |
| } |
| } |
| if ( !bRetValue ) |
| rSt.Seek( nOldPos ); |
| return bRetValue; |
| } |
| |
| sal_uInt32 SdrPowerPointImport::GetAktPageId() |
| { |
| PptSlidePersistList* pList = GetPageList( eAktPageKind ); |
| if ( pList && nAktPageNum < pList->Count() ) |
| return (*pList)[ (sal_uInt16)nAktPageNum ]->aPersistAtom.nSlideId; |
| return 0; |
| } |
| |
| sal_Bool SdrPowerPointImport::SeekToAktPage( DffRecordHeader* pRecHd ) const |
| { |
| sal_Bool bRet = sal_False; |
| PptSlidePersistList* pList = GetPageList( eAktPageKind ); |
| if ( pList && ( nAktPageNum < pList->Count() ) ) |
| { |
| sal_uLong nPersist = (*pList)[ (sal_uInt16)nAktPageNum ]->aPersistAtom.nPsrReference; |
| if ( nPersist > 0 && nPersist < nPersistPtrAnz ) |
| { |
| sal_uLong nFPos = 0; |
| nFPos = pPersistPtr[ nPersist ]; |
| if ( nFPos < nStreamLen ) |
| { |
| rStCtrl.Seek( nFPos ); |
| if ( pRecHd ) |
| rStCtrl >> *pRecHd; |
| bRet = sal_True; |
| } |
| } |
| } |
| return bRet; |
| } |
| |
| sal_uInt16 SdrPowerPointImport::GetPageCount( PptPageKind ePageKind ) const |
| { |
| PptSlidePersistList* pList = GetPageList( ePageKind ); |
| if ( pList ) |
| return pList->Count(); |
| return 0; |
| } |
| |
| void SdrPowerPointImport::SetPageNum( sal_uInt16 nPageNum, PptPageKind eKind ) |
| { |
| eAktPageKind = eKind; |
| nAktPageNum = nPageNum; |
| |
| pPPTStyleSheet = NULL; |
| |
| sal_Bool bHasMasterPage = sal_True; |
| sal_uInt16 nMasterIndex = 0; |
| |
| if ( eKind == PPT_MASTERPAGE ) |
| nMasterIndex = nPageNum; |
| else |
| { |
| if ( HasMasterPage( nPageNum, eKind ) ) |
| nMasterIndex = GetMasterPageIndex( nPageNum, eKind ); |
| else |
| bHasMasterPage = sal_False; |
| } |
| if ( bHasMasterPage ) |
| { |
| PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE ); |
| if ( pPageList && nMasterIndex < pPageList->Count() ) |
| { |
| PptSlidePersistEntry* pMasterPersist = (*pPageList)[ nMasterIndex ]; |
| if ( ( pMasterPersist->pStyleSheet == NULL ) && pMasterPersist->aSlideAtom.nMasterId ) |
| { |
| nMasterIndex = pMasterPages->FindPage( pMasterPersist->aSlideAtom.nMasterId ); |
| if ( nMasterIndex != PPTSLIDEPERSIST_ENTRY_NOTFOUND ) |
| pMasterPersist = (*pPageList)[ nMasterIndex ]; |
| } |
| pPPTStyleSheet = pMasterPersist->pStyleSheet; |
| } |
| } |
| if ( !pPPTStyleSheet ) |
| pPPTStyleSheet = pDefaultSheet; |
| } |
| |
| Size SdrPowerPointImport::GetPageSize() const |
| { |
| Size aRet( IsNoteOrHandout( nAktPageNum, eAktPageKind ) ? aDocAtom.GetNotesPageSize() : aDocAtom.GetSlidesPageSize() ); |
| Scale( aRet ); |
| // PPT arbeitet nur mit Einheiten zu 576DPI. Um Ungenauigkeiten zu |
| // vermeiden runde ich die letzte Nachkommastelle metrisch weg. |
| if ( nMapMul > 2 * nMapDiv ) |
| { |
| MapUnit eMap = pSdrModel->GetScaleUnit(); |
| bool bInch = IsInch( eMap ); |
| long nInchMul = 1, nInchDiv = 1; |
| if ( bInch ) |
| { // Size temporaer (zum runden) in nach metric konvertieren |
| Fraction aFact(GetMapFactor(eMap,MAP_100TH_MM).X()); |
| nInchMul = aFact.GetNumerator(); |
| nInchDiv = aFact.GetDenominator(); |
| aRet.Width() = BigMulDiv( aRet.Width(), nInchMul, nInchDiv ); |
| aRet.Height() = BigMulDiv( aRet.Height(), nInchMul, nInchDiv ); |
| } |
| aRet.Width() += 5; aRet.Width() /= 10; aRet.Width()*=10; |
| aRet.Height() += 5; aRet.Height() /= 10; aRet.Height()*=10; |
| if ( bInch ) |
| { |
| aRet.Width() = BigMulDiv( aRet.Width(), nInchDiv, nInchMul ); |
| aRet.Height() = BigMulDiv( aRet.Height(), nInchDiv, nInchMul ); |
| } |
| } |
| return aRet; |
| } |
| |
| FASTBOOL SdrPowerPointImport::GetColorFromPalette( sal_uInt16 nNum, Color& rColor ) const |
| { |
| if ( nPageColorsNum != nAktPageNum || ePageColorsKind != eAktPageKind ) |
| { |
| sal_uInt16 nSlideFlags = 0; |
| PptSlidePersistList* pPageList = GetPageList( eAktPageKind ); |
| if ( pPageList && ( nAktPageNum < pPageList->Count() ) ) |
| { |
| PptSlidePersistEntry* pE = (*pPageList)[ nAktPageNum ]; |
| if ( pE ) |
| nSlideFlags = pE->aSlideAtom.nFlags; |
| if ( ! ( nSlideFlags & 2 ) ) |
| ((SdrPowerPointImport*)this)->aPageColors = pE->aColorScheme; |
| } |
| if ( nSlideFlags & 2 ) // follow master colorscheme ? |
| { |
| PptSlidePersistList* pPageList2 = GetPageList( PPT_MASTERPAGE ); |
| if ( pPageList2 ) |
| { |
| PptSlidePersistEntry* pMasterPersist = NULL; |
| if ( eAktPageKind == PPT_MASTERPAGE ) |
| pMasterPersist = (*pPageList2)[ nAktPageNum ]; |
| else |
| { |
| if ( HasMasterPage( nAktPageNum, eAktPageKind ) ) |
| { |
| sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind ); |
| if ( nMasterNum < pPageList2->Count() ) |
| pMasterPersist = (*pPageList2)[ nMasterNum ]; |
| } |
| } |
| if ( pMasterPersist ) |
| { |
| while( ( pMasterPersist && pMasterPersist->aSlideAtom.nFlags & 2 ) // it is possible that a masterpage |
| && pMasterPersist->aSlideAtom.nMasterId ) // itself is following a master colorscheme |
| { |
| sal_uInt16 nNextMaster = pMasterPages->FindPage( pMasterPersist->aSlideAtom.nMasterId ); |
| if ( nNextMaster == PPTSLIDEPERSIST_ENTRY_NOTFOUND ) |
| break; |
| else |
| pMasterPersist = (*pPageList2)[ nNextMaster ]; |
| } |
| ((SdrPowerPointImport*)this)->aPageColors = pMasterPersist->aColorScheme; |
| } |
| } |
| } |
| // momentanes Farbschema eintragen |
| ((SdrPowerPointImport*)this)->nPageColorsNum = nAktPageNum; |
| ((SdrPowerPointImport*)this)->ePageColorsKind = eAktPageKind; |
| } |
| rColor = aPageColors.GetColor( nNum ); |
| return sal_True; |
| } |
| |
| sal_Bool SdrPowerPointImport::SeekToShape( SvStream& rSt, void* pClientData, sal_uInt32 nId ) const |
| { |
| sal_Bool bRet = SvxMSDffManager::SeekToShape( rSt, pClientData, nId ); |
| if ( !bRet ) |
| { |
| ProcessData& rData = *( (ProcessData*)pClientData ); |
| PptSlidePersistEntry& rPersistEntry = rData.rPersistEntry; |
| if ( rPersistEntry.ePageKind == PPT_SLIDEPAGE ) |
| { |
| if ( HasMasterPage( nAktPageNum, eAktPageKind ) ) |
| { |
| sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind ); |
| PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE ); |
| if ( pPageList && ( nMasterNum < pPageList->Count() ) ) |
| { |
| PptSlidePersistEntry* pPersist = (*pPageList)[ nMasterNum ]; // get the masterpage's persistentry |
| if ( pPersist && pPersist->pPresentationObjects ) |
| { |
| sal_uInt32 nCurrent(0L); |
| DffRecordList* pCList = maShapeRecords.pCList; // we got a backup of the current position |
| if ( pCList ) |
| nCurrent = pCList->nCurrent; |
| if ( ((SdrEscherImport*)this )->maShapeRecords.SeekToContent( rSt, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| sal_uInt32 nStreamPos = rSt.Tell(); |
| PPTTextObj aTextObj( rSt, (SdrPowerPointImport&)*this, rPersistEntry, NULL ); |
| if ( aTextObj.Count() || aTextObj.GetOEPlaceHolderAtom() ) |
| { |
| sal_uInt32 nShapePos = 0; |
| switch ( aTextObj.GetInstance() ) |
| { |
| case TSS_TYPE_TITLE : |
| nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_PAGETITLE ]; |
| break; |
| case TSS_TYPE_PAGETITLE : |
| nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_PAGETITLE ]; |
| break; |
| case TSS_TYPE_SUBTITLE : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : |
| case TSS_TYPE_BODY : |
| nShapePos = pPersist->pPresentationObjects[ TSS_TYPE_BODY ]; |
| break; |
| // case TSS_TYPE_NOTES : |
| // case TSS_TYPE_UNUSED : |
| // case TSS_TYPE_TEXT_IN_SHAPE : |
| } |
| if ( nShapePos ) |
| { |
| rSt.Seek( nShapePos ); |
| bRet = sal_True; |
| } |
| } |
| if ( !bRet ) |
| rSt.Seek( nStreamPos ); |
| } |
| if ( pCList ) // restoring |
| pCList->nCurrent = nCurrent; |
| ((SdrEscherImport*)this )->maShapeRecords.pCList = pCList; |
| } |
| } |
| } |
| } |
| } |
| return bRet; |
| } |
| |
| SdrPage* SdrPowerPointImport::MakeBlancPage( sal_Bool bMaster ) const |
| { |
| SdrPage* pRet = pSdrModel->AllocPage( bMaster ); |
| pRet->SetSize( GetPageSize() ); |
| |
| /* |
| SJ (21.08.00) : since bug #77576# i decided not to set a border size. |
| |
| Size aPageSize( aDocAtom.GetSlidesPageSize() ); // PageSize in 576DPI-Units |
| long nHMarg = aPageSize.Width() - aDocAtom.aSlidesPageSize.Width(); |
| long nVMarg = aPageSize.Height() - aDocAtom.aSlidesPageSize.Height(); |
| if ( nHMarg > 0 ) |
| { |
| Scale( nHMarg ); |
| pRet->SetLftBorder( nHMarg / 2 ); |
| pRet->SetRgtBorder( nHMarg - nHMarg / 2 ); |
| } |
| if ( nVMarg > 0 ) |
| { |
| Scale( nVMarg ); |
| pRet->SetUppBorder( nVMarg / 2 ); |
| pRet->SetLwrBorder( nVMarg - nVMarg / 2 ); |
| } |
| */ |
| return pRet; |
| } |
| |
| void ImportComment10( SvxMSDffManager& rMan, SvStream& rStCtrl, SdrPage* pPage, DffRecordHeader& rComment10Hd ) |
| { |
| rtl::OUString sAuthor; |
| rtl::OUString sText; |
| rtl::OUString sInitials; |
| |
| sal_Int32 nIndex = 0; |
| util::DateTime aDateTime; |
| sal_Int32 nPosX = 0; |
| sal_Int32 nPosY = 0; |
| |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < rComment10Hd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aCommentHd; |
| rStCtrl >> aCommentHd; |
| switch( aCommentHd.nRecType ) |
| { |
| case PPT_PST_CString : |
| { |
| String aString; |
| SvxMSDffManager::MSDFFReadZString( rStCtrl, aString, aCommentHd.nRecLen, sal_True ); |
| switch ( aCommentHd.nRecInstance ) |
| { |
| case 0 : sAuthor = aString; break; |
| case 1 : sText = aString; break; |
| case 2 : sInitials = aString; break; |
| } |
| } |
| break; |
| |
| case PPT_PST_CommentAtom10 : |
| { |
| rStCtrl >> nIndex |
| >> aDateTime.Year |
| >> aDateTime.Month |
| >> aDateTime.Day // DayOfWeek |
| >> aDateTime.Day |
| >> aDateTime.Hours |
| >> aDateTime.Minutes |
| >> aDateTime.Seconds |
| >> aDateTime.HundredthSeconds |
| >> nPosX |
| >> nPosY; |
| |
| aDateTime.HundredthSeconds /= 10; |
| } |
| break; |
| } |
| aCommentHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| Point aPosition( nPosX, nPosY ); |
| rMan.Scale( aPosition ); |
| |
| try |
| { |
| uno::Reference< office::XAnnotationAccess > xAnnotationAccess( pPage->getUnoPage(), UNO_QUERY_THROW ); |
| uno::Reference< office::XAnnotation > xAnnotation( xAnnotationAccess->createAndInsertAnnotation() ); |
| xAnnotation->setPosition( geometry::RealPoint2D( aPosition.X() / 100.0, aPosition.Y() / 100.0 ) ); |
| xAnnotation->setAuthor( sAuthor ); |
| xAnnotation->setDateTime( aDateTime ); |
| uno::Reference< text::XText > xText( xAnnotation->getTextRange() ); |
| xText->setString( sText ); |
| } |
| catch( uno::Exception& ) |
| { |
| |
| } |
| } |
| |
| |
| // be sure not to import masterpages with this method |
| // be sure not to import masterpages with this method |
| void SdrPowerPointImport::ImportPage( SdrPage* pRet, const PptSlidePersistEntry* pMasterPersist ) |
| { |
| sal_uInt32 nMerk = rStCtrl.Tell(); |
| PptSlidePersistList* pList = GetPageList( eAktPageKind ); |
| if ( ( !pList ) || ( pList->Count() <= nAktPageNum ) ) |
| return; |
| PptSlidePersistEntry& rSlidePersist = *(*pList)[ nAktPageNum ]; |
| if ( rSlidePersist.bStarDrawFiller ) |
| return; |
| |
| DffRecordHeader aPageHd; |
| if ( SeekToAktPage( &aPageHd ) ) |
| { |
| if ( mbTracing ) |
| mpTracer->AddAttribute( eAktPageKind == PPT_SLIDEPAGE |
| ? rtl::OUString::createFromAscii( "Page" ) |
| : rtl::OUString::createFromAscii( "NotesPage" ), |
| rtl::OUString::valueOf( (sal_Int32)nAktPageNum + 1 ) ); |
| |
| rSlidePersist.pHeaderFooterEntry = new HeaderFooterEntry( pMasterPersist ); |
| ProcessData aProcessData( rSlidePersist, (SdPage*)pRet ); |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPageHd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aHd; |
| rStCtrl >> aHd; |
| switch ( aHd.nRecType ) |
| { |
| case PPT_PST_HeadersFooters : |
| { |
| ImportHeaderFooterContainer( aHd, *rSlidePersist.pHeaderFooterEntry ); |
| } |
| break; |
| |
| case PPT_PST_ProgTags : |
| { |
| DffRecordHeader aContentDataHd; |
| if ( SeekToContentOfProgTag( 10, rStCtrl, aHd, aContentDataHd ) ) |
| { |
| DffRecordHeader aComment10Hd; |
| while( ( rStCtrl.GetError() == 0 ) && SeekToRec( rStCtrl, PPT_PST_Comment10, aContentDataHd.GetRecEndFilePos(), &aComment10Hd ) ) |
| { |
| ImportComment10( *this, rStCtrl, pRet, aComment10Hd ); |
| aComment10Hd.SeekToEndOfRecord( rStCtrl ); |
| } |
| } |
| } |
| break; |
| |
| case PPT_PST_PPDrawing : |
| { |
| DffRecordHeader aPPDrawHd; |
| if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, aHd.GetRecEndFilePos(), &aPPDrawHd ) ) |
| { |
| sal_uInt32 nPPDrawOfs = rStCtrl.Tell(); |
| |
| // importing the background object before importing the page |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPPDrawHd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aEscherObjListHd; |
| rStCtrl >> aEscherObjListHd; |
| switch ( aEscherObjListHd.nRecType ) |
| { |
| case DFF_msofbtSpContainer : |
| { |
| Rectangle aPageSize( Point(), pRet->GetSize() ); |
| if ( rSlidePersist.aSlideAtom.nFlags & 4 ) // follow master background ? |
| { |
| if ( HasMasterPage( nAktPageNum, eAktPageKind ) ) |
| { |
| sal_uInt16 nMasterNum = GetMasterPageIndex( nAktPageNum, eAktPageKind ); |
| PptSlidePersistList* pPageList = GetPageList( PPT_MASTERPAGE ); |
| PptSlidePersistEntry* pE = (*pPageList)[ nMasterNum ]; |
| while( ( pE->aSlideAtom.nFlags & 4 ) && pE->aSlideAtom.nMasterId ) |
| { |
| sal_uInt16 nNextMaster = pMasterPages->FindPage( pE->aSlideAtom.nMasterId ); |
| if ( nNextMaster == PPTSLIDEPERSIST_ENTRY_NOTFOUND ) |
| break; |
| else |
| pE = (*pPageList)[ nNextMaster ]; |
| } |
| if ( pE->nBackgroundOffset ) |
| { |
| // do not follow master colorscheme ? |
| sal_Bool bTemporary = ( rSlidePersist.aSlideAtom.nFlags & 2 ) != 0; |
| sal_uInt32 nPos = rStCtrl.Tell(); |
| rStCtrl.Seek( pE->nBackgroundOffset ); |
| rSlidePersist.pBObj = ImportObj( rStCtrl, (void*)&aProcessData, aPageSize, aPageSize ); |
| rSlidePersist.bBObjIsTemporary = bTemporary; |
| rStCtrl.Seek( nPos ); |
| } |
| } |
| } |
| else |
| { |
| DffRecordHeader aShapeHd; |
| rStCtrl >> aShapeHd; |
| if ( aShapeHd.nRecType == DFF_msofbtSp ) |
| { |
| sal_uInt32 nSpFlags; |
| rStCtrl >> nSpFlags >> nSpFlags; |
| if ( nSpFlags & SP_FBACKGROUND ) |
| { |
| aEscherObjListHd.SeekToBegOfRecord( rStCtrl ); |
| rSlidePersist.pBObj = ImportObj( rStCtrl, (void*)&aProcessData, aPageSize, aPageSize ); |
| rSlidePersist.bBObjIsTemporary = sal_False; |
| } |
| } |
| } |
| } |
| break; |
| } |
| if ( aEscherObjListHd.nRecType == DFF_msofbtSpContainer ) |
| break; |
| aEscherObjListHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| |
| // now importing page |
| rStCtrl.Seek( nPPDrawOfs ); |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aPPDrawHd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aEscherObjListHd; |
| rStCtrl >> aEscherObjListHd; |
| switch ( aEscherObjListHd.nRecType ) |
| { |
| case DFF_msofbtSpgrContainer : |
| { |
| DffRecordHeader aShapeHd; |
| if ( SeekToRec( rStCtrl, DFF_msofbtSpContainer, aEscherObjListHd.GetRecEndFilePos(), &aShapeHd ) ) |
| { |
| aShapeHd.SeekToEndOfRecord( rStCtrl ); |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < aEscherObjListHd.GetRecEndFilePos() ) ) |
| { |
| rStCtrl >> aShapeHd; |
| if ( ( aShapeHd.nRecType == DFF_msofbtSpContainer ) || ( aShapeHd.nRecType == DFF_msofbtSpgrContainer ) ) |
| { |
| Rectangle aEmpty; |
| aShapeHd.SeekToBegOfRecord( rStCtrl ); |
| sal_Int32 nShapeId; |
| aProcessData.pTableRowProperties = NULL; |
| SdrObject* pObj = ImportObj( rStCtrl, (void*)&aProcessData, aEmpty, aEmpty, 0, &nShapeId ); |
| if ( pObj ) |
| { |
| if ( aProcessData.pTableRowProperties ) |
| pObj = CreateTable( pObj, aProcessData.pTableRowProperties, aProcessData.rPersistEntry.pSolverContainer ); |
| |
| pRet->NbcInsertObject( pObj ); |
| |
| if( nShapeId ) |
| insertShapeId( nShapeId, pObj ); |
| } |
| } |
| aShapeHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| } |
| } |
| break; |
| } |
| if ( aEscherObjListHd.nRecType == DFF_msofbtSpgrContainer ) |
| break; |
| aEscherObjListHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| |
| /* There are a lot of Shapes who are dependent to |
| the current background color */ |
| if ( rSlidePersist.ePageKind == PPT_SLIDEPAGE ) |
| { |
| List* pList2 = aProcessData.pBackgroundColoredObjects; |
| if ( pList2 ) |
| { |
| if ( rSlidePersist.pBObj ) |
| { |
| void* pPtr; |
| const SfxPoolItem* pPoolItem = NULL; |
| const SfxItemSet& rObjectItemSet = rSlidePersist.pBObj->GetMergedItemSet(); |
| |
| //SfxItemState eState = rObjectItemSet.GetItemState( XATTR_FILLCOLOR, sal_False, &pPoolItem ); |
| if ( pPoolItem ) |
| { |
| SfxItemSet aNewSet(*rObjectItemSet.GetPool()); |
| aNewSet.Put(*pPoolItem); |
| aNewSet.Put(XFillStyleItem( XFILL_SOLID )); |
| |
| for ( pPtr = pList2->First(); pPtr; pPtr = pList2->Next() ) |
| { |
| ((SdrObject*)pPtr)->SetMergedItemSet(aNewSet); |
| } |
| } |
| } |
| } |
| } |
| if ( rSlidePersist.pBObj ) |
| { |
| // #i99386# transfer the attributes from the temporary BackgroundObject |
| // to the Page and delete it. Maybe rSlidePersist.bBObjIsTemporary is |
| // obsolete here, too. |
| pRet->getSdrPageProperties().ClearItem(); |
| pRet->getSdrPageProperties().PutItemSet(rSlidePersist.pBObj->GetMergedItemSet()); |
| SdrObject::Free( rSlidePersist.pBObj ); |
| } |
| } |
| } |
| break; |
| } |
| aHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| if ( rSlidePersist.pSolverContainer ) |
| SolveSolver( *rSlidePersist.pSolverContainer ); |
| if ( mbTracing ) |
| mpTracer->RemoveAttribute( eAktPageKind == PPT_SLIDEPAGE |
| ? rtl::OUString::createFromAscii( "Page" ) |
| : rtl::OUString::createFromAscii( "NotesPage" ) ); |
| } |
| rStCtrl.Seek( nMerk ); |
| } |
| |
| const PptSlideLayoutAtom* SdrPowerPointImport::GetSlideLayoutAtom() const |
| { |
| PptSlidePersistList* pPageList = GetPageList( eAktPageKind ); |
| if ( pPageList && nAktPageNum < pPageList->Count() ) |
| { |
| PptSlidePersistEntry* pE = (*pPageList)[ nAktPageNum ]; |
| if ( pE ) |
| return &pE->aSlideAtom.aLayout; |
| } |
| return NULL; |
| } |
| |
| sal_Bool SdrPowerPointImport::IsNoteOrHandout( sal_uInt16 nPageNum, PptPageKind /*ePageKind*/) const |
| { |
| sal_Bool bNote = eAktPageKind == PPT_NOTEPAGE; |
| if ( eAktPageKind == PPT_MASTERPAGE ) |
| bNote = ( nPageNum & 1 ) == 0; |
| return bNote; |
| } |
| |
| sal_uInt32 SdrPowerPointImport::GetMasterPageId( sal_uInt16 nPageNum, PptPageKind ePageKind ) const |
| { |
| PptSlidePersistList* pPageList = GetPageList( ePageKind ); |
| if ( pPageList && nPageNum < pPageList->Count() ) |
| return (*pPageList)[ nPageNum ]->aSlideAtom.nMasterId; |
| return 0; |
| } |
| |
| sal_uInt32 SdrPowerPointImport::GetNotesPageId( sal_uInt16 nPageNum ) const |
| { |
| PptSlidePersistList* pPageList=GetPageList( PPT_SLIDEPAGE ); |
| if ( pPageList && nPageNum < pPageList->Count() ) |
| return (*pPageList)[ nPageNum ]->aSlideAtom.nNotesId; |
| return 0; |
| } |
| |
| sal_Bool SdrPowerPointImport::HasMasterPage( sal_uInt16 nPageNum, PptPageKind ePageKind ) const |
| { |
| if ( ePageKind == PPT_NOTEPAGE ) |
| return aDocAtom.nNotesMasterPersist != 0; |
| if ( ePageKind == PPT_MASTERPAGE ) |
| return sal_False; |
| return GetMasterPageId( nPageNum, ePageKind ) != 0; |
| } |
| |
| sal_uInt16 SdrPowerPointImport::GetMasterPageIndex( sal_uInt16 nPageNum, PptPageKind ePageKind ) const |
| { |
| sal_uInt16 nIdx = 0; |
| if ( ePageKind == PPT_NOTEPAGE ) |
| return 2; |
| sal_uInt32 nId = GetMasterPageId( nPageNum, ePageKind ); |
| if ( nId && pMasterPages ) |
| { |
| nIdx = pMasterPages->FindPage( nId ); |
| if ( nIdx == PPTSLIDEPERSIST_ENTRY_NOTFOUND ) |
| nIdx = 0; |
| } |
| return nIdx; |
| } |
| |
| SdrObject* SdrPowerPointImport::ImportPageBackgroundObject( const SdrPage& rPage, sal_uInt32& nBgFileOffset, sal_Bool bForce ) |
| { |
| SdrObject* pRet = NULL; |
| sal_Bool bCreateObj = bForce; |
| SfxItemSet* pSet = NULL; |
| sal_uLong nFPosMerk = rStCtrl.Tell(); // FilePos merken fuer spaetere Restauration |
| DffRecordHeader aPageHd; |
| if ( SeekToAktPage( &aPageHd ) ) |
| { // und nun die Hintergrundattribute der Page suchen |
| sal_uLong nPageRecEnd = aPageHd.GetRecEndFilePos(); |
| DffRecordHeader aPPDrawHd; |
| if ( SeekToRec( rStCtrl, PPT_PST_PPDrawing, nPageRecEnd, &aPPDrawHd ) ) |
| { |
| sal_uLong nPPDrawEnd = aPPDrawHd.GetRecEndFilePos(); |
| DffRecordHeader aEscherF002Hd; |
| if ( SeekToRec( rStCtrl, DFF_msofbtDgContainer, nPPDrawEnd, &aEscherF002Hd ) ) |
| { |
| sal_uLong nEscherF002End = aEscherF002Hd.GetRecEndFilePos(); |
| DffRecordHeader aEscherObjectHd; |
| if ( SeekToRec( rStCtrl, DFF_msofbtSpContainer, nEscherF002End, &aEscherObjectHd ) ) |
| { |
| nBgFileOffset = aEscherObjectHd.GetRecBegFilePos(); |
| //sal_uLong nEscherObjectEnd = aEscherObjectHd.GetRecEndFilePos(); |
| //DffRecordHeader aEscherPropertiesHd; |
| if ( SeekToRec( rStCtrl, DFF_msofbtOPT,nEscherF002End ) ) |
| { |
| rStCtrl >> (DffPropertyReader&)*this; |
| mnFix16Angle = Fix16ToAngle( GetPropertyValue( DFF_Prop_Rotation, 0 ) ); |
| sal_uInt32 nColor = GetPropertyValue( DFF_Prop_fillColor, 0xffffff ); |
| pSet = new SfxItemSet( pSdrModel->GetItemPool() ); |
| DffObjData aObjData( aEscherObjectHd, Rectangle( 0, 0, 28000, 21000 ), 0 ); |
| ApplyAttributes( rStCtrl, *pSet, aObjData ); |
| Color aColor( MSO_CLR_ToColor( nColor ) ); |
| pSet->Put( XFillColorItem( String(), aColor ) ); |
| } |
| } |
| } |
| } |
| } |
| rStCtrl.Seek( nFPosMerk ); // FilePos restaurieren |
| if ( bCreateObj ) |
| { |
| if ( !pSet ) |
| { |
| pSet = new SfxItemSet( pSdrModel->GetItemPool() ); |
| pSet->Put( XFillStyleItem( XFILL_NONE ) ); |
| } |
| pSet->Put( XLineStyleItem( XLINE_NONE ) ); |
| Rectangle aRect( rPage.GetLftBorder(), rPage.GetUppBorder(), rPage.GetWdt()-rPage.GetRgtBorder(), rPage.GetHgt()-rPage.GetLwrBorder() ); |
| pRet = new SdrRectObj( aRect ); |
| pRet->SetModel( pSdrModel ); |
| |
| pRet->SetMergedItemSet(*pSet); |
| |
| pRet->SetMarkProtect( sal_True ); |
| pRet->SetMoveProtect( sal_True ); |
| pRet->SetResizeProtect( sal_True ); |
| } |
| delete pSet; |
| return pRet; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| HeaderFooterEntry::HeaderFooterEntry( const PptSlidePersistEntry* pMPE ) : |
| pMasterPersist ( pMPE ), |
| nAtom ( 0 ) |
| { |
| if ( pMPE ) |
| { |
| HeaderFooterEntry* pMHFE = pMPE->pHeaderFooterEntry; |
| if ( pMHFE ) |
| { |
| nAtom = pMPE->pHeaderFooterEntry->nAtom; |
| pPlaceholder[ 0 ] = pMHFE->pPlaceholder[ 0 ]; |
| pPlaceholder[ 1 ] = pMHFE->pPlaceholder[ 1 ]; |
| pPlaceholder[ 2 ] = pMHFE->pPlaceholder[ 2 ]; |
| pPlaceholder[ 3 ] = pMHFE->pPlaceholder[ 3 ]; |
| } |
| } |
| } |
| |
| HeaderFooterEntry::~HeaderFooterEntry() |
| { |
| } |
| |
| sal_uInt32 HeaderFooterEntry::GetMaskForInstance( sal_uInt32 nInstance ) |
| { |
| sal_uInt32 nRet = 0; |
| switch ( nInstance ) |
| { |
| case 0 : nRet = 0x07ffff; break; |
| case 1 : nRet = 0x100000; break; |
| case 2 : nRet = 0x200000; break; |
| case 3 : nRet = 0x080000; break; |
| } |
| return nRet; |
| } |
| |
| sal_uInt32 HeaderFooterEntry::IsToDisplay( sal_uInt32 nInstance ) |
| { |
| sal_uInt32 nMask = 0; |
| switch ( nInstance ) |
| { |
| case 0 : nMask = 0x010000; break; |
| case 1 : nMask = 0x100000; break; |
| case 2 : nMask = 0x200000; break; |
| case 3 : nMask = 0x080000; break; |
| } |
| return ( nAtom & nMask ); |
| } |
| |
| // The following method checks if the slide is using a different colorscheme than |
| // its master, if this is the fact, then the HeaderFooter must probably be |
| // imported as real sdrobject. In this case, the return value is the offset to the |
| // master header footer object, so it can be re-loaded with a different color set |
| sal_uInt32 HeaderFooterEntry::NeedToImportInstance( const sal_uInt32 nInstance, const PptSlidePersistEntry& rSlidePersist ) |
| { |
| sal_uInt32 nRet = 0; |
| if ( pMasterPersist ) |
| { |
| if ( !( rSlidePersist.aSlideAtom.nFlags & 2 ) ) |
| { // not following the master persist, so we have to check if the colors are changed |
| if ( memcmp( &rSlidePersist.aColorScheme, &pMasterPersist->aColorScheme, 32 ) ) |
| { |
| nRet = pMasterPersist->HeaderFooterOfs[ nInstance ]; |
| } |
| } |
| } |
| return nRet; |
| } |
| |
| void SdrEscherImport::ImportHeaderFooterContainer( DffRecordHeader& rHd, HeaderFooterEntry& rE ) |
| { |
| rHd.SeekToContent( rStCtrl ); |
| while ( ( rStCtrl.GetError() == 0 ) && ( rStCtrl.Tell() < rHd.GetRecEndFilePos() ) ) |
| { |
| DffRecordHeader aHd; |
| rStCtrl >> aHd; |
| switch ( aHd.nRecType ) |
| { |
| case PPT_PST_HeadersFootersAtom : |
| rStCtrl >> rE.nAtom; |
| break; |
| |
| case PPT_PST_CString : |
| { |
| if ( aHd.nRecInstance < 4 ) |
| MSDFFReadZString( rStCtrl, rE.pPlaceholder[ aHd.nRecInstance ], aHd.nRecLen, sal_True ); |
| } |
| break; |
| } |
| aHd.SeekToEndOfRecord( rStCtrl ); |
| } |
| } |
| |
| //static sal_Unicode PPTExportMapper( sal_Unicode nUni, sal_Bool& bNeedsStarBats ) |
| //{ |
| // bNeedsStarBats = sal_False; |
| // |
| // sal_Unicode cLo, cReplace; |
| // cLo = cReplace = 0; |
| // switch ( nUni ) |
| // { |
| // case 132 : cLo = 175; break; |
| // case 147 : cLo = 174; break; |
| // // Currency |
| // case 0x00A2: cReplace = 224; break; |
| // case 0x00A4: cReplace = 225; break; |
| // case 0x00A5: cReplace = 226; break; |
| // case 0x20A1: cReplace = 228; break; |
| // case 0x20A2: cReplace = 229; break; |
| // case 0x20A3: cReplace = 230; break; |
| // case 0x20A4: cReplace = 231; break; |
| // case 0x20A7: cReplace = 227; break; |
| // case 0x20A8: cReplace = 234; break; |
| // case 0x20A9: cReplace = 232; break; |
| // case 0x20AB: cReplace = 233; break; |
| // case 0x20AC: cReplace = 128; break; |
| // // Punctuation and other |
| // case 0x201A: cReplace = 130; break; // SINGLE LOW-9 QUOTATION MARK |
| // case 0x0192: cReplace = 131; break; // LATIN SMALL LETTER F WITH HOOK |
| // case 0x201E: // DOUBLE LOW-9 QUOTATION MARK |
| // case 0x301F: // LOW DOUBLE PRIME QUOTATION MARK |
| // cReplace = 132; break; |
| // case 0x2026: cReplace = 133; break; // HORIZONTAL ELLIPSES |
| // case 0x2020: cReplace = 134; break; // DAGGER |
| // case 0x2021: cReplace = 135; break; // DOUBLE DAGGER |
| // case 0x02C6: cReplace = 136; break; // MODIFIER LETTER CIRCUMFLEX ACCENT |
| // case 0x2030: cReplace = 137; break; // PER MILLE SIGN |
| // case 0x0160: cReplace = 138; break; // LATIN CAPITAL LETTER S WITH CARON |
| // case 0x2039: cReplace = 139; break; // SINGLE LEFT-POINTING ANGLE QUOTATION MARK |
| // case 0x0152: cReplace = 140; break; // LATIN CAPITAL LIGATURE OE |
| // case 0x017D: cReplace = 142; break; // LATIN CAPITAL LETTER Z WITH CARON |
| // case 0x2018: // LEFT SINGLE QUOTATION MARK |
| // case 0x02BB: // MODIFIER LETTER TURNED COMMA |
| // cReplace = 145; break; |
| // case 0x2019: // RIGHT SINGLE QUOTATION MARK |
| // case 0x02BC: // MODIFIER LETTER APOSTROPHE |
| // cReplace = 146; break; |
| // case 0x201C: // LEFT DOUBLE QUOTATION MARK |
| // case 0x301D: // REVERSED DOUBLE PRIME QUOTATION MARK |
| // cReplace = 147; break; |
| // case 0x201D: // RIGHT DOUBLE QUOTATION MARK |
| // case 0x301E: // REVERSED DOUBLE PRIME QUOTATION MARK |
| // cReplace = 148; break; |
| // case 0x2022: cReplace = 149; break; // BULLET |
| // case 0x2013: cReplace = 150; break; // EN DASH |
| // case 0x2014: cReplace = 151; break; // EM DASH |
| // case 0x02DC: cReplace = 152; break; // SMALL TILDE |
| // case 0x2122: cReplace = 153; break; // TRADE MARK SIGN |
| // case 0x0161: cReplace = 154; break; // LATIN SMALL LETTER S WITH CARON |
| // case 0x203A: cReplace = 155; break; // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK |
| // case 0x0153: cReplace = 156; break; // LATIN SMALL LIGATURE OE |
| // case 0x017E: cReplace = 158; break; // LATIN SMALL LETTER Z WITH CARON |
| // case 0x0178: cReplace = 159; break; // LATIN CAPITAL LETTER Y WITH DIAERESIS |
| // case 0x00B6: cReplace = 222; break; // PILCROW SIGN / PARAGRAPH SIGN |
| // } |
| // if ( cReplace ) |
| // { |
| // bNeedsStarBats = sal_True; |
| // return cReplace; |
| // } |
| // else |
| // return cLo; |
| //} |
| |
| // no longer needed |
| sal_Unicode SdrPowerPointImport::PPTSubstitute( sal_uInt16 /*nFont*/, sal_Unicode /*nChar*/, |
| sal_uInt32& /*nMappedFontId*/, Font& /*rFont*/, char /*nDefault*/) const |
| { |
| return 0; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTBuGraEntry::PPTBuGraEntry( Graphic& rGraphic, sal_uInt32 nInst ) : |
| nInstance ( nInst ), |
| aBuGra ( rGraphic ) {} |
| |
| PPTExtParaLevel::PPTExtParaLevel() |
| : mnExtParagraphMask( 0 ) |
| , mnBuBlip( 0xffff ) |
| , mnHasAnm( 0 ) |
| , mnAnmScheme( 0 ) |
| , mpfPP10Ext( 0 ) |
| , mnExtCharacterMask( 0 ) |
| , mcfPP10Ext( 0 ) |
| , mbSet( sal_False ) |
| {} |
| |
| SvStream& operator>>( SvStream& rIn, PPTExtParaLevel& rLevel ) |
| { |
| rLevel.mbSet = sal_True; |
| rIn >> rLevel.mnExtParagraphMask; |
| if ( rLevel.mnExtParagraphMask & 0x00800000 ) |
| rIn >> rLevel.mnBuBlip; |
| if ( rLevel.mnExtParagraphMask & 0x02000000 ) |
| rIn >> rLevel.mnHasAnm; |
| if ( rLevel.mnExtParagraphMask & 0x01000000 ) |
| rIn >> rLevel.mnAnmScheme; |
| if ( rLevel.mnExtParagraphMask & 0x04000000 ) |
| rIn >> rLevel.mpfPP10Ext; |
| rIn >> rLevel.mnExtCharacterMask; |
| if ( rLevel.mnExtCharacterMask & 0x100000 ) |
| rIn >> rLevel.mcfPP10Ext; |
| return rIn; |
| } |
| |
| sal_Bool PPTExtParaProv::GetGraphic( sal_uInt32 nInstance, Graphic& rGraph ) const |
| { |
| sal_Bool bRetValue = sal_False; |
| PPTBuGraEntry* pPtr = NULL; |
| if ( nInstance < aBuGraList.Count() ) |
| { |
| pPtr = (PPTBuGraEntry*)aBuGraList.GetObject( nInstance ); |
| if ( pPtr->nInstance == nInstance ) |
| bRetValue = sal_True; |
| } |
| if ( !bRetValue ) |
| { |
| sal_uInt32 i; |
| for ( i = 0; i < aBuGraList.Count(); i++ ) |
| { |
| pPtr = (PPTBuGraEntry*)aBuGraList.GetObject( i ); |
| if ( pPtr->nInstance == nInstance ) |
| { |
| bRetValue = sal_True; |
| break; |
| } |
| } |
| } |
| if ( bRetValue ) |
| rGraph = pPtr->aBuGra; |
| return bRetValue; |
| } |
| |
| PPTExtParaProv::PPTExtParaProv( SdrPowerPointImport& rMan, SvStream& rSt, const DffRecordHeader* pHd ) : |
| bStyles ( sal_False ), |
| bGraphics ( sal_False ) |
| { |
| sal_uInt32 nOldPos = rSt.Tell(); |
| |
| // here we have to get the graphical bullets... |
| |
| DffRecordHeader aHd; |
| DffRecordHeader aContentDataHd; |
| |
| const DffRecordHeader* pListHd = rMan.aDocRecManager.GetRecordHeader( PPT_PST_List, SEEK_FROM_BEGINNING ); |
| while( pListHd ) |
| { |
| pListHd->SeekToContent( rSt ); |
| if ( !rMan.SeekToContentOfProgTag( 9, rSt, *pListHd, aContentDataHd ) ) |
| break; |
| while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aContentDataHd.GetRecEndFilePos() ) ) |
| { |
| rSt >> aHd; |
| switch ( aHd.nRecType ) |
| { |
| case PPT_PST_ExtendedBuGraContainer : |
| { |
| while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aHd.GetRecEndFilePos() ) ) |
| { |
| sal_uInt16 nType; |
| DffRecordHeader aBuGraAtomHd; |
| rSt >> aBuGraAtomHd; |
| if ( aBuGraAtomHd.nRecType == PPT_PST_ExtendedBuGraAtom ) |
| { |
| rSt >> nType; |
| Graphic aGraphic; |
| if ( rMan.GetBLIPDirect( rSt, aGraphic, NULL ) ) |
| { |
| sal_uInt32 nInstance = aBuGraAtomHd.nRecInstance; |
| PPTBuGraEntry* pBuGra = new PPTBuGraEntry( aGraphic, nInstance ); |
| sal_uInt32 n = 0; |
| sal_uInt32 nBuGraCount = aBuGraList.Count(); |
| if ( nBuGraCount ) |
| { |
| if ( ( (PPTBuGraEntry*)aBuGraList.GetObject( nBuGraCount - 1 ) )->nInstance < nInstance ) |
| n = nBuGraCount; |
| else |
| { // maybe the instances are not sorted, we sort it |
| for ( n = 0; n < nBuGraCount; n++ ) |
| { // sorting fields ( hi >> lo ) |
| if ( ( (PPTBuGraEntry*)aBuGraList.GetObject( n ) )->nInstance < nInstance ) |
| break; |
| } |
| } |
| } |
| aBuGraList.Insert( pBuGra, (sal_uInt32)n ); |
| } |
| #ifdef DBG_UTIL |
| else DBG_ERROR( "PPTExParaProv::PPTExParaProv - bullet graphic is not valid (SJ)" ); |
| #endif |
| } |
| #ifdef DBG_UTIL |
| else DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom interpreting the PPT_PST_ExtendedBuGraContainer (SJ)" ); |
| #endif |
| aBuGraAtomHd.SeekToEndOfRecord( rSt ); |
| } |
| if ( aBuGraList.Count() ) |
| bGraphics = sal_True; |
| } |
| break; |
| |
| case PPT_PST_ExtendedPresRuleContainer : |
| aExtendedPresRules.Consume( rSt, sal_False, aHd.GetRecEndFilePos() ); |
| break; |
| #ifdef DBG_UTIL |
| default : |
| DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom reading ppt2000 num rules (SJ)" ); |
| case PPT_PST_MasterText : // first seen in: ms-tt02.ppt |
| case PPT_PST_SrKinsoku : |
| case PPT_PST_NewlyAddedAtom4016 : |
| case PPT_PST_NewlyAddedAtomByPPT2000_6010 : |
| case PPT_PST_NewlyAddedAtomByPPT2000_6011 : |
| case PPT_PST_NewlyAddedAtomByXP1037 : |
| case PPT_PST_NewlyAddedAtomByXP12004 : |
| case PPT_PST_NewlyAddedAtomByXP14001 : |
| break; |
| #endif |
| } |
| aHd.SeekToEndOfRecord( rSt ); |
| } |
| break; |
| } |
| |
| while( pHd ) |
| { // get the extended paragraph styles on mainmaster ( graphical bullets, num ruling ... ) |
| if ( !rMan.SeekToContentOfProgTag( 9, rSt, *pHd, aContentDataHd ) ) |
| break; |
| while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aContentDataHd.GetRecEndFilePos() ) ) |
| { |
| rSt >> aHd; |
| switch ( aHd.nRecType ) |
| { |
| case PPT_PST_ExtendedParagraphMasterAtom : |
| { |
| if ( aHd.nRecInstance < PPT_STYLESHEETENTRYS ) |
| { |
| sal_uInt16 nDepth, i = 0; |
| rSt >> nDepth; |
| if ( i <= 5 ) |
| { |
| |
| while ( ( rSt.GetError() == 0 ) && ( rSt.Tell() < aHd.GetRecEndFilePos() ) && ( i < nDepth ) ) |
| { |
| bStyles = sal_True; |
| rSt >> aExtParaSheet[ aHd.nRecInstance ].aExtParaLevel[ i++ ]; |
| } |
| #ifdef DBG_UTIL |
| if ( rSt.Tell() != aHd.GetRecEndFilePos() ) |
| DBG_ERROR( "PPTExParaProv::PPTExParaProv - error reading PPT_PST_ExtendedParagraphMasterAtom (SJ)" ); |
| #endif |
| } |
| #ifdef DBG_UTIL |
| else DBG_ERROR( "PPTExParaProv::PPTExParaProv - depth is greater than 5 (SJ)" ); |
| #endif |
| } |
| #ifdef DBG_UTIL |
| else DBG_ERROR( "PPTExParaProv::PPTExParaProv - instance out of range (SJ)" ); |
| #endif |
| } |
| break; |
| default : |
| DBG_ERROR( "PPTExParaProv::PPTExParaProv - unknown atom, assuming PPT_PST_ExtendedParagraphMasterAtom (SJ)" ); |
| case PPT_PST_NewlyAddedAtomByXP11008 : |
| case PPT_PST_NewlyAddedAtomByXP11010 : |
| case PPT_PST_NewlyAddedAtomByXP12010 : |
| case PPT_PST_NewlyAddedAtomByXP12011 : |
| case 0xf144 : |
| break; |
| } |
| aHd.SeekToEndOfRecord( rSt ); |
| } |
| break; |
| } |
| rSt.Seek( nOldPos ); |
| } |
| |
| PPTExtParaProv::~PPTExtParaProv() |
| { |
| void* pPtr; |
| for ( pPtr = aBuGraList.First(); pPtr; pPtr = aBuGraList.Next() ) |
| delete (PPTBuGraEntry*)pPtr; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTNumberFormatCreator::PPTNumberFormatCreator( PPTExtParaProv* pParaProv ) : |
| pExtParaProv ( pParaProv ) |
| { |
| } |
| |
| PPTNumberFormatCreator::~PPTNumberFormatCreator() |
| { |
| delete pExtParaProv; |
| } |
| |
| sal_Bool PPTNumberFormatCreator::ImplGetExtNumberFormat( SdrPowerPointImport& rManager, |
| SvxNumberFormat& rNumberFormat, sal_uInt32 nLevel, sal_uInt32 nInstance, sal_uInt32 nDestinationInstance, |
| boost::optional< sal_Int16 >& rStartNumbering, sal_uInt32 nFontHeight, PPTParagraphObj* pPara ) |
| { |
| sal_Bool bHardAttribute = ( nDestinationInstance == 0xffffffff ); |
| |
| sal_uInt32 nBuFlags = 0; |
| sal_uInt16 nHasAnm = 0; |
| sal_uInt32 nAnmScheme = 0x10003; |
| sal_uInt16 nBuBlip = 0xffff; |
| |
| const PPTExtParaProv* pParaProv = pExtParaProv; |
| if ( !pExtParaProv ) |
| pParaProv = ( pPara ) ? pPara->mrStyleSheet.pExtParaProv |
| : rManager.pPPTStyleSheet->pExtParaProv; |
| if ( pPara ) |
| { |
| nBuFlags = pPara->pParaSet->mnExtParagraphMask; |
| if ( nBuFlags ) |
| { |
| if ( nBuFlags & 0x00800000 ) |
| nBuBlip = pPara->pParaSet->mnBuBlip; |
| if ( nBuFlags & 0x01000000 ) |
| nAnmScheme = pPara->pParaSet->mnAnmScheme; |
| if ( nBuFlags & 0x02000000 ) |
| nHasAnm = pPara->pParaSet->mnHasAnm; |
| bHardAttribute = sal_True; |
| } |
| } |
| |
| if ( ( nBuFlags & 0x03800000 ) != 0x03800000 ) // merge style sheet |
| { // we have to read the master attributes |
| if ( pParaProv && ( nLevel < 5 ) ) |
| { |
| if ( pParaProv->bStyles ) |
| { |
| const PPTExtParaLevel& rLev = pParaProv->aExtParaSheet[ nInstance ].aExtParaLevel[ nLevel ]; |
| if ( rLev.mbSet ) |
| { |
| sal_uInt32 nMaBuFlags = rLev.mnExtParagraphMask; |
| |
| if ( (!( nBuFlags & 0x00800000)) && ( nMaBuFlags & 0x00800000 ) ) |
| { |
| if (!( nBuFlags & 0x02000000)) // if there is a BuStart without BuInstance, |
| nBuBlip = rLev.mnBuBlip; // then there is no graphical Bullet possible |
| } |
| if ( (!( nBuFlags & 0x01000000)) && ( nMaBuFlags & 0x01000000 ) ) |
| nAnmScheme = rLev.mnAnmScheme; |
| if ( (!( nBuFlags & 0x02000000)) && ( nMaBuFlags & 0x02000000 ) ) |
| nHasAnm = rLev.mnHasAnm; |
| nBuFlags |= nMaBuFlags; |
| } |
| } |
| } |
| } |
| if ( nBuBlip != 0xffff ) // set graphical bullet |
| { |
| Graphic aGraphic; |
| if ( pParaProv->GetGraphic( nBuBlip, aGraphic ) ) |
| { |
| SvxBrushItem aBrush( aGraphic, GPOS_MM, SID_ATTR_BRUSH ); |
| rNumberFormat.SetGraphicBrush( &aBrush ); |
| sal_uInt32 nHeight = (sal_uInt32)( (double)nFontHeight * 0.2540 * nBulletHeight + 0.5 ); |
| Size aPrefSize( aGraphic.GetPrefSize() ); |
| sal_uInt32 nWidth = ( nHeight * aPrefSize.Width() ) / aPrefSize.Height(); |
| rNumberFormat.SetGraphicSize( Size( nWidth, nHeight ) ); |
| rNumberFormat.SetNumberingType ( SVX_NUM_BITMAP ); |
| } |
| } |
| else if ( nHasAnm ) |
| { |
| switch( static_cast< sal_uInt16 >( nAnmScheme ) ) |
| { |
| default : |
| case 0 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 1 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 2 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ARABIC ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| } |
| break; |
| case 3 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ARABIC ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 4 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) ); |
| } |
| break; |
| case 5 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| } |
| break; |
| case 6 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_LOWER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 7 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 8 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) ); |
| } |
| break; |
| case 9 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_LOWER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| } |
| break; |
| case 10 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) ); |
| } |
| break; |
| case 11 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CHARS_UPPER_LETTER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| } |
| break; |
| case 12 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ARABIC ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) ); |
| } |
| break; |
| case 13 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ARABIC ); |
| } |
| break; |
| case 14 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| rNumberFormat.SetPrefix( String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) ); |
| } |
| break; |
| case 15 : |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_ROMAN_UPPER ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) ); |
| } |
| break; |
| case 16: // Simplified Chinese. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH ); |
| } |
| break; |
| case 17: // Simplified Chinese with single-byte period. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 18: // Double byte circle numbers. |
| case 19: // Wingdings white circle numbers. |
| case 20: // Wingdings black circle numbers. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_CIRCLE_NUMBER ); |
| } |
| break; |
| case 21: // Traditional Chinese. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH_TW ); |
| } |
| break; |
| case 22: // Traditional Chinese with single-byte period. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_UPPER_ZH_TW ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 26: // Japanese/Korean. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH ); |
| } |
| break; |
| case 27: // Japanese/Korean with single-byte period. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH ); |
| rNumberFormat.SetSuffix( String( RTL_CONSTASCII_USTRINGPARAM( "." ) ) ); |
| } |
| break; |
| case 28: // Double-byte Arabic numbers. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_FULL_WIDTH_ARABIC ); |
| } |
| break; |
| case 29: // Double-byte Arabic numbers with double-byte period. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_FULL_WIDTH_ARABIC ); |
| rNumberFormat.SetSuffix( String( sal_Unicode(0xff0e) ) ); |
| } |
| break; |
| case 38: // Japanese with double-byte period. |
| { |
| rNumberFormat.SetNumberingType( SVX_NUM_NUMBER_LOWER_ZH ); // No such type. Instead with Lower Chinese Number |
| rNumberFormat.SetSuffix( String( sal_Unicode(0xff0e) ) ); |
| } |
| break; |
| } |
| rStartNumbering = boost::optional< sal_Int16 >( nAnmScheme >> 16 ); |
| sal_Int16 nBuStart = *rStartNumbering; |
| //The Seventh bit of nBuFlags that specifies whether fBulletHasAutoNumber exists, |
| //and fBulletHasAutoNumber that specifies whether this paragraph has an automatic numbering scheme. |
| if ( ( nBuFlags & 0x02000000 ) && ( nBuStart != 1 )) |
| { |
| rNumberFormat.SetStart( static_cast<sal_uInt16>(nBuStart) ); |
| } |
| } |
| return bHardAttribute; |
| } |
| |
| void PPTNumberFormatCreator::GetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, sal_uInt32 nLevel, const PPTParaLevel& rParaLevel, const PPTCharLevel& rCharLevel, sal_uInt32 nInstance ) |
| { |
| nIsBullet = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn ) ) != 0 ? 1 : 0; |
| nBulletChar = rParaLevel.mnBulletChar; |
| |
| sal_Bool bBuHardFont; |
| bBuHardFont = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0; |
| if ( bBuHardFont ) |
| nBulletFont = rParaLevel.mnBulletFont; |
| else |
| nBulletFont = rCharLevel.mnFont; |
| nBulletHeight = rParaLevel.mnBulletHeight; |
| nBulletColor = rParaLevel.mnBulletColor; |
| nTextOfs = rParaLevel.mnTextOfs; |
| nBulletOfs = rParaLevel.mnBulletOfs; |
| |
| boost::optional< sal_Int16 > oStartNumbering; |
| ImplGetExtNumberFormat( rManager, rNumberFormat, nLevel, nInstance, 0xffffffff, oStartNumbering, rCharLevel.mnFontHeight, NULL ); |
| if ( ( rNumberFormat.GetNumberingType() != SVX_NUM_BITMAP ) && ( nBulletHeight > 0x7fff ) ) |
| nBulletHeight = rCharLevel.mnFontHeight ? ((-((sal_Int16)nBulletHeight)) * 100 ) / rCharLevel.mnFontHeight : 100; |
| ImplGetNumberFormat( rManager, rNumberFormat, nLevel ); |
| switch ( rNumberFormat.GetNumberingType() ) |
| { |
| case SVX_NUM_CHARS_UPPER_LETTER : |
| case SVX_NUM_CHARS_LOWER_LETTER : |
| case SVX_NUM_ROMAN_UPPER : |
| case SVX_NUM_ROMAN_LOWER : |
| case SVX_NUM_ARABIC : |
| case SVX_NUM_CHARS_UPPER_LETTER_N : |
| case SVX_NUM_CHARS_LOWER_LETTER_N : |
| { |
| sal_uInt32 nFont = rCharLevel.mnFont; |
| PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nFont ); |
| if ( pFontEnityAtom ) |
| { |
| Font aFont; |
| aFont.SetCharSet( pFontEnityAtom->eCharSet ); |
| aFont.SetName( pFontEnityAtom->aName ); |
| aFont.SetFamily( pFontEnityAtom->eFamily ); |
| aFont.SetPitch( pFontEnityAtom->ePitch ); |
| rNumberFormat.SetBulletFont( &aFont ); |
| } |
| } |
| break; |
| } |
| } |
| |
| sal_Bool PPTNumberFormatCreator::GetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, PPTParagraphObj* pParaObj, |
| sal_uInt32 nDestinationInstance, boost::optional< sal_Int16 >& rStartNumbering ) |
| { |
| sal_uInt32 nHardCount = 0; |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletChar, nBulletChar, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletFont, nBulletFont, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletHeight, nBulletHeight, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletColor, nBulletColor, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_TextOfs, nTextOfs, nDestinationInstance ); |
| nHardCount += pParaObj->GetAttrib( PPT_ParaAttr_BulletOfs, nBulletOfs, nDestinationInstance ); |
| |
| if ( nIsBullet ) |
| rNumberFormat.SetNumberingType( SVX_NUM_CHAR_SPECIAL ); |
| |
| sal_uInt32 nFontHeight = 24; |
| PPTPortionObj* pPtr = pParaObj->First(); |
| if ( pPtr ) |
| pPtr->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance ); |
| if ( nIsBullet ) |
| nHardCount += ImplGetExtNumberFormat( rManager, rNumberFormat, pParaObj->pParaSet->mnDepth, |
| pParaObj->mnInstance, nDestinationInstance, rStartNumbering, nFontHeight, pParaObj ); |
| |
| if ( rNumberFormat.GetNumberingType() != SVX_NUM_BITMAP ) |
| pParaObj->UpdateBulletRelSize( nBulletHeight ); |
| if ( nHardCount ) |
| ImplGetNumberFormat( rManager, rNumberFormat, pParaObj->pParaSet->mnDepth ); |
| |
| if ( nHardCount ) |
| { |
| switch ( rNumberFormat.GetNumberingType() ) |
| { |
| case SVX_NUM_CHARS_UPPER_LETTER : |
| case SVX_NUM_CHARS_LOWER_LETTER : |
| case SVX_NUM_ROMAN_UPPER : |
| case SVX_NUM_ROMAN_LOWER : |
| case SVX_NUM_ARABIC : |
| case SVX_NUM_CHARS_UPPER_LETTER_N : |
| case SVX_NUM_CHARS_LOWER_LETTER_N : |
| { |
| if ( pPtr ) |
| { |
| sal_uInt32 nFont; |
| pPtr->GetAttrib( PPT_CharAttr_Font, nFont, nDestinationInstance ); |
| PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nFont ); |
| if ( pFontEnityAtom ) |
| { |
| Font aFont; |
| aFont.SetCharSet( pFontEnityAtom->eCharSet ); |
| aFont.SetName( pFontEnityAtom->aName ); |
| aFont.SetFamily( pFontEnityAtom->eFamily ); |
| aFont.SetPitch( pFontEnityAtom->ePitch ); |
| rNumberFormat.SetBulletFont( &aFont ); |
| } |
| } |
| } |
| break; |
| } |
| } |
| return ( nHardCount ) ? sal_True : sal_False; |
| } |
| |
| void PPTNumberFormatCreator::ImplGetNumberFormat( SdrPowerPointImport& rManager, SvxNumberFormat& rNumberFormat, sal_uInt32 /*nLevel*/) |
| { |
| Font aFont; |
| PptFontEntityAtom* pAtom = rManager.GetFontEnityAtom( nBulletFont ); |
| if ( pAtom ) |
| { |
| CharSet eCharSet( pAtom->eCharSet ); |
| aFont.SetName( pAtom->aName ); |
| aFont.SetCharSet( eCharSet ); |
| aFont.SetFamily( pAtom->eFamily ); |
| aFont.SetPitch( pAtom->ePitch ); |
| } |
| Color aCol( rManager.MSO_TEXT_CLR_ToColor( nBulletColor ) ); |
| aFont.SetColor( aCol ); |
| |
| sal_uInt16 nBuChar = (sal_uInt16)nBulletChar; |
| if ( aFont.GetCharSet() == RTL_TEXTENCODING_SYMBOL ) |
| { |
| nBuChar &= 0x00ff; |
| nBuChar |= 0xf000; |
| } |
| rNumberFormat.SetBulletFont( &aFont ); |
| rNumberFormat.SetBulletChar( nBuChar ); |
| rNumberFormat.SetBulletRelSize( (sal_uInt16)nBulletHeight ); |
| rNumberFormat.SetBulletColor( aCol ); |
| sal_uInt16 nAbsLSpace = (sal_uInt16)( ( (sal_uInt32)nTextOfs * 2540 ) / 576 ); |
| sal_uInt16 nFirstLineOffset = nAbsLSpace - (sal_uInt16)( ( (sal_uInt32)nBulletOfs * 2540 ) / 576 ); |
| rNumberFormat.SetAbsLSpace( nAbsLSpace ); |
| rNumberFormat.SetFirstLineOffset( -nFirstLineOffset ); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTCharSheet::PPTCharSheet( sal_uInt32 nInstance ) |
| { |
| sal_uInt32 nColor = PPT_COLSCHEME_TEXT_UND_ZEILEN; |
| sal_uInt16 nFontHeight(0); |
| switch ( nInstance ) |
| { |
| case TSS_TYPE_PAGETITLE : |
| case TSS_TYPE_TITLE : |
| { |
| nColor = PPT_COLSCHEME_TITELTEXT; |
| nFontHeight = 44; |
| } |
| break; |
| case TSS_TYPE_BODY : |
| case TSS_TYPE_SUBTITLE : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : |
| nFontHeight = 32; |
| break; |
| case TSS_TYPE_NOTES : |
| nFontHeight = 12; |
| break; |
| case TSS_TYPE_UNUSED : |
| case TSS_TYPE_TEXT_IN_SHAPE : |
| nFontHeight = 24; |
| break; |
| } |
| for ( sal_uInt32 nDepth = 0; nDepth < 5; nDepth++ ) |
| { |
| maCharLevel[ nDepth ].mnFlags = 0; |
| maCharLevel[ nDepth ].mnFont = 0; |
| maCharLevel[ nDepth ].mnAsianOrComplexFont = 0xffff; |
| maCharLevel[ nDepth ].mnFontHeight = nFontHeight; |
| maCharLevel[ nDepth ].mnFontColor = nColor; |
| maCharLevel[ nDepth ].mnFontColorInStyleSheet = Color( (sal_uInt8)nColor, (sal_uInt8)( nColor >> 8 ), (sal_uInt8)( nColor >> 16 ) ); |
| maCharLevel[ nDepth ].mnEscapement = 0; |
| } |
| } |
| |
| PPTCharSheet::PPTCharSheet( const PPTCharSheet& rAttr ) |
| { |
| *this = rAttr; |
| } |
| |
| void PPTCharSheet::Read( SvStream& rIn, sal_Bool /*bMasterStyle*/, sal_uInt32 nLevel, sal_Bool /*bFirst*/) |
| { |
| // Zeichenattribute |
| sal_uInt32 nCMask; |
| sal_uInt16 nVal16; |
| rIn >> nCMask; |
| |
| if ( nCMask & 0x0000FFFF ) |
| { |
| sal_uInt16 nBitAttr; |
| maCharLevel[ nLevel ].mnFlags &= ~( (sal_uInt16)nCMask ); |
| rIn >> nBitAttr; // Bit-Attribute (Fett, Unterstrichen, ...) |
| maCharLevel[ nLevel ].mnFlags |= nBitAttr; |
| } |
| if ( nCMask & ( 1 << PPT_CharAttr_Font ) ) // 0x00010000 |
| rIn >> maCharLevel[ nLevel ].mnFont; |
| if ( nCMask & ( 1 << PPT_CharAttr_AsianOrComplexFont ) ) // 0x00200000 |
| rIn >> maCharLevel[ nLevel ].mnAsianOrComplexFont; |
| if ( nCMask & ( 1 << PPT_CharAttr_ANSITypeface ) ) // 0x00400000 |
| rIn >> nVal16; |
| if ( nCMask & ( 1 << PPT_CharAttr_Symbol ) ) // 0x00800000 |
| rIn >> nVal16; |
| if ( nCMask & ( 1 << PPT_CharAttr_FontHeight ) ) // 0x00020000 |
| rIn >> maCharLevel[ nLevel ].mnFontHeight; |
| if ( nCMask & ( 1 << PPT_CharAttr_FontColor ) ) // 0x00040000 |
| { |
| rIn >> maCharLevel[ nLevel ].mnFontColor; |
| if( ! (maCharLevel[ nLevel ].mnFontColor & 0xff000000 ) ) |
| maCharLevel[ nLevel ].mnFontColor = PPT_COLSCHEME_HINTERGRUND; |
| } |
| if ( nCMask & ( 1 << PPT_CharAttr_Escapement ) ) // 0x00080000 |
| rIn >> maCharLevel[ nLevel ].mnEscapement; |
| if ( nCMask & 0x00100000 ) // 0x00100000 |
| rIn >> nVal16; |
| |
| nCMask >>= 24; |
| while( nCMask ) |
| { |
| if ( nCMask & 1 ) |
| { |
| DBG_ERROR( "PPTCharSheet::Read - unknown attribute, send me this document (SJ)" ); |
| rIn >> nVal16; |
| } |
| nCMask >>= 1; |
| } |
| } |
| |
| PPTParaSheet::PPTParaSheet( sal_uInt32 nInstance ) |
| { |
| sal_uInt16 nBuFlags = 0; |
| sal_uInt32 nBulletColor = 0x8000000; |
| sal_uInt16 nUpperDist = 0; |
| |
| switch ( nInstance ) |
| { |
| case TSS_TYPE_PAGETITLE : |
| case TSS_TYPE_TITLE : |
| nBulletColor = PPT_COLSCHEME_TITELTEXT; |
| break; |
| case TSS_TYPE_BODY : |
| case TSS_TYPE_SUBTITLE : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : |
| { |
| nBuFlags = 1; |
| nUpperDist = 0x14; |
| } |
| break; |
| case TSS_TYPE_NOTES : |
| nUpperDist = 0x1e; |
| break; |
| /* |
| default : |
| case TSS_TYPE_UNUSED : |
| case TSS_TYPE_TEXT_IN_SHAPE : |
| break; |
| */ |
| } |
| for ( sal_uInt32 i = 0; i < 5; i++ ) |
| { |
| maParaLevel[ i ].mnBuFlags = nBuFlags; |
| maParaLevel[ i ].mnBulletChar = 0x2022; |
| maParaLevel[ i ].mnBulletFont = 0; |
| maParaLevel[ i ].mnBulletHeight = 100; |
| maParaLevel[ i ].mnBulletColor = nBulletColor; |
| maParaLevel[ i ].mnAdjust = 0; |
| maParaLevel[ i ].mnLineFeed = 100; |
| maParaLevel[ i ].mnLowerDist = 0; |
| maParaLevel[ i ].mnUpperDist = nUpperDist; |
| maParaLevel[ i ].mnTextOfs = 0; |
| maParaLevel[ i ].mnBulletOfs = 0; |
| maParaLevel[ i ].mnDefaultTab = 0x240; |
| maParaLevel[ i ].mnAsianLineBreak = 0; |
| maParaLevel[ i ].mnBiDi = 0; |
| } |
| } |
| |
| PPTParaSheet::PPTParaSheet( const PPTParaSheet& rSheet ) |
| { |
| *this = rSheet; |
| } |
| |
| void PPTParaSheet::Read( SdrPowerPointImport& |
| #ifdef DBG_UTIL |
| rManager |
| #endif |
| , SvStream& rIn, sal_Bool /*bMasterStyle*/, |
| sal_uInt32 nLevel, sal_Bool bFirst ) |
| { |
| // Absatzattribute |
| sal_uInt16 nVal16, i, nMask16; |
| sal_uInt32 nVal32, nPMask; |
| rIn >> nPMask; |
| |
| nMask16 = (sal_uInt16)nPMask & 0xf; |
| if ( nMask16 ) |
| { |
| rIn >> nVal16; |
| maParaLevel[ nLevel ].mnBuFlags &=~ nMask16; |
| nVal16 &= nMask16; |
| maParaLevel[ nLevel ].mnBuFlags |= nVal16; |
| } |
| if ( nPMask & 0x0080 ) |
| rIn >> maParaLevel[ nLevel ].mnBulletChar; |
| if ( nPMask & 0x0010 ) |
| rIn >> maParaLevel[ nLevel ].mnBulletFont; |
| if ( nPMask & 0x0040 ) |
| { |
| rIn >> nVal16; |
| maParaLevel[ nLevel ].mnBulletHeight = nVal16; |
| } |
| if ( nPMask & 0x0020 ) |
| { |
| rIn >> nVal32; |
| maParaLevel[ nLevel ].mnBulletColor = nVal32; |
| } |
| if ( bFirst ) |
| { |
| if ( nPMask & 0xF00 ) |
| { // AbsJust! |
| rIn >> nVal16; |
| maParaLevel[ nLevel ].mnAdjust = nVal16 & 3; |
| } |
| if ( nPMask & 0x1000 ) |
| rIn >> maParaLevel[ nLevel ].mnLineFeed; |
| if ( nPMask & 0x2000 ) |
| rIn >> maParaLevel[ nLevel ].mnUpperDist; |
| if ( nPMask & 0x4000 ) |
| rIn >> maParaLevel[ nLevel ].mnLowerDist; |
| if ( nPMask & 0x8000 ) |
| rIn >> maParaLevel[ nLevel ].mnTextOfs; |
| if ( nPMask & 0x10000 ) |
| rIn >> maParaLevel[ nLevel ].mnBulletOfs; |
| if ( nPMask & 0x20000 ) |
| rIn >> maParaLevel[ nLevel ].mnDefaultTab; |
| if ( nPMask & 0x200000 ) |
| { |
| // number of tabulators |
| rIn >> nVal16; |
| for ( i = 0; i < nVal16; i++ ) |
| rIn >> nVal32; // reading the tabulators |
| } |
| if ( nPMask & 0x40000 ) |
| rIn >> nVal16; |
| if ( nPMask & 0x80000 ) |
| rIn >> maParaLevel[ nLevel ].mnAsianLineBreak; |
| if ( nPMask & 0x100000 ) |
| rIn >> maParaLevel[ nLevel ].mnBiDi; |
| } |
| else |
| { |
| if ( nPMask & 0x800 ) |
| { |
| rIn >> nVal16; |
| maParaLevel[ nLevel ].mnAdjust = nVal16 & 3; |
| } |
| if ( nPMask & 0x1000 ) |
| rIn >> maParaLevel[ nLevel ].mnLineFeed; |
| if ( nPMask & 0x2000 ) |
| rIn >> maParaLevel[ nLevel ].mnUpperDist; |
| if ( nPMask & 0x4000 ) |
| rIn >> maParaLevel[ nLevel ].mnLowerDist; |
| if ( nPMask & 0x8000 ) |
| rIn >> nVal16; |
| if ( nPMask & 0x100 ) |
| rIn >> maParaLevel[ nLevel ].mnTextOfs; |
| if ( nPMask & 0x200 ) |
| rIn >> nVal16; |
| if ( nPMask & 0x400 ) |
| rIn >> maParaLevel[ nLevel ].mnBulletOfs; |
| if ( nPMask & 0x10000 ) |
| rIn >> nVal16; |
| if ( nPMask & 0xe0000 ) |
| { |
| sal_uInt16 nFlagsToModifyMask = (sal_uInt16)( ( nPMask >> 17 ) & 7 ); |
| rIn >> nVal16; |
| // bits that are not involved to zero |
| nVal16 &= nFlagsToModifyMask; |
| // bits that are to change to zero |
| maParaLevel[ nLevel ].mnAsianLineBreak &=~nFlagsToModifyMask; |
| // now set the corresponding bits |
| maParaLevel[ nLevel ].mnAsianLineBreak |= nVal16; |
| } |
| if ( nPMask & 0x100000 ) |
| { |
| // number of tabulators |
| rIn >> nVal16; |
| for ( i = 0; i < nVal16; i++ ) |
| rIn >> nVal32; // reading the tabulators |
| } |
| if ( nPMask & 0x200000 ) |
| rIn >> maParaLevel[ nLevel ].mnBiDi; // #88602# |
| } |
| |
| nPMask >>= 22; |
| while( nPMask ) |
| { |
| if ( nPMask & 1 ) |
| { |
| #ifdef DBG_UTIL |
| if (!(rManager.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT)) |
| { |
| DBG_ERROR( "PPTParaSheet::Read - unknown attribute, send me this document (SJ)" ); |
| } |
| #endif |
| rIn >> nVal16; |
| } |
| nPMask >>= 1; |
| } |
| } |
| |
| void PPTParaSheet::UpdateBulletRelSize( sal_uInt32 nLevel, sal_uInt16 nFontHeight ) |
| { |
| if ( maParaLevel[ nLevel ].mnBulletHeight > 0x7fff ) // a negative value is the absolute bullet height |
| { |
| sal_Int16 nBulletRelSize = ( sal_Int16 )maParaLevel[ nLevel ].mnBulletHeight; |
| nBulletRelSize = nFontHeight ? ((-nBulletRelSize) * 100 ) / nFontHeight : 100; |
| if ( nBulletRelSize < 0 ) //bullet size over flow |
| nBulletRelSize = 100; |
| maParaLevel[ nLevel ].mnBulletHeight = nBulletRelSize; |
| } |
| } |
| |
| PPTStyleSheet::PPTStyleSheet( const DffRecordHeader& rSlideHd, SvStream& rIn, SdrPowerPointImport& rManager, |
| const PPTTextCharacterStyleAtomInterpreter& /*rTxCFStyle*/, const PPTTextParagraphStyleAtomInterpreter& rTxPFStyle, |
| const PPTTextSpecInfo& rTextSpecInfo ) : |
| |
| PPTNumberFormatCreator ( new PPTExtParaProv( rManager, rIn, &rSlideHd ) ), |
| maTxSI ( rTextSpecInfo ) |
| { |
| sal_uInt32 i; |
| sal_uInt32 nOldFilePos = rIn.Tell(); |
| |
| // default stylesheets |
| mpCharSheet[ TSS_TYPE_PAGETITLE ] = new PPTCharSheet( TSS_TYPE_PAGETITLE ); |
| mpCharSheet[ TSS_TYPE_BODY ] = new PPTCharSheet( TSS_TYPE_BODY ); |
| mpCharSheet[ TSS_TYPE_NOTES ] = new PPTCharSheet( TSS_TYPE_NOTES ); |
| mpCharSheet[ TSS_TYPE_UNUSED ] = new PPTCharSheet( TSS_TYPE_UNUSED ); // this entry is not used by ppt |
| mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ] = new PPTCharSheet( TSS_TYPE_TEXT_IN_SHAPE ); |
| mpParaSheet[ TSS_TYPE_PAGETITLE ] = new PPTParaSheet( TSS_TYPE_PAGETITLE ); |
| mpParaSheet[ TSS_TYPE_BODY ] = new PPTParaSheet( TSS_TYPE_BODY ); |
| mpParaSheet[ TSS_TYPE_NOTES ] = new PPTParaSheet( TSS_TYPE_NOTES ); |
| mpParaSheet[ TSS_TYPE_UNUSED ] = new PPTParaSheet( TSS_TYPE_UNUSED ); |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ] = new PPTParaSheet( TSS_TYPE_TEXT_IN_SHAPE ); |
| mpCharSheet[ TSS_TYPE_QUARTERBODY ] = mpCharSheet[ TSS_TYPE_HALFBODY ] = mpCharSheet[ TSS_TYPE_TITLE ] = mpCharSheet[ TSS_TYPE_SUBTITLE ] = NULL; |
| mpParaSheet[ TSS_TYPE_QUARTERBODY ] = mpParaSheet[ TSS_TYPE_HALFBODY ] = mpParaSheet[ TSS_TYPE_TITLE ] = mpParaSheet[ TSS_TYPE_SUBTITLE ] = NULL; |
| |
| /* SJ: try to locate the txMasterStyleAtom in the Environment |
| |
| it seems that the environment TextStyle is having a higher priority |
| than the TextStyle that can be found within the master page |
| */ |
| sal_Bool bFoundTxMasterStyleAtom04 = sal_False; |
| DffRecordHeader* pEnvHeader = rManager.aDocRecManager.GetRecordHeader( PPT_PST_Environment ); |
| if ( pEnvHeader ) |
| { |
| pEnvHeader->SeekToContent( rIn ); |
| DffRecordHeader aTxMasterStyleHd; |
| while ( rIn.Tell() < pEnvHeader->GetRecEndFilePos() ) |
| { |
| rIn >> aTxMasterStyleHd; |
| if ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom ) |
| { |
| sal_uInt16 nLevelAnz; |
| rIn >> nLevelAnz; |
| |
| sal_uInt16 nLev = 0; |
| sal_Bool bFirst = sal_True; |
| bFoundTxMasterStyleAtom04 = sal_True; |
| while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() && nLev < nLevelAnz ) |
| { |
| if ( nLev ) |
| { |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev ] = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev - 1 ]; |
| mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ] = mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev - 1 ]; |
| } |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rManager, rIn, sal_True, nLev, bFirst ); |
| if ( !nLev ) |
| { |
| // set paragraph defaults for instance 4 (TSS_TYPE_TEXT_IN_SHAPE) |
| if ( rTxPFStyle.bValid ) |
| { |
| PPTParaLevel& rParaLevel = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ 0 ]; |
| rParaLevel.mnAsianLineBreak = 0; |
| if ( rTxPFStyle.bForbiddenRules ) |
| rParaLevel.mnAsianLineBreak |= 1; |
| if ( !rTxPFStyle.bLatinTextWrap ) |
| rParaLevel.mnAsianLineBreak |= 2; |
| if ( rTxPFStyle.bHangingPunctuation ) |
| rParaLevel.mnAsianLineBreak |= 4; |
| } |
| } |
| mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rIn, sal_True, nLev, bFirst ); |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->UpdateBulletRelSize( nLev, mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ].mnFontHeight ); |
| bFirst = sal_False; |
| nLev++; |
| } |
| break; |
| } |
| else |
| aTxMasterStyleHd.SeekToEndOfRecord( rIn ); |
| } |
| } |
| |
| rSlideHd.SeekToContent( rIn ); |
| DffRecordHeader aTxMasterStyleHd; |
| while ( rIn.Tell() < rSlideHd.GetRecEndFilePos() ) |
| { |
| rIn >> aTxMasterStyleHd; |
| if ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom ) |
| break; |
| else |
| aTxMasterStyleHd.SeekToEndOfRecord( rIn ); |
| } |
| while ( ( aTxMasterStyleHd.nRecType == PPT_PST_TxMasterStyleAtom ) && ( rIn.Tell() < rSlideHd.GetRecEndFilePos() ) ) //TODO: aTxMasterStyleHd may be used without having been properly initialized |
| { |
| sal_uInt32 nInstance = aTxMasterStyleHd.nRecInstance; |
| if ( ( nInstance < PPT_STYLESHEETENTRYS ) && |
| ( ( nInstance != TSS_TYPE_TEXT_IN_SHAPE ) || ( bFoundTxMasterStyleAtom04 == sal_False ) ) ) |
| { |
| if ( nInstance > 4 ) |
| { |
| delete mpCharSheet[ nInstance ]; // be sure to delete the old one if this instance comes twice |
| delete mpParaSheet[ nInstance ]; |
| |
| switch ( nInstance ) |
| { |
| case TSS_TYPE_SUBTITLE : |
| { |
| mpCharSheet[ TSS_TYPE_SUBTITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_SUBTITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| break; |
| case TSS_TYPE_TITLE : |
| { |
| mpCharSheet[ TSS_TYPE_TITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_PAGETITLE ] ) ); |
| mpParaSheet[ TSS_TYPE_TITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_PAGETITLE ] ) ); |
| } |
| break; |
| case TSS_TYPE_HALFBODY : |
| { |
| mpCharSheet[ TSS_TYPE_HALFBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_HALFBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| break; |
| |
| case TSS_TYPE_QUARTERBODY : |
| { |
| mpCharSheet[ TSS_TYPE_QUARTERBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_QUARTERBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| break; |
| } |
| } |
| sal_uInt16 nLevelAnz; |
| rIn >> nLevelAnz; |
| if ( nLevelAnz > 5 ) |
| { |
| DBG_ERROR( "PPTStyleSheet::Ppt-TextStylesheet hat mehr als 5 Ebenen! (SJ)" ); |
| nLevelAnz = 5; |
| } |
| sal_uInt16 nLev = 0; |
| sal_Bool bFirst = sal_True; |
| |
| while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() && nLev < nLevelAnz ) |
| { |
| if ( nLev && ( nInstance < 5 ) ) |
| { |
| mpParaSheet[ nInstance ]->maParaLevel[ nLev ] = mpParaSheet[ nInstance ]->maParaLevel[ nLev - 1 ]; |
| mpCharSheet[ nInstance ]->maCharLevel[ nLev ] = mpCharSheet[ nInstance ]->maCharLevel[ nLev - 1 ]; |
| } |
| |
| // Ausnahme: Vorlage 5, 6 (MasterTitle Titel und SubTitel) |
| if ( nInstance >= TSS_TYPE_SUBTITLE ) |
| { |
| bFirst = sal_False; |
| |
| sal_uInt16 nDontKnow; |
| rIn >> nDontKnow; |
| } |
| mpParaSheet[ nInstance ]->Read( rManager, rIn, sal_True, nLev, bFirst ); |
| mpCharSheet[ nInstance ]->Read( rIn, sal_True, nLev, bFirst ); |
| mpParaSheet[ nInstance ]->UpdateBulletRelSize( nLev, mpCharSheet[ nInstance ]->maCharLevel[ nLev ].mnFontHeight ); |
| bFirst = sal_False; |
| nLev++; |
| } |
| #ifdef DBG_UTIL |
| if (!(rManager.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT)) |
| { |
| if ( rIn.GetError() == 0 ) |
| { |
| ByteString aMsg; |
| if ( rIn.Tell() > aTxMasterStyleHd.GetRecEndFilePos() ) |
| { |
| aMsg += "\n "; |
| aMsg += "reading too many bytes:"; |
| aMsg += ByteString::CreateFromInt32( rIn.Tell() - aTxMasterStyleHd.GetRecEndFilePos() ); |
| } |
| if ( rIn.Tell() < aTxMasterStyleHd.GetRecEndFilePos() ) |
| { |
| aMsg += "\n "; |
| aMsg += "reading too less bytes:"; |
| aMsg += ByteString::CreateFromInt32( aTxMasterStyleHd.GetRecEndFilePos() - rIn.Tell() ); |
| } |
| if ( aMsg.Len() != 0 ) |
| { |
| aMsg.Insert( "]:", 0 ); |
| aMsg.Insert( "PptStyleSheet::operator>>[", 0 ); |
| DBG_ERROR(aMsg.GetBuffer()); |
| } |
| } |
| if ( rIn.Tell() != aTxMasterStyleHd.GetRecEndFilePos() ) |
| DBG_ASSERT(0, "SJ: Falsche Anzahl von Bytes gelesen beim Import der PPT-Formatvorlagen"); |
| } |
| #endif |
| } |
| aTxMasterStyleHd.SeekToEndOfRecord( rIn ); |
| rIn >> aTxMasterStyleHd; |
| } |
| if ( !mpCharSheet[ TSS_TYPE_SUBTITLE ] ) |
| { |
| mpCharSheet[ TSS_TYPE_SUBTITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_SUBTITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| if ( !mpCharSheet[ TSS_TYPE_TITLE ] ) |
| { |
| mpCharSheet[ TSS_TYPE_TITLE ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_PAGETITLE ] ) ); |
| mpParaSheet[ TSS_TYPE_TITLE ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_PAGETITLE ] ) ); |
| } |
| if ( !mpCharSheet[ TSS_TYPE_HALFBODY ] ) |
| { |
| mpCharSheet[ TSS_TYPE_HALFBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_HALFBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| if ( !mpCharSheet[ TSS_TYPE_QUARTERBODY ] ) |
| { |
| mpCharSheet[ TSS_TYPE_QUARTERBODY ] = new PPTCharSheet( *( mpCharSheet[ TSS_TYPE_BODY ] ) ); |
| mpParaSheet[ TSS_TYPE_QUARTERBODY ] = new PPTParaSheet( *( mpParaSheet[ TSS_TYPE_BODY ] ) ); |
| } |
| if ( !bFoundTxMasterStyleAtom04 ) |
| { // try to locate the txMasterStyleAtom in the Environment |
| DffRecordHeader* pEnvHeader2 = rManager.aDocRecManager.GetRecordHeader( PPT_PST_Environment ); |
| if ( pEnvHeader2 ) |
| { |
| pEnvHeader2->SeekToContent( rIn ); |
| DffRecordHeader aTxMasterStyleHd2; |
| while ( rIn.Tell() < pEnvHeader2->GetRecEndFilePos() ) |
| { |
| rIn >> aTxMasterStyleHd2; |
| if ( aTxMasterStyleHd2.nRecType == PPT_PST_TxMasterStyleAtom ) |
| { |
| sal_uInt16 nLevelAnz; |
| rIn >> nLevelAnz; |
| |
| sal_uInt16 nLev = 0; |
| sal_Bool bFirst = sal_True; |
| while ( rIn.GetError() == 0 && rIn.Tell() < aTxMasterStyleHd2.GetRecEndFilePos() && nLev < nLevelAnz ) |
| { |
| if ( nLev ) |
| { |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev ] = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ nLev - 1 ]; |
| mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ] = mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev - 1 ]; |
| } |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rManager, rIn, sal_True, nLev, bFirst ); |
| if ( !nLev ) |
| { |
| // set paragraph defaults for instance 4 (TSS_TYPE_TEXT_IN_SHAPE) |
| if ( rTxPFStyle.bValid ) |
| { |
| PPTParaLevel& rParaLevel = mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maParaLevel[ 0 ]; |
| rParaLevel.mnAsianLineBreak = 0; |
| if ( rTxPFStyle.bForbiddenRules ) |
| rParaLevel.mnAsianLineBreak |= 1; |
| if ( !rTxPFStyle.bLatinTextWrap ) |
| rParaLevel.mnAsianLineBreak |= 2; |
| if ( rTxPFStyle.bHangingPunctuation ) |
| rParaLevel.mnAsianLineBreak |= 4; |
| } |
| } |
| mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->Read( rIn, sal_True, nLev, bFirst ); |
| mpParaSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->UpdateBulletRelSize( nLev, mpCharSheet[ TSS_TYPE_TEXT_IN_SHAPE ]->maCharLevel[ nLev ].mnFontHeight ); |
| bFirst = sal_False; |
| nLev++; |
| } |
| break; |
| } |
| else |
| aTxMasterStyleHd2.SeekToEndOfRecord( rIn ); |
| } |
| } |
| } |
| rIn.Seek( nOldFilePos ); |
| |
| // will will create the default numbulletitem for each instance |
| for ( i = 0; i < PPT_STYLESHEETENTRYS; i++ ) |
| { |
| sal_uInt16 nLevels, nDepth = 0; |
| SvxNumRuleType eNumRuleType; |
| |
| switch ( i ) |
| { |
| case TSS_TYPE_PAGETITLE : |
| case TSS_TYPE_TITLE : |
| nLevels = 1; |
| eNumRuleType = SVX_RULETYPE_NUMBERING; |
| break; |
| case TSS_TYPE_SUBTITLE : |
| nLevels = 10; |
| eNumRuleType = SVX_RULETYPE_NUMBERING; |
| break; |
| case TSS_TYPE_BODY : |
| case TSS_TYPE_HALFBODY : |
| case TSS_TYPE_QUARTERBODY : |
| nLevels = 10; |
| eNumRuleType = SVX_RULETYPE_PRESENTATION_NUMBERING; |
| break; |
| default : |
| case TSS_TYPE_NOTES : |
| case TSS_TYPE_UNUSED : |
| case TSS_TYPE_TEXT_IN_SHAPE : |
| nLevels = 10; |
| eNumRuleType = SVX_RULETYPE_NUMBERING; |
| break; |
| } |
| SvxNumRule aRule( NUM_BULLET_REL_SIZE | NUM_BULLET_COLOR | |
| NUM_CHAR_TEXT_DISTANCE | NUM_SYMBOL_ALIGNMENT, |
| nLevels, sal_False, eNumRuleType ); |
| for ( sal_uInt16 nCount = 0; nDepth < nLevels; nCount++ ) |
| { |
| const PPTParaLevel& rParaLevel = mpParaSheet[ i ]->maParaLevel[ nCount ]; |
| const PPTCharLevel& rCharLevel = mpCharSheet[ i ]->maCharLevel[ nCount ]; |
| SvxNumberFormat aNumberFormat( SVX_NUM_CHAR_SPECIAL ); |
| aNumberFormat.SetBulletChar( ' ' ); |
| GetNumberFormat( rManager, aNumberFormat, nCount, rParaLevel, rCharLevel, i ); |
| aRule.SetLevel( nDepth++, aNumberFormat ); |
| if ( nCount >= 4 ) |
| { |
| for ( ;nDepth < nLevels; nDepth++ ) |
| aRule.SetLevel( nDepth, aNumberFormat ); |
| if ( eNumRuleType == SVX_RULETYPE_PRESENTATION_NUMBERING ) |
| aRule.SetLevel( 0, aNumberFormat ); |
| } |
| } |
| mpNumBulletItem[ i ] = new SvxNumBulletItem( aRule, EE_PARA_NUMBULLET ); |
| } |
| } |
| |
| PPTStyleSheet::~PPTStyleSheet() |
| { |
| for ( sal_uInt32 i = 0; i < PPT_STYLESHEETENTRYS; i++ ) |
| { |
| delete mpCharSheet[ i ]; |
| delete mpParaSheet[ i ]; |
| delete mpNumBulletItem[ i ]; |
| } |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTParaPropSet::PPTParaPropSet() : |
| pParaSet( new ImplPPTParaPropSet ) |
| { |
| pParaSet->mnHasAnm = 1; |
| } |
| |
| PPTParaPropSet::PPTParaPropSet( PPTParaPropSet& rParaPropSet ) |
| { |
| pParaSet = rParaPropSet.pParaSet; |
| pParaSet->mnRefCount++; |
| |
| mnOriginalTextPos = rParaPropSet.mnOriginalTextPos; |
| } |
| |
| PPTParaPropSet::~PPTParaPropSet() |
| { |
| if ( ! ( --pParaSet->mnRefCount ) ) |
| delete pParaSet; |
| } |
| |
| PPTParaPropSet& PPTParaPropSet::operator=( PPTParaPropSet& rParaPropSet ) |
| { |
| if ( this != &rParaPropSet ) |
| { |
| if ( ! ( --pParaSet->mnRefCount ) ) |
| delete pParaSet; |
| pParaSet = rParaPropSet.pParaSet; |
| pParaSet->mnRefCount++; |
| |
| mnOriginalTextPos = rParaPropSet.mnOriginalTextPos; |
| } |
| return *this; |
| } |
| |
| PPTCharPropSet::PPTCharPropSet( sal_uInt32 nParagraph ) : |
| mnParagraph ( nParagraph ), |
| mpFieldItem ( NULL ), |
| pCharSet ( new ImplPPTCharPropSet ) |
| { |
| mnHylinkOrigColor = 0; |
| mbIsHyperlink = sal_False; |
| mbHardHylinkOrigColor = sal_False; |
| mnLanguage[ 0 ] = mnLanguage[ 1 ] = mnLanguage[ 2 ] = 0; |
| } |
| |
| PPTCharPropSet::PPTCharPropSet( PPTCharPropSet& rCharPropSet ) |
| { |
| mnHylinkOrigColor = rCharPropSet.mnHylinkOrigColor; |
| mbIsHyperlink = rCharPropSet.mbIsHyperlink; |
| mbHardHylinkOrigColor = rCharPropSet.mbHardHylinkOrigColor; |
| pCharSet = rCharPropSet.pCharSet; |
| pCharSet->mnRefCount++; |
| |
| mnParagraph = rCharPropSet.mnParagraph; |
| mnOriginalTextPos = rCharPropSet.mnOriginalTextPos; |
| maString = rCharPropSet.maString; |
| mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL; |
| mnLanguage[ 0 ] = rCharPropSet.mnLanguage[ 0 ]; |
| mnLanguage[ 1 ] = rCharPropSet.mnLanguage[ 1 ]; |
| mnLanguage[ 2 ] = rCharPropSet.mnLanguage[ 2 ]; |
| } |
| |
| PPTCharPropSet::PPTCharPropSet( PPTCharPropSet& rCharPropSet, sal_uInt32 nParagraph ) |
| { |
| pCharSet = rCharPropSet.pCharSet; |
| pCharSet->mnRefCount++; |
| |
| mnHylinkOrigColor = rCharPropSet.mnHylinkOrigColor; |
| mbIsHyperlink = rCharPropSet.mbIsHyperlink; |
| mbHardHylinkOrigColor = rCharPropSet.mbHardHylinkOrigColor; |
| |
| mnParagraph = nParagraph; |
| mnOriginalTextPos = rCharPropSet.mnOriginalTextPos; |
| maString = rCharPropSet.maString; |
| mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL; |
| mnLanguage[ 0 ] = mnLanguage[ 1 ] = mnLanguage[ 2 ] = 0; |
| } |
| |
| PPTCharPropSet::~PPTCharPropSet() |
| { |
| if ( ! ( --pCharSet->mnRefCount ) ) |
| delete pCharSet; |
| delete mpFieldItem; |
| } |
| |
| PPTCharPropSet& PPTCharPropSet::operator=( PPTCharPropSet& rCharPropSet ) |
| { |
| if ( this != &rCharPropSet ) |
| { |
| if ( ! ( --pCharSet->mnRefCount ) ) |
| delete pCharSet; |
| pCharSet = rCharPropSet.pCharSet; |
| pCharSet->mnRefCount++; |
| |
| mnOriginalTextPos = rCharPropSet.mnOriginalTextPos; |
| mnParagraph = rCharPropSet.mnParagraph; |
| maString = rCharPropSet.maString; |
| mpFieldItem = ( rCharPropSet.mpFieldItem ) ? new SvxFieldItem( *rCharPropSet.mpFieldItem ) : NULL; |
| } |
| return *this; |
| } |
| |
| void PPTCharPropSet::ImplMakeUnique() |
| { |
| if ( pCharSet->mnRefCount > 1 ) |
| { |
| ImplPPTCharPropSet& rOld = *pCharSet; |
| rOld.mnRefCount--; |
| pCharSet = new ImplPPTCharPropSet( rOld ); |
| pCharSet->mnRefCount = 1; |
| } |
| } |
| |
| void PPTCharPropSet::SetFont( sal_uInt16 nFont ) |
| { |
| sal_uInt32 nMask = 1 << PPT_CharAttr_Font; |
| sal_uInt32 bDoNotMake = pCharSet->mnAttrSet & nMask; |
| |
| if ( bDoNotMake ) |
| bDoNotMake = nFont == pCharSet->mnFont; |
| |
| if ( !bDoNotMake ) |
| { |
| ImplMakeUnique(); |
| pCharSet->mnFont = nFont; |
| pCharSet->mnAttrSet |= nMask; |
| } |
| } |
| |
| void PPTCharPropSet::SetColor( sal_uInt32 nColor ) |
| { |
| ImplMakeUnique(); |
| pCharSet->mnColor = nColor; |
| pCharSet->mnAttrSet |= 1 << PPT_CharAttr_FontColor; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTRuler::PPTRuler() : |
| nRefCount ( 1 ), |
| nFlags ( 0 ), |
| pTab ( NULL ), |
| nTabCount ( 0 ) |
| { |
| } |
| |
| PPTRuler::~PPTRuler() |
| { |
| delete[] pTab; |
| }; |
| |
| |
| PPTTextRulerInterpreter::PPTTextRulerInterpreter() : |
| mpImplRuler ( new PPTRuler() ) |
| { |
| } |
| |
| PPTTextRulerInterpreter::PPTTextRulerInterpreter( PPTTextRulerInterpreter& rRuler ) |
| { |
| mpImplRuler = rRuler.mpImplRuler; |
| mpImplRuler->nRefCount++; |
| } |
| |
| PPTTextRulerInterpreter::PPTTextRulerInterpreter( sal_uInt32 nFileOfs, SdrPowerPointImport& rMan, DffRecordHeader& rHeader, SvStream& rIn ) : |
| mpImplRuler ( new PPTRuler() ) |
| { |
| if ( nFileOfs != 0xffffffff ) |
| { |
| sal_uInt32 nOldPos = rIn.Tell(); |
| DffRecordHeader rHd; |
| if ( nFileOfs ) |
| { |
| rIn.Seek( nFileOfs ); |
| rIn >> rHd; |
| } |
| else |
| { |
| rHeader.SeekToContent( rIn ); |
| if ( rMan.SeekToRec( rIn, PPT_PST_TextRulerAtom, rHeader.GetRecEndFilePos(), &rHd ) ) |
| nFileOfs++; |
| } |
| if ( nFileOfs ) |
| { |
| sal_Int16 nTCount; |
| sal_Int32 i; |
| rIn >> mpImplRuler->nFlags; |
| if ( mpImplRuler->nFlags & 1 ) |
| rIn >> mpImplRuler->nDefaultTab; |
| if ( mpImplRuler->nFlags & 4 ) |
| { |
| rIn >> nTCount; |
| if ( nTCount ) |
| { |
| mpImplRuler->nTabCount = (sal_uInt16)nTCount; |
| mpImplRuler->pTab = new PPTTabEntry[ mpImplRuler->nTabCount ]; |
| for ( i = 0; i < nTCount; i++ ) |
| { |
| rIn >> mpImplRuler->pTab[ i ].nOffset |
| >> mpImplRuler->pTab[ i ].nStyle; |
| } |
| } |
| } |
| for ( i = 0; i < 5; i++ ) |
| { |
| if ( mpImplRuler->nFlags & ( 8 << i ) ) |
| rIn >> mpImplRuler->nTextOfs[ i ]; |
| if ( mpImplRuler->nFlags & ( 256 << i ) ) |
| rIn >> mpImplRuler->nBulletOfs[ i ]; |
| } |
| } |
| rIn.Seek( nOldPos ); |
| } |
| } |
| |
| sal_Bool PPTTextRulerInterpreter::GetDefaultTab( sal_uInt32 /*nLevel*/, sal_uInt16& nValue ) const |
| { |
| if ( ! ( mpImplRuler->nFlags & 1 ) ) |
| return sal_False; |
| nValue = mpImplRuler->nDefaultTab; |
| return sal_True; |
| } |
| |
| sal_Bool PPTTextRulerInterpreter::GetTextOfs( sal_uInt32 nLevel, sal_uInt16& nValue ) const |
| { |
| if ( ! ( ( nLevel < 5 ) && ( mpImplRuler->nFlags & ( 8 << nLevel ) ) ) ) |
| return sal_False; |
| nValue = mpImplRuler->nTextOfs[ nLevel ]; |
| return sal_True; |
| } |
| |
| sal_Bool PPTTextRulerInterpreter::GetBulletOfs( sal_uInt32 nLevel, sal_uInt16& nValue ) const |
| { |
| if ( ! ( ( nLevel < 5 ) && ( mpImplRuler->nFlags & ( 256 << nLevel ) ) ) ) |
| return sal_False; |
| nValue = mpImplRuler->nBulletOfs[ nLevel ]; |
| return sal_True; |
| } |
| |
| PPTTextRulerInterpreter& PPTTextRulerInterpreter::operator=( PPTTextRulerInterpreter& rRuler ) |
| { |
| if ( this != &rRuler ) |
| { |
| if ( ! ( --mpImplRuler->nRefCount ) ) |
| delete mpImplRuler; |
| mpImplRuler = rRuler.mpImplRuler; |
| mpImplRuler->nRefCount++; |
| } |
| return *this; |
| } |
| |
| PPTTextRulerInterpreter::~PPTTextRulerInterpreter() |
| { |
| if ( ! ( --mpImplRuler->nRefCount ) ) |
| delete mpImplRuler; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTTextCharacterStyleAtomInterpreter::PPTTextCharacterStyleAtomInterpreter() : |
| nFlags1 ( 0 ), |
| nFlags2 ( 0 ), |
| nFlags3 ( 0 ) |
| { |
| } |
| |
| sal_Bool PPTTextCharacterStyleAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd ) |
| { |
| rRecHd.SeekToContent( rIn ); |
| |
| rIn >> nFlags1 |
| >> nFlags2 |
| >> nFlags3 |
| >> n1 |
| >> nFontHeight |
| >> nFontColor; |
| |
| return sal_True; |
| } |
| |
| PPTTextCharacterStyleAtomInterpreter::~PPTTextCharacterStyleAtomInterpreter() |
| { |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| PPTTextParagraphStyleAtomInterpreter::PPTTextParagraphStyleAtomInterpreter() : |
| bValid ( sal_False ), |
| bForbiddenRules ( sal_False ), |
| bHangingPunctuation ( sal_False ), |
| bLatinTextWrap ( sal_False ) |
| { |
| } |
| |
| sal_Bool PPTTextParagraphStyleAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd ) |
| { |
| bValid = sal_False; |
| rRecHd.SeekToContent( rIn ); |
| sal_uInt32 nDummy32, nFlags, nRecEndPos = rRecHd.GetRecEndFilePos(); |
| sal_uInt16 nDummy16; |
| |
| rIn >> nDummy16 |
| >> nFlags; |
| |
| if ( nFlags & 0xf && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // BuFlags |
| if ( nFlags & 0x80 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // BuChar |
| if ( nFlags & 0x10 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // nBuFont; |
| if ( nFlags & 0x40 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // nBuHeight; |
| if ( nFlags & 0x0020 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy32; // nBuColor; |
| if ( nFlags & 0x800 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // AbsJust! |
| if ( nFlags & 0x400 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; |
| if ( nFlags & 0x200 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; |
| if ( nFlags & 0x100 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; |
| if ( nFlags & 0x1000 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // LineFeed |
| if ( nFlags & 0x2000 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // nUpperDist |
| if ( nFlags & 0x4000 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; // nLowerDist |
| if ( nFlags & 0x8000 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; |
| if ( nFlags & 0x10000 && ( rIn.Tell() < nRecEndPos ) ) |
| rIn >> nDummy16; |
| if ( nFlags & 0xe0000 && ( rIn.Tell() < nRecEndPos ) ) |
| { |
| rIn >> nDummy16; |
| if ( nFlags & 0x20000 ) |
| bForbiddenRules = ( nDummy16 & 1 ) == 1; |
| if ( nFlags & 0x40000 ) |
| bLatinTextWrap = ( nDummy16 & 2 ) == 0; |
| if ( nFlags & 0x80000 ) |
| bHangingPunctuation = ( nDummy16 & 4 ) == 4; |
| } |
| nFlags &=~ 0xfffff; |
| sal_uInt32 nMask = 0x100000; |
| while ( nFlags && nMask && ( rIn.Tell() < nRecEndPos ) ) |
| { |
| if ( nFlags & nMask ) |
| { |
| rIn >> nDummy16; |
| nFlags ^= nMask; |
| } |
| nMask <<= 1; |
| } |
| bValid = rIn.Tell() == nRecEndPos; |
| return bValid; |
| } |
| |
| PPTTextParagraphStyleAtomInterpreter::~PPTTextParagraphStyleAtomInterpreter() |
| { |
| |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| PPTTextSpecInfo::PPTTextSpecInfo( sal_uInt32 _nCharIdx ) : |
| nCharIdx ( _nCharIdx ), |
| nDontKnow ( 1 ) |
| { |
| nLanguage[ 0 ] = 0x400; |
| nLanguage[ 1 ] = 0; |
| nLanguage[ 2 ] = 0; |
| } |
| |
| PPTTextSpecInfo::~PPTTextSpecInfo() |
| { |
| } |
| |
| PPTTextSpecInfoAtomInterpreter::PPTTextSpecInfoAtomInterpreter() : |
| bValid ( sal_False ) |
| { |
| } |
| |
| sal_Bool PPTTextSpecInfoAtomInterpreter::Read( SvStream& rIn, const DffRecordHeader& rRecHd, |
| sal_uInt16 nRecordType, const PPTTextSpecInfo* pTextSpecDefault ) |
| { |
| bValid = sal_False; |
| sal_uInt32 nCharIdx = 0; |
| rRecHd.SeekToContent( rIn ); |
| |
| while ( rIn.Tell() < rRecHd.GetRecEndFilePos() ) |
| { |
| sal_uInt32 nCharCount, |
| nFlags, i; |
| |
| if ( nRecordType == PPT_PST_TextSpecInfoAtom ) |
| { |
| rIn >> nCharCount; |
| nCharIdx += nCharCount; |
| } |
| rIn >> nFlags; |
| |
| PPTTextSpecInfo* pEntry = new PPTTextSpecInfo( nCharIdx ); |
| if ( pTextSpecDefault ) |
| { |
| pEntry->nDontKnow = pTextSpecDefault->nDontKnow; |
| pEntry->nLanguage[ 0 ] = pTextSpecDefault->nLanguage[ 0 ]; |
| pEntry->nLanguage[ 1 ] = pTextSpecDefault->nLanguage[ 1 ]; |
| pEntry->nLanguage[ 2 ] = pTextSpecDefault->nLanguage[ 2 ]; |
| } |
| for ( i = 1; nFlags && i ; i <<= 1 ) |
| { |
| sal_uInt16 nLang = 0; |
| switch( nFlags & i ) |
| { |
| case 0 : break; |
| case 1 : rIn >> pEntry->nDontKnow; break; |
| case 2 : rIn >> nLang; break; |
| case 4 : rIn >> nLang; break; |
| default : |
| { |
| rIn.SeekRel( 2 ); |
| } |
| } |
| if ( nLang ) |
| { |
| // bug119985 2012.06.14 |
| if (i == 2) |
| { |
| pEntry->nLanguage[ 0 ] = pEntry->nLanguage[ 1 ] = pEntry->nLanguage[ 2 ] = nLang; |
| } |
| } |
| nFlags &= ~i; |
| } |
| aList.Insert( pEntry, LIST_APPEND ); |
| } |
| bValid = rIn.Tell() == rRecHd.GetRecEndFilePos(); |
| return bValid; |
| } |
| |
| PPTTextSpecInfoAtomInterpreter::~PPTTextSpecInfoAtomInterpreter() |
| { |
| void *pPtr; |
| for ( pPtr = aList.First(); pPtr; pPtr = aList.Next() ) |
| delete (PPTTextSpecInfo*)pPtr; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| void StyleTextProp9::Read( SvStream& rIn ) |
| { |
| rIn >> mnExtParagraphMask; |
| if ( mnExtParagraphMask & 0x800000 ) |
| rIn >> mnBuBlip; |
| if ( mnExtParagraphMask & 0x2000000 ) |
| rIn >> mnHasAnm; |
| if ( mnExtParagraphMask & 0x1000000 ) |
| rIn >> mnAnmScheme; |
| if ( mnExtParagraphMask & 0x4000000 ) |
| rIn >> mpfPP10Ext; |
| rIn >> mnExtCharacterMask; |
| if ( mnExtCharacterMask & 0x100000 ) |
| rIn >> mncfPP10Ext; |
| rIn >> mnSpecialInfoMask; |
| if ( mnSpecialInfoMask & 0x20 ) |
| rIn >> mnPP10Ext; |
| if ( mnSpecialInfoMask & 0x40 ) |
| rIn >> mfBidi; |
| } |
| |
| PPTStyleTextPropReader::PPTStyleTextPropReader( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader, |
| PPTTextRulerInterpreter& rRuler, const DffRecordHeader& rExtParaHd, sal_uInt32 nInstance ) |
| { |
| Init(rIn, rMan, rTextHeader, rRuler, rExtParaHd, nInstance); |
| } |
| |
| void PPTStyleTextPropReader::ReadParaProps( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader, |
| const String& aString, PPTTextRulerInterpreter& rRuler, |
| sal_uInt32& nCharCount, sal_Bool& bTextPropAtom ) |
| { |
| sal_uInt32 nMask = 0; //TODO: nMask initialized here to suppress warning for now, see corresponding TODO below |
| sal_uInt32 nCharAnzRead = 0; |
| sal_uInt16 nDummy16; |
| |
| sal_uInt16 nStringLen = aString.Len(); |
| |
| DffRecordHeader aTextHd2; |
| rTextHeader.SeekToContent( rIn ); |
| if ( rMan.SeekToRec( rIn, PPT_PST_StyleTextPropAtom, rTextHeader.GetRecEndFilePos(), &aTextHd2 ) ) |
| bTextPropAtom = sal_True; |
| while ( nCharAnzRead <= nStringLen ) |
| { |
| PPTParaPropSet aParaPropSet; |
| ImplPPTParaPropSet& aSet = *aParaPropSet.pParaSet; |
| if ( bTextPropAtom ) |
| { |
| rIn >> nCharCount |
| >> aParaPropSet.pParaSet->mnDepth; // Einruecktiefe |
| |
| aParaPropSet.pParaSet->mnDepth = // taking care of about using not more than 9 outliner levels |
| std::min(sal_uInt16(8), |
| aParaPropSet.pParaSet->mnDepth); |
| |
| nCharCount--; |
| |
| rIn >> nMask; |
| aSet.mnAttrSet = nMask & 0x207df7; |
| sal_uInt16 nBulFlg = 0; |
| if ( nMask & 0xF ) |
| rIn >> nBulFlg; // Bullet-HardAttr-Flags |
| aSet.mpArry[ PPT_ParaAttr_BulletOn ] = ( nBulFlg & 1 ) ? 1 : 0; |
| aSet.mpArry[ PPT_ParaAttr_BuHardFont ] = ( nBulFlg & 2 ) ? 1 : 0; |
| aSet.mpArry[ PPT_ParaAttr_BuHardColor ] = ( nBulFlg & 4 ) ? 1 : 0; |
| |
| if ( nMask & 0x0080 ) // buChar |
| rIn >> aSet.mpArry[ PPT_ParaAttr_BulletChar ]; |
| if ( nMask & 0x0010 ) // buTypeface |
| rIn >> aSet.mpArry[ PPT_ParaAttr_BulletFont ]; |
| if ( nMask & 0x0040 ) // buSize |
| { |
| rIn >> aSet.mpArry[ PPT_ParaAttr_BulletHeight ]; |
| if ( ! ( ( nMask & ( 1 << PPT_ParaAttr_BuHardHeight ) ) |
| && ( nBulFlg & ( 1 << PPT_ParaAttr_BuHardHeight ) ) ) ) |
| aSet.mnAttrSet ^= 0x40; |
| } |
| if ( nMask & 0x0020 ) // buColor |
| { |
| sal_uInt32 nVal32, nHiByte; |
| rIn >> nVal32; |
| nHiByte = nVal32 >> 24; |
| if ( nHiByte <= 8 ) |
| nVal32 = nHiByte | PPT_COLSCHEME; |
| aSet.mnBulletColor = nVal32; |
| } |
| if ( nMask & 0x0800 ) // pfAlignment |
| { |
| rIn >> nDummy16; |
| aSet.mpArry[ PPT_ParaAttr_Adjust ] = nDummy16 & 3; |
| } |
| if ( nMask & 0x1000 ) // pfLineSpacing |
| rIn >> aSet.mpArry[ PPT_ParaAttr_LineFeed ]; |
| if ( nMask & 0x2000 ) // pfSpaceBefore |
| rIn >> aSet.mpArry[ PPT_ParaAttr_UpperDist ]; |
| if ( nMask & 0x4000 ) // pfSpaceAfter |
| rIn >> aSet.mpArry[ PPT_ParaAttr_LowerDist ]; |
| if ( nMask & 0x100 ) // pfLeftMargin |
| { |
| rIn >> aSet.mpArry[ PPT_ParaAttr_TextOfs ]; |
| aSet.mnAttrSet |= 1 << PPT_ParaAttr_TextOfs; |
| } |
| if ( nMask & 0x400 ) // pfIndent |
| { |
| rIn >> aSet.mpArry[ PPT_ParaAttr_BulletOfs ]; |
| aSet.mnAttrSet |= 1 << PPT_ParaAttr_BulletOfs; |
| } |
| if ( nMask & 0x8000 ) // pfDefaultTabSize |
| rIn >> nDummy16; |
| if ( nMask & 0x100000 ) // pfTabStops |
| { |
| sal_uInt16 i, nDistance, nAlignment, nNumberOfTabStops = 0; |
| rIn >> nNumberOfTabStops; |
| for ( i = 0; i < nNumberOfTabStops; i++ ) |
| { |
| rIn >> nDistance |
| >> nAlignment; |
| } |
| } |
| if ( nMask & 0x10000 ) // pfBaseLine |
| rIn >> nDummy16; |
| if ( nMask & 0xe0000 ) // pfCharWrap, pfWordWrap, pfOverflow |
| { |
| rIn >> nDummy16; |
| if ( nMask & 0x20000 ) |
| aSet.mpArry[ PPT_ParaAttr_AsianLB_1 ] = nDummy16 & 1; |
| if ( nMask & 0x40000 ) |
| aSet.mpArry[ PPT_ParaAttr_AsianLB_2 ] = ( nDummy16 >> 1 ) & 1; |
| if ( nMask & 0x80000 ) |
| aSet.mpArry[ PPT_ParaAttr_AsianLB_3 ] = ( nDummy16 >> 2 ) & 1; |
| aSet.mnAttrSet |= ( ( nMask >> 17 ) & 7 ) << PPT_ParaAttr_AsianLB_1; |
| } |
| if ( nMask & 0x200000 ) // pfTextDirection |
| rIn >> aSet.mpArry[ PPT_ParaAttr_BiDi ]; |
| } |
| else |
| nCharCount = nStringLen; |
| |
| //if the textofs attr has been read at above, need not to reset. |
| if ( ( !( aSet.mnAttrSet & 1 << PPT_ParaAttr_TextOfs ) ) && rRuler.GetTextOfs( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_TextOfs ] ) ) |
| aSet.mnAttrSet |= 1 << PPT_ParaAttr_TextOfs; |
| if ( ( !( aSet.mnAttrSet & 1 << PPT_ParaAttr_BulletOfs ) ) && rRuler.GetBulletOfs( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_BulletOfs ] ) ) |
| aSet.mnAttrSet |= 1 << PPT_ParaAttr_BulletOfs; |
| if ( rRuler.GetDefaultTab( aParaPropSet.pParaSet->mnDepth, aSet.mpArry[ PPT_ParaAttr_DefaultTab ] ) ) |
| aSet.mnAttrSet |= 1 << PPT_ParaAttr_DefaultTab; |
| |
| if ( ( nCharCount > nStringLen ) || ( nStringLen < nCharAnzRead + nCharCount ) ) |
| { |
| bTextPropAtom = sal_False; |
| nCharCount = nStringLen - nCharAnzRead; |
| // please fix the right hand side of |
| // PPTParaPropSet& PPTParaPropSet::operator=(PPTParaPropSet&), |
| // it should be a const reference |
| PPTParaPropSet aTmpPPTParaPropSet; |
| aParaPropSet = aTmpPPTParaPropSet; |
| DBG_ERROR( "SJ:PPTStyleTextPropReader::could not get this PPT_PST_StyleTextPropAtom by reading the paragraph attributes" ); |
| } |
| PPTParaPropSet* pPara = new PPTParaPropSet( aParaPropSet ); |
| pPara->mnOriginalTextPos = nCharAnzRead; |
| aParaPropList.Insert( pPara, LIST_APPEND ); |
| if ( nCharCount ) |
| { |
| sal_uInt32 nCount; |
| const sal_Unicode* pDat = aString.GetBuffer() + nCharAnzRead; |
| for ( nCount = 0; nCount < nCharCount; nCount++ ) |
| { |
| if ( pDat[ nCount ] == 0xd ) |
| { |
| pPara = new PPTParaPropSet( aParaPropSet ); |
| pPara->mnOriginalTextPos = nCharAnzRead + nCount + 1; |
| aParaPropList.Insert( pPara, LIST_APPEND ); |
| } |
| } |
| } |
| nCharAnzRead += nCharCount + 1; |
| } |
| } |
| |
| void PPTStyleTextPropReader::ReadCharProps( SvStream& rIn, PPTCharPropSet& aCharPropSet, const String& aString, |
| sal_uInt32& nCharCount, sal_uInt32 nCharAnzRead, |
| sal_Bool& bTextPropAtom, sal_uInt32 nExtParaPos, |
| const std::vector< StyleTextProp9 >& aStyleTextProp9, |
| sal_uInt32& nExtParaFlags, sal_uInt16& nBuBlip, |
| sal_uInt16& nHasAnm, sal_uInt32& nAnmScheme ) |
| { |
| sal_uInt32 nMask = 0; //TODO: nMask initialized here to suppress warning for now, see corresponding TODO below |
| sal_uInt16 nDummy16; |
| sal_Int32 nCharsToRead; |
| sal_uInt32 nExtParaNibble = 0; |
| |
| sal_uInt16 nStringLen = aString.Len(); |
| |
| rIn >> nDummy16; |
| nCharCount = nDummy16; |
| rIn >> nDummy16; |
| nCharsToRead = nStringLen - ( nCharAnzRead + nCharCount ); |
| if ( nCharsToRead < 0 ) |
| { |
| nCharCount = nStringLen - nCharAnzRead; |
| if ( nCharsToRead < -1 ) |
| { |
| bTextPropAtom = sal_False; |
| DBG_ERROR( "SJ:PPTStyleTextPropReader::could not get this PPT_PST_StyleTextPropAtom by reading the character attributes" ); |
| } |
| } |
| ImplPPTCharPropSet& aSet = *aCharPropSet.pCharSet; |
| |
| // character attributes |
| rIn >> nMask; |
| if ( (sal_uInt16)nMask ) |
| { |
| aSet.mnAttrSet |= (sal_uInt16)nMask; |
| rIn >> aSet.mnFlags; |
| } |
| if ( nMask & 0x10000 ) // cfTypeface |
| { |
| rIn >> aSet.mnFont; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_Font; |
| } |
| if ( nMask & 0x200000 ) // cfFEOldTypeface |
| { |
| rIn >> aSet.mnAsianOrComplexFont; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_AsianOrComplexFont; |
| } |
| if ( nMask & 0x400000 ) // cfANSITypeface |
| { |
| rIn >> aSet.mnANSITypeface; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_ANSITypeface; |
| } |
| if ( nMask & 0x800000 ) // cfSymbolTypeface |
| { |
| rIn >> aSet.mnSymbolFont; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_Symbol; |
| } |
| if ( nMask & 0x20000 ) // cfSize |
| { |
| rIn >> aSet.mnFontHeight; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_FontHeight; |
| } |
| if ( nMask & 0x40000 ) // cfColor |
| { |
| sal_uInt32 nVal; |
| rIn >> nVal; |
| if ( !( nVal & 0xff000000 ) ) |
| nVal = PPT_COLSCHEME_HINTERGRUND; |
| aSet.mnColor = nVal; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_FontColor; |
| } |
| if ( nMask & 0x80000 ) // cfPosition |
| { |
| rIn >> aSet.mnEscapement; |
| aSet.mnAttrSet |= 1 << PPT_CharAttr_Escapement; |
| } |
| if ( nExtParaPos ) |
| { |
| sal_uInt32 nExtBuInd = nMask & 0x3c00; |
| if ( nExtBuInd ) |
| nExtBuInd = ( aSet.mnFlags & 0x3c00 ) >> 10; |
| if ( nExtBuInd < aStyleTextProp9.size() ) |
| { |
| if ( nExtParaNibble && ( ( nExtBuInd + nExtParaNibble ) < aStyleTextProp9.size() ) ) |
| nExtBuInd += nExtParaNibble; |
| |
| nExtParaFlags = aStyleTextProp9[ nExtBuInd ].mnExtParagraphMask; |
| nBuBlip = aStyleTextProp9[ nExtBuInd ].mnBuBlip; |
| nHasAnm = aStyleTextProp9[ nExtBuInd ].mnHasAnm; |
| nAnmScheme = aStyleTextProp9[ nExtBuInd ].mnAnmScheme; |
| } |
| if ( ( nExtBuInd & 0xf ) == 0xf ) |
| nExtParaNibble += 16; |
| } |
| } |
| |
| void PPTStyleTextPropReader::Init( SvStream& rIn, SdrPowerPointImport& rMan, const DffRecordHeader& rTextHeader, |
| PPTTextRulerInterpreter& rRuler, const DffRecordHeader& rExtParaHd, sal_uInt32 nInstance ) |
| { |
| sal_uInt32 nMerk = rIn.Tell(); |
| sal_uInt32 nExtParaPos = ( rExtParaHd.nRecType == PPT_PST_ExtendedParagraphAtom ) ? rExtParaHd.nFilePos + 8 : 0; |
| |
| std::vector< StyleTextProp9 > aStyleTextProp9; |
| if ( rExtParaHd.nRecType == PPT_PST_ExtendedParagraphAtom ) |
| { |
| rIn.Seek( rExtParaHd.nFilePos + 8 ); |
| while( ( rIn.GetError() == 0 ) && ( rIn.Tell() < rExtParaHd.GetRecEndFilePos() ) ) |
| { |
| aStyleTextProp9.resize( aStyleTextProp9.size() + 1 ); |
| aStyleTextProp9.back().Read( rIn ); |
| } |
| rIn.Seek( nMerk ); |
| } |
| |
| String aString; |
| DffRecordHeader aTextHd; |
| rIn >> aTextHd; |
| sal_uInt32 nMaxLen = aTextHd.nRecLen; |
| if ( nMaxLen >= 0xFFFF ) |
| nMaxLen = 0xFFFE; |
| |
| if( aTextHd.nRecType == PPT_PST_TextCharsAtom ) |
| { |
| sal_uInt32 i; |
| sal_Unicode nChar,*pBuf = new sal_Unicode[ ( nMaxLen >> 1 ) + 1 ]; |
| rIn.Read( pBuf, nMaxLen ); |
| nMaxLen >>= 1; |
| pBuf[ nMaxLen ] = 0; |
| sal_Unicode* pPtr = pBuf; |
| #ifdef OSL_BIGENDIAN |
| sal_Unicode nTemp; |
| for ( i = 0; i < nMaxLen; i++ ) |
| { |
| nTemp = *pPtr; |
| *pPtr++ = ( nTemp << 8 ) | ( nTemp >> 8 ); |
| } |
| pPtr = pBuf; |
| #endif |
| |
| for ( i = 0; i < nMaxLen; pPtr++, i++ ) |
| { |
| nChar = *pPtr; |
| if ( !nChar ) |
| break; |
| if ( ( nChar & 0xff00 ) == 0xf000 ) // in this special case we got a symbol |
| aSpecMarkerList.Insert( (void*)( i | PPT_SPEC_SYMBOL ), LIST_APPEND ); |
| else if ( nChar == 0xd ) |
| { |
| if ( nInstance == TSS_TYPE_PAGETITLE ) |
| *pPtr = 0xb; |
| else |
| aSpecMarkerList.Insert( (void*)( i | PPT_SPEC_NEWLINE ), LIST_APPEND ); |
| } |
| } |
| if ( i ) |
| aString = String( pBuf, (sal_uInt16)i ); |
| delete[] pBuf; |
| } |
| else if( aTextHd.nRecType == PPT_PST_TextBytesAtom ) |
| { |
| sal_Char *pBuf = new sal_Char[ nMaxLen + 1 ]; |
| pBuf[ nMaxLen ] = 0; |
| rIn.Read( pBuf, nMaxLen ); |
| sal_Char* pPtr = pBuf; |
| for (;;) |
| { |
| sal_Char cLo = *pPtr; |
| if ( cLo == 0 ) |
| break; |
| if ( cLo == 0xd ) |
| { |
| if ( nInstance == TSS_TYPE_PAGETITLE ) |
| *pPtr = 0xb; |
| else |
| aSpecMarkerList.Insert( (void*)( (pPtr - pBuf) | PPT_SPEC_NEWLINE ), LIST_APPEND ); |
| } |
| pPtr++; |
| } |
| xub_StrLen nLen = sal::static_int_cast< xub_StrLen >( pPtr - pBuf ); |
| if ( nLen ) |
| aString = String( pBuf, nLen, RTL_TEXTENCODING_MS_1252 ); |
| delete[] pBuf; |
| } |
| else |
| { |
| // no chars, but potentially char/para props? |
| sal_uInt32 nCharCount; |
| sal_Bool bTextPropAtom = sal_False; |
| ReadParaProps( rIn, rMan, rTextHeader, aString, rRuler, nCharCount, bTextPropAtom ); |
| |
| if ( bTextPropAtom ) |
| { |
| // yeah, StyleTextProp is there, read it all & push to |
| // aParaPropList |
| PPTCharPropSet aCharPropSet(0); |
| aCharPropSet.mnOriginalTextPos = 0; |
| |
| sal_uInt32 nCharAnzRead = 0; |
| sal_uInt32 nExtParaFlags = 0, nAnmScheme = 0; |
| sal_uInt16 nBuBlip = 0xffff, nHasAnm = 0; |
| ReadCharProps( rIn, aCharPropSet, aString, nCharCount, nCharAnzRead, |
| bTextPropAtom, nExtParaPos, aStyleTextProp9, nExtParaFlags, |
| nBuBlip, nHasAnm, nAnmScheme ); |
| |
| aCharPropList.Insert( |
| new PPTCharPropSet( aCharPropSet, 0 ), LIST_APPEND ); |
| } |
| } |
| |
| if ( aString.Len() ) |
| { |
| sal_uInt32 nCharCount; |
| sal_Bool bTextPropAtom = sal_False; |
| |
| ReadParaProps( rIn, rMan, rTextHeader, aString, rRuler, nCharCount, bTextPropAtom ); |
| |
| sal_Bool bEmptyParaPossible = sal_True; |
| sal_uInt32 nCharAnzRead = 0; |
| sal_uInt32 nCurrentPara = 0; |
| sal_uInt32 nCurrentSpecMarker = (sal_uInt32)(sal_uIntPtr)aSpecMarkerList.First(); |
| sal_uInt16 nStringLen = aString.Len(); |
| |
| while ( nCharAnzRead < nStringLen ) |
| { |
| sal_uInt32 nExtParaFlags = 0, nLatestParaUpdate = 0xffffffff, nAnmScheme = 0; |
| sal_uInt16 nBuBlip = 0xffff, nHasAnm = 0; |
| |
| PPTCharPropSet aCharPropSet( nCurrentPara ); |
| if ( bTextPropAtom ) |
| ReadCharProps( rIn, aCharPropSet, aString, nCharCount, nCharAnzRead, |
| bTextPropAtom, nExtParaPos, aStyleTextProp9, nExtParaFlags, |
| nBuBlip, nHasAnm, nAnmScheme ); |
| else |
| nCharCount = nStringLen; |
| |
| sal_uInt32 nLen; |
| while( nCharCount ) |
| { |
| if ( nExtParaPos && ( nLatestParaUpdate != nCurrentPara ) && ( nCurrentPara < aParaPropList.Count() ) ) |
| { |
| PPTParaPropSet* pPropSet = (PPTParaPropSet*)aParaPropList.GetObject( nCurrentPara ); |
| pPropSet->pParaSet->mnExtParagraphMask = nExtParaFlags; |
| if ( nExtParaFlags & 0x800000 ) |
| pPropSet->pParaSet->mnBuBlip = nBuBlip; |
| if ( nExtParaFlags & 0x01000000 ) |
| pPropSet->pParaSet->mnAnmScheme = nAnmScheme; |
| if ( nExtParaFlags & 0x02000000 ) |
| pPropSet->pParaSet->mnHasAnm = nHasAnm; |
| nLatestParaUpdate = nCurrentPara; |
| } |
| aCharPropSet.mnOriginalTextPos = nCharAnzRead; |
| if ( nCurrentSpecMarker && ( ( nCurrentSpecMarker & 0xffff ) < ( nCharAnzRead + nCharCount ) ) ) |
| { |
| if ( nCurrentSpecMarker & PPT_SPEC_NEWLINE ) |
| { |
| nLen = ( nCurrentSpecMarker & 0xffff ) - nCharAnzRead; |
| if ( nLen ) |
| aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nLen ); |
| else if ( bEmptyParaPossible ) |
| aCharPropSet.maString = String(); |
| if ( nLen || bEmptyParaPossible ) |
| aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND ); |
| nCurrentPara++; |
| nLen++; |
| nCharAnzRead += nLen; |
| nCharCount -= nLen; |
| bEmptyParaPossible = sal_True; |
| } |
| else if ( nCurrentSpecMarker & PPT_SPEC_SYMBOL ) |
| { |
| if ( ( nCurrentSpecMarker & 0xffff ) != nCharAnzRead ) |
| { |
| nLen = ( nCurrentSpecMarker & 0xffff ) - nCharAnzRead; |
| aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nLen ); |
| aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND ); |
| nCharCount -= nLen; |
| nCharAnzRead += nLen; |
| } |
| PPTCharPropSet* pCPropSet = new PPTCharPropSet( aCharPropSet, nCurrentPara ); |
| pCPropSet->maString = aString.GetChar( (sal_uInt16)nCharAnzRead ); |
| if ( aCharPropSet.pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_Symbol ) ) |
| pCPropSet->SetFont( aCharPropSet.pCharSet->mnSymbolFont ); |
| aCharPropList.Insert( pCPropSet, LIST_APPEND ); |
| nCharCount--; |
| nCharAnzRead++; |
| bEmptyParaPossible = sal_False; |
| } |
| nCurrentSpecMarker = (sal_uInt32)(sal_uIntPtr)aSpecMarkerList.Next(); |
| } |
| else |
| { |
| aCharPropSet.maString = String( aString, (sal_uInt16)nCharAnzRead, (sal_uInt16)nCharCount ); |
| aCharPropList.Insert( new PPTCharPropSet( aCharPropSet, nCurrentPara ), LIST_APPEND ); |
| nCharAnzRead += nCharCount; |
| bEmptyParaPossible = sal_False; |
| break; |
| } |
| } |
| } |
| if ( aCharPropList.Count() && ( ((PPTCharPropSet*)aCharPropList.Last())->mnParagraph != nCurrentPara ) ) |
| { |
| PPTCharPropSet* pCharPropSet = new PPTCharPropSet( *(PPTCharPropSet*)aCharPropList.Last(), nCurrentPara ); |
| pCharPropSet->maString = String(); |
| pCharPropSet->mnOriginalTextPos = nStringLen - 1; |
| aCharPropList.Insert( pCharPropSet, LIST_APPEND ); |
| } |
| } |
| rIn.Seek( nMerk ); |
| } |
| |
| PPTStyleTextPropReader::~PPTStyleTextPropReader() |
| { |
| void* pTmp; |
| for ( pTmp = aParaPropList.First(); pTmp; pTmp = aParaPropList.Next() ) |
| delete (PPTParaPropSet*)pTmp; |
| for ( pTmp = aCharPropList.First(); pTmp; pTmp = aCharPropList.Next() ) |
| delete (PPTCharPropSet*)pTmp; |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| struct FieldEntry |
| { |
| sal_uInt32 nFieldType; |
| sal_uInt32 nFieldStartPos; |
| sal_uInt32 nFieldEndPos; |
| String aFieldUrl; |
| |
| FieldEntry( sal_uInt32 nType, sal_uInt32 nStart, sal_uInt32 nEnd ) |
| { |
| nFieldType = nType; |
| nFieldStartPos = nStart; |
| nFieldEndPos = nEnd; |
| } |
| FieldEntry( FieldEntry& rFieldEntry ) |
| { |
| nFieldType = rFieldEntry.nFieldType; |
| nFieldStartPos = rFieldEntry.nFieldStartPos; |
| nFieldEndPos = rFieldEntry.nFieldEndPos; |
| aFieldUrl = rFieldEntry.aFieldUrl; |
| } |
| }; |
| |
| |
| PPTPortionObj::PPTPortionObj( const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt32 nDepth ) : |
| PPTCharPropSet ( 0 ), |
| mrStyleSheet ( rStyleSheet ), |
| mnInstance ( nInstance ), |
| mnDepth ( ( nDepth > 4 ) ? 4 : nDepth ) |
| { |
| } |
| |
| PPTPortionObj::PPTPortionObj( PPTCharPropSet& rCharPropSet, const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt32 nDepth ) : |
| PPTCharPropSet ( rCharPropSet ), |
| mrStyleSheet ( rStyleSheet ), |
| mnInstance ( nInstance ), |
| mnDepth ( nDepth ) |
| { |
| } |
| |
| PPTPortionObj::PPTPortionObj( PPTPortionObj& rPortionObj ) : |
| PPTCharPropSet ( rPortionObj ), |
| mrStyleSheet ( rPortionObj.mrStyleSheet ), |
| mnInstance ( rPortionObj.mnInstance ), |
| mnDepth ( rPortionObj.mnDepth ) |
| { |
| } |
| |
| PPTPortionObj::~PPTPortionObj() |
| { |
| } |
| |
| sal_Bool PPTPortionObj::HasTabulator() |
| { |
| sal_Bool bRetValue = sal_False; |
| sal_Int32 nCount; |
| const sal_Unicode* pPtr = maString.GetBuffer(); |
| for ( nCount = 0; nCount < maString.Len(); nCount++ ) |
| { |
| if ( pPtr[ nCount ] == 0x9 ) |
| { |
| bRetValue = sal_True; |
| break; |
| } |
| |
| } |
| return bRetValue; |
| } |
| |
| sal_Bool PPTPortionObj::GetAttrib( sal_uInt32 nAttr, sal_uInt32& nRetValue, sal_uInt32 nDestinationInstance ) |
| { |
| sal_uInt32 nMask = 1 << nAttr; |
| nRetValue = 0; |
| |
| sal_uInt32 bIsHardAttribute = ( ( pCharSet->mnAttrSet & nMask ) != 0 ) ? 1 : 0; |
| |
| if ( bIsHardAttribute ) |
| { |
| switch ( nAttr ) |
| { |
| case PPT_CharAttr_Bold : |
| case PPT_CharAttr_Italic : |
| case PPT_CharAttr_Underline : |
| case PPT_CharAttr_Shadow : |
| case PPT_CharAttr_Strikeout : |
| case PPT_CharAttr_Embossed : |
| nRetValue = ( pCharSet->mnFlags & nMask ) ? 1 : 0; |
| break; |
| case PPT_CharAttr_Font : |
| nRetValue = pCharSet->mnFont; |
| break; |
| case PPT_CharAttr_AsianOrComplexFont : |
| nRetValue = pCharSet->mnAsianOrComplexFont; |
| break; |
| case PPT_CharAttr_FontHeight : |
| nRetValue = pCharSet->mnFontHeight; |
| break; |
| case PPT_CharAttr_FontColor : |
| nRetValue = pCharSet->mnColor; |
| break; |
| case PPT_CharAttr_Escapement : |
| nRetValue = pCharSet->mnEscapement; |
| break; |
| default : |
| DBG_ERROR( "SJ:PPTPortionObj::GetAttrib ( hard attribute does not exist )" ); |
| } |
| } |
| else |
| { |
| const PPTCharLevel& rCharLevel = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ]; |
| PPTCharLevel* pCharLevel = NULL; |
| if ( ( nDestinationInstance == 0xffffffff ) |
| || ( mnDepth && ( ( mnInstance == TSS_TYPE_SUBTITLE ) || ( mnInstance == TSS_TYPE_TEXT_IN_SHAPE ) ) ) ) |
| bIsHardAttribute = 1; |
| else if ( nDestinationInstance != mnInstance ) |
| pCharLevel = &mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ mnDepth ]; |
| switch( nAttr ) |
| { |
| case PPT_CharAttr_Bold : |
| case PPT_CharAttr_Italic : |
| case PPT_CharAttr_Underline : |
| case PPT_CharAttr_Shadow : |
| case PPT_CharAttr_Strikeout : |
| case PPT_CharAttr_Embossed : |
| { |
| nRetValue = ( rCharLevel.mnFlags & nMask ) ? 1 : 0; |
| if ( pCharLevel ) |
| { |
| sal_uInt32 nTmp = ( pCharLevel->mnFlags & nMask ) ? 1 : 0; |
| if ( nRetValue != nTmp ) |
| bIsHardAttribute = 1; |
| } |
| } |
| break; |
| case PPT_CharAttr_Font : |
| { |
| nRetValue = rCharLevel.mnFont; |
| if ( pCharLevel && ( nRetValue != pCharLevel->mnFont ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_CharAttr_AsianOrComplexFont : |
| { |
| nRetValue = rCharLevel.mnAsianOrComplexFont; |
| if ( pCharLevel && ( nRetValue != pCharLevel->mnAsianOrComplexFont ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_CharAttr_FontHeight : |
| { |
| nRetValue = rCharLevel.mnFontHeight; |
| if ( pCharLevel && ( nRetValue != pCharLevel->mnFontHeight ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_CharAttr_FontColor : |
| { |
| nRetValue = rCharLevel.mnFontColor; |
| if ( pCharLevel && ( nRetValue != pCharLevel->mnFontColor ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_CharAttr_Escapement : |
| { |
| nRetValue = rCharLevel.mnEscapement; |
| if ( pCharLevel && ( nRetValue != pCharLevel->mnEscapement ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| default : |
| DBG_ERROR( "SJ:PPTPortionObj::GetAttrib ( attribute does not exist )" ); |
| } |
| } |
| return (sal_Bool)bIsHardAttribute; |
| } |
| |
| void PPTPortionObj::ApplyTo( SfxItemSet& rSet, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance ) |
| { |
| ApplyTo( rSet, rManager, nDestinationInstance, NULL ); |
| } |
| |
| void PPTPortionObj::ApplyTo( SfxItemSet& rSet, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance, const PPTTextObj* pTextObj ) |
| { |
| sal_uInt32 nVal; |
| if ( GetAttrib( PPT_CharAttr_Bold, nVal, nDestinationInstance ) ) |
| { |
| rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT ) ); |
| rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT_CJK ) ); |
| rSet.Put( SvxWeightItem( nVal != 0 ? WEIGHT_BOLD : WEIGHT_NORMAL, EE_CHAR_WEIGHT_CTL ) ); |
| } |
| if ( GetAttrib( PPT_CharAttr_Italic, nVal, nDestinationInstance ) ) |
| { |
| rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC ) ); |
| rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC_CJK ) ); |
| rSet.Put( SvxPostureItem( nVal != 0 ? ITALIC_NORMAL : ITALIC_NONE, EE_CHAR_ITALIC_CTL ) ); |
| } |
| if ( GetAttrib( PPT_CharAttr_Underline, nVal, nDestinationInstance ) ) |
| rSet.Put( SvxUnderlineItem( nVal != 0 ? UNDERLINE_SINGLE : UNDERLINE_NONE, EE_CHAR_UNDERLINE ) ); |
| |
| if ( GetAttrib( PPT_CharAttr_Shadow, nVal, nDestinationInstance ) ) |
| rSet.Put( SvxShadowedItem( nVal != 0, EE_CHAR_SHADOW ) ); |
| |
| if ( GetAttrib( PPT_CharAttr_Strikeout, nVal, nDestinationInstance ) ) |
| rSet.Put( SvxCrossedOutItem( nVal != 0 ? STRIKEOUT_SINGLE : STRIKEOUT_NONE, EE_CHAR_STRIKEOUT ) ); |
| |
| sal_uInt32 nAsianFontId = 0xffff; |
| if ( GetAttrib( PPT_CharAttr_AsianOrComplexFont, nAsianFontId, nDestinationInstance ) ) |
| { |
| if ( nAsianFontId != 0xffff ) |
| { |
| PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nAsianFontId ); |
| if ( pFontEnityAtom ) |
| { |
| rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, |
| String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CJK ) ); |
| rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, |
| String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CTL ) ); |
| } |
| } |
| } |
| if ( GetAttrib( PPT_CharAttr_Font, nVal, nDestinationInstance ) ) |
| { |
| PptFontEntityAtom* pFontEnityAtom = rManager.GetFontEnityAtom( nVal ); |
| if ( pFontEnityAtom ) |
| { |
| rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO ) ); |
| |
| // #119475# bullet font info for CJK and CTL |
| if ( RTL_TEXTENCODING_SYMBOL == pFontEnityAtom->eCharSet ) |
| { |
| rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CJK ) ); |
| rSet.Put( SvxFontItem( pFontEnityAtom->eFamily, pFontEnityAtom->aName, String(), pFontEnityAtom->ePitch, pFontEnityAtom->eCharSet, EE_CHAR_FONTINFO_CTL ) ); |
| } |
| } |
| } |
| if ( GetAttrib( PPT_CharAttr_FontHeight, nVal, nDestinationInstance ) ) // Schriftgrad in Point |
| { |
| sal_uInt32 nHeight = rManager.ScalePoint( nVal ); |
| rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT ) ); |
| rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CJK ) ); |
| rSet.Put( SvxFontHeightItem( nHeight, 100, EE_CHAR_FONTHEIGHT_CTL ) ); |
| } |
| |
| if ( GetAttrib( PPT_CharAttr_Embossed, nVal, nDestinationInstance ) ) |
| rSet.Put( SvxCharReliefItem( nVal != 0 ? RELIEF_EMBOSSED : RELIEF_NONE, EE_CHAR_RELIEF ) ); |
| if ( nVal ) /* if Embossed is set, the font color depends to the fillstyle/color of the object, |
| if the object has no fillstyle, the font color depends to fillstyle of the background */ |
| { |
| Color aDefColor( COL_BLACK ); |
| MSO_FillType eFillType = mso_fillSolid; |
| if ( rManager.GetPropertyValue( DFF_Prop_fNoFillHitTest ) & 0x10 ) |
| eFillType = (MSO_FillType)rManager.GetPropertyValue( DFF_Prop_fillType, mso_fillSolid ); |
| else |
| eFillType = mso_fillBackground; |
| switch( eFillType ) |
| { |
| case mso_fillShade : |
| case mso_fillShadeCenter : |
| case mso_fillShadeShape : |
| case mso_fillShadeScale : |
| case mso_fillShadeTitle : |
| case mso_fillSolid : |
| aDefColor = rManager.MSO_CLR_ToColor( rManager.GetPropertyValue( DFF_Prop_fillColor ) ); |
| break; |
| case mso_fillPattern : |
| aDefColor = rManager.MSO_CLR_ToColor( rManager.GetPropertyValue( DFF_Prop_fillBackColor ) ); |
| break; |
| case mso_fillTexture : |
| { |
| Graphic aGraf; |
| if ( rManager.GetBLIP( rManager.GetPropertyValue( DFF_Prop_fillBlip ), aGraf, NULL ) ) |
| { |
| Bitmap aBmp( aGraf.GetBitmap() ); |
| Size aSize( aBmp.GetSizePixel() ); |
| if ( aSize.Width() && aSize.Height() ) |
| { |
| if ( aSize.Width () > 64 ) |
| aSize.Width () = 64; |
| if ( aSize.Height() > 64 ) |
| aSize.Height() = 64; |
| |
| sal_uLong nRt = 0, nGn = 0, nBl = 0; |
| BitmapReadAccess* pAcc = aBmp.AcquireReadAccess(); |
| if( pAcc ) |
| { |
| const long nWidth = aSize.Width(); |
| const long nHeight = aSize.Height(); |
| |
| if( pAcc->HasPalette() ) |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor& rCol = pAcc->GetPaletteColor( pAcc->GetPixelIndex( nY, nX ) ); |
| nRt+=rCol.GetRed(); nGn+=rCol.GetGreen(); nBl+=rCol.GetBlue(); |
| } |
| } |
| } |
| else |
| { |
| for( long nY = 0L; nY < nHeight; nY++ ) |
| { |
| for( long nX = 0L; nX < nWidth; nX++ ) |
| { |
| const BitmapColor aCol( pAcc->GetPixel( nY, nX ) ); |
| nRt+=aCol.GetRed(); nGn+=aCol.GetGreen(); nBl+=aCol.GetBlue(); |
| } |
| } |
| } |
| aBmp.ReleaseAccess( pAcc ); |
| sal_uInt32 nC = ( aSize.Width() * aSize.Height() ); |
| nRt /= nC; |
| nGn /= nC; |
| nBl /= nC; |
| aDefColor = Color(sal_uInt8( nRt ), sal_uInt8( nGn ),sal_uInt8( nBl ) ); |
| } |
| } |
| } |
| } |
| break; |
| case mso_fillBackground : |
| { |
| if ( pTextObj ) // the textobject is needed |
| { |
| const SfxItemSet* pItemSet = pTextObj->GetBackground(); |
| if ( pItemSet ) |
| { |
| const SfxPoolItem* pFillStyleItem = NULL; |
| pItemSet->GetItemState( XATTR_FILLSTYLE, sal_False, &pFillStyleItem ); |
| if ( pFillStyleItem ) |
| { |
| XFillStyle eFillStyle = ((XFillStyleItem*)pFillStyleItem)->GetValue(); |
| switch( eFillStyle ) |
| { |
| case XFILL_SOLID : |
| { |
| const SfxPoolItem* pFillColorItem = NULL; |
| pItemSet->GetItemState( XATTR_FILLCOLOR, sal_False, &pFillColorItem ); |
| if ( pFillColorItem ) |
| aDefColor = ((XColorItem*)pFillColorItem)->GetColorValue(); |
| } |
| break; |
| case XFILL_GRADIENT : |
| { |
| const SfxPoolItem* pGradientItem = NULL; |
| pItemSet->GetItemState( XATTR_FILLGRADIENT, sal_False, &pGradientItem ); |
| if ( pGradientItem ) |
| aDefColor = ((XFillGradientItem*)pGradientItem)->GetGradientValue().GetStartColor(); |
| } |
| break; |
| case XFILL_HATCH : |
| case XFILL_BITMAP : |
| aDefColor = Color( COL_WHITE ); |
| break; |
| default: break; |
| } |
| } |
| } |
| } |
| } |
| break; |
| // case mso_fillPicture : |
| default: break; |
| } |
| rSet.Put( SvxColorItem( aDefColor, EE_CHAR_COLOR ) ); |
| } |
| else |
| { |
| if ( GetAttrib( PPT_CharAttr_FontColor, nVal, nDestinationInstance ) ) // Textfarbe (4Byte-Arg) |
| { |
| Color aCol( rManager.MSO_TEXT_CLR_ToColor( nVal ) ); |
| rSet.Put( SvxColorItem( aCol, EE_CHAR_COLOR ) ); |
| if ( nDestinationInstance == 0xffffffff ) |
| mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ].mnFontColorInStyleSheet = aCol; |
| } |
| else if ( nVal & 0x0f000000 ) // this is not a hard attribute, but maybe the page has a different colerscheme, |
| { // so that in this case we must use a hard color attribute |
| Color aCol( rManager.MSO_TEXT_CLR_ToColor( nVal ) ); |
| Color& aColorInSheet = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ mnDepth ].mnFontColorInStyleSheet; |
| if ( aColorInSheet != aCol ) |
| rSet.Put( SvxColorItem( aCol, EE_CHAR_COLOR ) ); |
| } |
| } |
| |
| if ( GetAttrib( PPT_CharAttr_Escapement, nVal, nDestinationInstance ) ) // Hoch/Tiefstellung in % |
| { |
| sal_uInt16 nEsc = 0; |
| sal_uInt8 nProp = 100; |
| |
| if ( nVal ) |
| { |
| nEsc = (sal_Int16)nVal; |
| nProp = DFLT_ESC_PROP; |
| } |
| SvxEscapementItem aItem( nEsc, nProp, EE_CHAR_ESCAPEMENT ); |
| rSet.Put( aItem ); |
| } |
| if ( mnLanguage[ 0 ] ) |
| rSet.Put( SvxLanguageItem( mnLanguage[ 0 ], EE_CHAR_LANGUAGE ) ); |
| if ( mnLanguage[ 1 ] ) |
| rSet.Put( SvxLanguageItem( mnLanguage[ 1 ], EE_CHAR_LANGUAGE_CJK ) ); |
| if ( mnLanguage[ 2 ] ) |
| rSet.Put( SvxLanguageItem( mnLanguage[ 2 ], EE_CHAR_LANGUAGE_CTL ) ); |
| } |
| |
| SvxFieldItem* PPTPortionObj::GetTextField() |
| { |
| if ( mpFieldItem ) |
| return new SvxFieldItem( *mpFieldItem ); |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| PPTParagraphObj::PPTParagraphObj( const PPTStyleSheet& rStyleSheet, sal_uInt32 nInstance, sal_uInt16 nDepth ) : |
| PPTNumberFormatCreator ( NULL ), |
| mrStyleSheet ( rStyleSheet ), |
| mnInstance ( nInstance ), |
| mbTab ( sal_True ), // style sheets always have to get the right tabulator setting |
| mnPortionCount ( 0 ), |
| mpPortionList ( NULL ) |
| { |
| if ( nDepth > 4 ) |
| nDepth = 4; |
| pParaSet->mnDepth = nDepth; |
| } |
| |
| PPTParagraphObj::PPTParagraphObj( PPTStyleTextPropReader& rPropReader, const PPTStyleSheet& rStyleSheet, |
| sal_uInt32 nInstance, PPTTextRulerInterpreter& rRuler ) : |
| PPTParaPropSet ( *( (PPTParaPropSet*)rPropReader.aParaPropList.GetCurObject() ) ), |
| PPTNumberFormatCreator ( NULL ), |
| PPTTextRulerInterpreter ( rRuler ), |
| mrStyleSheet ( rStyleSheet ), |
| mnInstance ( nInstance ), |
| mbTab ( sal_False ), |
| mnCurrentObject ( 0 ), |
| mnPortionCount ( 0 ), |
| mpPortionList ( NULL ) |
| { |
| sal_uInt32 nCurPos = rPropReader.aCharPropList.GetCurPos(); |
| PPTCharPropSet* pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.GetCurObject(); |
| if ( pCharPropSet ) |
| { |
| sal_uInt32 nCurrentParagraph = pCharPropSet->mnParagraph; |
| for ( ; pCharPropSet && ( pCharPropSet->mnParagraph == nCurrentParagraph ); pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Next() ) |
| mnPortionCount++; // counting number of portions that are part of this paragraph |
| pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Seek( nCurPos ); |
| |
| mpPortionList = new PPTPortionObj*[ mnPortionCount ]; |
| for ( sal_uInt32 i = 0; i < mnPortionCount; i++ ) |
| { |
| if ( pCharPropSet ) |
| { |
| PPTPortionObj* pPPTPortion = new PPTPortionObj( *pCharPropSet, rStyleSheet, nInstance, pParaSet->mnDepth ); |
| mpPortionList[ i ] = pPPTPortion; |
| if ( !mbTab ) |
| mbTab = mpPortionList[ i ]->HasTabulator(); |
| } |
| else |
| { |
| DBG_ERROR( "SJ:PPTParagraphObj::It seems that there are missing some textportions" ); |
| mpPortionList[ i ] = NULL; |
| } |
| pCharPropSet = (PPTCharPropSet*)rPropReader.aCharPropList.Next(); |
| } |
| } |
| } |
| |
| PPTParagraphObj::~PPTParagraphObj() |
| { |
| ImplClear(); |
| } |
| |
| void PPTParagraphObj::AppendPortion( PPTPortionObj& rPPTPortion ) |
| { |
| sal_uInt32 i; |
| PPTPortionObj** mpOldPortionList = mpPortionList; |
| mpPortionList = new PPTPortionObj*[ ++mnPortionCount ]; |
| for ( i = 0; i < mnPortionCount - 1; i++ ) |
| mpPortionList[ i ] = mpOldPortionList[ i ]; |
| delete[] mpOldPortionList; |
| mpPortionList[ mnPortionCount - 1 ] = new PPTPortionObj( rPPTPortion ); |
| if ( !mbTab ) |
| mbTab = mpPortionList[ mnPortionCount - 1 ]->HasTabulator(); |
| } |
| |
| void PPTParagraphObj::UpdateBulletRelSize( sal_uInt32& nBulletRelSize ) const |
| { |
| if ( nBulletRelSize > 0x7fff ) // a negative value is the absolute bullet height |
| { |
| sal_uInt16 nFontHeight = 0; |
| if ( mpPortionList ) |
| { |
| PPTPortionObj* pPortion = mpPortionList[ 0 ]; |
| if ( pPortion && ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_FontHeight ) ) ) |
| nFontHeight = pPortion->pCharSet->mnFontHeight; |
| } |
| // if we do not have a hard attributed fontheight, the fontheight is taken from the style |
| if ( !nFontHeight ) |
| nFontHeight = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontHeight; |
| nBulletRelSize = nFontHeight ? ((-((sal_Int16)nBulletRelSize)) * 100 ) / nFontHeight : 100; |
| } |
| } |
| |
| sal_Bool PPTParagraphObj::GetAttrib( sal_uInt32 nAttr, sal_uInt32& nRetValue, sal_uInt32 nDestinationInstance ) |
| { |
| sal_uInt32 nMask = 1 << nAttr; |
| nRetValue = 0; |
| |
| if ( nAttr > 21 ) |
| { |
| DBG_ERROR( "SJ:PPTParagraphObj::GetAttrib - attribute does not exist" ); |
| return sal_False; |
| } |
| |
| sal_uInt32 bIsHardAttribute = ( ( pParaSet->mnAttrSet & nMask ) != 0 ) ? 1 : 0; |
| |
| if ( bIsHardAttribute ) |
| { |
| if ( nAttr == PPT_ParaAttr_BulletColor ) |
| { |
| sal_Bool bHardBulletColor; |
| if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardColor ) ) |
| bHardBulletColor = pParaSet->mpArry[ PPT_ParaAttr_BuHardColor ] != 0; |
| else |
| bHardBulletColor = ( mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ].mnBuFlags |
| & ( 1 << PPT_ParaAttr_BuHardColor ) ) != 0; |
| if ( bHardBulletColor ) |
| nRetValue = pParaSet->mnBulletColor; |
| else |
| { |
| nRetValue = PPT_COLSCHEME_TEXT_UND_ZEILEN; |
| if ( ( nDestinationInstance != 0xffffffff ) && mnPortionCount ) |
| { |
| PPTPortionObj* pPortion = mpPortionList[ 0 ]; |
| if ( pPortion ) |
| { |
| if ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_FontColor ) ) |
| nRetValue = pPortion->pCharSet->mnColor; |
| else |
| nRetValue = mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor; |
| } |
| } |
| } |
| } |
| else if ( nAttr == PPT_ParaAttr_BulletFont ) |
| { |
| sal_Bool bHardBuFont; |
| if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardFont ) ) |
| bHardBuFont = pParaSet->mpArry[ PPT_ParaAttr_BuHardFont ] != 0; |
| else |
| bHardBuFont = ( mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ].mnBuFlags |
| & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0; |
| if ( bHardBuFont ) |
| nRetValue = pParaSet->mpArry[ PPT_ParaAttr_BulletFont ]; |
| else |
| { |
| // it is the font used which assigned to the first character of the following text |
| nRetValue = 0; |
| if ( ( nDestinationInstance != 0xffffffff ) && mnPortionCount ) |
| { |
| PPTPortionObj* pPortion = mpPortionList[ 0 ]; |
| if ( pPortion ) |
| { |
| if ( pPortion->pCharSet->mnAttrSet & ( 1 << PPT_CharAttr_Font ) ) |
| nRetValue = pPortion->pCharSet->mnFont; |
| else |
| nRetValue = mrStyleSheet.mpCharSheet[ nDestinationInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFont; |
| } |
| } |
| } |
| } |
| else |
| nRetValue = pParaSet->mpArry[ nAttr ]; |
| } |
| else |
| { |
| const PPTParaLevel& rParaLevel = mrStyleSheet.mpParaSheet[ mnInstance ]->maParaLevel[ pParaSet->mnDepth ]; |
| |
| PPTParaLevel* pParaLevel = NULL; |
| if ( ( nDestinationInstance == 0xffffffff ) |
| || ( pParaSet->mnDepth && ( ( mnInstance == TSS_TYPE_SUBTITLE ) || ( mnInstance == TSS_TYPE_TEXT_IN_SHAPE ) ) ) ) |
| bIsHardAttribute = 1; |
| else if ( nDestinationInstance != mnInstance ) |
| pParaLevel = &mrStyleSheet.mpParaSheet[ nDestinationInstance ]->maParaLevel[ pParaSet->mnDepth ]; |
| switch ( nAttr ) |
| { |
| case PPT_ParaAttr_BulletOn : |
| { |
| nRetValue = rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn ); |
| if ( pParaLevel ) |
| { |
| if ( nRetValue != ( (sal_uInt32)pParaLevel->mnBuFlags & ( 1 << PPT_ParaAttr_BulletOn ) ) ) |
| bIsHardAttribute = 1; |
| } |
| } |
| break; |
| case PPT_ParaAttr_BuHardFont : |
| case PPT_ParaAttr_BuHardColor : |
| case PPT_ParaAttr_BuHardHeight : |
| DBG_ERROR( "SJ:PPTParagraphObj::GetAttrib - this attribute does not make sense" ); |
| break; |
| case PPT_ParaAttr_BulletChar : |
| { |
| nRetValue = rParaLevel.mnBulletChar; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletChar ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_BulletFont : |
| { |
| sal_Bool bHardBuFont; |
| if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardFont ) ) |
| bHardBuFont = pParaSet->mpArry[ PPT_ParaAttr_BuHardFont ] != 0; |
| else |
| bHardBuFont = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardFont ) ) != 0; |
| if ( bHardBuFont ) |
| { |
| nRetValue = rParaLevel.mnBulletFont; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletFont ) ) |
| bIsHardAttribute = 1; |
| } |
| else |
| { |
| if ( mnPortionCount ) |
| { |
| PPTPortionObj* pPortion = mpPortionList[ 0 ]; |
| if ( pPortion ) |
| bIsHardAttribute = pPortion->GetAttrib( PPT_CharAttr_Font, nRetValue, nDestinationInstance ); |
| } |
| else |
| { |
| nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFont; |
| bIsHardAttribute = 1; |
| } |
| } |
| } |
| break; |
| case PPT_ParaAttr_BulletHeight : |
| { |
| nRetValue = rParaLevel.mnBulletHeight; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletHeight ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_BulletColor : |
| { |
| sal_Bool bHardBulletColor; |
| if ( pParaSet->mnAttrSet & ( 1 << PPT_ParaAttr_BuHardColor ) ) |
| bHardBulletColor = pParaSet->mpArry[ PPT_ParaAttr_BuHardColor ] != 0; |
| else |
| bHardBulletColor = ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardColor ) ) != 0; |
| if ( bHardBulletColor ) |
| { |
| nRetValue = rParaLevel.mnBulletColor; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletColor ) ) |
| bIsHardAttribute = 1; |
| } |
| else |
| { |
| if ( mnPortionCount ) |
| { |
| PPTPortionObj* pPortion = mpPortionList[ 0 ]; |
| if ( pPortion ) |
| { |
| if (pPortion->mbIsHyperlink ) |
| { |
| if( pPortion->mbHardHylinkOrigColor ) |
| nRetValue = pPortion->mnHylinkOrigColor; |
| else |
| nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor; |
| bIsHardAttribute = sal_True; |
| } |
| else |
| { |
| bIsHardAttribute = pPortion->GetAttrib( PPT_CharAttr_FontColor, nRetValue, nDestinationInstance ); |
| } |
| } |
| } |
| else |
| { |
| nRetValue = mrStyleSheet.mpCharSheet[ mnInstance ]->maCharLevel[ pParaSet->mnDepth ].mnFontColor; |
| bIsHardAttribute = 1; |
| } |
| } |
| } |
| break; |
| case PPT_ParaAttr_Adjust : |
| { |
| nRetValue = rParaLevel.mnAdjust; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnAdjust ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_LineFeed : |
| { |
| nRetValue = rParaLevel.mnLineFeed; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnLineFeed ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_UpperDist : |
| { |
| nRetValue = rParaLevel.mnUpperDist; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnUpperDist ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_LowerDist : |
| { |
| nRetValue = rParaLevel.mnLowerDist; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnLowerDist ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_TextOfs : |
| { |
| nRetValue = rParaLevel.mnTextOfs; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnTextOfs ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_BulletOfs : |
| { |
| nRetValue = rParaLevel.mnBulletOfs; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletOfs ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_DefaultTab : |
| { |
| nRetValue = rParaLevel.mnDefaultTab; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBulletOfs ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_AsianLB_1 : |
| { |
| nRetValue = rParaLevel.mnAsianLineBreak & 1; |
| if ( pParaLevel && ( nRetValue != ( (sal_uInt32)pParaLevel->mnAsianLineBreak & 1 ) ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_AsianLB_2 : |
| { |
| nRetValue = ( rParaLevel.mnAsianLineBreak >> 1 ) & 1; |
| if ( pParaLevel && ( nRetValue != ( ( (sal_uInt32)pParaLevel->mnAsianLineBreak >> 1 ) & 1 ) ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_AsianLB_3 : |
| { |
| nRetValue = ( rParaLevel.mnAsianLineBreak >> 2 ) & 1; |
| if ( pParaLevel && ( nRetValue != ( ( (sal_uInt32)pParaLevel->mnAsianLineBreak >> 2 ) & 1 ) ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| case PPT_ParaAttr_BiDi : |
| { |
| nRetValue = rParaLevel.mnBiDi; |
| if ( pParaLevel && ( nRetValue != pParaLevel->mnBiDi ) ) |
| bIsHardAttribute = 1; |
| } |
| break; |
| } |
| } |
| return (sal_Bool)bIsHardAttribute; |
| } |
| |
| void PPTParagraphObj::ApplyTo( SfxItemSet& rSet, boost::optional< sal_Int16 >& rStartNumbering, SdrPowerPointImport& rManager, sal_uInt32 nDestinationInstance, const PPTParagraphObj* /*pPrev*/) |
| { |
| sal_Int16 nVal2; |
| sal_uInt32 nVal, nUpperDist, nLowerDist; |
| sal_uInt32 nInstance = nDestinationInstance != 0xffffffff ? nDestinationInstance : mnInstance; |
| |
| if ( ( nDestinationInstance != 0xffffffff ) || ( pParaSet->mnDepth <= 1 ) ) |
| { |
| SvxNumBulletItem* pNumBulletItem = mrStyleSheet.mpNumBulletItem[ nInstance ]; |
| if ( pNumBulletItem ) |
| { |
| SvxNumberFormat aNumberFormat( SVX_NUM_NUMBER_NONE ); |
| if ( GetNumberFormat( rManager, aNumberFormat, this, nDestinationInstance, rStartNumbering ) ) |
| { |
| if ( aNumberFormat.GetNumberingType() == SVX_NUM_NUMBER_NONE ) |
| { |
| aNumberFormat.SetLSpace( 0 ); |
| aNumberFormat.SetAbsLSpace( 0 ); |
| aNumberFormat.SetFirstLineOffset( 0 ); |
| aNumberFormat.SetCharTextDistance( 0 ); |
| aNumberFormat.SetFirstLineIndent( 0 ); |
| aNumberFormat.SetIndentAt( 0 ); |
| } |
| SvxNumBulletItem aNewNumBulletItem( *pNumBulletItem ); |
| SvxNumRule* pRule = aNewNumBulletItem.GetNumRule(); |
| if ( pRule ) |
| { |
| pRule->SetLevel( pParaSet->mnDepth, aNumberFormat ); |
| sal_uInt16 i, n; |
| for ( i = 0; i < pRule->GetLevelCount(); i++ ) |
| { |
| if ( i != pParaSet->mnDepth ) |
| { |
| n = i > 4 ? 4 : i; |
| |
| SvxNumberFormat aNumberFormat2( pRule->GetLevel( i ) ); |
| const PPTParaLevel& rParaLevel = mrStyleSheet.mpParaSheet[ nInstance ]->maParaLevel[ n ]; |
| const PPTCharLevel& rCharLevel = mrStyleSheet.mpCharSheet[ nInstance ]->maCharLevel[ n ]; |
| sal_uInt32 nColor; |
| if ( rParaLevel.mnBuFlags & ( 1 << PPT_ParaAttr_BuHardColor ) ) |
| nColor = rParaLevel.mnBulletColor; |
| else |
| nColor = rCharLevel.mnFontColor; |
| aNumberFormat2.SetBulletColor( rManager.MSO_TEXT_CLR_ToColor( nColor ) ); |
| pRule->SetLevel( i, aNumberFormat2 ); |
| } |
| } |
| rSet.Put( aNewNumBulletItem ); |
| } |
| } |
| } |
| } |
| |
| sal_uInt32 nIsBullet2, _nTextOfs, _nBulletOfs, nHardAttribute = 0; |
| GetAttrib( PPT_ParaAttr_BulletOn, nIsBullet2, nDestinationInstance ); |
| nHardAttribute += GetAttrib( PPT_ParaAttr_TextOfs, _nTextOfs, nDestinationInstance ); |
| nHardAttribute += GetAttrib( PPT_ParaAttr_BulletOfs, _nBulletOfs, nDestinationInstance ); |
| if ( !nIsBullet2 ) |
| { |
| SvxLRSpaceItem aLRSpaceItem( EE_PARA_LRSPACE ); |
| sal_uInt16 nAbsLSpace = (sal_uInt16)( ( (sal_uInt32)_nTextOfs * 2540 ) / 576 ); |
| sal_uInt16 nFirstLineOffset = nAbsLSpace - (sal_uInt16)( ( (sal_uInt32)_nBulletOfs * 2540 ) / 576 ); |
| aLRSpaceItem.SetLeft( nAbsLSpace ); |
| aLRSpaceItem.SetTxtFirstLineOfstValue( -nFirstLineOffset ); |
| rSet.Put( aLRSpaceItem ); |
| } |
| else |
| { |
| SvxLRSpaceItem aLRSpaceItem( EE_PARA_LRSPACE ); |
| aLRSpaceItem.SetLeft( 0 ); |
| aLRSpaceItem.SetTxtFirstLineOfstValue( 0 ); |
| rSet.Put( aLRSpaceItem ); |
| } |
| if ( GetAttrib( PPT_ParaAttr_Adjust, nVal, nDestinationInstance ) ) |
| { |
| if ( nVal <= 3 ) |
| { // Absatzausrichtung |
| static SvxAdjust __READONLY_DATA aAdj[ 4 ] = { SVX_ADJUST_LEFT, SVX_ADJUST_CENTER, SVX_ADJUST_RIGHT, SVX_ADJUST_BLOCK }; |
| rSet.Put( SvxAdjustItem( aAdj[ nVal ], EE_PARA_JUST ) ); |
| } |
| } |
| |
| if ( GetAttrib( PPT_ParaAttr_AsianLB_1, nVal, nDestinationInstance ) ) |
| rSet.Put( SfxBoolItem( EE_PARA_FORBIDDENRULES, nVal != 0 ) ); |
| if ( GetAttrib( PPT_ParaAttr_AsianLB_3, nVal, nDestinationInstance ) ) |
| rSet.Put( SfxBoolItem( EE_PARA_HANGINGPUNCTUATION, nVal != 0 ) ); |
| |
| if ( GetAttrib( PPT_ParaAttr_BiDi, nVal, nDestinationInstance ) ) |
| rSet.Put( SvxFrameDirectionItem( nVal == 1 ? FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, EE_PARA_WRITINGDIR ) ); |
| |
| // LineSpacing |
| PPTPortionObj* pPortion = First(); |
| sal_Bool bIsHardAttribute = GetAttrib( PPT_ParaAttr_LineFeed, nVal, nDestinationInstance ); |
| nVal2 = (sal_Int16)nVal; |
| sal_uInt32 nFont = sal_uInt32(); |
| if ( pPortion && pPortion->GetAttrib( PPT_CharAttr_Font, nFont, nDestinationInstance ) ) |
| bIsHardAttribute = sal_True; |
| |
| if ( bIsHardAttribute ) |
| { |
| if ( pPortion && ( nVal2 > 200 ) ) |
| { |
| sal_uInt32 nFontHeight; |
| pPortion->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance ); |
| nVal2 = -(sal_Int16)( ( nFontHeight * nVal * 8 ) / 100 ); |
| } |
| rSet.Put( SdrTextFixedCellHeightItem( sal_True ), SDRATTR_TEXT_USEFIXEDCELLHEIGHT ); |
| SvxLineSpacingItem aItem( 200, EE_PARA_SBL ); |
| if ( nVal2 <= 0 ) |
| { |
| aItem.SetLineHeight( (sal_uInt16)( rManager.ScalePoint( -nVal2 ) / 8 ) ); |
| aItem.GetLineSpaceRule() = SVX_LINE_SPACE_FIX; |
| } |
| else |
| { |
| sal_uInt8 nPropLineSpace = (sal_uInt8)nVal2; |
| aItem.SetPropLineSpace( nPropLineSpace ); |
| aItem.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO; |
| } |
| rSet.Put( aItem ); |
| } |
| |
| // Paragraph Spacing |
| sal_uInt32 nFontHeight = 0; |
| bIsHardAttribute = ( (sal_uInt32)GetAttrib( PPT_ParaAttr_UpperDist, nUpperDist, nDestinationInstance ) + |
| (sal_uInt32)GetAttrib( PPT_ParaAttr_LowerDist, nLowerDist, nDestinationInstance ) ) != 0; |
| if ( ( nUpperDist > 0 ) || ( nLowerDist > 0 ) ) |
| { |
| if ( mnPortionCount ) |
| { |
| mpPortionList[ mnPortionCount - 1 ]->GetAttrib( PPT_CharAttr_FontHeight, nFontHeight, nDestinationInstance ); |
| if ( ((sal_Int16)nUpperDist) > 0 ) |
| nUpperDist = - (sal_Int16)( ( nFontHeight * nUpperDist * 100 ) / 1000 ); |
| if ( ((sal_Int16)nLowerDist) > 0 ) |
| nLowerDist = - (sal_Int16)( ( nFontHeight * nLowerDist * 100 ) / 1000 ); |
| } |
| bIsHardAttribute = sal_True; |
| } |
| if ( bIsHardAttribute ) |
| { |
| SvxULSpaceItem aULSpaceItem( EE_PARA_ULSPACE ); |
| nVal2 = (sal_Int16)nUpperDist; |
| if ( nVal2 <= 0 ) |
| aULSpaceItem.SetUpper( (sal_uInt16)(((sal_uInt32) - nVal2 * 2540 ) / ( 72 * 8 ) ) ); |
| else |
| { |
| aULSpaceItem.SetUpperValue( 0 ); |
| aULSpaceItem.SetPropUpper( (sal_uInt16)nUpperDist == 100 ? 101 : (sal_uInt16)nUpperDist ); |
| } |
| nVal2 = (sal_Int16)nLowerDist; |
| if ( nVal2 <= 0 ) |
| aULSpaceItem.SetLower( (sal_uInt16)(((sal_uInt32) - nVal2 * 2540 ) / ( 72 * 8 ) ) ); |
| else |
| { |
| aULSpaceItem.SetLowerValue( 0 ); |
| aULSpaceItem.SetPropLower( (sal_uInt16)nLowerDist == 100 ? 101 : (sal_uInt16)nLowerDist ); |
| } |
| rSet.Put( aULSpaceItem ); |
| } |
| |
| if ( mbTab ) // makes it sense to apply tabsettings |
| { |
| sal_uInt32 i, nDefaultTab, nTab, nTextOfs2 = 0; |
| sal_uInt32 nLatestManTab = 0; |
| GetAttrib( PPT_ParaAttr_TextOfs, nTextOfs2, nDestinationInstance ); |
| GetAttrib( PPT_ParaAttr_BulletOfs, nTab, nDestinationInstance ); |
| GetAttrib( PPT_ParaAttr_BulletOn, i, nDestinationInstance ); |
| GetAttrib( PPT_ParaAttr_DefaultTab, nDefaultTab, nDestinationInstance ); |
| SvxTabStopItem aTabItem( 0, 0, SVX_TAB_ADJUST_DEFAULT, EE_PARA_TABS ); |
| if ( GetTabCount() ) |
| { |
| //paragraph offset = MIN(first_line_offset, hanging_offset) |
| sal_uInt32 nParaOffset = Min( nTextOfs2, nTab ); |
| for ( i = 0; i < GetTabCount(); i++ ) |
| { |
| SvxTabAdjust eTabAdjust; |
| nTab = GetTabOffsetByIndex( (sal_uInt16)i ); |
| switch( GetTabStyleByIndex( (sal_uInt16)i ) ) |
| { |
| case 1 : eTabAdjust = SVX_TAB_ADJUST_CENTER; break; |
| case 2 : eTabAdjust = SVX_TAB_ADJUST_RIGHT; break; |
| case 3 : eTabAdjust = SVX_TAB_ADJUST_DECIMAL; break; |
| default : eTabAdjust = SVX_TAB_ADJUST_LEFT; |
| } |
| if ( nTab > nParaOffset )//If tab stop greater than paragraph offset |
| aTabItem.Insert( SvxTabStop( ( ( (long( nTab - nTextOfs2 )) * 2540 ) / 576 ), eTabAdjust ) ); |
| } |
| nLatestManTab = nTab; |
| } |
| if ( nIsBullet2 == 0 ) |
| aTabItem.Insert( SvxTabStop( (sal_uInt16)0 ) ); |
| if ( nDefaultTab ) |
| { |
| nTab = ( nTextOfs2 > nLatestManTab ) ? nTextOfs2 : nLatestManTab; |
| nTab /= nDefaultTab; |
| nTab = nDefaultTab * ( 1 + nTab ); |
| for ( i = 0; ( i < 20 ) && ( nTab < 0x1b00 ); i++ ) |
| { |
| aTabItem.Insert( SvxTabStop( (sal_uInt16)( ( ( nTab - nTextOfs2 ) * 2540 ) / 576 ) ) ); |
| nTab += nDefaultTab; |
| } |
| } |
| rSet.Put( aTabItem ); |
| } |
| } |
| |
| sal_uInt32 PPTParagraphObj::GetTextSize() |
| { |
| sal_uInt32 nCount, nRetValue = 0; |
| for ( sal_uInt32 i = 0; i < mnPortionCount; i++ ) |
| { |
| PPTPortionObj* pPortionObj = mpPortionList[ i ]; |
| nCount = pPortionObj->Count(); |
| if ( ( !nCount ) && pPortionObj->mpFieldItem ) |
| nCount++; |
| nRetValue += nCount; |
| } |
| return nRetValue; |
| } |
| |
| PPTPortionObj* PPTParagraphObj::First() |
| { |
| mnCurrentObject = 0; |
| if ( !mnPortionCount ) |
| return NULL; |
| return mpPortionList[ 0 ]; |
| } |
| |
| PPTPortionObj* PPTParagraphObj::Next() |
| { |
| sal_uInt32 i = mnCurrentObject + 1; |
| if ( i >= mnPortionCount ) |
| return NULL; |
| mnCurrentObject++; |
| return mpPortionList[ i ]; |
| } |
| |
| void PPTParagraphObj::ImplClear() |
| { |
| for ( void* pPtr = First(); pPtr; pPtr = Next() ) |
| delete (PPTPortionObj*)pPtr; |
| delete[] mpPortionList; |
| } |
| |
| PPTFieldEntry::~PPTFieldEntry() |
| { |
| delete pField1; |
| delete pField2; |
| delete pString; |
| }; |
| |
| void PPTFieldEntry::GetDateTime( const sal_uInt32 nVal, SvxDateFormat& eDateFormat, SvxTimeFormat& eTimeFormat ) |
| { |
| eDateFormat = SVXDATEFORMAT_APPDEFAULT; |
| eTimeFormat = SVXTIMEFORMAT_APPDEFAULT; |
| // ID auswerten |
| switch( nVal ) |
| { |
| case 0: |
| case 6: |
| eDateFormat = SVXDATEFORMAT_A; |
| break; |
| case 1: |
| eDateFormat = SVXDATEFORMAT_F; |
| break; |
| case 2: |
| case 3: |
| eDateFormat = SVXDATEFORMAT_D; |
| break; |
| case 4: |
| case 5: |
| eDateFormat = SVXDATEFORMAT_C; |
| break; |
| case 7: |
| eDateFormat = SVXDATEFORMAT_A; |
| case 9: |
| eTimeFormat = SVXTIMEFORMAT_24_HM; |
| break; |
| case 8: |
| eDateFormat = SVXDATEFORMAT_A; |
| case 11: |
| eTimeFormat = SVXTIMEFORMAT_12_HM; |
| break; |
| case 10: |
| eTimeFormat = SVXTIMEFORMAT_24_HMS; |
| break; |
| case 12: |
| eTimeFormat = SVXTIMEFORMAT_12_HMS; |
| break; |
| } |
| } |
| |
| void PPTFieldEntry::SetDateTime( sal_uInt32 nVal ) |
| { |
| SvxDateFormat eDateFormat; |
| SvxTimeFormat eTimeFormat; |
| GetDateTime( nVal, eDateFormat, eTimeFormat ); |
| if ( eDateFormat != SVXDATEFORMAT_APPDEFAULT ) |
| pField1 = new SvxFieldItem( SvxDateField( Date(), SVXDATETYPE_VAR, eDateFormat ), EE_FEATURE_FIELD ); |
| if ( eTimeFormat != SVXTIMEFORMAT_APPDEFAULT ) |
| { |
| SvxFieldItem* pFieldItem = new SvxFieldItem( SvxExtTimeField( Time(), SVXTIMETYPE_VAR, eTimeFormat ), EE_FEATURE_FIELD ); |
| if ( pField1 ) |
| pField2 = pFieldItem; |
| else |
| pField1 = pFieldItem; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| PPTTextObj::PPTTextObj( SvStream& rIn, SdrPowerPointImport& rSdrPowerPointImport, PptSlidePersistEntry& rPersistEntry, DffObjData* pObjData ) : |
| mpImplTextObj ( new ImplPPTTextObj( rPersistEntry ) ) |
| { |
| mpImplTextObj->mnRefCount = 1; |
| mpImplTextObj->mnShapeId = 0; |
| mpImplTextObj->mnShapeMaster = 0; |
| mpImplTextObj->mpPlaceHolderAtom = NULL; |
| mpImplTextObj->mnDestinationInstance = mpImplTextObj->mnInstance = 4; |
| mpImplTextObj->mnCurrentObject = 0; |
| mpImplTextObj->mnParagraphCount = 0; |
| mpImplTextObj->mpParagraphList = NULL; |
| mpImplTextObj->mnTextFlags = 0; |
| mpImplTextObj->meShapeType = ( pObjData && pObjData->bShapeType ) ? pObjData->eShapeType : mso_sptMin; |
| |
| DffRecordHeader aExtParaHd; |
| aExtParaHd.nRecType = 0; // set empty |
| |
| sal_uInt32 bStatus = sal_True; |
| |
| DffRecordHeader aShapeContainerHd; |
| rIn >> aShapeContainerHd; |
| |
| if ( ( pObjData == NULL ) || ( pObjData->bShapeType ) ) |
| { |
| PPTExtParaProv* pExtParaProv = rSdrPowerPointImport.pPPTStyleSheet->pExtParaProv; |
| if ( pObjData ) |
| { |
| mpImplTextObj->mnShapeId = pObjData->nShapeId; |
| if ( pObjData->nSpFlags & SP_FHAVEMASTER ) |
| mpImplTextObj->mnShapeMaster = rSdrPowerPointImport.GetPropertyValue( DFF_Prop_hspMaster, 0 ); |
| } |
| //////////////// |
| // ClientData // |
| //////////////// |
| if ( rSdrPowerPointImport.maShapeRecords.SeekToContent( rIn, DFF_msofbtClientData, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| sal_uInt32 nOldPos = rIn.Tell(); |
| DffRecordHeader& aClientDataContainerHd = *rSdrPowerPointImport.maShapeRecords.Current(); |
| DffRecordHeader aPlaceHolderAtomHd; |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_OEPlaceholderAtom, aClientDataContainerHd.GetRecEndFilePos(), &aPlaceHolderAtomHd ) ) |
| { |
| mpImplTextObj->mpPlaceHolderAtom = new PptOEPlaceholderAtom; |
| rIn >> *( mpImplTextObj->mpPlaceHolderAtom ); |
| } |
| rIn.Seek( nOldPos ); |
| DffRecordHeader aProgTagHd; |
| if ( rSdrPowerPointImport.SeekToContentOfProgTag( 9, rIn, aClientDataContainerHd, aProgTagHd ) ) |
| { |
| rIn >> aExtParaHd; |
| } |
| } |
| |
| /////////////////// |
| // ClientTextBox // |
| /////////////////// |
| if ( rSdrPowerPointImport.maShapeRecords.SeekToContent( rIn, DFF_msofbtClientTextbox, SEEK_FROM_CURRENT_AND_RESTART ) ) |
| { |
| DffRecordHeader aClientTextBoxHd( *rSdrPowerPointImport.maShapeRecords.Current() ); |
| sal_uInt32 nTextRulerAtomOfs = 0; // case of zero -> this atom may be found in aClientDataContainerHd; |
| // case of -1 -> ther is no atom of this kind |
| // else -> this is the fileofs where we can get it |
| |
| ////////////////////////////////////// |
| // checkout if this is a referenced // |
| // textobj, if so the we will patch // |
| // the ClientTextBoxHd for a // |
| // equivalent one // |
| ////////////////////////////////////// |
| DffRecordHeader aTextHd; |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_OutlineTextRefAtom, aClientTextBoxHd.GetRecEndFilePos(), &aTextHd ) ) |
| { |
| sal_uInt32 nRefNum; |
| rIn >> nRefNum; |
| |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextRulerAtom, aClientTextBoxHd.GetRecEndFilePos() ) ) |
| nTextRulerAtomOfs = rIn.Tell(); |
| else |
| nTextRulerAtomOfs = 0xffffffff; |
| |
| sal_uInt32 nInstance = 0; |
| switch( rSdrPowerPointImport.eAktPageKind ) |
| { |
| case PPT_NOTEPAGE : |
| nInstance++; |
| case PPT_MASTERPAGE : |
| nInstance++; |
| case PPT_SLIDEPAGE : |
| break; |
| default : |
| bStatus = sal_False; |
| } |
| if ( bStatus ) |
| { |
| sal_uInt32 nSlideId = rSdrPowerPointImport.GetAktPageId(); |
| if ( !nSlideId ) |
| bStatus = sal_False; |
| else |
| { |
| if ( !aExtParaHd.nRecType ) |
| { |
| sal_uInt32 nOldPos = rIn.Tell(); |
| // try to locate the referenced ExtendedParaHd |
| DffRecordHeader* pHd = pExtParaProv-> |
| aExtendedPresRules.GetRecordHeader( PPT_PST_ExtendedParagraphHeaderAtom, |
| SEEK_FROM_CURRENT_AND_RESTART ); |
| DffRecordHeader aPresRuleHd; |
| DffRecordHeader* pFirst = pHd; |
| |
| sal_uInt32 nTmpSlideId, nTmpRef; |
| while ( pHd ) |
| { |
| pHd->SeekToContent( rIn ); |
| rIn >> nTmpSlideId |
| >> nTmpRef; // this seems to be the instance |
| |
| if ( ( nTmpSlideId == nSlideId ) && ( pHd->nRecInstance == nRefNum ) ) |
| { |
| pHd->SeekToEndOfRecord( rIn ); |
| rIn >> aPresRuleHd; |
| if ( aPresRuleHd.nRecType == PPT_PST_ExtendedParagraphAtom ) |
| { |
| aExtParaHd = aPresRuleHd; |
| break; |
| } |
| } |
| pHd = pExtParaProv-> |
| aExtendedPresRules.GetRecordHeader( PPT_PST_ExtendedParagraphHeaderAtom, |
| SEEK_FROM_CURRENT_AND_RESTART ); |
| if ( pHd == pFirst ) |
| break; |
| } |
| rIn.Seek( nOldPos ); |
| } |
| // now pHd points to the right SlideListWithText Container |
| PptSlidePersistList* pPageList = rSdrPowerPointImport.GetPageList( rSdrPowerPointImport.eAktPageKind ); |
| PptSlidePersistEntry* pE = NULL; |
| if ( pPageList && ( rSdrPowerPointImport.nAktPageNum < pPageList->Count() ) ) |
| pE = (*pPageList)[ rSdrPowerPointImport.nAktPageNum ]; |
| if ( (!pE) || (!pE->nSlidePersistStartOffset) || ( pE->aPersistAtom.nSlideId != nSlideId ) ) |
| bStatus = sal_False; |
| else |
| { |
| rIn.Seek( pE->nSlidePersistStartOffset ); |
| // now we got the right page and are searching for the right |
| // TextHeaderAtom |
| while ( rIn.Tell() < pE->nSlidePersistEndOffset ) |
| { |
| rIn >> aClientTextBoxHd; |
| if ( aClientTextBoxHd.nRecType == PPT_PST_TextHeaderAtom ) |
| { |
| if ( aClientTextBoxHd.nRecInstance == nRefNum ) |
| { |
| aClientTextBoxHd.SeekToEndOfRecord( rIn ); |
| break; |
| } |
| } |
| aClientTextBoxHd.SeekToEndOfRecord( rIn ); |
| } |
| if ( rIn.Tell() > pE->nSlidePersistEndOffset ) |
| bStatus = sal_False; |
| else |
| { // patching the RecordHeader |
| aClientTextBoxHd.nFilePos -= DFF_COMMON_RECORD_HEADER_SIZE; |
| aClientTextBoxHd.nRecLen += DFF_COMMON_RECORD_HEADER_SIZE; |
| aClientTextBoxHd.nRecType = DFF_msofbtClientTextbox; |
| aClientTextBoxHd.nRecVer = DFF_PSFLAG_CONTAINER; |
| |
| // we have to calculate the correct record len |
| DffRecordHeader aTmpHd; |
| while ( rIn.Tell() < pE->nSlidePersistEndOffset ) |
| { |
| rIn >> aTmpHd; |
| if ( ( aTmpHd.nRecType == PPT_PST_SlidePersistAtom ) || ( aTmpHd.nRecType == PPT_PST_TextHeaderAtom ) ) |
| break; |
| aTmpHd.SeekToEndOfRecord( rIn ); |
| aClientTextBoxHd.nRecLen += aTmpHd.nRecLen + DFF_COMMON_RECORD_HEADER_SIZE; |
| } |
| aClientTextBoxHd.SeekToContent( rIn ); |
| } |
| } |
| } |
| } |
| } |
| |
| if ( bStatus ) |
| { |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextHeaderAtom, aClientTextBoxHd.GetRecEndFilePos(), &aTextHd ) ) |
| { |
| // TextHeaderAtom is always the first Atom |
| sal_uInt16 nInstance; |
| rIn >> nInstance; // this number tells us the TxMasterStyleAtom Instance |
| if ( nInstance > 8 ) |
| nInstance = 4; |
| aTextHd.SeekToEndOfRecord( rIn ); |
| mpImplTextObj->mnInstance = nInstance; |
| |
| sal_uInt32 nFilePos = rIn.Tell(); |
| if ( rSdrPowerPointImport.SeekToRec2( PPT_PST_TextBytesAtom, |
| PPT_PST_TextCharsAtom, |
| aClientTextBoxHd.GetRecEndFilePos() ) |
| || rSdrPowerPointImport.SeekToRec( rIn, |
| PPT_PST_StyleTextPropAtom, |
| aClientTextBoxHd.GetRecEndFilePos() ) ) |
| { |
| PPTTextRulerInterpreter aTextRulerInterpreter( nTextRulerAtomOfs, rSdrPowerPointImport, |
| aClientTextBoxHd, rIn ); |
| |
| PPTStyleTextPropReader aStyleTextPropReader( rIn, rSdrPowerPointImport, aClientTextBoxHd, |
| aTextRulerInterpreter, aExtParaHd, nInstance ); |
| sal_uInt32 nParagraphs = mpImplTextObj->mnParagraphCount = aStyleTextPropReader.aParaPropList.Count(); |
| if ( nParagraphs ) |
| { |
| // the language settings will be merged into the list of PPTCharPropSet |
| DffRecordHeader aTextSpecInfoHd; |
| PPTTextSpecInfoAtomInterpreter aTextSpecInfoAtomInterpreter; |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_TextSpecInfoAtom, |
| aClientTextBoxHd.GetRecEndFilePos(), &aTextSpecInfoHd ) ) |
| { |
| if ( aTextSpecInfoAtomInterpreter.Read( rIn, aTextSpecInfoHd, PPT_PST_TextSpecInfoAtom, |
| &(rSdrPowerPointImport.pPPTStyleSheet->maTxSI) ) ) |
| { |
| sal_uInt32 nI = 0; |
| PPTTextSpecInfo* pSpecInfo; |
| for ( pSpecInfo = (PPTTextSpecInfo*)aTextSpecInfoAtomInterpreter.aList.First(); |
| pSpecInfo; pSpecInfo =(PPTTextSpecInfo*)aTextSpecInfoAtomInterpreter.aList.Next() ) |
| { |
| sal_uInt32 nCharIdx = pSpecInfo->nCharIdx; |
| |
| // portions and text have to been splitted in some cases |
| for ( ; nI < aStyleTextPropReader.aCharPropList.Count(); ) |
| { |
| PPTCharPropSet* pSet = (PPTCharPropSet*)aStyleTextPropReader.aCharPropList.GetObject( nI ); |
| if ( pSet->mnOriginalTextPos < nCharIdx ) |
| { |
| pSet->mnLanguage[ 0 ] = pSpecInfo->nLanguage[ 0 ]; |
| pSet->mnLanguage[ 1 ] = pSpecInfo->nLanguage[ 1 ]; |
| pSet->mnLanguage[ 2 ] = pSpecInfo->nLanguage[ 2 ]; |
| // test if the current portion needs to be splitted |
| if ( pSet->maString.Len() > 1 ) |
| { |
| sal_Int32 nIndexOfNextPortion = pSet->maString.Len() + pSet->mnOriginalTextPos; |
| sal_Int32 nNewLen = nIndexOfNextPortion - nCharIdx; |
| sal_Int32 nOldLen = pSet->maString.Len() - nNewLen; |
| |
| if ( ( nNewLen > 0 ) && ( nOldLen > 0 ) ) |
| { |
| String aString( pSet->maString ); |
| PPTCharPropSet* pNew = new PPTCharPropSet( *pSet ); |
| pSet->maString = String( aString, 0, (sal_uInt16)nOldLen ); |
| pNew->maString = String( aString, (sal_uInt16)nOldLen, (sal_uInt16)nNewLen ); |
| pNew->mnOriginalTextPos += nOldLen; |
| aStyleTextPropReader.aCharPropList.Insert( pNew, nI + 1 ); |
| } |
| } |
| } |
| else |
| break; |
| nI++; |
| } |
| } |
| } |
| #ifdef DBG_UTIL |
| else |
| { |
| if (!(rSdrPowerPointImport.rImportParam.nImportFlags & PPT_IMPORTFLAGS_NO_TEXT_ASSERT)) |
| { |
| DBG_ERROR( "SdrTextSpecInfoAtomInterpreter::Ctor(): parsing error, this document needs to be analysed (SJ)" ); |
| } |
| } |
| #endif |
| } |
| // |
| // now will search for possible textextensions such as date/time fields |
| // or ParaTabStops and append them on this textobj |
| // |
| rIn.Seek( nFilePos ); |
| List* pFieldList = NULL; |
| while ( rIn.Tell() < aClientTextBoxHd.GetRecEndFilePos() ) |
| { |
| rIn >> aTextHd; |
| sal_uInt16 nVal = 0; |
| PPTFieldEntry* pEntry = NULL; |
| switch ( aTextHd.nRecType ) |
| { |
| case PPT_PST_DateTimeMCAtom : |
| { |
| pEntry = new PPTFieldEntry; |
| rIn >> pEntry->nPos |
| >> nVal |
| >> nVal; |
| pEntry->SetDateTime( nVal & 0xff ); |
| } |
| break; |
| |
| case PPT_PST_FooterMCAtom : |
| { |
| pEntry = new PPTFieldEntry; |
| rIn >> pEntry->nPos; |
| pEntry->pField1 = new SvxFieldItem( SvxFooterField(), EE_FEATURE_FIELD ); |
| } |
| break; |
| |
| case PPT_PST_HeaderMCAtom : |
| { |
| pEntry = new PPTFieldEntry; |
| rIn >> pEntry->nPos; |
| pEntry->pField1 = new SvxFieldItem( SvxHeaderField(), EE_FEATURE_FIELD ); |
| } |
| break; |
| |
| case PPT_PST_GenericDateMCAtom : |
| { |
| pEntry = new PPTFieldEntry; |
| rIn >> pEntry->nPos; |
| pEntry->pField1 = new SvxFieldItem( SvxDateTimeField(), EE_FEATURE_FIELD ); |
| if ( rPersistEntry.pHeaderFooterEntry ) // sj: #i34111# on master pages it is possible |
| { // that there is no HeaderFooterEntry available |
| if ( rPersistEntry.pHeaderFooterEntry->nAtom & 0x20000 ) // auto date time |
| pEntry->SetDateTime( rPersistEntry.pHeaderFooterEntry->nAtom & 0xff ); |
| else |
| pEntry->pString = new String( rPersistEntry.pHeaderFooterEntry->pPlaceholder[ nVal ] ); |
| } |
| } |
| break; |
| |
| case PPT_PST_SlideNumberMCAtom : |
| case PPT_PST_RTFDateTimeMCAtom : |
| { |
| pEntry = new PPTFieldEntry; |
| if ( aTextHd.nRecLen >= 4 ) |
| { |
| rIn >> pEntry->nPos |
| >> nVal; |
| |
| // ID auswerten |
| //SvxFieldItem* pFieldItem = NULL; |
| switch( aTextHd.nRecType ) |
| { |
| case PPT_PST_SlideNumberMCAtom: |
| pEntry->pField1 = new SvxFieldItem( SvxPageField(), EE_FEATURE_FIELD ); |
| break; |
| |
| case PPT_PST_RTFDateTimeMCAtom: |
| { |
| // Rude workaround for one specal case reported |
| // by a customer. (#i75203#) |
| |
| // Don't even attempt to handle the general use |
| // case for PPT_PST_RTFDateTimeMCAtom (a generic |
| // MS style date/time format string). Just handle |
| // the special case where the format string |
| // contains only one or several possibly empty |
| // quoted strings. I.e. something that doesn't |
| // expand to any date or time at all, but to a |
| // fixed string. How on earth somebody manages to |
| // produce such things in PPT slides I have no |
| // idea. |
| if (nVal == 0) |
| { |
| sal_Unicode n; |
| xub_StrLen nLen; |
| String aStr; |
| bool inquote = sal_False; |
| for (nLen = 0, n = 0; nLen < 64; nLen++) |
| { |
| rIn >> n; |
| |
| // Collect quoted characters into aStr |
| if ( n == '\'') |
| inquote = !inquote; |
| else if (!n) |
| { |
| // End of format string |
| pEntry->pString = new String( aStr ); |
| break; |
| } |
| else if (!inquote) |
| { |
| // Non-quoted character, i.e. a real |
| // format specifier. We don't handle |
| // those. Sorry. |
| break; |
| } |
| else |
| { |
| aStr += n; |
| } |
| } |
| } |
| if ( pEntry->pString == NULL ) |
| { |
| // Handle as previously |
| pEntry->pField1 = new SvxFieldItem( SvxDateField( Date(), SVXDATETYPE_FIX ), EE_FEATURE_FIELD ); |
| } |
| } |
| } |
| } |
| } |
| break; |
| |
| case PPT_PST_InteractiveInfo : |
| { |
| DffRecordHeader aHdInteractiveInfoAtom; |
| if ( rSdrPowerPointImport.SeekToRec( rIn, PPT_PST_InteractiveInfoAtom, aTextHd.GetRecEndFilePos(), &aHdInteractiveInfoAtom ) ) |
| { |
| PptInteractiveInfoAtom aInteractiveInfoAtom; |
| rIn >> aInteractiveInfoAtom; |
| for ( SdHyperlinkEntry* pHyperlink = (SdHyperlinkEntry*)rSdrPowerPointImport.aHyperList.First(); |
| pHyperlink; pHyperlink = (SdHyperlinkEntry*)rSdrPowerPointImport.aHyperList.Next() ) |
| { |
| if ( pHyperlink->nIndex == aInteractiveInfoAtom.nExHyperlinkId ) |
| { |
| aTextHd.SeekToEndOfRecord( rIn ); |
| rIn >> aTextHd; |
| if ( aTextHd.nRecType != PPT_PST_TxInteractiveInfoAtom ) |
| { |
| aTextHd.SeekToBegOfRecord( rIn ); |
| continue; |
| } |
| else |
| { |
| sal_uInt32 nStartPos, nEndPos; |
| rIn >> nStartPos |
| >> nEndPos; |
| if ( nEndPos ) |
| { |
| pEntry = new PPTFieldEntry; |
| pEntry->nPos = (sal_uInt16)nStartPos; |
| pEntry->nTextRangeEnd = (sal_uInt16)nEndPos; |
| String aTarget( pHyperlink->aTarget ); |
| if ( pHyperlink->aConvSubString.Len() ) |
| { |
| aTarget.Append( (sal_Unicode)'#' ); |
| aTarget.Append( pHyperlink->aConvSubString ); |
| } |
| pEntry->pField1 = new SvxFieldItem( SvxURLField( aTarget, String(), SVXURLFORMAT_REPR ), EE_FEATURE_FIELD ); |
| } |
| } |
| break; |
| } |
| } |
| } |
| } |
| break; |
| } |
| aTextHd.SeekToEndOfRecord( rIn ); |
| if ( pEntry ) |
| { |
| if ( !pFieldList ) |
| pFieldList = new List; |
| sal_uInt32 n; |
| for ( n = 0; n < pFieldList->Count(); n++ ) |
| { // sorting fields ( hi >> lo ) |
| if ( ( (PPTFieldEntry*)pFieldList->GetObject( n ) )->nPos < pEntry->nPos ) |
| break; |
| } |
| pFieldList->Insert( pEntry, (sal_uInt32)n ); |
| } |
| } |
| if ( pFieldList ) |
| { |
| PPTFieldEntry* pFE = (PPTFieldEntry*)pFieldList->First(); |
| List& aCharPropList = aStyleTextPropReader.aCharPropList; |
| |
| sal_Int32 i = nParagraphs - 1; |
| sal_Int32 n = aCharPropList.Count() - 1; |
| |
| // at this point we just have a list of textportions(aCharPropList) |
| // the next while loop tries to resolve the list of fields(pFieldList) |
| while( pFE && ( n >= 0 ) && ( i >= 0 ) ) |
| { |
| PPTCharPropSet* pSet = (PPTCharPropSet*)aCharPropList.GetObject( n ); |
| String aString( pSet->maString ); |
| sal_uInt32 nCount = aString.Len(); |
| sal_uInt32 nPos = pSet->mnOriginalTextPos + nCount; |
| while ( pFE && nCount-- ) |
| { |
| nPos--; |
| while ( pFE && ( pFE->nPos > nPos ) ) |
| pFE = (PPTFieldEntry*)pFieldList->Next(); |
| if ( !pFE ) |
| break; |
| |
| if ( pFE->nPos == nPos ) |
| { |
| if ( aString.GetChar( (sal_uInt16)nCount ) == 0x2a ) |
| { |
| sal_uInt32 nBehind = aString.Len() - ( nCount + 1 ); |
| pSet->maString = String(); |
| if ( nBehind ) |
| { |
| PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet ); |
| pNewCPS->maString = String( aString, (sal_uInt16)nCount + 1, (sal_uInt16)nBehind ); |
| aCharPropList.Insert( pNewCPS, n + 1 ); |
| } |
| if ( pFE->pField2 ) |
| { |
| PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet ); |
| pNewCPS->mpFieldItem = pFE->pField2, pFE->pField2 = NULL; |
| aCharPropList.Insert( pNewCPS, n + 1 ); |
| |
| pNewCPS = new PPTCharPropSet( *pSet ); |
| pNewCPS->maString = String( String( RTL_CONSTASCII_USTRINGPARAM( " " ) ) ); |
| aCharPropList.Insert( pNewCPS, n + 1 ); |
| } |
| if ( nCount ) |
| { |
| PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pSet ); |
| pNewCPS->maString = String( aString, (sal_uInt16)0, (sal_uInt16)nCount ); |
| aCharPropList.Insert( pNewCPS, n++ ); |
| } |
| if ( pFE->pField1 ) |
| { |
| pSet->mpFieldItem = pFE->pField1, pFE->pField1 = NULL; |
| } |
| else if ( pFE->pString ) |
| pSet->maString = *pFE->pString; |
| } |
| else |
| { |
| if ( pFE->nTextRangeEnd ) // text range hyperlink |
| { |
| sal_uInt32 nHyperLen = pFE->nTextRangeEnd - nPos; |
| if ( nHyperLen ) |
| { |
| PPTCharPropSet* pBefCPS = NULL; |
| if ( nCount ) |
| { |
| pBefCPS = new PPTCharPropSet( *pSet ); |
| pSet->maString = String( pSet->maString, (sal_uInt16)nCount, (sal_uInt16)( pSet->maString.Len() - nCount ) ); |
| } |
| sal_uInt32 nIdx = n; |
| sal_Int32 nHyperLenLeft = nHyperLen; |
| |
| while ( ( aCharPropList.Count() > nIdx ) && nHyperLenLeft ) |
| { |
| // the textrange hyperlink can take more than 1 paragraph |
| // the solution here is to clone the hyperlink... |
| |
| PPTCharPropSet* pCurrent = (PPTCharPropSet*)aCharPropList.GetObject( nIdx ); |
| sal_Int32 nNextStringLen = pCurrent->maString.Len(); |
| |
| DBG_ASSERT( pFE->pField1, "missing field!" ); |
| if (!pFE->pField1) |
| break; |
| |
| const SvxURLField* pField = (const SvxURLField*)pFE->pField1->GetField(); |
| |
| pCurrent->mbIsHyperlink=sal_True; |
| pCurrent->mnHylinkOrigColor=pCurrent->pCharSet->mnColor; |
| pCurrent->mbHardHylinkOrigColor= ( ( pCurrent->pCharSet->mnAttrSet >>PPT_CharAttr_FontColor ) & 1)>0; |
| |
| if ( pCurrent->mpFieldItem ) |
| { |
| pCurrent->SetColor( PPT_COLSCHEME_A_UND_HYPERLINK ); |
| if ( pCurrent->mpFieldItem->GetField()->ISA( SvxURLField ) ) |
| break; |
| nHyperLenLeft--; |
| } |
| else if ( nNextStringLen ) |
| { |
| if ( nNextStringLen <= nHyperLenLeft ) |
| { |
| pCurrent->mpFieldItem = new SvxFieldItem( SvxURLField( pField->GetURL(), pCurrent->maString, SVXURLFORMAT_REPR ), EE_FEATURE_FIELD ); |
| nHyperLenLeft -= nNextStringLen; |
| |
| if ( nHyperLenLeft ) |
| { |
| // if the next portion is in a higher paragraph, |
| // the textrange is to decrease (because of the LineBreak character) |
| if ( aCharPropList.Count() > ( nIdx + 1 ) ) |
| { |
| PPTCharPropSet* pNext = (PPTCharPropSet*)aCharPropList.GetObject( nIdx + 1 ); |
| if ( pNext->mnParagraph > pCurrent->mnParagraph ) |
| nHyperLenLeft--; |
| } |
| } |
| } |
| else |
| { |
| PPTCharPropSet* pNewCPS = new PPTCharPropSet( *pCurrent ); |
| pNewCPS->maString = String( pCurrent->maString, (sal_uInt16)nHyperLenLeft, (sal_uInt16)( nNextStringLen - nHyperLenLeft ) ); |
| aCharPropList.Insert( pNewCPS, nIdx + 1 ); |
| String aRepresentation( pCurrent->maString, 0, (sal_uInt16)nHyperLenLeft ); |
| pCurrent->mpFieldItem = new SvxFieldItem( SvxURLField( pField->GetURL(), aRepresentation, SVXURLFORMAT_REPR ), EE_FEATURE_FIELD ); |
| nHyperLenLeft = 0; |
| } |
| pCurrent->maString = String(); |
| pCurrent->SetColor( PPT_COLSCHEME_A_UND_HYPERLINK ); |
| } |
| nIdx++; |
| } |
| delete pFE->pField1, pFE->pField1 = NULL; |
| |
| if ( pBefCPS ) |
| { |
| pBefCPS->maString = String( aString, (sal_uInt16)0, (sal_uInt16)nCount ); |
| aCharPropList.Insert( pBefCPS, n++ ); |
| |
| } |
| } |
| } |
| } |
| break; |
| } |
| } |
| n--; |
| } |
| for ( void* pPtr = pFieldList->First(); pPtr; pPtr = pFieldList->Next() ) |
| delete (PPTFieldEntry*)pPtr; |
| delete pFieldList; |
| } |
| mpImplTextObj->mpParagraphList = new PPTParagraphObj*[ nParagraphs ]; |
| aStyleTextPropReader.aCharPropList.First(); |
| sal_uInt32 nCount = 0; |
| for ( void* pPtr = aStyleTextPropReader.aParaPropList.First(); |
| pPtr; |
| pPtr = aStyleTextPropReader.aParaPropList.Next() ) |
| { |
| PPTParagraphObj* pPara = new PPTParagraphObj( aStyleTextPropReader, *rSdrPowerPointImport.pPPTStyleSheet, nInstance, aTextRulerInterpreter ); |
| mpImplTextObj->mpParagraphList[ nCount++ ] = pPara; |
| |
| sal_uInt32 nParaAdjust, nFlags = 0; |
| pPara->GetAttrib( PPT_ParaAttr_Adjust, nParaAdjust, GetInstance() ); |
| |
| switch ( nParaAdjust ) |
| { |
| case 0 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT; break; |
| case 1 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER; break; |
| case 2 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; break; |
| case 3 : nFlags = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK; break; |
| } |
| mpImplTextObj->mnTextFlags |= nFlags; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| PPTTextObj::PPTTextObj( PPTTextObj& rTextObj ) |
| { |
| mpImplTextObj = rTextObj.mpImplTextObj; |
| mpImplTextObj->mnRefCount++; |
| } |
| |
| PPTTextObj::~PPTTextObj() |
| { |
| ImplClear(); |
| } |
| |
| PPTParagraphObj* PPTTextObj::First() |
| { |
| mpImplTextObj->mnCurrentObject = 0; |
| if ( !mpImplTextObj->mnParagraphCount ) |
| return NULL; |
| return mpImplTextObj->mpParagraphList[ 0 ]; |
| } |
| |
| PPTParagraphObj* PPTTextObj::Next() |
| { |
| sal_uInt32 i = mpImplTextObj->mnCurrentObject + 1; |
| if ( i >= mpImplTextObj->mnParagraphCount ) |
| return NULL; |
| mpImplTextObj->mnCurrentObject++; |
| return mpImplTextObj->mpParagraphList[ i ]; |
| } |
| |
| const SfxItemSet* PPTTextObj::GetBackground() const |
| { |
| if ( mpImplTextObj->mrPersistEntry.pBObj ) |
| return &mpImplTextObj->mrPersistEntry.pBObj->GetMergedItemSet(); |
| else |
| return NULL; |
| } |
| |
| void PPTTextObj::ImplClear() |
| { |
| if ( ! ( --mpImplTextObj->mnRefCount ) ) |
| { |
| for ( PPTParagraphObj* pPtr = First(); pPtr; pPtr = Next() ) |
| delete pPtr; |
| delete[] mpImplTextObj->mpParagraphList; |
| delete mpImplTextObj->mpPlaceHolderAtom; |
| delete mpImplTextObj; |
| } |
| } |
| |
| PPTTextObj& PPTTextObj::operator=( PPTTextObj& rTextObj ) |
| { |
| if ( this != &rTextObj ) |
| { |
| ImplClear(); |
| mpImplTextObj = rTextObj.mpImplTextObj; |
| mpImplTextObj->mnRefCount++; |
| } |
| return *this; |
| } |
| |
| sal_Bool IsLine( const SdrObject* pObj ) |
| { |
| return pObj->ISA( SdrPathObj ) && ((SdrPathObj*)pObj)->IsLine() && (((SdrPathObj*)pObj)->GetPointCount() == 2 ); |
| } |
| |
| sal_Bool GetCellPosition( const SdrObject* pObj, const std::set< sal_Int32 >& rRows, const std::set< sal_Int32 >& rColumns, |
| sal_Int32& nTableIndex, sal_Int32& nRow, sal_Int32& nRowCount, sal_Int32& nColumn, sal_Int32& nColumnCount ) |
| { |
| Rectangle aSnapRect( pObj->GetSnapRect() ); |
| sal_Bool bCellObject = ( aSnapRect.GetWidth() > 1 ) && ( aSnapRect.GetHeight() > 1 ); |
| if ( bCellObject ) |
| { |
| std::set< sal_Int32 >::const_iterator aRowIter( rRows.find( aSnapRect.Top() ) ); |
| std::set< sal_Int32 >::const_iterator aColumnIter( rColumns.find( aSnapRect.Left() ) ); |
| if ( ( aRowIter == rRows.end() ) || ( aColumnIter == rColumns.end() ) ) |
| bCellObject = sal_False; |
| else |
| { |
| nRowCount = 1; |
| nRow = std::distance( rRows.begin(), aRowIter ); |
| while( ++aRowIter != rRows.end() ) |
| { |
| if ( *aRowIter >= aSnapRect.Bottom() ) |
| break; |
| nRowCount++; |
| } |
| nColumnCount = 1; |
| nColumn = std::distance( rColumns.begin(), aColumnIter ); |
| while( ++aColumnIter != rColumns.end() ) |
| { |
| if ( *aColumnIter >= aSnapRect.Right() ) |
| break; |
| nColumnCount++; |
| } |
| nTableIndex = nRow * rColumns.size() + nColumn; |
| } |
| } |
| return bCellObject; |
| } |
| |
| #define LinePositionLeft 0x01000000 |
| #define LinePositionTop 0x02000000 |
| #define LinePositionRight 0x04000000 |
| #define LinePositionBottom 0x08000000 |
| #define LinePositionTLBR 0x10000000 |
| #define LinePositionBLTR 0x20000000 |
| |
| |
| void GetRowPositions( const Rectangle& rSnapRect, const std::set< sal_Int32 >& rRows, |
| const std::set< sal_Int32 >& rColumns, std::vector< sal_Int32 >& rPositions, sal_Int32 nColumn, sal_Int32 nFlags ) |
| { |
| std::set< sal_Int32 >::const_iterator aRow( rRows.find( rSnapRect.Top() ) ); |
| if ( aRow != rRows.end() ) |
| { |
| sal_Int32 nRow = std::distance( rRows.begin(), aRow ); |
| while( ( aRow != rRows.end() ) && ((*aRow) < rSnapRect.Bottom() ) ) |
| { |
| if ( nFlags & LinePositionLeft ) |
| rPositions.push_back( ( ( nRow * rColumns.size() ) + nColumn ) | LinePositionLeft ); |
| if ( nFlags & LinePositionRight ) |
| rPositions.push_back( ( ( nRow * rColumns.size() ) + ( nColumn - 1 ) ) | LinePositionRight ); |
| |
| nRow++; |
| aRow++; |
| } |
| } |
| } |
| |
| |
| void GetColumnPositions( const Rectangle& rSnapRect, const std::set< sal_Int32 >& /* rRows */, |
| const std::set< sal_Int32 >& rColumns, std::vector< sal_Int32 >& rPositions, sal_Int32 nRow, sal_Int32 nFlags ) |
| { |
| std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( rSnapRect.Left() ) ); |
| if ( aColumn != rColumns.end() ) |
| { |
| sal_Int32 nColumn = std::distance( rColumns.begin(), aColumn ); |
| while( ( aColumn != rColumns.end() ) && ((*aColumn) < rSnapRect.Right() ) ) |
| { |
| if ( nFlags & LinePositionTop ) |
| rPositions.push_back( ( ( nRow * rColumns.size() ) + nColumn ) | LinePositionTop ); |
| if ( nFlags & LinePositionBottom ) |
| rPositions.push_back( ( ( ( nRow - 1 ) * rColumns.size() ) + nColumn ) | LinePositionBottom ); |
| |
| nColumn++; |
| aColumn++; |
| } |
| } |
| } |
| |
| void GetLinePositions( const SdrObject* pObj, const std::set< sal_Int32 >& rRows, const std::set< sal_Int32 >& rColumns, |
| std::vector< sal_Int32 >& rPositions, const Rectangle& rGroupSnap ) |
| { |
| Rectangle aSnapRect( pObj->GetSnapRect() ); |
| if ( aSnapRect.Left() == aSnapRect.Right() ) |
| { |
| std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( aSnapRect.Left() ) ); |
| if ( ( aColumn != rColumns.end() ) || ( aSnapRect.Left() == rGroupSnap.Right() ) ) |
| { |
| sal_Int32 nColumn, nFlags; |
| if ( aColumn != rColumns.end() ) |
| { |
| nColumn = std::distance( rColumns.begin(), aColumn ); |
| nFlags = LinePositionLeft; |
| if ( aColumn != rColumns.begin() ) |
| nFlags |= LinePositionRight; |
| } |
| else |
| { |
| nColumn = rColumns.size(); |
| nFlags = LinePositionRight; |
| } |
| GetRowPositions( aSnapRect, rRows, rColumns, rPositions, nColumn, nFlags ); |
| } |
| } |
| else if ( aSnapRect.Top() == aSnapRect.Bottom() ) |
| { |
| std::set< sal_Int32 >::const_iterator aRow( rRows.find( aSnapRect.Top() ) ); |
| if ( ( aRow != rRows.end() ) || ( aSnapRect.Top() == rGroupSnap.Bottom() ) ) |
| { |
| sal_Int32 nRow, nFlags; |
| if ( aRow != rRows.end() ) |
| { |
| nRow = std::distance( rRows.begin(), aRow ); |
| nFlags = LinePositionTop; |
| if ( aRow != rRows.begin() ) |
| nFlags |= LinePositionBottom; |
| } |
| else |
| { |
| nRow = rRows.size(); |
| nFlags = LinePositionBottom; |
| } |
| GetColumnPositions( aSnapRect, rRows, rColumns, rPositions, nRow, nFlags ); |
| } |
| } |
| else |
| { |
| sal_uInt32 nPosition = 0; |
| Point aPt1( ((SdrPathObj*)pObj)->GetPoint( 0 ) ); |
| Point aPt2( ((SdrPathObj*)pObj)->GetPoint( 1 ) ); |
| if ( aPt1.X() < aPt2.X() ) |
| nPosition |= aPt1.Y() < aPt2.Y() ? LinePositionTLBR : LinePositionBLTR; |
| else |
| nPosition |= aPt1.Y() < aPt2.Y() ? LinePositionBLTR : LinePositionTLBR; |
| |
| std::set< sal_Int32 >::const_iterator aRow( rRows.find( aPt1.Y() < aPt2.Y() ? aPt1.Y() : aPt2.Y() ) ); |
| std::set< sal_Int32 >::const_iterator aColumn( rColumns.find( aPt1.X() < aPt2.X() ? aPt1.X() : aPt2.X() ) ); |
| if ( ( aRow != rRows.end() ) && ( aColumn != rColumns.end() ) ) |
| { |
| nPosition |= ( std::distance( rRows.begin(), aRow ) * rColumns.size() ) + std::distance( rColumns.begin(), aColumn ); |
| rPositions.push_back( nPosition ); |
| } |
| } |
| } |
| |
| void CreateTableRows( Reference< XTableRows > xTableRows, const std::set< sal_Int32 >& rRows, sal_Int32 nTableBottom ) |
| { |
| if ( rRows.size() > 1 ) |
| xTableRows->insertByIndex( 0, rRows.size() - 1 ); |
| |
| std::set< sal_Int32 >::const_iterator aIter( rRows.begin() ); |
| sal_Int32 nLastPosition( *aIter ); |
| Reference< XIndexAccess > xIndexAccess( xTableRows, UNO_QUERY_THROW ); |
| for ( sal_Int32 n = 0; n < xIndexAccess->getCount(); n++ ) |
| { |
| sal_Int32 nHeight; |
| if ( ++aIter != rRows.end() ) |
| { |
| nHeight = *aIter - nLastPosition; |
| nLastPosition = *aIter; |
| } |
| else |
| nHeight = nTableBottom - nLastPosition; |
| |
| static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Height" ) ); |
| Reference< XPropertySet > xPropSet( xIndexAccess->getByIndex( n ), UNO_QUERY_THROW ); |
| xPropSet->setPropertyValue( sWidth, Any( nHeight ) ); |
| } |
| } |
| |
| void CreateTableColumns( Reference< XTableColumns > xTableColumns, const std::set< sal_Int32 >& rColumns, sal_Int32 nTableRight ) |
| { |
| if ( rColumns.size() > 1 ) |
| xTableColumns->insertByIndex( 0, rColumns.size() - 1 ); |
| |
| std::set< sal_Int32 >::const_iterator aIter( rColumns.begin() ); |
| sal_Int32 nLastPosition( *aIter ); |
| Reference< XIndexAccess > xIndexAccess( xTableColumns, UNO_QUERY_THROW ); |
| for ( sal_Int32 n = 0; n < xIndexAccess->getCount(); n++ ) |
| { |
| sal_Int32 nWidth; |
| if ( ++aIter != rColumns.end() ) |
| { |
| nWidth = *aIter - nLastPosition; |
| nLastPosition = *aIter; |
| } |
| else |
| nWidth = nTableRight - nLastPosition; |
| |
| static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Width" ) ); |
| Reference< XPropertySet > xPropSet( xIndexAccess->getByIndex( n ), UNO_QUERY_THROW ); |
| xPropSet->setPropertyValue( sWidth, Any( nWidth ) ); |
| } |
| } |
| |
| void MergeCells( const Reference< XTable >& xTable, sal_Int32 nCol, sal_Int32 nRow, sal_Int32 nColSpan, sal_Int32 nRowSpan ) |
| { |
| DBG_ASSERT( (nColSpan > 1) || (nRowSpan > 1), "nonsense parameter!!" ); |
| DBG_ASSERT( (nCol >= 0) && (nCol < xTable->getColumnCount()) && (nRow >= 0) && (nRow < xTable->getRowCount()), "die celle gibts nicht!!" ); |
| DBG_ASSERT( (nColSpan >= 1) && ((nCol + nColSpan - 1) < xTable->getColumnCount()), "nColSpan murks!" ); |
| DBG_ASSERT( (nRowSpan >= 1) && ((nRow + nRowSpan - 1) < xTable->getRowCount()), "nRowSpan murks!" ); |
| |
| if( xTable.is() ) try |
| { |
| Reference< XMergeableCellRange > xRange( xTable->createCursorByRange( xTable->getCellRangeByPosition( nCol, nRow,nCol + nColSpan - 1, nRow + nRowSpan - 1 ) ), UNO_QUERY_THROW ); |
| if( xRange->isMergeable() ) |
| xRange->merge(); |
| } |
| catch( Exception& ) |
| { |
| DBG_ASSERT( false, "exception caught!" ); |
| } |
| } |
| |
| void ApplyCellAttributes( const SdrObject* pObj, Reference< XCell >& xCell ) |
| { |
| try |
| { |
| Reference< XPropertySet > xPropSet( xCell, UNO_QUERY_THROW ); |
| |
| const sal_Int32 nLeftDist(((const SdrTextLeftDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_LEFTDIST)).GetValue()); |
| const sal_Int32 nRightDist(((const SdrTextRightDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_RIGHTDIST)).GetValue()); |
| const sal_Int32 nUpperDist(((const SdrTextUpperDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_UPPERDIST)).GetValue()); |
| const sal_Int32 nLowerDist(((const SdrTextLowerDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_LOWERDIST)).GetValue()); |
| static const rtl::OUString sTopBorder( RTL_CONSTASCII_USTRINGPARAM( "TextUpperDistance" ) ); |
| static const rtl::OUString sBottomBorder( RTL_CONSTASCII_USTRINGPARAM( "TextLowerDistance" ) ); |
| static const rtl::OUString sLeftBorder( RTL_CONSTASCII_USTRINGPARAM( "TextLeftDistance" ) ); |
| static const rtl::OUString sRightBorder( RTL_CONSTASCII_USTRINGPARAM( "TextRightDistance" ) ); |
| xPropSet->setPropertyValue( sTopBorder, Any( nUpperDist ) ); |
| xPropSet->setPropertyValue( sRightBorder, Any( nRightDist ) ); |
| xPropSet->setPropertyValue( sLeftBorder, Any( nLeftDist ) ); |
| xPropSet->setPropertyValue( sBottomBorder, Any( nLowerDist ) ); |
| |
| static const rtl::OUString sTextVerticalAdjust( RTL_CONSTASCII_USTRINGPARAM( "TextVerticalAdjust" ) ); |
| const SdrTextVertAdjust eTextVertAdjust(((const SdrTextVertAdjustItem&)pObj->GetMergedItem(SDRATTR_TEXT_VERTADJUST)).GetValue()); |
| drawing::TextVerticalAdjust eVA( drawing::TextVerticalAdjust_TOP ); |
| if ( eTextVertAdjust == SDRTEXTVERTADJUST_CENTER ) |
| eVA = drawing::TextVerticalAdjust_CENTER; |
| else if ( eTextVertAdjust == SDRTEXTVERTADJUST_BOTTOM ) |
| eVA = drawing::TextVerticalAdjust_BOTTOM; |
| xPropSet->setPropertyValue( sTextVerticalAdjust, Any( eVA ) ); |
| |
| //set textHorizontalAdjust and TextWritingMode attr |
| const sal_Int32 eHA(((const SdrTextLeftDistItem&)pObj->GetMergedItem(SDRATTR_TEXT_HORZADJUST)).GetValue()); |
| const SvxFrameDirection eDirection = (const SvxFrameDirection)((( const SvxFrameDirectionItem&)pObj->GetMergedItem(EE_PARA_WRITINGDIR)).GetValue()); |
| static const rtl::OUString sHorizontalAdjust( RTL_CONSTASCII_USTRINGPARAM( "TextHorizontalAdjust" ) ); |
| static const rtl::OUString sWritingMode( RTL_CONSTASCII_USTRINGPARAM("TextWritingMode") ); |
| xPropSet->setPropertyValue( sHorizontalAdjust , Any( eHA ) ); |
| if ( eDirection == FRMDIR_VERT_TOP_RIGHT ) |
| {//vertical writing |
| xPropSet->setPropertyValue( sWritingMode , Any( ::com::sun::star::text::WritingMode_TB_RL ) ); |
| } |
| SfxItemSet aSet( pObj->GetMergedItemSet() ); |
| XFillStyle eFillStyle(((XFillStyleItem&)pObj->GetMergedItem( XATTR_FILLSTYLE )).GetValue()); |
| ::com::sun::star::drawing::FillStyle eFS( com::sun::star::drawing::FillStyle_NONE ); |
| switch( eFillStyle ) |
| { |
| case XFILL_SOLID : |
| { |
| static const rtl::OUString sFillColor( String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) ); |
| eFS = com::sun::star::drawing::FillStyle_SOLID; |
| Color aFillColor( ((XFillColorItem&)pObj->GetMergedItem( XATTR_FILLCOLOR )).GetColorValue() ); |
| sal_Int32 nFillColor( aFillColor.GetColor() ); |
| xPropSet->setPropertyValue( sFillColor, Any( nFillColor ) ); |
| } |
| break; |
| case XFILL_GRADIENT : |
| { |
| eFS = com::sun::star::drawing::FillStyle_GRADIENT; |
| XGradient aXGradient(((const XFillGradientItem&)pObj->GetMergedItem(XATTR_FILLGRADIENT)).GetGradientValue()); |
| |
| com::sun::star::awt::Gradient aGradient; |
| aGradient.Style = (awt::GradientStyle) aXGradient.GetGradientStyle(); |
| aGradient.StartColor = (sal_Int32)aXGradient.GetStartColor().GetColor(); |
| aGradient.EndColor = (sal_Int32)aXGradient.GetEndColor().GetColor(); |
| aGradient.Angle = (short)aXGradient.GetAngle(); |
| aGradient.Border = aXGradient.GetBorder(); |
| aGradient.XOffset = aXGradient.GetXOffset(); |
| aGradient.YOffset = aXGradient.GetYOffset(); |
| aGradient.StartIntensity = aXGradient.GetStartIntens(); |
| aGradient.EndIntensity = aXGradient.GetEndIntens(); |
| aGradient.StepCount = aXGradient.GetSteps(); |
| |
| static const rtl::OUString sFillGradient( String( RTL_CONSTASCII_USTRINGPARAM( "FillGradient" ) ) ); |
| xPropSet->setPropertyValue( sFillGradient, Any( aGradient ) ); |
| } |
| break; |
| case XFILL_HATCH : |
| eFS = com::sun::star::drawing::FillStyle_HATCH; |
| break; |
| case XFILL_BITMAP : |
| { |
| eFS = com::sun::star::drawing::FillStyle_BITMAP; |
| |
| const XFillBitmapItem aXFillBitmapItem((const XFillBitmapItem&)pObj->GetMergedItem( XATTR_FILLBITMAP )); |
| rtl::OUString aURL( RTL_CONSTASCII_USTRINGPARAM(UNO_NAME_GRAPHOBJ_URLPREFIX)); |
| aURL += rtl::OUString::createFromAscii(aXFillBitmapItem.GetGraphicObject().GetUniqueID().GetBuffer()); |
| |
| static const rtl::OUString sFillBitmapURL( String( RTL_CONSTASCII_USTRINGPARAM( "FillBitmapURL" ) ) ); |
| xPropSet->setPropertyValue( sFillBitmapURL, Any( aURL ) ); |
| |
| static const rtl::OUString sFillBitmapMode( String( RTL_CONSTASCII_USTRINGPARAM( "FillBitmapMode" ) ) ); |
| const XFillBmpStretchItem aStretchItem(( const XFillBmpStretchItem&)pObj->GetMergedItem( XATTR_FILLBMP_STRETCH )); |
| const XFillBmpTileItem aTileItem(( const XFillBmpTileItem&)pObj->GetMergedItem( XATTR_FILLBMP_TILE )); |
| if( aTileItem.GetValue() ) |
| xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_REPEAT ) ); |
| else if( aStretchItem.GetValue() ) |
| xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_STRETCH ) ); |
| else |
| xPropSet->setPropertyValue( sFillBitmapMode, Any( com::sun::star::drawing::BitmapMode_NO_REPEAT ) ); |
| } |
| break; |
| case XFILL_NONE : |
| eFS = com::sun::star::drawing::FillStyle_NONE; |
| break; |
| |
| } |
| static const rtl::OUString sFillStyle( String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) ); |
| xPropSet->setPropertyValue( sFillStyle, Any( eFS ) ); |
| if ( eFillStyle != XFILL_NONE ) |
| { |
| sal_Int16 nFillTransparence( ( (const XFillTransparenceItem&)pObj->GetMergedItem( XATTR_FILLTRANSPARENCE ) ).GetValue() ); |
| static const rtl::OUString sFillTransparence( String( RTL_CONSTASCII_USTRINGPARAM( "FillTransparence" ) ) ); |
| xPropSet->setPropertyValue( sFillTransparence, Any( nFillTransparence ) ); |
| } |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| |
| void ApplyCellLineAttributes( const SdrObject* pLine, Reference< XTable >& xTable, const std::vector< sal_Int32 > vPositions, sal_Int32 nColumns ) |
| { |
| try |
| { |
| SfxItemSet aSet( pLine->GetMergedItemSet() ); |
| XLineStyle eLineStyle(((XLineStyleItem&)pLine->GetMergedItem( XATTR_LINESTYLE )).GetValue()); |
| com::sun::star::table::BorderLine aBorderLine; |
| switch( eLineStyle ) |
| { |
| case XLINE_DASH : |
| case XLINE_SOLID : |
| { |
| Color aLineColor( ((XLineColorItem&)pLine->GetMergedItem( XATTR_LINECOLOR )).GetColorValue() ); |
| aBorderLine.Color = aLineColor.GetColor(); |
| // Avoid width = 0, the min value should be 1. |
| aBorderLine.OuterLineWidth = std::max( static_cast< sal_Int16 >( 1 ), static_cast< sal_Int16 >( ((const XLineWidthItem&)(pLine->GetMergedItem(XATTR_LINEWIDTH))).GetValue() / 4) ); |
| aBorderLine.InnerLineWidth = std::max( static_cast< sal_Int16 >( 1 ), static_cast< sal_Int16 >( ((const XLineWidthItem&)(pLine->GetMergedItem(XATTR_LINEWIDTH))).GetValue() / 4) ); |
| aBorderLine.LineDistance = 0; |
| } |
| break; |
| case XLINE_NONE : |
| { |
| aBorderLine.OuterLineWidth = 0; |
| aBorderLine.InnerLineWidth = 0; |
| aBorderLine.LineDistance = 0; |
| } |
| break; |
| } |
| Reference< XCellRange > xCellRange( xTable, UNO_QUERY_THROW ); |
| std::vector< sal_Int32 >::const_iterator aIter( vPositions.begin() ); |
| while( aIter != vPositions.end() ) |
| { |
| static const rtl::OUString sTopBorder( String( RTL_CONSTASCII_USTRINGPARAM( "TopBorder" ) ) ); |
| static const rtl::OUString sBottomBorder( String( RTL_CONSTASCII_USTRINGPARAM( "BottomBorder" ) ) ); |
| static const rtl::OUString sLeftBorder( String( RTL_CONSTASCII_USTRINGPARAM( "LeftBorder" ) ) ); |
| static const rtl::OUString sRightBorder( String( RTL_CONSTASCII_USTRINGPARAM( "RightBorder" ) ) ); |
| static const rtl::OUString sDiagonalTLBR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalTLBR" ) ); |
| static const rtl::OUString sDiagonalBLTR( RTL_CONSTASCII_USTRINGPARAM ( "DiagonalBLTR" ) ); |
| |
| sal_Int32 nPosition = *aIter & 0xffffff; |
| sal_Int32 nFlags = *aIter &~0xffffff; |
| sal_Int32 nRow = nPosition / nColumns; |
| sal_Int32 nColumn = nPosition - ( nRow * nColumns ); |
| Reference< XCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ) ); |
| Reference< XPropertySet > xPropSet( xCell, UNO_QUERY_THROW ); |
| |
| if ( nFlags & LinePositionLeft ) |
| xPropSet->setPropertyValue( sLeftBorder, Any( aBorderLine ) ); |
| if ( nFlags & LinePositionTop ) |
| xPropSet->setPropertyValue( sTopBorder, Any( aBorderLine ) ); |
| if ( nFlags & LinePositionRight ) |
| xPropSet->setPropertyValue( sRightBorder, Any( aBorderLine ) ); |
| if ( nFlags & LinePositionBottom ) |
| xPropSet->setPropertyValue( sBottomBorder, Any( aBorderLine ) ); |
| if ( nFlags & LinePositionTLBR ) |
| xPropSet->setPropertyValue( sDiagonalTLBR, Any( sal_True ) ); |
| if ( nFlags & LinePositionBLTR ) |
| xPropSet->setPropertyValue( sDiagonalBLTR, Any( sal_True ) ); |
| aIter++; |
| } |
| } |
| catch( Exception& ) |
| { |
| } |
| } |
| |
| SdrObject* SdrPowerPointImport::CreateTable( SdrObject* pGroup, sal_uInt32* pTableArry, SvxMSDffSolverContainer* pSolverContainer ) |
| { |
| SdrObject* pRet = pGroup; |
| sal_uInt32 nRows = pTableArry[ 1 ]; |
| if ( nRows && pGroup->ISA( SdrObjGroup ) ) |
| { |
| SdrObjList* pSubList(((SdrObjGroup*)pGroup)->GetSubList()); |
| if ( pSubList ) |
| { |
| std::set< sal_Int32 > aRows; |
| std::set< sal_Int32 > aColumns; |
| |
| SdrObjListIter aGroupIter( *pSubList, IM_DEEPNOGROUPS, sal_False ); |
| while( aGroupIter.IsMore() ) |
| { |
| const SdrObject* pObj( aGroupIter.Next() ); |
| if ( !IsLine( pObj ) ) |
| { |
| Rectangle aSnapRect( pObj->GetSnapRect() ); |
| aRows.insert( aSnapRect.Top() ); |
| aColumns.insert( aSnapRect.Left() ); |
| } |
| } |
| ::sdr::table::SdrTableObj* pTable = new ::sdr::table::SdrTableObj( pSdrModel ); |
| pTable->uno_lock(); |
| Reference< XTable > xTable( pTable->getTable() ); |
| try |
| { |
| Reference< XColumnRowRange > xColumnRowRange( xTable, UNO_QUERY_THROW ); |
| |
| CreateTableRows( xColumnRowRange->getRows(), aRows, pGroup->GetSnapRect().Bottom() ); |
| CreateTableColumns( xColumnRowRange->getColumns(), aColumns, pGroup->GetSnapRect().Right() ); |
| |
| sal_Int32 nCellCount = aRows.size() * aColumns.size(); |
| sal_Int32 *pMergedCellIndexTable = new sal_Int32[ nCellCount ]; |
| for ( sal_Int32 i = 0; i < nCellCount; i++ ) |
| pMergedCellIndexTable[ i ] = i; |
| |
| aGroupIter.Reset(); |
| while( aGroupIter.IsMore() ) |
| { |
| SdrObject* pObj( aGroupIter.Next() ); |
| if ( !IsLine( pObj ) ) |
| { |
| Rectangle aSnapRect( pObj->GetSnapRect() ); |
| sal_Int32 nTableIndex = 0; |
| sal_Int32 nRow = 0; |
| sal_Int32 nRowCount = 0; |
| sal_Int32 nColumn = 0; |
| sal_Int32 nColumnCount = 0; |
| if ( GetCellPosition( pObj, aRows, aColumns, nTableIndex, nRow, nRowCount, nColumn, nColumnCount ) ) |
| { |
| Reference< XCellRange > xCellRange( xTable, UNO_QUERY_THROW ); |
| Reference< XCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ) ); |
| |
| ApplyCellAttributes( pObj, xCell ); |
| |
| if ( ( nRowCount > 1 ) || ( nColumnCount > 1 ) ) // cell merging |
| { |
| MergeCells( xTable, nColumn, nRow, nColumnCount, nRowCount ); |
| for ( sal_Int32 nRowIter = 0; nRowIter < nRowCount; nRowIter++ ) |
| { |
| for ( sal_Int32 nColumnIter = 0; nColumnIter < nColumnCount; nColumnIter++ ) |
| { // now set the correct index for the merged cell |
| pMergedCellIndexTable[ ( ( nRow + nRowIter ) * aColumns.size() ) + nColumn + nColumnIter ] = nTableIndex; |
| } |
| } |
| } |
| |
| // applying text |
| OutlinerParaObject* pParaObject = pObj->GetOutlinerParaObject(); |
| if ( pParaObject ) |
| { |
| SdrText* pSdrText = pTable->getText( nTableIndex ); |
| if ( pSdrText ) |
| pSdrText->SetOutlinerParaObject(new OutlinerParaObject(*pParaObject) ); |
| } |
| } |
| } |
| } |
| aGroupIter.Reset(); |
| while( aGroupIter.IsMore() ) |
| { |
| SdrObject* pObj( aGroupIter.Next() ); |
| if ( IsLine( pObj ) ) |
| { |
| std::vector< sal_Int32 > vPositions; // containing cell indexes + cell position |
| GetLinePositions( pObj, aRows, aColumns, vPositions, pGroup->GetSnapRect() ); |
| |
| // correcting merged cell position |
| std::vector< sal_Int32 >::iterator aIter( vPositions.begin() ); |
| while( aIter != vPositions.end() ) |
| { |
| sal_Int32 nOldPosition = *aIter & 0xffff; |
| sal_Int32 nOldFlags = *aIter & 0xffff0000; |
| sal_Int32 nNewPosition = pMergedCellIndexTable[ nOldPosition ] | nOldFlags; |
| *aIter++ = nNewPosition; |
| } |
| ApplyCellLineAttributes( pObj, xTable, vPositions, aColumns.size() ); |
| } |
| } |
| delete[] pMergedCellIndexTable; |
| |
| // we are replacing the whole group object by a single table object, so |
| // possibly connections to the group object have to be removed. |
| if ( pSolverContainer ) |
| { |
| for ( SvxMSDffConnectorRule* pPtr = (SvxMSDffConnectorRule*)pSolverContainer->aCList.First(); |
| pPtr; pPtr = (SvxMSDffConnectorRule*)pSolverContainer->aCList.Next() ) |
| { |
| SdrObjListIter aIter( *pGroup, IM_DEEPWITHGROUPS ); |
| while( aIter.IsMore() ) |
| { |
| SdrObject* pPartObj = aIter.Next(); |
| if ( pPtr->pAObj == pPartObj ) |
| pPtr->pAObj = NULL; |
| if ( pPtr->pBObj == pPartObj ) |
| pPtr->pBObj = NULL; |
| } |
| //In MS, the one_row_one_col table is made up of five shape,the connector is connected to some part of a table. |
| //but in AOO, the connector is connected to the whole group table,so the connector obj is a group table when export by AOO. |
| //should process this situation when import. |
| if ( pPtr->pAObj == pGroup ) |
| pPtr->pAObj = pTable; |
| if ( pPtr->pBObj == pGroup ) |
| pPtr->pBObj = pTable; |
| } |
| } |
| pTable->uno_unlock(); |
| pTable->SetSnapRect( pGroup->GetSnapRect() ); |
| pRet = pTable; |
| |
| //Remove Objects from shape map |
| SdrObjListIter aIter( *pGroup, IM_DEEPWITHGROUPS ); |
| while( aIter.IsMore() ) |
| { |
| SdrObject* pPartObj = aIter.Next(); |
| removeShapeId( pPartObj ); |
| } |
| |
| SdrObject::Free( pGroup ); |
| } |
| catch( Exception& ) |
| { |
| pTable->uno_unlock(); |
| SdrObject* pObj = pTable; |
| SdrObject::Free( pObj ); |
| } |
| } |
| } |
| return pRet; |
| } |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| sal_Bool SdrPowerPointImport::IsVerticalText() const |
| { |
| sal_Bool bVerticalText = sal_False; |
| if ( IsProperty( DFF_Prop_txflTextFlow ) ) |
| { |
| MSO_TextFlow eTextFlow = (MSO_TextFlow)( GetPropertyValue( DFF_Prop_txflTextFlow ) & 0xFFFF ); |
| switch( eTextFlow ) |
| { |
| case mso_txflTtoBA : // Top to Bottom @-font, above -> below |
| case mso_txflTtoBN : // Top to Bottom non-@, above -> below |
| case mso_txflVertN : // Vertical, non-@, above -> below |
| bVerticalText = !bVerticalText; |
| break; |
| default: break; |
| } |
| } |
| |
| return bVerticalText; |
| } |
| |
| void SdrPowerPointImport::ApplyTextAnchorAttributes( PPTTextObj& rTextObj, SfxItemSet& rSet ) const |
| { |
| SdrTextVertAdjust eTVA; |
| SdrTextHorzAdjust eTHA; |
| |
| sal_uInt32 nTextFlags = rTextObj.GetTextFlags(); |
| |
| nTextFlags &= PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT |
| | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_CENTER | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_BLOCK; |
| |
| if ( IsVerticalText() ) |
| { |
| eTVA = SDRTEXTVERTADJUST_BLOCK; |
| eTHA = SDRTEXTHORZADJUST_CENTER; |
| |
| // Textverankerung lesen |
| MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop ); |
| |
| switch( eTextAnchor ) |
| { |
| case mso_anchorTop: |
| case mso_anchorTopCentered: |
| eTHA = SDRTEXTHORZADJUST_RIGHT; |
| break; |
| |
| case mso_anchorMiddle : |
| case mso_anchorMiddleCentered: |
| eTHA = SDRTEXTHORZADJUST_CENTER; |
| break; |
| |
| case mso_anchorBottom: |
| case mso_anchorBottomCentered: |
| eTHA = SDRTEXTHORZADJUST_LEFT; |
| break; |
| |
| default: |
| break; |
| } |
| // if there is a 100% use of following attributes, the textbox can been aligned also in vertical direction |
| switch ( eTextAnchor ) |
| { |
| case mso_anchorTopCentered : |
| case mso_anchorMiddleCentered : |
| case mso_anchorBottomCentered : |
| { |
| // check if it is sensible to use the centered alignment |
| sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; |
| if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left or also right aligned pararagraphs |
| eTVA = SDRTEXTVERTADJUST_CENTER; // the text has to be displayed using the full width; |
| } |
| break; |
| |
| default : |
| { |
| if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT ) |
| eTVA = SDRTEXTVERTADJUST_TOP; |
| else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT ) |
| eTVA = SDRTEXTVERTADJUST_BOTTOM; |
| } |
| break; |
| } |
| } |
| else |
| { |
| eTVA = SDRTEXTVERTADJUST_CENTER; |
| eTHA = SDRTEXTHORZADJUST_BLOCK; |
| |
| // Textverankerung lesen |
| MSO_Anchor eTextAnchor = (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop ); |
| |
| switch( eTextAnchor ) |
| { |
| case mso_anchorTop: |
| case mso_anchorTopCentered: |
| eTVA = SDRTEXTVERTADJUST_TOP; |
| break; |
| |
| case mso_anchorMiddle : |
| case mso_anchorMiddleCentered: |
| eTVA = SDRTEXTVERTADJUST_CENTER; |
| break; |
| |
| case mso_anchorBottom: |
| case mso_anchorBottomCentered: |
| eTVA = SDRTEXTVERTADJUST_BOTTOM; |
| break; |
| |
| default: |
| break; |
| } |
| // if there is a 100% usage of following attributes, the textbox can be aligned also in horizontal direction |
| switch ( eTextAnchor ) |
| { |
| case mso_anchorTopCentered : |
| case mso_anchorMiddleCentered : |
| case mso_anchorBottomCentered : |
| { |
| // check if it is sensible to use the centered alignment |
| sal_uInt32 nMask = PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT | PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT; |
| if ( ( nTextFlags & nMask ) != nMask ) // if the textobject has left or also right aligned pararagraphs |
| eTHA = SDRTEXTHORZADJUST_CENTER; // the text has to be displayed using the full width; |
| } |
| break; |
| |
| default : |
| { |
| if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_LEFT ) |
| eTHA = SDRTEXTHORZADJUST_LEFT; |
| else if ( nTextFlags == PPT_TEXTOBJ_FLAGS_PARA_ALIGNMENT_USED_RIGHT ) |
| eTHA = SDRTEXTHORZADJUST_RIGHT; |
| } |
| break; |
| } |
| } |
| rSet.Put( SdrTextVertAdjustItem( eTVA ) ); |
| rSet.Put( SdrTextHorzAdjustItem( eTHA ) ); |
| } |