chart2/source/view/main/DummyXShape.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 #include "DummyXShape.hxx"
  10
  11 #include <string>
  12 #include <vector>
  13 #include <iostream>
  14 #include <fstream>
  15 #include <algorithm>
  16 #include <stdlib.h>
  17 #include <string.h>
  18
  19 #include "CommonConverters.hxx"
  20
  21 #include <rtl/ustring.hxx>
  22
  23 #include <vcl/window.hxx>
  24 #include <vcl/virdev.hxx>
  25 #include <vcl/svapp.hxx>
  26 #include <tools/gen.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <cppuhelper/implbase1.hxx>
  29 #include <editeng/unoprnms.hxx>
  30 #include <toolkit/helper/vclunohelper.hxx>
  31
  32 #include <basegfx/point/b2dpoint.hxx>
  33 #include <basegfx/matrix/b3dhommatrix.hxx>
  34
  35 #include <com/sun/star/beans/Property.hpp>
  36
  37 #include <com/sun/star/awt/XBitmap.hpp>
  38
  39 #define ENABLE_DEBUG_PROPERTIES 0
  40
  41 using namespace com::sun::star;
  42
  43 using namespace std;
  44
  45 namespace chart {
  46
  47 namespace dummy {
  48
  49 #if 0
  50
  51 std::ostream& operator<<(std::ostream& rStrm, const awt::Point& rPoint)
  52 {
  53     rStrm << rPoint.X << "," << rPoint.Y;
  54     return rStrm;
  55 }
  56
  57 std::ostream& operator<<(std::ostream& rStrm, const awt::Size& rSize)
  58 {
  59     rStrm << rSize.Width << "," << rSize.Height;
  60     return rStrm;
  61 }
  62
  63 #endif
  64
  65 bool TextCache::hasEntry(const TextCacheKey& rKey)
  66 {
  67     return maCache.find(rKey) != maCache.end();
  68 }
  69
  70 BitmapEx& TextCache::getBitmap(const TextCacheKey& rKey)
  71 {
  72     return maCache.find(rKey)->second;
  73 }
  74
  75 void TextCache::insertBitmap(const TextCacheKey& rKey, const BitmapEx& rBitmap)
  76 {
  77     maCache.insert(std::pair<TextCacheKey, BitmapEx>(rKey, rBitmap));
  78 }
  79
  80 class DummyPropertySetInfo : public cppu::WeakImplHelper1<
  81                                 com::sun::star::beans::XPropertySetInfo >
  82 {
  83 public:
  84     DummyPropertySetInfo(const std::map<OUString, uno::Any>& rProps ):
  85         mrProperties(rProps) {}
  86
  87     virtual sal_Bool SAL_CALL hasPropertyByName( const OUString& rName )
  88         throw(uno::RuntimeException, std::exception) SAL_OVERRIDE;
  89
  90     virtual beans::Property SAL_CALL getPropertyByName( const OUString& rName )
  91         throw(uno::RuntimeException, beans::UnknownPropertyException, std::exception) SAL_OVERRIDE;
  92
  93     virtual uno::Sequence< beans::Property > SAL_CALL getProperties()
  94         throw(uno::RuntimeException, std::exception) SAL_OVERRIDE;
  95
  96 private:
  97     const std::map<OUString, uno::Any>& mrProperties;
  98 };
  99
 100 sal_Bool SAL_CALL DummyPropertySetInfo::hasPropertyByName( const OUString& rName )
 101     throw(uno::RuntimeException, std::exception)
 102 {
 103     return mrProperties.find(rName) != mrProperties.end();
 104 }
 105
 106 beans::Property SAL_CALL DummyPropertySetInfo::getPropertyByName( const OUString& rName )
 107     throw(uno::RuntimeException, beans::UnknownPropertyException, std::exception)
 108 {
 109     beans::Property aRet;
 110     if(mrProperties.find(rName) == mrProperties.end())
 111         throw beans::UnknownPropertyException();
 112
 113     std::map<OUString, uno::Any>::const_iterator itr = mrProperties.find(rName);
 114     aRet.Name = rName;
 115     aRet.Type = itr->second.getValueType();
 116
 117     return aRet;
 118 }
 119
 120 uno::Sequence< beans::Property > SAL_CALL DummyPropertySetInfo::getProperties()
 121     throw(uno::RuntimeException, std::exception)
 122 {
 123     uno::Sequence< beans::Property > aRet(mrProperties.size());
 124
 125     size_t i = 0;
 126     for(std::map<OUString, uno::Any>::const_iterator itr = mrProperties.begin(),
 127             itrEnd = mrProperties.end(); itr != itrEnd; ++itr, ++i)
 128     {
 129         beans::Property aProp;
 130
 131         aProp.Name = itr->first;
 132         aProp.Type = itr->second.getValueType();
 133         aRet[i] = aProp;
 134     }
 135     return aRet;
 136 }
 137
 138 namespace {
 139
 140 struct PrintProperties
 141 {
 142 #if ENABLE_DEBUG_PROPERTIES
 143     void operator()(const std::pair<OUString, uno::Any>& rProp)
 144     {
 145         SAL_INFO("chart2.opengl.properties", "Property: " << rProp.first);
 146     }
 147 #else
 148     void operator()(const std::pair<OUString, uno::Any>&)
 149     {
 150     }
 151 #endif
 152 };
 153
 154 void debugProperties(std::map<OUString, uno::Any>& rProperties)
 155 {
 156     for_each(rProperties.begin(), rProperties.end(), PrintProperties());
 157 }
 158
 159 }
 160
 161 DummyXShape::DummyXShape()
 162 {
 163 }
 164
 165 OUString SAL_CALL DummyXShape::getName()
 166     throw(uno::RuntimeException, std::exception)
 167 {
 168     return maName;
 169 }
 170
 171 void SAL_CALL DummyXShape::setName( const OUString& rName )
 172     throw(uno::RuntimeException, std::exception)
 173 {
 174     maName = rName;
 175 }
 176
 177 awt::Point SAL_CALL DummyXShape::getPosition()
 178     throw(uno::RuntimeException, std::exception)
 179 {
 180     return maPosition;
 181 }
 182
 183 void SAL_CALL DummyXShape::setPosition( const awt::Point& rPoint )
 184     throw(uno::RuntimeException, std::exception)
 185 {
 186     maPosition = rPoint;
 187 }
 188
 189 awt::Size SAL_CALL DummyXShape::getSize()
 190     throw(uno::RuntimeException, std::exception)
 191 {
 192     return maSize;
 193 }
 194
 195 void SAL_CALL DummyXShape::setSize( const awt::Size& rSize )
 196     throw(beans::PropertyVetoException, uno::RuntimeException, std::exception)
 197 {
 198     maSize = rSize;
 199 }
 200
 201 OUString SAL_CALL DummyXShape::getShapeType()
 202     throw(uno::RuntimeException, std::exception)
 203 {
 204     return OUString("dummy shape");
 205 }
 206
 207 uno::Reference< beans::XPropertySetInfo > SAL_CALL DummyXShape::getPropertySetInfo()
 208     throw(uno::RuntimeException, std::exception)
 209 {
 210     return new DummyPropertySetInfo(maProperties);
 211 }
 212
 213 void SAL_CALL DummyXShape::setPropertyValue( const OUString& rName, const uno::Any& rValue)
 214     throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 215             lang::IllegalArgumentException, lang::WrappedTargetException,
 216             uno::RuntimeException, std::exception)
 217 {
 218     SAL_INFO("chart2", "DummyXShape::setProperty: " << rName << " Any");
 219     maProperties[rName] = rValue;
 220     if(rName == "Transformation")
 221     {
 222         SAL_INFO("chart2.opengl", "Transformation");
 223     }
 224 }
 225
 226 uno::Any SAL_CALL DummyXShape::getPropertyValue( const OUString& rName )
 227     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 228 {
 229     SAL_INFO("chart2.opengl", "DummyXShape::getPropertyValue: " << rName);
 230     std::map<OUString, uno::Any>::iterator itr = maProperties.find(rName);
 231     if(itr != maProperties.end())
 232         return itr->second;
 233
 234     return uno::Any();
 235 }
 236
 237 void SAL_CALL DummyXShape::addPropertyChangeListener( const OUString&, const uno::Reference< beans::XPropertyChangeListener >& )
 238     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 239 {
 240 }
 241
 242 void SAL_CALL DummyXShape::removePropertyChangeListener( const OUString&, const uno::Reference< beans::XPropertyChangeListener >& )
 243     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 244 {
 245 }
 246
 247 void SAL_CALL DummyXShape::addVetoableChangeListener( const OUString&, const uno::Reference< beans::XVetoableChangeListener >& )
 248     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 249 {
 250 }
 251
 252 void SAL_CALL DummyXShape::removeVetoableChangeListener( const OUString&, const uno::Reference< beans::XVetoableChangeListener >& )
 253     throw(beans::UnknownPropertyException, lang::WrappedTargetException, uno::RuntimeException, std::exception)
 254 {
 255 }
 256
 257 void SAL_CALL DummyXShape::setPropertyValues( const uno::Sequence< OUString >& rNames,
 258         const uno::Sequence< uno::Any >& rValues)
 259 throw (beans::PropertyVetoException, lang::IllegalArgumentException,
 260         lang::WrappedTargetException, uno::RuntimeException, std::exception)
 261 {
 262     size_t n = std::min<size_t>(rNames.getLength(), rValues.getLength());
 263     for(size_t i = 0; i < n; ++i)
 264     {
 265         maProperties[rNames[i]] = rValues[i];
 266     }
 267 }
 268
 269 uno::Sequence< uno::Any > SAL_CALL DummyXShape::getPropertyValues(
 270         const uno::Sequence< OUString >& rNames)
 271     throw (uno::RuntimeException, std::exception)
 272 {
 273     uno::Sequence< uno::Any > aValues(rNames.getLength());
 274     for(sal_Int32 i = 0; i < rNames.getLength(); ++i)
 275     {
 276         OUString aName = rNames[i];
 277
 278         std::map<OUString, uno::Any>::iterator itr = maProperties.find(aName);
 279         if(itr != maProperties.end())
 280             aValues[i] = itr->second;
 281     }
 282     return aValues;
 283 }
 284
 285 void SAL_CALL DummyXShape::addPropertiesChangeListener( const uno::Sequence< OUString >& , const uno::Reference< beans::XPropertiesChangeListener >& ) throw (uno::RuntimeException, std::exception)
 286 {
 287 }
 288
 289 void SAL_CALL DummyXShape::removePropertiesChangeListener( const uno::Reference< beans::XPropertiesChangeListener >& ) throw (uno::RuntimeException, std::exception)
 290 {
 291 }
 292
 293 void SAL_CALL DummyXShape::firePropertiesChangeEvent( const uno::Sequence< OUString >& ,
 294         const uno::Reference< beans::XPropertiesChangeListener >& )
 295     throw (uno::RuntimeException, std::exception)
 296 {
 297 }
 298
 299 OUString SAL_CALL DummyXShape::getImplementationName()
 300     throw(uno::RuntimeException, std::exception)
 301 {
 302     return OUString("DummyXShape");
 303 }
 304
 305 namespace {
 306
 307 uno::Sequence< OUString > listSupportedServices()
 308 {
 309     static uno::Sequence< OUString > aSupportedServices;
 310     if(aSupportedServices.getLength() == 0)
 311     {
 312         aSupportedServices.realloc(3);
 313         aSupportedServices[0] = "com.sun.star.drawing.Shape";
 314         aSupportedServices[1] = "com.sun.star.container.Named";
 315         aSupportedServices[2] = "com.sun.star.beans.PropertySet";
 316     }
 317
 318     return aSupportedServices;
 319 }
 320
 321 }
 322
 323 uno::Sequence< OUString > SAL_CALL DummyXShape::getSupportedServiceNames()
 324     throw(uno::RuntimeException, std::exception)
 325 {
 326     return listSupportedServices();
 327 }
 328
 329 sal_Bool SAL_CALL DummyXShape::supportsService( const OUString& rServiceName )
 330     throw(uno::RuntimeException, std::exception)
 331 {
 332     return cppu::supportsService(this, rServiceName);
 333 }
 334
 335 uno::Reference< uno::XInterface > SAL_CALL DummyXShape::getParent()
 336     throw(uno::RuntimeException, std::exception)
 337 {
 338     return mxParent;
 339 }
 340
 341 void SAL_CALL DummyXShape::setParent( const uno::Reference< uno::XInterface >& xParent )
 342     throw(lang::NoSupportException, uno::RuntimeException, std::exception)
 343 {
 344     mxParent = xParent;
 345 }
 346
 347 void DummyXShape::render()
 348 {
 349     SAL_WARN("chart2.opengl", "maybe a missing implementation in a subclass?");
 350 }
 351
 352 namespace {
 353
 354 void setProperties( const uno::Reference< beans::XPropertySet > & xPropSet, const tPropertyNameMap& rPropertyNameMap,
 355         std::map<OUString, uno::Any>& rTargetMap)
 356 {
 357     tNameSequence aNames;
 358     tAnySequence aValues;
 359     PropertyMapper::getMultiPropertyLists( aNames, aValues,
 360             xPropSet, rPropertyNameMap );
 361
 362     sal_Int32 nSize = std::min(aNames.getLength(), aValues.getLength());
 363     for(sal_Int32 i = 0; i < nSize; ++i)
 364     {
 365         rTargetMap[aNames[i]] = aValues[i];
 366     }
 367 }
 368
 369 void setProperties( const tNameSequence& rNames, const tAnySequence& rValues,
 370         std::map<OUString, uno::Any>& rTargetMap)
 371 {
 372     sal_Int32 nSize = std::min(rNames.getLength(), rValues.getLength());
 373     for(sal_Int32 i = 0; i < nSize; ++i)
 374     {
 375         rTargetMap[rNames[i]] = rValues[i];
 376     }
 377 }
 378
 379 }
 380
 381 DummyCube::DummyCube(const drawing::Position3D &rPos, const drawing::Direction3D& rSize,
 382         const uno::Reference< beans::XPropertySet > & xPropSet,
 383         const tPropertyNameMap& rPropertyNameMap )
 384 {
 385     setPosition(Position3DToAWTPoint(rPos));
 386     setSize(Direction3DToAWTSize(rSize));
 387     setProperties(xPropSet, rPropertyNameMap, maProperties);
 388 }
 389
 390 DummyCylinder::DummyCylinder(const drawing::Position3D& rPos, const drawing::Direction3D& rSize )
 391 {
 392     setPosition(Position3DToAWTPoint(rPos));
 393     setSize(Direction3DToAWTSize(rSize));
 394 }
 395
 396 DummyPyramid::DummyPyramid(const drawing::Position3D& rPos, const drawing::Direction3D& rSize,
 397         const uno::Reference< beans::XPropertySet > & xPropSet,
 398         const tPropertyNameMap& rPropertyNameMap)
 399 {
 400     setPosition(Position3DToAWTPoint(rPos));
 401     setSize(Direction3DToAWTSize(rSize));
 402     setProperties(xPropSet, rPropertyNameMap, maProperties);
 403 }
 404
 405 DummyCone::DummyCone(const drawing::Position3D& rPos, const drawing::Direction3D& rSize)
 406 {
 407     setPosition(Position3DToAWTPoint(rPos));
 408     setSize(Direction3DToAWTSize(rSize));
 409 }
 410
 411 DummyPieSegment2D::DummyPieSegment2D(double fUnitCircleStartAngleDegree, double fUnitCircleWidthAngleDegree,
 412         double fUnitCircleInnerRadius, double fUnitCircleOuterRadius,
 413         const drawing::Direction3D& rOffset, const drawing::HomogenMatrix& rUnitCircleToScene):
 414     mfUnitCircleStartAngleDegree(fUnitCircleStartAngleDegree),
 415     mfUnitCircleWidthAngleDegree(fUnitCircleWidthAngleDegree),
 416     mfUnitCircleInnerRadius(fUnitCircleInnerRadius),
 417     mfUnitCircleOuterRadius(fUnitCircleOuterRadius),
 418     maOffset(rOffset),
 419     maUnitCircleToScene(rUnitCircleToScene)
 420 {
 421 }
 422
 423 void DummyPieSegment2D::render()
 424 {
 425     SAL_INFO("chart2.opengl", "render DummyPieSegment2D");
 426     DummyChart* pChart = getRootShape();
 427
 428     while(mfUnitCircleWidthAngleDegree>360)
 429         mfUnitCircleWidthAngleDegree -= 360.0;
 430     while(mfUnitCircleWidthAngleDegree<0)
 431         mfUnitCircleWidthAngleDegree += 360.0;
 432
 433     pChart->m_GLRender.GeneratePieSegment2D(mfUnitCircleInnerRadius, mfUnitCircleOuterRadius,
 434             mfUnitCircleStartAngleDegree, mfUnitCircleWidthAngleDegree);
 435
 436     sal_uInt8 nAlpha = 255;
 437     std::map<OUString, uno::Any>::const_iterator itr = maProperties.find(UNO_NAME_FILL_TRANSPARENCE);
 438     if(itr != maProperties.end())
 439     {
 440         nAlpha = 255 - itr->second.get<sal_Int32>();
 441     }
 442
 443     itr = maProperties.find(UNO_NAME_FILLCOLOR);
 444     if(itr != maProperties.end())
 445     {
 446         sal_Int32 nColor = itr->second.get<sal_Int32>();
 447         pChart->m_GLRender.SetColor(nColor, nAlpha);
 448     }
 449
 450     float nSize = std::max<float>(maUnitCircleToScene.Line1.Column1, maUnitCircleToScene.Line2.Column2);
 451     pChart->m_GLRender.RenderPieSegment2DShape(nSize, maUnitCircleToScene.Line1.Column4 + maOffset.DirectionX,
 452             maUnitCircleToScene.Line2.Column4 + maOffset.DirectionY);
 453
 454 }
 455
 456 DummyPieSegment::DummyPieSegment(
 457         const drawing::Direction3D& rOffset, const drawing::HomogenMatrix& rUnitCircleToScene ):
 458     maOffset(rOffset),
 459     maUnitCircleToScene(rUnitCircleToScene)
 460 {
 461 }
 462
 463 DummyStripe::DummyStripe(const Stripe& rStripe, const uno::Reference< beans::XPropertySet > & xPropSet,
 464         const tPropertyNameMap& rPropertyNameMap ):
 465     maStripe(rStripe)
 466 {
 467     setProperties(xPropSet, rPropertyNameMap, maProperties);
 468 }
 469
 470 DummyArea3D::DummyArea3D(const drawing::PolyPolygonShape3D& rShape):
 471     maShapes(rShape)
 472 {
 473 }
 474
 475 DummyArea2D::DummyArea2D(const drawing::PointSequenceSequence& rShape):
 476     maShapes(rShape)
 477 {
 478 }
 479
 480 void DummyArea2D::render()
 481 {
 482     SAL_INFO("chart2.opengl", "render DummyArea2D");
 483     DummyChart* pChart = getRootShape();
 484     sal_Int32 nPointssCount = maShapes.getLength();
 485     for(sal_Int32 i = 0; i < nPointssCount; i++)
 486     {
 487         const com::sun::star::uno::Sequence<com::sun::star::awt::Point>& points = maShapes[i];
 488         sal_Int32 nPointsCount = points.getLength();
 489         for(sal_Int32 j = 0; j < nPointsCount; j++)
 490         {
 491             const com::sun::star::awt::Point& p = points[j];
 492             pChart->m_GLRender.SetArea2DShapePoint((float)p.X, (float)p.Y, nPointsCount);
 493         }
 494     }
 495
 496     std::map<OUString, uno::Any>::const_iterator itr = maProperties.find(UNO_NAME_FILLCOLOR);
 497     if(itr != maProperties.end())
 498     {
 499         sal_Int32 nColor = itr->second.get<sal_Int32>();
 500         pChart->m_GLRender.SetColor(nColor, 255);
 501     }
 502
 503     pChart->m_GLRender.RenderArea2DShape();
 504 }
 505
 506 DummySymbol2D::DummySymbol2D(const drawing::Position3D& rPos, const drawing::Direction3D& rSize,
 507         sal_Int32 nStandardSymbol, sal_Int32 nFillColor):
 508     mrPosition(rPos),
 509     mrSize(rSize),
 510     mnStandardSymbol(nStandardSymbol),
 511     mnFillColor(nFillColor)
 512 {
 513     setPosition(Position3DToAWTPoint(rPos));
 514     setSize(Direction3DToAWTSize(rSize));
 515 }
 516
 517 void DummySymbol2D::render()
 518 {
 519     DummyChart* pChart = getRootShape();
 520
 521     pChart->m_GLRender.SetColor(mnFillColor, 255);
 522
 523     pChart->m_GLRender.RenderSymbol2DShape(maPosition.X, maPosition.Y, maSize.Width, maSize.Height, mnStandardSymbol);
 524 }
 525
 526 DummyCircle::DummyCircle(const awt::Point& rPos, const awt::Size& rSize)
 527 {
 528     setPosition(rPos);
 529     setSize(rSize);
 530 }
 531
 532 void DummyCircle::render()
 533 {
 534     SAL_INFO("chart2.opengl", "render DummyCircle");
 535     debugProperties(maProperties);
 536     DummyChart* pChart = getRootShape();
 537
 538     sal_uInt8 nAlpha = 255;
 539     std::map<OUString, uno::Any>::const_iterator itr = maProperties.find("FillTransparence");
 540     if(itr != maProperties.end())
 541     {
 542         sal_Int32 nTrans = itr->second.get<sal_Int32>()/100.0*255;
 543         nAlpha = 255 - static_cast<sal_uInt8>(nTrans & 0xFF);
 544
 545         if(nAlpha == 0)
 546             return;
 547     }
 548
 549     itr = maProperties.find("FillColor");
 550     if(itr != maProperties.end())
 551     {
 552         sal_Int32 nColor = itr->second.get<sal_Int32>();
 553         pChart->m_GLRender.SetColor(nColor, nAlpha);
 554     }
 555     else
 556         SAL_WARN("chart2.opengl", "missing color");
 557
 558     pChart->m_GLRender.Bubble2DShapePoint(maPosition.X, maPosition.Y,
 559                                           maSize.Width, maSize.Height);
 560     pChart->m_GLRender.RenderBubble2FBO(GL_TRUE);
 561 }
 562
 563 namespace {
 564
 565 void setProperties( const VLineProperties& rLineProperties, std::map<OUString, uno::Any>& rTargetProps )
 566 {
 567     //Transparency
 568     if(rLineProperties.Transparence.hasValue())
 569         rTargetProps.insert(std::pair<OUString, uno::Any>(
 570                     UNO_NAME_LINETRANSPARENCE, rLineProperties.Transparence));
 571
 572     //LineStyle
 573     if(rLineProperties.LineStyle.hasValue())
 574         rTargetProps.insert(std::pair<OUString, uno::Any>(
 575                     UNO_NAME_LINESTYLE, rLineProperties.LineStyle));
 576
 577     //LineWidth
 578     if(rLineProperties.Width.hasValue())
 579         rTargetProps.insert(std::pair<OUString, uno::Any>(
 580                     UNO_NAME_LINEWIDTH, rLineProperties.Width));
 581
 582     //LineColor
 583     if(rLineProperties.Color.hasValue())
 584         rTargetProps.insert(std::pair<OUString, uno::Any>(
 585                     UNO_NAME_LINECOLOR, rLineProperties.Color));
 586
 587     //LineDashName
 588     if(rLineProperties.DashName.hasValue())
 589         rTargetProps.insert(std::pair<OUString, uno::Any>(
 590                     "LineDashName", rLineProperties.DashName));
 591 }
 592
 593 }
 594
 595 DummyLine3D::DummyLine3D(const drawing::PolyPolygonShape3D& rPoints, const VLineProperties& rLineProperties):
 596     maPoints(rPoints)
 597 {
 598     setProperties(rLineProperties, maProperties);
 599 }
 600
 601 DummyLine2D::DummyLine2D(const drawing::PointSequenceSequence& rPoints, const VLineProperties* pLineProperties):
 602     maPoints(rPoints)
 603 {
 604     if(pLineProperties)
 605         setProperties(*pLineProperties, maProperties);
 606 }
 607
 608 DummyLine2D::DummyLine2D(const awt::Size& rSize, const awt::Point& rPosition)
 609 {
 610     setPosition(rPosition);
 611     setSize(rSize);
 612 }
 613
 614 void DummyLine2D::render()
 615 {
 616     SAL_INFO("chart2.opengl", "rendering line 2D");
 617     debugProperties(maProperties);
 618     DummyChart* pChart = getRootShape();
 619
 620     //add style and transparency
 621     std::map< OUString, uno::Any >::const_iterator itr = maProperties.find(UNO_NAME_LINESTYLE);
 622     if (itr != maProperties.end())
 623     {
 624         uno::Any cow = itr->second;
 625         drawing::LineStyle nStyle = cow.get<drawing::LineStyle>();
 626         if (drawing::LineStyle_NONE == nStyle)
 627         {
 628             // nothing to render
 629             return;
 630         }
 631     }
 632
 633     sal_uInt8 nAlpha = 255;
 634     itr = maProperties.find("LineTransparence");
 635     if(itr != maProperties.end())
 636     {
 637         uno::Any al = itr->second;
 638         nAlpha = 255 - al.get<sal_Int32>();
 639     }
 640
 641     itr = maProperties.find(UNO_NAME_LINECOLOR);
 642     if(itr != maProperties.end())
 643     {
 644         //set line color
 645         uno::Any co =  itr->second;
 646         sal_Int32 nColorValue = co.get<sal_Int32>();
 647         SAL_INFO("chart2.opengl", "line colorvalue = " << nColorValue);
 648         sal_uInt8 R = (nColorValue & 0x00FF0000) >> 16;
 649         sal_uInt8 G = (nColorValue & 0x0000FF00) >> 8;
 650         sal_uInt8 B = (nColorValue & 0x000000FF);
 651         pChart->m_GLRender.SetLine2DColor(R, G, B, nAlpha);
 652
 653         SAL_INFO("chart2.opengl", "line colorvalue = " << nColorValue << ", R = " << (int)R << ", G = " << (int)G << ", B = " << (int)B);
 654     }
 655     else
 656         SAL_WARN("chart2.opengl", "no line color set");
 657
 658     //set line width
 659     itr = maProperties.find(UNO_NAME_LINEWIDTH);
 660     if(itr != maProperties.end())
 661     {
 662         uno::Any cow = itr->second;
 663         sal_Int32 nWidth = cow.get<sal_Int32>();
 664         pChart->m_GLRender.SetLine2DWidth(nWidth);
 665
 666         SAL_INFO("chart2.opengl", "width = " << nWidth);
 667     }
 668     else
 669         SAL_WARN("chart2.opengl", "no line width set");
 670
 671     sal_Int32 pointsscount = maPoints.getLength();
 672     for(sal_Int32 i = 0; i < pointsscount; i++)
 673     {
 674         com::sun::star::uno::Sequence<com::sun::star::awt::Point>& points = maPoints[i];
 675         sal_Int32 pointscount = points.getLength();
 676         for(sal_Int32 j = 0; j < pointscount; j++)
 677         {
 678             com::sun::star::awt::Point& p = points[j];
 679             pChart->m_GLRender.SetLine2DShapePoint((float)p.X, (float)p.Y, pointscount);
 680         }
 681
 682     }
 683     pChart->m_GLRender.RenderLine2FBO(GL_TRUE);
 684
 685 }
 686
 687 DummyRectangle::DummyRectangle()
 688 {
 689 }
 690
 691 DummyRectangle::DummyRectangle(const awt::Size& rSize)
 692 {
 693     setSize(rSize);
 694 }
 695
 696 DummyRectangle::DummyRectangle(const awt::Size& rSize, const awt::Point& rPoint, const tNameSequence& rNames,
 697         const tAnySequence& rValues)
 698 {
 699     setSize(rSize);
 700     setPosition(rPoint);
 701     setProperties(rNames, rValues, maProperties);
 702 }
 703
 704 void DummyRectangle::render()
 705 {
 706     SAL_INFO("chart2.opengl", "render DummyRectangle");
 707     debugProperties(maProperties);
 708     DummyChart* pChart = getRootShape();
 709     std::map< OUString, uno::Any >::const_iterator itr = maProperties.find("Invisible");
 710     if(itr != maProperties.end())
 711     {
 712         return;
 713     }
 714
 715     bool bFill = true;
 716     drawing::FillStyle eStyle = drawing::FillStyle_NONE;
 717     itr = maProperties.find("FillStyle");
 718     if(itr != maProperties.end())
 719     {
 720         eStyle = itr->second.get<drawing::FillStyle>();
 721         if(eStyle == drawing::FillStyle_NONE)
 722         {
 723             bFill = false;
 724         }
 725     }
 726
 727     itr = maProperties.find("FillColor");
 728     if(itr != maProperties.end())
 729     {
 730         uno::Any co =  itr->second;
 731         sal_Int32 nColorValue = co.get<sal_Int32>();
 732         //here FillStyle works for background color and gradients
 733         pChart->m_GLRender.SetBackGroundColor(nColorValue, nColorValue, eStyle);
 734     }
 735
 736     bool bBorder = true;
 737     itr =  maProperties.find(UNO_NAME_LINESTYLE);
 738     if (itr != maProperties.end())
 739     {
 740         uno::Any cow = itr->second;
 741         drawing::LineStyle nStyle = cow.get<drawing::LineStyle>();
 742         if (drawing::LineStyle_NONE == nStyle)
 743         {
 744             bBorder = false;
 745         }
 746     }
 747
 748     //TODO: moggi: correct handling of gradients
 749     itr =  maProperties.find("FillTransparenceGradientName");
 750     if (itr != maProperties.end())
 751     {
 752         uno::Any co = itr->second;
 753         rtl::OUString aGradientValue = co.get<rtl::OUString>();
 754         if (aGradientValue.endsWith("1"))
 755         {
 756             pChart->m_GLRender.SetChartTransparencyGradient(1);
 757         }
 758     }
 759     pChart->m_GLRender.RectangleShapePoint(maPosition.X, maPosition.Y, maSize.Width, maSize.Height);
 760     pChart->m_GLRender.RenderRectangleShape(bBorder, bFill);
 761 }
 762
 763 namespace {
 764
 765 struct FontAttribSetter
 766 {
 767     FontAttribSetter(vcl::Font& rFont):
 768         mrFont(rFont) {}
 769
 770     void operator()(const std::pair<OUString, uno::Any>& rProp)
 771     {
 772         const OUString& rPropName = rProp.first;
 773         if(rPropName == "CharFontName")
 774         {
 775             OUString aName = rProp.second.get<OUString>();
 776             mrFont.SetName(aName);
 777         }
 778         else if(rPropName == "CharColor")
 779         {
 780             sal_Int32 nColor = rProp.second.get<sal_Int32>();
 781             mrFont.SetFillColor(nColor);
 782         }
 783         else if(rPropName == "CharHeight")
 784         {
 785             float fHeight = rProp.second.get<float>();
 786             mrFont.SetSize(Size(0,(fHeight*127+36)/72)); //taken from the MCW implementation
 787         }
 788         else if(rPropName == "CharUnderline")
 789         {
 790             FontUnderline eUnderline = static_cast<FontUnderline>(rProp.second.get<sal_Int16>());
 791             mrFont.SetUnderline(eUnderline);
 792         }
 793         else if(rPropName == "CharWeight")
 794         {
 795             float fWeight = rProp.second.get<float>();
 796             FontWeight eFontWeight = VCLUnoHelper::ConvertFontWeight(fWeight);
 797             mrFont.SetWeight(eFontWeight);
 798         }
 799         else if(rPropName == "ChartWidth")
 800         {
 801             float fWidth = rProp.second.get<float>();
 802             FontWidth eFontWidth = VCLUnoHelper::ConvertFontWidth(fWidth);
 803             mrFont.SetWidth(eFontWidth);
 804         }
 805     }
 806 private:
 807     vcl::Font& mrFont;
 808 };
 809
 810 }
 811
 812 DummyText::DummyText(const OUString& rText, const tNameSequence& rNames,
 813         const tAnySequence& rValues, const uno::Any& rTrans, uno::Reference< drawing::XShapes > xTarget, double nRotation ):
 814     maText(rText),
 815     maTrans(rTrans),
 816     mnRotation(nRotation)
 817 {
 818     setProperties(rNames, rValues, maProperties);
 819
 820     xTarget->add(this);
 821     DummyChart* pChart = getRootShape();
 822     TextCache& rCache = pChart->getTextCache();
 823     TextCache::TextCacheKey aKey;
 824     aKey.maText = maText;
 825     aKey.maProperties = maProperties;
 826     int bmpWidth;
 827     int bmpHeight;
 828     if(rCache.hasEntry(aKey))
 829     {
 830         maBitmap = rCache.getBitmap(aKey);
 831         bmpWidth = maBitmap.GetSizePixel().Width();
 832         bmpHeight = maBitmap.GetSizePixel().Height();
 833     }
 834     else
 835     {
 836         vcl::Font aFont;
 837         std::for_each(maProperties.begin(), maProperties.end(), FontAttribSetter(aFont));
 838         ScopedVclPtrInstance< VirtualDevice > pDevice(*Application::GetDefaultDevice(), 0, 0);
 839         pDevice->Erase();
 840         Rectangle aRect;
 841         pDevice->SetFont(aFont);
 842         pDevice->GetTextBoundRect(aRect, rText);
 843         int screenWidth = (aRect.BottomRight().X());
 844         int screenHeight = (aRect.BottomRight().Y());
 845         pDevice->SetOutputSizePixel(Size(screenWidth * 3, screenHeight));
 846         pDevice->SetBackground(Wallpaper(COL_TRANSPARENT));
 847         pDevice->DrawText(Point(0, 0), rText);
 848         bmpWidth = aRect.Right() - aRect.Left();
 849         bmpHeight = aRect.Bottom() - aRect.Top();
 850         maBitmap = BitmapEx(pDevice->GetBitmapEx(aRect.TopLeft(), Size(bmpWidth, bmpHeight)));
 851         rCache.insertBitmap(aKey, maBitmap);
 852     }
 853
 854     if(rTrans.hasValue())
 855     {
 856         drawing::HomogenMatrix3 aTrans = rTrans.get<drawing::HomogenMatrix3>();
 857         setSize(awt::Size(20*bmpWidth, 20*bmpHeight));
 858         setPosition(awt::Point(aTrans.Line1.Column3, aTrans.Line2.Column3));
 859         aTrans.Line1.Column1 = 20 * bmpWidth;
 860         aTrans.Line2.Column2 = 20 * bmpHeight;
 861         setTransformatAsProperty(aTrans);
 862     }
 863     else
 864     {
 865         setSize(awt::Size(20*bmpWidth, 20*bmpHeight));
 866         uno::Reference< drawing::XShape > xTargetShape(xTarget, uno::UNO_QUERY);
 867         drawing::HomogenMatrix3 aTrans;
 868         aTrans.Line1.Column1 = 20 * bmpWidth;
 869         aTrans.Line2.Column2 = 20 * bmpHeight;
 870         aTrans.Line3.Column3 = 1;
 871         if(xTargetShape.is())
 872         {
 873             const awt::Point rPoint = xTargetShape->getPosition();
 874             setPosition(rPoint);
 875             aTrans.Line1.Column3 = rPoint.X;
 876             aTrans.Line2.Column3 = rPoint.Y;
 877         }
 878         setTransformatAsProperty(aTrans);
 879     }
 880 }
 881
 882 void DummyText::render()
 883 {
 884     SAL_INFO("chart2.opengl", "render DummyText");
 885     debugProperties(maProperties);
 886
 887     DummyChart* pChart = getRootShape();
 888
 889     drawing::HomogenMatrix3 aTransformation;
 890     std::map<OUString, uno::Any>::const_iterator itr =
 891         maProperties.find("Transformation");
 892     if(itr != maProperties.end())
 893     {
 894         SAL_INFO("chart2.opengl", "found a transformation");
 895         if(itr->second.hasValue())
 896         {
 897             aTransformation = itr->second.get<drawing::HomogenMatrix3>();
 898         }
 899     }
 900     else if(maTrans.hasValue())
 901     {
 902         aTransformation = maTrans.get<drawing::HomogenMatrix3>();
 903     }
 904     pChart->m_GLRender.CreateTextTexture(maBitmap, maPosition, maSize,
 905             mnRotation, aTransformation);
 906     pChart->m_GLRender.RenderTextShape();
 907 }
 908
 909 void SAL_CALL DummyText::setPropertyValue( const OUString& rName, const uno::Any& rValue)
 910     throw(beans::UnknownPropertyException, beans::PropertyVetoException,
 911             lang::IllegalArgumentException, lang::WrappedTargetException,
 912             uno::RuntimeException, std::exception)
 913 {
 914     SAL_INFO("chart2.opengl", "property value set after image has been created");
 915     DummyXShape::setPropertyValue(rName, rValue);
 916 }
 917
 918 void SAL_CALL DummyText::setPosition(const awt::Point& rPosition )
 919     throw(uno::RuntimeException, std::exception)
 920 {
 921     DummyXShape::setPosition(rPosition);
 922     if(maTrans.hasValue())
 923         return;
 924
 925     std::map<OUString, uno::Any>::const_iterator itr =
 926         maProperties.find("Transformation");
 927     if(itr != maProperties.end())
 928     {
 929         if(itr->second.hasValue())
 930         {
 931             drawing::HomogenMatrix3 aTrans = itr->second.get<drawing::HomogenMatrix3>();
 932             aTrans.Line1.Column3 = rPosition.X;
 933             aTrans.Line2.Column3 = rPosition.Y;
 934             setTransformatAsProperty(aTrans);
 935         }
 936     }
 937 }
 938
 939 void DummyText::setTransformatAsProperty(const drawing::HomogenMatrix3& rMatrix)
 940 {
 941     uno::Any aNewTrans;
 942     aNewTrans <<= rMatrix;
 943     setPropertyValue("Transformation", aNewTrans);
 944 }
 945
 946 DummyGroup3D::DummyGroup3D(const OUString& rName)
 947 {
 948     setName(rName);
 949 }
 950
 951 DummyGroup2D::DummyGroup2D(const OUString& rName)
 952 {
 953     setName(rName);
 954 }
 955
 956 awt::Point SAL_CALL DummyGroup2D::getPosition()
 957     throw(uno::RuntimeException, std::exception)
 958 {
 959     long nTop = std::numeric_limits<long>::max();
 960     long nLeft = std::numeric_limits<long>::max();
 961     for(std::vector<DummyXShape*>::iterator itr = maShapes.begin(),
 962             itrEnd = maShapes.end(); itr != itrEnd; ++itr)
 963     {
 964         awt::Point aPoint = (*itr)->getPosition();
 965         if(aPoint.X >= 0 && aPoint.Y >= 0)
 966         {
 967             nLeft = std::min<long>(nLeft, aPoint.X);
 968             nTop = std::min<long>(nTop, aPoint.Y);
 969         }
 970     }
 971
 972     return awt::Point(nLeft, nTop);
 973 }
 974
 975 awt::Size SAL_CALL DummyGroup2D::getSize()
 976     throw(uno::RuntimeException, std::exception)
 977 {
 978     long nTop = std::numeric_limits<long>::max();
 979     long nLeft = std::numeric_limits<long>::max();
 980     long nBottom = 0;
 981     long nRight = 0;
 982     for(std::vector<DummyXShape*>::iterator itr = maShapes.begin(),
 983             itrEnd = maShapes.end(); itr != itrEnd; ++itr)
 984     {
 985         awt::Point aPoint = (*itr)->getPosition();
 986         nLeft = std::min<long>(nLeft, aPoint.X);
 987         nTop = std::min<long>(nTop, aPoint.Y);
 988         awt::Size aSize = (*itr)->getSize();
 989         nRight = std::max<long>(nRight, aPoint.X + aSize.Width);
 990         nBottom = std::max<long>(nBottom, aPoint.Y + aSize.Height);
 991     }
 992
 993     return awt::Size(nRight - nLeft, nBottom - nTop);
 994 }
 995
 996 void SAL_CALL DummyGroup2D::setPosition( const awt::Point& rPos )
 997     throw(uno::RuntimeException, std::exception)
 998 {
 999     for(std::vector<DummyXShape*>::const_iterator itr = maShapes.begin(),
1000             itrEnd = maShapes.end(); itr != itrEnd; ++itr)
1001     {
1002         const awt::Point& rOldPos = (*itr)->getPos();
1003         awt::Point aNewPos( rPos.X + rOldPos.X, rPos.Y + rOldPos.Y);
1004         (*itr)->setPosition(aNewPos);
1005     }
1006 }
1007
1008 void SAL_CALL DummyGroup2D::setSize( const awt::Size& )
1009     throw( beans::PropertyVetoException, uno::RuntimeException, std::exception )
1010 {
1011     SAL_WARN("chart2.opengl", "set size on group shape");
1012 }
1013
1014 DummyGraphic2D::DummyGraphic2D(const drawing::Position3D& rPos, const drawing::Direction3D& rSize,
1015         const uno::Reference< graphic::XGraphic >& rGraphic ):
1016     mxGraphic(rGraphic)
1017 {
1018     setPosition(Position3DToAWTPoint(rPos));
1019     setSize(Direction3DToAWTSize(rSize));
1020 }
1021
1022 DummyChart* DummyXShape::getRootShape()
1023 {
1024     assert(mxParent.is());
1025     DummyXShape& rParent = dynamic_cast<DummyXShape&>(*mxParent.get());
1026     return rParent.getRootShape();
1027 }
1028
1029 DummyChart* DummyChart::getRootShape()
1030 {
1031     return this;
1032 }
1033
1034 #define QUERYINT( xint ) \
1035     if( rType == cppu::UnoType<xint>::get() ) \
1036         aAny <<= uno::Reference< xint >(this)
1037
1038 #define QUERY_INTERFACE( xint ) \
1039     if( rType == cppu::UnoType<xint>::get() ) \
1040         return uno::makeAny(uno::Reference<xint>(this));
1041
1042 uno::Any SAL_CALL DummyXShapes::queryInterface( const uno::Type& rType )
1043     throw(uno::RuntimeException, std::exception)
1044 {
1045     QUERY_INTERFACE( drawing::XShapes );
1046     QUERY_INTERFACE( container::XIndexAccess );
1047     return DummyXShape::queryInterface(rType);
1048 }
1049
1050 uno::Any SAL_CALL DummyXShapes::queryAggregation( const uno::Type & rType )
1051     throw(uno::RuntimeException, std::exception)
1052 {
1053     uno::Any aAny;
1054
1055     //QUERYINT( drawing::XShapeGroup );
1056     QUERYINT( drawing::XShapes );
1057     else
1058         return DummyXShape::queryAggregation( rType );
1059
1060     return aAny;
1061 }
1062
1063 void SAL_CALL DummyXShapes::acquire()
1064     throw()
1065 {
1066     DummyXShape::acquire();
1067 }
1068
1069 void DummyXShapes::release()
1070     throw()
1071 {
1072     DummyXShape::release();
1073 }
1074
1075 void SAL_CALL DummyXShapes::add( const uno::Reference< drawing::XShape>& xShape )
1076     throw(uno::RuntimeException, std::exception)
1077 {
1078     DummyXShape& rChild = dynamic_cast<DummyXShape&>(*xShape.get());
1079     maUNOShapes.push_back(xShape);
1080     rChild.setParent(static_cast< ::cppu::OWeakObject* >( this ));
1081     maShapes.push_back(&rChild);
1082 }
1083
1084 void SAL_CALL DummyXShapes::remove( const uno::Reference< drawing::XShape>& xShape )
1085     throw(uno::RuntimeException, std::exception)
1086 {
1087     std::vector< uno::Reference<drawing::XShape> >::iterator itr = std::find(maUNOShapes.begin(), maUNOShapes.end(), xShape);
1088     if(itr != maUNOShapes.end())
1089     {
1090         DummyXShape* pChild = dynamic_cast<DummyXShape*>((*itr).get());
1091         std::vector< DummyXShape* >::iterator itrShape = std::find(maShapes.begin(), maShapes.end(), pChild);
1092         if(itrShape != maShapes.end())
1093             maShapes.erase(itrShape);
1094
1095         maUNOShapes.erase(itr);
1096     }
1097 }
1098
1099 uno::Type SAL_CALL DummyXShapes::getElementType()
1100     throw(uno::RuntimeException, std::exception)
1101 {
1102     return cppu::UnoType<drawing::XShape>::get();
1103 }
1104
1105 sal_Bool SAL_CALL SAL_CALL DummyXShapes::hasElements()
1106     throw(uno::RuntimeException, std::exception)
1107 {
1108     return !maUNOShapes.empty();
1109 }
1110
1111 sal_Int32 SAL_CALL DummyXShapes::getCount()
1112     throw(uno::RuntimeException, std::exception)
1113 {
1114     return maUNOShapes.size();
1115 }
1116
1117 uno::Any SAL_CALL DummyXShapes::getByIndex(sal_Int32 nIndex)
1118     throw(lang::IndexOutOfBoundsException, lang::WrappedTargetException,
1119             uno::RuntimeException, std::exception)
1120 {
1121     uno::Any aShape;
1122     aShape <<= maUNOShapes[nIndex];
1123     return aShape;
1124 }
1125
1126 void DummyXShapes::render()
1127 {
1128     SAL_INFO("chart2.opengl", "render DummyShapes");
1129     for(std::vector<DummyXShape*>::iterator itr = maShapes.begin(),
1130             itrEnd = maShapes.end(); itr != itrEnd; ++itr)
1131     {
1132         (*itr)->render();
1133     }
1134 }
1135
1136 DummyChart::DummyChart():
1137     mbNotInit(true),
1138     m_GLRender()
1139 {
1140     SAL_INFO("chart2.opengl", "DummyXShape::DummyChart()-----test: ");
1141     setName("com.sun.star.chart2.shapes");
1142 }
1143
1144 void SAL_CALL DummyChart::setPosition( const awt::Point& aPosition )
1145     throw( uno::RuntimeException, std::exception )
1146 {
1147     DummyXShape::setPosition(aPosition);
1148 }
1149
1150 DummyChart::~DummyChart()
1151 {
1152 }
1153
1154 void SAL_CALL DummyChart::setSize( const awt::Size& aSize )
1155     throw( beans::PropertyVetoException, uno::RuntimeException, std::exception )
1156 {
1157     SAL_INFO("chart2.opengl", "DummyChart::setSize()---aSize.Width = " << aSize.Width << ", aSize.Height = " << aSize.Height);
1158     int width = aSize.Width;
1159     int height = aSize.Height;
1160     DummyXShape::setSize(awt::Size(0,0));
1161     m_GLRender.SetSize(width, height);
1162     SAL_INFO("chart2.opengl", "DummyChart::GLRender.Width = " << width << ", GLRender.Height = " << height);
1163 }
1164
1165 void DummyChart::render()
1166 {
1167     if(mbNotInit)
1168     {
1169         m_GLRender.InitOpenGL();
1170         mbNotInit = false;
1171     }
1172
1173     SAL_INFO("chart2.opengl", "render chart");
1174     m_GLRender.prepareToRender();
1175 #if 0
1176     m_GLRender.renderDebug();
1177 #else
1178     DummyXShapes::render();
1179 #endif
1180 }
1181
1182 void DummyChart::clear()
1183 {
1184     maUNOShapes.clear();
1185     maShapes.clear();
1186 }
1187
1188 }
1189
1190 }
1191
1192 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */