?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Version 5.2.6.1, tag libreoffice-5.2.6.1
[LibreOffice.git] / lotuswordpro / source / filter / lwpdrawobj.cxx
blobcab4dd2601258d0bf72ebc70c8a7a5fb350f0cae
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*************************************************************************
3 *
4 * The Contents of this file are made available subject to the terms of
5 * either of the following licenses
6 *
7 * - GNU Lesser General Public License Version 2.1
8 * - Sun Industry Standards Source License Version 1.1
9 *
10 * Sun Microsystems Inc., October, 2000
11 *
12 * GNU Lesser General Public License Version 2.1
13 * =============================================
14 * Copyright 2000 by Sun Microsystems, Inc.
15 * 901 San Antonio Road, Palo Alto, CA 94303, USA
16 *
17 * This library is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU Lesser General Public
19 * License version 2.1, as published by the Free Software Foundation.
20 *
21 * This library is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
24 * Lesser General Public License for more details.
25 *
26 * You should have received a copy of the GNU Lesser General Public
27 * License along with this library; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
29 * MA 02111-1307 USA
30 *
31 *
32 * Sun Industry Standards Source License Version 1.1
33 * =================================================
34 * The contents of this file are subject to the Sun Industry Standards
35 * Source License Version 1.1 (the "License"); You may not use this file
36 * except in compliance with the License. You may obtain a copy of the
37 * License at http://www.openoffice.org/license.html.
38 *
39 * Software provided under this License is provided on an "AS IS" basis,
40 * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
41 * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
42 * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
43 * See the License for the specific provisions governing your rights and
44 * obligations concerning the Software.
45 *
46 * The Initial Developer of the Original Code is: IBM Corporation
47 *
48 * Copyright: 2008 by IBM Corporation
49 *
50 * All Rights Reserved.
51 *
52 * Contributor(s): _______________________________________
53 *
54 *
55 ************************************************************************/
56 /**
57 * @file
58 * Implementation file of LwpDrawObjcts and associated class like LwpDrawGroup, LwpDrawRectange
59 * and so on.
60 */
61 #include <osl/thread.h>
62 #include "lwpglobalmgr.hxx"
63 #include "lwpdrawobj.hxx"
64 #include "lwptools.hxx"
65 #include <tools/stream.hxx>
66
67 #include "xfilter/xfframe.hxx"
68
69 #include "xfilter/xfstylemanager.hxx"
70 #include "xfilter/xfdrawstyle.hxx"
71 #include "xfilter/xftextstyle.hxx"
72 #include "xfilter/xfparastyle.hxx"
73 #include "xfilter/xfimagestyle.hxx"
74 #include "xfilter/xftextboxstyle.hxx"
75 #include "xfilter/xfparagraph.hxx"
76 #include "xfilter/xftextspan.hxx"
77 #include "xfilter/xffont.hxx"
78
79 #include "xfilter/xfdrawrect.hxx"
80 #include "xfilter/xfdrawpath.hxx"
81 #include "xfilter/xfdrawline.hxx"
82 #include "xfilter/xfdrawpolygon.hxx"
83 #include "xfilter/xfimage.hxx"
84
85 #include "lwpcharsetmgr.hxx"
86 #include "lwpsdwrect.hxx"
87
88 /**
89 * @descr Constructor of class LwpDrawObj
90 * @param pStream The memory stream which contains the lwp-sdw draw objects
91 */
92 LwpDrawObj::LwpDrawObj(SvStream * pStream, DrawingOffsetAndScale* pTransData)
93 : m_eType(OT_UNDEFINED)
94 , m_pStream(pStream)
95 , m_pTransData(pTransData)
96 {
97 ReadObjHeaderRecord();
98 }
99
100 /**
101 * @descr read the header record data of lwp-sdw-object
102 */
103 void LwpDrawObj::ReadObjHeaderRecord()
104 {
105 //flags
106 m_pStream->SeekRel(1);
107
108 //record Length
109 m_pStream->ReadUInt16( m_aObjHeader.nRecLen );
110
111 //boundrect
112 m_pStream->ReadInt16( m_aObjHeader.nLeft );
113 m_pStream->ReadInt16( m_aObjHeader.nTop );
114 m_pStream->ReadInt16( m_aObjHeader.nRight );
115 m_pStream->ReadInt16( m_aObjHeader.nBottom );
116
117 //nextObj, prevObj
118 m_pStream->SeekRel(4);
119 }
120
121 /**
122 * @descr read the style of closed lwp-sdw-object like: rectangle, ellipse and so on.
123 */
124 void LwpDrawObj::ReadClosedObjStyle()
125 {
126 if ((m_eType != OT_POLYGON) && (m_eType != OT_TEXTART))
127 {
128 m_pStream->SeekRel(8);
129 }
130
131 m_pStream->ReadUChar( m_aClosedObjStyleRec.nLineWidth );
132 m_pStream->ReadUChar( m_aClosedObjStyleRec.nLineStyle );
133
134 // pen color
135 m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nR );
136 m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nG );
137 m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nB );
138 m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.unused );
139
140 // foreground color
141 m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nR );
142 m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nG );
143 m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nB );
144 m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.unused );
145
146 // background color
147 m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nR );
148 m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nG );
149 m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nB );
150 m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.unused );
151
152 // fill style
153 m_pStream->ReadUInt16( m_aClosedObjStyleRec.nFillType );
154 m_pStream->Read(m_aClosedObjStyleRec.pFillPattern,
155 sizeof(m_aClosedObjStyleRec.pFillPattern));
156 }
157
158 /**
159 * @descr set fill style of drawing objects
160 * @param pStyle pointer of the drawing xfstyle.
161 */
162 void LwpDrawObj::SetFillStyle(XFDrawStyle* pStyle)
163 {
164 if (!pStyle)
165 {
166 assert(false);
167 return;
168 }
169
170 XFColor aForeColor(m_aClosedObjStyleRec.aForeColor.nR,
171 m_aClosedObjStyleRec.aForeColor.nG, m_aClosedObjStyleRec.aForeColor.nB);
172 XFColor aBackColor(m_aClosedObjStyleRec.aBackColor.nR,
173 m_aClosedObjStyleRec.aBackColor.nG, m_aClosedObjStyleRec.aBackColor.nB);
174
175 switch (m_aClosedObjStyleRec.nFillType)
176 {
177 default: //fall through!
178 case FT_TRANSPARENT:
179 {
180 // set fill style : none
181 break;
182 }
183 case FT_SOLID:
184 {
185 pStyle->SetAreaColor(aForeColor);
186 break;
187 }
188 case FT_HORZHATCH:
189 {
190 pStyle->SetAreaColor(aBackColor);
191 pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 0, 0.12, aForeColor);
192 break;
193 }
194 case FT_VERTHATCH:
195 {
196 pStyle->SetAreaColor(aBackColor);
197 pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 90, 0.12, aForeColor);
198 break;
199 }
200 case FT_FDIAGHATCH:
201 {
202 pStyle->SetAreaColor(aBackColor);
203 pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 135, 0.09, aForeColor);
204 break;
205 }
206 case FT_BDIAGHATCH:
207 {
208 pStyle->SetAreaColor(aBackColor);
209 pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 45, 0.09, aForeColor);
210 break;
211 }
212 case FT_CROSSHATCH:
213 {
214 pStyle->SetAreaColor(aBackColor);
215 pStyle->SetAreaLineStyle(enumXFAreaLineCrossed, 0, 0.12, aForeColor);
216 break;
217 }
218 case FT_DIAGCROSSHATCH:
219 {
220 pStyle->SetAreaColor(aBackColor);
221 pStyle->SetAreaLineStyle(enumXFAreaLineCrossed, 45, 0.095, aForeColor);
222 break;
223 }
224 }
225 }
226
227 /**
228 * @descr set line/border style of drawing objects.
229 * @param pStyle pointer of the drawing xfstyle.
230 * @param nWidth width of line/border.
231 * @param nLineStyle flag of line/border style: none, dot or solid.
232 * @param rColor color of line/border.
233 */
234 void LwpDrawObj::SetLineStyle(XFDrawStyle* pStyle, sal_uInt8 nWidth, sal_uInt8 nLineStyle,
235 const SdwColor& rColor)
236 {
237 if (!pStyle)
238 {
239 assert(false);
240 return;
241 }
242 if (nWidth == 0)
243 {
244 nLineStyle = LS_NULL;
245 }
246
247 if (nLineStyle == LS_NULL)
248 {
249 // set stroke:none
250 return;
251 }
252
253 if (nLineStyle == LS_DOT)
254 {
255 pStyle->SetLineDashStyle(enumXFLineDash, 0.05, 0.05, 0.05);
256 }
257
258 // line width
259 double fWidth = (double)nWidth/TWIPS_PER_CM;
260
261 // line color
262 XFColor aXFColor(rColor.nR, rColor.nG, rColor.nB);
263
264 pStyle->SetLineStyle(fWidth, aXFColor);
265 }
266
267 /**
268 * @descr set position of a drawing object in the frame.
269 * @param pObj pointer of the xf-drawing object
270 */
271 void LwpDrawObj::SetPosition(XFFrame* pObj)
272 {
273 double fOffsetX = 0.00, fOffsetY = 0.00;
274 double fScaleX = 1.00, fScaleY = 1.00;
275 if (m_pTransData)
276 {
277 fOffsetX = m_pTransData->fOffsetX;
278 fOffsetY = m_pTransData->fOffsetY;
279 fScaleX = m_pTransData->fScaleX;
280 fScaleY = m_pTransData->fScaleY;
281 }
282
283 pObj->SetPosition((double)m_aObjHeader.nLeft/TWIPS_PER_CM * fScaleX+ fOffsetX,
284 (double)m_aObjHeader.nTop/TWIPS_PER_CM * fScaleY + fOffsetY,
285 (double)(m_aObjHeader.nRight-m_aObjHeader.nLeft)/TWIPS_PER_CM * fScaleX,
286 (double)(m_aObjHeader.nBottom-m_aObjHeader.nTop)/TWIPS_PER_CM * fScaleY);
287 }
288
289 /**
290 * @descr set arrowhead of a xf-drawing object. only opened drawing objects can be assigned arrowheads
291 * @param pOpenedObjStyle the xf-drawing object which will be set arrowhead.
292 * @param nArrowFlag arrowhead flags of the object.
293 */
294 void LwpDrawObj::SetArrowHead(XFDrawStyle* pOpenedObjStyle, sal_uInt8 nArrowFlag, sal_uInt8 nLineWidth)
295 {
296 // no arrowhead
297 if (!nArrowFlag)
298 {
299 return;
300 }
301
302 if (!pOpenedObjStyle)
303 {
304 assert(false);
305 return;
306 }
307
308 // arrowhead flag of an object's start side
309 sal_uInt8 nLeftArrow = nArrowFlag & 0x0F;
310
311 // arrowhead flag of an object's end side
312 sal_uInt8 nRightArrow = (nArrowFlag & 0xF0) >> 4;
313
314 double fWidth_inch = (double)nLineWidth/TWIPS_PER_CM;
315 double fArrowSize_inch = fWidth_inch + 0.08;
316 double fArrowSize = fArrowSize_inch * CM_PER_INCH;
317
318 if (nLeftArrow)
319 {
320 pOpenedObjStyle->SetArrowStart( GetArrowName(nLeftArrow), fArrowSize);
321 }
322 if (nRightArrow)
323 {
324 pOpenedObjStyle->SetArrowEnd( GetArrowName(nRightArrow), fArrowSize);
325 }
326
327 }
328
329 /**
330 * @descr get arrow style name according to the flag.
331 * @param nArrowStyle style of the arrowhead.
332 * @return nWhichSide style name of the arrowhead.
333 */
334 OUString LwpDrawObj::GetArrowName(sal_uInt8 nArrowStyle)
335 {
336 // style name of arrowhead
337 OUString aArrowName;
338
339 switch(nArrowStyle)
340 {
341 default:
342 case AH_ARROW_FULLARROW:
343 aArrowName = "Symmetric arrow";
344 break;
345 case AH_ARROW_HALFARROW:
346 aArrowName = "Arrow concave";
347 break;
348 case AH_ARROW_LINEARROW:
349 aArrowName = "arrow100";
350 break;
351 case AH_ARROW_INVFULLARROW:
352 aArrowName = "reverse arrow";
353 break;
354 case AH_ARROW_INVHALFARROW:
355 aArrowName = "reverse concave arrow";
356 break;
357 case AH_ARROW_INVLINEARROW:
358 aArrowName = "reverse line arrow";
359 break;
360 case AH_ARROW_TEE:
361 aArrowName = "Dimension lines";
362 break;
363 case AH_ARROW_SQUARE:
364 aArrowName = "Square";
365 break;
366 case AH_ARROW_CIRCLE:
367 aArrowName = "Circle";
368 break;
369 }
370
371 return aArrowName;
372 }
373
374 /**
375 * @descr template method of creating drawing object from Lwp-Model to XF-Model
376 * @return pointer of the drawing object of XF-Model.
377 */
378 XFFrame* LwpDrawObj::CreateXFDrawObject()
379 {
380 // read records
381 Read();
382
383 // register style
384 OUString aStyleName = RegisterStyle();
385
386 // create XF-Objects
387 XFFrame* pXFObj = nullptr;
388 if (m_pTransData
389 && FABS(m_pTransData->fOffsetX - m_pTransData->fLeftMargin) < THRESHOLD
390 && FABS(m_pTransData->fOffsetY - m_pTransData->fTopMargin) < THRESHOLD
391 && FABS(m_pTransData->fScaleX - 1.0) < THRESHOLD
392 && FABS(m_pTransData->fScaleY - 1.0) < THRESHOLD)
393 {
394 pXFObj = CreateStandardDrawObj(aStyleName);
395 }
396 else
397 {
398 pXFObj = CreateDrawObj(aStyleName);
399 }
400
401 // set anchor type
402 if (pXFObj)
403 {
404 pXFObj->SetAnchorType(enumXFAnchorFrame);
405 }
406
407 return pXFObj;
408 }
409
410 /**
411 * @descr Constructor of class LwpDrawLine
412 * @param pStream The memory stream which contains the lwp-sdw draw objects
413 */
414 LwpDrawLine::LwpDrawLine(SvStream * pStream, DrawingOffsetAndScale* pTransData)
415 : LwpDrawObj(pStream, pTransData)
416 {
417 }
418
419 /**
420 * @descr reading function of class LwpDrawLine
421 */
422 void LwpDrawLine::Read()
423 {
424 m_pStream->ReadInt16( m_aLineRec.nStartX );
425 m_pStream->ReadInt16( m_aLineRec.nStartY );
426 m_pStream->ReadInt16( m_aLineRec.nEndX );
427 m_pStream->ReadInt16( m_aLineRec.nEndY );
428 m_pStream->ReadUChar( m_aLineRec.nLineWidth );
429 m_pStream->ReadUChar( m_aLineRec.nLineEnd );
430 m_pStream->ReadUChar( m_aLineRec.nLineStyle );
431
432 m_pStream->ReadUChar( m_aLineRec.aPenColor.nR );
433 m_pStream->ReadUChar( m_aLineRec.aPenColor.nG );
434 m_pStream->ReadUChar( m_aLineRec.aPenColor.nB );
435 m_pStream->ReadUChar( m_aLineRec.aPenColor.unused );
436 }
437
438 OUString LwpDrawLine::RegisterStyle()
439 {
440 XFDrawStyle* pStyle = new XFDrawStyle();
441
442 // set line style
443 SetLineStyle(pStyle, m_aLineRec.nLineWidth, m_aLineRec.nLineStyle, m_aLineRec.aPenColor);
444
445 // set arrow head
446 SetArrowHead(pStyle, m_aLineRec.nLineEnd, m_aLineRec.nLineWidth);
447
448 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
449 return (pXFStyleManager->AddStyle(pStyle)).m_pStyle->GetStyleName();
450
451 }
452
453 XFFrame* LwpDrawLine::CreateDrawObj(const OUString& rStyleName )
454 {
455 XFDrawPath* pLine = new XFDrawPath();
456 pLine->MoveTo(XFPoint((double)(m_aLineRec.nStartX)/TWIPS_PER_CM * m_pTransData->fScaleX,
457 (double)(m_aLineRec.nStartY)/TWIPS_PER_CM * m_pTransData->fScaleY));
458 pLine->LineTo(XFPoint((double)(m_aLineRec.nEndX)/TWIPS_PER_CM * m_pTransData->fScaleX,
459 (double)(m_aLineRec.nEndY)/TWIPS_PER_CM * m_pTransData->fScaleY));
460 SetPosition(pLine);
461
462 pLine->SetStyleName(rStyleName);
463
464 return pLine;
465 }
466
467 XFFrame* LwpDrawLine::CreateStandardDrawObj(const OUString& rStyleName)
468 {
469 XFDrawLine* pLine = new XFDrawLine();
470 pLine->SetStartPoint((double)(m_aLineRec.nStartX)/TWIPS_PER_CM,(double)(m_aLineRec.nStartY)/TWIPS_PER_CM);
471 pLine->SetEndPoint((double)(m_aLineRec.nEndX)/TWIPS_PER_CM,(double)(m_aLineRec.nEndY)/TWIPS_PER_CM);
472
473 pLine->SetStyleName(rStyleName);
474 return pLine;
475 }
476
477 /**
478 * @descr Constructor of class LwpDrawPolyLine
479 * @param pStream The memory stream which contains the lwp-sdw draw objects
480 */
481 LwpDrawPolyLine::LwpDrawPolyLine(SvStream * pStream, DrawingOffsetAndScale* pTransData)
482 : LwpDrawObj(pStream, pTransData), m_pVector(nullptr)
483 {
484 }
485 LwpDrawPolyLine::~LwpDrawPolyLine()
486 {
487 if (m_pVector)
488 {
489 delete [] m_pVector;
490 m_pVector = nullptr;
491 }
492 }
493
494 /**
495 * @descr reading function of class LwpDrawPolyLine
496 */
497 void LwpDrawPolyLine::Read()
498 {
499 m_pStream->ReadUChar( m_aPolyLineRec.nLineWidth );
500 m_pStream->ReadUChar( m_aPolyLineRec.nLineEnd );
501 m_pStream->ReadUChar( m_aPolyLineRec.nLineStyle );
502 m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nR );
503 m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nG );
504 m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nB );
505 m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.unused );
506 m_pStream->ReadUInt16( m_aPolyLineRec.nNumPoints );
507
508 if (m_aPolyLineRec.nNumPoints > m_pStream->remainingSize() / 4)
509 throw BadRead();
510
511 m_pVector= new SdwPoint[m_aPolyLineRec.nNumPoints];
512
513 for (sal_uInt16 nC = 0; nC < m_aPolyLineRec.nNumPoints; nC++)
514 {
515 m_pStream->ReadInt16( m_pVector[nC].x );
516 m_pStream->ReadInt16( m_pVector[nC].y );
517 }
518 }
519
520 OUString LwpDrawPolyLine::RegisterStyle()
521 {
522 XFDrawStyle* pStyle = new XFDrawStyle();
523
524 // set line style
525 SetLineStyle(pStyle, m_aPolyLineRec.nLineWidth, m_aPolyLineRec.nLineStyle,
526 m_aPolyLineRec.aPenColor);
527
528 // set arrow head
529 SetArrowHead(pStyle, m_aPolyLineRec.nLineEnd, m_aPolyLineRec.nLineWidth);
530
531 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
532 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
533 }
534
535 XFFrame* LwpDrawPolyLine::CreateDrawObj(const OUString& rStyleName )
536 {
537 XFDrawPath* pPolyline = new XFDrawPath();
538 pPolyline->MoveTo(XFPoint((double)m_pVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
539 (double)m_pVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
540 for (sal_uInt16 nC = 1; nC < m_aPolyLineRec.nNumPoints; nC++)
541 {
542 pPolyline->LineTo(XFPoint((double)m_pVector[nC].x/TWIPS_PER_CM * m_pTransData->fScaleX,
543 (double)m_pVector[nC].y/TWIPS_PER_CM * m_pTransData->fScaleY));
544 }
545 SetPosition(pPolyline);
546
547 pPolyline->SetStyleName(rStyleName);
548
549 return pPolyline;
550 }
551
552 XFFrame* LwpDrawPolyLine::CreateStandardDrawObj(const OUString& rStyleName)
553 {
554 XFDrawPolyline* pPolyline = new XFDrawPolyline();
555 for (sal_uInt16 nC = 0; nC < m_aPolyLineRec.nNumPoints; nC++)
556 {
557 pPolyline->AddPoint((double)m_pVector[nC].x/TWIPS_PER_CM,
558 (double)m_pVector[nC].y/TWIPS_PER_CM);
559 }
560
561 pPolyline->SetStyleName(rStyleName);
562
563 return pPolyline;
564 }
565
566 /**
567 * @descr Constructor of class LwpDrawPolygon
568 * @param pStream The memory stream which contains the lwp-sdw draw objects
569 */
570 LwpDrawPolygon::LwpDrawPolygon(SvStream * pStream, DrawingOffsetAndScale* pTransData)
571 : LwpDrawObj(pStream, pTransData)
572 , m_nNumPoints(0)
573 , m_pVector(nullptr)
574 {
575 }
576
577 LwpDrawPolygon::~LwpDrawPolygon()
578 {
579 if (m_pVector)
580 {
581 delete [] m_pVector;
582 m_pVector = nullptr;
583 }
584 }
585
586 /**
587 * @descr reading function of class LwpDrawPolygon
588 */
589 void LwpDrawPolygon::Read()
590 {
591 ReadClosedObjStyle();
592 m_pStream->ReadUInt16( m_nNumPoints );
593
594 if (m_nNumPoints > m_pStream->remainingSize() / 4)
595 throw BadRead();
596
597 m_pVector = new SdwPoint[m_nNumPoints];
598
599 for (sal_uInt16 nC = 0; nC < m_nNumPoints; nC++)
600 {
601 m_pStream->ReadInt16( m_pVector[nC].x );
602 m_pStream->ReadInt16( m_pVector[nC].y );
603 }
604 }
605
606 OUString LwpDrawPolygon::RegisterStyle()
607 {
608 XFDrawStyle* pStyle = new XFDrawStyle();
609
610 // set line style
611 SetLineStyle(pStyle, m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle,
612 m_aClosedObjStyleRec.aPenColor);
613
614 // set fill style
615 SetFillStyle(pStyle);
616
617 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
618 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
619 }
620
621 XFFrame* LwpDrawPolygon::CreateDrawObj(const OUString& rStyleName)
622 {
623 XFDrawPath* pPolygon = new XFDrawPath();
624 pPolygon->MoveTo(XFPoint((double)m_pVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
625 (double)m_pVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
626 for (sal_uInt16 nC = 1; nC < m_nNumPoints; nC++)
627 {
628 pPolygon->LineTo(XFPoint((double)m_pVector[nC].x/TWIPS_PER_CM * m_pTransData->fScaleX,
629 (double)m_pVector[nC].y/TWIPS_PER_CM * m_pTransData->fScaleY));
630 }
631 pPolygon->ClosePath();
632 SetPosition(pPolygon);
633 pPolygon->SetStyleName(rStyleName);
634
635 return pPolygon;
636 }
637
638 XFFrame* LwpDrawPolygon::CreateStandardDrawObj(const OUString& rStyleName)
639 {
640 XFDrawPolygon* pPolygon = new XFDrawPolygon();
641 for (sal_uInt16 nC = 0; nC < m_nNumPoints; nC++)
642 {
643 pPolygon->AddPoint((double)m_pVector[nC].x/TWIPS_PER_CM,
644 (double)m_pVector[nC].y/TWIPS_PER_CM);
645 }
646
647 pPolygon->SetStyleName(rStyleName);
648
649 return pPolygon;
650 }
651
652 /**
653 * @descr Constructor of class LwpDrawRectangle
654 * @param pStream The memory stream which contains the lwp-sdw draw objects
655 */
656 LwpDrawRectangle::LwpDrawRectangle(SvStream * pStream, DrawingOffsetAndScale* pTransData)
657 : LwpDrawObj(pStream, pTransData)
658 {
659 }
660
661 /**
662 * @descr reading function of class LwpDrawRectangle
663 */
664 void LwpDrawRectangle::Read()
665 {
666 ReadClosedObjStyle();
667
668 sal_uInt8 nPointsCount;
669 if (m_eType == OT_RNDRECT)
670 {
671 nPointsCount = 16;
672 m_pStream->SeekRel(4); // corner points
673 }
674 else
675 {
676 nPointsCount = 4;
677 }
678
679 for (sal_uInt8 nC = 0; nC < nPointsCount; nC++)
680 {
681 m_pStream->ReadInt16( m_aVector[nC].x );
682 m_pStream->ReadInt16( m_aVector[nC].y );
683 }
684 }
685
686 OUString LwpDrawRectangle::RegisterStyle()
687 {
688 XFDrawStyle* pStyle = new XFDrawStyle();
689
690 // set line style
691 SetLineStyle(pStyle, m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle,
692 m_aClosedObjStyleRec.aPenColor);
693
694 // set fill style
695 SetFillStyle(pStyle);
696
697 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
698 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
699 }
700
701 XFFrame* LwpDrawRectangle::CreateDrawObj(const OUString& rStyleName)
702 {
703 if (m_eType == OT_RNDRECT)
704 {
705 return CreateRoundedRect(rStyleName);
706 }
707 else
708 {
709 XFDrawPath* pRect = new XFDrawPath();
710 pRect->MoveTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
711 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
712 for (sal_uInt8 nC = 1; nC < 4; nC++)
713 {
714 pRect->LineTo(XFPoint((double)m_aVector[nC].x/TWIPS_PER_CM * m_pTransData->fScaleX,
715 (double)m_aVector[nC].y/TWIPS_PER_CM * m_pTransData->fScaleY));
716 }
717 pRect->LineTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
718 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
719 pRect->ClosePath();
720 SetPosition(pRect);
721
722 pRect->SetStyleName(rStyleName);
723
724 return pRect;
725 }
726 }
727
728 XFFrame* LwpDrawRectangle::CreateRoundedRect(const OUString& rStyleName)
729 {
730 XFDrawPath* pRoundedRect = new XFDrawPath();
731 pRoundedRect->MoveTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
732 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
733
734 sal_uInt8 nPtIndex = 1;
735 for (sal_uInt8 nC = 0; nC < 7; nC++)
736 {
737 if (nC%2 == 0)
738 {
739 XFPoint aCtrl1((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
740 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
741 nPtIndex++;
742 XFPoint aCtrl2((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
743 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
744 nPtIndex++;
745 XFPoint aDest((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
746 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
747 nPtIndex++;
748
749 pRoundedRect->CurveTo(aDest, aCtrl1, aCtrl2);
750 }
751 else
752 {
753 XFPoint aDest((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
754 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
755 nPtIndex++;
756
757 pRoundedRect->LineTo(aDest);
758 }
759 }
760
761 pRoundedRect->LineTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
762 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
763 pRoundedRect->ClosePath();
764 SetPosition(pRoundedRect);
765
766 pRoundedRect->SetStyleName(rStyleName);
767
768 return pRoundedRect;
769 }
770
771 XFFrame* LwpDrawRectangle::CreateStandardDrawObj(const OUString& rStyleName)
772 {
773 if (m_eType == OT_RNDRECT)
774 {
775 return CreateRoundedRect(rStyleName);
776 }
777 else
778 {
779 XFDrawRect* pRect = new XFDrawRect();
780 double fStartX, fStartY, fWidth, fHeight;
781 double fRotAngle = 0.0;
782 SdwRectangle aSdwRect;
783 Rectangle aOriginalRect;
784 Point aPt0, aPt1, aPt2, aPt3;
785
786 aPt0.setX(m_aVector[0].x); aPt0.setY(m_aVector[0].y);
787 aPt1.setX(m_aVector[1].x); aPt1.setY(m_aVector[1].y);
788 aPt2.setX(m_aVector[2].x); aPt2.setY(m_aVector[2].y);
789 aPt3.setX(m_aVector[3].x); aPt3.setY(m_aVector[3].y);
790
791 aSdwRect = SdwRectangle(aPt0, aPt1, aPt2, aPt3);
792 if (aSdwRect.IsRectRotated())
793 {
794 aOriginalRect = aSdwRect.GetOriginalRect();
795 fRotAngle = aSdwRect.GetRotationAngle();
796 }
797 else
798 {
799 aOriginalRect = Rectangle(aPt0, aPt2);
800 }
801
802 fStartX = aOriginalRect.TopLeft().X();
803 fStartY = aOriginalRect.TopLeft().Y();
804 fWidth = aOriginalRect.GetWidth();
805 fHeight = aOriginalRect.GetHeight();
806
807 pRect->SetStartPoint(XFPoint(fStartX/TWIPS_PER_CM + m_pTransData->fOffsetX,
808 fStartY/TWIPS_PER_CM + m_pTransData->fOffsetY));
809 pRect->SetSize(fWidth/TWIPS_PER_CM, fHeight/TWIPS_PER_CM);
810
811 if (aSdwRect.IsRectRotated())
812 {
813 pRect->SetRotate( fRotAngle / PI * 180);// aXFCenter);
814 }
815
816 pRect->SetStyleName(rStyleName);
817
818 return pRect;
819 }
820 }
821
822 /**
823 * @descr Constructor of class LwpDrawEllipse
824 * @param pStream The memory stream which contains the lwp-sdw draw objects
825 */
826 LwpDrawEllipse::LwpDrawEllipse(SvStream * pStream, DrawingOffsetAndScale* pTransData)
827 : LwpDrawObj(pStream, pTransData)
828 {
829 }
830
831 /**
832 * @descr reading function of class LwpDrawEllipse
833 */
834 void LwpDrawEllipse::Read()
835 {
836 ReadClosedObjStyle();
837
838 for (SdwPoint & nC : m_aVector)
839 {
840 m_pStream->ReadInt16( nC.x );
841 m_pStream->ReadInt16( nC.y );
842 }
843 }
844
845 OUString LwpDrawEllipse::RegisterStyle()
846 {
847 XFDrawStyle* pStyle = new XFDrawStyle();
848
849 // set line style
850 SetLineStyle(pStyle, m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle,
851 m_aClosedObjStyleRec.aPenColor);
852
853 // set fill style
854 SetFillStyle(pStyle);
855
856 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
857 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
858 }
859
860 XFFrame* LwpDrawEllipse::CreateDrawObj(const OUString& rStyleName )
861 {
862 XFDrawPath* pEllipse = new XFDrawPath();
863 pEllipse->MoveTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
864 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
865 sal_uInt8 nPtIndex = 1;
866 for (sal_uInt8 nC = 0; nC < 4; nC++)
867 {
868 XFPoint aCtrl1((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
869 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
870 nPtIndex++;
871 XFPoint aCtrl2((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
872 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
873 nPtIndex++;
874 XFPoint aDest((double)m_aVector[nPtIndex].x/TWIPS_PER_CM * m_pTransData->fScaleX,
875 (double)m_aVector[nPtIndex].y/TWIPS_PER_CM * m_pTransData->fScaleY);
876 nPtIndex++;
877
878 pEllipse->CurveTo(aDest, aCtrl1, aCtrl2);
879 }
880 pEllipse->ClosePath();
881 SetPosition(pEllipse);
882
883 pEllipse->SetStyleName(rStyleName);
884
885 return pEllipse;
886 }
887
888 XFFrame* LwpDrawEllipse::CreateStandardDrawObj(const OUString& rStyleName)
889 {
890 return CreateDrawObj(rStyleName);
891 }
892
893 /**
894 * @descr Constructor of class LwpDrawArc
895 * @param pStream The memory stream which contains the lwp-sdw draw objects
896 */
897 LwpDrawArc::LwpDrawArc(SvStream * pStream, DrawingOffsetAndScale* pTransData)
898 : LwpDrawObj(pStream, pTransData)
899 {
900 }
901
902 /**
903 * @descr reading function of class LwpDrawArc
904 */
905 void LwpDrawArc::Read()
906 {
907 m_pStream->SeekRel(16);// arcRect, startPt, endPt
908
909 m_pStream->ReadUChar( m_aArcRec.nLineWidth );
910 m_pStream->ReadUChar( m_aArcRec.nLineStyle );
911 m_pStream->ReadUChar( m_aArcRec.aPenColor.nR );
912 m_pStream->ReadUChar( m_aArcRec.aPenColor.nG );
913 m_pStream->ReadUChar( m_aArcRec.aPenColor.nB );
914 m_pStream->ReadUChar( m_aArcRec.aPenColor.unused );
915 m_pStream->ReadUChar( m_aArcRec.nLineEnd );
916
917 for (SdwPoint & nC : m_aVector)
918 {
919 m_pStream->ReadInt16( nC.x );
920 m_pStream->ReadInt16( nC.y );
921 }
922 }
923
924 OUString LwpDrawArc::RegisterStyle()
925 {
926 XFDrawStyle* pStyle = new XFDrawStyle();
927
928 // set line style
929 SetLineStyle(pStyle, m_aArcRec.nLineWidth, m_aArcRec.nLineStyle,
930 m_aArcRec.aPenColor);
931
932 // set arrow head
933 SetArrowHead(pStyle, m_aArcRec.nLineEnd, m_aArcRec.nLineWidth);
934
935 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
936 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
937 }
938
939 XFFrame* LwpDrawArc::CreateDrawObj(const OUString& rStyleName )
940 {
941 XFDrawPath* pArc = new XFDrawPath();
942 pArc->MoveTo(XFPoint((double)m_aVector[0].x/TWIPS_PER_CM * m_pTransData->fScaleX,
943 (double)m_aVector[0].y/TWIPS_PER_CM * m_pTransData->fScaleY));
944 XFPoint aDest((double)m_aVector[3].x/TWIPS_PER_CM * m_pTransData->fScaleX,
945 (double)m_aVector[3].y/TWIPS_PER_CM * m_pTransData->fScaleY);
946 XFPoint aCtl1((double)m_aVector[1].x/TWIPS_PER_CM * m_pTransData->fScaleX,
947 (double)m_aVector[1].y/TWIPS_PER_CM * m_pTransData->fScaleY);
948 XFPoint aCtl2((double)m_aVector[2].x/TWIPS_PER_CM* m_pTransData->fScaleX,
949 (double)m_aVector[2].y/TWIPS_PER_CM * m_pTransData->fScaleY);
950 pArc->CurveTo(aDest, aCtl1, aCtl2);
951
952 SetPosition(pArc);
953
954 pArc->SetStyleName(rStyleName);
955
956 return pArc;
957 }
958
959 XFFrame* LwpDrawArc::CreateStandardDrawObj(const OUString& rStyleName)
960 {
961 return CreateDrawObj(rStyleName);
962 }
963
964 /**
965 * @descr Constructor of class LwpDrawTextBox
966 * @param pStream The memory stream which contains the lwp-sdw draw objects
967 */
968 LwpDrawTextBox::LwpDrawTextBox(SvStream* pStream) : LwpDrawObj(pStream)
969 {
970 }
971
972 LwpDrawTextBox::~LwpDrawTextBox()
973 {
974 if (m_aTextRec.pTextString)
975 {
976 delete [] m_aTextRec.pTextString;
977 m_aTextRec.pTextString = nullptr;
978 }
979 }
980
981 void LwpDrawTextBox::SetFontStyle(rtl::Reference<XFFont> const & pFont, SdwTextBoxRecord* pRec)
982 {
983 // color
984 XFColor aXFColor(pRec->aTextColor.nR, pRec->aTextColor.nG,
985 pRec->aTextColor.nB);
986 pFont->SetColor(aXFColor);
987 //size
988 pFont->SetFontSize(pRec->nTextSize/20);
989 // bold
990 pFont->SetBold(((pRec->nTextAttrs & TA_BOLD) != 0));
991 // italic
992 pFont->SetItalic(((pRec->nTextAttrs & TA_ITALIC) != 0));
993 // strike-through
994 if (pRec->nTextAttrs & TA_STRIKETHRU)
995 {
996 pFont->SetCrossout(enumXFCrossoutSignel);
997 }
998 else
999 {
1000 pFont->SetCrossout(enumXFCrossoutNone);
1001 }
1002 // underline
1003 if (pRec->nTextAttrs & TA_UNDERLINE)
1004 {
1005 pFont->SetUnderline(enumXFUnderlineSingle);
1006 }
1007 else if (pRec->nTextAttrs & TA_WORDUNDERLINE)
1008 {
1009 pFont->SetUnderline(enumXFUnderlineSingle, true);
1010 }
1011 else if (pRec->nTextAttrs & TA_DOUBLEUNDER)
1012 {
1013 pFont->SetUnderline(enumXFUnderlineDouble);
1014 }
1015 else
1016 {
1017 pFont->SetUnderline(enumXFUnderlineNone);
1018 }
1019 // small-caps
1020 if (pRec->nTextAttrs & TA_SMALLCAPS)
1021 {
1022 pFont->SetTransform(enumXFTransformSmallCaps);
1023 }
1024 }
1025
1026 /**
1027 * @descr reading function of class LwpDrawTextBox
1028 */
1029 void LwpDrawTextBox::Read()
1030 {
1031 m_pStream->ReadInt16( m_aVector.x );
1032 m_pStream->ReadInt16( m_aVector.y );
1033 m_pStream->ReadInt16( m_aTextRec.nTextWidth );
1034
1035 if (m_aTextRec.nTextWidth == 0)
1036 m_aTextRec.nTextWidth = 1;
1037
1038 m_pStream->ReadInt16( m_aTextRec.nTextHeight );
1039 m_pStream->Read(m_aTextRec.tmpTextFaceName, DRAW_FACESIZE);
1040 m_pStream->SeekRel(1);// PitchAndFamily
1041
1042 m_pStream->ReadInt16( m_aTextRec.nTextSize );
1043
1044 if (m_aTextRec.nTextSize < 0)
1045 m_aTextRec.nTextSize = -m_aTextRec.nTextSize;
1046
1047 //color
1048 m_pStream->ReadUChar( m_aTextRec.aTextColor.nR );
1049 m_pStream->ReadUChar( m_aTextRec.aTextColor.nG );
1050 m_pStream->ReadUChar( m_aTextRec.aTextColor.nB );
1051 m_pStream->ReadUChar( m_aTextRec.aTextColor.unused );
1052
1053 m_pStream->ReadUInt16( m_aTextRec.nTextAttrs );
1054 m_pStream->ReadUInt16( m_aTextRec.nTextCharacterSet );
1055 m_pStream->ReadInt16( m_aTextRec.nTextRotation );
1056 m_pStream->ReadInt16( m_aTextRec.nTextExtraSpacing );
1057
1058 // some draw files in version 1.2 have an extra byte following '\0'.
1059 // can't rely on that, so read in the whole string into memory.
1060
1061 // the 71 is the fixed length before text content in textbox record
1062 sal_Int16 TextLength = m_aObjHeader.nRecLen - 71;
1063 m_aTextRec.pTextString = new sal_uInt8 [TextLength];
1064
1065 m_pStream->Read(m_aTextRec.pTextString, TextLength);
1066 }
1067
1068 OUString LwpDrawTextBox::RegisterStyle()
1069 {
1070 XFParaStyle* pStyle = new XFParaStyle();
1071
1072 // font style
1073 // the pFont need to be deleted myself?
1074 rtl::Reference<XFFont> pFont = new XFFont();
1075
1076 rtl_TextEncoding aEncoding = RTL_TEXTENCODING_MS_1252;
1077 OUString aFontName = OUString(reinterpret_cast<char*>(m_aTextRec.tmpTextFaceName),
1078 strlen(reinterpret_cast<char*>(m_aTextRec.tmpTextFaceName)), aEncoding);
1079 pFont->SetFontName(aFontName);
1080
1081 SetFontStyle(pFont, &m_aTextRec);
1082
1083 pStyle->SetFont(pFont);
1084
1085 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1086 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
1087 }
1088
1089 XFFrame* LwpDrawTextBox::CreateDrawObj(const OUString& rStyleName )
1090 {
1091 XFFrame* pTextBox = new XFFrame(true);
1092
1093 sal_Int16 TextLength = m_aObjHeader.nRecLen - 71;
1094 rtl_TextEncoding aEncoding;
1095 if (!m_aTextRec.nTextCharacterSet)
1096 {
1097 aEncoding = osl_getThreadTextEncoding();
1098 }
1099 else
1100 {
1101 // temporary code, need to create Encoding from the value of nTextCharacterSet
1102 aEncoding = LwpCharSetMgr::GetTextCharEncoding();
1103 }
1104
1105 XFParagraph* pXFPara = new XFParagraph();
1106 pXFPara->Add(OUString(reinterpret_cast<char*>(m_aTextRec.pTextString), (TextLength-2), aEncoding));
1107 pXFPara->SetStyleName(rStyleName);
1108
1109 pTextBox->Add(pXFPara);
1110 SetPosition(pTextBox);
1111
1112 XFTextBoxStyle* pBoxStyle = new XFTextBoxStyle();
1113
1114 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1115 OUString sName = pXFStyleManager->AddStyle(pBoxStyle).m_pStyle->GetStyleName();
1116 pTextBox->SetStyleName(sName);
1117
1118 //todo: add the interface for rotating textbox
1119 // if (m_aTextRec.nTextRotation)
1120 // {
1121 // double fAngle = double(3600-m_aTextRec.nTextRotation)/10;
1122 // pTextBox->SetRotate(fAngle);
1123 // }
1124
1125 return pTextBox;
1126 }
1127
1128 XFFrame* LwpDrawTextBox::CreateStandardDrawObj(const OUString& rStyleName)
1129 {
1130 return CreateDrawObj(rStyleName);
1131 }
1132
1133 /**
1134 * @descr Constructor of class LwpDrawTextBox
1135 * @param pStream The memory stream which contains the lwp-sdw draw objects
1136 */
1137 LwpDrawTextArt::LwpDrawTextArt(SvStream* pStream, DrawingOffsetAndScale* pTransData)
1138 : LwpDrawObj(pStream, pTransData)
1139 {
1140 }
1141
1142 LwpDrawTextArt::~LwpDrawTextArt()
1143 {
1144 if (m_aTextArtRec.aPath[0].pPts)
1145 {
1146 delete [] m_aTextArtRec.aPath[0].pPts;
1147 m_aTextArtRec.aPath[0].pPts = nullptr;
1148 }
1149 if (m_aTextArtRec.aPath[1].pPts)
1150 {
1151 delete [] m_aTextArtRec.aPath[1].pPts;
1152 m_aTextArtRec.aPath[1].pPts = nullptr;
1153 }
1154 if (m_aTextArtRec.pTextString)
1155 {
1156 delete [] m_aTextArtRec.pTextString;
1157 m_aTextArtRec.pTextString = nullptr;
1158 }
1159
1160 }
1161
1162 void LwpDrawTextArt::CreateFWPath(XFDrawPath* pPath)
1163 {
1164 sal_Int16 nX, nY;
1165 nX = (m_aTextArtRec.aPath[0].pPts[0].x + m_aTextArtRec.aPath[1].pPts[0].x) / 2;
1166 nY = (m_aTextArtRec.aPath[0].pPts[0].y + m_aTextArtRec.aPath[1].pPts[0].y) / 2;
1167 XFPoint aStart((double)nX/TWIPS_PER_CM * m_pTransData->fScaleX,
1168 (double)nY/TWIPS_PER_CM * m_pTransData->fScaleY);
1169 pPath->MoveTo(aStart);
1170
1171 sal_uInt8 nPtIndex = 1;
1172 for (sal_uInt16 nC = 1; nC <= m_aTextArtRec.aPath[0].n; nC++)
1173 {
1174 nX = (m_aTextArtRec.aPath[0].pPts[nPtIndex].x + m_aTextArtRec.aPath[1].pPts[nPtIndex].x) / 2;
1175 nY = (m_aTextArtRec.aPath[0].pPts[nPtIndex].y + m_aTextArtRec.aPath[1].pPts[nPtIndex].y) / 2;
1176 XFPoint aCtrl1((double)nX/TWIPS_PER_CM * m_pTransData->fScaleX,
1177 (double)nY/TWIPS_PER_CM * m_pTransData->fScaleY);
1178
1179 nPtIndex++;
1180 nX = (m_aTextArtRec.aPath[0].pPts[nPtIndex].x + m_aTextArtRec.aPath[1].pPts[nPtIndex].x) / 2;
1181 nY = (m_aTextArtRec.aPath[0].pPts[nPtIndex].y + m_aTextArtRec.aPath[1].pPts[nPtIndex].y) / 2;
1182 XFPoint aCtrl2((double)nX/TWIPS_PER_CM * m_pTransData->fScaleX,
1183 (double)nY/TWIPS_PER_CM * m_pTransData->fScaleY);
1184
1185 nPtIndex++;
1186 nX = (m_aTextArtRec.aPath[0].pPts[nPtIndex].x + m_aTextArtRec.aPath[1].pPts[nPtIndex].x) / 2;
1187 nY = (m_aTextArtRec.aPath[0].pPts[nPtIndex].y + m_aTextArtRec.aPath[1].pPts[nPtIndex].y) / 2;
1188 XFPoint aDest((double)nX/TWIPS_PER_CM * m_pTransData->fScaleX,
1189 (double)nY/TWIPS_PER_CM * m_pTransData->fScaleY);
1190
1191 pPath->CurveTo(aDest, aCtrl1, aCtrl2);
1192 }
1193 }
1194
1195 void LwpDrawTextArt::Read()
1196 {
1197 for (SdwPoint & nC : m_aVector)
1198 {
1199 m_pStream->ReadInt16( nC.x );
1200 m_pStream->ReadInt16( nC.y );
1201 }
1202
1203 ReadClosedObjStyle();
1204 m_aTextArtRec.aTextColor = m_aClosedObjStyleRec.aForeColor;
1205
1206 m_pStream->ReadUChar( m_aTextArtRec.nIndex );
1207 m_pStream->ReadInt16( m_aTextArtRec.nRotation );
1208
1209 sal_uInt16 nPointNumber;
1210 sal_Int16 nX, nY;
1211 m_pStream->ReadUInt16( nPointNumber );
1212
1213 size_t nPoints = nPointNumber*3+1;
1214 if (nPoints > m_pStream->remainingSize() / 4)
1215 throw BadRead();
1216
1217 m_aTextArtRec.aPath[0].n = nPointNumber;
1218 m_aTextArtRec.aPath[0].pPts = new SdwPoint[nPoints];
1219 for (size_t nPt = 0; nPt < nPoints; ++nPt)
1220 {
1221 m_pStream->ReadInt16( nX );
1222 m_pStream->ReadInt16( nY );
1223 m_aTextArtRec.aPath[0].pPts[nPt].x = nX;
1224 m_aTextArtRec.aPath[0].pPts[nPt].y = nY;
1225 }
1226
1227 m_pStream->ReadUInt16( nPointNumber );
1228
1229 nPoints = nPointNumber*3+1;
1230 if (nPoints > m_pStream->remainingSize() / 4)
1231 throw BadRead();
1232
1233 m_aTextArtRec.aPath[1].n = nPointNumber;
1234 m_aTextArtRec.aPath[1].pPts = new SdwPoint[nPoints];
1235 for (size_t nPt = 0; nPt < nPoints; ++nPt)
1236 {
1237 m_pStream->ReadInt16( nX );
1238 m_pStream->ReadInt16( nY );
1239 m_aTextArtRec.aPath[1].pPts[nPt].x = nX;
1240 m_aTextArtRec.aPath[1].pPts[nPt].y = nY;
1241 }
1242
1243 m_pStream->SeekRel(1);
1244
1245 m_pStream->Read(m_aTextArtRec.tmpTextFaceName, DRAW_FACESIZE);
1246 m_pStream->SeekRel(1);// PitchAndFamily
1247
1248 m_pStream->ReadInt16( m_aTextArtRec.nTextSize );
1249
1250 if (m_aTextArtRec.nTextSize < 0)
1251 m_aTextArtRec.nTextSize = -m_aTextArtRec.nTextSize;
1252
1253 m_pStream->ReadUInt16( m_aTextArtRec.nTextAttrs );
1254 m_pStream->ReadUInt16( m_aTextArtRec.nTextCharacterSet );
1255 m_aTextArtRec.nTextRotation = 0;
1256 m_pStream->ReadInt16( m_aTextArtRec.nTextExtraSpacing );
1257
1258 const sal_uInt16 nTextArtFixedLength = 105;
1259 m_aTextArtRec.nTextLen = m_aObjHeader.nRecLen - nTextArtFixedLength
1260 - (m_aTextArtRec.aPath[0].n*3 + 1)*4
1261 - (m_aTextArtRec.aPath[1].n*3 + 1)*4;
1262
1263
1264 if (m_aTextArtRec.nTextLen > m_pStream->remainingSize())
1265 throw BadRead();
1266
1267 m_aTextArtRec.pTextString = new sal_uInt8 [m_aTextArtRec.nTextLen];
1268 m_pStream->Read(m_aTextArtRec.pTextString, m_aTextArtRec.nTextLen);
1269 m_aTextArtRec.pTextString[m_aTextArtRec.nTextLen-1] = 0;
1270
1271 }
1272
1273 OUString LwpDrawTextArt::RegisterStyle()
1274 {
1275 XFParaStyle* pStyle = new XFParaStyle();
1276
1277 // font style
1278 // the pFont need to be deleted myself?
1279 rtl::Reference<XFFont> pFont = new XFFont();
1280
1281 rtl_TextEncoding aEncoding = RTL_TEXTENCODING_MS_1252;
1282 OUString aFontName = OUString(reinterpret_cast<char*>(m_aTextArtRec.tmpTextFaceName),
1283 strlen(reinterpret_cast<char*>(m_aTextArtRec.tmpTextFaceName)), aEncoding);
1284 pFont->SetFontName(aFontName);
1285
1286 LwpDrawTextBox::SetFontStyle(pFont, &m_aTextArtRec);
1287
1288 pStyle->SetFont(pFont);
1289
1290 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1291 return pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName();
1292 }
1293
1294 XFFrame* LwpDrawTextArt::CreateDrawObj(const OUString& rStyleName)
1295 {
1296 XFFrame* pRetObj = nullptr;
1297 XFDrawStyle* pStyle = new XFDrawStyle();
1298
1299 pRetObj = new XFDrawPath();
1300 XFDrawPath* pFWPath = static_cast<XFDrawPath*>(pRetObj);
1301 CreateFWPath(pFWPath);
1302 pStyle->SetFontWorkStyle(enumXFFWSlantY, enumXFFWAdjustAutosize);
1303
1304 SetPosition(pRetObj);
1305
1306 rtl_TextEncoding aEncoding;
1307 if (!m_aTextArtRec.nTextCharacterSet)
1308 {
1309 aEncoding = osl_getThreadTextEncoding();
1310 }
1311 else
1312 {
1313 // temporary code, need to create Encoding from the value of nTextCharacterSet
1314 aEncoding = LwpCharSetMgr::GetTextCharEncoding();
1315 }
1316
1317 XFParagraph* pXFPara = new XFParagraph();
1318 pXFPara->Add(OUString(reinterpret_cast<char*>(m_aTextArtRec.pTextString), (m_aTextArtRec.nTextLen-1), aEncoding));
1319 pXFPara->SetStyleName(rStyleName);
1320 pRetObj->Add(pXFPara);
1321
1322 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1323 pRetObj->SetStyleName(pXFStyleManager->AddStyle(pStyle).m_pStyle->GetStyleName());
1324
1325 return pRetObj;
1326 }
1327
1328 XFFrame* LwpDrawTextArt::CreateStandardDrawObj(const OUString& rStyleName )
1329 {
1330 return CreateDrawObj(rStyleName);
1331 }
1332
1333 /**
1334 * @descr Constructor of class LwpDrawMetafile
1335 * @param pStream The memory stream which contains the lwp-sdw draw objects
1336 */
1337 LwpDrawMetafile::LwpDrawMetafile(SvStream* pStream) : LwpDrawObj(pStream)
1338 {
1339 }
1340
1341 /**
1342 * @descr reading function of class LwpDrawMetafile
1343 */
1344 void LwpDrawMetafile::Read()
1345 {
1346 m_pStream->SeekRel(m_aObjHeader.nRecLen -16);
1347 }
1348
1349 /**
1350 * @descr Constructor of class LwpDrawBitmap
1351 * @param pStream The memory stream which contains the lwp-sdw draw objects
1352 */
1353 LwpDrawBitmap::LwpDrawBitmap(SvStream* pStream) : LwpDrawObj(pStream), m_pImageData(nullptr)
1354 {
1355 }
1356
1357 LwpDrawBitmap::~LwpDrawBitmap()
1358 {
1359 if (m_pImageData)
1360 {
1361 delete [] m_pImageData;
1362 m_pImageData = nullptr;
1363 }
1364 }
1365
1366 /**
1367 * @descr reading function of class LwpDrawBitmap
1368 */
1369 void LwpDrawBitmap::Read()
1370 {
1371 m_pStream->ReadUInt16( m_aBmpRec.nTranslation );
1372 m_pStream->ReadUInt16( m_aBmpRec.nRotation );
1373
1374 // 20 == length of draw-specific fields.
1375 // 14 == length of bmp file header.
1376 m_aBmpRec.nFileSize = m_aObjHeader.nRecLen - 20 + 14;
1377 m_pImageData = new sal_uInt8 [m_aBmpRec.nFileSize];
1378
1379 BmpInfoHeader2 aInfoHeader2;
1380 m_pStream->ReadUInt32( aInfoHeader2.nHeaderLen );
1381
1382 sal_uInt32 N;
1383 sal_uInt32 rgbTableSize;
1384
1385 if (aInfoHeader2.nHeaderLen == sizeof(BmpInfoHeader))
1386 {
1387 m_pStream->ReadUInt32( aInfoHeader2.nWidth );
1388 m_pStream->ReadUInt32( aInfoHeader2.nHeight );
1389 m_pStream->ReadUInt16( aInfoHeader2.nPlanes );
1390 m_pStream->ReadUInt16( aInfoHeader2.nBitCount );
1391
1392 N = aInfoHeader2.nPlanes * aInfoHeader2.nBitCount;
1393 if (N == 24)
1394 {
1395 rgbTableSize = 0;
1396 }
1397 else
1398 {
1399 rgbTableSize = 3 * (1 << N);
1400 }
1401 }
1402 else
1403 {
1404 m_pStream->ReadUInt32( aInfoHeader2.nWidth );
1405 m_pStream->ReadUInt32( aInfoHeader2.nHeight );
1406 m_pStream->ReadUInt16( aInfoHeader2.nPlanes );
1407 m_pStream->ReadUInt16( aInfoHeader2.nBitCount );
1408 N = aInfoHeader2.nPlanes * aInfoHeader2.nBitCount;
1409 if (N == 24)
1410 {
1411 rgbTableSize = 0;
1412 }
1413 else
1414 {
1415 rgbTableSize = 4 * (1 << N);
1416 }
1417
1418 }
1419
1420 sal_uInt32 nOffBits = 14 + aInfoHeader2.nHeaderLen + rgbTableSize;
1421 m_pImageData[0] = 'B';
1422 m_pImageData[1] = 'M';
1423 m_pImageData[2] = (sal_uInt8)m_aBmpRec.nFileSize;
1424 m_pImageData[3] = (sal_uInt8)(m_aBmpRec.nFileSize >> 8);
1425 m_pImageData[4] = (sal_uInt8)(m_aBmpRec.nFileSize >> 16);
1426 m_pImageData[5] = (sal_uInt8)(m_aBmpRec.nFileSize >> 24);
1427 m_pImageData[6] = 0;
1428 m_pImageData[7] = 0;
1429 m_pImageData[8] = 0;
1430 m_pImageData[9] = 0;
1431 m_pImageData[10] = (sal_uInt8)nOffBits;
1432 m_pImageData[11] = (sal_uInt8)(nOffBits >> 8);
1433 m_pImageData[12] = (sal_uInt8)(nOffBits >> 16);
1434 m_pImageData[13] = (sal_uInt8)(nOffBits >> 24);
1435
1436 sal_uInt32 nDIBRemaining;
1437 sal_uInt8* pPicData = m_pImageData;
1438 if (aInfoHeader2.nHeaderLen== sizeof(BmpInfoHeader))
1439 {
1440 m_pImageData[14] = (sal_uInt8)aInfoHeader2.nHeaderLen;
1441 m_pImageData[15] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 8);
1442 m_pImageData[16] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 16);
1443 m_pImageData[17] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 24);
1444 m_pImageData[18] = (sal_uInt8)aInfoHeader2.nWidth;
1445 m_pImageData[19] = (sal_uInt8)(aInfoHeader2.nWidth >> 8);
1446 m_pImageData[20] = (sal_uInt8)aInfoHeader2.nHeight;
1447 m_pImageData[21] = (sal_uInt8)(aInfoHeader2.nHeight >> 8);
1448 m_pImageData[22] = (sal_uInt8)aInfoHeader2.nPlanes;
1449 m_pImageData[23] = (sal_uInt8)(aInfoHeader2.nPlanes >> 8);
1450 m_pImageData[24] = (sal_uInt8)aInfoHeader2.nBitCount;
1451 m_pImageData[25] = (sal_uInt8)(aInfoHeader2.nBitCount >> 8);
1452
1453 nDIBRemaining = m_aBmpRec.nFileSize - 26;
1454 pPicData += 26*sizeof(sal_uInt8);
1455 }
1456 else
1457 {
1458 m_pImageData[14] = (sal_uInt8)aInfoHeader2.nHeaderLen;
1459 m_pImageData[15] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 8);
1460 m_pImageData[16] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 16);
1461 m_pImageData[17] = (sal_uInt8)(aInfoHeader2.nHeaderLen >> 24);
1462 m_pImageData[18] = (sal_uInt8)aInfoHeader2.nWidth;
1463 m_pImageData[19] = (sal_uInt8)(aInfoHeader2.nWidth >> 8);
1464 m_pImageData[20] = (sal_uInt8)(aInfoHeader2.nWidth >> 16);
1465 m_pImageData[21] = (sal_uInt8)(aInfoHeader2.nWidth >> 24);
1466 m_pImageData[22] = (sal_uInt8)aInfoHeader2.nHeight;
1467 m_pImageData[23] = (sal_uInt8)(aInfoHeader2.nHeight >> 8);
1468 m_pImageData[24] = (sal_uInt8)(aInfoHeader2.nHeight >> 16);
1469 m_pImageData[25] = (sal_uInt8)(aInfoHeader2.nHeight >> 24);
1470 m_pImageData[26] = (sal_uInt8)aInfoHeader2.nPlanes;
1471 m_pImageData[27] = (sal_uInt8)(aInfoHeader2.nPlanes >> 8);
1472 m_pImageData[28] = (sal_uInt8)aInfoHeader2.nBitCount;
1473 m_pImageData[29] = (sal_uInt8)(aInfoHeader2.nBitCount >> 8);
1474
1475 nDIBRemaining = m_aBmpRec.nFileSize - 30;
1476 pPicData += 30*sizeof(sal_uInt8);
1477 }
1478
1479 m_pStream->Read(pPicData, nDIBRemaining);
1480 }
1481
1482 OUString LwpDrawBitmap::RegisterStyle()
1483 {
1484 XFImageStyle* pBmpStyle = new XFImageStyle();
1485 pBmpStyle->SetYPosType(enumXFFrameYPosFromTop, enumXFFrameYRelFrame);
1486 pBmpStyle->SetXPosType(enumXFFrameXPosFromLeft, enumXFFrameXRelFrame);
1487
1488 XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager();
1489 return pXFStyleManager->AddStyle(pBmpStyle).m_pStyle->GetStyleName();
1490 }
1491
1492 XFFrame* LwpDrawBitmap::CreateDrawObj(const OUString& rStyleName)
1493 {
1494 XFImage* pImage = new XFImage();
1495 pImage->SetImageData(m_pImageData, m_aBmpRec.nFileSize);
1496 SetPosition(pImage);
1497
1498 pImage->SetStyleName(rStyleName);
1499
1500 return pImage;
1501 }
1502
1503 XFFrame* LwpDrawBitmap::CreateStandardDrawObj(const OUString& rStyleName)
1504 {
1505 return CreateDrawObj(rStyleName);
1506 }
1507
1508 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE