From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- lotuswordpro/source/filter/lwpdrawobj.cxx | 1488 +++++++++++++++++++++++++++++ 1 file changed, 1488 insertions(+) create mode 100644 lotuswordpro/source/filter/lwpdrawobj.cxx (limited to 'lotuswordpro/source/filter/lwpdrawobj.cxx') diff --git a/lotuswordpro/source/filter/lwpdrawobj.cxx b/lotuswordpro/source/filter/lwpdrawobj.cxx new file mode 100644 index 000000000..5b704c1d5 --- /dev/null +++ b/lotuswordpro/source/filter/lwpdrawobj.cxx @@ -0,0 +1,1488 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/************************************************************************* + * + * The Contents of this file are made available subject to the terms of + * either of the following licenses + * + * - GNU Lesser General Public License Version 2.1 + * - Sun Industry Standards Source License Version 1.1 + * + * Sun Microsystems Inc., October, 2000 + * + * GNU Lesser General Public License Version 2.1 + * ============================================= + * Copyright 2000 by Sun Microsystems, Inc. + * 901 San Antonio Road, Palo Alto, CA 94303, USA + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License version 2.1, as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, + * MA 02111-1307 USA + * + * + * Sun Industry Standards Source License Version 1.1 + * ================================================= + * The contents of this file are subject to the Sun Industry Standards + * Source License Version 1.1 (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.openoffice.org/license.html. + * + * Software provided under this License is provided on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, + * WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS, + * MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING. + * See the License for the specific provisions governing your rights and + * obligations concerning the Software. + * + * The Initial Developer of the Original Code is: IBM Corporation + * + * Copyright: 2008 by IBM Corporation + * + * All Rights Reserved. + * + * Contributor(s): _______________________________________ + * + * + ************************************************************************/ +/** + * @file + * Implementation file of LwpDrawObjects and associated class like LwpDrawGroup, LwpDrawRectangle + * and so on. + */ +#include +#include +#include "lwpdrawobj.hxx" +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include "lwpcharsetmgr.hxx" +#include "lwpsdwrect.hxx" + +/** + * @descr Constructor of class LwpDrawObj + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawObj::LwpDrawObj(SvStream * pStream, DrawingOffsetAndScale* pTransData) + : m_eType(OT_UNDEFINED) + , m_pStream(pStream) + , m_pTransData(pTransData) +{ + ReadObjHeaderRecord(); +} + +/** + * @descr read the header record data of lwp-sdw-object + */ +void LwpDrawObj::ReadObjHeaderRecord() +{ + //flags + m_pStream->SeekRel(1); + + //record Length + m_pStream->ReadUInt16( m_aObjHeader.nRecLen ); + + //boundrect + m_pStream->ReadInt16( m_aObjHeader.nLeft ); + m_pStream->ReadInt16( m_aObjHeader.nTop ); + m_pStream->ReadInt16( m_aObjHeader.nRight ); + m_pStream->ReadInt16( m_aObjHeader.nBottom ); + + //nextObj, prevObj + m_pStream->SeekRel(4); +} + +/** + * @descr read the style of closed lwp-sdw-object like: rectangle, ellipse and so on. + */ +void LwpDrawObj::ReadClosedObjStyle() +{ + if ((m_eType != OT_POLYGON) && (m_eType != OT_TEXTART)) + { + m_pStream->SeekRel(8); + } + + m_pStream->ReadUChar( m_aClosedObjStyleRec.nLineWidth ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.nLineStyle ); + + // pen color + m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nR ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nG ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.nB ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aPenColor.unused ); + + // foreground color + m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nR ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nG ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.nB ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aForeColor.unused ); + + // background color + m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nR ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nG ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.nB ); + m_pStream->ReadUChar( m_aClosedObjStyleRec.aBackColor.unused ); + + // fill style + m_pStream->ReadUInt16( m_aClosedObjStyleRec.nFillType ); + m_pStream->ReadBytes(m_aClosedObjStyleRec.pFillPattern, + sizeof(m_aClosedObjStyleRec.pFillPattern)); +} + +/** + * @descr set fill style of drawing objects + * @param pStyle pointer of the drawing xfstyle. + */ +void LwpDrawObj::SetFillStyle(XFDrawStyle* pStyle) +{ + if (!pStyle) + { + assert(false); + return; + } + + XFColor aForeColor(m_aClosedObjStyleRec.aForeColor.nR, + m_aClosedObjStyleRec.aForeColor.nG, m_aClosedObjStyleRec.aForeColor.nB); + XFColor aBackColor(m_aClosedObjStyleRec.aBackColor.nR, + m_aClosedObjStyleRec.aBackColor.nG, m_aClosedObjStyleRec.aBackColor.nB); + + switch (m_aClosedObjStyleRec.nFillType) + { + default: //fall through! + case FT_TRANSPARENT: + { + // set fill style : none + break; + } + case FT_SOLID: + { + pStyle->SetAreaColor(aForeColor); + break; + } + case FT_HORZHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 0, 0.12, aForeColor); + break; + } + case FT_VERTHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 90, 0.12, aForeColor); + break; + } + case FT_FDIAGHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 135, 0.09, aForeColor); + break; + } + case FT_BDIAGHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineSingle, 45, 0.09, aForeColor); + break; + } + case FT_CROSSHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineCrossed, 0, 0.12, aForeColor); + break; + } + case FT_DIAGCROSSHATCH: + { + pStyle->SetAreaColor(aBackColor); + pStyle->SetAreaLineStyle(enumXFAreaLineCrossed, 45, 0.095, aForeColor); + break; + } + } +} + +/** + * @descr set line/border style of drawing objects. + * @param pStyle pointer of the drawing xfstyle. + * @param nWidth width of line/border. + * @param nLineStyle flag of line/border style: none, dot or solid. + * @param rColor color of line/border. + */ +void LwpDrawObj::SetLineStyle(XFDrawStyle* pStyle, sal_uInt8 nWidth, sal_uInt8 nLineStyle, + const SdwColor& rColor) +{ + if (!pStyle) + { + assert(false); + return; + } + if (nWidth == 0) + { + nLineStyle = LS_NULL; + } + + if (nLineStyle == LS_NULL) + { + // set stroke:none + return; + } + + if (nLineStyle == LS_DOT) + { + pStyle->SetLineDashStyle(enumXFLineDash, 0.05, 0.05, 0.05); + } + + // line width + double fWidth = static_cast(nWidth)/TWIPS_PER_CM; + + // line color + XFColor aXFColor(rColor.nR, rColor.nG, rColor.nB); + + pStyle->SetLineStyle(fWidth, aXFColor); +} + +/** + * @descr set position of a drawing object in the frame. + * @param pObj pointer of the xf-drawing object + */ +void LwpDrawObj::SetPosition(XFFrame* pObj) +{ + double fOffsetX = 0.00, fOffsetY = 0.00; + double fScaleX = 1.00, fScaleY = 1.00; + if (m_pTransData) + { + fOffsetX = m_pTransData->fOffsetX; + fOffsetY = m_pTransData->fOffsetY; + fScaleX = m_pTransData->fScaleX; + fScaleY = m_pTransData->fScaleY; + } + + pObj->SetPosition(static_cast(m_aObjHeader.nLeft)/TWIPS_PER_CM * fScaleX+ fOffsetX, + static_cast(m_aObjHeader.nTop)/TWIPS_PER_CM * fScaleY + fOffsetY, + static_cast(m_aObjHeader.nRight-m_aObjHeader.nLeft)/TWIPS_PER_CM * fScaleX, + static_cast(m_aObjHeader.nBottom-m_aObjHeader.nTop)/TWIPS_PER_CM * fScaleY); +} + +/** + * @descr set arrowhead of a xf-drawing object. only opened drawing objects can be assigned arrowheads + * @param pOpenedObjStyle the xf-drawing object which will be set arrowhead. + * @param nArrowFlag arrowhead flags of the object. + */ +void LwpDrawObj::SetArrowHead(XFDrawStyle* pOpenedObjStyle, sal_uInt8 nArrowFlag, sal_uInt8 nLineWidth) +{ + // no arrowhead + if (!nArrowFlag) + { + return; + } + + if (!pOpenedObjStyle) + { + assert(false); + return; + } + + // arrowhead flag of an object's start side + sal_uInt8 nLeftArrow = nArrowFlag & 0x0F; + + // arrowhead flag of an object's end side + sal_uInt8 nRightArrow = (nArrowFlag & 0xF0) >> 4; + + double fWidth_inch = static_cast(nLineWidth)/TWIPS_PER_CM; + double fArrowSize_inch = fWidth_inch + 0.08; + double fArrowSize = fArrowSize_inch * CM_PER_INCH; + + if (nLeftArrow) + { + pOpenedObjStyle->SetArrowStart( GetArrowName(nLeftArrow), fArrowSize); + } + if (nRightArrow) + { + pOpenedObjStyle->SetArrowEnd( GetArrowName(nRightArrow), fArrowSize); + } + +} + +/** + * @descr get arrow style name according to the flag. + * @param nArrowStyle style of the arrowhead. + * @return nWhichSide style name of the arrowhead. + */ +OUString LwpDrawObj::GetArrowName(sal_uInt8 nArrowStyle) +{ + // style name of arrowhead + OUString aArrowName; + + switch(nArrowStyle) + { + default: + case AH_ARROW_FULLARROW: + aArrowName = "Symmetric arrow"; + break; + case AH_ARROW_HALFARROW: + aArrowName = "Arrow concave"; + break; + case AH_ARROW_LINEARROW: + aArrowName = "arrow100"; + break; + case AH_ARROW_INVFULLARROW: + aArrowName = "reverse arrow"; + break; + case AH_ARROW_INVHALFARROW: + aArrowName = "reverse concave arrow"; + break; + case AH_ARROW_INVLINEARROW: + aArrowName = "reverse line arrow"; + break; + case AH_ARROW_TEE: + aArrowName = "Dimension lines"; + break; + case AH_ARROW_SQUARE: + aArrowName = "Square"; + break; + case AH_ARROW_CIRCLE: + aArrowName = "Circle"; + break; + } + + return aArrowName; +} + +/** + * @descr template method of creating drawing object from Lwp-Model to XF-Model + * @return pointer of the drawing object of XF-Model. + */ +rtl::Reference LwpDrawObj::CreateXFDrawObject() +{ + // read records + Read(); + + // register style + OUString aStyleName = RegisterStyle(); + + // create XF-Objects + rtl::Reference xXFObj; + if (m_pTransData + && FABS(m_pTransData->fOffsetX - m_pTransData->fLeftMargin) < THRESHOLD + && FABS(m_pTransData->fOffsetY - m_pTransData->fTopMargin) < THRESHOLD + && FABS(m_pTransData->fScaleX - 1.0) < THRESHOLD + && FABS(m_pTransData->fScaleY - 1.0) < THRESHOLD) + { + xXFObj = CreateStandardDrawObj(aStyleName); + } + else + { + xXFObj = CreateDrawObj(aStyleName); + } + + // set anchor type + if (xXFObj) + { + xXFObj->SetAnchorType(enumXFAnchorFrame); + } + + return xXFObj; +} + +/** + * @descr Constructor of class LwpDrawLine + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawLine::LwpDrawLine(SvStream * pStream, DrawingOffsetAndScale* pTransData) +: LwpDrawObj(pStream, pTransData) +{ +} + +/** + * @descr reading function of class LwpDrawLine + */ +void LwpDrawLine::Read() +{ + m_pStream->ReadInt16( m_aLineRec.nStartX ); + m_pStream->ReadInt16( m_aLineRec.nStartY ); + m_pStream->ReadInt16( m_aLineRec.nEndX ); + m_pStream->ReadInt16( m_aLineRec.nEndY ); + m_pStream->ReadUChar( m_aLineRec.nLineWidth ); + m_pStream->ReadUChar( m_aLineRec.nLineEnd ); + m_pStream->ReadUChar( m_aLineRec.nLineStyle ); + + m_pStream->ReadUChar( m_aLineRec.aPenColor.nR ); + m_pStream->ReadUChar( m_aLineRec.aPenColor.nG ); + m_pStream->ReadUChar( m_aLineRec.aPenColor.nB ); + m_pStream->ReadUChar( m_aLineRec.aPenColor.unused ); +} + +OUString LwpDrawLine::RegisterStyle() +{ + std::unique_ptr pStyle( new XFDrawStyle() ); + + // set line style + SetLineStyle(pStyle.get(), m_aLineRec.nLineWidth, m_aLineRec.nLineStyle, m_aLineRec.aPenColor); + + // set arrow head + SetArrowHead(pStyle.get(), m_aLineRec.nLineEnd, m_aLineRec.nLineWidth); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawLine::CreateDrawObj(const OUString& rStyleName ) +{ + rtl::Reference xLine(new XFDrawPath()); + xLine->MoveTo(XFPoint(static_cast(m_aLineRec.nStartX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aLineRec.nStartY)/TWIPS_PER_CM * m_pTransData->fScaleY)); + xLine->LineTo(XFPoint(static_cast(m_aLineRec.nEndX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aLineRec.nEndY)/TWIPS_PER_CM * m_pTransData->fScaleY)); + SetPosition(xLine.get()); + + xLine->SetStyleName(rStyleName); + + return xLine; +} + +rtl::Reference LwpDrawLine::CreateStandardDrawObj(const OUString& rStyleName) +{ + rtl::Reference xLine(new XFDrawLine()); + xLine->SetStartPoint(static_cast(m_aLineRec.nStartX)/TWIPS_PER_CM,static_cast(m_aLineRec.nStartY)/TWIPS_PER_CM); + xLine->SetEndPoint(static_cast(m_aLineRec.nEndX)/TWIPS_PER_CM,static_cast(m_aLineRec.nEndY)/TWIPS_PER_CM); + + xLine->SetStyleName(rStyleName); + return xLine; +} + +/** + * @descr Constructor of class LwpDrawPolyLine + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawPolyLine::LwpDrawPolyLine(SvStream * pStream, DrawingOffsetAndScale* pTransData) +: LwpDrawObj(pStream, pTransData) +{ +} +LwpDrawPolyLine::~LwpDrawPolyLine() +{ +} + +/** + * @descr reading function of class LwpDrawPolyLine + */ +void LwpDrawPolyLine::Read() +{ + m_pStream->ReadUChar( m_aPolyLineRec.nLineWidth ); + m_pStream->ReadUChar( m_aPolyLineRec.nLineEnd ); + m_pStream->ReadUChar( m_aPolyLineRec.nLineStyle ); + m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nR ); + m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nG ); + m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.nB ); + m_pStream->ReadUChar( m_aPolyLineRec.aPenColor.unused ); + m_pStream->ReadUInt16( m_aPolyLineRec.nNumPoints ); + + if (!m_pStream->good() || m_aPolyLineRec.nNumPoints > m_pStream->remainingSize() / 4) + throw BadRead(); + + m_pVector.reset( new SdwPoint[m_aPolyLineRec.nNumPoints] ); + + for (sal_uInt16 nC = 0; nC < m_aPolyLineRec.nNumPoints; nC++) + { + m_pStream->ReadInt16( m_pVector[nC].x ); + m_pStream->ReadInt16( m_pVector[nC].y ); + } +} + +OUString LwpDrawPolyLine::RegisterStyle() +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + // set line style + SetLineStyle(pStyle.get(), m_aPolyLineRec.nLineWidth, m_aPolyLineRec.nLineStyle, + m_aPolyLineRec.aPenColor); + + // set arrow head + SetArrowHead(pStyle.get(), m_aPolyLineRec.nLineEnd, m_aPolyLineRec.nLineWidth); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawPolyLine::CreateDrawObj(const OUString& rStyleName ) +{ + rtl::Reference xPolyline(new XFDrawPath()); + xPolyline->MoveTo(XFPoint(static_cast(m_pVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_pVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + for (sal_uInt16 nC = 1; nC < m_aPolyLineRec.nNumPoints; nC++) + { + xPolyline->LineTo(XFPoint(static_cast(m_pVector[nC].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_pVector[nC].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + } + SetPosition(xPolyline.get()); + + xPolyline->SetStyleName(rStyleName); + + return xPolyline; +} + +rtl::Reference LwpDrawPolyLine::CreateStandardDrawObj(const OUString& rStyleName) +{ + rtl::Reference xPolyline(new XFDrawPolyline()); + for (sal_uInt16 nC = 0; nC < m_aPolyLineRec.nNumPoints; nC++) + { + xPolyline->AddPoint(static_cast(m_pVector[nC].x)/TWIPS_PER_CM, + static_cast(m_pVector[nC].y)/TWIPS_PER_CM); + } + + xPolyline->SetStyleName(rStyleName); + + return xPolyline; +} + +/** + * @descr Constructor of class LwpDrawPolygon + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawPolygon::LwpDrawPolygon(SvStream * pStream, DrawingOffsetAndScale* pTransData) + : LwpDrawObj(pStream, pTransData) + , m_nNumPoints(0) +{ +} + +LwpDrawPolygon::~LwpDrawPolygon() +{ +} + +/** + * @descr reading function of class LwpDrawPolygon + */ +void LwpDrawPolygon::Read() +{ + ReadClosedObjStyle(); + m_pStream->ReadUInt16( m_nNumPoints ); + + if (!m_pStream->good() || m_nNumPoints > m_pStream->remainingSize() / 4) + throw BadRead(); + + m_pVector.reset( new SdwPoint[m_nNumPoints] ); + + for (sal_uInt16 nC = 0; nC < m_nNumPoints; nC++) + { + m_pStream->ReadInt16( m_pVector[nC].x ); + m_pStream->ReadInt16( m_pVector[nC].y ); + } +} + +OUString LwpDrawPolygon::RegisterStyle() +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + // set line style + SetLineStyle(pStyle.get(), m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle, + m_aClosedObjStyleRec.aPenColor); + + // set fill style + SetFillStyle(pStyle.get()); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawPolygon::CreateDrawObj(const OUString& rStyleName) +{ + rtl::Reference xPolygon(new XFDrawPath()); + xPolygon->MoveTo(XFPoint(static_cast(m_pVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_pVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + for (sal_uInt16 nC = 1; nC < m_nNumPoints; nC++) + { + xPolygon->LineTo(XFPoint(static_cast(m_pVector[nC].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_pVector[nC].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + } + xPolygon->ClosePath(); + SetPosition(xPolygon.get()); + xPolygon->SetStyleName(rStyleName); + + return xPolygon; +} + +rtl::Reference LwpDrawPolygon::CreateStandardDrawObj(const OUString& rStyleName) +{ + rtl::Reference xPolygon(new XFDrawPolygon()); + for (sal_uInt16 nC = 0; nC < m_nNumPoints; nC++) + { + xPolygon->AddPoint(static_cast(m_pVector[nC].x)/TWIPS_PER_CM, + static_cast(m_pVector[nC].y)/TWIPS_PER_CM); + } + + xPolygon->SetStyleName(rStyleName); + + return xPolygon; +} + +/** + * @descr Constructor of class LwpDrawRectangle + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawRectangle::LwpDrawRectangle(SvStream * pStream, DrawingOffsetAndScale* pTransData) + : LwpDrawObj(pStream, pTransData) +{ +} + +/** + * @descr reading function of class LwpDrawRectangle + */ +void LwpDrawRectangle::Read() +{ + ReadClosedObjStyle(); + + sal_uInt8 nPointsCount; + if (m_eType == OT_RNDRECT) + { + nPointsCount = 16; + m_pStream->SeekRel(4); // corner points + } + else + { + nPointsCount = 4; + } + + for (sal_uInt8 nC = 0; nC < nPointsCount; nC++) + { + m_pStream->ReadInt16( m_aVector[nC].x ); + m_pStream->ReadInt16( m_aVector[nC].y ); + } +} + +OUString LwpDrawRectangle::RegisterStyle() +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + // set line style + SetLineStyle(pStyle.get(), m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle, + m_aClosedObjStyleRec.aPenColor); + + // set fill style + SetFillStyle(pStyle.get()); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawRectangle::CreateDrawObj(const OUString& rStyleName) +{ + if (m_eType == OT_RNDRECT) + { + return CreateRoundedRect(rStyleName); + } + else + { + rtl::Reference xRect(new XFDrawPath()); + xRect->MoveTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + for (sal_uInt8 nC = 1; nC < 4; nC++) + { + xRect->LineTo(XFPoint(static_cast(m_aVector[nC].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nC].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + } + xRect->LineTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + xRect->ClosePath(); + SetPosition(xRect.get()); + + xRect->SetStyleName(rStyleName); + + return xRect; + } +} + +XFFrame* LwpDrawRectangle::CreateRoundedRect(const OUString& rStyleName) +{ + XFDrawPath* pRoundedRect = new XFDrawPath(); + pRoundedRect->MoveTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + + sal_uInt8 nPtIndex = 1; + for (sal_uInt8 nC = 0; nC < 7; nC++) + { + if (nC%2 == 0) + { + XFPoint aCtrl1(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + XFPoint aCtrl2(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + XFPoint aDest(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + + pRoundedRect->CurveTo(aDest, aCtrl1, aCtrl2); + } + else + { + XFPoint aDest(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + + pRoundedRect->LineTo(aDest); + } + } + + pRoundedRect->LineTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + pRoundedRect->ClosePath(); + SetPosition(pRoundedRect); + + pRoundedRect->SetStyleName(rStyleName); + + return pRoundedRect; +} + +rtl::Reference LwpDrawRectangle::CreateStandardDrawObj(const OUString& rStyleName) +{ + if (m_eType == OT_RNDRECT) + { + return CreateRoundedRect(rStyleName); + } + else + { + rtl::Reference xRect(new XFDrawRect()); + double fStartX, fStartY, fWidth, fHeight; + double fRotAngle = 0.0; + SdwRectangle aSdwRect; + tools::Rectangle aOriginalRect; + Point aPt0, aPt1, aPt2, aPt3; + + aPt0.setX(m_aVector[0].x); aPt0.setY(m_aVector[0].y); + aPt1.setX(m_aVector[1].x); aPt1.setY(m_aVector[1].y); + aPt2.setX(m_aVector[2].x); aPt2.setY(m_aVector[2].y); + aPt3.setX(m_aVector[3].x); aPt3.setY(m_aVector[3].y); + + aSdwRect = SdwRectangle(aPt0, aPt1, aPt2, aPt3); + if (aSdwRect.IsRectRotated()) + { + aOriginalRect = aSdwRect.GetOriginalRect(); + fRotAngle = aSdwRect.GetRotationAngle(); + } + else + { + aOriginalRect = tools::Rectangle(aPt0, aPt2); + } + + fStartX = aOriginalRect.Left(); + fStartY = aOriginalRect.Top(); + fWidth = aOriginalRect.GetWidth(); + fHeight = aOriginalRect.GetHeight(); + + xRect->SetStartPoint(XFPoint(fStartX/TWIPS_PER_CM + m_pTransData->fOffsetX, + fStartY/TWIPS_PER_CM + m_pTransData->fOffsetY)); + xRect->SetSize(fWidth/TWIPS_PER_CM, fHeight/TWIPS_PER_CM); + + if (aSdwRect.IsRectRotated()) + { + xRect->SetRotate( basegfx::rad2deg(fRotAngle) );// aXFCenter); + } + + xRect->SetStyleName(rStyleName); + + return xRect; + } +} + +/** + * @descr Constructor of class LwpDrawEllipse + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawEllipse::LwpDrawEllipse(SvStream * pStream, DrawingOffsetAndScale* pTransData) +: LwpDrawObj(pStream, pTransData) +{ +} + +/** + * @descr reading function of class LwpDrawEllipse + */ +void LwpDrawEllipse::Read() +{ + ReadClosedObjStyle(); + + for (SdwPoint & nC : m_aVector) + { + m_pStream->ReadInt16( nC.x ); + m_pStream->ReadInt16( nC.y ); + } +} + +OUString LwpDrawEllipse::RegisterStyle() +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + // set line style + SetLineStyle(pStyle.get(), m_aClosedObjStyleRec.nLineWidth, m_aClosedObjStyleRec.nLineStyle, + m_aClosedObjStyleRec.aPenColor); + + // set fill style + SetFillStyle(pStyle.get()); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawEllipse::CreateDrawObj(const OUString& rStyleName ) +{ + rtl::Reference xEllipse(new XFDrawPath()); + xEllipse->MoveTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + sal_uInt8 nPtIndex = 1; + for (sal_uInt8 nC = 0; nC < 4; nC++) + { + XFPoint aCtrl1(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + XFPoint aCtrl2(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + XFPoint aDest(static_cast(m_aVector[nPtIndex].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[nPtIndex].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + nPtIndex++; + + xEllipse->CurveTo(aDest, aCtrl1, aCtrl2); + } + xEllipse->ClosePath(); + SetPosition(xEllipse.get()); + + xEllipse->SetStyleName(rStyleName); + + return xEllipse; +} + +rtl::Reference LwpDrawEllipse::CreateStandardDrawObj(const OUString& rStyleName) +{ + return CreateDrawObj(rStyleName); +} + +/** + * @descr Constructor of class LwpDrawArc + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawArc::LwpDrawArc(SvStream * pStream, DrawingOffsetAndScale* pTransData) +: LwpDrawObj(pStream, pTransData) +{ +} + +/** + * @descr reading function of class LwpDrawArc + */ +void LwpDrawArc::Read() +{ + m_pStream->SeekRel(16);// arcRect, startPt, endPt + + m_pStream->ReadUChar( m_aArcRec.nLineWidth ); + m_pStream->ReadUChar( m_aArcRec.nLineStyle ); + m_pStream->ReadUChar( m_aArcRec.aPenColor.nR ); + m_pStream->ReadUChar( m_aArcRec.aPenColor.nG ); + m_pStream->ReadUChar( m_aArcRec.aPenColor.nB ); + m_pStream->ReadUChar( m_aArcRec.aPenColor.unused ); + m_pStream->ReadUChar( m_aArcRec.nLineEnd ); + + for (SdwPoint & nC : m_aVector) + { + m_pStream->ReadInt16( nC.x ); + m_pStream->ReadInt16( nC.y ); + } +} + +OUString LwpDrawArc::RegisterStyle() +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + // set line style + SetLineStyle(pStyle.get(), m_aArcRec.nLineWidth, m_aArcRec.nLineStyle, + m_aArcRec.aPenColor); + + // set arrow head + SetArrowHead(pStyle.get(), m_aArcRec.nLineEnd, m_aArcRec.nLineWidth); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawArc::CreateDrawObj(const OUString& rStyleName ) +{ + rtl::Reference xArc(new XFDrawPath()); + xArc->MoveTo(XFPoint(static_cast(m_aVector[0].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[0].y)/TWIPS_PER_CM * m_pTransData->fScaleY)); + XFPoint aDest(static_cast(m_aVector[3].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[3].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + XFPoint aCtl1(static_cast(m_aVector[1].x)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(m_aVector[1].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + XFPoint aCtl2(static_cast(m_aVector[2].x)/TWIPS_PER_CM* m_pTransData->fScaleX, + static_cast(m_aVector[2].y)/TWIPS_PER_CM * m_pTransData->fScaleY); + xArc->CurveTo(aDest, aCtl1, aCtl2); + + SetPosition(xArc.get()); + + xArc->SetStyleName(rStyleName); + + return xArc; +} + +rtl::Reference LwpDrawArc::CreateStandardDrawObj(const OUString& rStyleName) +{ + return CreateDrawObj(rStyleName); +} + +/** + * @descr Constructor of class LwpDrawTextBox + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawTextBox::LwpDrawTextBox(SvStream* pStream) : LwpDrawObj(pStream) +{ +} + +LwpDrawTextBox::~LwpDrawTextBox() +{ + if (m_aTextRec.pTextString) + { + delete [] m_aTextRec.pTextString; + m_aTextRec.pTextString = nullptr; + } +} + +void LwpDrawTextBox::SetFontStyle(rtl::Reference const & pFont, SdwTextBoxRecord const * pRec) +{ + // color + XFColor aXFColor(pRec->aTextColor.nR, pRec->aTextColor.nG, + pRec->aTextColor.nB); + pFont->SetColor(aXFColor); + //size + pFont->SetFontSize(pRec->nTextSize/20); + // bold + pFont->SetBold((pRec->nTextAttrs & TA_BOLD) != 0); + // italic + pFont->SetItalic((pRec->nTextAttrs & TA_ITALIC) != 0); + // strike-through + if (pRec->nTextAttrs & TA_STRIKETHRU) + { + pFont->SetCrossout(enumXFCrossoutSignel); + } + else + { + pFont->SetCrossout(enumXFCrossoutNone); + } + // underline + if (pRec->nTextAttrs & TA_UNDERLINE) + { + pFont->SetUnderline(enumXFUnderlineSingle); + } + else if (pRec->nTextAttrs & TA_WORDUNDERLINE) + { + pFont->SetUnderline(enumXFUnderlineSingle, true); + } + else if (pRec->nTextAttrs & TA_DOUBLEUNDER) + { + pFont->SetUnderline(enumXFUnderlineDouble); + } + else + { + pFont->SetUnderline(enumXFUnderlineNone); + } + // small-caps + if (pRec->nTextAttrs & TA_SMALLCAPS) + { + pFont->SetTransform(enumXFTransformSmallCaps); + } +} + +/** + * @descr reading function of class LwpDrawTextBox + */ +void LwpDrawTextBox::Read() +{ + m_pStream->ReadInt16( m_aVector.x ); + m_pStream->ReadInt16( m_aVector.y ); + m_pStream->ReadInt16( m_aTextRec.nTextWidth ); + + if (m_aTextRec.nTextWidth == 0) + m_aTextRec.nTextWidth = 1; + + m_pStream->ReadInt16( m_aTextRec.nTextHeight ); + m_pStream->ReadBytes(m_aTextRec.tmpTextFaceName, DRAW_FACESIZE); + m_aTextRec.tmpTextFaceName[DRAW_FACESIZE - 1] = 0; + m_pStream->SeekRel(1);// PitchAndFamily + + m_pStream->ReadInt16( m_aTextRec.nTextSize ); + + if (m_aTextRec.nTextSize < 0) + m_aTextRec.nTextSize = -m_aTextRec.nTextSize; + + //color + m_pStream->ReadUChar( m_aTextRec.aTextColor.nR ); + m_pStream->ReadUChar( m_aTextRec.aTextColor.nG ); + m_pStream->ReadUChar( m_aTextRec.aTextColor.nB ); + m_pStream->ReadUChar( m_aTextRec.aTextColor.unused ); + + m_pStream->ReadUInt16( m_aTextRec.nTextAttrs ); + m_pStream->ReadUInt16( m_aTextRec.nTextCharacterSet ); + m_pStream->ReadInt16( m_aTextRec.nTextRotation ); + m_pStream->ReadInt16( m_aTextRec.nTextExtraSpacing ); + + if (!m_pStream->good()) + throw BadRead(); + + // some draw files in version 1.2 have an extra byte following '\0'. + // can't rely on that, so read in the whole string into memory. + + // the 71 is the fixed length before text content in textbox record + sal_Int16 TextLength = m_aObjHeader.nRecLen - 71; + if (TextLength < 0) + throw BadRead(); + m_aTextRec.pTextString = new sal_uInt8[TextLength]; + if (m_pStream->ReadBytes(m_aTextRec.pTextString, TextLength) != o3tl::make_unsigned(TextLength)) + throw BadRead(); +} + +OUString LwpDrawTextBox::RegisterStyle() +{ + std::unique_ptr pStyle(new XFParaStyle()); + + // font style + // the pFont need to be deleted myself? + rtl::Reference pFont = new XFFont(); + + OUString aFontName(reinterpret_cast(m_aTextRec.tmpTextFaceName), + strlen(reinterpret_cast(m_aTextRec.tmpTextFaceName)), RTL_TEXTENCODING_MS_1252); + pFont->SetFontName(aFontName); + + SetFontStyle(pFont, &m_aTextRec); + + pStyle->SetFont(pFont); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawTextBox::CreateDrawObj(const OUString& rStyleName ) +{ + rtl::Reference xTextBox(new XFFrame(true)); + + sal_Int16 TextLength = m_aObjHeader.nRecLen - 71; + rtl_TextEncoding aEncoding; + if (!m_aTextRec.nTextCharacterSet) + { + aEncoding = osl_getThreadTextEncoding(); + } + else + { + // temporary code, need to create Encoding from the value of nTextCharacterSet + aEncoding = LwpCharSetMgr::GetTextCharEncoding(); + } + + if (TextLength < 2) + throw BadRead(); + + XFParagraph* pXFPara = new XFParagraph(); + pXFPara->Add(OUString(reinterpret_cast(m_aTextRec.pTextString), (TextLength-2), aEncoding)); + pXFPara->SetStyleName(rStyleName); + + xTextBox->Add(pXFPara); + SetPosition(xTextBox.get()); + + std::unique_ptr pBoxStyle(new XFTextBoxStyle()); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + OUString sName = pXFStyleManager->AddStyle(std::move(pBoxStyle)).m_pStyle->GetStyleName(); + xTextBox->SetStyleName(sName); + + return xTextBox; +} + +rtl::Reference LwpDrawTextBox::CreateStandardDrawObj(const OUString& rStyleName) +{ + return CreateDrawObj(rStyleName); +} + +/** + * @descr Constructor of class LwpDrawTextBox + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawTextArt::LwpDrawTextArt(SvStream* pStream, DrawingOffsetAndScale* pTransData) +: LwpDrawObj(pStream, pTransData) +{ +} + +LwpDrawTextArt::~LwpDrawTextArt() +{ + m_aTextArtRec.aPath[0].aPts.clear(); + m_aTextArtRec.aPath[1].aPts.clear(); + if (m_aTextArtRec.pTextString) + { + delete [] m_aTextArtRec.pTextString; + m_aTextArtRec.pTextString = nullptr; + } + +} + +void LwpDrawTextArt::CreateFWPath(XFDrawPath* pPath) +{ + sal_Int16 nX, nY; + nX = (m_aTextArtRec.aPath[0].aPts[0].x + m_aTextArtRec.aPath[1].aPts[0].x) / 2; + nY = (m_aTextArtRec.aPath[0].aPts[0].y + m_aTextArtRec.aPath[1].aPts[0].y) / 2; + XFPoint aStart(static_cast(nX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(nY)/TWIPS_PER_CM * m_pTransData->fScaleY); + pPath->MoveTo(aStart); + + sal_uInt8 nPtIndex = 1; + for (sal_uInt16 nC = 1; nC <= m_aTextArtRec.aPath[0].n; nC++) + { + nX = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).x + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).x) / 2; + nY = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).y + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).y) / 2; + XFPoint aCtrl1(static_cast(nX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(nY)/TWIPS_PER_CM * m_pTransData->fScaleY); + + nPtIndex++; + nX = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).x + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).x) / 2; + nY = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).y + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).y) / 2; + XFPoint aCtrl2(static_cast(nX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(nY)/TWIPS_PER_CM * m_pTransData->fScaleY); + + nPtIndex++; + nX = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).x + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).x) / 2; + nY = (m_aTextArtRec.aPath[0].aPts.at(nPtIndex).y + m_aTextArtRec.aPath[1].aPts.at(nPtIndex).y) / 2; + XFPoint aDest(static_cast(nX)/TWIPS_PER_CM * m_pTransData->fScaleX, + static_cast(nY)/TWIPS_PER_CM * m_pTransData->fScaleY); + + pPath->CurveTo(aDest, aCtrl1, aCtrl2); + } +} + +void LwpDrawTextArt::Read() +{ + for (SdwPoint & nC : m_aVector) + { + m_pStream->ReadInt16( nC.x ); + m_pStream->ReadInt16( nC.y ); + } + + ReadClosedObjStyle(); + m_aTextArtRec.aTextColor = m_aClosedObjStyleRec.aForeColor; + + m_pStream->ReadUChar( m_aTextArtRec.nIndex ); + m_pStream->ReadInt16( m_aTextArtRec.nRotation ); + + sal_uInt16 nPointNumber; + m_pStream->ReadUInt16( nPointNumber ); + + size_t nPoints = nPointNumber*3+1; + if (!m_pStream->good() || nPoints > m_pStream->remainingSize() / 4) + throw BadRead(); + + m_aTextArtRec.aPath[0].n = nPointNumber; + m_aTextArtRec.aPath[0].aPts.resize(nPoints); + for (size_t nPt = 0; nPt < nPoints; ++nPt) + { + sal_Int16 nX, nY; + m_pStream->ReadInt16( nX ); + m_pStream->ReadInt16( nY ); + m_aTextArtRec.aPath[0].aPts[nPt].x = nX; + m_aTextArtRec.aPath[0].aPts[nPt].y = nY; + } + + m_pStream->ReadUInt16( nPointNumber ); + + nPoints = nPointNumber*3+1; + if (!m_pStream->good() || nPoints > m_pStream->remainingSize() / 4) + throw BadRead(); + + m_aTextArtRec.aPath[1].n = nPointNumber; + m_aTextArtRec.aPath[1].aPts.resize(nPoints); + for (size_t nPt = 0; nPt < nPoints; ++nPt) + { + sal_Int16 nX, nY; + m_pStream->ReadInt16( nX ); + m_pStream->ReadInt16( nY ); + m_aTextArtRec.aPath[1].aPts[nPt].x = nX; + m_aTextArtRec.aPath[1].aPts[nPt].y = nY; + } + + m_pStream->SeekRel(1); + + m_pStream->ReadBytes(m_aTextArtRec.tmpTextFaceName, DRAW_FACESIZE); + m_aTextArtRec.tmpTextFaceName[DRAW_FACESIZE - 1] = 0; + m_pStream->SeekRel(1);// PitchAndFamily + + m_pStream->ReadInt16( m_aTextArtRec.nTextSize ); + + if (m_aTextArtRec.nTextSize < 0) + m_aTextArtRec.nTextSize = -m_aTextArtRec.nTextSize; + + m_pStream->ReadUInt16( m_aTextArtRec.nTextAttrs ); + m_pStream->ReadUInt16( m_aTextArtRec.nTextCharacterSet ); + m_aTextArtRec.nTextRotation = 0; + m_pStream->ReadInt16( m_aTextArtRec.nTextExtraSpacing ); + + const sal_uInt16 nTextArtFixedLength = 105; + m_aTextArtRec.nTextLen = m_aObjHeader.nRecLen - nTextArtFixedLength + - (m_aTextArtRec.aPath[0].n*3 + 1)*4 + - (m_aTextArtRec.aPath[1].n*3 + 1)*4; + + + if (!m_pStream->good()) + throw BadRead(); + if (m_aTextArtRec.nTextLen > m_pStream->remainingSize()) + throw BadRead(); + if (m_aTextArtRec.nTextLen < 1) + throw BadRead(); + + m_aTextArtRec.pTextString = new sal_uInt8 [m_aTextArtRec.nTextLen]; + m_pStream->ReadBytes(m_aTextArtRec.pTextString, m_aTextArtRec.nTextLen); + m_aTextArtRec.pTextString[m_aTextArtRec.nTextLen-1] = 0; + +} + +OUString LwpDrawTextArt::RegisterStyle() +{ + std::unique_ptr pStyle(new XFParaStyle()); + + // font style + // the pFont need to be deleted myself? + rtl::Reference pFont = new XFFont(); + + OUString aFontName(reinterpret_cast(m_aTextArtRec.tmpTextFaceName), + strlen(reinterpret_cast(m_aTextArtRec.tmpTextFaceName)), RTL_TEXTENCODING_MS_1252); + pFont->SetFontName(aFontName); + + LwpDrawTextBox::SetFontStyle(pFont, &m_aTextArtRec); + + pStyle->SetFont(pFont); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawTextArt::CreateDrawObj(const OUString& rStyleName) +{ + std::unique_ptr pStyle(new XFDrawStyle()); + + rtl::Reference xRetObj(new XFDrawPath()); + XFDrawPath* pFWPath = static_cast(xRetObj.get()); + CreateFWPath(pFWPath); + pStyle->SetFontWorkStyle(enumXFFWSlantY, enumXFFWAdjustAutosize); + + SetPosition(xRetObj.get()); + + rtl_TextEncoding aEncoding; + if (!m_aTextArtRec.nTextCharacterSet) + { + aEncoding = osl_getThreadTextEncoding(); + } + else + { + // temporary code, need to create Encoding from the value of nTextCharacterSet + aEncoding = LwpCharSetMgr::GetTextCharEncoding(); + } + + XFParagraph* pXFPara = new XFParagraph(); + pXFPara->Add(OUString(reinterpret_cast(m_aTextArtRec.pTextString), (m_aTextArtRec.nTextLen-1), aEncoding)); + pXFPara->SetStyleName(rStyleName); + xRetObj->Add(pXFPara); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + xRetObj->SetStyleName(pXFStyleManager->AddStyle(std::move(pStyle)).m_pStyle->GetStyleName()); + + return xRetObj; +} + +rtl::Reference LwpDrawTextArt::CreateStandardDrawObj(const OUString& rStyleName ) +{ + return CreateDrawObj(rStyleName); +} + +/** + * @descr Constructor of class LwpDrawMetafile + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawMetafile::LwpDrawMetafile(SvStream* pStream) : LwpDrawObj(pStream) +{ +} + +/** + * @descr reading function of class LwpDrawMetafile + */ +void LwpDrawMetafile::Read() +{ + m_pStream->SeekRel(m_aObjHeader.nRecLen -16); +} + +/** + * @descr Constructor of class LwpDrawBitmap + * @param pStream The memory stream which contains the lwp-sdw draw objects + */ +LwpDrawBitmap::LwpDrawBitmap(SvStream* pStream) : LwpDrawObj(pStream) +{ +} + +LwpDrawBitmap::~LwpDrawBitmap() +{ +} + +static bool IsValid(const BmpInfoHeader2& rHeader) +{ + if (rHeader.nPlanes != 1) + return false; + + if (rHeader.nBitCount != 0 && rHeader.nBitCount != 1 && + rHeader.nBitCount != 4 && rHeader.nBitCount != 8 && + rHeader.nBitCount != 16 && rHeader.nBitCount != 24 && + rHeader.nBitCount != 32) + { + return false; + } + + return true; +} + +/** + * @descr reading function of class LwpDrawBitmap + */ +void LwpDrawBitmap::Read() +{ + m_pStream->ReadUInt16( m_aBmpRec.nTranslation ); + m_pStream->ReadUInt16( m_aBmpRec.nRotation ); + + // 20 == length of draw-specific fields. + if (m_aObjHeader.nRecLen < 20) + throw BadRead(); + + sal_uInt64 nBmpPos = m_pStream->Tell(); + sal_uInt64 nBmpLen = + std::min(m_aObjHeader.nRecLen - 20, m_pStream->remainingSize()); + + BmpInfoHeader2 aInfoHeader2; + m_pStream->ReadUInt32( aInfoHeader2.nHeaderLen ); + + if (!m_pStream->good() || nBmpLen < aInfoHeader2.nHeaderLen) + throw BadRead(); + + sal_uInt32 N; + sal_uInt32 rgbTableSize; + + if (aInfoHeader2.nHeaderLen == sizeof(BmpInfoHeader)) + { + sal_uInt16 nTmp; + + m_pStream->ReadUInt16( nTmp ); + aInfoHeader2.nWidth = nTmp; + m_pStream->ReadUInt16( nTmp ); + aInfoHeader2.nHeight = nTmp; + m_pStream->ReadUInt16( aInfoHeader2.nPlanes ); + m_pStream->ReadUInt16( aInfoHeader2.nBitCount ); + + if (!m_pStream->good() || !IsValid(aInfoHeader2)) + throw BadRead(); + + N = aInfoHeader2.nPlanes * aInfoHeader2.nBitCount; + if (N >= 16) + { + rgbTableSize = 0; + } + else + { + rgbTableSize = 3 * (1 << N); + } + } + else if (aInfoHeader2.nHeaderLen >= sizeof(BmpInfoHeader2)) + { + m_pStream->ReadUInt32( aInfoHeader2.nWidth ); + m_pStream->ReadUInt32( aInfoHeader2.nHeight ); + m_pStream->ReadUInt16( aInfoHeader2.nPlanes ); + m_pStream->ReadUInt16( aInfoHeader2.nBitCount ); + + if (!m_pStream->good() || !IsValid(aInfoHeader2)) + throw BadRead(); + + N = aInfoHeader2.nPlanes * aInfoHeader2.nBitCount; + if (N >= 16) + { + rgbTableSize = 0; + } + else + { + rgbTableSize = 4 * (1 << N); + } + } + else + { + throw BadRead(); + } + + m_aBmpRec.nFileSize = static_cast(nBmpLen + 14); + m_pImageData.reset( new sal_uInt8 [m_aBmpRec.nFileSize] ); + + sal_uInt32 nOffBits = 14 + aInfoHeader2.nHeaderLen + rgbTableSize; + m_pImageData[0] = 'B'; + m_pImageData[1] = 'M'; + m_pImageData[2] = static_cast(m_aBmpRec.nFileSize); + m_pImageData[3] = static_cast(m_aBmpRec.nFileSize >> 8); + m_pImageData[4] = static_cast(m_aBmpRec.nFileSize >> 16); + m_pImageData[5] = static_cast(m_aBmpRec.nFileSize >> 24); + m_pImageData[6] = 0; + m_pImageData[7] = 0; + m_pImageData[8] = 0; + m_pImageData[9] = 0; + m_pImageData[10] = static_cast(nOffBits); + m_pImageData[11] = static_cast(nOffBits >> 8); + m_pImageData[12] = static_cast(nOffBits >> 16); + m_pImageData[13] = static_cast(nOffBits >> 24); + + sal_uInt8* pPicData = m_pImageData.get(); + + m_pStream->Seek(nBmpPos); + if (nBmpLen != m_pStream->ReadBytes(pPicData + 14, nBmpLen)) + throw BadRead(); +} + +OUString LwpDrawBitmap::RegisterStyle() +{ + std::unique_ptr pBmpStyle(new XFImageStyle()); + pBmpStyle->SetYPosType(enumXFFrameYPosFromTop, enumXFFrameYRelFrame); + pBmpStyle->SetXPosType(enumXFFrameXPosFromLeft, enumXFFrameXRelFrame); + + XFStyleManager* pXFStyleManager = LwpGlobalMgr::GetInstance()->GetXFStyleManager(); + return pXFStyleManager->AddStyle(std::move(pBmpStyle)).m_pStyle->GetStyleName(); +} + +rtl::Reference LwpDrawBitmap::CreateDrawObj(const OUString& rStyleName) +{ + rtl::Reference xImage(new XFImage()); + xImage->SetImageData(m_pImageData.get(), m_aBmpRec.nFileSize); + SetPosition(xImage.get()); + + xImage->SetStyleName(rStyleName); + + return xImage; +} + +rtl::Reference LwpDrawBitmap::CreateStandardDrawObj(const OUString& rStyleName) +{ + return CreateDrawObj(rStyleName); +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ -- cgit v1.2.3