sc/source/filter/oox/drawingbase.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <drawingbase.hxx>
  21 #include <addressconverter.hxx>
  22
  23 #include <com/sun/star/awt/Rectangle.hpp>
  24 #include <osl/diagnose.h>
  25 #include <oox/helper/attributelist.hxx>
  26 #include <unitconverter.hxx>
  27 #include <oox/token/namespaces.hxx>
  28 #include <oox/token/tokens.hxx>
  29
  30 namespace oox {
  31 namespace xls {
  32
  33 using namespace ::oox::drawingml;
  34
  35 namespace {
  36
  37 /** Converts the passed 32-bit integer value from 1/100 mm to EMUs. */
  38 sal_Int64 lclHmmToEmu( sal_Int32 nValue )
  39 {
  40     return (nValue < 0) ? -1 : convertHmmToEmu( nValue );
  41 }
  42
  43 /** Converts the passed 64-bit integer value from EMUs to 1/100 mm. */
  44 sal_Int32 lclEmuToHmm( sal_Int64 nValue )
  45 {
  46     return (nValue < 0) ? -1 : convertEmuToHmm( nValue );
  47 }
  48
  49 } // namespace
  50
  51 CellAnchorModel::CellAnchorModel() :
  52     mnCol( -1 ),
  53     mnRow( -1 ),
  54     mnColOffset( 0 ),
  55     mnRowOffset( 0 )
  56 {
  57 }
  58
  59 AnchorClientDataModel::AnchorClientDataModel() :
  60     mbLocksWithSheet( true ),
  61     mbPrintsWithSheet( true )
  62 {
  63 }
  64
  65 ShapeAnchor::ShapeAnchor( const WorksheetHelper& rHelper ) :
  66     WorksheetHelper( rHelper ),
  67     meAnchorType( ANCHOR_INVALID ),
  68     meCellAnchorType( CellAnchorType::Emu ),
  69     meEditAs( ANCHOR_TWOCELL )
  70 {
  71 }
  72
  73 void ShapeAnchor::importAnchor( sal_Int32 nElement, const AttributeList& rAttribs )
  74 {
  75     switch( nElement )
  76     {
  77         case XDR_TOKEN( absoluteAnchor ):
  78             meAnchorType = ANCHOR_ABSOLUTE;
  79         break;
  80         case XDR_TOKEN( oneCellAnchor ):
  81             meAnchorType = ANCHOR_ONECELL;
  82         break;
  83         case XDR_TOKEN( twoCellAnchor ):
  84         {
  85             meAnchorType = ANCHOR_TWOCELL;
  86             OUString sEditAs = rAttribs.getXString( XML_editAs, OUString() );
  87             if ( !sEditAs.isEmpty() )
  88             {
  89                 if ( sEditAs.equalsIgnoreAsciiCase("absolute" ) )
  90                     meEditAs = ANCHOR_ABSOLUTE;
  91                 else if ( sEditAs.equalsIgnoreAsciiCase("oneCell") )
  92                     meEditAs = ANCHOR_ONECELL;
  93                 else if (sEditAs.equalsIgnoreAsciiCase("twoCell") )
  94                     meEditAs = ANCHOR_TWOCELL;
  95             }
  96         }
  97         break;
  98         default:
  99             OSL_ENSURE( false, "ShapeAnchor::importAnchor - unexpected element" );
 100     }
 101     meCellAnchorType = CellAnchorType::Emu;
 102 }
 103
 104 void ShapeAnchor::importPos( const AttributeList& rAttribs )
 105 {
 106     OSL_ENSURE( meAnchorType == ANCHOR_ABSOLUTE, "ShapeAnchor::importPos - unexpected 'xdr:pos' element" );
 107     maPos.X = rAttribs.getHyper( XML_x, 0 );
 108     maPos.Y = rAttribs.getHyper( XML_y, 0 );
 109 }
 110
 111 void ShapeAnchor::importExt( const AttributeList& rAttribs )
 112 {
 113     OSL_ENSURE( (meAnchorType == ANCHOR_ABSOLUTE) || (meAnchorType == ANCHOR_ONECELL), "ShapeAnchor::importExt - unexpected 'xdr:ext' element" );
 114     maSize.Width = rAttribs.getHyper( XML_cx, 0 );
 115     maSize.Height = rAttribs.getHyper( XML_cy, 0 );
 116 }
 117
 118 void ShapeAnchor::importClientData( const AttributeList& rAttribs )
 119 {
 120     maClientData.mbLocksWithSheet  = rAttribs.getBool( XML_fLocksWithSheet, true );
 121     maClientData.mbPrintsWithSheet = rAttribs.getBool( XML_fPrintsWithSheet, true );
 122 }
 123
 124 void ShapeAnchor::setCellPos( sal_Int32 nElement, sal_Int32 nParentContext, const OUString& rValue )
 125 {
 126     CellAnchorModel* pCellAnchor = nullptr;
 127     switch( nParentContext )
 128     {
 129         case XDR_TOKEN( from ):
 130             OSL_ENSURE( (meAnchorType == ANCHOR_ONECELL) || (meAnchorType == ANCHOR_TWOCELL), "ShapeAnchor::setCellPos - unexpected 'xdr:from' element" );
 131             pCellAnchor = &maFrom;
 132         break;
 133         case XDR_TOKEN( to ):
 134             OSL_ENSURE( meAnchorType == ANCHOR_TWOCELL, "ShapeAnchor::setCellPos - unexpected 'xdr:to' element" );
 135             pCellAnchor = &maTo;
 136         break;
 137         default:
 138             OSL_ENSURE( false, "ShapeAnchor::setCellPos - unexpected parent element" );
 139     }
 140     if( pCellAnchor ) switch( nElement )
 141     {
 142         case XDR_TOKEN( col ):      pCellAnchor->mnCol = rValue.toInt32();          break;
 143         case XDR_TOKEN( row ):      pCellAnchor->mnRow = rValue.toInt32();          break;
 144         case XDR_TOKEN( colOff ):   pCellAnchor->mnColOffset = rValue.toInt64();    break;
 145         case XDR_TOKEN( rowOff ):   pCellAnchor->mnRowOffset = rValue.toInt64();    break;
 146         default:    OSL_ENSURE( false, "ShapeAnchor::setCellPos - unexpected element" );
 147     }
 148 }
 149
 150 void ShapeAnchor::importVmlAnchor( const OUString& rAnchor )
 151 {
 152     meAnchorType = ANCHOR_VML;
 153     meCellAnchorType = CellAnchorType::Pixel;
 154
 155     sal_Int32 nValues[8];
 156     sal_Int32 nI{ 0 };
 157
 158     for(sal_Int32 nIndex{ 0 }; nIndex>=0;)
 159     {
 160         nValues[nI] = rAnchor.getToken( 0, ',', nIndex ).toInt32();
 161         if (++nI==8)
 162         {
 163             maFrom.mnCol       = nValues[0];
 164             maFrom.mnColOffset = nValues[1];
 165             maFrom.mnRow       = nValues[2];
 166             maFrom.mnRowOffset = nValues[3];
 167             maTo.mnCol         = nValues[4];
 168             maTo.mnColOffset   = nValues[5];
 169             maTo.mnRow         = nValues[6];
 170             maTo.mnRowOffset   = nValues[7];
 171             return;
 172         }
 173     }
 174
 175     OSL_FAIL("ShapeAnchor::importVmlAnchor - missing anchor tokens" );
 176 }
 177
 178 bool ShapeAnchor::isAnchorValid() const
 179 {
 180     // Checks whether the shape is visible based on the anchor
 181     // if From and To anchor has the same attribute values, the shape will not have width and height
 182     // and thus we can assume that such kind of shape will be not be visible
 183     return !(meAnchorType == ANCHOR_TWOCELL &&
 184         (maTo.mnRow == maFrom.mnRow && maTo.mnCol == maFrom.mnCol) &&
 185         (maTo.mnColOffset == maFrom.mnColOffset && maTo.mnRowOffset == maFrom.mnRowOffset));
 186 }
 187
 188 EmuRectangle ShapeAnchor::calcAnchorRectEmu( const css::awt::Size& rPageSizeHmm ) const
 189 {
 190     AddressConverter& rAddrConv = getAddressConverter();
 191     EmuSize aPageSize( lclHmmToEmu( rPageSizeHmm.Width ), lclHmmToEmu( rPageSizeHmm.Height ) );
 192     EmuRectangle aAnchorRect( -1, -1, -1, -1 );
 193
 194     // calculate shape position
 195     switch( meAnchorType )
 196     {
 197         case ANCHOR_ABSOLUTE:
 198             OSL_ENSURE( maPos.isValid(), "ShapeAnchor::calcAnchorRectEmu - invalid position" );
 199             if( maPos.isValid() && (maPos.X < aPageSize.Width) && (maPos.Y < aPageSize.Height) )
 200                 aAnchorRect.setPos( maPos );
 201         break;
 202         case ANCHOR_ONECELL:
 203         case ANCHOR_TWOCELL:
 204         case ANCHOR_VML:
 205             OSL_ENSURE( maFrom.isValid(), "ShapeAnchor::calcAnchorRectEmu - invalid position" );
 206             if( maFrom.isValid() && rAddrConv.checkCol( maFrom.mnCol, true ) && rAddrConv.checkRow( maFrom.mnRow, true ) )
 207             {
 208                 EmuPoint aPoint = calcCellAnchorEmu( maFrom );
 209                 if( (aPoint.X < aPageSize.Width) && (aPoint.Y < aPageSize.Height) )
 210                     aAnchorRect.setPos( aPoint );
 211             }
 212         break;
 213         case ANCHOR_INVALID:
 214             OSL_ENSURE( false, "ShapeAnchor::calcAnchorRectEmu - invalid anchor" );
 215         break;
 216     }
 217
 218     // calculate shape size
 219     if( (aAnchorRect.X >= 0) && (aAnchorRect.Y >= 0) ) switch( meAnchorType )
 220     {
 221         case ANCHOR_ABSOLUTE:
 222         case ANCHOR_ONECELL:
 223             OSL_ENSURE( maSize.isValid(), "ShapeAnchor::calcAnchorRectEmu - invalid size" );
 224             if( maSize.isValid() )
 225             {
 226                 aAnchorRect.Width = ::std::min< sal_Int64 >( maSize.Width, aPageSize.Width - aAnchorRect.X );
 227                 aAnchorRect.Height = ::std::min< sal_Int64 >( maSize.Height, aPageSize.Height - aAnchorRect.Y );
 228             }
 229         break;
 230         case ANCHOR_TWOCELL:
 231         case ANCHOR_VML:
 232             OSL_ENSURE( maTo.isValid(), "ShapeAnchor::calcAnchorRectEmu - invalid position" );
 233             if( maTo.isValid() )
 234             {
 235                 /*  Pass a valid cell address to calcCellAnchorEmu(), otherwise
 236                     nothing useful is returned, even if either row or column is valid. */
 237                 ScAddress aToCell = rAddrConv.createValidCellAddress( BinAddress( maTo.mnCol, maTo.mnRow ), getSheetIndex(), true );
 238                 CellAnchorModel aValidTo = maTo;
 239                 aValidTo.mnCol = aToCell.Col();
 240                 aValidTo.mnRow = aToCell.Row();
 241                 EmuPoint aPoint = calcCellAnchorEmu( aValidTo );
 242                 // width (if column index is valid, use the calculated offset, otherwise stretch to maximum available X position)
 243                 aAnchorRect.Width = aPageSize.Width - aAnchorRect.X;
 244                 if( aToCell.Col() == maTo.mnCol )
 245                     aAnchorRect.Width = ::std::min< sal_Int64 >( aPoint.X - aAnchorRect.X + 1, aAnchorRect.Width );
 246                 // height (if row index is valid, use the calculated offset, otherwise stretch to maximum available Y position)
 247                 aAnchorRect.Height = aPageSize.Height - aAnchorRect.Y;
 248                 if( aToCell.Row() == maTo.mnRow )
 249                     aAnchorRect.Height = ::std::min< sal_Int64 >( aPoint.Y - aAnchorRect.Y + 1, aAnchorRect.Height );
 250             }
 251         break;
 252         case ANCHOR_INVALID:
 253         break;
 254     }
 255
 256     return aAnchorRect;
 257 }
 258
 259 css::awt::Rectangle ShapeAnchor::calcAnchorRectHmm( const css::awt::Size& rPageSizeHmm ) const
 260 {
 261     EmuRectangle aAnchorRect = calcAnchorRectEmu( rPageSizeHmm );
 262     return css::awt::Rectangle( lclEmuToHmm( aAnchorRect.X ), lclEmuToHmm( aAnchorRect.Y ), lclEmuToHmm( aAnchorRect.Width ), lclEmuToHmm( aAnchorRect.Height ) );
 263 }
 264
 265 EmuPoint ShapeAnchor::calcCellAnchorEmu( const CellAnchorModel& rModel ) const
 266 {
 267     // calculate position of top-left edge of the cell
 268     css::awt::Point aPoint = getCellPosition( rModel.mnCol, rModel.mnRow );
 269     EmuPoint aEmuPoint( lclHmmToEmu( aPoint.X ), lclHmmToEmu( aPoint.Y ) );
 270
 271     // add the offset inside the cell
 272     switch( meCellAnchorType )
 273     {
 274         case CellAnchorType::Emu:
 275             aEmuPoint.X += rModel.mnColOffset;
 276             aEmuPoint.Y += rModel.mnRowOffset;
 277         break;
 278
 279         case CellAnchorType::Pixel:
 280         {
 281             const UnitConverter& rUnitConv = getUnitConverter();
 282             aEmuPoint.X += static_cast< sal_Int64 >( rUnitConv.scaleValue( static_cast< double >( rModel.mnColOffset ), Unit::ScreenX, Unit::Emu ) );
 283             aEmuPoint.Y += static_cast< sal_Int64 >( rUnitConv.scaleValue( static_cast< double >( rModel.mnRowOffset ), Unit::ScreenY, Unit::Emu ) );
 284         }
 285         break;
 286     }
 287
 288     return aEmuPoint;
 289 }
 290
 291 } // namespace xls
 292 } // namespace oox
 293
 294 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */