?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / svx / source / customshapes / EnhancedCustomShapeFontWork.cxx
blobb772ca84481b07f15e77c181cb4d93b788a4f796
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: EnhancedCustomShapeFontWork.cxx,v $
10 * $Revision: 1.20 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33 #include "EnhancedCustomShapeFontWork.hxx"
34 #include <tools/solar.h> // UINTXX
35 #include <svx/svddef.hxx>
36 #include <svx/svdogrp.hxx>
37 #include <svx/svdopath.hxx>
38 #include <vcl/metric.hxx>
39 #include <svx/svdpage.hxx>
40 #include <svx/sdasitm.hxx>
41 #include <svx/sdasaitm.hxx>
42 #include <svx/sdtfsitm.hxx>
43 #include <vcl/virdev.hxx>
44 #include <svditer.hxx>
45 #include <vcl/metric.hxx>
46 #include <svx/eeitem.hxx>
47 #include <svx/frmdiritem.hxx>
48 #include <fontitem.hxx>
49 #include <svx/postitem.hxx>
50 #include <svx/wghtitem.hxx>
51 #include <svx/charscaleitem.hxx>
52 #include "EnhancedCustomShapeTypeNames.hxx"
53 #include <svx/svdorect.hxx>
54 #include <svx/svdoashp.hxx>
55 #include <svx/outliner.hxx>
56 #include <svx/outlobj.hxx>
57 #include <svx/editobj.hxx>
58 #include <svx/editeng.hxx>
59 #include <svx/svdmodel.hxx>
60 #include <vector>
61 #include <numeric>
62 #include <algorithm>
63 #include <comphelper/processfactory.hxx>
64 #ifndef _COM_SUN_STAR_I18N_SCRIPTTYPE_HDL_
65 #include <com/sun/star/i18n/ScriptType.hdl>
66 #endif
67 #include <basegfx/polygon/b2dpolypolygontools.hxx>
68 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
69 #ifndef _COM_SUN_STAR_I18N_CHARACTERITERATORMODE_HDL_
70 #include <com/sun/star/i18n/CharacterIteratorMode.hdl>
71 #endif
72 #include <basegfx/polygon/b2dpolygontools.hxx>
73
74 using namespace com::sun::star;
75 using namespace com::sun::star::uno;
76
77 typedef std::vector< std::vector< double > > PolyPolygonDistances;
78
79 struct FWCharacterData // representing a single character
80 {
81 std::vector< PolyPolygon > vOutlines;
82 Rectangle aBoundRect;
83 };
84 struct FWParagraphData // representing a single paragraph
85 {
86 rtl::OUString aString;
87 std::vector< FWCharacterData > vCharacters;
88 Rectangle aBoundRect;
89 sal_Int16 nFrameDirection;
90 };
91 struct FWTextArea // representing multiple concluding paragraphs
92 {
93 std::vector< FWParagraphData > vParagraphs;
94 Rectangle aBoundRect;
95 };
96 struct FWData // representing the whole text
97 {
98 std::vector< FWTextArea > vTextAreas;
99 double fHorizontalTextScaling;
100 sal_uInt32 nMaxParagraphsPerTextArea;
101 sal_Int32 nSingleLineHeight;
102 sal_Bool bSingleLineMode;
103 };
104
105
106 sal_Bool InitializeFontWorkData( const SdrObject* pCustomShape, const sal_uInt16 nOutlinesCount2d, FWData& rFWData )
107 {
108 sal_Bool bNoErr = sal_False;
109 sal_Bool bSingleLineMode = sal_False;
110 sal_uInt16 nTextAreaCount = nOutlinesCount2d;
111 if ( nOutlinesCount2d & 1 )
112 bSingleLineMode = sal_True;
113 else
114 nTextAreaCount >>= 1;
115
116 if ( nTextAreaCount )
117 {
118 rFWData.bSingleLineMode = bSingleLineMode;
119
120 // setting the strings
121 OutlinerParaObject* pParaObj = ((SdrObjCustomShape*)pCustomShape)->GetOutlinerParaObject();
122 if ( pParaObj )
123 {
124 const EditTextObject& rTextObj = pParaObj->GetTextObject();
125 sal_Int32 nParagraphsLeft = rTextObj.GetParagraphCount();
126
127 rFWData.nMaxParagraphsPerTextArea = ( ( nParagraphsLeft - 1 ) / nTextAreaCount ) + 1;
128 sal_Int16 j = 0;
129 while( nParagraphsLeft && nTextAreaCount )
130 {
131 FWTextArea aTextArea;
132 sal_Int32 i, nParagraphs = ( ( nParagraphsLeft - 1 ) / nTextAreaCount ) + 1;
133 for ( i = 0; i < nParagraphs; i++, j++ )
134 {
135 FWParagraphData aParagraphData;
136 aParagraphData.aString = rTextObj.GetText( j );
137
138 const SfxItemSet& rParaSet = rTextObj.GetParaAttribs( j ); // retrieving some paragraph attributes
139 aParagraphData.nFrameDirection = ((SvxFrameDirectionItem&)rParaSet.Get( EE_PARA_WRITINGDIR )).GetValue();
140 aTextArea.vParagraphs.push_back( aParagraphData );
141 }
142 rFWData.vTextAreas.push_back( aTextArea );
143 nParagraphsLeft -= nParagraphs;
144 nTextAreaCount--;
145 }
146 bNoErr = sal_True;
147 }
148 }
149 return bNoErr;
150 }
151
152 double GetLength( const Polygon& rPolygon )
153 {
154 double fLength = 0;
155 if ( rPolygon.GetSize() > 1 )
156 {
157 sal_uInt16 nCount = rPolygon.GetSize();
158 while( --nCount )
159 fLength += ((Polygon&)rPolygon).CalcDistance( nCount, nCount - 1 );
160 }
161 return fLength;
162 }
163
164
165 /* CalculateHorizontalScalingFactor returns the horizontal scaling factor for
166 the whole text object, so that each text will match its corresponding 2d Outline */
167 void CalculateHorizontalScalingFactor( const SdrObject* pCustomShape,
168 FWData& rFWData, const PolyPolygon& rOutline2d )
169 {
170 double fScalingFactor = 1.0;
171 sal_Bool bScalingFactorDefined = sal_False;
172
173 sal_uInt16 i = 0;
174 sal_Bool bSingleLineMode = sal_False;
175 sal_uInt16 nOutlinesCount2d = rOutline2d.Count();
176
177 Font aFont;
178 SvxFontItem& rFontItem = (SvxFontItem&)pCustomShape->GetMergedItem( EE_CHAR_FONTINFO );
179 aFont.SetHeight( pCustomShape->GetLogicRect().GetHeight() / rFWData.nMaxParagraphsPerTextArea );
180 aFont.SetAlign( ALIGN_TOP );
181 aFont.SetName( rFontItem.GetFamilyName() );
182 aFont.SetFamily( rFontItem.GetFamily() );
183 aFont.SetStyleName( rFontItem.GetStyleName() );
184 aFont.SetOrientation( 0 );
185 // initializing virtual device
186
187 VirtualDevice aVirDev( 1 );
188 aVirDev.SetMapMode( MAP_100TH_MM );
189 aVirDev.SetFont( aFont );
190
191 if ( nOutlinesCount2d & 1 )
192 bSingleLineMode = sal_True;
193
194 std::vector< FWTextArea >::iterator aTextAreaIter = rFWData.vTextAreas.begin();
195 std::vector< FWTextArea >::iterator aTextAreaIEnd = rFWData.vTextAreas.end();
196 while( aTextAreaIter != aTextAreaIEnd )
197 {
198 // calculating the width of the corresponding 2d text area
199 double fWidth = GetLength( rOutline2d.GetObject( i++ ) );
200 if ( !bSingleLineMode )
201 {
202 fWidth += GetLength( rOutline2d.GetObject( i++ ) );
203 fWidth /= 2.0;
204 }
205 std::vector< FWParagraphData >::const_iterator aParagraphIter( aTextAreaIter->vParagraphs.begin() );
206 std::vector< FWParagraphData >::const_iterator aParagraphIEnd( aTextAreaIter->vParagraphs.end() );
207 while( aParagraphIter != aParagraphIEnd )
208 {
209 double fTextWidth = aVirDev.GetTextWidth( aParagraphIter->aString );
210 if ( fTextWidth > 0.0 )
211 {
212 double fScale = fWidth / fTextWidth;
213 if ( !bScalingFactorDefined )
214 {
215 fScalingFactor = fScale;
216 bScalingFactorDefined = sal_True;
217 }
218 else
219 {
220 if ( fScale < fScalingFactor )
221 fScalingFactor = fScale;
222 }
223 }
224 aParagraphIter++;
225 }
226 aTextAreaIter++;
227 }
228 rFWData.fHorizontalTextScaling = fScalingFactor;
229 }
230
231 void GetTextAreaOutline( const FWData& rFWData, const SdrObject* pCustomShape, FWTextArea& rTextArea, sal_Bool bSameLetterHeights )
232 {
233 sal_Bool bIsVertical = ((SdrObjCustomShape*)pCustomShape)->IsVerticalWriting();
234 sal_Int32 nVerticalOffset = rFWData.nMaxParagraphsPerTextArea > rTextArea.vParagraphs.size()
235 ? rFWData.nSingleLineHeight / 2 : 0;
236
237 std::vector< FWParagraphData >::iterator aParagraphIter( rTextArea.vParagraphs.begin() );
238 std::vector< FWParagraphData >::iterator aParagraphIEnd( rTextArea.vParagraphs.end() );
239 while( aParagraphIter != aParagraphIEnd )
240 {
241 const rtl::OUString& rText = aParagraphIter->aString;
242 if ( rText.getLength() )
243 {
244 // generating vcl/font
245 USHORT nScriptType = i18n::ScriptType::LATIN;
246 Reference< i18n::XBreakIterator > xBI( EnhancedCustomShapeFontWork::GetBreakIterator() );
247 if ( xBI.is() )
248 {
249 nScriptType = xBI->getScriptType( rText, 0 );
250 sal_uInt16 nChg = 0;
251 if( i18n::ScriptType::WEAK == nScriptType )
252 {
253 nChg = (xub_StrLen)xBI->endOfScript( rText, nChg, nScriptType );
254 if( nChg < rText.getLength() )
255 nScriptType = xBI->getScriptType( rText, nChg );
256 else
257 nScriptType = i18n::ScriptType::LATIN;
258 }
259 }
260 UINT16 nFntItm = EE_CHAR_FONTINFO;
261 if ( nScriptType == i18n::ScriptType::COMPLEX )
262 nFntItm = EE_CHAR_FONTINFO_CTL;
263 else if ( nScriptType == i18n::ScriptType::ASIAN )
264 nFntItm = EE_CHAR_FONTINFO_CJK;
265 SvxFontItem& rFontItem = (SvxFontItem&)pCustomShape->GetMergedItem( nFntItm );
266 Font aFont;
267 aFont.SetHeight( rFWData.nSingleLineHeight );
268 aFont.SetAlign( ALIGN_TOP );
269 // aFont.SetAlign( )
270
271 aFont.SetName( rFontItem.GetFamilyName() );
272 aFont.SetFamily( rFontItem.GetFamily() );
273 aFont.SetStyleName( rFontItem.GetStyleName() );
274 aFont.SetOrientation( 0 );
275
276 SvxPostureItem& rPostureItem = (SvxPostureItem&)pCustomShape->GetMergedItem( EE_CHAR_ITALIC );
277 aFont.SetItalic( rPostureItem.GetPosture() );
278
279 SvxWeightItem& rWeightItem = (SvxWeightItem&)pCustomShape->GetMergedItem( EE_CHAR_WEIGHT );
280 aFont.SetWeight( rWeightItem.GetWeight() );
281
282 // initializing virtual device
283 VirtualDevice aVirDev( 1 );
284 aVirDev.SetMapMode( MAP_100TH_MM );
285 aVirDev.SetFont( aFont );
286 aVirDev.EnableRTL( sal_True );
287 if ( aParagraphIter->nFrameDirection == FRMDIR_HORI_RIGHT_TOP )
288 aVirDev.SetLayoutMode( TEXT_LAYOUT_BIDI_RTL );
289
290 SvxCharScaleWidthItem& rCharScaleWidthItem = (SvxCharScaleWidthItem&)pCustomShape->GetMergedItem( EE_CHAR_FONTWIDTH );
291 sal_uInt16 nCharScaleWidth = rCharScaleWidthItem.GetValue();
292 sal_Int32* pDXArry = NULL;
293 sal_Int32 nWidth = 0;
294
295 // VERTICAL
296 if ( bIsVertical )
297 {
298 // vertical _> each single character needs to be rotated by 90
299 sal_Int32 i;
300 sal_Int32 nHeight = 0;
301 Rectangle aSingleCharacterUnion;
302 for ( i = 0; i < rText.getLength(); i++ )
303 {
304 FWCharacterData aCharacterData;
305 rtl::OUString aCharText( (sal_Unicode)rText[ i ] );
306 if ( aVirDev.GetTextOutlines( aCharacterData.vOutlines, aCharText, 0, 0, STRING_LEN, TRUE, nWidth, pDXArry ) )
307 {
308 sal_Int32 nTextWidth = aVirDev.GetTextWidth( aCharText, 0, STRING_LEN );
309 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterData.vOutlines.begin();
310 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterData.vOutlines.end();
311 if ( aOutlineIter == aOutlineIEnd )
312 {
313 nHeight += rFWData.nSingleLineHeight;
314 }
315 else
316 {
317 while ( aOutlineIter != aOutlineIEnd )
318 {
319 // rotating
320 aOutlineIter->Rotate( Point( nTextWidth / 2, rFWData.nSingleLineHeight / 2 ), 900 );
321 aCharacterData.aBoundRect.Union( aOutlineIter->GetBoundRect() );
322 aOutlineIter++;
323 }
324 aOutlineIter = aCharacterData.vOutlines.begin();
325 aOutlineIEnd = aCharacterData.vOutlines.end();
326 while ( aOutlineIter != aOutlineIEnd )
327 {
328 sal_Int32 nM = - aCharacterData.aBoundRect.Left() + nHeight;
329 aOutlineIter->Move( nM, 0 );
330 aCharacterData.aBoundRect.Move( nM, 0 );
331 aOutlineIter++;
332 }
333 nHeight += aCharacterData.aBoundRect.GetWidth() + ( rFWData.nSingleLineHeight / 5 );
334 aSingleCharacterUnion.Union( aCharacterData.aBoundRect );
335 }
336 }
337 aParagraphIter->vCharacters.push_back( aCharacterData );
338 }
339 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
340 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
341 while ( aCharacterIter != aCharacterIEnd )
342 {
343 std::vector< PolyPolygon >::iterator aOutlineIter( aCharacterIter->vOutlines.begin() );
344 std::vector< PolyPolygon >::iterator aOutlineIEnd( aCharacterIter->vOutlines.end() );
345 while ( aOutlineIter != aOutlineIEnd )
346 {
347 aOutlineIter->Move( ( aSingleCharacterUnion.GetWidth() - aCharacterIter->aBoundRect.GetWidth() ) / 2, 0 );
348 aOutlineIter++;
349 }
350 aCharacterIter++;
351 }
352 }
353 else
354 {
355 if ( ( nCharScaleWidth != 100 ) && nCharScaleWidth )
356 { // applying character spacing
357 pDXArry = new sal_Int32[ rText.getLength() ];
358 aVirDev.GetTextArray( rText, pDXArry, 0, STRING_LEN );
359 FontMetric aFontMetric( aVirDev.GetFontMetric() );
360 aFont.SetWidth( (sal_Int32)( (double)aFontMetric.GetWidth() * ( (double)100 / (double)nCharScaleWidth ) ) );
361 aVirDev.SetFont( aFont );
362 }
363 FWCharacterData aCharacterData;
364 if ( aVirDev.GetTextOutlines( aCharacterData.vOutlines, rText, 0, 0, STRING_LEN, TRUE, nWidth, pDXArry ) )
365 {
366 aParagraphIter->vCharacters.push_back( aCharacterData );
367 }
368
369 /* trying to retrieve each single character _> is not working well
370 sal_Int32 i;
371 for ( i = 0; i < rText.getLength(); i++ )
372 {
373 FWCharacterData aCharacterData;
374 if ( aVirDev.GetTextOutlines( aCharacterData.vOutlines, rText, 0, i, 1, TRUE, nWidth, pDXArry ) )
375 {
376 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterData.vOutlines.begin();
377 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterData.vOutlines.end();
378 while ( aOutlineIter != aOutlineIEnd )
379 {
380 aCharacterData.aBoundRect.Union( aOutlineIter->GetBoundRect() );
381 aOutlineIter++;
382 }
383 }
384 aParagraphIter->vCharacters.push_back( aCharacterData );
385 }
386 */
387 }
388 delete[] pDXArry;
389
390 // veritcal alignment
391 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
392 std::vector< FWCharacterData >::iterator aCharacterIEnd ( aParagraphIter->vCharacters.end() );
393 while ( aCharacterIter != aCharacterIEnd )
394 {
395 std::vector< PolyPolygon >::iterator aOutlineIter( aCharacterIter->vOutlines.begin() );
396 std::vector< PolyPolygon >::iterator aOutlineIEnd( aCharacterIter->vOutlines.end() );
397 while( aOutlineIter != aOutlineIEnd )
398 {
399
400 PolyPolygon& rPolyPoly = *aOutlineIter++;
401
402 if ( nVerticalOffset )
403 rPolyPoly.Move( 0, nVerticalOffset );
404
405 // retrieving the boundrect for the paragraph
406 Rectangle aBoundRect( rPolyPoly.GetBoundRect() );
407 aParagraphIter->aBoundRect.Union( aBoundRect );
408 }
409 aCharacterIter++;
410 }
411 }
412 // updating the boundrect for the text area by merging the current paragraph boundrect
413 if ( aParagraphIter->aBoundRect.IsEmpty() )
414 {
415 if ( rTextArea.aBoundRect.IsEmpty() )
416 rTextArea.aBoundRect = Rectangle( Point( 0, 0 ), Size( 1, rFWData.nSingleLineHeight ) );
417 else
418 rTextArea.aBoundRect.Bottom() += rFWData.nSingleLineHeight;
419 }
420 else
421 {
422 Rectangle& rParagraphBoundRect = aParagraphIter->aBoundRect;
423 rTextArea.aBoundRect.Union( rParagraphBoundRect );
424
425 if ( bSameLetterHeights )
426 {
427 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
428 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
429 while ( aCharacterIter != aCharacterIEnd )
430 {
431 std::vector< PolyPolygon >::iterator aOutlineIter( aCharacterIter->vOutlines.begin() );
432 std::vector< PolyPolygon >::iterator aOutlineIEnd( aCharacterIter->vOutlines.end() );
433 while( aOutlineIter != aOutlineIEnd )
434 {
435 Rectangle aPolyPolyBoundRect( aOutlineIter->GetBoundRect() );
436 if ( aPolyPolyBoundRect.GetHeight() != rParagraphBoundRect.GetHeight() )
437 aOutlineIter->Scale( 1.0, (double)rParagraphBoundRect.GetHeight() / aPolyPolyBoundRect.GetHeight() );
438 aPolyPolyBoundRect = aOutlineIter->GetBoundRect();
439 sal_Int32 nMove = aPolyPolyBoundRect.Top() - rParagraphBoundRect.Top();
440 if ( nMove )
441 aOutlineIter->Move( 0, -nMove );
442 aOutlineIter++;
443 }
444 aCharacterIter++;
445 }
446 }
447 }
448 if ( bIsVertical )
449 nVerticalOffset -= rFWData.nSingleLineHeight;
450 else
451 nVerticalOffset += rFWData.nSingleLineHeight;
452 aParagraphIter++;
453 }
454 }
455
456 void GetFontWorkOutline( FWData& rFWData, const SdrObject* pCustomShape )
457 {
458 SdrTextHorzAdjust eHorzAdjust( ((SdrTextHorzAdjustItem&)pCustomShape->GetMergedItem( SDRATTR_TEXT_HORZADJUST )).GetValue() );
459 SdrFitToSizeType eFTS( ((SdrTextFitToSizeTypeItem&)pCustomShape->GetMergedItem( SDRATTR_TEXT_FITTOSIZE )).GetValue() );
460
461 std::vector< FWTextArea >::iterator aTextAreaIter = rFWData.vTextAreas.begin();
462 std::vector< FWTextArea >::iterator aTextAreaIEnd = rFWData.vTextAreas.end();
463
464 rFWData.nSingleLineHeight = (sal_Int32)( ( (double)pCustomShape->GetLogicRect().GetHeight()
465 / rFWData.nMaxParagraphsPerTextArea ) * rFWData.fHorizontalTextScaling );
466
467 sal_Bool bSameLetterHeights = sal_False;
468 SdrCustomShapeGeometryItem& rGeometryItem = (SdrCustomShapeGeometryItem&)pCustomShape->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY );
469 const rtl::OUString sTextPath( RTL_CONSTASCII_USTRINGPARAM ( "TextPath" ) );
470 const rtl::OUString sSameLetterHeights( RTL_CONSTASCII_USTRINGPARAM ( "SameLetterHeights" ) );
471 com::sun::star::uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sTextPath, sSameLetterHeights );
472 if ( pAny )
473 *pAny >>= bSameLetterHeights;
474
475 while ( aTextAreaIter != aTextAreaIEnd )
476 {
477 GetTextAreaOutline( rFWData, pCustomShape, *aTextAreaIter, bSameLetterHeights );
478 if ( eFTS == SDRTEXTFIT_ALLLINES )
479 {
480 std::vector< FWParagraphData >::iterator aParagraphIter( aTextAreaIter->vParagraphs.begin() );
481 std::vector< FWParagraphData >::iterator aParagraphIEnd( aTextAreaIter->vParagraphs.end() );
482 while ( aParagraphIter != aParagraphIEnd )
483 {
484 sal_Int32 nParaWidth = aParagraphIter->aBoundRect.GetWidth();
485 if ( nParaWidth )
486 {
487 double fScale = (double)aTextAreaIter->aBoundRect.GetWidth() / nParaWidth;
488
489 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
490 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
491 while ( aCharacterIter != aCharacterIEnd )
492 {
493 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterIter->vOutlines.begin();
494 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterIter->vOutlines.end();
495 while( aOutlineIter != aOutlineIEnd )
496 {
497 aOutlineIter->Scale( fScale, 1.0 );
498 aOutlineIter++;
499 }
500 aCharacterIter++;
501 }
502 }
503 aParagraphIter++;
504 }
505 }
506 else
507 {
508 switch( eHorzAdjust )
509 {
510 case SDRTEXTHORZADJUST_RIGHT :
511 case SDRTEXTHORZADJUST_CENTER:
512 {
513 std::vector< FWParagraphData >::iterator aParagraphIter( aTextAreaIter->vParagraphs.begin() );
514 std::vector< FWParagraphData >::iterator aParagraphIEnd( aTextAreaIter->vParagraphs.end() );
515 while ( aParagraphIter != aParagraphIEnd )
516 {
517 sal_Int32 nHorzDiff = 0;
518 if ( eHorzAdjust == SDRTEXTHORZADJUST_CENTER )
519 nHorzDiff = ( aTextAreaIter->aBoundRect.GetWidth() - aParagraphIter->aBoundRect.GetWidth() ) / 2;
520 else if ( eHorzAdjust == SDRTEXTHORZADJUST_RIGHT )
521 nHorzDiff = ( aTextAreaIter->aBoundRect.GetWidth() - aParagraphIter->aBoundRect.GetWidth() );
522 if ( nHorzDiff )
523 {
524 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
525 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
526 while ( aCharacterIter != aCharacterIEnd )
527 {
528 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterIter->vOutlines.begin();
529 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterIter->vOutlines.end();
530 while( aOutlineIter != aOutlineIEnd )
531 {
532 aOutlineIter->Move( nHorzDiff, 0 );
533 aOutlineIter++;
534 }
535 aCharacterIter++;
536 }
537 }
538 aParagraphIter++;
539 }
540 }
541 break;
542 default:
543 case SDRTEXTHORZADJUST_BLOCK : break; // don't know
544 case SDRTEXTHORZADJUST_LEFT : break; // already left aligned -> nothing to do
545 }
546 }
547 aTextAreaIter++;
548 }
549 }
550
551 basegfx::B2DPolyPolygon GetOutlinesFromShape2d( const SdrObject* pShape2d )
552 {
553 basegfx::B2DPolyPolygon aOutlines2d;
554
555 SdrObjListIter aObjListIter( *pShape2d, IM_DEEPWITHGROUPS );
556 while( aObjListIter.IsMore() )
557 {
558 SdrObject* pPartObj = aObjListIter.Next();
559 if ( pPartObj->ISA( SdrPathObj ) )
560 {
561 basegfx::B2DPolyPolygon aCandidate(((SdrPathObj*)pPartObj)->GetPathPoly());
562 if(aCandidate.areControlPointsUsed())
563 {
564 aCandidate = basegfx::tools::adaptiveSubdivideByAngle(aCandidate);
565 }
566 aOutlines2d.append(aCandidate);
567 }
568 }
569
570 return aOutlines2d;
571 }
572
573 void CalcDistances( const Polygon& rPoly, std::vector< double >& rDistances )
574 {
575 sal_uInt16 i, nCount = rPoly.GetSize();
576 if ( nCount > 1 )
577 {
578 for ( i = 0; i < nCount; i++ )
579 {
580 double fDistance = i ? ((Polygon&)rPoly).CalcDistance( i, i - 1 ) : 0.0;
581 rDistances.push_back( fDistance );
582 }
583 std::partial_sum( rDistances.begin(), rDistances.end(), rDistances.begin() );
584 double fLength = rDistances[ rDistances.size() - 1 ];
585 if ( fLength > 0.0 )
586 {
587 std::vector< double >::iterator aIter = rDistances.begin();
588 std::vector< double >::iterator aEnd = rDistances.end();
589 while ( aIter != aEnd )
590 *aIter++ /= fLength;
591 }
592 }
593 }
594
595 void InsertMissingOutlinePoints( const Polygon& /*rOutlinePoly*/, const std::vector< double >& rDistances, const Rectangle& rTextAreaBoundRect, Polygon& rPoly )
596 {
597 sal_uInt16 i = 0;
598 double fLastDistance = 0.0;
599 for ( i = 0; i < rPoly.GetSize(); i++ )
600 {
601 Point& rPoint = rPoly[ i ];
602 double fDistance = (double)( rPoint.X() - rTextAreaBoundRect.Left() ) / (double)rTextAreaBoundRect.GetWidth();
603 if ( i )
604 {
605 if ( fDistance > fLastDistance )
606 {
607 std::vector< double >::const_iterator aIter = std::upper_bound( rDistances.begin(), rDistances.end(), fLastDistance );
608 if ( aIter != rDistances.end() && ( *aIter > fLastDistance ) && ( *aIter < fDistance ) )
609 {
610 Point& rPt0 = rPoly[ i - 1 ];
611 sal_Int32 fX = rPoint.X() - rPt0.X();
612 sal_Int32 fY = rPoint.Y() - rPt0.Y();
613 double fd = ( 1.0 / ( fDistance - fLastDistance ) ) * ( *aIter - fLastDistance );
614 rPoly.Insert( i, Point( (sal_Int32)( rPt0.X() + fX * fd ), (sal_Int32)( rPt0.Y() + fY * fd ) ) );
615 fDistance = *aIter;
616 }
617 }
618 else if ( fDistance < fLastDistance )
619 {
620 std::vector< double >::const_iterator aIter = std::lower_bound( rDistances.begin(), rDistances.end(), fLastDistance );
621 if ( aIter-- != rDistances.begin() )
622 {
623 if ( ( *aIter > fDistance ) && ( *aIter < fLastDistance ) )
624 {
625 Point& rPt0 = rPoly[ i - 1 ];
626 sal_Int32 fX = rPoint.X() - rPt0.X();
627 sal_Int32 fY = rPoint.Y() - rPt0.Y();
628 double fd = ( 1.0 / ( fDistance - fLastDistance ) ) * ( *aIter - fLastDistance );
629 rPoly.Insert( i, Point( (sal_Int32)( rPt0.X() + fX * fd ), (sal_Int32)( rPt0.Y() + fY * fd ) ) );
630 fDistance = *aIter;
631 }
632 }
633 }
634 }
635 fLastDistance = fDistance;
636 }
637 }
638
639 void GetPoint( const Polygon& rPoly, const std::vector< double >& rDistances, const double& fX, double& fx1, double& fy1 )
640 {
641 fy1 = fx1 = 0.0;
642 if ( rPoly.GetSize() > 1 )
643 {
644 std::vector< double >::const_iterator aIter = std::lower_bound( rDistances.begin(), rDistances.end(), fX );
645 sal_uInt16 nIdx = sal::static_int_cast<sal_uInt16>( std::distance( rDistances.begin(), aIter ) );
646 if ( aIter == rDistances.end() )
647 nIdx--;
648 const Point& rPt = rPoly[ nIdx ];
649 fx1 = rPt.X();
650 fy1 = rPt.Y();
651 if ( nIdx && ( aIter != rDistances.end() ) && ( *aIter != fX ) )
652 {
653 nIdx = sal::static_int_cast<sal_uInt16>( std::distance( rDistances.begin(), aIter ) );
654 double fDist0 = *( aIter - 1 );
655 double fd = ( 1.0 / ( *aIter - fDist0 ) ) * ( fX - fDist0 );
656 const Point& rPt2 = rPoly[ nIdx - 1 ];
657 double fWidth = rPt.X() - rPt2.X();
658 double fHeight= rPt.Y() - rPt2.Y();
659 fWidth *= fd;
660 fHeight*= fd;
661 fx1 = rPt2.X() + fWidth;
662 fy1 = rPt2.Y() + fHeight;
663 }
664 }
665 }
666
667 void FitTextOutlinesToShapeOutlines( const PolyPolygon& aOutlines2d, FWData& rFWData )
668 {
669 std::vector< FWTextArea >::iterator aTextAreaIter = rFWData.vTextAreas.begin();
670 std::vector< FWTextArea >::iterator aTextAreaIEnd = rFWData.vTextAreas.end();
671
672 sal_uInt16 nOutline2dIdx = 0;
673 while( aTextAreaIter != aTextAreaIEnd )
674 {
675 Rectangle rTextAreaBoundRect = aTextAreaIter->aBoundRect;
676 sal_Int32 nLeft = rTextAreaBoundRect.Left();
677 sal_Int32 nTop = rTextAreaBoundRect.Top();
678 sal_Int32 nWidth = rTextAreaBoundRect.GetWidth();
679 sal_Int32 nHeight= rTextAreaBoundRect.GetHeight();
680 if ( rFWData.bSingleLineMode && nHeight && nWidth )
681 {
682 if ( nOutline2dIdx >= aOutlines2d.Count() )
683 break;
684 const Polygon& rOutlinePoly( aOutlines2d[ nOutline2dIdx++ ] );
685 const sal_uInt16 nPointCount = rOutlinePoly.GetSize();
686 if ( nPointCount > 1 )
687 {
688 std::vector< double > vDistances;
689 vDistances.reserve( nPointCount );
690 CalcDistances( rOutlinePoly, vDistances );
691 if ( vDistances.size() )
692 {
693 std::vector< FWParagraphData >::iterator aParagraphIter( aTextAreaIter->vParagraphs.begin() );
694 std::vector< FWParagraphData >::iterator aParagraphIEnd( aTextAreaIter->vParagraphs.end() );
695 while( aParagraphIter != aParagraphIEnd )
696 {
697 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
698 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
699 while ( aCharacterIter != aCharacterIEnd )
700 {
701 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterIter->vOutlines.begin();
702 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterIter->vOutlines.end();
703 while( aOutlineIter != aOutlineIEnd )
704 {
705 PolyPolygon& rPolyPoly = *aOutlineIter;
706 Rectangle aBoundRect( rPolyPoly.GetBoundRect() );
707 double fx1 = aBoundRect.Left() - nLeft;
708 double fx2 = aBoundRect.Right() - nLeft;
709 double fy1, fy2;
710 double fM1 = fx1 / (double)nWidth;
711 double fM2 = fx2 / (double)nWidth;
712
713 GetPoint( rOutlinePoly, vDistances, fM1, fx1, fy1 );
714 GetPoint( rOutlinePoly, vDistances, fM2, fx2, fy2 );
715
716 double fvx = ( fy2 - fy1 );
717 double fvy = - ( fx2 - fx1 );
718 fx1 = fx1 + ( ( fx2 - fx1 ) * 0.5 );
719 fy1 = fy1 + ( ( fy2 - fy1 ) * 0.5 );
720
721 double fAngle = atan2( -fvx, -fvy );
722 double fL = hypot( fvx, fvy );
723 fvx = fvx / fL;
724 fvy = fvy / fL;
725 fL = (double)( aTextAreaIter->aBoundRect.GetHeight() / 2.0 + aTextAreaIter->aBoundRect.Top() ) - aParagraphIter->aBoundRect.Center().Y();
726 fvx *= fL;
727 fvy *= fL;
728 rPolyPoly.Rotate( Point( aBoundRect.Center().X(), aParagraphIter->aBoundRect.Center().Y() ), sin( fAngle ), cos( fAngle ) );
729 rPolyPoly.Move( (sal_Int32)( ( fx1 + fvx )- aBoundRect.Center().X() ), (sal_Int32)( ( fy1 + fvy ) - aParagraphIter->aBoundRect.Center().Y() ) );
730
731 aOutlineIter++;
732 }
733 aCharacterIter++;
734 }
735 aParagraphIter++;
736 }
737 }
738 }
739 }
740 else
741 {
742 if ( ( nOutline2dIdx + 1 ) >= aOutlines2d.Count() )
743 break;
744 const Polygon& rOutlinePoly( aOutlines2d[ nOutline2dIdx++ ] );
745 const Polygon& rOutlinePoly2( aOutlines2d[ nOutline2dIdx++ ] );
746 const sal_uInt16 nPointCount = rOutlinePoly.GetSize();
747 const sal_uInt16 nPointCount2 = rOutlinePoly2.GetSize();
748 if ( ( nPointCount > 1 ) && ( nPointCount2 > 1 ) )
749 {
750 std::vector< double > vDistances;
751 vDistances.reserve( nPointCount );
752 std::vector< double > vDistances2;
753 vDistances2.reserve( nPointCount2 );
754 CalcDistances( rOutlinePoly, vDistances );
755 CalcDistances( rOutlinePoly2, vDistances2 );
756 std::vector< FWParagraphData >::iterator aParagraphIter = aTextAreaIter->vParagraphs.begin();
757 std::vector< FWParagraphData >::iterator aParagraphIEnd = aTextAreaIter->vParagraphs.end();
758 while( aParagraphIter != aParagraphIEnd )
759 {
760 std::vector< FWCharacterData >::iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
761 std::vector< FWCharacterData >::iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
762 while ( aCharacterIter != aCharacterIEnd )
763 {
764 std::vector< PolyPolygon >::iterator aOutlineIter = aCharacterIter->vOutlines.begin();
765 std::vector< PolyPolygon >::iterator aOutlineIEnd = aCharacterIter->vOutlines.end();
766 while( aOutlineIter != aOutlineIEnd )
767 {
768 PolyPolygon& rPolyPoly = *aOutlineIter;
769 sal_uInt16 i, nPolyCount = rPolyPoly.Count();
770 for ( i = 0; i < nPolyCount; i++ )
771 {
772 // #i35928#
773 basegfx::B2DPolygon aCandidate(rPolyPoly[ i ].getB2DPolygon());
774
775 if(aCandidate.areControlPointsUsed())
776 {
777 aCandidate = basegfx::tools::adaptiveSubdivideByAngle(aCandidate);
778 }
779
780 // create local polygon copy to work on
781 Polygon aLocalPoly(aCandidate);
782
783 InsertMissingOutlinePoints( rOutlinePoly, vDistances, rTextAreaBoundRect, aLocalPoly );
784 InsertMissingOutlinePoints( rOutlinePoly2, vDistances2, rTextAreaBoundRect, aLocalPoly );
785
786 sal_uInt16 j, _nPointCount = aLocalPoly.GetSize();
787 for ( j = 0; j < _nPointCount; j++ )
788 {
789 Point& rPoint = aLocalPoly[ j ];
790 rPoint.X() -= nLeft;
791 rPoint.Y() -= nTop;
792 double fX = (double)rPoint.X() / (double)nWidth;
793 double fY = (double)rPoint.Y() / (double)nHeight;
794
795 double fx1, fy1, fx2, fy2;
796 GetPoint( rOutlinePoly, vDistances, fX, fx1, fy1 );
797 GetPoint( rOutlinePoly2, vDistances2, fX, fx2, fy2 );
798 double fWidth = fx2 - fx1;
799 double fHeight= fy2 - fy1;
800 rPoint.X() = (sal_Int32)( fx1 + fWidth * fY );
801 rPoint.Y() = (sal_Int32)( fy1 + fHeight* fY );
802 }
803
804 // write back polygon
805 rPolyPoly[ i ] = aLocalPoly;
806 }
807 aOutlineIter++;
808 }
809 aCharacterIter++;
810 }
811 aParagraphIter++;
812 }
813 }
814 }
815 aTextAreaIter++;
816 }
817 }
818
819 SdrObject* CreateSdrObjectFromParagraphOutlines( const FWData& rFWData, const SdrObject* pCustomShape )
820 {
821 SdrObject* pRet = NULL;
822 if ( rFWData.vTextAreas.size() )
823 {
824 pRet = new SdrObjGroup();
825 // SJ: not setting model, so we save a lot of broadcasting and the model is not modified any longer
826 // pRet->SetModel( pCustomShape->GetModel() );
827 std::vector< FWTextArea >::const_iterator aTextAreaIter = rFWData.vTextAreas.begin();
828 std::vector< FWTextArea >::const_iterator aTextAreaIEnd = rFWData.vTextAreas.end();
829 while ( aTextAreaIter != aTextAreaIEnd )
830 {
831 std::vector< FWParagraphData >::const_iterator aParagraphIter = aTextAreaIter->vParagraphs.begin();
832 std::vector< FWParagraphData >::const_iterator aParagraphIEnd = aTextAreaIter->vParagraphs.end();
833 while ( aParagraphIter != aParagraphIEnd )
834 {
835 std::vector< FWCharacterData >::const_iterator aCharacterIter( aParagraphIter->vCharacters.begin() );
836 std::vector< FWCharacterData >::const_iterator aCharacterIEnd( aParagraphIter->vCharacters.end() );
837 while ( aCharacterIter != aCharacterIEnd )
838 {
839 std::vector< PolyPolygon >::const_iterator aOutlineIter = aCharacterIter->vOutlines.begin();
840 std::vector< PolyPolygon >::const_iterator aOutlineIEnd = aCharacterIter->vOutlines.end();
841 while( aOutlineIter != aOutlineIEnd )
842 {
843 SdrObject* pPathObj = new SdrPathObj( OBJ_POLY, aOutlineIter->getB2DPolyPolygon() );
844 // SJ: not setting model, so we save a lot of broadcasting and the model is not modified any longer
845 // pPathObj->SetModel( pCustomShape->GetModel() );
846 ((SdrObjGroup*)pRet)->GetSubList()->NbcInsertObject( pPathObj );
847 aOutlineIter++;
848 }
849 aCharacterIter++;
850 }
851 aParagraphIter++;
852 }
853 aTextAreaIter++;
854 }
855
856 Point aP( pCustomShape->GetSnapRect().Center() );
857 Size aS( pCustomShape->GetLogicRect().GetSize() );
858 aP.X() -= aS.Width() / 2;
859 aP.Y() -= aS.Height() / 2;
860 Rectangle aLogicRect( aP, aS );
861
862 SfxItemSet aSet( pCustomShape->GetMergedItemSet() );
863 aSet.ClearItem( SDRATTR_TEXTDIRECTION ); //SJ: vertical writing is not required, by removing this item no outliner is created
864 aSet.Put(SdrShadowItem(sal_False)); // #i37011# NO shadow for FontWork geometry
865 pRet->SetMergedItemSet( aSet ); // * otherwise we would crash, because the outliner tries to create a Paraobject, but there is no model
866 }
867 return pRet;
868 }
869
870 ::com::sun::star::uno::Reference < ::com::sun::star::i18n::XBreakIterator > EnhancedCustomShapeFontWork::mxBreakIterator = 0;
871
872 Reference < i18n::XBreakIterator > EnhancedCustomShapeFontWork::GetBreakIterator()
873 {
874 if ( !mxBreakIterator.is() )
875 {
876 Reference< lang::XMultiServiceFactory > xMSF = ::comphelper::getProcessServiceFactory();
877 Reference < XInterface > xI = xMSF->createInstance( rtl::OUString::createFromAscii( "com.sun.star.i18n.BreakIterator" ) );
878 if ( xI.is() )
879 {
880 Any x = xI->queryInterface( ::getCppuType((const Reference< i18n::XBreakIterator >*)0) );
881 x >>= mxBreakIterator;
882 }
883 }
884 return mxBreakIterator;
885 }
886
887 SdrObject* EnhancedCustomShapeFontWork::CreateFontWork( const SdrObject* pShape2d, const SdrObject* pCustomShape )
888 {
889 SdrObject* pRet = NULL;
890
891 Rectangle aLogicRect( pCustomShape->GetLogicRect() );
892 PolyPolygon aOutlines2d( GetOutlinesFromShape2d( pShape2d ) );
893 sal_uInt16 nOutlinesCount2d = aOutlines2d.Count();
894 if ( nOutlinesCount2d )
895 {
896 FWData aFWData;
897 if ( InitializeFontWorkData( pCustomShape, nOutlinesCount2d, aFWData ) )
898 {
899 /* retrieves the horizontal scaling factor that has to be used
900 to fit each paragraph text into its corresponding 2d outline */
901 CalculateHorizontalScalingFactor( pCustomShape, aFWData, aOutlines2d );
902
903 /* retrieving the Outlines for the each Paragraph. */
904
905 GetFontWorkOutline( aFWData, pCustomShape );
906
907 FitTextOutlinesToShapeOutlines( aOutlines2d, aFWData );
908
909 pRet = CreateSdrObjectFromParagraphOutlines( aFWData, pCustomShape );
910 }
911 }
912 return pRet;
913 }
vba interoperability for OOo