Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sd / source / filter / eppt / epptso.cxx
blob: 8a9f2071b97c9cb2c986dc8f15ec53229878790b [file] [log] [blame]
/**************************************************************
*
* 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_sd.hxx"
#include <osl/endian.h>
#include <eppt.hxx>
#include "epptdef.hxx"
#ifndef _PptEscherEx_HXX
#include "escherex.hxx"
#endif
#include <tools/poly.hxx>
#include <vcl/bmpacc.hxx>
#include <vcl/gradient.hxx>
#include <vcl/gfxlink.hxx>
#include <tools/stream.hxx>
#include <sot/storage.hxx>
#include <vcl/outdev.hxx>
#include <vcl/virdev.hxx>
#include <vcl/gradient.hxx>
#include <sfx2/app.hxx>
#include <svl/languageoptions.hxx>
//#ifndef _SVX_XIT_HXX
//#include <svx/xit.hxx>
//#endif
#include <editeng/svxenum.hxx>
#include <svx/unoapi.hxx>
#include <svx/svdoashp.hxx>
#include <com/sun/star/style/VerticalAlignment.hpp>
#include <com/sun/star/container/XIndexReplace.hpp>
#include <com/sun/star/presentation/XPresentationPage.hpp>
#include <com/sun/star/awt/XFont.hpp>
#ifndef _COM_SUN_STAR_AWT_XFONTWEIGHT_HPP_
#include <com/sun/star/awt/FontWeight.hpp>
#endif
#ifndef _COM_SUN_STAR_AWT_XFONTUNDERLINE_HPP_
#include <com/sun/star/awt/FontUnderline.hpp>
#endif
#include <com/sun/star/style/ParagraphAdjust.hpp>
#include <com/sun/star/style/LineSpacing.hpp>
#include <com/sun/star/style/LineSpacingMode.hpp>
#ifndef _COM_SUN_STAR_STYLE_XSTYLEFAMILIESSUPPLIER_PP_
#include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
#endif
#include <com/sun/star/style/XStyle.hpp>
#include <com/sun/star/drawing/PointSequence.hpp>
#include <com/sun/star/drawing/FlagSequence.hpp>
#include <com/sun/star/drawing/PolygonFlags.hpp>
#include <com/sun/star/beans/PropertyValue.hpp>
#include <com/sun/star/drawing/XControlShape.hpp>
#include <comphelper/processfactory.hxx>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/i18n/XBreakIterator.hpp>
#include <com/sun/star/i18n/XScriptTypeDetector.hpp>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <com/sun/star/i18n/ScriptDirection.hpp>
#include <com/sun/star/embed/Aspects.hpp>
#include <vcl/cvtgrf.hxx>
#include <tools/urlobj.hxx>
#ifndef _CPPUHELPER_EXTRACT_HXX_
#include <comphelper/extract.hxx>
#endif
#ifndef _CPPUHELPER_PROPTYPEHLP_HXX_
#include <cppuhelper/proptypehlp.hxx>
#endif
#ifndef _UCBHELPER_CONTENT_HXX_
#include <ucbhelper/content.hxx>
#endif
#ifndef _UCBHELPER_CONTENTBROKER_HXX_
#include <ucbhelper/contentbroker.hxx>
#endif
#ifndef _TOOLKIT_UNOHLP_HXX
#include <toolkit/unohlp.hxx>
#endif
#include <rtl/crc.h>
#include <sot/clsids.hxx>
#include <unotools/ucbstreamhelper.hxx>
#include <com/sun/star/text/FontRelief.hpp>
#include <editeng/frmdiritem.hxx>
/*
#include <editeng/outliner.hxx>
#include <editeng/outlobj.hxx>
#include <svx/svdmodel.hxx>
*/
#include <svtools/fltcall.hxx>
#include <com/sun/star/table/XTable.hpp>
#include <com/sun/star/table/XMergeableCell.hpp>
#include <com/sun/star/table/BorderLine.hpp>
#include <set>
//#include <svx/xbtmpit.hxx>
#include "i18npool/mslangid.hxx"
#include <vos/xception.hxx>
using namespace vos;
using namespace ::com::sun::star;
////////////////////////////////////////////////////////////////////////////////////////////////////
#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
// ---------------------------------------------------------------------------------------------
com::sun::star::uno::Reference< com::sun::star::i18n::XBreakIterator > xPPTBreakIter;
com::sun::star::uno::Reference< com::sun::star::i18n::XScriptTypeDetector > xScriptTypeDetector;
PPTExBulletProvider::PPTExBulletProvider()
{
pGraphicProv = new EscherGraphicProvider( _E_GRAPH_PROV_USE_INSTANCES | _E_GRAPH_PROV_DO_NOT_ROTATE_METAFILES );
}
PPTExBulletProvider::~PPTExBulletProvider()
{
delete pGraphicProv;
}
sal_uInt16 PPTExBulletProvider::GetId( const ByteString& rUniqueId, Size& rGraphicSize )
{
sal_uInt16 nRetValue = 0xffff;
sal_uInt32 nId = 0;
if ( rUniqueId.Len() )
{
Rectangle aRect;
GraphicObject aGraphicObject( rUniqueId );
Graphic aMappedGraphic, aGraphic( aGraphicObject.GetGraphic() );
Size aPrefSize( aGraphic.GetPrefSize() );
BitmapEx aBmpEx( aGraphic.GetBitmapEx() );
if ( rGraphicSize.Width() && rGraphicSize.Height() )
{
double fQ1 = ( (double)aPrefSize.Width() / (double)aPrefSize.Height() );
double fQ2 = ( (double)rGraphicSize.Width() / (double)rGraphicSize.Height() );
double fXScale = 1;
double fYScale = 1;
if ( fQ1 > fQ2 )
fYScale = fQ1 / fQ2;
else if ( fQ1 < fQ2 )
fXScale = fQ2 / fQ1;
if ( ( fXScale != 1.0 ) || ( fYScale != 1.0 ) )
{
aBmpEx.Scale( fXScale, fYScale );
Size aNewSize( (sal_Int32)((double)rGraphicSize.Width() / fXScale + 0.5 ),
(sal_Int32)((double)rGraphicSize.Height() / fYScale + 0.5 ) );
rGraphicSize = aNewSize;
aMappedGraphic = Graphic( aBmpEx );
aGraphicObject = GraphicObject( aMappedGraphic );
}
}
nId = pGraphicProv->GetBlibID( aBuExPictureStream, aGraphicObject.GetUniqueID(), aRect, NULL, NULL );
if ( nId && ( nId < 0x10000 ) )
nRetValue = (sal_uInt16)nId - 1;
}
return nRetValue;
}
// ---------------------------------------------------------------------------------------------
GroupTable::GroupTable() :
mnCurrentGroupEntry ( 0 ),
mnMaxGroupEntry ( 0 ),
mnGroupsClosed ( 0 ),
mpGroupEntry ( NULL )
{
ImplResizeGroupTable( 32 );
}
// ---------------------------------------------------------------------------------------------
GroupTable::~GroupTable()
{
for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; delete mpGroupEntry[ i++ ] ) ;
delete[] mpGroupEntry;
}
// ---------------------------------------------------------------------------------------------
void GroupTable::ImplResizeGroupTable( sal_uInt32 nEntrys )
{
if ( nEntrys > mnMaxGroupEntry )
{
mnMaxGroupEntry = nEntrys;
GroupEntry** pTemp = new GroupEntry*[ nEntrys ];
for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; i++ )
pTemp[ i ] = mpGroupEntry[ i ];
if ( mpGroupEntry )
delete[] mpGroupEntry;
mpGroupEntry = pTemp;
}
}
// ---------------------------------------------------------------------------------------------
sal_Bool GroupTable::EnterGroup( ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess >& rXIndexAccessRef )
{
sal_Bool bRet = sal_False;
if ( rXIndexAccessRef.is() )
{
GroupEntry* pNewGroup = new GroupEntry( rXIndexAccessRef );
if ( pNewGroup->mnCount )
{
if ( mnMaxGroupEntry == mnCurrentGroupEntry )
ImplResizeGroupTable( mnMaxGroupEntry + 8 );
mpGroupEntry[ mnCurrentGroupEntry++ ] = pNewGroup;
bRet = sal_True;
}
else
delete pNewGroup;
}
return bRet;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 GroupTable::GetGroupsClosed()
{
sal_uInt32 nRet = mnGroupsClosed;
mnGroupsClosed = 0;
return nRet;
}
// ---------------------------------------------------------------------------------------------
void GroupTable::ClearGroupTable()
{
for ( sal_uInt32 i = 0; i < mnCurrentGroupEntry; i++, delete mpGroupEntry[ i ] ) ;
mnCurrentGroupEntry = 0;
}
// ---------------------------------------------------------------------------------------------
void GroupTable::ResetGroupTable( sal_uInt32 nCount )
{
ClearGroupTable();
mpGroupEntry[ mnCurrentGroupEntry++ ] = new GroupEntry( nCount );
}
// ---------------------------------------------------------------------------------------------
sal_Bool GroupTable::GetNextGroupEntry()
{
while ( mnCurrentGroupEntry )
{
mnIndex = mpGroupEntry[ mnCurrentGroupEntry - 1 ]->mnCurrentPos++;
if ( mpGroupEntry[ mnCurrentGroupEntry - 1 ]->mnCount > mnIndex )
return sal_True;
delete ( mpGroupEntry[ --mnCurrentGroupEntry ] );
if ( mnCurrentGroupEntry )
mnGroupsClosed++;
}
return sal_False;
}
// ---------------------------------------------------------------------------------------------
FontCollectionEntry::~FontCollectionEntry()
{
}
// ---------------------------------------------------------------------------------------------
void FontCollectionEntry::ImplInit( const String& rName )
{
String aSubstName( GetSubsFontName( rName, SUBSFONT_ONLYONE | SUBSFONT_MS ) );
if ( aSubstName.Len() )
{
Name = aSubstName;
bIsConverted = sal_True;
}
else
{
Name = rName;
bIsConverted = sal_False;
}
}
FontCollection::~FontCollection()
{
for( void* pStr = List::First(); pStr; pStr = List::Next() )
delete (FontCollectionEntry*)pStr;
delete pVDev;
xPPTBreakIter = NULL;
xScriptTypeDetector = NULL;
}
FontCollection::FontCollection() :
pVDev ( NULL )
{
com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >
xMSF = ::comphelper::getProcessServiceFactory();
com::sun::star::uno::Reference< com::sun::star::uno::XInterface >
xInterface = xMSF->createInstance( rtl::OUString::createFromAscii( "com.sun.star.i18n.BreakIterator" ) );
if ( xInterface.is() )
xPPTBreakIter = com::sun::star::uno::Reference< com::sun::star::i18n::XBreakIterator >
( xInterface, com::sun::star::uno::UNO_QUERY );
xInterface = xMSF->createInstance( rtl::OUString::createFromAscii( "com.sun.star.i18n.ScriptTypeDetector" ) );
if ( xInterface.is() )
xScriptTypeDetector = com::sun::star::uno::Reference< com::sun::star::i18n::XScriptTypeDetector >
( xInterface, com::sun::star::uno::UNO_QUERY );
}
short FontCollection::GetScriptDirection( const String& rString ) const
{
short nRet = com::sun::star::i18n::ScriptDirection::NEUTRAL;
if ( xScriptTypeDetector.is() )
{
const rtl::OUString sT( rString );
nRet = xScriptTypeDetector->getScriptDirection( sT, 0, com::sun::star::i18n::ScriptDirection::NEUTRAL );
}
return nRet;
}
sal_uInt32 FontCollection::GetId( FontCollectionEntry& rEntry )
{
if( rEntry.Name.Len() )
{
const sal_uInt32 nFonts = GetCount();
for( sal_uInt32 i = 0; i < nFonts; i++ )
{
const FontCollectionEntry* pEntry = GetById( i );
if( pEntry->Name == rEntry.Name )
return i;
}
Font aFont;
aFont.SetCharSet( rEntry.CharSet );
aFont.SetName( rEntry.Original );
// aFont.SetFamily( rEntry.Family );
// aFont.SetPitch( rEntry.Pitch );
aFont.SetHeight( 100 );
if ( !pVDev )
pVDev = new VirtualDevice;
pVDev->SetFont( aFont );
FontMetric aMetric( pVDev->GetFontMetric() );
sal_uInt16 nTxtHeight = (sal_uInt16)aMetric.GetAscent() + (sal_uInt16)aMetric.GetDescent();
if ( nTxtHeight )
{
double fScaling = (double)nTxtHeight / 120.0;
if ( ( fScaling > 0.50 ) && ( fScaling < 1.5 ) )
rEntry.Scaling = fScaling;
}
List::Insert( new FontCollectionEntry( rEntry ), LIST_APPEND );
return nFonts;
}
return 0;
}
const FontCollectionEntry* FontCollection::GetById( sal_uInt32 nId )
{
return (FontCollectionEntry*)List::GetObject( nId );
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplVBAInfoContainer( SvStream* pStrm )
{
sal_uInt32 nSize = 28;
if ( pStrm )
{
*pStrm << (sal_uInt32)( 0x1f | ( EPP_VBAInfo << 16 ) )
<< (sal_uInt32)( nSize - 8 )
<< (sal_uInt32)( 2 | ( EPP_VBAInfoAtom << 16 ) )
<< (sal_uInt32)12;
mpPptEscherEx->InsertPersistOffset( EPP_Persist_VBAInfoAtom, pStrm->Tell() );
*pStrm << (sal_uInt32)0
<< (sal_uInt32)0
<< (sal_uInt32)1;
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplSlideViewInfoContainer( sal_uInt32 nInstance, SvStream* pStrm )
{
sal_uInt32 nSize = 111;
if ( pStrm )
{
sal_uInt8 bShowGuides = 0;
sal_uInt8 bSnapToGrid = 1;
sal_uInt8 bSnapToShape = 0;
sal_Int32 nScaling = 85;
sal_Int32 nMasterCoordinate = 0xdda;
sal_Int32 nXOrigin = -780;
sal_Int32 nYOrigin = -84;
sal_Int32 nPosition1 = 0x870;
sal_Int32 nPosition2 = 0xb40;
if ( nInstance )
{
bShowGuides = 1;
nScaling = 0x3b;
nMasterCoordinate = 0xf0c;
nXOrigin = -1752;
nYOrigin = -72;
nPosition1 = 0xb40;
nPosition2 = 0x870;
}
*pStrm << (sal_uInt32)( 0xf | ( EPP_SlideViewInfo << 16 ) | ( nInstance << 4 ) )
<< (sal_uInt32)( nSize - 8 )
<< (sal_uInt32)( EPP_SlideViewInfoAtom << 16 ) << (sal_uInt32)3
<< bShowGuides << bSnapToGrid << bSnapToShape
<< (sal_uInt32)( EPP_ViewInfoAtom << 16 ) << (sal_uInt32)52
<< nScaling << (sal_Int32)100 << nScaling << (sal_Int32)100 // scaling atom - Keeps the current scale
<< nScaling << (sal_Int32)100 << nScaling << (sal_Int32)100 // scaling atom - Keeps the previous scale
<< (sal_Int32)0x17ac << nMasterCoordinate// Origin - Keeps the origin in master coordinates
<< nXOrigin << nYOrigin // Origin
<< (sal_uInt8)1 // Bool1 varScale - Set if zoom to fit is set
<< (sal_uInt8)0 // bool1 draftMode - Not used
<< (sal_uInt16)0 // padword
<< (sal_uInt32)( ( 7 << 4 ) | ( EPP_GuideAtom << 16 ) ) << (sal_uInt32)8
<< (sal_uInt32)0 // Type of the guide. If the guide is horizontal this value is zero. If it's vertical, it's one.
<< nPosition1 // Position of the guide in master coordinates. X coordinate if it's vertical, and Y coordinate if it's horizontal.
<< (sal_uInt32)( ( 7 << 4 ) | ( EPP_GuideAtom << 16 ) ) << (sal_uInt32)8
<< (sal_Int32)1 // Type of the guide. If the guide is horizontal this value is zero. If it's vertical, it's one.
<< nPosition2; // Position of the guide in master coordinates. X coordinate if it's vertical, and Y coordinate if it's horizontal.
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplOutlineViewInfoContainer( SvStream* pStrm )
{
sal_uInt32 nSize = 68;
if ( pStrm )
{
*pStrm << (sal_uInt32)( 0xf | ( EPP_OutlineViewInfo << 16 ) ) << (sal_uInt32)( nSize - 8 )
<< (sal_uInt32)( EPP_ViewInfoAtom << 16 ) << (sal_uInt32)52
<< (sal_Int32)170 << (sal_Int32)200 << (sal_Int32)170 << (sal_Int32)200 // scaling atom - Keeps the current scale
<< (sal_Int32)170 << (sal_Int32)200 << (sal_Int32)170 << (sal_Int32)200 // scaling atom - Keeps the previous scale
<< (sal_Int32)0x17ac << 0xdda // Origin - Keeps the origin in master coordinates
<< (sal_Int32)-780 << (sal_Int32)-84 // Origin
<< (sal_uInt8)1 // bool1 varScale - Set if zoom to fit is set
<< (sal_uInt8)0 // bool1 draftMode - Not used
<< (sal_uInt16)0; // padword
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplProgBinaryTag( SvStream* pStrm )
{
sal_uInt32 nPictureStreamSize, nOutlineStreamSize, nSize = 8;
nPictureStreamSize = aBuExPictureStream.Tell();
if ( nPictureStreamSize )
nSize += nPictureStreamSize + 8;
nOutlineStreamSize = aBuExOutlineStream.Tell();
if ( nOutlineStreamSize )
nSize += nOutlineStreamSize + 8;
if ( pStrm )
{
*pStrm << (sal_uInt32)( EPP_BinaryTagData << 16 ) << (sal_uInt32)( nSize - 8 );
if ( nPictureStreamSize )
{
*pStrm << (sal_uInt32)( 0xf | ( EPP_PST_ExtendedBuGraContainer << 16 ) ) << nPictureStreamSize;
pStrm->Write( aBuExPictureStream.GetData(), nPictureStreamSize );
}
if ( nOutlineStreamSize )
{
*pStrm << (sal_uInt32)( 0xf | ( EPP_PST_ExtendedPresRuleContainer << 16 ) ) << nOutlineStreamSize;
pStrm->Write( aBuExOutlineStream.GetData(), nOutlineStreamSize );
}
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplProgBinaryTagContainer( SvStream* pStrm, SvMemoryStream* pBinTagStrm )
{
sal_uInt32 nSize = 8 + 8 + 14;
if ( pStrm )
{
*pStrm << (sal_uInt32)( 0xf | ( EPP_ProgBinaryTag << 16 ) ) << (sal_uInt32)0
<< (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)14
<< (sal_uInt32)0x5f005f << (sal_uInt32)0x50005f
<< (sal_uInt32)0x540050 << (sal_uInt16)0x39;
}
if ( pBinTagStrm )
{
sal_uInt32 nLen = pBinTagStrm->Tell();
nSize += nLen + 8;
*pStrm << (sal_uInt32)( EPP_BinaryTagData << 16 ) << nLen;
pStrm->Write( pBinTagStrm->GetData(), nLen );
}
else
nSize += ImplProgBinaryTag( pStrm );
if ( pStrm )
{
pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
*pStrm << (sal_uInt32)( nSize - 8 );
pStrm->SeekRel( nSize - 8 );
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplProgTagContainer( SvStream* pStrm, SvMemoryStream* pBinTagStrm )
{
sal_uInt32 nSize = 0;
if ( aBuExPictureStream.Tell() || aBuExOutlineStream.Tell() || pBinTagStrm )
{
nSize = 8;
if ( pStrm )
{
*pStrm << (sal_uInt32)( 0xf | ( EPP_ProgTags << 16 ) ) << (sal_uInt32)0;
}
nSize += ImplProgBinaryTagContainer( pStrm, pBinTagStrm );
if ( pStrm )
{
pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
*pStrm << (sal_uInt32)( nSize - 8 );
pStrm->SeekRel( nSize - 8 );
}
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplDocumentListContainer( SvStream* pStrm )
{
sal_uInt32 nSize = 8;
if ( pStrm )
{
*pStrm << (sal_uInt32)( ( EPP_List << 16 ) | 0xf ) << (sal_uInt32)0;
}
nSize += ImplVBAInfoContainer( pStrm );
nSize += ImplSlideViewInfoContainer( 0, pStrm );
nSize += ImplOutlineViewInfoContainer( pStrm );
nSize += ImplSlideViewInfoContainer( 1, pStrm );
nSize += ImplProgTagContainer( pStrm );
if ( pStrm )
{
pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
*pStrm << (sal_uInt32)( nSize - 8 );
pStrm->SeekRel( nSize - 8 );
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplMasterSlideListContainer( SvStream* pStrm )
{
sal_uInt32 i, nSize = 28 * mnMasterPages + 8;
if ( pStrm )
{
*pStrm << (sal_uInt32)( 0x1f | ( EPP_SlideListWithText << 16 ) ) << (sal_uInt32)( nSize - 8 );
for ( i = 0; i < mnMasterPages; i++ )
{
*pStrm << (sal_uInt32)( EPP_SlidePersistAtom << 16 ) << (sal_uInt32)20;
mpPptEscherEx->InsertPersistOffset( EPP_MAINMASTER_PERSIST_KEY | i, pStrm->Tell() );
*pStrm << (sal_uInt32)0 // psrReference - logical reference to the slide persist object ( EPP_MAINMASTER_PERSIST_KEY )
<< (sal_uInt32)0 // flags - only bit 3 used, if set then slide contains shapes other than placeholders
<< (sal_Int32)0 // numberTexts - number of placeholder texts stored with the persist object. Allows to display outline view without loading the slide persist objects
<< (sal_Int32)( 0x80000000 | i ) // slideId - Unique slide identifier, used for OLE link monikers for example
<< (sal_uInt32)0; // reserved, usualy 0
}
}
return nSize;
}
// ---------------------------------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplInsertBookmarkURL( const String& rBookmarkURL, const sal_uInt32 nType,
const String& rStringVer0, const String& rStringVer1, const String& rStringVer2, const String& rStringVer3 )
{
sal_uInt32 nHyperId = ++mnExEmbed;
rtl::OUString sBookmarkURL( rBookmarkURL );
INetURLObject aBaseURI( maBaseURI );
INetURLObject aBookmarkURI( rBookmarkURL );
if( aBaseURI.GetProtocol() == aBookmarkURI.GetProtocol() )
{
rtl::OUString aRelUrl( INetURLObject::GetRelURL( maBaseURI, rBookmarkURL,
INetURLObject::WAS_ENCODED, INetURLObject::DECODE_TO_IURI, RTL_TEXTENCODING_UTF8, INetURLObject::FSYS_DETECT ) );
if ( aRelUrl.getLength() )
sBookmarkURL = aRelUrl;
}
maHyperlink.Insert( new EPPTHyperlink( sBookmarkURL, nType ), LIST_APPEND );
*mpExEmbed << (sal_uInt16)0xf
<< (sal_uInt16)EPP_ExHyperlink
<< (sal_uInt32)0;
sal_uInt32 nHyperSize, nHyperStart = mpExEmbed->Tell();
*mpExEmbed << (sal_uInt16)0
<< (sal_uInt16)EPP_ExHyperlinkAtom
<< (sal_uInt32)4
<< nHyperId;
sal_uInt16 i, nStringLen;
nStringLen = rStringVer0.Len();
if ( nStringLen )
{
*mpExEmbed << (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)( nStringLen * 2 );
for ( i = 0; i < nStringLen; i++ )
{
*mpExEmbed << rStringVer0.GetChar( i );
}
}
nStringLen = rStringVer1.Len();
if ( nStringLen )
{
*mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x10 ) << (sal_uInt32)( nStringLen * 2 );
for ( i = 0; i < nStringLen; i++ )
{
*mpExEmbed << rStringVer1.GetChar( i );
}
}
nStringLen = rStringVer2.Len();
if ( nStringLen )
{
*mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x20 ) << (sal_uInt32)( nStringLen * 2 );
for ( i = 0; i < nStringLen; i++ )
{
*mpExEmbed << rStringVer2.GetChar( i );
}
}
nStringLen = rStringVer3.Len();
if ( nStringLen )
{
*mpExEmbed << (sal_uInt32)( ( EPP_CString << 16 ) | 0x30 ) << (sal_uInt32)( nStringLen * 2 );
for ( i = 0; i < nStringLen; i++ )
{
*mpExEmbed << rStringVer3.GetChar( i );
}
}
nHyperSize = mpExEmbed->Tell() - nHyperStart;
mpExEmbed->SeekRel( - ( (sal_Int32)nHyperSize + 4 ) );
*mpExEmbed << nHyperSize;
mpExEmbed->SeekRel( nHyperSize );
return nHyperId;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PPTWriter::ImplCloseDocument()
{
sal_uInt32 nOfs = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_Document );
if ( nOfs )
{
mpPptEscherEx->PtReplaceOrInsert( EPP_Persist_CurrentPos, mpStrm->Tell() );
mpStrm->Seek( nOfs );
// creating the TxMasterStyleAtom
SvMemoryStream aTxMasterStyleAtomStrm( 0x200, 0x200 );
{
EscherExAtom aTxMasterStyleAtom( aTxMasterStyleAtomStrm, EPP_TxMasterStyleAtom, EPP_TEXTTYPE_Other );
aTxMasterStyleAtomStrm << (sal_uInt16)5; // paragraph count
sal_uInt16 nLev;
sal_Bool bFirst = sal_True;
for ( nLev = 0; nLev < 5; nLev++ )
{
mpStyleSheet->mpParaSheet[ EPP_TEXTTYPE_Other ]->Write( aTxMasterStyleAtomStrm, mpPptEscherEx, nLev, bFirst, sal_False, mXPagePropSet );
mpStyleSheet->mpCharSheet[ EPP_TEXTTYPE_Other ]->Write( aTxMasterStyleAtomStrm, mpPptEscherEx, nLev, bFirst, sal_False, mXPagePropSet );
bFirst = sal_False;
}
}
mpExEmbed->Seek( STREAM_SEEK_TO_END );
sal_uInt32 nExEmbedSize = mpExEmbed->Tell();
// nEnviroment : Gesamtgroesse des Environment Containers
sal_uInt32 nEnvironment = maFontCollection.GetCount() * 76 // 68 bytes pro Fontenityatom und je 8 Bytes fuer die Header
+ 8 // 1 FontCollection Container
+ 20 // SrKinsoku Container
+ 18 // 1 TxSiStyleAtom
+ aTxMasterStyleAtomStrm.Tell() // 1 TxMasterStyleAtom;
+ mpStyleSheet->SizeOfTxCFStyleAtom();
sal_uInt32 nBytesToInsert = nEnvironment + 8;
if ( nExEmbedSize )
nBytesToInsert += nExEmbedSize + 8 + 12;
nBytesToInsert += maSoundCollection.GetSize();
nBytesToInsert += mpPptEscherEx->DrawingGroupContainerSize();
nBytesToInsert += ImplMasterSlideListContainer( NULL );
nBytesToInsert += ImplDocumentListContainer( NULL );
// nBytes im Stream einfuegen, und abhaengige Container anpassen
mpPptEscherEx->InsertAtCurrentPos( nBytesToInsert, false );
// CREATE HYPERLINK CONTAINER
if ( nExEmbedSize )
{
*mpStrm << (sal_uInt16)0xf
<< (sal_uInt16)EPP_ExObjList
<< (sal_uInt32)( nExEmbedSize + 12 )
<< (sal_uInt16)0
<< (sal_uInt16)EPP_ExObjListAtom
<< (sal_uInt32)4
<< (sal_uInt32)mnExEmbed;
mpPptEscherEx->InsertPersistOffset( EPP_Persist_ExObj, mpStrm->Tell() );
mpStrm->Write( mpExEmbed->GetData(), nExEmbedSize );
}
// CREATE ENVIRONMENT
*mpStrm << (sal_uInt16)0xf << (sal_uInt16)EPP_Environment << (sal_uInt32)nEnvironment;
// Open Container ( EPP_SrKinsoku )
*mpStrm << (sal_uInt16)0x2f << (sal_uInt16)EPP_SrKinsoku << (sal_uInt32)12;
mpPptEscherEx->AddAtom( 4, EPP_SrKinsokuAtom, 0, 3 );
*mpStrm << (sal_Int32)0; // SrKinsoku Level 0
// Open Container ( EPP_FontCollection )
*mpStrm << (sal_uInt16)0xf << (sal_uInt16)EPP_FontCollection << (sal_uInt32)maFontCollection.GetCount() * 76;
for ( sal_uInt32 i = 0; i < maFontCollection.GetCount(); i++ )
{
mpPptEscherEx->AddAtom( 68, EPP_FontEnityAtom, 0, i );
const FontCollectionEntry* pDesc = maFontCollection.GetById( i );
sal_uInt32 nFontLen = pDesc->Name.Len();
if ( nFontLen > 31 )
nFontLen = 31;
for ( sal_uInt16 n = 0; n < 32; n++ )
{
sal_Unicode nUniCode = 0;
if ( n < nFontLen )
nUniCode = pDesc->Name.GetChar( n );
*mpStrm << nUniCode;
}
sal_uInt8 lfCharSet = ANSI_CHARSET;
sal_uInt8 lfClipPrecision = 0;
sal_uInt8 lfQuality = 6;
sal_uInt8 lfPitchAndFamily = 0;
if ( pDesc->CharSet == RTL_TEXTENCODING_SYMBOL )
lfCharSet = SYMBOL_CHARSET;
switch( pDesc->Family )
{
case ::com::sun::star::awt::FontFamily::ROMAN :
lfPitchAndFamily |= FF_ROMAN;
break;
case ::com::sun::star::awt::FontFamily::SWISS :
lfPitchAndFamily |= FF_SWISS;
break;
case ::com::sun::star::awt::FontFamily::MODERN :
lfPitchAndFamily |= FF_MODERN;
break;
case ::com::sun::star::awt::FontFamily::SCRIPT:
lfPitchAndFamily |= FF_SCRIPT;
break;
case ::com::sun::star::awt::FontFamily::DECORATIVE:
lfPitchAndFamily |= FF_DECORATIVE;
break;
default:
lfPitchAndFamily |= FAMILY_DONTKNOW;
break;
}
switch( pDesc->Pitch )
{
case ::com::sun::star::awt::FontPitch::FIXED:
lfPitchAndFamily |= FIXED_PITCH;
break;
default:
lfPitchAndFamily |= DEFAULT_PITCH;
break;
}
*mpStrm << lfCharSet
<< lfClipPrecision
<< lfQuality
<< lfPitchAndFamily;
}
mpStyleSheet->WriteTxCFStyleAtom( *mpStrm ); // create style that is used for new standard objects
mpPptEscherEx->AddAtom( 10, EPP_TxSIStyleAtom );
*mpStrm << (sal_uInt32)7 // ?
<< (sal_Int16)2 // ?
<< (sal_uInt8)9 // ?
<< (sal_uInt8)8 // ?
<< (sal_Int16)0; // ?
mpStrm->Write( aTxMasterStyleAtomStrm.GetData(), aTxMasterStyleAtomStrm.Tell() );
maSoundCollection.Write( *mpStrm );
mpPptEscherEx->WriteDrawingGroupContainer( *mpStrm );
ImplMasterSlideListContainer( mpStrm );
ImplDocumentListContainer( mpStrm );
sal_uInt32 nOldPos = mpPptEscherEx->PtGetOffsetByID( EPP_Persist_CurrentPos );
if ( nOldPos )
{
mpStrm->Seek( nOldPos );
return sal_True;
}
}
return sal_False;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PropValue::GetPropertyValue(
::com::sun::star::uno::Any& rAny,
const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
const String& rString,
sal_Bool bTestPropertyAvailability )
{
sal_Bool bRetValue = sal_True;
if ( bTestPropertyAvailability )
{
bRetValue = sal_False;
try
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo >
aXPropSetInfo( rXPropSet->getPropertySetInfo() );
if ( aXPropSetInfo.is() )
bRetValue = aXPropSetInfo->hasPropertyByName( rString );
}
catch( ::com::sun::star::uno::Exception& )
{
bRetValue = sal_False;
}
}
if ( bRetValue )
{
try
{
rAny = rXPropSet->getPropertyValue( rString );
if ( !rAny.hasValue() )
bRetValue = sal_False;
}
catch( ::com::sun::star::uno::Exception& )
{
bRetValue = sal_False;
}
}
return bRetValue;
}
// ---------------------------------------------------------------------------------------------
::com::sun::star::beans::PropertyState PropValue::GetPropertyState(
const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
const String& rPropertyName )
{
::com::sun::star::beans::PropertyState eRetValue = ::com::sun::star::beans::PropertyState_AMBIGUOUS_VALUE;
try
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertyState > aXPropState
( rXPropSet, ::com::sun::star::uno::UNO_QUERY );
if ( aXPropState.is() )
eRetValue = aXPropState->getPropertyState( rPropertyName );
}
catch( ::com::sun::star::uno::Exception& )
{
//...
}
return eRetValue;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PropValue::ImplGetPropertyValue( const String& rString )
{
return GetPropertyValue( mAny, mXPropSet, rString );
}
// ---------------------------------------------------------------------------------------------
sal_Bool PropValue::ImplGetPropertyValue( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & aXPropSet, const String& rString )
{
return GetPropertyValue( mAny, aXPropSet, rString );
}
// ---------------------------------------------------------------------------------------------
sal_Bool PropStateValue::ImplGetPropertyValue( const String& rString, sal_Bool bGetPropertyState )
{
ePropState = ::com::sun::star::beans::PropertyState_AMBIGUOUS_VALUE;
sal_Bool bRetValue = sal_True;
#ifdef UNX
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySetInfo >
aXPropSetInfo( mXPropSet->getPropertySetInfo() );
if ( !aXPropSetInfo.is() )
return sal_False;
#endif
try
{
mAny = mXPropSet->getPropertyValue( rString );
if ( !mAny.hasValue() )
bRetValue = sal_False;
else if ( bGetPropertyState )
ePropState = mXPropState->getPropertyState( rString );
else
ePropState = ::com::sun::star::beans::PropertyState_DIRECT_VALUE;
}
catch( ::com::sun::star::uno::Exception& )
{
bRetValue = sal_False;
}
return bRetValue;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PPTWriter::ImplInitSOIface()
{
while( sal_True )
{
mXDrawPagesSupplier = ::com::sun::star::uno::Reference<
::com::sun::star::drawing::XDrawPagesSupplier >
( mXModel, ::com::sun::star::uno::UNO_QUERY );
if ( !mXDrawPagesSupplier.is() )
break;
mXMasterPagesSupplier = ::com::sun::star::uno::Reference<
::com::sun::star::drawing::XMasterPagesSupplier >
( mXModel, ::com::sun::star::uno::UNO_QUERY );
if ( !mXMasterPagesSupplier.is() )
break;
mXDrawPages = mXMasterPagesSupplier->getMasterPages();
if ( !mXDrawPages.is() )
break;
mnMasterPages = mXDrawPages->getCount();
mXDrawPages = mXDrawPagesSupplier->getDrawPages();
if( !mXDrawPages.is() )
break;
mnPages = mXDrawPages->getCount();
if ( !ImplGetPageByIndex( 0, NORMAL ) )
break;
return sal_True;
}
return sal_False;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PPTWriter::ImplSetCurrentStyleSheet( sal_uInt32 nPageNum )
{
sal_Bool bRet = sal_False;
if ( nPageNum >= maStyleSheetList.size() )
nPageNum = 0;
else
bRet = sal_True;
mpStyleSheet = maStyleSheetList[ nPageNum ];
return bRet;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PPTWriter::ImplGetPageByIndex( sal_uInt32 nIndex, PageType ePageType )
{
while( sal_True )
{
if ( ePageType != meLatestPageType )
{
switch( ePageType )
{
case NORMAL :
case NOTICE :
{
mXDrawPages = mXDrawPagesSupplier->getDrawPages();
if( !mXDrawPages.is() )
return sal_False;
}
break;
case MASTER :
{
mXDrawPages = mXMasterPagesSupplier->getMasterPages();
if( !mXDrawPages.is() )
return sal_False;
}
break;
default:
break;
}
meLatestPageType = ePageType;
}
::com::sun::star::uno::Any aAny( mXDrawPages->getByIndex( nIndex ) );
aAny >>= mXDrawPage;
if ( !mXDrawPage.is() )
break;
if ( ePageType == NOTICE )
{
::com::sun::star::uno::Reference< ::com::sun::star::presentation::XPresentationPage >
aXPresentationPage( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( !aXPresentationPage.is() )
break;
mXDrawPage = aXPresentationPage->getNotesPage();
if ( !mXDrawPage.is() )
break;
}
mXPagePropSet = ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( !mXPagePropSet.is() )
break;
mXShapes = ::com::sun::star::uno::Reference<
::com::sun::star::drawing::XShapes >
( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( !mXShapes.is() )
break;
/* try to get the "real" background PropertySet. If the normal page is not supporting this property, it is
taken the property from the master */
sal_Bool bHasBackground = GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Background" ) ), sal_True );
if ( bHasBackground )
bHasBackground = ( aAny >>= mXBackgroundPropSet );
if ( !bHasBackground )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPageTarget >
aXMasterPageTarget( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( aXMasterPageTarget.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage > aXMasterDrawPage;
aXMasterDrawPage = aXMasterPageTarget->getMasterPage();
if ( aXMasterDrawPage.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > aXMasterPagePropSet;
aXMasterPagePropSet = ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
( aXMasterDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( aXMasterPagePropSet.is() )
{
sal_Bool bBackground = GetPropertyValue( aAny, aXMasterPagePropSet,
String( RTL_CONSTASCII_USTRINGPARAM( "Background" ) ) );
if ( bBackground )
{
aAny >>= mXBackgroundPropSet;
}
}
}
}
}
return sal_True;
}
return sal_False;
}
// ---------------------------------------------------------------------------------------------
sal_Bool PPTWriter::ImplGetShapeByIndex( sal_uInt32 nIndex, sal_Bool bGroup )
{
while(sal_True)
{
if ( ( bGroup == sal_False ) || ( GetCurrentGroupLevel() == 0 ) )
{
::com::sun::star::uno::Any aAny( mXShapes->getByIndex( nIndex ) );
aAny >>= mXShape;
}
else
{
::com::sun::star::uno::Any aAny( GetCurrentGroupAccess()->getByIndex( GetCurrentGroupIndex() ) );
aAny >>= mXShape;
}
if ( !mXShape.is() )
break;
::com::sun::star::uno::Any aAny( mXShape->queryInterface( ::getCppuType( (const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >*) 0 ) ));
aAny >>= mXPropSet;
if ( !mXPropSet.is() )
break;
maPosition = ImplMapPoint( mXShape->getPosition() );
maSize = ImplMapSize( mXShape->getSize() );
maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
mType = ByteString( String( mXShape->getShapeType() ), RTL_TEXTENCODING_UTF8 );
mType.Erase( 0, 13 ); // "com.sun.star." entfernen
sal_uInt16 nPos = mType.Search( (const char*)"Shape" );
mType.Erase( nPos, 5 );
mbPresObj = mbEmptyPresObj = sal_False;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "IsPresentationObject" ) ) ) )
mAny >>= mbPresObj;
if ( mbPresObj && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "IsEmptyPresentationObject" ) ) ) )
mAny >>= mbEmptyPresObj;
mnAngle = ( PropValue::GetPropertyValue( aAny,
mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "RotateAngle" ) ), sal_True ) )
? *((sal_Int32*)aAny.getValue() )
: 0;
return sal_True;
}
return sal_False;
}
// -----------------------------------------------------------------------
sal_uInt32 PPTWriter::ImplGetMasterIndex( PageType ePageType )
{
sal_uInt32 nRetValue = 0;
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XMasterPageTarget >
aXMasterPageTarget( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( aXMasterPageTarget.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XDrawPage >
aXDrawPage = aXMasterPageTarget->getMasterPage();
if ( aXDrawPage.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
aXPropertySet( aXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( aXPropertySet.is() )
{
if ( ImplGetPropertyValue( aXPropertySet, String( RTL_CONSTASCII_USTRINGPARAM( "Number" ) ) ) )
nRetValue |= *(sal_Int16*)mAny.getValue();
if ( nRetValue & 0xffff ) // ueberlauf vermeiden
nRetValue--;
}
}
}
if ( ePageType == NOTICE )
nRetValue += mnMasterPages;
return nRetValue;
}
// -----------------------------------------------------------------------
sal_Bool PPTWriter::ImplGetStyleSheets()
{
int nInstance, nLevel;
sal_Bool bRetValue = sal_False;
sal_uInt32 nPageNum;
for ( nPageNum = 0; nPageNum < mnMasterPages; nPageNum++ )
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XNamed >
aXNamed;
::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >
aXNameAccess;
::com::sun::star::uno::Reference< ::com::sun::star::style::XStyleFamiliesSupplier >
aXStyleFamiliesSupplier( mXModel, ::com::sun::star::uno::UNO_QUERY );
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
aXPropSet( mXModel, ::com::sun::star::uno::UNO_QUERY );
sal_uInt16 nDefaultTab = ( aXPropSet.is() && ImplGetPropertyValue( aXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TabStop" ) ) ) )
? (sal_uInt16)( *(sal_Int32*)mAny.getValue() / 4.40972 )
: 1250;
maStyleSheetList.push_back( new PPTExStyleSheet( nDefaultTab, (PPTExBulletProvider&)*this ) );
ImplSetCurrentStyleSheet( nPageNum );
if ( ImplGetPageByIndex( nPageNum, MASTER ) )
aXNamed = ::com::sun::star::uno::Reference< ::com::sun::star::container::XNamed >
( mXDrawPage, ::com::sun::star::uno::UNO_QUERY );
if ( aXStyleFamiliesSupplier.is() )
aXNameAccess = aXStyleFamiliesSupplier->getStyleFamilies();
bRetValue = aXNamed.is() && aXNameAccess.is() && aXStyleFamiliesSupplier.is();
if ( bRetValue )
{
for ( nInstance = EPP_TEXTTYPE_Title; nInstance <= EPP_TEXTTYPE_CenterTitle; nInstance++ )
{
String aStyle;
String aFamily;
switch ( nInstance )
{
case EPP_TEXTTYPE_CenterTitle :
case EPP_TEXTTYPE_Title :
{
aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "title" ) );
aFamily = aXNamed->getName();
}
break;
case EPP_TEXTTYPE_Body :
{
aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "outline1" ) ); // SD_LT_SEPARATOR
aFamily = aXNamed->getName();
}
break;
case EPP_TEXTTYPE_Other :
{
aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "standard" ) );
aFamily = String( RTL_CONSTASCII_USTRINGPARAM( "graphics" ) );
}
break;
case EPP_TEXTTYPE_CenterBody :
{
aStyle = String( RTL_CONSTASCII_USTRINGPARAM( "subtitle" ) );
aFamily = aXNamed->getName();
}
break;
}
if ( aStyle.Len() && aFamily.Len() )
{
try
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >xNameAccess;
if ( aXNameAccess->hasByName( aFamily ) )
{
::com::sun::star::uno::Any aAny( aXNameAccess->getByName( aFamily ) );
if( aAny.getValue() && ::cppu::extractInterface( xNameAccess, aAny ) )
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess > aXFamily;
if ( aAny >>= aXFamily )
{
if ( aXFamily->hasByName( aStyle ) )
{
::com::sun::star::uno::Reference< ::com::sun::star::style::XStyle > xStyle;
aAny = aXFamily->getByName( aStyle );
if( aAny.getValue() && ::cppu::extractInterface( xStyle, aAny ) )
{
::com::sun::star::uno::Reference< ::com::sun::star::style::XStyle > aXStyle;
aAny >>= aXStyle;
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xPropSet( aXStyle, ::com::sun::star::uno::UNO_QUERY );
if( xPropSet.is() )
mpStyleSheet->SetStyleSheet( xPropSet, maFontCollection, nInstance, 0 );
for ( nLevel = 1; nLevel < 5; nLevel++ )
{
if ( nInstance == EPP_TEXTTYPE_Body )
{
sal_Unicode cTemp = aStyle.GetChar( aStyle.Len() - 1 );
aStyle.SetChar( aStyle.Len() - 1, ++cTemp );
if ( aXFamily->hasByName( aStyle ) )
{
aXFamily->getByName( aStyle ) >>= xStyle;
if( xStyle.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xPropertySet( xStyle, ::com::sun::star::uno::UNO_QUERY );
if ( xPropertySet.is() )
mpStyleSheet->SetStyleSheet( xPropertySet, maFontCollection, nInstance, nLevel );
}
}
}
else
mpStyleSheet->SetStyleSheet( xPropSet, maFontCollection, nInstance, nLevel );
}
}
}
}
}
}
}
catch( ::com::sun::star::uno::Exception& )
{
//
}
}
}
for ( ; nInstance <= EPP_TEXTTYPE_QuarterBody; nInstance++ )
{
}
}
}
return bRetValue;
}
// -----------------------------------------------------------------------
void PPTWriter::ImplWriteParagraphs( SvStream& rOut, TextObj& rTextObj )
{
sal_Bool bFirstParagraph = sal_True;
sal_uInt32 nCharCount;
sal_uInt32 nPropertyFlags = 0;
sal_uInt16 nDepth = 0;
sal_Int16 nLineSpacing;
int nInstance = rTextObj.GetInstance();
for ( ParagraphObj* pPara = rTextObj.First() ; pPara; pPara = rTextObj.Next(), bFirstParagraph = sal_False )
{
PortionObj* pPortion = (PortionObj*)pPara->First();
nCharCount = pPara->Count();
nDepth = pPara->nDepth;
if ( nDepth > 4)
nDepth = 4;
if ( ( pPara->meTextAdjust == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_Adjust, pPara->mnTextAdjust ) ) )
nPropertyFlags |= 0x00000800;
nLineSpacing = pPara->mnLineSpacing;
const FontCollectionEntry* pDesc = maFontCollection.GetById( pPortion->mnFont );
sal_Int16 nNormalSpacing = 100;
if ( !mbFontIndependentLineSpacing && pDesc )
{
double fN = 100.0;
fN *= pDesc->Scaling;
nNormalSpacing = (sal_Int16)( fN + 0.5 );
}
if ( !mbFontIndependentLineSpacing && bFirstParagraph && ( nLineSpacing > nNormalSpacing ) ) // sj: i28747, no replacement for fixed linespacing
{
nLineSpacing = nNormalSpacing;
nPropertyFlags |= 0x00001000;
}
else
{
if ( nLineSpacing > 0 )
{
if ( !mbFontIndependentLineSpacing && pDesc )
nLineSpacing = (sal_Int16)( (double)nLineSpacing * pDesc->Scaling + 0.5 );
}
else
{
if ( pPortion && pPortion->mnCharHeight > (sal_uInt16)( ((double)-nLineSpacing) * 0.001 * 72.0 / 2.54 ) ) // 1/100mm to point
nLineSpacing = nNormalSpacing;
else
nLineSpacing = (sal_Int16)( (double)nLineSpacing / 4.40972 );
}
if ( ( pPara->meLineSpacing == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_LineFeed, nLineSpacing ) ) )
nPropertyFlags |= 0x00001000;
}
if ( ( pPara->meLineSpacingTop == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mnLineSpacingTop ) ) )
nPropertyFlags |= 0x00002000;
if ( ( pPara->meLineSpacingBottom == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_LowerDist, pPara->mnLineSpacingBottom ) ) )
nPropertyFlags |= 0x00004000;
if ( ( pPara->meForbiddenRules == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mbForbiddenRules ) ) )
nPropertyFlags |= 0x00020000;
if ( ( pPara->meParagraphPunctation == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, ParaAttr_UpperDist, pPara->mbParagraphPunctation ) ) )
nPropertyFlags |= 0x00080000;
if ( ( pPara->meBiDi == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_BiDi, pPara->mnBiDi ) ) )
nPropertyFlags |= 0x00200000;
sal_Int32 nBuRealSize = pPara->nBulletRealSize;
sal_Int16 nBulletFlags = pPara->nBulletFlags;
if ( pPara->bExtendedParameters )
nPropertyFlags |= pPara->nParaFlags;
else
{
nPropertyFlags |= 1; // turn off bullet explicit
nBulletFlags = 0;
}
// Write nTextOfs and nBullets
if ( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_TextOfs, pPara->nTextOfs ) )
nPropertyFlags |= 0x100;
if ( mpStyleSheet->IsHardAttribute( nInstance, nDepth, ParaAttr_BulletOfs, pPara->nBulletOfs ))
nPropertyFlags |= 0x400;
FontCollectionEntry aFontDescEntry( pPara->aFontDesc.Name, pPara->aFontDesc.Family, pPara->aFontDesc.Pitch, pPara->aFontDesc.CharSet );
sal_uInt16 nFontId = (sal_uInt16)maFontCollection.GetId( aFontDescEntry );
rOut << nCharCount
<< nDepth // Level
<< (sal_uInt32)nPropertyFlags; // Paragraph Attribut Set
if ( nPropertyFlags & 0xf )
rOut << nBulletFlags;
if ( nPropertyFlags & 0x80 )
rOut << (sal_uInt16)( pPara->cBulletId );
if ( nPropertyFlags & 0x10 )
rOut << nFontId;
if ( nPropertyFlags & 0x40 )
rOut << (sal_Int16)nBuRealSize;
if ( nPropertyFlags & 0x20 )
{
sal_uInt32 nBulletColor = pPara->nBulletColor;
if ( nBulletColor == COL_AUTO )
{
sal_Bool bIsDark = sal_False;
::com::sun::star::uno::Any aAny;
if ( PropValue::GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundDark" ) ), sal_True ) )
aAny >>= bIsDark;
nBulletColor = bIsDark ? 0xffffff : 0x000000;
}
nBulletColor &= 0xffffff;
nBulletColor |= 0xfe000000;
rOut << nBulletColor;
}
if ( nPropertyFlags & 0x00000800 )
rOut << (sal_uInt16)( pPara->mnTextAdjust );
if ( nPropertyFlags & 0x00001000 )
rOut << (sal_uInt16)( nLineSpacing );
if ( nPropertyFlags & 0x00002000 )
rOut << (sal_uInt16)( pPara->mnLineSpacingTop );
if ( nPropertyFlags & 0x00004000 )
rOut << (sal_uInt16)( pPara->mnLineSpacingBottom );
if ( nPropertyFlags & 0x100 )
rOut << (sal_uInt16)(pPara->nTextOfs);
if ( nPropertyFlags & 0x400 )
rOut << (sal_uInt16)(pPara->nBulletOfs);
if ( nPropertyFlags & 0x000e0000 )
{
sal_uInt16 nAsianSettings = 0;
if ( pPara->mbForbiddenRules )
nAsianSettings |= 1;
if ( pPara->mbParagraphPunctation )
nAsianSettings |= 4;
rOut << nAsianSettings;
}
if ( nPropertyFlags & 0x200000 )
rOut << pPara->mnBiDi;
}
}
// -----------------------------------------------------------------------
void PPTWriter::ImplWritePortions( SvStream& rOut, TextObj& rTextObj )
{
sal_uInt32 nPropertyFlags, i = 0;
int nInstance = rTextObj.GetInstance();
for ( ParagraphObj* pPara = rTextObj.First(); pPara; pPara = rTextObj.Next(), i++ )
{
for ( PortionObj* pPortion = (PortionObj*)pPara->First(); pPortion; pPortion = (PortionObj*)pPara->Next() )
{
nPropertyFlags = 0;
sal_uInt32 nCharAttr = pPortion->mnCharAttr;
sal_uInt32 nCharColor = pPortion->mnCharColor;
if ( nCharColor == COL_AUTO ) // nCharColor depends to the background color
{
sal_Bool bIsDark = sal_False;
::com::sun::star::uno::Any aAny;
if ( PropValue::GetPropertyValue( aAny, mXPagePropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsBackgroundDark" ) ), sal_True ) )
aAny >>= bIsDark;
nCharColor = bIsDark ? 0xffffff : 0x000000;
}
nCharColor &= 0xffffff;
/* the portion is using the embossed or engraved attribute, which we want to map to the relief feature of PPT.
Because the relief feature of PPT is dependent to the background color, such a mapping can not always be used. */
if ( nCharAttr & 0x200 )
{
sal_uInt32 nBackgroundColor = 0xffffff;
if ( !nCharColor ) // special threatment for
nCharColor = 0xffffff; // black fontcolor
::com::sun::star::uno::Any aAny;
::com::sun::star::drawing::FillStyle aFS( ::com::sun::star::drawing::FillStyle_NONE );
if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) ) )
aAny >>= aFS;
switch( aFS )
{
case ::com::sun::star::drawing::FillStyle_GRADIENT :
{
Point aEmptyPoint = Point();
Rectangle aRect( aEmptyPoint, Size( 28000, 21000 ) );
EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect );
aPropOpt.CreateGradientProperties( mXPropSet );
aPropOpt.GetOpt( ESCHER_Prop_fillColor, nBackgroundColor );
}
break;
case ::com::sun::star::drawing::FillStyle_SOLID :
{
if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) ) )
nBackgroundColor = mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) );
}
break;
case ::com::sun::star::drawing::FillStyle_NONE :
{
::com::sun::star::uno::Any aBackAny;
::com::sun::star::drawing::FillStyle aBackFS( ::com::sun::star::drawing::FillStyle_NONE );
if ( PropValue::GetPropertyValue( aBackAny, mXBackgroundPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ) ) )
aBackAny >>= aBackFS;
switch( aBackFS )
{
case ::com::sun::star::drawing::FillStyle_GRADIENT :
{
Point aEmptyPoint = Point();
Rectangle aRect( aEmptyPoint, Size( 28000, 21000 ) );
EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect );
aPropOpt.CreateGradientProperties( mXBackgroundPropSet );
aPropOpt.GetOpt( ESCHER_Prop_fillColor, nBackgroundColor );
}
break;
case ::com::sun::star::drawing::FillStyle_SOLID :
{
if ( PropValue::GetPropertyValue( aAny, mXBackgroundPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ) ) )
nBackgroundColor = mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) );
}
break;
default:
break;
}
}
break;
default:
break;
}
sal_Int32 nB = nBackgroundColor & 0xff;
nB += (sal_uInt8)( nBackgroundColor >> 8 );
nB += (sal_uInt8)( nBackgroundColor >> 16 );
// if the background color is nearly black, relief can't been used, because the text would not be visible
if ( nB < 0x60 || ( nBackgroundColor != nCharColor ) )
{
nCharAttr &=~ 0x200;
// now check if the text is part of a group, and if the previous object has the same color than the fontcolor
// ( and if fillcolor is not available the background color ), it is sometimes
// not possible to export the 'embossed' flag
if ( ( GetCurrentGroupLevel() > 0 ) && ( GetCurrentGroupIndex() >= 1 ) )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > aGroupedShape( GetCurrentGroupAccess()->getByIndex( GetCurrentGroupIndex() - 1 ), uno::UNO_QUERY );
if( aGroupedShape.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > aPropSetOfNextShape
( aGroupedShape, ::com::sun::star::uno::UNO_QUERY );
if ( aPropSetOfNextShape.is() )
{
if ( PropValue::GetPropertyValue( aAny, aPropSetOfNextShape,
String( RTL_CONSTASCII_USTRINGPARAM( "FillColor" ) ), sal_True ) )
{
if ( nCharColor == mpPptEscherEx->GetColor( *((sal_uInt32*)aAny.getValue()) ) )
{
nCharAttr |= 0x200;
}
}
}
}
}
}
}
nCharColor |= 0xfe000000;
if ( nInstance == 4 ) // special handling for normal textobjects:
nPropertyFlags |= nCharAttr & 0x217; // not all attributes ar inherited
else
{
if ( /* ( pPortion->mnCharAttrHard & 1 ) || */
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Bold, nCharAttr ) ) )
nPropertyFlags |= 1;
if ( /* ( pPortion->mnCharAttrHard & 2 ) || */
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Italic, nCharAttr ) ) )
nPropertyFlags |= 2;
if ( /* ( pPortion->mnCharAttrHard & 4 ) || */
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Underline, nCharAttr ) ) )
nPropertyFlags |= 4;
if ( /* ( pPortion->mnCharAttrHard & 0x10 ) || */
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Shadow, nCharAttr ) ) )
nPropertyFlags |= 0x10;
if ( /* ( pPortion->mnCharAttrHard & 0x200 ) || */
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Embossed, nCharAttr ) ) )
nPropertyFlags |= 512;
}
if ( rTextObj.HasExtendedBullets() )
{
nPropertyFlags |= ( i & 0x3f ) << 10 ;
nCharAttr |= ( i & 0x3f ) << 10;
}
if ( ( pPortion->meFontName == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Font, pPortion->mnFont ) ) )
nPropertyFlags |= 0x00010000;
if ( ( pPortion->meAsianOrComplexFont == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_AsianOrComplexFont, pPortion->mnAsianOrComplexFont ) ) )
nPropertyFlags |= 0x00200000;
if ( ( pPortion->meCharHeight == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_FontHeight, pPortion->mnCharHeight ) ) )
nPropertyFlags |= 0x00020000;
if ( ( pPortion->meCharColor == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_FontColor, nCharColor & 0xffffff ) ) )
nPropertyFlags |= 0x00040000;
if ( ( pPortion->meCharEscapement == ::com::sun::star::beans::PropertyState_DIRECT_VALUE ) ||
( mpStyleSheet->IsHardAttribute( nInstance, pPara->nDepth, CharAttr_Escapement, pPortion->mnCharEscapement ) ) )
nPropertyFlags |= 0x00080000;
sal_uInt32 nCharCount = pPortion->Count();
rOut << nCharCount
<< nPropertyFlags; //PropertyFlags
if ( nPropertyFlags & 0xffff )
rOut << (sal_uInt16)( nCharAttr );
if ( nPropertyFlags & 0x00010000 )
rOut << pPortion->mnFont;
if ( nPropertyFlags & 0x00200000 )
rOut << pPortion->mnAsianOrComplexFont;
if ( nPropertyFlags & 0x00020000 )
rOut << (sal_uInt16)( pPortion->mnCharHeight );
if ( nPropertyFlags & 0x00040000 )
rOut << (sal_uInt32)nCharColor;
if ( nPropertyFlags & 0x00080000 )
rOut << pPortion->mnCharEscapement;
}
}
}
// ----------------------------------------------------------------------------------------
// laedt und konvertiert text aus shape, ergebnis ist mnTextSize gespeichert;
sal_Bool PPTWriter::ImplGetText()
{
mnTextSize = 0;
mbFontIndependentLineSpacing = sal_False;
mXText = ::com::sun::star::uno::Reference<
::com::sun::star::text::XSimpleText >
( mXShape, ::com::sun::star::uno::UNO_QUERY );
if ( mXText.is() )
{
mnTextSize = mXText->getString().getLength();
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FontIndependentLineSpacing" ) ) ), sal_True )
aAny >>= mbFontIndependentLineSpacing;
}
return ( mnTextSize != 0 );
}
// -----------------------------------------------------------------------
void PPTWriter::ImplFlipBoundingBox( EscherPropertyContainer& rPropOpt )
{
if ( mnAngle < 0 )
mnAngle = ( 36000 + mnAngle ) % 36000;
else
mnAngle = ( 36000 - ( mnAngle % 36000 ) );
double fCos = cos( (double)mnAngle * F_PI18000 );
double fSin = sin( (double)mnAngle * F_PI18000 );
double fWidthHalf = maRect.GetWidth() / 2;
double fHeightHalf = maRect.GetHeight() / 2;
double fXDiff = fCos * fWidthHalf + fSin * (-fHeightHalf);
double fYDiff = - ( fSin * fWidthHalf - fCos * ( -fHeightHalf ) );
maRect.Move( (sal_Int32)( -( fWidthHalf - fXDiff ) ), (sal_Int32)( - ( fHeightHalf + fYDiff ) ) );
mnAngle *= 655;
mnAngle += 0x8000;
mnAngle &=~0xffff; // nAngle auf volle Gradzahl runden
rPropOpt.AddOpt( ESCHER_Prop_Rotation, mnAngle );
if ( ( mnAngle >= ( 45 << 16 ) && mnAngle < ( 135 << 16 ) ) ||
( mnAngle >= ( 225 << 16 ) && mnAngle < ( 315 << 16 ) ) )
{
// In diesen beiden Bereichen steht in PPT gemeinerweise die
// BoundingBox bereits senkrecht. Daher muss diese VOR
// DER ROTATION flachgelegt werden.
::com::sun::star::awt::Point
aTopLeft( (sal_Int32)( maRect.Left() + fWidthHalf - fHeightHalf ), (sal_Int32)( maRect.Top() + fHeightHalf - fWidthHalf ) );
Size aNewSize( maRect.GetHeight(), maRect.GetWidth() );
maRect = Rectangle( Point( aTopLeft.X, aTopLeft.Y ), aNewSize );
}
}
// -----------------------------------------------------------------------
struct FieldEntry
{
sal_uInt32 nFieldType;
sal_uInt32 nFieldStartPos;
sal_uInt32 nFieldEndPos;
String aRepresentation;
String aFieldUrl;
FieldEntry( sal_uInt32 nType, sal_uInt32 nStart, sal_uInt32 nEnd )
{
nFieldType = nType;
nFieldStartPos = nStart;
nFieldEndPos = nEnd;
}
};
// -----------------------------------------------------------------------
PortionObj::PortionObj( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
FontCollection& rFontCollection ) :
mnCharAttrHard ( 0 ),
mnCharAttr ( 0 ),
mnFont ( 0 ),
mnAsianOrComplexFont( 0xffff ),
mnTextSize ( 0 ),
mbLastPortion ( sal_True ),
mpText ( NULL ),
mpFieldEntry ( NULL )
{
mXPropSet = rXPropSet;
ImplGetPortionValues( rFontCollection, sal_False );
}
PortionObj::PortionObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & rXTextRange,
sal_Bool bLast, FontCollection& rFontCollection ) :
mnCharAttrHard ( 0 ),
mnCharAttr ( 0 ),
mnFont ( 0 ),
mnAsianOrComplexFont ( 0xffff ),
mbLastPortion ( bLast ),
mpText ( NULL ),
mpFieldEntry ( NULL )
{
String aString( rXTextRange->getString() );
String aURL;
sal_Bool bRTL_endingParen = sal_False;
mnTextSize = aString.Len();
if ( bLast )
mnTextSize++;
if ( mnTextSize )
{
mpFieldEntry = NULL;
sal_uInt32 nFieldType = 0;
mXPropSet = ::com::sun::star::uno::Reference<
::com::sun::star::beans::XPropertySet >
( rXTextRange, ::com::sun::star::uno::UNO_QUERY );
mXPropState = ::com::sun::star::uno::Reference<
::com::sun::star::beans::XPropertyState >
( rXTextRange, ::com::sun::star::uno::UNO_QUERY );
sal_Bool bPropSetsValid = ( mXPropSet.is() && mXPropState.is() );
if ( bPropSetsValid )
nFieldType = ImplGetTextField( rXTextRange, mXPropSet, aURL );
if ( nFieldType )
{
mpFieldEntry = new FieldEntry( nFieldType, 0, mnTextSize );
if ( ( nFieldType >> 28 == 4 ) )
{
mpFieldEntry->aRepresentation = aString;
mpFieldEntry->aFieldUrl = aURL;
}
}
sal_Bool bSymbol = sal_False;
if ( bPropSetsValid && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSet" ) ), sal_False ) )
{
sal_Int16 nCharset;
mAny >>= nCharset;
if ( nCharset == ::com::sun::star::awt::CharSet::SYMBOL )
bSymbol = sal_True;
}
if ( mpFieldEntry && ( nFieldType & 0x800000 ) ) // placeholder ?
{
mnTextSize = 1;
if ( bLast )
mnTextSize++;
mpText = new sal_uInt16[ mnTextSize ];
mpText[ 0 ] = 0x2a;
}
else
{
const sal_Unicode* pText = aString.GetBuffer();
// For i39516 - a closing parenthesis that ends an RTL string is displayed backwards by PPT
// Solution: add a Unicode Right-to-Left Mark, following the method described in i18024
if ( bLast && pText[ aString.Len() - 1 ] == sal_Unicode(')') && rFontCollection.GetScriptDirection( aString ) == com::sun::star::i18n::ScriptDirection::RIGHT_TO_LEFT )
{
mnTextSize++;
bRTL_endingParen = sal_True;
}
mpText = new sal_uInt16[ mnTextSize ];
sal_uInt16 nChar;
for ( int i = 0; i < aString.Len(); i++ )
{
nChar = (sal_uInt16)pText[ i ];
if ( nChar == 0xa )
nChar++;
else if ( !bSymbol )
{
switch ( nChar )
{
// Currency
case 128: nChar = 0x20AC; break;
// Punctuation and other
case 130: nChar = 0x201A; break;// SINGLE LOW-9 QUOTATION MARK
case 131: nChar = 0x0192; break;// LATIN SMALL LETTER F WITH HOOK
case 132: nChar = 0x201E; break;// DOUBLE LOW-9 QUOTATION MARK
// LOW DOUBLE PRIME QUOTATION MARK
case 133: nChar = 0x2026; break;// HORIZONTAL ELLIPSES
case 134: nChar = 0x2020; break;// DAGGER
case 135: nChar = 0x2021; break;// DOUBLE DAGGER
case 136: nChar = 0x02C6; break;// MODIFIER LETTER CIRCUMFLEX ACCENT
case 137: nChar = 0x2030; break;// PER MILLE SIGN
case 138: nChar = 0x0160; break;// LATIN CAPITAL LETTER S WITH CARON
case 139: nChar = 0x2039; break;// SINGLE LEFT-POINTING ANGLE QUOTATION MARK
case 140: nChar = 0x0152; break;// LATIN CAPITAL LIGATURE OE
case 142: nChar = 0x017D; break;// LATIN CAPITAL LETTER Z WITH CARON
case 145: nChar = 0x2018; break;// LEFT SINGLE QUOTATION MARK
// MODIFIER LETTER TURNED COMMA
case 146: nChar = 0x2019; break;// RIGHT SINGLE QUOTATION MARK
// MODIFIER LETTER APOSTROPHE
case 147: nChar = 0x201C; break;// LEFT DOUBLE QUOTATION MARK
// REVERSED DOUBLE PRIME QUOTATION MARK
case 148: nChar = 0x201D; break;// RIGHT DOUBLE QUOTATION MARK
// REVERSED DOUBLE PRIME QUOTATION MARK
case 149: nChar = 0x2022; break;// BULLET
case 150: nChar = 0x2013; break;// EN DASH
case 151: nChar = 0x2014; break;// EM DASH
case 152: nChar = 0x02DC; break;// SMALL TILDE
case 153: nChar = 0x2122; break;// TRADE MARK SIGN
case 154: nChar = 0x0161; break;// LATIN SMALL LETTER S WITH CARON
case 155: nChar = 0x203A; break;// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
case 156: nChar = 0x0153; break;// LATIN SMALL LIGATURE OE
case 158: nChar = 0x017E; break;// LATIN SMALL LETTER Z WITH CARON
case 159: nChar = 0x0178; break;// LATIN CAPITAL LETTER Y WITH DIAERESIS
// case 222: nChar = 0x00B6; break;// PILCROW SIGN / PARAGRAPH SIGN
}
}
mpText[ i ] = nChar;
}
}
if ( bRTL_endingParen )
mpText[ mnTextSize - 2 ] = 0x200F; // Unicode Right-to-Left mark
if ( bLast )
mpText[ mnTextSize - 1 ] = 0xd;
if ( bPropSetsValid )
ImplGetPortionValues( rFontCollection, sal_True );
}
}
PortionObj::PortionObj( const PortionObj& rPortionObj )
: PropStateValue( rPortionObj )
{
ImplConstruct( rPortionObj );
}
PortionObj::~PortionObj()
{
ImplClear();
}
void PortionObj::Write( SvStream* pStrm, sal_Bool bLast )
{
sal_uInt32 nCount = mnTextSize;
if ( bLast && mbLastPortion )
nCount--;
for ( sal_uInt32 i = 0; i < nCount; i++ )
*pStrm << (sal_uInt16)mpText[ i ];
}
void PortionObj::ImplGetPortionValues( FontCollection& rFontCollection, sal_Bool bGetPropStateValue )
{
sal_Bool bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontName" ) ), bGetPropStateValue );
meFontName = ePropState;
if ( bOk )
{
FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
sal_uInt32 nCount = rFontCollection.GetCount();
mnFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
if ( mnFont == nCount )
{
FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSet" ) ), sal_False ) )
mAny >>= rFontDesc.CharSet;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamily" ) ), sal_False ) )
mAny >>= rFontDesc.Family;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitch" ) ), sal_False ) )
mAny >>= rFontDesc.Pitch;
}
}
sal_Int16 nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguage() );
if ( mpText && mnTextSize && xPPTBreakIter.is() )
{
rtl::OUString sT( mpText, mnTextSize );
nScriptType = xPPTBreakIter->getScriptType( sT, 0 );
}
if ( nScriptType != com::sun::star::i18n::ScriptType::COMPLEX )
{
bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontNameAsian" ) ), bGetPropStateValue );
meAsianOrComplexFont = ePropState;
if ( bOk )
{
FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
sal_uInt32 nCount = rFontCollection.GetCount();
mnAsianOrComplexFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
if ( mnAsianOrComplexFont == nCount )
{
FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSetAsian" ) ), sal_False ) )
mAny >>= rFontDesc.CharSet;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamilyAsian" ) ), sal_False ) )
mAny >>= rFontDesc.Family;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitchAsian" ) ), sal_False ) )
mAny >>= rFontDesc.Pitch;
}
}
}
else
{
bOk = ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontNameComplex" ) ), bGetPropStateValue );
meAsianOrComplexFont = ePropState;
if ( bOk )
{
FontCollectionEntry aFontDesc( *(::rtl::OUString*)mAny.getValue() );
sal_uInt32 nCount = rFontCollection.GetCount();
mnAsianOrComplexFont = (sal_uInt16)rFontCollection.GetId( aFontDesc );
if ( mnAsianOrComplexFont == nCount )
{
FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontCharSetComplex" ) ), sal_False ) )
mAny >>= rFontDesc.CharSet;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontFamilyComplex" ) ), sal_False ) )
mAny >>= rFontDesc.Family;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharFontPitchComplex" ) ), sal_False ) )
mAny >>= rFontDesc.Pitch;
}
}
}
rtl::OUString aCharHeightName, aCharWeightName, aCharLocaleName, aCharPostureName;
switch( nScriptType )
{
case com::sun::star::i18n::ScriptType::ASIAN :
{
aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeightAsian" ) );
aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeightAsian" ) );
aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocaleAsian" ) );
aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPostureAsian" ) );
break;
}
case com::sun::star::i18n::ScriptType::COMPLEX :
{
aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeightComplex" ) );
aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeightComplex" ) );
aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocaleComplex" ) );
aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPostureComplex" ) );
break;
}
default:
{
aCharHeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharHeight" ) );
aCharWeightName = String( RTL_CONSTASCII_USTRINGPARAM( "CharWeight" ) );
aCharLocaleName = String( RTL_CONSTASCII_USTRINGPARAM( "CharLocale" ) );
aCharPostureName = String( RTL_CONSTASCII_USTRINGPARAM( "CharPosture" ) );
break;
}
}
mnCharHeight = 24;
if ( GetPropertyValue( mAny, mXPropSet, aCharHeightName, sal_False ) )
{
float fVal(0.0);
if ( mAny >>= fVal )
{
mnCharHeight = (sal_uInt16)( fVal + 0.5 );
meCharHeight = GetPropertyState( mXPropSet, aCharHeightName );
}
}
if ( GetPropertyValue( mAny, mXPropSet, aCharWeightName, sal_False ) )
{
float fFloat(0.0);
if ( mAny >>= fFloat )
{
if ( fFloat >= ::com::sun::star::awt::FontWeight::SEMIBOLD )
mnCharAttr |= 1;
if ( GetPropertyState( mXPropSet, aCharWeightName ) == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
mnCharAttrHard |= 1;
}
}
if ( GetPropertyValue( mAny, mXPropSet, aCharLocaleName, sal_False ) )
{
com::sun::star::lang::Locale eLocale;
if ( mAny >>= eLocale )
meCharLocale = eLocale;
}
if ( GetPropertyValue( mAny, mXPropSet, aCharPostureName, sal_False ) )
{
::com::sun::star::awt::FontSlant aFS;
if ( mAny >>= aFS )
{
switch( aFS )
{
case ::com::sun::star::awt::FontSlant_OBLIQUE :
case ::com::sun::star::awt::FontSlant_ITALIC :
mnCharAttr |= 2;
break;
default:
break;
}
if ( GetPropertyState( mXPropSet, aCharPostureName ) == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
mnCharAttrHard |= 2;
}
}
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharUnderline" ) ), bGetPropStateValue ) )
{
sal_Int16 nVal(0);
mAny >>= nVal;
switch ( nVal )
{
case ::com::sun::star::awt::FontUnderline::SINGLE :
case ::com::sun::star::awt::FontUnderline::DOUBLE :
case ::com::sun::star::awt::FontUnderline::DOTTED :
mnCharAttr |= 4;
}
}
if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
mnCharAttrHard |= 4;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharShadowed" ) ), bGetPropStateValue ) )
{
sal_Bool bBool(sal_False);
mAny >>= bBool;
if ( bBool )
mnCharAttr |= 0x10;
}
if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
mnCharAttrHard |= 16;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharRelief" ) ), bGetPropStateValue ) )
{
sal_Int16 nVal(0);
mAny >>= nVal;
if ( nVal != ::com::sun::star::text::FontRelief::NONE )
mnCharAttr |= 512;
}
if ( ePropState == ::com::sun::star::beans::PropertyState_DIRECT_VALUE )
mnCharAttrHard |= 512;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharColor" ) ), bGetPropStateValue ) )
{
sal_uInt32 nSOColor = *( (sal_uInt32*)mAny.getValue() );
mnCharColor = nSOColor & 0xff00ff00; // green and hibyte
mnCharColor |= (sal_uInt8)( nSOColor ) << 16; // red and blue is switched
mnCharColor |= (sal_uInt8)( nSOColor >> 16 );
}
meCharColor = ePropState;
mnCharEscapement = 0;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CharEscapement" ) ), bGetPropStateValue ) )
{
mAny >>= mnCharEscapement;
if ( mnCharEscapement > 100 )
mnCharEscapement = 33;
else if ( mnCharEscapement < -100 )
mnCharEscapement = -33;
}
meCharEscapement = ePropState;
}
void PortionObj::ImplClear()
{
delete (FieldEntry*)mpFieldEntry;
delete[] mpText;
}
void PortionObj::ImplConstruct( const PortionObj& rPortionObj )
{
mbLastPortion = rPortionObj.mbLastPortion;
mnTextSize = rPortionObj.mnTextSize;
mnCharColor = rPortionObj.mnCharColor;
mnCharEscapement = rPortionObj.mnCharEscapement;
mnCharAttr = rPortionObj.mnCharAttr;
mnCharHeight = rPortionObj.mnCharHeight;
mnFont = rPortionObj.mnFont;
mnAsianOrComplexFont = rPortionObj.mnAsianOrComplexFont;
if ( rPortionObj.mpText )
{
mpText = new sal_uInt16[ mnTextSize ];
memcpy( mpText, rPortionObj.mpText, mnTextSize << 1 );
}
else
mpText = NULL;
if ( rPortionObj.mpFieldEntry )
mpFieldEntry = new FieldEntry( *( rPortionObj.mpFieldEntry ) );
else
mpFieldEntry = NULL;
}
sal_uInt32 PortionObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
{
if ( mpFieldEntry && ( !mpFieldEntry->nFieldStartPos ) )
{
mpFieldEntry->nFieldStartPos += nCurrentTextPosition;
mpFieldEntry->nFieldEndPos += nCurrentTextPosition;
}
return mnTextSize;
}
// -----------------------------------------------------------------------
// Rueckgabe: 0 = kein TextField
// bit28->31 text field type :
// 1 = Date
// 2 = Time
// 3 = SlideNumber
// 4 = Url
// 5 = DateTime
// 6 = header
// 7 = footer
// bit24->27 text field sub type (optional)
// 23-> PPT Textfield needs a placeholder
sal_uInt32 PortionObj::ImplGetTextField( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > & ,
const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet, String& rURL )
{
sal_uInt32 nRetValue = 0;
sal_Int32 nFormat;
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, rXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TextPortionType" ) ), sal_True ) )
{
String aTextFieldType( *(::rtl::OUString*)aAny.getValue() );
if ( aTextFieldType == String( RTL_CONSTASCII_USTRINGPARAM( "TextField" ) ) )
{
if ( GetPropertyValue( aAny, rXPropSet, aTextFieldType, sal_True ) )
{
::com::sun::star::uno::Reference< ::com::sun::star::text::XTextField > aXTextField;
if ( aAny >>= aXTextField )
{
if ( aXTextField.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xFieldPropSet( aXTextField, ::com::sun::star::uno::UNO_QUERY );
if ( xFieldPropSet.is() )
{
String aFieldKind( aXTextField->getPresentation( sal_True ) );
if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Date" ) ) )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
{
sal_Bool bBool;
aAny >>= bBool;
if ( !bBool ) // Fixed DateFields gibt es in PPT nicht
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Format" ) ) ), sal_True )
{
nFormat = *(sal_Int32*)aAny.getValue();
switch ( nFormat )
{
default:
case 5 :
case 4 :
case 2 : nFormat = 0; break;
case 8 :
case 9 :
case 3 : nFormat = 1; break;
case 7 :
case 6 : nFormat = 2; break;
}
nRetValue |= ( ( ( 1 << 4 ) | nFormat ) << 24 ) | 0x800000;
}
}
}
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ) )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "URL" ) ) ), sal_True )
rURL = String( *(::rtl::OUString*)aAny.getValue() );
nRetValue = 4 << 28;
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Page" ) ) )
{
nRetValue = 3 << 28 | 0x800000;
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Pages" ) ) )
{
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Time" ) ) )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
{
sal_Bool bBool;
aAny >>= bBool;
if ( !bBool )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
{
nFormat = *(sal_Int32*)aAny.getValue();
nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
}
}
}
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "File" ) ) )
{
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Table" ) ) )
{
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "ExtTime" ) ) )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFix" ) ) ), sal_True )
{
sal_Bool bBool;
aAny >>= bBool;
if ( !bBool )
{
if ( GetPropertyValue( aAny, xFieldPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Format" ) ) ), sal_True )
{
nFormat = *(sal_Int32*)aAny.getValue();
switch ( nFormat )
{
default:
case 6 :
case 7 :
case 8 :
case 2 : nFormat = 12; break;
case 3 : nFormat = 9; break;
case 5 :
case 4 : nFormat = 10; break;
}
nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
}
}
}
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "ExtFile" ) ) )
{
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Author" ) ) )
{
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "DateTime" ) ) )
{
nRetValue = 5 << 28 | 0x800000;
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Header" ) ) )
{
nRetValue = 6 << 28 | 0x800000;
}
else if ( aFieldKind == String( RTL_CONSTASCII_USTRINGPARAM( "Footer" ) ) )
{
nRetValue = 7 << 28 | 0x800000;
}
}
}
}
}
}
}
return nRetValue;
}
PortionObj& PortionObj::operator=( const PortionObj& rPortionObj )
{
if ( this != &rPortionObj )
{
ImplClear();
ImplConstruct( rPortionObj );
}
return *this;
}
// -----------------------------------------------------------------------
ParagraphObj::ParagraphObj( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rXPropSet,
PPTExBulletProvider& rProv ) :
maMapModeSrc ( MAP_100TH_MM ),
maMapModeDest ( MAP_INCH, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) )
{
mXPropSet = rXPropSet;
bExtendedParameters = sal_False;
nDepth = 0;
nBulletFlags = 0;
nParaFlags = 0;
ImplGetParagraphValues( rProv, sal_False );
}
ParagraphObj::ParagraphObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XTextContent > & rXTextContent,
ParaFlags aParaFlags, FontCollection& rFontCollection, PPTExBulletProvider& rProv ) :
maMapModeSrc ( MAP_100TH_MM ),
maMapModeDest ( MAP_INCH, Point(), Fraction( 1, 576 ), Fraction( 1, 576 ) ),
mbFirstParagraph ( aParaFlags.bFirstParagraph ),
mbLastParagraph ( aParaFlags.bLastParagraph )
{
bExtendedParameters = sal_False;
nDepth = 0;
nBulletFlags = 0;
nParaFlags = 0;
mXPropSet = ::com::sun::star::uno::Reference<
::com::sun::star::beans::XPropertySet >
( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
mXPropState = ::com::sun::star::uno::Reference<
::com::sun::star::beans::XPropertyState >
( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
if ( mXPropSet.is() && mXPropState.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumerationAccess >
aXTextPortionEA( rXTextContent, ::com::sun::star::uno::UNO_QUERY );
if ( aXTextPortionEA.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration >
aXTextPortionE( aXTextPortionEA->createEnumeration() );
if ( aXTextPortionE.is() )
{
while ( aXTextPortionE->hasMoreElements() )
{
::com::sun::star::uno::Reference< ::com::sun::star::text::XTextRange > aXCursorText;
::com::sun::star::uno::Any aAny( aXTextPortionE->nextElement() );
if ( aAny >>= aXCursorText )
{
PortionObj* pPortionObj = new PortionObj( aXCursorText, !aXTextPortionE->hasMoreElements(), rFontCollection );
if ( pPortionObj->Count() )
Insert( pPortionObj, LIST_APPEND );
else
delete pPortionObj;
}
}
}
}
ImplGetParagraphValues( rProv, sal_True );//
}
}
ParagraphObj::ParagraphObj( const ParagraphObj& rObj )
: List()
, PropStateValue()
, SOParagraph()
{
ImplConstruct( rObj );
}
ParagraphObj::~ParagraphObj()
{
ImplClear();
}
void ParagraphObj::Write( SvStream* pStrm )
{
for ( void* pPtr = First(); pPtr; pPtr = Next() )
((PortionObj*)pPtr)->Write( pStrm, mbLastParagraph );
}
void ParagraphObj::ImplClear()
{
for ( void* pPtr = First(); pPtr; pPtr = Next() )
delete (PortionObj*)pPtr;
}
void ParagraphObj::CalculateGraphicBulletSize( sal_uInt16 nFontHeight )
{
if ( ( (SvxExtNumType)nNumberingType == SVX_NUM_BITMAP ) && ( nBulletId != 0xffff ) )
{
// calculate the bulletrealsize for this grafik
if ( aBuGraSize.Width() && aBuGraSize.Height() )
{
double fCharHeight = nFontHeight;
double fLen = aBuGraSize.Height();
fCharHeight = fCharHeight * 0.2540;
double fQuo = fLen / fCharHeight;
nBulletRealSize = (sal_Int16)( fQuo + 0.5 );
if ( (sal_uInt16)nBulletRealSize > 400 )
nBulletRealSize = 400;
}
}
}
// from sw/source/filter/ww8/wrtw8num.cxx for default bullets to export to MS intact
static void lcl_SubstituteBullet(String& rNumStr, rtl_TextEncoding& rChrSet, String& rFontName)
{
sal_Unicode cChar = rNumStr.GetChar(0);
StarSymbolToMSMultiFont *pConvert = CreateStarSymbolToMSMultiFont();
String sFont = pConvert->ConvertChar(cChar);
delete pConvert;
if (sFont.Len())
{
rNumStr = static_cast< sal_Unicode >(cChar | 0xF000);
rFontName = sFont;
rChrSet = RTL_TEXTENCODING_SYMBOL;
}
else if ( (rNumStr.GetChar(0) < 0xE000 || rNumStr.GetChar(0) > 0xF8FF) )
{
/*
Ok we can't fit into a known windows unicode font, but
we are not in the private area, so we are a
standardized symbol, so turn off the symbol bit and
let words own font substitution kick in
*/
rChrSet = RTL_TEXTENCODING_UNICODE;
rFontName = ::GetFontToken(rFontName, 0);
}
else
{
/*
Well we don't have an available substition, and we're
in our private area, so give up and show a standard
bullet symbol
*/
rFontName.AssignAscii(RTL_CONSTASCII_STRINGPARAM("Wingdings"));
rNumStr = static_cast< sal_Unicode >(0x6C);
}
}
void ParagraphObj::ImplGetNumberingLevel( PPTExBulletProvider& rBuProv, sal_Int16 nNumberingDepth, sal_Bool bIsBullet, sal_Bool bGetPropStateValue )
{
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaLeftMargin" ) ) ) )
{
sal_Int32 nVal;
if ( aAny >>= nVal )
nTextOfs = static_cast< sal_Int16 >( nVal / ( 2540.0 / 576 ) + 0.5 ) ;
}
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaFirstLineIndent" ) ) ) )
{
if ( aAny >>= nBulletOfs )
nBulletOfs = static_cast< sal_Int32 >( nBulletOfs / ( 2540.0 / 576 ) + 0.5 );
}
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "NumberingIsNumber" ) ) ) )
aAny >>= bNumberingIsNumber;
::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexReplace > aXIndexReplace;
if ( bIsBullet && ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "NumberingRules" ) ), bGetPropStateValue ) )
{
if ( ( mAny >>= aXIndexReplace ) && nNumberingDepth < aXIndexReplace->getCount() )
{
mAny <<= aXIndexReplace->getByIndex( nNumberingDepth );
::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue>
aPropertySequence( *( ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue>*)mAny.getValue() );
const ::com::sun::star::beans::PropertyValue* pPropValue = aPropertySequence.getArray();
sal_Int32 nPropertyCount = aPropertySequence.getLength();
if ( nPropertyCount )
{
bExtendedParameters = sal_True;
nBulletRealSize = 100;
nMappedNumType = 0;
String aGraphicURL;
for ( sal_Int32 i = 0; i < nPropertyCount; i++ )
{
const void* pValue = pPropValue[ i ].Value.getValue();
if ( pValue )
{
::rtl::OUString aPropName( pPropValue[ i ].Name );
if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "NumberingType" ) ) )
nNumberingType = *( (sal_Int16*)pValue );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Adjust" ) ) )
nHorzAdjust = *( (sal_Int16*)pValue );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletChar" ) ) )
{
String aString( *( (String*)pValue ) );
if ( aString.Len() )
cBulletId = aString.GetChar( 0 );
}
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletFont" ) ) )
{
aFontDesc = *( (::com::sun::star::awt::FontDescriptor*)pValue );
// Our numbullet dialog has set the wrong textencoding for our "StarSymbol" font,
// instead of a Unicode encoding the encoding RTL_TEXTENCODING_SYMBOL was used.
// Because there might exist a lot of damaged documemts I added this two lines
// which fixes the bullet problem for the export.
if ( aFontDesc.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StarSymbol" ) ) )
aFontDesc.CharSet = RTL_TEXTENCODING_MS_1252;
}
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "GraphicURL" ) ) )
aGraphicURL = ( *(::rtl::OUString*)pValue );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "GraphicSize" ) ) )
{
if ( pPropValue[ i ].Value.getValueType() == ::getCppuType( (::com::sun::star::awt::Size*)0) )
{
// don't cast awt::Size to Size as on 64-bits they are not the same.
::com::sun::star::awt::Size aSize;
pPropValue[ i ].Value >>= aSize;
aBuGraSize.nA = aSize.Width;
aBuGraSize.nB = aSize.Height;
}
}
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "StartWith" ) ) )
nStartWith = *( (sal_Int16*)pValue );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "LeftMargin" ) ) )
nTextOfs = nTextOfs + static_cast< sal_Int16 >( *( (sal_Int32*)pValue ) / ( 2540.0 / 576 ) );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "FirstLineOffset" ) ) )
nBulletOfs += (sal_Int16)( *( (sal_Int32*)pValue ) / ( 2540.0 / 576 ) );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletColor" ) ) )
{
sal_uInt32 nSOColor = *( (sal_uInt32*)pValue );
nBulletColor = nSOColor & 0xff00ff00; // green and hibyte
nBulletColor |= (sal_uInt8)( nSOColor ) << 16; // red
nBulletColor |= (sal_uInt8)( nSOColor >> 16 ) | 0xfe000000; // blue
}
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "BulletRelSize" ) ) )
{
nBulletRealSize = *( (sal_Int16*)pValue );
nParaFlags |= 0x40;
nBulletFlags |= 8;
}
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Prefix" ) ) )
sPrefix = ( *(::rtl::OUString*)pValue );
else if ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Suffix" ) ) )
sSuffix = ( *(::rtl::OUString*)pValue );
#ifdef DBG_UTIL
else if ( ! (
( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "SymbolTextDistance" ) ) )
|| ( aPropName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "Graphic" ) ) ) ) )
{
DBG_ERROR( "Unbekanntes Property" );
}
#endif
}
}
if ( aGraphicURL.Len() )
{
if ( aBuGraSize.Width() && aBuGraSize.Height() )
{
xub_StrLen nIndex = aGraphicURL.Search( (sal_Unicode)':', 0 );
if ( nIndex != STRING_NOTFOUND )
{
nIndex++;
if ( aGraphicURL.Len() > nIndex )
{
ByteString aUniqueId( aGraphicURL, nIndex, aGraphicURL.Len() - nIndex, RTL_TEXTENCODING_UTF8 );
if ( aUniqueId.Len() )
{
nBulletId = rBuProv.GetId( aUniqueId, aBuGraSize );
if ( nBulletId != 0xffff )
bExtendedBulletsUsed = sal_True;
}
}
}
}
else
{
nNumberingType = SVX_NUM_NUMBER_NONE;
}
}
PortionObj* pPortion = (PortionObj*)First();
CalculateGraphicBulletSize( ( pPortion ) ? pPortion->mnCharHeight : 24 );
switch( (SvxExtNumType)nNumberingType )
{
case SVX_NUM_NUMBER_NONE : nParaFlags |= 0xf; break;
case SVX_NUM_CHAR_SPECIAL : // Bullet
{
if ( aFontDesc.Name.equalsIgnoreAsciiCaseAscii("starsymbol") ||
aFontDesc.Name.equalsIgnoreAsciiCaseAscii("opensymbol") )
{
String sFontName = aFontDesc.Name;
String sNumStr = cBulletId;
rtl_TextEncoding eChrSet = aFontDesc.CharSet;
lcl_SubstituteBullet(sNumStr,eChrSet,sFontName);
aFontDesc.Name = sFontName;
cBulletId = sNumStr.GetChar( 0 );
aFontDesc.CharSet = eChrSet;
}
if ( aFontDesc.Name.getLength() )
{
/*
if ( aFontDesc.CharSet != ::com::sun::star::awt::CharSet::SYMBOL )
{
switch ( cBulletId )
{
// Currency
case 128: cBulletId = 0x20AC; break;
// Punctuation and other
case 130: cBulletId = 0x201A; break;// SINGLE LOW-9 QUOTATION MARK
case 131: cBulletId = 0x0192; break;// LATIN SMALL LETTER F WITH HOOK
case 132: cBulletId = 0x201E; break;// DOUBLE LOW-9 QUOTATION MARK
// LOW DOUBLE PRIME QUOTATION MARK
case 133: cBulletId = 0x2026; break;// HORIZONTAL ELLIPSES
case 134: cBulletId = 0x2020; break;// DAGGER
case 135: cBulletId = 0x2021; break;// DOUBLE DAGGER
case 136: cBulletId = 0x02C6; break;// MODIFIER LETTER CIRCUMFLEX ACCENT
case 137: cBulletId = 0x2030; break;// PER MILLE SIGN
case 138: cBulletId = 0x0160; break;// LATIN CAPITAL LETTER S WITH CARON
case 139: cBulletId = 0x2039; break;// SINGLE LEFT-POINTING ANGLE QUOTATION MARK
case 140: cBulletId = 0x0152; break;// LATIN CAPITAL LIGATURE OE
case 142: cBulletId = 0x017D; break;// LATIN CAPITAL LETTER Z WITH CARON
case 145: cBulletId = 0x2018; break;// LEFT SINGLE QUOTATION MARK
// MODIFIER LETTER TURNED COMMA
case 146: cBulletId = 0x2019; break;// RIGHT SINGLE QUOTATION MARK
// MODIFIER LETTER APOSTROPHE
case 147: cBulletId = 0x201C; break;// LEFT DOUBLE QUOTATION MARK
// REVERSED DOUBLE PRIME QUOTATION MARK
case 148: cBulletId = 0x201D; break;// RIGHT DOUBLE QUOTATION MARK
// REVERSED DOUBLE PRIME QUOTATION MARK
case 149: cBulletId = 0x2022; break;// BULLET
case 150: cBulletId = 0x2013; break;// EN DASH
case 151: cBulletId = 0x2014; break;// EM DASH
case 152: cBulletId = 0x02DC; break;// SMALL TILDE
case 153: cBulletId = 0x2122; break;// TRADE MARK SIGN
case 154: cBulletId = 0x0161; break;// LATIN SMALL LETTER S WITH CARON
case 155: cBulletId = 0x203A; break;// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
case 156: cBulletId = 0x0153; break;// LATIN SMALL LIGATURE OE
case 158: cBulletId = 0x017E; break;// LATIN SMALL LETTER Z WITH CARON
case 159: cBulletId = 0x0178; break;// LATIN CAPITAL LETTER Y WITH DIAERESIS
// case 222: cBulletId = 0x00B6; break;// PILCROW SIGN / PARAGRAPH SIGN
}
}
*/
nParaFlags |= 0x90; // wir geben den Font und den Charset vor
}
}
case SVX_NUM_CHARS_UPPER_LETTER : // zaehlt von a-z, aa - az, ba - bz, ...
case SVX_NUM_CHARS_LOWER_LETTER :
case SVX_NUM_ROMAN_UPPER :
case SVX_NUM_ROMAN_LOWER :
case SVX_NUM_ARABIC :
case SVX_NUM_PAGEDESC : // Numerierung aus der Seitenvorlage
case SVX_NUM_BITMAP :
case SVX_NUM_CHARS_UPPER_LETTER_N : // zaehlt von a-z, aa-zz, aaa-zzz
case SVX_NUM_CHARS_LOWER_LETTER_N :
case SVX_NUM_NUMBER_UPPER_ZH:
case SVX_NUM_CIRCLE_NUMBER:
case SVX_NUM_NUMBER_UPPER_ZH_TW:
case SVX_NUM_NUMBER_LOWER_ZH:
case SVX_NUM_FULL_WIDTH_ARABIC:
{
if ( nNumberingType != SVX_NUM_CHAR_SPECIAL )
{
bExtendedBulletsUsed = sal_True;
if ( nNumberingDepth & 1 )
cBulletId = 0x2013; // defaulting bullet characters for ppt97
else if ( nNumberingDepth == 4 )
cBulletId = 0xbb;
else
cBulletId = 0x2022;
switch( (SvxExtNumType)nNumberingType )
{
case SVX_NUM_CHARS_UPPER_LETTER :
case SVX_NUM_CHARS_UPPER_LETTER_N :
{
if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
{
if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
nMappedNumType = 0xa0001; // (A)
else
nMappedNumType = 0xb0001; // A)
}
else
nMappedNumType = 0x10001; // A.
}
break;
case SVX_NUM_CHARS_LOWER_LETTER :
case SVX_NUM_CHARS_LOWER_LETTER_N :
{
if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
{
if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
nMappedNumType = 0x80001; // (a)
else
nMappedNumType = 0x90001; // a)
}
else
nMappedNumType = 0x00001; // a.
}
break;
case SVX_NUM_ROMAN_UPPER :
{
if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
{
if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
nMappedNumType = 0xe0001; // (I)
else
nMappedNumType = 0xf0001; // I)
}
else
nMappedNumType = 0x70001; // I.
}
break;
case SVX_NUM_ROMAN_LOWER :
{
if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
{
if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
nMappedNumType = 0x40001; // (i)
else
nMappedNumType = 0x50001; // i)
}
else
nMappedNumType = 0x60001; // i.
}
break;
case SVX_NUM_ARABIC :
{
if ( sSuffix == String( RTL_CONSTASCII_USTRINGPARAM( ")" ) ) )
{
if ( sPrefix == String( RTL_CONSTASCII_USTRINGPARAM( "(" ) ) )
nMappedNumType = 0xc0001; // (1)
else
nMappedNumType = 0x20001; // 1)
}
else
{
if ( ! ( sSuffix.Len() + sPrefix.Len() ) )
nMappedNumType = 0xd0001; // 1
else
nMappedNumType = 0x30001; // 1.
}
}
break;
case SVX_NUM_NUMBER_UPPER_ZH :
{
if ( sSuffix.Len() )
nMappedNumType = 0x110001; // Simplified Chinese with single-byte period.
else
nMappedNumType = 0x100001; // Simplified Chinese.
}
break;
case SVX_NUM_CIRCLE_NUMBER :
{
nMappedNumType = 0x120001; // Double byte circle numbers.
}
break;
case SVX_NUM_NUMBER_UPPER_ZH_TW :
{
if ( sSuffix.Len() )
nMappedNumType = 0x160001; // Traditional Chinese with single-byte period.
else
nMappedNumType = 0x150001; // Traditional Chinese.
}
break;
case SVX_NUM_NUMBER_LOWER_ZH :
{
if ( sSuffix == String( sal_Unicode(0xff0e)) )
nMappedNumType = 0x260001; // Japanese with double-byte period.
else if ( sSuffix.Len() )
nMappedNumType = 0x1B0001; // Japanese/Korean with single-byte period.
else
nMappedNumType = 0x1A0001; // Japanese/Korean.
}
break;
case SVX_NUM_FULL_WIDTH_ARABIC :
{
if ( sSuffix.Len() )
nMappedNumType = 0x1D0001; // Double-byte Arabic numbers with double-byte period.
else
nMappedNumType = 0x1C0001; // Double-byte Arabic numbers.
}
break;
default:
break;
}
}
nParaFlags |= 0x2f;
nBulletFlags |= 6;
if ( mbIsBullet && bNumberingIsNumber )
nBulletFlags |= 1;
}
default: break;
}
}
}
}
nBulletOfs = nTextOfs + nBulletOfs;
if ( nBulletOfs < 0 )
nBulletOfs = 0;
}
void ParagraphObj::ImplGetParagraphValues( PPTExBulletProvider& rBuProv, sal_Bool bGetPropStateValue )
{
static String sNumberingLevel ( RTL_CONSTASCII_USTRINGPARAM( "NumberingLevel" ) );
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, mXPropSet, sNumberingLevel, sal_True ) )
{
if ( bGetPropStateValue )
meBullet = GetPropertyState( mXPropSet, sNumberingLevel );
nDepth = *( (sal_Int16*)aAny.getValue() );
if ( nDepth < 0 )
{
mbIsBullet = sal_False;
nDepth = 0;
}
else
{
if ( nDepth > 4 )
nDepth = 4;
mbIsBullet = sal_True;
}
}
else
{
nDepth = 0;
mbIsBullet = sal_False;
}
ImplGetNumberingLevel( rBuProv, nDepth, mbIsBullet, bGetPropStateValue );
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaTabStops" ) ), bGetPropStateValue ) )
maTabStop = *( ::com::sun::star::uno::Sequence< ::com::sun::star::style::TabStop>*)mAny.getValue();
sal_Int16 eTextAdjust( ::com::sun::star::style::ParagraphAdjust_LEFT );
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "ParaAdjust" ) ), bGetPropStateValue ) )
aAny >>= eTextAdjust;
switch ( (::com::sun::star::style::ParagraphAdjust)eTextAdjust )
{
case ::com::sun::star::style::ParagraphAdjust_CENTER :
mnTextAdjust = 1;
break;
case ::com::sun::star::style::ParagraphAdjust_RIGHT :
mnTextAdjust = 2;
break;
case ::com::sun::star::style::ParagraphAdjust_BLOCK :
mnTextAdjust = 3;
break;
default :
case ::com::sun::star::style::ParagraphAdjust_LEFT :
mnTextAdjust = 0;
break;
}
meTextAdjust = ePropState;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaLineSpacing" ) ), bGetPropStateValue ) )
{
::com::sun::star::style::LineSpacing aLineSpacing
= *( (::com::sun::star::style::LineSpacing*)mAny.getValue() );
switch ( aLineSpacing.Mode )
{
case ::com::sun::star::style::LineSpacingMode::MINIMUM :
case ::com::sun::star::style::LineSpacingMode::LEADING :
case ::com::sun::star::style::LineSpacingMode::FIX :
mnLineSpacing = (sal_Int16)(-( aLineSpacing.Height ) );
break;
case ::com::sun::star::style::LineSpacingMode::PROP :
default:
mnLineSpacing = (sal_Int16)( aLineSpacing.Height );
break;
}
}
meLineSpacing = ePropState;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaBottomMargin" ) ), bGetPropStateValue ) )
{
double fSpacing = *( (sal_uInt32*)mAny.getValue() ) + ( 2540.0 / 576.0 ) - 1;
mnLineSpacingBottom = (sal_Int16)(-( fSpacing * 576.0 / 2540.0 ) );
}
meLineSpacingBottom = ePropState;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaTopMargin" ) ), bGetPropStateValue ) )
{
double fSpacing = *( (sal_uInt32*)mAny.getValue() ) + ( 2540.0 / 576.0 ) - 1;
mnLineSpacingTop = (sal_Int16)(-( fSpacing * 576.0 / 2540.0 ) );
}
meLineSpacingTop = ePropState;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaIsForbiddenRules" ) ), bGetPropStateValue ) )
mAny >>= mbForbiddenRules;
meForbiddenRules = ePropState;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "ParaIsHangingPunctuation" ) ), bGetPropStateValue ) )
mAny >>= mbParagraphPunctation;
meParagraphPunctation = ePropState;
mnBiDi = 0;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "WritingMode" ) ), bGetPropStateValue ) )
{
sal_Int16 nWritingMode;
mAny >>= nWritingMode;
SvxFrameDirection eWritingMode( (SvxFrameDirection)nWritingMode );
if ( ( eWritingMode == FRMDIR_HORI_RIGHT_TOP )
|| ( eWritingMode == FRMDIR_VERT_TOP_RIGHT ) )
{
mnBiDi = 1;
}
}
meBiDi = ePropState;
}
void ParagraphObj::ImplConstruct( const ParagraphObj& rParagraphObj )
{
mnTextSize = rParagraphObj.mnTextSize;
mnTextAdjust = rParagraphObj.mnTextAdjust;
mnLineSpacing = rParagraphObj.mnLineSpacing;
mnLineSpacingTop = rParagraphObj.mnLineSpacingTop;
mnLineSpacingBottom = rParagraphObj.mnLineSpacingBottom;
mbFirstParagraph = rParagraphObj.mbFirstParagraph;
mbLastParagraph = rParagraphObj.mbLastParagraph;
mbParagraphPunctation = rParagraphObj.mbParagraphPunctation;
mbForbiddenRules = rParagraphObj.mbForbiddenRules;
mnBiDi = rParagraphObj.mnBiDi;
ParagraphObj& rOther = const_cast<ParagraphObj&>(rParagraphObj);
for ( const void* pPtr = rOther.First(); pPtr; pPtr = rOther.Next() )
Insert( new PortionObj( *(const PortionObj*)pPtr ), LIST_APPEND );
maTabStop = rParagraphObj.maTabStop;
bExtendedParameters = rParagraphObj.bExtendedParameters;
nParaFlags = rParagraphObj.nParaFlags;
nBulletFlags = rParagraphObj.nBulletFlags;
sPrefix = rParagraphObj.sPrefix;
sSuffix = rParagraphObj.sSuffix;
sGraphicUrl = rParagraphObj.sGraphicUrl; // String auf eine Graphic
aBuGraSize = rParagraphObj.aBuGraSize;
nNumberingType = rParagraphObj.nNumberingType; // in wirlichkeit ist dies ein SvxEnum
nHorzAdjust = rParagraphObj.nHorzAdjust;
nBulletColor = rParagraphObj.nBulletColor;
nBulletOfs = rParagraphObj.nBulletOfs;
nStartWith = rParagraphObj.nStartWith; // Start der nummerierung
nTextOfs = rParagraphObj.nTextOfs;
nBulletRealSize = rParagraphObj.nBulletRealSize; // GroessenVerhaeltnis in Proz
nDepth = rParagraphObj.nDepth; // aktuelle tiefe
cBulletId = rParagraphObj.cBulletId; // wenn Numbering Type == CharSpecial
aFontDesc = rParagraphObj.aFontDesc;
bExtendedBulletsUsed = rParagraphObj.bExtendedBulletsUsed;
nBulletId = rParagraphObj.nBulletId;
}
sal_uInt32 ParagraphObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
{
mnTextSize = 0;
for ( void* pPtr = First(); pPtr; pPtr = Next() )
mnTextSize += ((PortionObj*)pPtr)->ImplCalculateTextPositions( nCurrentTextPosition + mnTextSize );
return mnTextSize;
}
ParagraphObj& ParagraphObj::operator=( const ParagraphObj& rParagraphObj )
{
if ( this != &rParagraphObj )
{
ImplClear();
ImplConstruct( rParagraphObj );
}
return *this;
}
// -----------------------------------------------------------------------
ImplTextObj::ImplTextObj( int nInstance )
{
mnRefCount = 1;
mnTextSize = 0;
mnInstance = nInstance;
mpList = new List;
mbHasExtendedBullets = sal_False;
mbFixedCellHeightUsed = sal_False;
}
ImplTextObj::~ImplTextObj()
{
for ( ParagraphObj* pPtr = (ParagraphObj*)mpList->First(); pPtr; pPtr = (ParagraphObj*)mpList->Next() )
delete pPtr;
delete mpList;
}
TextObj::TextObj( ::com::sun::star::uno::Reference< ::com::sun::star::text::XSimpleText > & rXTextRef,
int nInstance, FontCollection& rFontCollection, PPTExBulletProvider& rProv )
{
mpImplTextObj = new ImplTextObj( nInstance );
::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumerationAccess >
aXTextParagraphEA( rXTextRef, ::com::sun::star::uno::UNO_QUERY );
if ( aXTextParagraphEA.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::container::XEnumeration >
aXTextParagraphE( aXTextParagraphEA->createEnumeration() );
if ( aXTextParagraphE.is() )
{
ParaFlags aParaFlags;
while ( aXTextParagraphE->hasMoreElements() )
{
::com::sun::star::uno::Reference< ::com::sun::star::text::XTextContent > aXParagraph;
::com::sun::star::uno::Any aAny( aXTextParagraphE->nextElement() );
if ( aAny >>= aXParagraph )
{
if ( !aXTextParagraphE->hasMoreElements() )
aParaFlags.bLastParagraph = sal_True;
ParagraphObj* pPara = new ParagraphObj( aXParagraph, aParaFlags, rFontCollection, rProv );
mpImplTextObj->mbHasExtendedBullets |= pPara->bExtendedBulletsUsed;
mpImplTextObj->mpList->Insert( pPara, LIST_APPEND );
aParaFlags.bFirstParagraph = sal_False;
}
}
}
}
ImplCalculateTextPositions();
}
TextObj::TextObj( const TextObj& rTextObj )
{
mpImplTextObj = rTextObj.mpImplTextObj;
mpImplTextObj->mnRefCount++;
}
TextObj::~TextObj()
{
if ( ! ( --mpImplTextObj->mnRefCount ) )
delete mpImplTextObj;
}
void TextObj::Write( SvStream* pStrm )
{
sal_uInt32 nSize, nPos = pStrm->Tell();
*pStrm << (sal_uInt32)( EPP_TextCharsAtom << 16 ) << (sal_uInt32)0;
for ( void* pPtr = First(); pPtr; pPtr = Next() )
((ParagraphObj*)pPtr)->Write( pStrm );
nSize = pStrm->Tell() - nPos;
pStrm->SeekRel( - ( (sal_Int32)nSize - 4 ) );
*pStrm << (sal_uInt32)( nSize - 8 );
pStrm->SeekRel( nSize - 8 );
}
void TextObj::ImplCalculateTextPositions()
{
mpImplTextObj->mnTextSize = 0;
for ( void* pPtr = First(); pPtr; pPtr = Next() )
mpImplTextObj->mnTextSize += ((ParagraphObj*)pPtr)->ImplCalculateTextPositions( mpImplTextObj->mnTextSize );
}
TextObj& TextObj::operator=( TextObj& rTextObj )
{
if ( this != &rTextObj )
{
if ( ! ( --mpImplTextObj->mnRefCount ) )
delete mpImplTextObj;
mpImplTextObj = rTextObj.mpImplTextObj;
mpImplTextObj->mnRefCount++;
}
return *this;
}
void TextObj::WriteTextSpecInfo( SvStream* pStrm )
{
sal_uInt32 nCharactersLeft( Count() );
if ( nCharactersLeft >= 1 )
{
EscherExAtom aAnimationInfoAtom( *pStrm, EPP_TextSpecInfoAtom, 0, 0 );
for ( ParagraphObj* pPtr = static_cast < ParagraphObj * >( First() ); nCharactersLeft && pPtr; pPtr = static_cast< ParagraphObj* >( Next() ) )
{
for ( PortionObj* pPortion = static_cast< PortionObj* >( pPtr->First() ); nCharactersLeft && pPortion; pPortion = static_cast< PortionObj* >( pPtr->Next() ) )
{
sal_Int32 nPortionSize = pPortion->mnTextSize >= nCharactersLeft ? nCharactersLeft : pPortion->mnTextSize;
sal_Int32 nFlags = 7;
nCharactersLeft -= nPortionSize;
*pStrm << static_cast< sal_uInt32 >( nPortionSize )
<< nFlags
<< static_cast< sal_Int16 >( 1 ) // spellinfo -> needs rechecking
<< static_cast< sal_Int16 >( MsLangId::convertLocaleToLanguageWithFallback( pPortion->meCharLocale ) )
<< static_cast< sal_Int16 >( 0 ); // alt language
}
}
if ( nCharactersLeft )
*pStrm << nCharactersLeft << static_cast< sal_Int32 >( 1 ) << static_cast< sal_Int16 >( 1 );
}
}
// -----------------------------------------------------------------------
void PPTWriter::ImplAdjustFirstLineLineSpacing( TextObj& rTextObj, EscherPropertyContainer& rPropOpt )
{
if ( !mbFontIndependentLineSpacing )
{
ParagraphObj* pPara = rTextObj.First();
if ( pPara )
{
PortionObj* pPortion = (PortionObj*)pPara->First();
if ( pPortion )
{
sal_Int16 nLineSpacing = pPara->mnLineSpacing;
const FontCollectionEntry* pDesc = maFontCollection.GetById( pPortion->mnFont );
if ( pDesc )
nLineSpacing = (sal_Int16)( (double)nLineSpacing * pDesc->Scaling + 0.5 );
if ( ( nLineSpacing > 0 ) && ( nLineSpacing < 100 ) )
{
/*
if ( rxText.is() )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XShape > xShape( rxText, ::com::sun::star::uno::UNO_QUERY );
if ( xShape.is() )
{
SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
if ( pObj )
{
const OutlinerParaObject* pParaObj = pObj->GetOutlinerParaObject();
if ( pParaObj )
{
SdrModel* pModel = pObj->GetModel();
if ( pModel )
{
Outliner aOutliner( &pModel->GetItemPool(), pParaObj->GetOutlinerMode() );
aOutliner.SetText( *pParaObj );
sal_uLong nTextHeight = aOutliner.GetLineHeight( 0, 0 );
if ( nTextHeight )
{
}
}
}
}
}
}
*/
double fCharHeight = pPortion->mnCharHeight;
fCharHeight *= 2540 / 72;
fCharHeight *= 100 - nLineSpacing;
fCharHeight /= 100;
sal_uInt32 nUpperDistance = 0;
rPropOpt.GetOpt( ESCHER_Prop_dyTextTop, nUpperDistance );
nUpperDistance += static_cast< sal_uInt32 >( fCharHeight * 360.0 );
rPropOpt.AddOpt( ESCHER_Prop_dyTextTop, nUpperDistance );
}
}
}
}
}
// -----------------------------------------------------------------------
void PPTWriter::ImplWriteTextStyleAtom( SvStream& rOut, int nTextInstance, sal_uInt32 nAtomInstance,
TextRuleEntry* pTextRule, SvStream& rExtBuStr, EscherPropertyContainer* pPropOpt )
{
PPTExParaSheet& rParaSheet = mpStyleSheet->GetParaSheet( nTextInstance );
rOut << (sal_uInt32)( ( EPP_TextHeaderAtom << 16 ) | ( nAtomInstance << 4 ) ) << (sal_uInt32)4
<< nTextInstance;
if ( mbEmptyPresObj )
mnTextSize = 0;
if ( !mbEmptyPresObj )
{
ParagraphObj* pPara;
TextObj aTextObj( mXText, nTextInstance, maFontCollection, (PPTExBulletProvider&)*this );
// leaving out EPP_TextCharsAtom w/o text - still write out
// attribute info though
if ( mnTextSize )
aTextObj.Write( &rOut );
if ( pPropOpt )
ImplAdjustFirstLineLineSpacing( aTextObj, *pPropOpt );
sal_uInt32 nSize, nPos = rOut.Tell();
rOut << (sal_uInt32)( EPP_StyleTextPropAtom << 16 ) << (sal_uInt32)0;
ImplWriteParagraphs( rOut, aTextObj );
ImplWritePortions( rOut, aTextObj );
nSize = rOut.Tell() - nPos;
rOut.SeekRel( - ( (sal_Int32)nSize - 4 ) );
rOut << (sal_uInt32)( nSize - 8 );
rOut.SeekRel( nSize - 8 );
for ( pPara = aTextObj.First(); pPara; pPara = aTextObj.Next() )
{
for ( PortionObj* pPortion = (PortionObj*)pPara->First(); pPortion; pPortion = (PortionObj*)pPara->Next() )
{
if ( pPortion->mpFieldEntry )
{
const FieldEntry* pFieldEntry = pPortion->mpFieldEntry;
switch ( pFieldEntry->nFieldType >> 28 )
{
case 1 :
case 2 :
{
rOut << (sal_uInt32)( EPP_DateTimeMCAtom << 16 ) << (sal_uInt32)8
<< (sal_uInt32)( pFieldEntry->nFieldStartPos ) // TxtOffset auf TxtField;
<< (sal_uInt8)( pFieldEntry->nFieldType & 0xff ) // Type
<< (sal_uInt8)0 << (sal_uInt16)0; // PadBytes
}
break;
case 3 :
{
rOut << (sal_uInt32)( EPP_SlideNumberMCAtom << 16 ) << (sal_uInt32 ) 4
<< (sal_uInt32)( pFieldEntry->nFieldStartPos );
}
break;
case 4 :
{
sal_uInt32 nPageIndex = 0;
String aPageUrl;
String aEmpty;
String aFile( pFieldEntry->aFieldUrl );
INetURLObject aUrl( pFieldEntry->aFieldUrl );
if ( INET_PROT_FILE == aUrl.GetProtocol() )
aFile = aUrl.PathToFileName();
else if ( pFieldEntry->aFieldUrl.GetChar( 0 ) == '#' )
{
String aPage( INetURLObject::decode( pFieldEntry->aFieldUrl, '%', INetURLObject::DECODE_WITH_CHARSET ) );
aPage.Erase( 0, 1 );
for ( String* pStr = (String*)maSlideNameList.First(); pStr; pStr = (String*)maSlideNameList.Next(), nPageIndex++ )
{
if ( *pStr == aPage )
{
aPageUrl = UniString::CreateFromInt32( 256 + nPageIndex );
aPageUrl.Append( String( RTL_CONSTASCII_USTRINGPARAM( "," ) ) );
aPageUrl.Append( String::CreateFromInt32( nPageIndex + 1 ) );
aPageUrl.Append( String( RTL_CONSTASCII_USTRINGPARAM( ",Slide " ) ) );
aPageUrl.Append( String::CreateFromInt32( nPageIndex + 1 ) );
}
}
}
sal_uInt32 nHyperId;
if ( aPageUrl.Len() )
nHyperId = ImplInsertBookmarkURL( aPageUrl, 1 | ( nPageIndex << 8 ) | ( 1 << 31 ), pFieldEntry->aRepresentation, aEmpty, aEmpty, aPageUrl );
else
nHyperId = ImplInsertBookmarkURL( pFieldEntry->aFieldUrl, 2 | ( nHyperId << 8 ), aFile, pFieldEntry->aFieldUrl, aEmpty, aEmpty );
rOut << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)24
<< (sal_uInt32)( EPP_InteractiveInfoAtom << 16 ) << (sal_uInt32)16
<< (sal_uInt32)0 // soundref
<< nHyperId // hyperlink id
<< (sal_uInt8)4 // hyperlink action
<< (sal_uInt8)0 // ole verb
<< (sal_uInt8)0 // jump
<< (sal_uInt8)0 // flags
<< (sal_uInt8)8 // hyperlink type ?
<< (sal_uInt8)0 << (sal_uInt8)0 << (sal_uInt8)0
<< (sal_uInt32)( EPP_TxInteractiveInfoAtom << 16 ) << (sal_uInt32)8
<< (sal_uInt32)( pFieldEntry->nFieldStartPos )
<< (sal_uInt32)( pFieldEntry->nFieldEndPos );
}
break;
case 5 :
{
rOut << (sal_uInt32)( EPP_GenericDateMCAtom << 16 ) << (sal_uInt32)4
<< (sal_uInt32)( pFieldEntry->nFieldStartPos );
}
break;
case 6 :
{
rOut << (sal_uInt32)( EPP_HeaderMCAtom << 16 ) << (sal_uInt32 ) 4
<< (sal_uInt32)( pFieldEntry->nFieldStartPos );
}
break;
case 7 :
{
rOut << (sal_uInt32)( EPP_FooterMCAtom << 16 ) << (sal_uInt32 ) 4
<< (sal_uInt32)( pFieldEntry->nFieldStartPos );
}
break;
default:
break;
}
}
}
}
aTextObj.WriteTextSpecInfo( &rOut );
// Star Office Default TabSizes schreiben ( wenn noetig )
pPara = aTextObj.First();
if ( pPara )
{
sal_uInt32 nParaFlags = 0x1f;
sal_Int16 nDepth, nMask, nNumberingRule[ 10 ];
sal_uInt32 nTextOfs = pPara->nTextOfs;
sal_uInt32 nTabs = pPara->maTabStop.getLength();
const ::com::sun::star::style::TabStop* pTabStop = ( const ::com::sun::star::style::TabStop* )pPara->maTabStop.getConstArray();
for ( ; pPara; pPara = aTextObj.Next() )
{
if ( pPara->bExtendedParameters )
{
nDepth = pPara->nDepth;
if ( nDepth < 5 )
{
nMask = 1 << nDepth;
if ( nParaFlags & nMask )
{
nParaFlags &=~ nMask;
if ( ( rParaSheet.maParaLevel[ nDepth ].mnTextOfs != pPara->nTextOfs ) ||
( rParaSheet.maParaLevel[ nDepth ].mnBulletOfs != pPara->nBulletOfs ) )
{
nParaFlags |= nMask << 16;
nNumberingRule[ nDepth << 1 ] = pPara->nTextOfs;
nNumberingRule[ ( nDepth << 1 ) + 1 ] = (sal_Int16)pPara->nBulletOfs;
}
}
}
}
}
nParaFlags >>= 16;
sal_uInt32 nDefaultTabSize = ImplMapSize( ::com::sun::star::awt::Size( 2011, 1 ) ).Width;
sal_uInt32 nDefaultTabs = abs( maRect.GetWidth() ) / nDefaultTabSize;
if ( nTabs )
nDefaultTabs -= (sal_Int32)( ( ( pTabStop[ nTabs - 1 ].Position / 4.40972 ) + nTextOfs ) / nDefaultTabSize );
if ( (sal_Int32)nDefaultTabs < 0 )
nDefaultTabs = 0;
sal_uInt32 nTabCount = nTabs + nDefaultTabs;
sal_uInt32 i, nTextRulerAtomFlags = 0;
if ( nTabCount )
nTextRulerAtomFlags |= 4;
if ( nParaFlags )
nTextRulerAtomFlags |= ( ( nParaFlags << 3 ) | ( nParaFlags << 8 ) );
if ( nTextRulerAtomFlags )
{
SvStream* pRuleOut = &rOut;
if ( pTextRule )
pRuleOut = pTextRule->pOut = new SvMemoryStream( 0x100, 0x100 );
sal_uInt32 nRulePos = pRuleOut->Tell();
*pRuleOut << (sal_uInt32)( EPP_TextRulerAtom << 16 ) << (sal_uInt32)0;
*pRuleOut << nTextRulerAtomFlags;
if ( nTextRulerAtomFlags & 4 )
{
*pRuleOut << (sal_uInt16)nTabCount;
for ( i = 0; i < nTabs; i++ )
{
sal_uInt16 nPosition = (sal_uInt16)( ( pTabStop[ i ].Position / 4.40972 ) + nTextOfs );
sal_uInt16 nType;
switch ( pTabStop[ i ].Alignment )
{
case ::com::sun::star::style::TabAlign_DECIMAL : nType = 3; break;
case ::com::sun::star::style::TabAlign_RIGHT : nType = 2; break;
case ::com::sun::star::style::TabAlign_CENTER : nType = 1; break;
case ::com::sun::star::style::TabAlign_LEFT :
default: nType = 0;
};
*pRuleOut << nPosition
<< nType;
}
sal_uInt32 nWidth = 1;
if ( nTabs )
nWidth += (sal_Int32)( ( ( pTabStop[ nTabs - 1 ].Position / 4.40972 + nTextOfs ) / nDefaultTabSize ) );
nWidth *= nDefaultTabSize;
for ( i = 0; i < nDefaultTabs; i++, nWidth += nDefaultTabSize )
*pRuleOut << nWidth;
}
for ( i = 0; i < 5; i++ )
{
if ( nTextRulerAtomFlags & ( 8 << i ) )
*pRuleOut << nNumberingRule[ i << 1 ];
if ( nTextRulerAtomFlags & ( 256 << i ) )
*pRuleOut << nNumberingRule[ ( i << 1 ) + 1 ];
}
sal_uInt32 nBufSize = pRuleOut->Tell() - nRulePos;
pRuleOut->SeekRel( - ( (sal_Int32)nBufSize - 4 ) );
*pRuleOut << (sal_uInt32)( nBufSize - 8 );
pRuleOut->SeekRel( nBufSize - 8 );
}
}
if ( aTextObj.HasExtendedBullets() )
{
ParagraphObj* pBulletPara = aTextObj.First();
if ( pBulletPara )
{
sal_uInt32 nBulletFlags = 0;
sal_uInt32 nNumberingType = 0, nPos2 = rExtBuStr.Tell();
rExtBuStr << (sal_uInt32)( EPP_PST_ExtendedParagraphAtom << 16 ) << (sal_uInt32)0;
for ( ; pBulletPara; pBulletPara = aTextObj.Next() )
{
nBulletFlags = 0;
sal_uInt16 nBulletId = pBulletPara->nBulletId;
if ( pBulletPara->bExtendedBulletsUsed )
{
nBulletFlags = 0x800000;
if ( pBulletPara->nNumberingType != SVX_NUM_BITMAP )
nBulletFlags = 0x3000000;
}
rExtBuStr << (sal_uInt32)nBulletFlags;
if ( nBulletFlags & 0x800000 )
rExtBuStr << nBulletId;
if ( nBulletFlags & 0x1000000 )
{
switch( pBulletPara->nNumberingType )
{
case SVX_NUM_NUMBER_NONE :
case SVX_NUM_CHAR_SPECIAL :
nNumberingType = 0;
break;
case SVX_NUM_CHARS_UPPER_LETTER :
case SVX_NUM_CHARS_UPPER_LETTER_N :
case SVX_NUM_CHARS_LOWER_LETTER :
case SVX_NUM_CHARS_LOWER_LETTER_N :
case SVX_NUM_ROMAN_UPPER :
case SVX_NUM_ROMAN_LOWER :
case SVX_NUM_ARABIC :
case SVX_NUM_NUMBER_UPPER_ZH:
case SVX_NUM_CIRCLE_NUMBER:
case SVX_NUM_NUMBER_UPPER_ZH_TW:
case SVX_NUM_NUMBER_LOWER_ZH:
case SVX_NUM_FULL_WIDTH_ARABIC:
nNumberingType = pBulletPara->nMappedNumType;
break;
// case SVX_NUM_PAGEDESC :
case SVX_NUM_BITMAP :
nNumberingType = 0;
break;
}
rExtBuStr << (sal_uInt32)nNumberingType;
}
if ( nBulletFlags & 0x2000000 )
rExtBuStr << (sal_uInt16)pBulletPara->nStartWith;
rExtBuStr << (sal_uInt32)0 << (sal_uInt32)0;
}
sal_uInt32 nBulletSize = ( rExtBuStr.Tell() - nPos2 ) - 8;
rExtBuStr.SeekRel( - ( (sal_Int32)nBulletSize + 4 ) );
rExtBuStr << nBulletSize;
rExtBuStr.SeekRel( nBulletSize );
}
}
}
}
// -----------------------------------------------------------------------
void PPTWriter::ImplWriteObjectEffect( SvStream& rSt,
::com::sun::star::presentation::AnimationEffect eAe,
::com::sun::star::presentation::AnimationEffect eTe,
sal_uInt16 nOrder )
{
EscherExContainer aAnimationInfo( rSt, EPP_AnimationInfo );
EscherExAtom aAnimationInfoAtom( rSt, EPP_AnimationInfoAtom, 0, 1 );
sal_uInt32 nDimColor = 0x7000000; // color to use for dimming
sal_uInt32 nFlags = 0x4400; // set of flags that determine type of build
sal_uInt32 nSoundRef = 0; // 0 if storage is from clipboard. Otherwise index(ID) in SoundCollection list.
sal_uInt32 nDelayTime = 0; // delay before playing object
sal_uInt16 nSlideCount = 1; // number of slides to play object
sal_uInt8 nBuildType = 1; // type of build
sal_uInt8 nFlyMethod = 0; // animation effect( fly, zoom, appear, etc )
sal_uInt8 nFlyDirection = 0; // Animation direction( left, right, up, down, etc )
sal_uInt8 nAfterEffect = 0; // what to do after build
sal_uInt8 nSubEffect = 0; // build by word or letter
sal_uInt8 nOleVerb = 0; // Determines object's class (sound, video, other)
if ( eAe == ::com::sun::star::presentation::AnimationEffect_NONE )
{
nBuildType = 0;
eAe = eTe;
}
switch ( eAe )
{
case ::com::sun::star::presentation::AnimationEffect_NONE :
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LEFT :
{
nFlyDirection = 2;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_TOP :
{
nFlyDirection = 3;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_RIGHT :
{
nFlyDirection = 0;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_BOTTOM :
{
nFlyDirection = 1;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_TO_CENTER :
{
nFlyDirection = 1;
nFlyMethod = 11;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_CENTER :
{
nFlyDirection = 0;
nFlyMethod = 11;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LEFT :
{
nFlyDirection = 0;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_TOP :
{
nFlyDirection = 1;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_RIGHT :
{
nFlyDirection = 2;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_BOTTOM :
{
nFlyDirection = 3;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_VERTICAL_STRIPES :
{
nFlyDirection = 0;
nFlyMethod = 2;
}
break;
case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_STRIPES :
{
nFlyDirection = 1;
nFlyMethod = 2;
}
break;
case ::com::sun::star::presentation::AnimationEffect_CLOCKWISE :
{
nFlyDirection = 1;
nFlyMethod = 3;
}
break;
case ::com::sun::star::presentation::AnimationEffect_COUNTERCLOCKWISE :
{
nFlyDirection = 0;
nFlyMethod = 3;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_UPPERLEFT :
{
nFlyDirection = 7;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_UPPERRIGHT :
{
nFlyDirection = 6;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LOWERLEFT :
{
nFlyDirection = 5;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_FADE_FROM_LOWERRIGHT :
{
nFlyDirection = 4;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_CLOSE_VERTICAL :
{
nFlyDirection = 1;
nFlyMethod = 13;
}
break;
case ::com::sun::star::presentation::AnimationEffect_CLOSE_HORIZONTAL :
{
nFlyDirection = 3;
nFlyMethod = 13;
}
break;
case ::com::sun::star::presentation::AnimationEffect_OPEN_VERTICAL :
{
nFlyDirection = 0;
nFlyMethod = 13;
}
break;
case ::com::sun::star::presentation::AnimationEffect_OPEN_HORIZONTAL :
{
nFlyDirection = 2;
nFlyMethod = 13;
}
break;
case ::com::sun::star::presentation::AnimationEffect_PATH :
{
nFlyDirection = 28;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LEFT :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_TOP :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_RIGHT :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_BOTTOM :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_SPIRALIN_LEFT :
case ::com::sun::star::presentation::AnimationEffect_SPIRALIN_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_SPIRALOUT_LEFT :
case ::com::sun::star::presentation::AnimationEffect_SPIRALOUT_RIGHT :
{
nFlyDirection = 0x1c;
nFlyMethod = 0xc;
}
break;
case ::com::sun::star::presentation::AnimationEffect_DISSOLVE :
{
nFlyDirection = 0;
nFlyMethod = 5;
}
break;
case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_LEFT :
{
nFlyDirection = 2;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_TOP :
{
nFlyDirection = 3;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_RIGHT :
{
nFlyDirection = 0;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_WAVYLINE_FROM_BOTTOM :
{
nFlyDirection = 1;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_RANDOM :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_VERTICAL_LINES :
{
nFlyDirection = 1;
nFlyMethod = 8;
}
break;
case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_LINES :
{
nFlyDirection = 0;
nFlyMethod = 8;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LEFT :
{
nFlyDirection = 2;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_TOP :
{
nFlyDirection = 3;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_RIGHT :
{
nFlyDirection = 0;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_BOTTOM :
{
nFlyDirection = 1;
nFlyMethod = 10;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_UPPERLEFT :
{
nFlyDirection = 7;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_UPPERRIGHT :
{
nFlyDirection = 6;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LOWERLEFT :
{
nFlyDirection = 5;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_LASER_FROM_LOWERRIGHT :
{
nFlyDirection = 4;
nFlyMethod = 9;
}
break;
case ::com::sun::star::presentation::AnimationEffect_APPEAR :
break;
case ::com::sun::star::presentation::AnimationEffect_HIDE :
{
nFlyDirection = 0;
nFlyMethod = 1;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_UPPERLEFT :
{
nFlyDirection = 4;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_UPPERRIGHT :
{
nFlyDirection = 5;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LOWERRIGHT :
{
nFlyDirection = 7;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_FROM_LOWERLEFT :
{
nFlyDirection = 6;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_UPPERLEFT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_UPPERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LOWERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_TO_LOWERLEFT :
nAfterEffect |= 2;
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LEFT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_UPPERLEFT :
{
nFlyDirection = 8;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_TOP :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_UPPERRIGHT :
{
nFlyDirection = 11;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LOWERRIGHT :
{
nFlyDirection = 10;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_BOTTOM :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_FROM_LOWERLEFT :
{
nFlyDirection = 9;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LEFT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_UPPERLEFT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_TOP :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_UPPERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LOWERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_BOTTOM :
case ::com::sun::star::presentation::AnimationEffect_MOVE_SHORT_TO_LOWERLEFT :
nAfterEffect |= 2;
break;
case ::com::sun::star::presentation::AnimationEffect_VERTICAL_CHECKERBOARD :
{
nFlyDirection = 1;
nFlyMethod = 3;
}
break;
case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_CHECKERBOARD :
{
nFlyDirection = 0;
nFlyMethod = 3;
}
break;
case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_ROTATE :
case ::com::sun::star::presentation::AnimationEffect_VERTICAL_ROTATE :
{
nFlyDirection = 27;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_HORIZONTAL_STRETCH :
case ::com::sun::star::presentation::AnimationEffect_VERTICAL_STRETCH :
{
nFlyDirection = 22;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LEFT :
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_UPPERLEFT :
{
nFlyDirection = 23;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_TOP :
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_UPPERRIGHT :
{
nFlyDirection = 24;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LOWERRIGHT :
{
nFlyDirection = 25;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_BOTTOM :
case ::com::sun::star::presentation::AnimationEffect_STRETCH_FROM_LOWERLEFT :
{
nFlyDirection = 26;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN :
{
nFlyDirection = 16;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_SMALL :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_SPIRAL :
{
nFlyDirection = 17;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT :
{
nFlyDirection = 18;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_SMALL :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_SPIRAL :
{
nFlyDirection = 19;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_UPPERLEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_TOP :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_UPPERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LOWERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_BOTTOM :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_LOWERLEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_IN_FROM_CENTER :
{
nFlyDirection = 16;
nFlyMethod = 12;
}
break;
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_UPPERLEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_TOP :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_UPPERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_RIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LOWERRIGHT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_BOTTOM :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_LOWERLEFT :
case ::com::sun::star::presentation::AnimationEffect_ZOOM_OUT_FROM_CENTER :
nAfterEffect |= 2;
break;
default:
break;
}
if ( mnDiaMode >= 1 )
nFlags |= 4;
if ( eTe != ::com::sun::star::presentation::AnimationEffect_NONE )
nBuildType = 2;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "SoundOn" ) ) ) )
{
sal_Bool bBool;
mAny >>= bBool;
if ( bBool )
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Sound" ) ) ) )
{
nSoundRef = maSoundCollection.GetId( *(::rtl::OUString*)mAny.getValue() );
if ( nSoundRef )
nFlags |= 0x10;
}
}
}
sal_Bool bDimHide = sal_False;
sal_Bool bDimPrevious = sal_False;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimHide" ) ) ) )
mAny >>= bDimHide;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimPrevious" ) ) ) )
mAny >>= bDimPrevious;
if ( bDimPrevious )
nAfterEffect |= 1;
if ( bDimHide )
nAfterEffect |= 2;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "DimColor" ) ) ) )
nDimColor = mpPptEscherEx->GetColor( *((sal_uInt32*)mAny.getValue()) ) | 0xfe000000;
rSt << nDimColor << nFlags << nSoundRef << nDelayTime
<< nOrder // order of build ( 1.. )
<< nSlideCount << nBuildType << nFlyMethod << nFlyDirection
<< nAfterEffect << nSubEffect << nOleVerb
<< (sal_uInt16)0; // PadWord
}
// -----------------------------------------------------------------------
void PPTWriter::ImplWriteClickAction( SvStream& rSt, ::com::sun::star::presentation::ClickAction eCa, sal_Bool bMediaClickAction )
{
sal_uInt32 nSoundRef = 0; // a reference to a sound in the sound collection, or NULL.
sal_uInt32 nHyperLinkID = 0;// a persistent unique identifier to an external hyperlink object (only valid when action == HyperlinkAction).
sal_uInt8 nAction = 0; // Action See Action Table
sal_uInt8 nOleVerb = 0; // OleVerb Only valid when action == OLEAction. OLE verb to use, 0 = first verb, 1 = second verb, etc.
sal_uInt8 nJump = 0; // Jump See Jump Table
sal_uInt8 nFlags = 0; // Bit 1: Animated. If 1, then button is animated
// Bit 2: Stop sound. If 1, then stop current sound when button is pressed.
// Bit 3: CustomShowReturn. If 1, and this is a jump to custom show, then return to this slide after custom show.
sal_uInt8 nHyperLinkType = 0;// HyperlinkType a value from the LinkTo enum, such as LT_URL (only valid when action == HyperlinkAction).
String aFile;
/*
Action Table: Action Value
NoAction 0
MacroAction 1
RunProgramAction 2
JumpAction 3
HyperlinkAction 4
OLEAction 5
MediaAction 6
CustomShowAction 7
Jump Table: Jump Value
NoJump 0
NextSlide, 1
PreviousSlide, 2
FirstSlide, 3
LastSlide, 4
LastSlideViewed 5
EndShow 6
*/
if ( bMediaClickAction )
nAction = 6;
else switch( eCa )
{
case ::com::sun::star::presentation::ClickAction_STOPPRESENTATION :
nJump += 2;
case ::com::sun::star::presentation::ClickAction_LASTPAGE :
nJump++;
case ::com::sun::star::presentation::ClickAction_FIRSTPAGE :
nJump++;
case ::com::sun::star::presentation::ClickAction_PREVPAGE :
nJump++;
case ::com::sun::star::presentation::ClickAction_NEXTPAGE :
{
nJump++;
nAction = 3;
}
break;
case ::com::sun::star::presentation::ClickAction_SOUND :
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
nSoundRef = maSoundCollection.GetId( *(::rtl::OUString*)mAny.getValue() );
}
break;
case ::com::sun::star::presentation::ClickAction_PROGRAM :
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
{
INetURLObject aUrl( *(::rtl::OUString*)mAny.getValue() );
if ( INET_PROT_FILE == aUrl.GetProtocol() )
{
aFile = aUrl.PathToFileName();
nAction = 2;
}
}
}
break;
case ::com::sun::star::presentation::ClickAction_BOOKMARK :
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
{
String aBookmark( *(::rtl::OUString*)mAny.getValue() );
sal_uInt32 nIndex = 0;
for ( String* pStr = (String*)maSlideNameList.First(); pStr; pStr = (String*)maSlideNameList.Next(), nIndex++ )
{
if ( *pStr == aBookmark )
{
// Bookmark ist ein link zu einer Dokumentseite
nAction = 4;
nHyperLinkType = 7;
String aEmpty;
String aHyperString = UniString::CreateFromInt32( 256 + nIndex );
aHyperString.Append( String( RTL_CONSTASCII_USTRINGPARAM( "," ) ) );
aHyperString.Append( String::CreateFromInt32( nIndex + 1 ) );
aHyperString.Append( String( RTL_CONSTASCII_USTRINGPARAM( ",Slide " ) ) );
aHyperString.Append( String::CreateFromInt32( nIndex + 1 ) );
nHyperLinkID = ImplInsertBookmarkURL( aHyperString, 1 | ( nIndex << 8 ) | ( 1 << 31 ), aBookmark, aEmpty, aEmpty, aHyperString );
}
}
}
}
break;
case ::com::sun::star::presentation::ClickAction_DOCUMENT :
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bookmark" ) ) ) )
{
String aBookmark( *(::rtl::OUString*)mAny.getValue() );
if ( aBookmark.Len() )
{
nAction = 4;
nHyperLinkType = 8;
String aEmpty;
String aBookmarkFile( aBookmark );
INetURLObject aUrl( aBookmark );
if ( INET_PROT_FILE == aUrl.GetProtocol() )
aBookmarkFile = aUrl.PathToFileName();
nHyperLinkID = ImplInsertBookmarkURL( aBookmark, (sal_uInt32)(2 | ( 1 << 31 )), aBookmarkFile, aBookmark, aEmpty, aEmpty );
}
}
}
break;
case ::com::sun::star::presentation::ClickAction_INVISIBLE :
case ::com::sun::star::presentation::ClickAction_VERB :
case ::com::sun::star::presentation::ClickAction_VANISH :
case ::com::sun::star::presentation::ClickAction_MACRO :
default :
break;
}
sal_uInt32 nContainerSize = 24;
if ( nAction == 2 )
nContainerSize += ( aFile.Len() * 2 ) + 8;
rSt << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)nContainerSize
<< (sal_uInt32)( EPP_InteractiveInfoAtom << 16 ) << (sal_uInt32)16
<< nSoundRef
<< nHyperLinkID
<< nAction
<< nOleVerb
<< nJump
<< nFlags
<< (sal_uInt32)nHyperLinkType;
if ( nAction == 2 ) // run program Action
{
sal_uInt16 i, nLen = aFile.Len();
rSt << (sal_uInt32)( ( EPP_CString << 16 ) | 0x20 ) << (sal_uInt32)( nLen * 2 );
for ( i = 0; i < nLen; i++ )
rSt << aFile.GetChar( i );
}
rSt << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0x1f ) << (sal_uInt32)24 // Mouse Over Action
<< (sal_uInt32)( EPP_InteractiveInfo << 16 ) << (sal_uInt32)16;
for ( int i = 0; i < 4; i++, rSt << (sal_uInt32)0 ) ;
}
// -----------------------------------------------------------------------
sal_Bool PPTWriter::ImplGetEffect( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet > & rPropSet,
::com::sun::star::presentation::AnimationEffect& eEffect,
::com::sun::star::presentation::AnimationEffect& eTextEffect,
sal_Bool& bIsSound )
{
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Effect" ) ) ) )
aAny >>= eEffect;
else
eEffect = ::com::sun::star::presentation::AnimationEffect_NONE;
if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "TextEffect" ) ) ) )
aAny >>= eTextEffect;
else
eTextEffect = ::com::sun::star::presentation::AnimationEffect_NONE;
if ( GetPropertyValue( aAny, rPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "SoundOn" ) ) ) )
aAny >>= bIsSound;
else
bIsSound = sal_False;
sal_Bool bHasEffect = ( ( eEffect != ::com::sun::star::presentation::AnimationEffect_NONE )
|| ( eTextEffect != ::com::sun::star::presentation::AnimationEffect_NONE )
|| bIsSound );
return bHasEffect;
};
// -----------------------------------------------------------------------
sal_Bool PPTWriter::ImplCreatePresentationPlaceholder( const sal_Bool bMasterPage, const PageType /* ePageType */,
const sal_uInt32 nStyleInstance, const sal_uInt8 nPlaceHolderId )
{
sal_Bool bRet = ImplGetText();
if ( bRet && bMasterPage )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
sal_uInt32 nPresShapeID = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, nPresShapeID );// Flags: HaveAnchor | HasSpt
EscherPropertyContainer aPropOpt;
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
aPropOpt.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
aPropOpt.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
aPropOpt.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
sal_uInt32 nLineFlags = 0x90001;
if ( aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
nLineFlags |= 0x10001; // draw dashed line if no line
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
SvMemoryStream aExtBu( 0x200, 0x200 );
SvMemoryStream aClientTextBox( 0x200, 0x200 );
ImplWriteTextStyleAtom( aClientTextBox, nStyleInstance, 0, NULL, aExtBu, &aPropOpt );
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
aPropOpt.CreateShapeProperties( mXShape );
aPropOpt.Commit( *mpStrm );
mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
*mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
mpPptEscherEx->OpenContainer( ESCHER_ClientData );
mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
*mpStrm << (sal_uInt32)0 // PlacementID
<< (sal_uInt8)nPlaceHolderId // PlaceHolderID
<< (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
<< (sal_uInt16)0; // padword
mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
/*
if ( aExtBu.Tell() )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
ImplProgTagContainer( pClientData, &aExtBu );
}
*/
if ( aClientTextBox.Tell() )
{
*mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
<< (sal_uInt32)aClientTextBox.Tell();
mpStrm->Write( aClientTextBox.GetData(), aClientTextBox.Tell() );
}
mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
}
else
bRet = sal_False;
return bRet;
}
// -----------------------------------------------------------------------
void PPTWriter::ImplCreateShape( sal_uInt32 nType, sal_uInt32 nFlags, EscherSolverContainer& rSolver )
{
sal_uInt32 nId = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( nType, nFlags, nId );
rSolver.AddShape( mXShape, nId );
}
void PPTWriter::ImplCreateTextShape( EscherPropertyContainer& rPropOpt, EscherSolverContainer& rSolver, sal_Bool bFill )
{
mnTextStyle = EPP_TEXTSTYLE_TEXT;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_TextBox, 0xa00, rSolver );
if ( bFill )
rPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
if ( ImplGetText() )
rPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
}
void PPTWriter::ImplWritePage( const PHLayout& rLayout, EscherSolverContainer& aSolverContainer, PageType ePageType, sal_Bool bMasterPage, int nPageNumber )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// sal_uInt32 nGroupLevel = 0;
sal_uInt32 nInstance, nGroups, nShapes, nShapeCount, nPer, nLastPer, nIndices, nOlePictureId;
sal_uInt16 nEffectCount;
::com::sun::star::awt::Point aTextRefPoint;
ResetGroupTable( nShapes = mXShapes->getCount() );
nIndices = nInstance = nLastPer = nShapeCount = nEffectCount = 0;
sal_Bool bIsTitlePossible = sal_True; // bei mehr als einem title geht powerpoint in die knie
sal_uInt32 nOutlinerCount = 0; // die gliederungsobjekte muessen dem layout entsprechen,
sal_uInt32 nPrevTextStyle = 0; // es darf nicht mehr als zwei geben
nOlePictureId = 0;
sal_Bool bAdditionalText = sal_False;
sal_Bool bSecOutl = sal_False;
sal_uInt32 nPObjects = 0;
SvMemoryStream* pClientTextBox = NULL;
SvMemoryStream* pClientData = NULL;
while( GetNextGroupEntry() )
{
nShapeCount++;
nPer = ( 5 * nShapeCount ) / nShapes;
if ( nPer != nLastPer )
{
nLastPer = nPer;
sal_uInt32 nValue = mnPagesWritten * 5 + nPer;
if ( nValue > mnStatMaxValue )
nValue = mnStatMaxValue;
if ( mbStatusIndicator && ( nValue > mnLatestStatValue ) )
{
mXStatusIndicator->setValue( nValue );
mnLatestStatValue = nValue;
}
}
nGroups = GetGroupsClosed();
for ( sal_uInt32 i = 0; i < nGroups; i++, mpPptEscherEx->LeaveGroup() ) ;
if ( ImplGetShapeByIndex( GetCurrentGroupIndex(), sal_True ) )
{
sal_Bool bIsSound;
sal_Bool bMediaClickAction = sal_False;
::com::sun::star::presentation::AnimationEffect eAe;
::com::sun::star::presentation::AnimationEffect eTe;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "PresentationOrder" ) ) ) )
nEffectCount = *(sal_uInt16*)mAny.getValue();
sal_Bool bEffect = ImplGetEffect( mXPropSet, eAe, eTe, bIsSound );
::com::sun::star::presentation::ClickAction eCa = ::com::sun::star::presentation::ClickAction_NONE;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "OnClick" ) ) ) )
mAny >>= eCa;
sal_Bool bGroup = mType == "drawing.Group";
sal_Bool bOpenBezier = mType == "drawing.OpenBezier";
sal_Bool bClosedBezier = mType == "drawing.ClosedBezier";
sal_Bool bPolyPolygon = mType == "drawing.PolyPolygon";
sal_Bool bPolyLine = mType == "drawing.PolyLine";
List aAdjustmentList;
Rectangle aPolyBoundRect;
const ::com::sun::star::awt::Size aSize100thmm( mXShape->getSize() );
const ::com::sun::star::awt::Point aPoint100thmm( mXShape->getPosition() );
Rectangle aRect100thmm( Point( aPoint100thmm.X, aPoint100thmm.Y ), Size( aSize100thmm.Width, aSize100thmm.Height ) );
EscherPropertyContainer aPropOpt( mpPptEscherEx->GetGraphicProvider(), mpPicStrm, aRect100thmm );
if ( bGroup )
{
SvMemoryStream* pTmp = NULL;
::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess >
aXIndexAccess( mXShape, ::com::sun::star::uno::UNO_QUERY );
if ( EnterGroup( aXIndexAccess ) )
{
if ( bEffect && !mbUseNewAnimations )
{
pTmp = new SvMemoryStream( 0x200, 0x200 );
ImplWriteObjectEffect( *pTmp, eAe, eTe, ++nEffectCount );
}
if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
{
if ( !pTmp )
pTmp = new SvMemoryStream( 0x200, 0x200 );
ImplWriteClickAction( *pTmp, eCa, bMediaClickAction );
}
sal_uInt32 nShapeId = mpPptEscherEx->EnterGroup( &maRect, pTmp );
aSolverContainer.AddShape( mXShape, nShapeId );
delete pTmp;
}
}
else
{
sal_Bool bIsFontwork = sal_False;
sal_Bool bIsHatching = sal_False;
::com::sun::star::uno::Any aAny;
::com::sun::star::drawing::FillStyle eFS;
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "IsFontwork" ) ), sal_True ) )
aAny >>= bIsFontwork;
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FillStyle" ) ), sal_True ) )
{
aAny >>= eFS;
bIsHatching = eFS == ::com::sun::star::drawing::FillStyle_HATCH;
}
if ( bIsHatching || bIsFontwork || ( mType == "drawing.Measure" ) || ( mType == "drawing.Caption" ) )
{
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "BoundRect" ) ) ) )
{
::com::sun::star::awt::Rectangle aRect( *(::com::sun::star::awt::Rectangle*)mAny.getValue() );
maPosition = ImplMapPoint( ::com::sun::star::awt::Point( aRect.X, aRect.Y ) );
maSize = ImplMapSize( ::com::sun::star::awt::Size( aRect.Width, aRect.Height ) );
maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
}
mType = "drawing.dontknow";
}
}
sal_uInt8 nPlaceHolderAtom = EPP_PLACEHOLDER_NONE;
mnTextSize = 0;
mnTextStyle = EPP_TEXTSTYLE_NORMAL;
if ( mType == "drawing.Custom" )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
sal_uInt32 nMirrorFlags;
rtl::OUString sCustomShapeType;
MSO_SPT eShapeType = aPropOpt.GetCustomShapeType( mXShape, nMirrorFlags, sCustomShapeType );
if ( sCustomShapeType.equalsAscii( "col-502ad400" ) || sCustomShapeType.equalsAscii( "col-60da8460" ) )
{ // sj: creating metafile for customshapes that can't be saved to ms format properly
ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
{
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
if ( pObj )
{
Rectangle aBound = pObj->GetCurrentBoundRect();
maPosition = ImplMapPoint( ::com::sun::star::awt::Point( aBound.Left(), aBound.Top() ) );
maSize = ImplMapSize( ::com::sun::star::awt::Size ( aBound.GetWidth(), aBound.GetHeight() ) );
maRect = Rectangle( Point( maPosition.X, maPosition.Y ), Size( maSize.Width, maSize.Height ) );
mnAngle = 0;
}
}
}
else
{
ImplCreateShape( eShapeType, nMirrorFlags | 0xa00, aSolverContainer );
aPropOpt.CreateCustomShapeProperties( eShapeType, mXShape );
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape);
if ( ImplGetText() )
{
if ( !aPropOpt.IsFontWork() )
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_True, sal_True );
}
}
}
else if ( mType == "drawing.Rectangle" )
{
sal_Int32 nRadius = 0;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CornerRadius" ) ) ) )
{
mAny >>= nRadius;
nRadius = ImplMapSize( ::com::sun::star::awt::Size( nRadius, 0 ) ).Width;
}
if ( nRadius )
{
ImplCreateShape( ESCHER_ShpInst_RoundRectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
sal_Int32 nLenght = maRect.GetWidth();
if ( nLenght > maRect.GetHeight() )
nLenght = maRect.GetHeight();
nLenght >>= 1;
if ( nRadius >= nLenght )
nRadius = 0x2a30; // 0x2a30 ist PPTs maximum radius
else
nRadius = ( 0x2a30 * nRadius ) / nLenght;
aPropOpt.AddOpt( ESCHER_Prop_adjustValue, nRadius );
}
else
{
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
}
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
if ( ImplGetText() )
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
}
else if ( mType == "drawing.Ellipse" )
{
::com::sun::star::drawing::CircleKind eCircleKind( ::com::sun::star::drawing::CircleKind_FULL );
PolyStyle ePolyKind = POLY_CHORD;
if ( ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleKind" ) ) ) )
{
mAny >>= eCircleKind;
switch ( eCircleKind )
{
case ::com::sun::star::drawing::CircleKind_SECTION :
{
ePolyKind = POLY_PIE;
}
break;
case ::com::sun::star::drawing::CircleKind_ARC :
{
ePolyKind = POLY_ARC;
}
break;
case ::com::sun::star::drawing::CircleKind_CUT :
{
ePolyKind = POLY_CHORD;
}
break;
default:
eCircleKind = ::com::sun::star::drawing::CircleKind_FULL;
}
}
if ( eCircleKind == ::com::sun::star::drawing::CircleKind_FULL )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_Ellipse, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
if ( ImplGetText() )
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
}
else
{
sal_Int32 nStartAngle, nEndAngle;
if ( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleStartAngle" ) ) ) )
continue;
nStartAngle = *( (sal_Int32*)mAny.getValue() );
if( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "CircleEndAngle" ) ) ) )
continue;
nEndAngle = *( (sal_Int32*)mAny.getValue() );
::com::sun::star::awt::Point aPoint( mXShape->getPosition() );
::com::sun::star::awt::Size aSize( mXShape->getSize() );
::com::sun::star::awt::Point aStart, aEnd, aCenter;
Rectangle aRect( Point( aPoint.X, aPoint.Y ), Size( aSize.Width, aSize.Height ) );
aStart.X = (sal_Int32)( ( cos( (double)( nStartAngle * F_PI18000 ) ) * 100.0 ) );
aStart.Y = - (sal_Int32)( ( sin( (double)( nStartAngle * F_PI18000 ) ) * 100.0 ) );
aEnd.X = (sal_Int32)( ( cos( (double)( nEndAngle * F_PI18000 ) ) * 100.0 ) );
aEnd.Y = - (sal_Int32)( ( sin( (double)( nEndAngle * F_PI18000 ) ) * 100.0 ) );
aCenter.X = aPoint.X + ( aSize.Width / 2 );
aCenter.Y = aPoint.Y + ( aSize.Height / 2 );
aStart.X += aCenter.X;
aStart.Y += aCenter.Y;
aEnd.X += aCenter.X;
aEnd.Y += aCenter.Y;
Polygon aPolygon( aRect, Point( aStart.X, aStart.Y ), Point( aEnd.X, aEnd.Y ), ePolyKind );
sal_Bool bNeedText = sal_True;
if ( mnAngle )
{
aPolygon.Rotate( aRect.TopLeft(), (sal_uInt16)( mnAngle / 10 ) );
if ( ImplGetText() )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( 0,0 );
// nGroupLevel = mpPptEscherEx->GetGroupLevel();
bNeedText = sal_False;
bAdditionalText = sal_True;
mnTextSize = 0;
}
mnAngle = 0;
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
::com::sun::star::awt::Rectangle aNewRect;
switch ( ePolyKind )
{
case POLY_PIE :
case POLY_CHORD :
{
if ( aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_False, aNewRect, &aPolygon ) )
aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
}
break;
case POLY_ARC :
{
if ( aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_False, aNewRect, &aPolygon ) )
aPropOpt.CreateLineProperties( mXPropSet, sal_False );
}
break;
}
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
if ( bNeedText && ImplGetText() )
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
}
}
else if ( mType == "drawing.Control" )
{
::com::sun::star::uno::Reference< ::com::sun::star::drawing::XControlShape >
aXControlShape( mXShape, ::com::sun::star::uno::UNO_QUERY );
if ( !aXControlShape.is() )
continue;
::com::sun::star::uno::Reference< ::com::sun::star::awt::XControlModel >
aXControlModel( aXControlShape->getControl() );
if ( !aXControlModel.is() )
continue;
sal_Int64 nAspect = ::com::sun::star::embed::Aspects::MSOLE_CONTENT;
try
{
// try to get the aspect when available
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xShapeProps( mXShape, ::com::sun::star::uno::UNO_QUERY_THROW );
xShapeProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Aspect" ) ) ) >>= nAspect;
}
catch( ::com::sun::star::uno::Exception& )
{}
*mpExEmbed << (sal_uInt32)( 0xf | ( EPP_ExControl << 16 ) )
<< (sal_uInt32)0; // Size of this container
sal_uInt32 nSize, nOldPos = mpExEmbed->Tell();
sal_uInt32 nPageId = nPageNumber;
if ( ePageType == MASTER )
nPageId |= 0x80000000;
else
nPageId += 0x100;
*mpExEmbed << (sal_uInt32)( EPP_ExControlAtom << 16 )
<< (sal_uInt32)4
<< nPageId;
PPTExOleObjEntry* pEntry = new PPTExOleObjEntry( OCX_CONTROL, mpExEmbed->Tell() );
pEntry->xControlModel = aXControlModel;
pEntry->xShape = mXShape;
maExOleObj.Insert( pEntry );
mnExEmbed++;
*mpExEmbed << (sal_uInt32)( 1 | ( EPP_ExOleObjAtom << 16 ) )
<< (sal_uInt32)24
<< (sal_uInt32)nAspect
<< (sal_uInt32)2
<< (sal_uInt32)mnExEmbed
<< (sal_uInt32)0
<< (sal_uInt32)4 // index to the persist table
<< (sal_uInt32)0x0012de00;
::com::sun::star::awt::Size aSize;
String aControlName;
SvStorageRef xTemp( new SvStorage( new SvMemoryStream(), sal_True ) );
if ( SvxMSConvertOCXControls::WriteOCXStream( xTemp, aXControlModel, aSize, aControlName ) )
{
String aUserName( xTemp->GetUserName() );
String aOleIdentifier;
if ( aUserName.Len() )
{
SvStorageStreamRef xCompObj = xTemp->OpenSotStream(
String( RTL_CONSTASCII_USTRINGPARAM( "\1CompObj" ) ),
STREAM_READ | STREAM_NOCREATE | STREAM_SHARE_DENYALL );
xCompObj->Seek( STREAM_SEEK_TO_END );
sal_uInt32 nStreamLen = xCompObj->Tell();
xCompObj->Seek( 0 );
sal_Int16 nVersion, nByteOrder;
sal_Int32 nWinVersion, nVal, nStringLen;
*xCompObj >> nVersion
>> nByteOrder
>> nWinVersion
>> nVal;
xCompObj->SeekRel( 16 ); // skipping clsid
*xCompObj >> nStringLen;
if ( ( xCompObj->Tell() + nStringLen ) < nStreamLen )
{
xCompObj->SeekRel( nStringLen ); // now skipping the UserName;
*xCompObj >> nStringLen;
if ( ( xCompObj->Tell() + nStringLen ) < nStreamLen )
{
xCompObj->SeekRel( nStringLen ); // now skipping the clipboard formatname
*xCompObj >> nStringLen;
if ( ( nStringLen > 1 ) && ( ( xCompObj->Tell() + nStringLen ) < nStreamLen ) )
{ // i think that the OleIdentifier will follow
ByteString aTemp;
sal_Char* p = aTemp.AllocBuffer( (sal_uInt16)(nStringLen - 1) );
xCompObj->Read( p, nStringLen - 1 );
aOleIdentifier = String( aTemp, gsl_getSystemTextEncoding() );
}
}
}
}
if ( aControlName.Len() )
PPTWriter::WriteCString( *mpExEmbed, aControlName, 1 );
if ( aOleIdentifier.Len() )
PPTWriter::WriteCString( *mpExEmbed, aOleIdentifier, 2 );
if ( aUserName.Len() )
PPTWriter::WriteCString( *mpExEmbed, aUserName, 3 );
}
nSize = mpExEmbed->Tell() - nOldPos;
mpExEmbed->Seek( nOldPos - 4 );
*mpExEmbed << nSize;
mpExEmbed->Seek( STREAM_SEEK_TO_END );
nOlePictureId = mnExEmbed;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
sal_uInt32 nSpFlags = SHAPEFLAG_HAVESPT | SHAPEFLAG_HAVEANCHOR | SHAPEFLAG_OLESHAPE;
ImplCreateShape( ESCHER_ShpInst_HostControl, nSpFlags, aSolverContainer );
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
//export form control graphic
else if ( aPropOpt.CreateBlipPropertiesforOLEControl(mXPropSet,mXShape))
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
aPropOpt.AddOpt( ESCHER_Prop_pictureId, mnExEmbed );
aPropOpt.AddOpt( ESCHER_Prop_pictureActive, 0x10000 );
if ( aControlName.Len() )
{
sal_uInt16 i, nBufSize;
nBufSize = ( aControlName.Len() + 1 ) << 1;
sal_uInt8* pBuf = new sal_uInt8[ nBufSize ];
sal_uInt8* pTmp = pBuf;
for ( i = 0; i < aControlName.Len(); i++ )
{
sal_Unicode nUnicode = aControlName.GetChar( i );
*pTmp++ = (sal_uInt8)nUnicode;
*pTmp++ = (sal_uInt8)( nUnicode >> 8 );
}
*pTmp++ = 0;
*pTmp = 0;
aPropOpt.AddOpt( ESCHER_Prop_wzName, sal_True, nBufSize, pBuf, nBufSize );
}
}
else if ( mType == "drawing.Connector" )
{
sal_uInt16 nSpType, nSpFlags;
::com::sun::star::awt::Rectangle aNewRect;
if ( aPropOpt.CreateConnectorProperties( mXShape, aSolverContainer, aNewRect, nSpType, nSpFlags ) == sal_False )
continue;
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( nSpType, nSpFlags, aSolverContainer );
// #119459# for connector shape, the start point and end point is fixed, and should not be rotated.
mnAngle = 0;
}
else if ( mType == "drawing.Measure" )
{
continue;
}
else if ( mType == "drawing.Line" )
{
::com::sun::star::awt::Rectangle aNewRect;
aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_LINE, sal_False, aNewRect, NULL );
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
if ( ImplGetText() )
{
aTextRefPoint = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
mnTextSize = 0;
bAdditionalText = sal_True;
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( &maRect,0 );
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
sal_uInt32 nFlags = 0xa00; // Flags: Connector | HasSpt
if ( maRect.Top() > maRect.Bottom() )
nFlags |= 0x80; // Flags: VertMirror
if ( maRect.Left() > maRect.Right() )
nFlags |= 0x40; // Flags: HorzMirror
ImplCreateShape( ESCHER_ShpInst_Line, nFlags, aSolverContainer );
aPropOpt.AddOpt( ESCHER_Prop_shapePath, ESCHER_ShapeComplex );
aPropOpt.CreateLineProperties( mXPropSet, sal_False );
mnAngle = 0;
}
else if ( bPolyPolygon )
{
if ( ImplGetText() )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( 0,0 );
// nGroupLevel = mpPptEscherEx->GetGroupLevel();
bAdditionalText = sal_True;
mnTextSize = 0;
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
::com::sun::star::awt::Rectangle aNewRect;
aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_False, aNewRect, NULL );
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
mnAngle = 0;
}
else if ( bPolyLine )
{
if ( ImplGetText() )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( 0,0 );
// nGroupLevel = mpPptEscherEx->GetGroupLevel();
bAdditionalText = sal_True;
mnTextSize = 0;
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
::com::sun::star::awt::Rectangle aNewRect;
aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_False, aNewRect, NULL );
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
aPropOpt.CreateLineProperties( mXPropSet, sal_False );
mnAngle = 0;
}
else if ( bOpenBezier )
{
if ( ImplGetText() )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( 0,0 );
// nGroupLevel = mpPptEscherEx->GetGroupLevel();
bAdditionalText = sal_True;
mnTextSize = 0;
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
::com::sun::star::awt::Rectangle aNewRect;
aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYLINE, sal_True, aNewRect, NULL );
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
aPropOpt.CreateLineProperties( mXPropSet, sal_False );
mnAngle = 0;
}
else if ( bClosedBezier )
{
if ( ImplGetText() )
{
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->EnterGroup( 0,0 );
// nGroupLevel = mpPptEscherEx->GetGroupLevel();
bAdditionalText = sal_True;
mnTextSize = 0;
}
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_NotPrimitive, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
::com::sun::star::awt::Rectangle aNewRect;
aPropOpt.CreatePolygonProperties( mXPropSet, ESCHER_CREATEPOLYGON_POLYPOLYGON, sal_True, aNewRect, NULL );
maRect = ImplMapRectangle( aNewRect );
maPosition = ::com::sun::star::awt::Point( maRect.Left(), maRect.Top() );
maSize = ::com::sun::star::awt::Size( maRect.GetWidth(), maRect.GetHeight() );
aPropOpt.CreateFillProperties( mXPropSet, sal_True , mXShape );
mnAngle = 0;
}
else if ( ( mType == "drawing.GraphicObject" ) || ( mType == "presentation.GraphicObject" ) )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
// ein GraphicObject kann auch ein ClickMe Element sein
if ( mbEmptyPresObj && ( ePageType == NORMAL ) )
{
nPlaceHolderAtom = rLayout.nUsedObjectPlaceHolder;
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x10001 );
aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
}
else
{
mXText = ::com::sun::star::uno::Reference<
::com::sun::star::text::XSimpleText >
( mXShape, ::com::sun::star::uno::UNO_QUERY );
if ( mXText.is() )
mnTextSize = mXText->getString().getLength();
if ( mnTextSize ) // graphic object oder Flachenfuellung
{
/* SJ #i34951#: because M. documents are not allowing GraphicObjects containing text, we
have to create a simpe Rectangle with fill bitmap instead (while not allowing BitmapMode_Repeat).
*/
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa00, aSolverContainer ); // Flags: Connector | HasSpt
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "GraphicURL" ) ), sal_True, sal_True, sal_False ) )
{
aPropOpt.AddOpt( ESCHER_Prop_WrapText, ESCHER_WrapNone );
aPropOpt.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x140014 );
aPropOpt.AddOpt( ESCHER_Prop_fillBackColor, 0x8000000 );
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x80000 );
if ( ImplGetText() )
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_False );
}
}
else
{
ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "GraphicURL" ) ), sal_False, sal_True ) )
{
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
}
}
}
}
else if ( ( mType == "drawing.Text" ) || ( mType == "presentation.Notes" ) )
{
if ( ( ePageType == NOTICE ) && mbPresObj )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Notes, EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE ) )
continue;
else
nPlaceHolderAtom = EPP_PLACEHOLDER_NOTESBODY;
}
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
else if ( mType == "presentation.TitleText" )
{
if ( mbPresObj )
{
if ( ( ePageType == NOTICE ) && mbEmptyPresObj )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
nPlaceHolderAtom = EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE;
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x200, aSolverContainer );
aPropOpt.CreateLineProperties( mXPropSet, sal_False );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
}
else if ( rLayout.bTitlePossible && bIsTitlePossible )
{
bIsTitlePossible = sal_False;
ImplGetText();
TextObj aTextObj( mXText, EPP_TEXTTYPE_Title, maFontCollection, (PPTExBulletProvider&)*this );
if ( ePageType == MASTER )
{
if ( mnTextSize )
{
::rtl::OUString aUString( mXText->getString() );
sal_uInt16 nChar;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
mnShapeMasterTitle = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, mnShapeMasterTitle );// Flags: HaveAnchor | HasSpt
EscherPropertyContainer aPropertyOptions;
aPropertyOptions.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
aPropertyOptions.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
aPropertyOptions.AddOpt( ESCHER_Prop_AnchorText, ESCHER_AnchorMiddle );
// aPropertyOptions.AddOpt( ESCHER_Prop_fillColor, nFillColor );
// aPropertyOptions.AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
aPropertyOptions.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
aPropertyOptions.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
aPropertyOptions.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
aPropertyOptions.CreateFillProperties( mXPropSet, sal_True, mXShape );
sal_uInt32 nLineFlags = 0x90001;
if ( aPropertyOptions.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
nLineFlags |= 0x10001; // draw dashed line if no line
aPropertyOptions.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
aPropertyOptions.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
aPropertyOptions.Commit( *mpStrm );
mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
*mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
mpPptEscherEx->OpenContainer( ESCHER_ClientData );
mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
*mpStrm << (sal_uInt32)0 // PlacementID
<< (sal_uInt8)EPP_PLACEHOLDER_MASTERTITLE // PlaceHolderID
<< (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
<< (sal_uInt16)0; // padword
mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
mpPptEscherEx->OpenContainer( ESCHER_ClientTextbox );
mpPptEscherEx->AddAtom( 4, EPP_TextHeaderAtom );
*mpStrm << (sal_uInt32)EPP_TEXTTYPE_Title;
mpPptEscherEx->AddAtom( mnTextSize << 1, EPP_TextCharsAtom );
const sal_Unicode* pString = aUString.getStr();
for ( sal_uInt32 i = 0; i < mnTextSize; i++ )
{
nChar = pString[ i ]; // 0xa -> 0xb weicher Zeilenumbruch
if ( nChar == 0xa )
nChar++; // 0xd -> 0xd harter Zeilenumbruch
*mpStrm << nChar;
}
mpPptEscherEx->AddAtom( 6, EPP_BaseTextPropAtom );
*mpStrm << (sal_uInt32)( mnTextSize + 1 ) << (sal_uInt16)0;
mpPptEscherEx->AddAtom( 10, EPP_TextSpecInfoAtom );
*mpStrm << (sal_uInt32)( mnTextSize + 1 ) << (sal_uInt32)1 << (sal_uInt16)0;
mpPptEscherEx->CloseContainer(); // ESCHER_ClientTextBox
mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
}
continue;
}
else
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
mnTextStyle = EPP_TEXTSTYLE_TITLE;
nPlaceHolderAtom = rLayout.nTypeOfTitle;
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterTitle );
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
if ( mbEmptyPresObj )
{
sal_uInt32 nNoLineDrawDash = 0;
aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
nNoLineDrawDash |= 0x10001;
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
}
}
}
else
mbPresObj = sal_False;
}
if ( !mbPresObj )
{
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( ( mType == "presentation.Outliner" ) || ( mType == "presentation.Subtitle" ) )
{
if ( mbPresObj )
{
nOutlinerCount++;
if ( (rLayout.bOutlinerPossible && ( nOutlinerCount == 1 )) ||
(( rLayout.bSecOutlinerPossible && ( nOutlinerCount == 2 ) ) && ( nPrevTextStyle == EPP_TEXTSTYLE_BODY ))
)
{
ImplGetText();
TextObj aTextObj( mXText, EPP_TEXTTYPE_Body, maFontCollection, (PPTExBulletProvider&)*this );
if ( ePageType == MASTER )
{
nPrevTextStyle = EPP_TEXTSTYLE_TITLE;
if ( mnTextSize )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
mnShapeMasterBody = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( ESCHER_ShpInst_Rectangle, 0xa00, mnShapeMasterBody ); // Flags: HaveAnchor | HasSpt
EscherPropertyContainer aPropOpt2;
aPropOpt2.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x50001 );
aPropOpt2.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
// aPropOpt2.AddOpt( ESCHER_Prop_fillColor, nFillColor );
// aPropOpt2.AddOpt( ESCHER_Prop_fillBackColor, nFillBackColor );
aPropOpt2.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x110001 );
aPropOpt2.AddOpt( ESCHER_Prop_lineColor, 0x8000001 );
aPropOpt2.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90001 );
aPropOpt2.AddOpt( ESCHER_Prop_shadowColor, 0x8000002 );
aPropOpt2.CreateFillProperties( mXPropSet, sal_True, mXShape );
sal_uInt32 nLineFlags = 0x90001;
if ( aPropOpt2.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags ) )
nLineFlags |= 0x10001; // draw dashed line if no line
aPropOpt2.AddOpt( ESCHER_Prop_fNoLineDrawDash, nLineFlags );
aPropOpt2.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt2 );
aPropOpt2.Commit( *mpStrm );
mpPptEscherEx->AddAtom( 8, ESCHER_ClientAnchor );
*mpStrm << (sal_Int16)maRect.Top() << (sal_Int16)maRect.Left() << (sal_Int16)maRect.Right() << (sal_Int16)maRect.Bottom(); // oben, links, rechts, unten ????
mpPptEscherEx->OpenContainer( ESCHER_ClientData );
mpPptEscherEx->AddAtom( 8, EPP_OEPlaceholderAtom );
sal_uInt8 PlaceHolderID = ( mType == "presentation.Subtitle") ? EPP_PLACEHOLDER_MASTERSUBTITLE:EPP_PLACEHOLDER_MASTERBODY;
*mpStrm << (sal_uInt32)1 // PlacementID
<< PlaceHolderID/*(sal_uInt8)EPP_PLACEHOLDER_MASTERBODY */ // PlaceHolderID
<< (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
<< (sal_uInt16)0; // padword
mpPptEscherEx->CloseContainer(); // ESCHER_ClientData
mpPptEscherEx->OpenContainer( ESCHER_ClientTextbox ); // printf
mpPptEscherEx->AddAtom( 4, EPP_TextHeaderAtom );
if ( mType == "presentation.Subtitle")
*mpStrm << (sal_uInt32)EPP_TEXTTYPE_CenterBody;
else
*mpStrm << (sal_uInt32)EPP_TEXTTYPE_Body;
mnTextSize = aTextObj.Count();
aTextObj.Write( mpStrm );
mpPptEscherEx->BeginAtom();
for ( ParagraphObj* pPara = aTextObj.First() ; pPara; pPara = aTextObj.Next() )
{
sal_uInt32 nCharCount = pPara->Count();
sal_uInt16 nDepth = pPara->nDepth;
if ( nDepth > 4)
nDepth = 4;
*mpStrm << nCharCount
<< nDepth;
}
mpPptEscherEx->EndAtom( EPP_BaseTextPropAtom );
mpPptEscherEx->AddAtom( 10, EPP_TextSpecInfoAtom );
*mpStrm << (sal_uInt32)( mnTextSize ) << (sal_uInt32)1 << (sal_uInt16)0;
mpPptEscherEx->CloseContainer(); // ESCHER_ClientTextBox
mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
}
continue;
}
else
{
mnTextStyle = EPP_TEXTSTYLE_BODY;
nPlaceHolderAtom = rLayout.nTypeOfOutliner;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
aPropOpt.CreateFillProperties( mXPropSet, sal_True, mXShape );
aPropOpt.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
ImplAdjustFirstLineLineSpacing( aTextObj, aPropOpt );
if ( mbEmptyPresObj )
{
sal_uInt32 nNoLineDrawDash = 0;
aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
nNoLineDrawDash |= 0x10001;
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, nNoLineDrawDash );
}
}
}
else
mbPresObj = sal_False;
}
if ( !mbPresObj )
{
if (ePageType == MASTER )
{
SdrObject* pObj = GetSdrObjectFromXShape( mXShape );
if (pObj && pObj->IsNotVisibleAsMaster())
continue;
}
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( ( mType == "drawing.Page" ) || ( mType == "presentation.Page" ) )
{
if ( ( ePageType == NOTICE ) && mbPresObj )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Notes, EPP_PLACEHOLDER_MASTERNOTESSLIDEIMAGE ) )
continue;
else
nPlaceHolderAtom = EPP_PLACEHOLDER_NOTESSLIDEIMAGE;
}
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
else if ( mType == "drawing.Frame" )
{
continue;
}
else if ( ( mType == "drawing.OLE2" ) || ( mType == "presentation.OLE2" )
|| ( mType == "presentation.Chart" ) || ( mType == "presentation.Calc" )
|| ( mType == "presentation.OrgChart" ) )
{
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
if ( mbEmptyPresObj && ( ePageType == NORMAL ) )
{
nPlaceHolderAtom = rLayout.nUsedObjectPlaceHolder;
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0x220, aSolverContainer ); // Flags: HaveAnchor | HaveMaster
aPropOpt.AddOpt( ESCHER_Prop_lTxid, mnTxId += 0x60 );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x10001 );
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x10001 );
aPropOpt.AddOpt( ESCHER_Prop_hspMaster, mnShapeMasterBody );
}
else
{
*mpExEmbed << (sal_uInt32)( 0xf | ( EPP_ExEmbed << 16 ) )
<< (sal_uInt32)0; // Size of this container
sal_uInt32 nSize, nOldPos = mpExEmbed->Tell();
*mpExEmbed << (sal_uInt32)( EPP_ExEmbedAtom << 16 )
<< (sal_uInt32)8
<< (sal_uInt32)0 // follow colorscheme : 0->do not follow
// 1->follow collorscheme
// 2->follow text and background scheme
<< (sal_uInt8)1 // (bool)set if embedded server can not be locked
<< (sal_uInt8)0 // (bool)do not need to send dimension
<< (sal_uInt8)0 // (bool)is object a world table
<< (sal_uInt8)0; // pad byte
PPTExOleObjEntry* pE = new PPTExOleObjEntry( NORMAL_OLE_OBJECT, mpExEmbed->Tell() );
pE->xShape = mXShape;
maExOleObj.Insert( pE );
mnExEmbed++;
sal_Int64 nAspect = ::com::sun::star::embed::Aspects::MSOLE_CONTENT;
try
{
// try to get the aspect when available
::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >
xShapeProps( mXShape, ::com::sun::star::uno::UNO_QUERY_THROW );
xShapeProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Aspect" ) ) ) >>= nAspect;
}
catch( ::com::sun::star::uno::Exception& )
{}
*mpExEmbed << (sal_uInt32)( 1 | ( EPP_ExOleObjAtom << 16 ) )
<< (sal_uInt32)24
<< (sal_uInt32)nAspect // Aspect
<< (sal_uInt32)0
<< (sal_uInt32)mnExEmbed // index to the persist table
<< (sal_uInt32)0 // subtype
<< (sal_uInt32)0
<< (sal_uInt32)0x0012b600;
// PPTWriter::WriteCString( *mpExEmbed, "Photo Editor Photo", 1 );
// PPTWriter::WriteCString( *mpExEmbed, "MSPhotoEd.3", 2 );
// PPTWriter::WriteCString( *mpExEmbed, "Microsoft Photo Editor 3.0 Photo", 3 );
nSize = mpExEmbed->Tell() - nOldPos;
mpExEmbed->Seek( nOldPos - 4 );
*mpExEmbed << nSize;
mpExEmbed->Seek( STREAM_SEEK_TO_END );
nOlePictureId = mnExEmbed;
sal_uInt32 nSpFlags = 0xa00;
if ( nOlePictureId )
nSpFlags |= 0x10;
ImplCreateShape( ESCHER_ShpInst_PictureFrame, nSpFlags, aSolverContainer );
if ( aPropOpt.CreateOLEGraphicProperties( mXShape ) )
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
if ( nOlePictureId )
aPropOpt.AddOpt( ESCHER_Prop_pictureId, nOlePictureId );
}
}
else if ( mType == "presentation.Header" )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERHEADER ) )
continue;
else
{
mbPresObj = sal_False;
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( mType == "presentation.Footer" )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERFOOTER ) )
continue;
else
{
mbPresObj = sal_False;
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( mType == "presentation.DateTime" )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERDATE ) )
continue;
else
{
mbPresObj = sal_False;
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( mType == "presentation.SlideNumber" )
{
if ( ImplCreatePresentationPlaceholder( bMasterPage, ePageType, EPP_TEXTTYPE_Other, EPP_PLACEHOLDER_MASTERSLIDENUMBER ) )
continue;
else
{
mbPresObj = sal_False;
mType = "drawing.Text";
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_True );
}
}
else if ( ( (sal_Char)'3' == mType.GetChar( 8 ) ) && ( (char)'D' == mType.GetChar( 9 ) ) ) // drawing.3D
{
// SceneObject, CubeObject, SphereObject, LatheObject, ExtrudeObject, PolygonObject
if ( !ImplGetPropertyValue( String( RTL_CONSTASCII_USTRINGPARAM( "Bitmap" ) ) ) )
continue;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "Bitmap" ) ), sal_False ) )
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
}
else if ( mType == "drawing.Media" )
{
mnAngle = 0;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
if ( aPropOpt.CreateMediaGraphicProperties( mXShape ) )
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
::com::sun::star::uno::Any aAny;
if ( PropValue::GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MediaURL" ) ), sal_True ) )
{
rtl::OUString aMediaURL;
if ( (aAny >>= aMediaURL ) && aMediaURL.getLength() )
{
// SJ: creating the Media RefObj
sal_uInt32 nRefId = ++mnExEmbed;
*mpExEmbed << (sal_uInt16)0xf
<< (sal_uInt16)EPP_ExMCIMovie // PPT_PST_ExAviMovie
<< (sal_uInt32)0;
sal_uInt32 nSize, nStart = mpExEmbed->Tell();
*mpExEmbed << (sal_uInt16)0
<< (sal_uInt16)EPP_ExObjRefAtom
<< (sal_uInt32)4
<< nRefId;
*mpExEmbed << (sal_uInt16)0xf
<< (sal_uInt16)EPP_ExVideo
<< (sal_uInt32)0;
*mpExEmbed << (sal_uInt16)0
<< (sal_uInt16)EPP_ExMediaAtom
<< (sal_uInt32)8
<< nRefId
<< (sal_uInt16)0
<< (sal_uInt16)0x435;
sal_uInt16 i, nStringLen = (sal_uInt16)aMediaURL.getLength();
*mpExEmbed << (sal_uInt32)( EPP_CString << 16 ) << (sal_uInt32)( nStringLen * 2 );
for ( i = 0; i < nStringLen; i++ )
{
sal_Unicode nChar = aMediaURL[ i ];
*mpExEmbed << nChar;
}
nSize = mpExEmbed->Tell() - nStart;
mpExEmbed->SeekRel( - ( (sal_Int32)nSize + 4 ) );
*mpExEmbed << nSize; // size of PPT_PST_ExMCIMovie
mpExEmbed->SeekRel( 0x10 );
nSize -= 20;
*mpExEmbed << nSize; // PPT_PST_ExMediaAtom
mpExEmbed->SeekRel( nSize );
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
*pClientData << (sal_uInt16)0
<< (sal_uInt16)EPP_ExObjRefAtom
<< (sal_uInt32)4
<< nRefId;
// write EPP_InteractiveInfo container for no_action
*pClientData << (sal_uInt32)( ( EPP_InteractiveInfo << 16 ) | 0xf ) << (sal_uInt32)24;
*pClientData << (sal_uInt16)0
<< (sal_uInt16)EPP_InteractiveInfoAtom
<< (sal_uInt32)16
<< (sal_uInt32) 0
<< (sal_uInt32) 0
<< (sal_uInt8) 6
<< (sal_uInt8) 0
<< (sal_uInt8) 0
<< (sal_uInt8) 0
<< (sal_uInt32) 0;
}
}
}
else if ( (mType == "drawing.Table") || (mType == "presentation.Table") )
{
SvMemoryStream* pTmp = NULL;
if ( bEffect && !mbUseNewAnimations )
{
pTmp = new SvMemoryStream( 0x200, 0x200 );
ImplWriteObjectEffect( *pTmp, eAe, eTe, ++nEffectCount );
}
if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
{
if ( !pTmp )
pTmp = new SvMemoryStream( 0x200, 0x200 );
ImplWriteClickAction( *pTmp, eCa, bMediaClickAction );
}
ImplCreateTable( mXShape, aSolverContainer, aPropOpt );
continue;
}
else if ( mType == "drawing.dontknow" )
{
mnAngle = 0;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_PictureFrame, 0xa00, aSolverContainer );
if ( aPropOpt.CreateGraphicProperties( mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "MetaFile" ) ), sal_False ) )
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x800080 );
}
else
{
continue;
}
sal_Int32 nPlacementID = -1;
sal_Bool bClientData = ( bEffect || ( eCa != ::com::sun::star::presentation::ClickAction_NONE ) ||
nPlaceHolderAtom || nOlePictureId );
if ( bClientData )
{
if ( nPlaceHolderAtom )
{
if ( ( mnTextStyle == EPP_TEXTSTYLE_TITLE ) || ( mnTextStyle == EPP_TEXTSTYLE_BODY ) )
nPlacementID = nIndices++;
else
{
switch ( nPlaceHolderAtom )
{
default :
{
if ( nPlaceHolderAtom < 19 )
break;
}
case EPP_PLACEHOLDER_NOTESBODY :
case EPP_PLACEHOLDER_MASTERDATE :
case EPP_PLACEHOLDER_NOTESSLIDEIMAGE :
case EPP_PLACEHOLDER_MASTERNOTESBODYIMAGE :
nPlacementID = nIndices++;
}
}
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
*pClientData << (sal_uInt32)( EPP_OEPlaceholderAtom << 16 ) << (sal_uInt32)8
<< nPlacementID // PlacementID
<< (sal_uInt8)nPlaceHolderAtom // PlaceHolderID
<< (sal_uInt8)0 // Size of PlaceHolder ( 0 = FULL, 1 = HALF, 2 = QUARTER )
<< (sal_uInt16)0; // padword
}
if ( nOlePictureId )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
*pClientData << (sal_uInt32)( EPP_ExObjRefAtom << 16 ) << (sal_uInt32)4
<< nOlePictureId;
nOlePictureId = 0;
}
if ( bEffect )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
// check if it is sensible to replace the object effect with text effect,
// because in Impress there is the possibility to use a compound effect,
// e.g. the object effect is an AnimationEffect_FADE_FROM_LEFT and the
// text effect is a AnimationEffect_FADE_FROM_TOP, in PowerPoint there
// can be used only one effect
if ( mnTextSize && ( eTe != ::com::sun::star::presentation::AnimationEffect_NONE )
&& ( eAe != ::com::sun::star::presentation::AnimationEffect_NONE )
&& ( eTe != eAe ) )
{
sal_uInt32 nFillStyleFlags, nLineStyleFlags;
if ( aPropOpt.GetOpt( ESCHER_Prop_fNoFillHitTest, nFillStyleFlags )
&& aPropOpt.GetOpt( ESCHER_Prop_fNoLineDrawDash, nLineStyleFlags ) )
{
// there is no fillstyle and also no linestyle
if ( ! ( ( nFillStyleFlags & 0x10 ) + ( nLineStyleFlags & 9 ) ) )
eAe = eTe;
}
}
if ( !mbUseNewAnimations )
ImplWriteObjectEffect( *pClientData, eAe, eTe, ++nEffectCount );
}
if ( eCa != ::com::sun::star::presentation::ClickAction_NONE )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
ImplWriteClickAction( *pClientData, eCa, bMediaClickAction );
}
}
if ( ( mnTextStyle == EPP_TEXTSTYLE_TITLE ) || ( mnTextStyle == EPP_TEXTSTYLE_BODY ) )
{
if ( !pClientTextBox )
pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
if ( mbEmptyPresObj == sal_False )
{
if ( ( ePageType == NORMAL ) && ( bMasterPage == sal_False ) )
{
sal_uInt32 nTextType = EPP_TEXTTYPE_Body;
if ( mnTextStyle == EPP_TEXTSTYLE_BODY )
{
if ( bSecOutl )
nTextType = EPP_TEXTTYPE_HalfBody;
else if ( mType == "presentation.Subtitle" )
nTextType = EPP_TEXTTYPE_CenterBody;
bSecOutl = sal_True;
}
else
nTextType = EPP_TEXTTYPE_Title;
TextRuleEntry aTextRule( nPageNumber );
SvMemoryStream aExtBu( 0x200, 0x200 );
ImplGetText();
ImplWriteTextStyleAtom( *pClientTextBox, nTextType, nPObjects, &aTextRule, aExtBu, NULL );
ImplWriteExtParaHeader( aExtBu, nPObjects++, nTextType, nPageNumber + 0x100 );
SvMemoryStream* pOut = aTextRule.pOut;
if ( pOut )
{
pClientTextBox->Write( pOut->GetData(), pOut->Tell() );
delete pOut, aTextRule.pOut = NULL;
}
if ( aExtBu.Tell() )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
ImplProgTagContainer( pClientData, &aExtBu );
}
}
}
}
else
{
if ( !aPropOpt.IsFontWork() )
{
if ( mnTextSize || ( nPlaceHolderAtom == EPP_PLACEHOLDER_MASTERDATE ) || ( nPlaceHolderAtom == EPP_PLACEHOLDER_NOTESBODY ) )
{
int nInstance2;
if ( ( nPlaceHolderAtom == EPP_PLACEHOLDER_MASTERDATE ) || ( nPlaceHolderAtom == EPP_PLACEHOLDER_NOTESBODY ) )
nInstance2 = 2;
else
nInstance2 = EPP_TEXTTYPE_Other; // Text in a Shape
if ( !pClientTextBox )
pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
SvMemoryStream aExtBu( 0x200, 0x200 );
ImplWriteTextStyleAtom( *pClientTextBox, nInstance2, 0, NULL, aExtBu, &aPropOpt );
if ( aExtBu.Tell() )
{
if ( !pClientData )
pClientData = new SvMemoryStream( 0x200, 0x200 );
ImplProgTagContainer( pClientData, &aExtBu );
}
}
else if ( nPlaceHolderAtom >= 19 )
{
if ( !pClientTextBox )
pClientTextBox = new SvMemoryStream( 12 );
*pClientTextBox << (sal_uInt32)( EPP_TextHeaderAtom << 16 ) << (sal_uInt32)4
<< (sal_uInt32)7;
}
}
}
aPropOpt.CreateShadowProperties( mXPropSet );
maRect.Justify();
if ( mnAngle )
ImplFlipBoundingBox( aPropOpt );
aPropOpt.CreateShapeProperties( mXShape );
aPropOpt.Commit( *mpStrm );
if ( GetCurrentGroupLevel() > 0 )
mpPptEscherEx->AddChildAnchor( maRect );
else
mpPptEscherEx->AddClientAnchor( maRect );
if ( pClientData )
{
*mpStrm << (sal_uInt32)( ( ESCHER_ClientData << 16 ) | 0xf )
<< (sal_uInt32)pClientData->Tell();
mpStrm->Write( pClientData->GetData(), pClientData->Tell() );
delete pClientData, pClientData = NULL;
}
if ( pClientTextBox )
{
*mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
<< (sal_uInt32)pClientTextBox->Tell();
mpStrm->Write( pClientTextBox->GetData(), pClientTextBox->Tell() );
delete pClientTextBox, pClientTextBox = NULL;
}
mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
}
nPrevTextStyle = mnTextStyle;
if ( bAdditionalText )
{
bAdditionalText = sal_False;
::com::sun::star::uno::Any aAny;
EscherPropertyContainer aPropOpt;
mnAngle = ( PropValue::GetPropertyValue( aAny,
mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "RotateAngle" ) ), sal_True ) )
? *((sal_Int32*)aAny.getValue() )
: 0;
aPropOpt.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90000 );
aPropOpt.AddOpt( ESCHER_Prop_fNoFillHitTest, 0x100000 );
if ( mType == "drawing.Line" )
{
double fDist = hypot( maRect.GetWidth(), maRect.GetHeight() );
maRect = Rectangle( Point( aTextRefPoint.X, aTextRefPoint.Y ),
Point( (sal_Int32)( aTextRefPoint.X + fDist ), aTextRefPoint.Y - 1 ) );
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_False );
aPropOpt.AddOpt( ESCHER_Prop_FitTextToShape, 0x60006 ); // Size Shape To Fit Text
if ( mnAngle < 0 )
mnAngle = ( 36000 + mnAngle ) % 36000;
if ( mnAngle )
ImplFlipBoundingBox( aPropOpt );
}
else
{
ImplCreateTextShape( aPropOpt, aSolverContainer, sal_False );
if ( mnAngle < 0 )
mnAngle = ( 36000 + mnAngle ) % 36000;
else
mnAngle = ( 36000 - ( mnAngle % 36000 ) );
mnAngle *= 655;
mnAngle += 0x8000;
mnAngle &=~0xffff; // nAngle auf volle Gradzahl runden
aPropOpt.AddOpt( ESCHER_Prop_Rotation, mnAngle );
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->SetGroupSnapRect( nGroupLevel, maRect );
// mpPptEscherEx->SetGroupLogicRect( nGroupLevel, maRect );
}
if ( !pClientTextBox )
pClientTextBox = new SvMemoryStream( 0x200, 0x200 );
SvMemoryStream aExtBu( 0x200, 0x200 );
ImplWriteTextStyleAtom( *pClientTextBox, EPP_TEXTTYPE_Other, 0, NULL, aExtBu, &aPropOpt );
aPropOpt.CreateShapeProperties( mXShape );
aPropOpt.Commit( *mpStrm );
if ( GetCurrentGroupLevel() > 0 )
mpPptEscherEx->AddChildAnchor( maRect );
else
mpPptEscherEx->AddClientAnchor( maRect );
*mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
<< (sal_uInt32)pClientTextBox->Tell();
mpStrm->Write( pClientTextBox->GetData(), pClientTextBox->Tell() );
delete pClientTextBox, pClientTextBox = NULL;
mpPptEscherEx->CloseContainer(); // ESCHER_SpContainer
// #119551# PPT does not support groups of polygons and text (MS patch KB2289187)
// mpPptEscherEx->LeaveGroup();
}
}
ClearGroupTable(); // gruppierungen wegschreiben, sofern noch irgendwelche offen sind, was eigendlich nicht sein sollte
nGroups = GetGroupsClosed();
for ( sal_uInt32 i = 0; i < nGroups; i++, mpPptEscherEx->LeaveGroup() ) ;
mnPagesWritten++;
}
// -----------------------------------------------------------------------
::com::sun::star::awt::Point PPTWriter::ImplMapPoint( const ::com::sun::star::awt::Point& rPoint )
{
Point aRet( OutputDevice::LogicToLogic( Point( rPoint.X, rPoint.Y ), maMapModeSrc, maMapModeDest ) );
return ::com::sun::star::awt::Point( aRet.X(), aRet.Y() );
}
// -----------------------------------------------------------------------
::com::sun::star::awt::Size PPTWriter::ImplMapSize( const ::com::sun::star::awt::Size& rSize )
{
Size aRetSize( OutputDevice::LogicToLogic( Size( rSize.Width, rSize.Height ), maMapModeSrc, maMapModeDest ) );
if ( !aRetSize.Width() )
aRetSize.Width()++;
if ( !aRetSize.Height() )
aRetSize.Height()++;
return ::com::sun::star::awt::Size( aRetSize.Width(), aRetSize.Height() );
}
// -----------------------------------------------------------------------
Rectangle PPTWriter::ImplMapRectangle( const ::com::sun::star::awt::Rectangle& rRect )
{
::com::sun::star::awt::Point aPoint( rRect.X, rRect.Y );
::com::sun::star::awt::Size aSize( rRect.Width, rRect.Height );
::com::sun::star::awt::Point aP( ImplMapPoint( aPoint ) );
::com::sun::star::awt::Size aS( ImplMapSize( aSize ) );
return Rectangle( Point( aP.X, aP.Y ), Size( aS.Width, aS.Height ) );
}
// -----------------------------------------------------------------------
struct CellBorder
{
sal_Int32 mnPos; // specifies the distance to the top/left position of the table
sal_Int32 mnLength;
table::BorderLine maCellBorder;
CellBorder() : mnPos ( 0 ), mnLength( 0 ){};
};
sal_Bool PPTWriter::ImplCreateCellBorder( const CellBorder* pCellBorder, sal_Int32 nX1, sal_Int32 nY1, sal_Int32 nX2, sal_Int32 nY2)
{
sal_Int32 nLineWidth = pCellBorder->maCellBorder.OuterLineWidth + pCellBorder->maCellBorder.InnerLineWidth;
if ( nLineWidth )
{
nLineWidth *= 2;
mnAngle = 0;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
EscherPropertyContainer aPropOptSp;
sal_uInt32 nId = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( ESCHER_ShpInst_Line, 0xa02, nId );
aPropOptSp.AddOpt( ESCHER_Prop_shapePath, ESCHER_ShapeComplex );
aPropOptSp.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0xa0008 );
aPropOptSp.AddOpt( ESCHER_Prop_fshadowObscured, 0x20000 );
sal_uInt32 nBorderColor = pCellBorder->maCellBorder.Color & 0xff00; // green
nBorderColor |= static_cast< sal_uInt8 >( pCellBorder->maCellBorder.Color ) << 16; // red
nBorderColor |= static_cast< sal_uInt8 >( pCellBorder->maCellBorder.Color >> 16 ); // blue
aPropOptSp.AddOpt( ESCHER_Prop_lineColor, nBorderColor );
aPropOptSp.AddOpt( ESCHER_Prop_lineWidth, nLineWidth * 360 );
aPropOptSp.AddOpt( ESCHER_Prop_fc3DLightFace, 0x80000 );
aPropOptSp.Commit( *mpStrm );
mpPptEscherEx->AddAtom( 16, ESCHER_ChildAnchor );
*mpStrm << nX1
<< nY1
<< nX2
<< nY2;
mpPptEscherEx->CloseContainer();
return sal_True;
}
return sal_False;
}
//get merged cell's width
sal_Int32 GetCellRight( sal_Int32 nColumn,
Rectangle& rect,
std::vector< std::pair< sal_Int32, sal_Int32 > >& aColumns,
uno::Reference< table::XMergeableCell >& xCell )
{
sal_Int32 nRight = aColumns[ nColumn ].first + aColumns[ nColumn ].second;
for ( sal_Int32 nColumnSpan = 1; nColumnSpan < xCell->getColumnSpan(); nColumnSpan++ )
{
sal_uInt32 nC = nColumnSpan + nColumn;
if ( nC < aColumns.size() )
nRight += aColumns[ nC ].second;
else
nRight = rect.Right();
}
return nRight;
}
//get merged cell's height
sal_Int32 GetCellBottom( sal_Int32 nRow,
Rectangle& rect,
std::vector< std::pair< sal_Int32, sal_Int32 > >& aRows,
uno::Reference< table::XMergeableCell >& xCell )
{
sal_Int32 nBottom = aRows[nRow].first + aRows[nRow].second;
for ( sal_Int32 nRowSpan = 1; nRowSpan < xCell->getRowSpan(); nRowSpan++ )
{
sal_uInt32 nR = nRowSpan + nRow;
if ( nR < aRows.size() )
nBottom += aRows[ nR ].second;
else
nBottom = rect.Bottom();
}
return nBottom;
}
void PPTWriter::WriteCString( SvStream& rSt, const String& rString, sal_uInt32 nInstance )
{
sal_uInt32 i, nLen = rString.Len();
if ( nLen )
{
rSt << (sal_uInt32)( ( nInstance << 4 ) | ( EPP_CString << 16 ) )
<< (sal_uInt32)( nLen << 1 );
for ( i = 0; i < nLen; i++ )
rSt << rString.GetChar( (sal_uInt16)i );
}
}
void PPTWriter::ImplCreateTable( uno::Reference< drawing::XShape >& rXShape, EscherSolverContainer& aSolverContainer,
EscherPropertyContainer& aPropOpt )
{
try
{
static const rtl::OUString sModel( RTL_CONSTASCII_USTRINGPARAM ( "Model" ) );
static const rtl::OUString sWidth( RTL_CONSTASCII_USTRINGPARAM ( "Width" ) );
static const rtl::OUString sHeight( RTL_CONSTASCII_USTRINGPARAM ( "Height" ) );
uno::Reference< table::XTable > xTable;
if ( mXPropSet->getPropertyValue( sModel ) >>= xTable )
{
uno::Reference< table::XColumnRowRange > xColumnRowRange( xTable, uno::UNO_QUERY_THROW );
uno::Reference< container::XIndexAccess > xColumns( xColumnRowRange->getColumns(), uno::UNO_QUERY_THROW );
uno::Reference< container::XIndexAccess > xRows( xColumnRowRange->getRows(), uno::UNO_QUERY_THROW );
sal_uInt16 nRowCount = static_cast< sal_uInt16 >( xRows->getCount() );
sal_uInt16 nColumnCount = static_cast< sal_uInt16 >( xColumns->getCount() );
std::vector< std::pair< sal_Int32, sal_Int32 > > aColumns;
std::vector< std::pair< sal_Int32, sal_Int32 > > aRows;
awt::Point aPosition( ImplMapPoint( rXShape->getPosition() ) );
sal_Int32 nPosition = aPosition.X;
for ( sal_Int32 x = 0; x < nColumnCount; x++ )
{
uno::Reference< beans::XPropertySet > xPropSet( xColumns->getByIndex( x ), uno::UNO_QUERY_THROW );
awt::Size aS( 0, 0 );
xPropSet->getPropertyValue( sWidth ) >>= aS.Width;
awt::Size aM( ImplMapSize( aS ) );
aColumns.push_back( std::pair< sal_Int32, sal_Int32 >( nPosition, aM.Width ) );
nPosition += aM.Width;
if ( x == nColumnCount - 1 && nPosition != maRect.Right() )
maRect.Right() = nPosition;
}
nPosition = aPosition.Y;
for ( sal_Int32 y = 0; y < nRowCount; y++ )
{
uno::Reference< beans::XPropertySet > xPropSet( xRows->getByIndex( y ), uno::UNO_QUERY_THROW );
awt::Size aS( 0, 0 );
xPropSet->getPropertyValue( sHeight ) >>= aS.Height;
awt::Size aM( ImplMapSize( aS ) );
aRows.push_back( std::pair< sal_Int32, sal_Int32 >( nPosition, aM.Height ) );
nPosition += aM.Height;
if ( y == nRowCount - 1 && nPosition != maRect.Bottom())
maRect.Bottom() = nPosition;
}
mpPptEscherEx->OpenContainer( ESCHER_SpgrContainer );
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
mpPptEscherEx->AddAtom( 16, ESCHER_Spgr, 1 );
*mpStrm << (sal_Int32)maRect.Left() // Bounding box fuer die Gruppierten shapes an die sie attached werden
<< (sal_Int32)maRect.Top()
<< (sal_Int32)maRect.Right()
<< (sal_Int32)maRect.Bottom();
sal_uInt32 nShapeId = mpPptEscherEx->GenerateShapeId();
mpPptEscherEx->AddShape( ESCHER_ShpInst_Min, 0x201, nShapeId ); // Flags: Group | Patriarch
aSolverContainer.AddShape( rXShape, nShapeId );
EscherPropertyContainer aPropOpt2;
if ( nRowCount )
{
SvMemoryStream aMemStrm;
aMemStrm.ObjectOwnsMemory( sal_False );
aMemStrm << nRowCount
<< nRowCount
<< (sal_uInt16)4;
std::vector< std::pair< sal_Int32, sal_Int32 > >::const_iterator aIter( aRows.begin() );
while( aIter != aRows.end() )
aMemStrm << (*aIter++).second;
aPropOpt.AddOpt( ESCHER_Prop_LockAgainstGrouping, 0x1000100 );
aPropOpt2.AddOpt( ESCHER_Prop_tableProperties, 1 );
aPropOpt2.AddOpt( ESCHER_Prop_tableRowProperties, sal_True, aMemStrm.Tell(), static_cast< sal_uInt8* >( const_cast< void* >( aMemStrm.GetData() ) ), aMemStrm.Tell() );
aPropOpt.CreateShapeProperties( rXShape );
aPropOpt.Commit( *mpStrm );
aPropOpt2.Commit( *mpStrm, 3, ESCHER_UDefProp );
if ( GetCurrentGroupLevel() > 0 )
mpPptEscherEx->AddChildAnchor( maRect );
else
mpPptEscherEx->AddClientAnchor( maRect );
mpPptEscherEx->CloseContainer();
uno::Reference< table::XCellRange > xCellRange( xTable, uno::UNO_QUERY_THROW );
for( sal_Int32 nRow = 0; nRow < xRows->getCount(); nRow++ )
{
for( sal_Int32 nColumn = 0; nColumn < xColumns->getCount(); nColumn++ )
{
uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nRow ), uno::UNO_QUERY_THROW );
if ( !xCell->isMerged() )
{
sal_Int32 nLeft = aColumns[ nColumn ].first;
sal_Int32 nTop = aRows[ nRow ].first;
sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
sal_Int32 nBottom = GetCellBottom( nRow, maRect,aRows,xCell );
mbFontIndependentLineSpacing = sal_False;
mXPropSet = uno::Reference< beans::XPropertySet >( xCell, uno::UNO_QUERY_THROW );
mXText = uno::Reference< text::XSimpleText >( xCell, uno::UNO_QUERY_THROW );
mnTextSize = mXText->getString().getLength();
::com::sun::star::uno::Any aAny;
if ( GetPropertyValue( aAny, mXPropSet, String( RTL_CONSTASCII_USTRINGPARAM( "FontIndependentLineSpacing" ) ) ), sal_True )
aAny >>= mbFontIndependentLineSpacing;
EscherPropertyContainer aPropOptSp;
mpPptEscherEx->OpenContainer( ESCHER_SpContainer );
ImplCreateShape( ESCHER_ShpInst_Rectangle, 0xa02, aSolverContainer ); // Flags: Connector | HasSpt | Child
aPropOptSp.CreateFillProperties( mXPropSet, sal_True );
aPropOptSp.AddOpt( ESCHER_Prop_fNoLineDrawDash, 0x90000 );
aPropOptSp.CreateTextProperties( mXPropSet, mnTxId += 0x60, sal_False, sal_True );
aPropOptSp.AddOpt( ESCHER_Prop_WrapText, ESCHER_WrapSquare );
SvMemoryStream aClientTextBox( 0x200, 0x200 );
SvMemoryStream aExtBu( 0x200, 0x200 );
ImplWriteTextStyleAtom( aClientTextBox, EPP_TEXTTYPE_Other, 0, NULL, aExtBu, &aPropOptSp );
// need write client data for extend bullet
if ( aExtBu.Tell() )
{
SvMemoryStream* pClientData = new SvMemoryStream( 0x200, 0x200 );
ImplProgTagContainer( pClientData, &aExtBu );
*mpStrm << (sal_uInt32)( ( ESCHER_ClientData << 16 ) | 0xf )
<< (sal_uInt32)pClientData->Tell();
mpStrm->Write( pClientData->GetData(), pClientData->Tell() );
delete pClientData, pClientData = NULL;
}
aPropOptSp.Commit( *mpStrm );
mpPptEscherEx->AddAtom( 16, ESCHER_ChildAnchor );
*mpStrm << nLeft
<< nTop
<< nRight
<< nBottom;
*mpStrm << (sal_uInt32)( ( ESCHER_ClientTextbox << 16 ) | 0xf )
<< (sal_uInt32)aClientTextBox.Tell();
mpStrm->Write( aClientTextBox.GetData(), aClientTextBox.Tell() );
mpPptEscherEx->CloseContainer();
}
}
}
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" ) );
// creating horz lines
for( sal_Int32 nLine = 0; nLine < ( xRows->getCount() + 1 ); nLine++ )
{
for( sal_Int32 nColumn = 0; nColumn < xColumns->getCount(); nColumn++ )
{
CellBorder aCellBorder;
aCellBorder.mnPos = aColumns[ nColumn ].first;
aCellBorder.mnLength = aColumns[ nColumn ].second;
sal_Bool bTop = sal_False;
//write nLine*nColumn cell's top border
if ( nLine < xRows->getCount() )
{ // top border
uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nLine ), uno::UNO_QUERY_THROW );
if ( !xCell->isMerged() )
{
uno::Reference< beans::XPropertySet > xPropSet2( xCell, uno::UNO_QUERY_THROW );
table::BorderLine aBorderLine;
if ( xPropSet2->getPropertyValue( sTopBorder ) >>= aBorderLine )
aCellBorder.maCellBorder = aBorderLine;
sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
bTop = ImplCreateCellBorder( &aCellBorder, aCellBorder.mnPos,
aRows[ nLine ].first, nRight, aRows[ nLine ].first );
}
}
//if nLine*nColumn cell's top border is empty, check (nLine-1)*nColumn cell's bottom border
//and write the last row's bottom border
if (( nLine && !bTop ) || (nLine == xRows->getCount()))
{ // bottom border
sal_Int32 nRow = nLine;
while( nRow )
{ //find last no merged cell
uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn, nRow - 1 ), uno::UNO_QUERY_THROW );
if ( !xCell->isMerged() )
{
sal_Int32 nRight = GetCellRight( nColumn, maRect,aColumns,xCell );
sal_Int32 nBottom = GetCellBottom( nRow - 1, maRect,aRows,xCell );
if ( nBottom == ( aRows[ nLine-1 ].first + aRows[ nLine-1 ].second ) )
{
uno::Reference< table::XMergeableCell > xCellOwn( xCellRange->getCellByPosition( nColumn, nRow - 1 ), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xPropSet2( xCellOwn, uno::UNO_QUERY_THROW );
table::BorderLine aBorderLine;
if ( xPropSet2->getPropertyValue( sBottomBorder ) >>= aBorderLine )
aCellBorder.maCellBorder = aBorderLine;
ImplCreateCellBorder( &aCellBorder, aCellBorder.mnPos,
nBottom, nRight, nBottom);
}
nRow=0;
}
else
nRow--;
}
}
}
}
// creating vertical lines
for( sal_Int32 nLine = 0; nLine < ( xColumns->getCount() + 1 ); nLine++ )
{
for( sal_Int32 nRow = 0; nRow < xRows->getCount(); nRow++ )
{
CellBorder aCellBorder;
aCellBorder.mnPos = aRows[ nRow].first;
aCellBorder.mnLength = aRows[ nRow].second;
sal_Bool bLeft = sal_False;
if ( nLine < xColumns->getCount() )
{ // left border
uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nLine, nRow ), uno::UNO_QUERY_THROW );
if (!xCell->isMerged() )
{
uno::Reference< beans::XPropertySet > xCellSet( xCell, uno::UNO_QUERY_THROW );
table::BorderLine aBorderLine;
if ( xCellSet->getPropertyValue( sLeftBorder ) >>= aBorderLine )
aCellBorder.maCellBorder = aBorderLine;
sal_Int32 nBottom = GetCellBottom( nRow, maRect, aRows,xCell );
bLeft = ImplCreateCellBorder( &aCellBorder, aColumns[nLine].first, aCellBorder.mnPos,
aColumns[nLine].first, nBottom );
}
}
if ( ( nLine && !bLeft )||(nLine == xColumns->getCount()))
{ // right border
sal_Int32 nColumn = nLine;
while ( nColumn )
{
uno::Reference< table::XMergeableCell > xCell( xCellRange->getCellByPosition( nColumn - 1, nRow ), uno::UNO_QUERY_THROW );
if (!xCell->isMerged() )
{
sal_Int32 nRight = GetCellRight( nColumn-1, maRect, aColumns,xCell );
sal_Int32 nBottom = GetCellBottom( nRow, maRect, aRows, xCell );
if ( nRight == (aColumns[nLine-1].first + aColumns[nLine-1].second) )
{
uno::Reference< table::XMergeableCell > xCellOwn( xCellRange->getCellByPosition( nColumn - 1, nRow ), uno::UNO_QUERY_THROW );
uno::Reference< beans::XPropertySet > xCellSet( xCellOwn, uno::UNO_QUERY_THROW );
table::BorderLine aBorderLine;
if ( xCellSet->getPropertyValue( sRightBorder ) >>= aBorderLine )
aCellBorder.maCellBorder = aBorderLine;
ImplCreateCellBorder( &aCellBorder, nRight, aCellBorder.mnPos,
nRight, nBottom );
}
nColumn = 0;
}
else
nColumn --;
}
}
}
}
}
}
}
catch( uno::Exception& )
{
}
mpPptEscherEx->CloseContainer();
}