reportdesign/source/core/sdr/RptObject.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 #include <RptObject.hxx>
  20 #include <vector>
  21 #include <algorithm>
  22
  23 #include <RptDef.hxx>
  24 #include <svx/unoshape.hxx>
  25 #include <RptModel.hxx>
  26 #include <RptObjectListener.hxx>
  27 #include <toolkit/helper/convert.hxx>
  28 #include <RptPage.hxx>
  29 #include <dbaccess/dbsubcomponentcontroller.hxx>
  30
  31 #include <strings.hrc>
  32 #include <strings.hxx>
  33 #include <svx/xflclit.hxx>
  34 #include <svx/xlnclit.hxx>
  35 #include <svx/xlndsit.hxx>
  36 #include <svx/xlineit0.hxx>
  37 #include <svx/sderitm.hxx>
  38 #include <svx/xlnwtit.hxx>
  39 #include <svx/xlntrit.hxx>
  40 #include <svtools/embedhlp.hxx>
  41 #include <com/sun/star/style/XStyle.hpp>
  42 #include <com/sun/star/awt/XTabControllerModel.hpp>
  43 #include <com/sun/star/awt/XUnoControlContainer.hpp>
  44 #include <com/sun/star/awt/XVclContainerPeer.hpp>
  45 #include <com/sun/star/awt/XWindow.hpp>
  46 #include <com/sun/star/awt/TextAlign.hpp>
  47 #include <com/sun/star/beans/XPropertySet.hpp>
  48 #include <com/sun/star/beans/PropertyAttribute.hpp>
  49 #include <com/sun/star/embed/XComponentSupplier.hpp>
  50 #include <com/sun/star/container/XContainer.hpp>
  51 #include <com/sun/star/lang/XServiceInfo.hpp>
  52 #include <com/sun/star/report/XShape.hpp>
  53 #include <com/sun/star/report/XFixedLine.hpp>
  54 #include <com/sun/star/chart/ChartDataRowSource.hpp>
  55 #include <com/sun/star/chart2/data/XDataReceiver.hpp>
  56 #include <com/sun/star/chart2/data/DatabaseDataProvider.hpp>
  57 #include <com/sun/star/chart2/XChartDocument.hpp>
  58 #include <com/sun/star/style/VerticalAlignment.hpp>
  59 #include <com/sun/star/style/ParagraphAdjust.hpp>
  60 #include <com/sun/star/report/XFormattedField.hpp>
  61 #include <comphelper/property.hxx>
  62 #include <tools/diagnose_ex.h>
  63 #include <PropertyForward.hxx>
  64 #include <connectivity/dbtools.hxx>
  65 #include <connectivity/dbconversion.hxx>
  66 #include <UndoActions.hxx>
  67 #include <UndoEnv.hxx>
  68 #include <functional>
  69
  70 namespace rptui
  71 {
  72
  73 using namespace ::com::sun::star;
  74 using namespace uno;
  75 using namespace beans;
  76 using namespace reportdesign;
  77 using namespace container;
  78 using namespace script;
  79 using namespace report;
  80
  81 sal_uInt16 OObjectBase::getObjectType(const uno::Reference< report::XReportComponent>& _xComponent)
  82 {
  83     uno::Reference< lang::XServiceInfo > xServiceInfo( _xComponent , uno::UNO_QUERY );
  84     OSL_ENSURE(xServiceInfo.is(),"Who deletes the XServiceInfo interface!");
  85     if ( xServiceInfo.is() )
  86     {
  87         if ( xServiceInfo->supportsService( SERVICE_FIXEDTEXT ))
  88             return OBJ_DLG_FIXEDTEXT;
  89         if ( xServiceInfo->supportsService( SERVICE_FIXEDLINE ))
  90         {
  91             uno::Reference< report::XFixedLine> xFixedLine(_xComponent,uno::UNO_QUERY);
  92             return xFixedLine->getOrientation() ? OBJ_DLG_HFIXEDLINE : OBJ_DLG_VFIXEDLINE;
  93         }
  94         if ( xServiceInfo->supportsService( SERVICE_IMAGECONTROL))
  95             return OBJ_DLG_IMAGECONTROL;
  96         if ( xServiceInfo->supportsService( SERVICE_FORMATTEDFIELD ))
  97             return OBJ_DLG_FORMATTEDFIELD;
  98         if ( xServiceInfo->supportsService("com.sun.star.drawing.OLE2Shape") )
  99             return OBJ_OLE2;
 100         if ( xServiceInfo->supportsService( SERVICE_SHAPE ))
 101             return OBJ_CUSTOMSHAPE;
 102         if ( xServiceInfo->supportsService( SERVICE_REPORTDEFINITION ) )
 103             return OBJ_DLG_SUBREPORT;
 104         return OBJ_OLE2;
 105     }
 106     return 0;
 107 }
 108
 109 SdrObject* OObjectBase::createObject(
 110     SdrModel& rTargetModel,
 111     const uno::Reference< report::XReportComponent>& _xComponent)
 112 {
 113     SdrObject* pNewObj = nullptr;
 114     sal_uInt16 nType = OObjectBase::getObjectType(_xComponent);
 115     switch( nType )
 116     {
 117         case OBJ_DLG_FIXEDTEXT:
 118             {
 119                 OUnoObject* pUnoObj = new OUnoObject(
 120                     rTargetModel,
 121                     _xComponent,
 122                     OUString("com.sun.star.form.component.FixedText"),
 123                     OBJ_DLG_FIXEDTEXT);
 124                 pNewObj = pUnoObj;
 125
 126                 uno::Reference<beans::XPropertySet> xControlModel(pUnoObj->GetUnoControlModel(),uno::UNO_QUERY);
 127                 if ( xControlModel.is() )
 128                     xControlModel->setPropertyValue( PROPERTY_MULTILINE,uno::makeAny(true));
 129             }
 130             break;
 131         case OBJ_DLG_IMAGECONTROL:
 132             pNewObj = new OUnoObject(
 133                 rTargetModel,
 134                 _xComponent,
 135                 OUString("com.sun.star.form.component.DatabaseImageControl"),
 136                 OBJ_DLG_IMAGECONTROL);
 137             break;
 138         case OBJ_DLG_FORMATTEDFIELD:
 139             pNewObj = new OUnoObject(
 140                 rTargetModel,
 141                 _xComponent,
 142                 OUString("com.sun.star.form.component.FormattedField"),
 143                 OBJ_DLG_FORMATTEDFIELD);
 144             break;
 145         case OBJ_DLG_HFIXEDLINE:
 146         case OBJ_DLG_VFIXEDLINE:
 147             pNewObj = new OUnoObject(
 148                 rTargetModel,
 149                 _xComponent,
 150                 OUString("com.sun.star.awt.UnoControlFixedLineModel"),
 151                 nType);
 152             break;
 153         case OBJ_CUSTOMSHAPE:
 154             pNewObj = OCustomShape::Create(
 155                 rTargetModel,
 156                 _xComponent);
 157             try
 158             {
 159                 bool bOpaque = false;
 160                 _xComponent->getPropertyValue(PROPERTY_OPAQUE) >>= bOpaque;
 161                 pNewObj->NbcSetLayer(bOpaque ? RPT_LAYER_FRONT : RPT_LAYER_BACK);
 162             }
 163             catch(const uno::Exception&)
 164             {
 165                 DBG_UNHANDLED_EXCEPTION("reportdesign");
 166             }
 167             break;
 168         case OBJ_DLG_SUBREPORT:
 169         case OBJ_OLE2:
 170             pNewObj = OOle2Obj::Create(
 171                 rTargetModel,
 172                 _xComponent,
 173                 nType);
 174             break;
 175         default:
 176             OSL_FAIL("Unknown object id");
 177             break;
 178     }
 179
 180     if ( pNewObj )
 181         pNewObj->SetDoNotInsertIntoPageAutomatically( true );
 182
 183     ensureSdrObjectOwnership( _xComponent );
 184
 185     return pNewObj;
 186 }
 187
 188 namespace
 189 {
 190     class ParaAdjust : public AnyConverter
 191     {
 192     public:
 193         virtual css::uno::Any operator() (const OUString& _sPropertyName,const css::uno::Any& lhs) const override
 194         {
 195             uno::Any aRet;
 196             if (_sPropertyName == PROPERTY_PARAADJUST)
 197             {
 198                 sal_Int16 nTextAlign = 0;
 199                 lhs >>= nTextAlign;
 200                 style::ParagraphAdjust eAdjust;
 201                 switch(nTextAlign)
 202                 {
 203                     case awt::TextAlign::LEFT:
 204                         eAdjust = style::ParagraphAdjust_LEFT;
 205                         break;
 206                     case awt::TextAlign::CENTER:
 207                         eAdjust = style::ParagraphAdjust_CENTER;
 208                         break;
 209                     case awt::TextAlign::RIGHT:
 210                         eAdjust = style::ParagraphAdjust_RIGHT;
 211                         break;
 212                     default:
 213                         OSL_FAIL("Illegal text alignment value!");
 214                         break;
 215                 }
 216                 aRet <<= eAdjust;
 217             }
 218             else
 219             {
 220                 sal_Int16 nTextAlign = 0;
 221                 sal_Int16 eParagraphAdjust = 0;
 222                 lhs >>= eParagraphAdjust;
 223                 switch(static_cast<style::ParagraphAdjust>(eParagraphAdjust))
 224                 {
 225                     case style::ParagraphAdjust_LEFT:
 226                     case style::ParagraphAdjust_BLOCK:
 227                         nTextAlign = awt::TextAlign::LEFT;
 228                         break;
 229                     case style::ParagraphAdjust_CENTER:
 230                         nTextAlign = awt::TextAlign::CENTER;
 231                         break;
 232                     case style::ParagraphAdjust_RIGHT:
 233                         nTextAlign = awt::TextAlign::RIGHT;
 234                         break;
 235                     default:
 236                         OSL_FAIL("Illegal text alignment value!");
 237                         break;
 238                 }
 239                 aRet <<= nTextAlign;
 240             }
 241             return aRet;
 242         }
 243     };
 244 }
 245
 246 const TPropertyNamePair& getPropertyNameMap(sal_uInt16 _nObjectId)
 247 {
 248     switch(_nObjectId)
 249     {
 250         case OBJ_DLG_IMAGECONTROL:
 251             {
 252                 static TPropertyNamePair s_aNameMap;
 253                 if ( s_aNameMap.empty() )
 254                 {
 255                     std::shared_ptr<AnyConverter> aNoConverter(new AnyConverter);
 256                     s_aNameMap.emplace(PROPERTY_CONTROLBACKGROUND,TPropertyConverter(PROPERTY_BACKGROUNDCOLOR,aNoConverter));
 257                     s_aNameMap.emplace(PROPERTY_CONTROLBORDER,TPropertyConverter(PROPERTY_BORDER,aNoConverter));
 258                     s_aNameMap.emplace(PROPERTY_CONTROLBORDERCOLOR,TPropertyConverter(PROPERTY_BORDERCOLOR,aNoConverter));
 259                 }
 260                 return s_aNameMap;
 261             }
 262
 263         case OBJ_DLG_FIXEDTEXT:
 264             {
 265                 static TPropertyNamePair s_aNameMap;
 266                 if ( s_aNameMap.empty() )
 267                 {
 268                     std::shared_ptr<AnyConverter> aNoConverter(new AnyConverter);
 269                     s_aNameMap.emplace(PROPERTY_CHARCOLOR,TPropertyConverter(PROPERTY_TEXTCOLOR,aNoConverter));
 270                     s_aNameMap.emplace(PROPERTY_CONTROLBACKGROUND,TPropertyConverter(PROPERTY_BACKGROUNDCOLOR,aNoConverter));
 271                     s_aNameMap.emplace(PROPERTY_CHARUNDERLINECOLOR,TPropertyConverter(PROPERTY_TEXTLINECOLOR,aNoConverter));
 272                     s_aNameMap.emplace(PROPERTY_CHARRELIEF,TPropertyConverter(PROPERTY_FONTRELIEF,aNoConverter));
 273                     s_aNameMap.emplace(PROPERTY_CHARFONTHEIGHT,TPropertyConverter(PROPERTY_FONTHEIGHT,aNoConverter));
 274                     s_aNameMap.emplace(PROPERTY_CHARSTRIKEOUT,TPropertyConverter(PROPERTY_FONTSTRIKEOUT,aNoConverter));
 275                     s_aNameMap.emplace(PROPERTY_CONTROLTEXTEMPHASISMARK,TPropertyConverter(PROPERTY_FONTEMPHASISMARK,aNoConverter));
 276                     s_aNameMap.emplace(PROPERTY_CONTROLBORDER,TPropertyConverter(PROPERTY_BORDER,aNoConverter));
 277                     s_aNameMap.emplace(PROPERTY_CONTROLBORDERCOLOR,TPropertyConverter(PROPERTY_BORDERCOLOR,aNoConverter));
 278
 279                     std::shared_ptr<AnyConverter> aParaAdjust(new ParaAdjust);
 280                     s_aNameMap.emplace(PROPERTY_PARAADJUST,TPropertyConverter(PROPERTY_ALIGN,aParaAdjust));
 281                 }
 282                 return s_aNameMap;
 283             }
 284         case OBJ_DLG_FORMATTEDFIELD:
 285             {
 286                 static TPropertyNamePair s_aNameMap;
 287                 if ( s_aNameMap.empty() )
 288                 {
 289                     std::shared_ptr<AnyConverter> aNoConverter(new AnyConverter);
 290                     s_aNameMap.emplace(PROPERTY_CHARCOLOR,TPropertyConverter(PROPERTY_TEXTCOLOR,aNoConverter));
 291                     s_aNameMap.emplace(PROPERTY_CONTROLBACKGROUND,TPropertyConverter(PROPERTY_BACKGROUNDCOLOR,aNoConverter));
 292                     s_aNameMap.emplace(PROPERTY_CHARUNDERLINECOLOR,TPropertyConverter(PROPERTY_TEXTLINECOLOR,aNoConverter));
 293                     s_aNameMap.emplace(PROPERTY_CHARRELIEF,TPropertyConverter(PROPERTY_FONTRELIEF,aNoConverter));
 294                     s_aNameMap.emplace(PROPERTY_CHARFONTHEIGHT,TPropertyConverter(PROPERTY_FONTHEIGHT,aNoConverter));
 295                     s_aNameMap.emplace(PROPERTY_CHARSTRIKEOUT,TPropertyConverter(PROPERTY_FONTSTRIKEOUT,aNoConverter));
 296                     s_aNameMap.emplace(PROPERTY_CONTROLTEXTEMPHASISMARK,TPropertyConverter(PROPERTY_FONTEMPHASISMARK,aNoConverter));
 297                     s_aNameMap.emplace(PROPERTY_CONTROLBORDER,TPropertyConverter(PROPERTY_BORDER,aNoConverter));
 298                     s_aNameMap.emplace(PROPERTY_CONTROLBORDERCOLOR,TPropertyConverter(PROPERTY_BORDERCOLOR,aNoConverter));
 299                     std::shared_ptr<AnyConverter> aParaAdjust(new ParaAdjust);
 300                     s_aNameMap.emplace(PROPERTY_PARAADJUST,TPropertyConverter(PROPERTY_ALIGN,aParaAdjust));
 301                 }
 302                 return s_aNameMap;
 303             }
 304
 305         case OBJ_CUSTOMSHAPE:
 306             {
 307                 static TPropertyNamePair s_aNameMap;
 308                 if ( s_aNameMap.empty() )
 309                 {
 310                     std::shared_ptr<AnyConverter> aNoConverter(new AnyConverter);
 311                     s_aNameMap.emplace(OUString("FillColor"),TPropertyConverter(PROPERTY_CONTROLBACKGROUND,aNoConverter));
 312                     s_aNameMap.emplace(PROPERTY_PARAADJUST,TPropertyConverter(PROPERTY_ALIGN,aNoConverter));
 313                 }
 314                 return s_aNameMap;
 315             }
 316
 317         default:
 318             break;
 319     }
 320     static TPropertyNamePair s_aEmptyNameMap;
 321     return s_aEmptyNameMap;
 322 }
 323
 324
 325 OObjectBase::OObjectBase(const uno::Reference< report::XReportComponent>& _xComponent)
 326 :m_bIsListening(false)
 327 {
 328     m_xReportComponent = _xComponent;
 329 }
 330
 331 OObjectBase::OObjectBase(const OUString& _sComponentName)
 332 :m_sComponentName(_sComponentName)
 333 ,m_bIsListening(false)
 334 {
 335 }
 336
 337 OObjectBase::~OObjectBase()
 338 {
 339     m_xMediator.clear();
 340     if ( isListening() )
 341         EndListening();
 342     m_xReportComponent.clear();
 343 }
 344
 345 uno::Reference< report::XSection> OObjectBase::getSection() const
 346 {
 347     uno::Reference< report::XSection> xSection;
 348     OReportPage* pPage = dynamic_cast<OReportPage*>(GetImplPage());
 349     if ( pPage )
 350         xSection = pPage->getSection();
 351     return xSection;
 352 }
 353
 354
 355 uno::Reference< beans::XPropertySet> OObjectBase::getAwtComponent()
 356 {
 357     return uno::Reference< beans::XPropertySet>();
 358 }
 359
 360 void OObjectBase::StartListening()
 361 {
 362     OSL_ENSURE(!isListening(), "OUnoObject::StartListening: already listening!");
 363
 364     if ( !isListening() && m_xReportComponent.is() )
 365     {
 366         m_bIsListening = true;
 367
 368         if ( !m_xPropertyChangeListener.is() )
 369         {
 370             m_xPropertyChangeListener = new OObjectListener( this );
 371             // register listener to all properties
 372             m_xReportComponent->addPropertyChangeListener( OUString() , m_xPropertyChangeListener );
 373         }
 374     }
 375 }
 376
 377 void OObjectBase::EndListening()
 378 {
 379     OSL_ENSURE(!m_xReportComponent.is() || isListening(), "OUnoObject::EndListening: not listening currently!");
 380
 381     if ( isListening() && m_xReportComponent.is() )
 382     {
 383         // XPropertyChangeListener
 384         if ( m_xPropertyChangeListener.is() )
 385         {
 386             // remove listener
 387             try
 388             {
 389                 m_xReportComponent->removePropertyChangeListener( OUString() , m_xPropertyChangeListener );
 390             }
 391             catch(const uno::Exception &)
 392             {
 393                 OSL_FAIL("OObjectBase::EndListening: Exception caught!");
 394             }
 395         }
 396         m_xPropertyChangeListener.clear();
 397     }
 398     m_bIsListening = false;
 399 }
 400
 401 void OObjectBase::SetPropsFromRect(const tools::Rectangle& _rRect)
 402 {
 403     // set properties
 404     OReportPage* pPage = dynamic_cast<OReportPage*>(GetImplPage());
 405     if ( pPage && !_rRect.IsEmpty() )
 406     {
 407         const uno::Reference<report::XSection>& xSection = pPage->getSection();
 408         assert(_rRect.getHeight() >= 0);
 409         const sal_uInt32 newHeight( ::std::max(0l, _rRect.getHeight()+_rRect.Top()) );
 410         if ( xSection.is() && ( newHeight > xSection->getHeight() ) )
 411             xSection->setHeight( newHeight );
 412
 413         // TODO
 414         //pModel->GetRefDevice()->Invalidate(InvalidateFlags::Children);
 415     }
 416 }
 417
 418 void OObjectBase::_propertyChange( const  beans::PropertyChangeEvent& /*evt*/ )
 419 {
 420 }
 421
 422 bool OObjectBase::supportsService( const OUString& _sServiceName ) const
 423 {
 424     bool bSupports = false;
 425
 426     Reference< lang::XServiceInfo > xServiceInfo( m_xReportComponent , UNO_QUERY );
 427         // TODO: cache xServiceInfo as member?
 428     if ( xServiceInfo.is() )
 429         bSupports = xServiceInfo->supportsService( _sServiceName );
 430
 431     return bSupports;
 432 }
 433
 434
 435 void OObjectBase::ensureSdrObjectOwnership( const uno::Reference< uno::XInterface >& _rxShape )
 436 {
 437     // UNDO in the report designer is implemented at the level of the XShapes, not
 438     // at the level of SdrObjects. That is, if an object is removed from the report
 439     // design, then this happens by removing the XShape from the UNO DrawPage, and
 440     // putting this XShape (resp. the ReportComponent which wraps it) into an UNDO
 441     // action.
 442     // Unfortunately, the SvxDrawPage implementation usually deletes SdrObjects
 443     // which are removed from it, which is deadly for us. To prevent this,
 444     // we give the XShape implementation the ownership of the SdrObject, which
 445     // ensures the SvxDrawPage won't delete it.
 446     SvxShape* pShape = SvxShape::getImplementation( _rxShape );
 447     OSL_ENSURE( pShape, "OObjectBase::ensureSdrObjectOwnership: can't access the SvxShape!" );
 448     if ( pShape )
 449     {
 450         OSL_ENSURE( !pShape->HasSdrObjectOwnership(), "OObjectBase::ensureSdrObjectOwnership: called twice?" );
 451         pShape->TakeSdrObjectOwnership();
 452     }
 453 }
 454
 455
 456 uno::Reference< uno::XInterface > OObjectBase::getUnoShapeOf( SdrObject& _rSdrObject )
 457 {
 458     uno::Reference< uno::XInterface > xShape( _rSdrObject.getWeakUnoShape() );
 459     if ( xShape.is() )
 460         return xShape;
 461
 462     xShape = _rSdrObject.SdrObject::getUnoShape();
 463     if ( !xShape.is() )
 464         return xShape;
 465
 466     ensureSdrObjectOwnership( xShape );
 467
 468     m_xKeepShapeAlive = xShape;
 469     return xShape;
 470 }
 471
 472 OCustomShape::OCustomShape(
 473     SdrModel& rSdrModel,
 474     const uno::Reference< report::XReportComponent>& _xComponent)
 475 :   SdrObjCustomShape(rSdrModel)
 476     ,OObjectBase(_xComponent)
 477 {
 478     impl_setUnoShape( uno::Reference< uno::XInterface >(_xComponent,uno::UNO_QUERY) );
 479     m_bIsListening = true;
 480 }
 481
 482 OCustomShape::OCustomShape(
 483     SdrModel& rSdrModel,
 484     const OUString& _sComponentName)
 485 :   SdrObjCustomShape(rSdrModel)
 486     ,OObjectBase(_sComponentName)
 487 {
 488     m_bIsListening = true;
 489 }
 490
 491
 492 OCustomShape::~OCustomShape()
 493 {
 494 }
 495
 496 sal_uInt16 OCustomShape::GetObjIdentifier() const
 497 {
 498     return sal_uInt16(OBJ_CUSTOMSHAPE);
 499 }
 500
 501 SdrInventor OCustomShape::GetObjInventor() const
 502 {
 503     return SdrInventor::ReportDesign;
 504 }
 505
 506 SdrPage* OCustomShape::GetImplPage() const
 507 {
 508     return getSdrPageFromSdrObject();
 509 }
 510
 511 void OCustomShape::NbcMove( const Size& rSize )
 512 {
 513     if ( m_bIsListening )
 514     {
 515         m_bIsListening = false;
 516
 517         if ( m_xReportComponent.is() )
 518         {
 519             OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 520             OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
 521             m_xReportComponent->setPositionX(m_xReportComponent->getPositionX() + rSize.Width());
 522             m_xReportComponent->setPositionY(m_xReportComponent->getPositionY() + rSize.Height());
 523         }
 524
 525         // set geometry properties
 526         SetPropsFromRect(GetSnapRect());
 527
 528         m_bIsListening = true;
 529     }
 530     else
 531         SdrObjCustomShape::NbcMove( rSize );
 532 }
 533
 534 void OCustomShape::NbcResize(const Point& rRef, const Fraction& xFract, const Fraction& yFract)
 535 {
 536     SdrObjCustomShape::NbcResize( rRef, xFract, yFract );
 537
 538     SetPropsFromRect(GetSnapRect());
 539 }
 540
 541 void OCustomShape::NbcSetLogicRect(const tools::Rectangle& rRect)
 542 {
 543     SdrObjCustomShape::NbcSetLogicRect(rRect);
 544     SetPropsFromRect(rRect);
 545 }
 546
 547 bool OCustomShape::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 548 {
 549     bool bResult = SdrObjCustomShape::EndCreate(rStat, eCmd);
 550     if ( bResult )
 551     {
 552         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 553         OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
 554
 555         if ( !m_xReportComponent.is() )
 556             m_xReportComponent.set(getUnoShape(),uno::UNO_QUERY);
 557
 558         SetPropsFromRect(GetSnapRect());
 559     }
 560
 561     return bResult;
 562 }
 563
 564
 565 uno::Reference< beans::XPropertySet> OCustomShape::getAwtComponent()
 566 {
 567     return uno::Reference< beans::XPropertySet>(m_xReportComponent,uno::UNO_QUERY);
 568 }
 569
 570
 571 uno::Reference< uno::XInterface > OCustomShape::getUnoShape()
 572 {
 573     uno::Reference< uno::XInterface> xShape = OObjectBase::getUnoShapeOf( *this );
 574     if ( !m_xReportComponent.is() )
 575     {
 576         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 577         OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
 578         m_xReportComponent.set(xShape,uno::UNO_QUERY);
 579     }
 580     return xShape;
 581 }
 582
 583 void OCustomShape::impl_setUnoShape( const uno::Reference< uno::XInterface >& rxUnoShape )
 584 {
 585     SdrObjCustomShape::impl_setUnoShape( rxUnoShape );
 586     releaseUnoShape();
 587     m_xReportComponent.clear();
 588 }
 589
 590 OUnoObject::OUnoObject(
 591     SdrModel& rSdrModel,
 592     const OUString& _sComponentName,
 593     const OUString& rModelName,
 594     sal_uInt16 _nObjectType)
 595 :   SdrUnoObj(rSdrModel, rModelName)
 596     ,OObjectBase(_sComponentName)
 597     ,m_nObjectType(_nObjectType)
 598     // tdf#119067
 599     ,m_bSetDefaultLabel(false)
 600 {
 601     if ( !rModelName.isEmpty() )
 602         impl_initializeModel_nothrow();
 603 }
 604
 605 OUnoObject::OUnoObject(
 606     SdrModel& rSdrModel,
 607     const uno::Reference< report::XReportComponent>& _xComponent,
 608     const OUString& rModelName,
 609     sal_uInt16 _nObjectType)
 610 :   SdrUnoObj(rSdrModel, rModelName)
 611     ,OObjectBase(_xComponent)
 612     ,m_nObjectType(_nObjectType)
 613     // tdf#119067
 614     ,m_bSetDefaultLabel(false)
 615 {
 616     impl_setUnoShape( uno::Reference< uno::XInterface >( _xComponent, uno::UNO_QUERY ) );
 617
 618     if ( !rModelName.isEmpty() )
 619         impl_initializeModel_nothrow();
 620
 621 }
 622
 623 OUnoObject::~OUnoObject()
 624 {
 625 }
 626
 627 void OUnoObject::impl_initializeModel_nothrow()
 628 {
 629     try
 630     {
 631         Reference< XFormattedField > xFormatted( m_xReportComponent, UNO_QUERY );
 632         if ( xFormatted.is() )
 633         {
 634             const Reference< XPropertySet > xModelProps( GetUnoControlModel(), UNO_QUERY_THROW );
 635             const OUString sTreatAsNumberProperty = "TreatAsNumber";
 636             xModelProps->setPropertyValue( sTreatAsNumberProperty, makeAny( false ) );
 637             xModelProps->setPropertyValue( PROPERTY_VERTICALALIGN,m_xReportComponent->getPropertyValue(PROPERTY_VERTICALALIGN));
 638         }
 639     }
 640     catch( const Exception& )
 641     {
 642         DBG_UNHANDLED_EXCEPTION("reportdesign");
 643     }
 644 }
 645
 646 sal_uInt16 OUnoObject::GetObjIdentifier() const
 647 {
 648     return m_nObjectType;
 649 }
 650
 651 SdrInventor OUnoObject::GetObjInventor() const
 652 {
 653     return SdrInventor::ReportDesign;
 654 }
 655
 656 SdrPage* OUnoObject::GetImplPage() const
 657 {
 658     return getSdrPageFromSdrObject();
 659 }
 660
 661 void OUnoObject::NbcMove( const Size& rSize )
 662 {
 663
 664     if ( m_bIsListening )
 665     {
 666         // stop listening
 667         OObjectBase::EndListening();
 668
 669         bool bPositionFixed = false;
 670         Size aUndoSize(0,0);
 671         if ( m_xReportComponent.is() )
 672         {
 673             bool bUndoMode = false;
 674             OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 675
 676             if (rRptModel.GetUndoEnv().IsUndoMode())
 677             {
 678                 // if we are locked from outside, then we must not handle wrong moves, we are in UNDO mode
 679                 bUndoMode = true;
 680             }
 681             OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
 682
 683             // LLA: why there exists getPositionX and getPositionY and NOT getPosition() which return a Point?
 684             int nNewX = m_xReportComponent->getPositionX() + rSize.Width();
 685             m_xReportComponent->setPositionX(nNewX);
 686             int nNewY = m_xReportComponent->getPositionY() + rSize.Height();
 687             if (nNewY < 0 && !bUndoMode)
 688             {
 689                 aUndoSize.setHeight( abs(nNewY) );
 690                 bPositionFixed = true;
 691                 nNewY = 0;
 692             }
 693             m_xReportComponent->setPositionY(nNewY);
 694         }
 695         if (bPositionFixed)
 696         {
 697             getSdrModelFromSdrObject().AddUndo(getSdrModelFromSdrObject().GetSdrUndoFactory().CreateUndoMoveObject(*this, aUndoSize));
 698         }
 699         // set geometry properties
 700         SetPropsFromRect(GetLogicRect());
 701
 702         // start listening
 703         OObjectBase::StartListening();
 704     }
 705     else
 706         SdrUnoObj::NbcMove( rSize );
 707 }
 708
 709
 710 void OUnoObject::NbcResize(const Point& rRef, const Fraction& xFract, const Fraction& yFract)
 711 {
 712     SdrUnoObj::NbcResize( rRef, xFract, yFract );
 713
 714     // stop listening
 715     OObjectBase::EndListening();
 716
 717     // set geometry properties
 718     SetPropsFromRect(GetLogicRect());
 719
 720     // start listening
 721     OObjectBase::StartListening();
 722 }
 723
 724 void OUnoObject::NbcSetLogicRect(const tools::Rectangle& rRect)
 725 {
 726     SdrUnoObj::NbcSetLogicRect(rRect);
 727     // stop listening
 728     OObjectBase::EndListening();
 729
 730     // set geometry properties
 731     SetPropsFromRect(rRect);
 732
 733     // start listening
 734     OObjectBase::StartListening();
 735 }
 736
 737 bool OUnoObject::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
 738 {
 739     const bool bResult(SdrUnoObj::EndCreate(rStat, eCmd));
 740
 741     if(bResult)
 742     {
 743         // tdf#118730 remember if this object was created interactively (due to ::EndCreate being called)
 744         m_bSetDefaultLabel = true;
 745
 746         // set geometry properties
 747         SetPropsFromRect(GetLogicRect());
 748     }
 749
 750     return bResult;
 751 }
 752
 753 OUString OUnoObject::GetDefaultName(const OUnoObject* _pObj)
 754 {
 755     OUString aDefaultName = "HERE WE HAVE TO INSERT OUR NAME!";
 756     if ( _pObj->supportsService( SERVICE_FIXEDTEXT ) )
 757     {
 758         aDefaultName = RID_STR_CLASS_FIXEDTEXT;
 759     }
 760     else if ( _pObj->supportsService( SERVICE_FIXEDLINE ) )
 761     {
 762         aDefaultName = RID_STR_CLASS_FIXEDLINE;
 763     }
 764     else if ( _pObj->supportsService( SERVICE_IMAGECONTROL ) )
 765     {
 766         aDefaultName = RID_STR_CLASS_IMAGECONTROL;
 767     }
 768     else if ( _pObj->supportsService( SERVICE_FORMATTEDFIELD ) )
 769     {
 770         aDefaultName = RID_STR_CLASS_FORMATTEDFIELD;
 771     }
 772
 773     return aDefaultName;
 774 }
 775
 776 void OUnoObject::_propertyChange( const  beans::PropertyChangeEvent& evt )
 777 {
 778     OObjectBase::_propertyChange(evt);
 779     if (isListening())
 780     {
 781         if ( evt.PropertyName == PROPERTY_CHARCOLOR )
 782         {
 783             Reference<XPropertySet> xControlModel(GetUnoControlModel(),uno::UNO_QUERY);
 784             if ( xControlModel.is() )
 785             {
 786                 OObjectBase::EndListening();
 787                 try
 788                 {
 789                     xControlModel->setPropertyValue(PROPERTY_TEXTCOLOR,evt.NewValue);
 790                 }
 791                 catch(uno::Exception&)
 792                 {
 793                 }
 794                 OObjectBase::StartListening();
 795             }
 796         }
 797         else if ( evt.PropertyName == PROPERTY_NAME )
 798         {
 799             Reference<XPropertySet> xControlModel(GetUnoControlModel(),uno::UNO_QUERY);
 800             if ( xControlModel.is() && xControlModel->getPropertySetInfo()->hasPropertyByName(PROPERTY_NAME) )
 801             {
 802                 // get old name
 803                 OUString aOldName;
 804                 evt.OldValue >>= aOldName;
 805
 806                 // get new name
 807                 OUString aNewName;
 808                 evt.NewValue >>= aNewName;
 809
 810                 if ( aNewName != aOldName )
 811                 {
 812                     // set old name property
 813                     OObjectBase::EndListening();
 814                     if ( m_xMediator.is() )
 815                         m_xMediator->stopListening();
 816                     try
 817                     {
 818                         xControlModel->setPropertyValue( PROPERTY_NAME, evt.NewValue );
 819                     }
 820                     catch(uno::Exception&)
 821                     {
 822                     }
 823                     if ( m_xMediator.is() )
 824                         m_xMediator->startListening();
 825                     OObjectBase::StartListening();
 826                 }
 827             }
 828         }
 829     }
 830 }
 831
 832 void OUnoObject::CreateMediator(bool _bReverse)
 833 {
 834     if ( !m_xMediator.is() )
 835     {
 836         // tdf#118730 Directly do things formerly done in
 837         // OUnoObject::impl_setReportComponent_nothrow here
 838         if(!m_xReportComponent.is())
 839         {
 840             OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 841             OXUndoEnvironment::OUndoEnvLock aLock( rRptModel.GetUndoEnv() );
 842             m_xReportComponent.set(getUnoShape(),uno::UNO_QUERY);
 843
 844             impl_initializeModel_nothrow();
 845         }
 846
 847         if(m_xReportComponent.is() && m_bSetDefaultLabel)
 848         {
 849             // tdf#118730 Directly do things formerly done in
 850             // OUnoObject::EndCreate here
 851             // tdf#119067 ...but *only* if result of interactive
 852             // creation in Report DesignView
 853             m_bSetDefaultLabel = false;
 854
 855             try
 856             {
 857                 if ( supportsService( SERVICE_FIXEDTEXT ) )
 858                 {
 859                     m_xReportComponent->setPropertyValue(
 860                         PROPERTY_LABEL,
 861                         uno::makeAny(GetDefaultName(this)));
 862                 }
 863             }
 864             catch(const uno::Exception&)
 865             {
 866                 DBG_UNHANDLED_EXCEPTION("reportdesign");
 867             }
 868         }
 869
 870         if(!m_xMediator.is() && m_xReportComponent.is())
 871         {
 872             Reference<XPropertySet> xControlModel(GetUnoControlModel(),uno::UNO_QUERY);
 873
 874             if(xControlModel.is())
 875             {
 876                 m_xMediator = new OPropertyMediator(
 877                     m_xReportComponent.get(),
 878                     xControlModel,
 879                     getPropertyNameMap(GetObjIdentifier()),
 880                     _bReverse);
 881             }
 882         }
 883
 884         OObjectBase::StartListening();
 885     }
 886 }
 887
 888 uno::Reference< beans::XPropertySet> OUnoObject::getAwtComponent()
 889 {
 890     return Reference<XPropertySet>(GetUnoControlModel(),uno::UNO_QUERY);
 891 }
 892
 893
 894 uno::Reference< uno::XInterface > OUnoObject::getUnoShape()
 895 {
 896     return OObjectBase::getUnoShapeOf( *this );
 897 }
 898
 899 void OUnoObject::impl_setUnoShape( const uno::Reference< uno::XInterface >& rxUnoShape )
 900 {
 901     SdrUnoObj::impl_setUnoShape( rxUnoShape );
 902     releaseUnoShape();
 903 }
 904
 905 OUnoObject* OUnoObject::CloneSdrObject(SdrModel& rTargetModel) const
 906 {
 907     return CloneHelper< OUnoObject >(rTargetModel);
 908 }
 909
 910 OUnoObject& OUnoObject::operator=(const OUnoObject& rObj)
 911 {
 912     if( this == &rObj )
 913         return *this;
 914     SdrUnoObj::operator=(rObj);
 915
 916     Reference<XPropertySet> xSource(const_cast<OUnoObject&>(rObj).getUnoShape(), uno::UNO_QUERY);
 917     Reference<XPropertySet> xDest(getUnoShape(), uno::UNO_QUERY);
 918     if ( xSource.is() && xDest.is() )
 919         comphelper::copyProperties(xSource.get(), xDest.get());
 920
 921     return *this;
 922 }
 923
 924 // OOle2Obj
 925 OOle2Obj::OOle2Obj(
 926     SdrModel& rSdrModel,
 927     const uno::Reference< report::XReportComponent>& _xComponent,
 928     sal_uInt16 _nType)
 929 :   SdrOle2Obj(rSdrModel)
 930     ,OObjectBase(_xComponent)
 931     ,m_nType(_nType)
 932     ,m_bOnlyOnce(true)
 933 {
 934     impl_setUnoShape( uno::Reference< uno::XInterface >( _xComponent, uno::UNO_QUERY ) );
 935     m_bIsListening = true;
 936 }
 937
 938 OOle2Obj::OOle2Obj(
 939     SdrModel& rSdrModel,
 940     const OUString& _sComponentName,
 941     sal_uInt16 _nType)
 942 :   SdrOle2Obj(rSdrModel)
 943     ,OObjectBase(_sComponentName)
 944     ,m_nType(_nType)
 945     ,m_bOnlyOnce(true)
 946 {
 947     m_bIsListening = true;
 948 }
 949
 950 OOle2Obj::~OOle2Obj()
 951 {
 952 }
 953
 954 sal_uInt16 OOle2Obj::GetObjIdentifier() const
 955 {
 956     return m_nType;
 957 }
 958
 959 SdrInventor OOle2Obj::GetObjInventor() const
 960 {
 961     return SdrInventor::ReportDesign;
 962 }
 963
 964 SdrPage* OOle2Obj::GetImplPage() const
 965 {
 966     return getSdrPageFromSdrObject();
 967 }
 968
 969 void OOle2Obj::NbcMove( const Size& rSize )
 970 {
 971
 972     if ( m_bIsListening )
 973     {
 974         // stop listening
 975         OObjectBase::EndListening();
 976
 977         bool bPositionFixed = false;
 978         Size aUndoSize(0,0);
 979         if ( m_xReportComponent.is() )
 980         {
 981             bool bUndoMode = false;
 982             OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
 983
 984             if (rRptModel.GetUndoEnv().IsUndoMode())
 985             {
 986                 // if we are locked from outside, then we must not handle wrong moves, we are in UNDO mode
 987                 bUndoMode = true;
 988             }
 989             OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
 990
 991             // LLA: why there exists getPositionX and getPositionY and NOT getPosition() which return a Point?
 992             int nNewX = m_xReportComponent->getPositionX() + rSize.Width();
 993             // can this hinder us to set components outside the area?
 994             // if (nNewX < 0)
 995             // {
 996             //     nNewX = 0;
 997             // }
 998             m_xReportComponent->setPositionX(nNewX);
 999             int nNewY = m_xReportComponent->getPositionY() + rSize.Height();
1000             if (nNewY < 0 && !bUndoMode)
1001             {
1002                 aUndoSize.setHeight( abs(nNewY) );
1003                 bPositionFixed = true;
1004                 nNewY = 0;
1005             }
1006             m_xReportComponent->setPositionY(nNewY);
1007         }
1008         if (bPositionFixed)
1009         {
1010             getSdrModelFromSdrObject().AddUndo(getSdrModelFromSdrObject().GetSdrUndoFactory().CreateUndoMoveObject(*this, aUndoSize));
1011         }
1012         // set geometry properties
1013         SetPropsFromRect(GetLogicRect());
1014
1015         // start listening
1016         OObjectBase::StartListening();
1017     }
1018     else
1019         SdrOle2Obj::NbcMove( rSize );
1020 }
1021
1022
1023 void OOle2Obj::NbcResize(const Point& rRef, const Fraction& xFract, const Fraction& yFract)
1024 {
1025     SdrOle2Obj::NbcResize( rRef, xFract, yFract );
1026
1027     // stop listening
1028     OObjectBase::EndListening();
1029
1030     // set geometry properties
1031     SetPropsFromRect(GetLogicRect());
1032
1033     // start listening
1034     OObjectBase::StartListening();
1035 }
1036
1037 void OOle2Obj::NbcSetLogicRect(const tools::Rectangle& rRect)
1038 {
1039     SdrOle2Obj::NbcSetLogicRect(rRect);
1040     // stop listening
1041     OObjectBase::EndListening();
1042
1043     // set geometry properties
1044     SetPropsFromRect(rRect);
1045
1046     // start listening
1047     OObjectBase::StartListening();
1048 }
1049
1050
1051 bool OOle2Obj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1052 {
1053     bool bResult = SdrOle2Obj::EndCreate(rStat, eCmd);
1054     if ( bResult )
1055     {
1056         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
1057         OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
1058
1059         if ( !m_xReportComponent.is() )
1060             m_xReportComponent.set(getUnoShape(),uno::UNO_QUERY);
1061
1062         // set geometry properties
1063         SetPropsFromRect(GetLogicRect());
1064     }
1065
1066     return bResult;
1067 }
1068
1069 uno::Reference< beans::XPropertySet> OOle2Obj::getAwtComponent()
1070 {
1071     return uno::Reference< beans::XPropertySet>(m_xReportComponent,uno::UNO_QUERY);
1072 }
1073
1074
1075 uno::Reference< uno::XInterface > OOle2Obj::getUnoShape()
1076 {
1077     uno::Reference< uno::XInterface> xShape = OObjectBase::getUnoShapeOf( *this );
1078     if ( !m_xReportComponent.is() )
1079     {
1080         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
1081         OXUndoEnvironment::OUndoEnvLock aLock(rRptModel.GetUndoEnv());
1082         m_xReportComponent.set(xShape,uno::UNO_QUERY);
1083     }
1084     return xShape;
1085 }
1086
1087 void OOle2Obj::impl_setUnoShape( const uno::Reference< uno::XInterface >& rxUnoShape )
1088 {
1089     SdrOle2Obj::impl_setUnoShape( rxUnoShape );
1090     releaseUnoShape();
1091     m_xReportComponent.clear();
1092 }
1093
1094
1095 static uno::Reference< chart2::data::XDatabaseDataProvider > lcl_getDataProvider(const uno::Reference < embed::XEmbeddedObject >& _xObj)
1096 {
1097     uno::Reference< chart2::data::XDatabaseDataProvider > xSource;
1098     uno::Reference< embed::XComponentSupplier > xCompSupp(_xObj,uno::UNO_QUERY);
1099     if( xCompSupp.is())
1100     {
1101         uno::Reference< chart2::XChartDocument> xChartDoc( xCompSupp->getComponent(), uno::UNO_QUERY );
1102         if ( xChartDoc.is() )
1103         {
1104             xSource.set(xChartDoc->getDataProvider(),uno::UNO_QUERY);
1105         }
1106     }
1107     return xSource;
1108 }
1109
1110 // Clone() should make a complete copy of the object.
1111 OOle2Obj* OOle2Obj::CloneSdrObject(SdrModel& rTargetModel) const
1112 {
1113     return CloneHelper< OOle2Obj >(rTargetModel);
1114 }
1115
1116 OOle2Obj& OOle2Obj::operator=(const OOle2Obj& rObj)
1117 {
1118     if( this == &rObj )
1119         return *this;
1120     SdrOle2Obj::operator=(rObj);
1121
1122     OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
1123     svt::EmbeddedObjectRef::TryRunningState( GetObjRef() );
1124     impl_createDataProvider_nothrow(rRptModel.getReportDefinition().get());
1125
1126     uno::Reference< chart2::data::XDatabaseDataProvider > xSource( lcl_getDataProvider(rObj.GetObjRef()) );
1127     uno::Reference< chart2::data::XDatabaseDataProvider > xDest( lcl_getDataProvider(GetObjRef()) );
1128     if ( xSource.is() && xDest.is() )
1129         comphelper::copyProperties(xSource.get(),xDest.get());
1130
1131     initializeChart(rRptModel.getReportDefinition().get());
1132
1133     return *this;
1134 }
1135
1136 void OOle2Obj::impl_createDataProvider_nothrow(const uno::Reference< frame::XModel>& _xModel)
1137 {
1138     try
1139     {
1140         uno::Reference < embed::XEmbeddedObject > xObj = GetObjRef();
1141         uno::Reference< chart2::data::XDataReceiver > xReceiver;
1142         uno::Reference< embed::XComponentSupplier > xCompSupp( xObj, uno::UNO_QUERY );
1143         if( xCompSupp.is())
1144             xReceiver.set( xCompSupp->getComponent(), uno::UNO_QUERY );
1145         OSL_ASSERT( xReceiver.is());
1146         if( xReceiver.is() )
1147         {
1148             uno::Reference< lang::XMultiServiceFactory> xFac(_xModel,uno::UNO_QUERY);
1149             uno::Reference< chart2::data::XDatabaseDataProvider > xDataProvider( xFac->createInstance("com.sun.star.chart2.data.DataProvider"),uno::UNO_QUERY);
1150             xReceiver->attachDataProvider( xDataProvider.get() );
1151         }
1152     }
1153     catch(const uno::Exception &)
1154     {
1155     }
1156 }
1157
1158 void OOle2Obj::initializeOle()
1159 {
1160     if ( m_bOnlyOnce )
1161     {
1162         m_bOnlyOnce = false;
1163         uno::Reference < embed::XEmbeddedObject > xObj = GetObjRef();
1164         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
1165         rRptModel.GetUndoEnv().AddElement(lcl_getDataProvider(xObj));
1166
1167         uno::Reference< embed::XComponentSupplier > xCompSupp( xObj, uno::UNO_QUERY );
1168         if( xCompSupp.is() )
1169         {
1170             uno::Reference< beans::XPropertySet > xChartProps( xCompSupp->getComponent(), uno::UNO_QUERY );
1171             if ( xChartProps.is() )
1172                 xChartProps->setPropertyValue("NullDate",
1173                     uno::makeAny(util::DateTime(0,0,0,0,30,12,1899,false)));
1174         }
1175     }
1176 }
1177
1178 void OOle2Obj::initializeChart( const uno::Reference< frame::XModel>& _xModel)
1179 {
1180     uno::Reference < embed::XEmbeddedObject > xObj = GetObjRef();
1181     uno::Reference< chart2::data::XDataReceiver > xReceiver;
1182     uno::Reference< embed::XComponentSupplier > xCompSupp( xObj, uno::UNO_QUERY );
1183     if( xCompSupp.is())
1184         xReceiver.set( xCompSupp->getComponent(), uno::UNO_QUERY );
1185     OSL_ASSERT( xReceiver.is());
1186     if( xReceiver.is() )
1187     {
1188         // lock the model to suppress any internal updates
1189         uno::Reference< frame::XModel > xChartModel( xReceiver, uno::UNO_QUERY );
1190         if( xChartModel.is() )
1191             xChartModel->lockControllers();
1192
1193         if ( !lcl_getDataProvider(xObj).is() )
1194             impl_createDataProvider_nothrow(_xModel);
1195
1196         OReportModel& rRptModel(static_cast< OReportModel& >(getSdrModelFromSdrObject()));
1197         rRptModel.GetUndoEnv().AddElement(lcl_getDataProvider(xObj));
1198
1199         ::comphelper::NamedValueCollection aArgs;
1200         aArgs.put( "CellRangeRepresentation", uno::makeAny( OUString( "all" ) ) );
1201         aArgs.put( "HasCategories", uno::makeAny( true ) );
1202         aArgs.put( "FirstCellAsLabel", uno::makeAny( true ) );
1203         aArgs.put( "DataRowSource", uno::makeAny( chart::ChartDataRowSource_COLUMNS ) );
1204         xReceiver->setArguments( aArgs.getPropertyValues() );
1205
1206         if( xChartModel.is() )
1207             xChartModel->unlockControllers();
1208     }
1209 }
1210
1211 uno::Reference< style::XStyle> getUsedStyle(const uno::Reference< report::XReportDefinition>& _xReport)
1212 {
1213     uno::Reference<container::XNameAccess> xStyles = _xReport->getStyleFamilies();
1214     uno::Reference<container::XNameAccess> xPageStyles(xStyles->getByName("PageStyles"),uno::UNO_QUERY);
1215
1216     uno::Reference< style::XStyle> xReturn;
1217     uno::Sequence< OUString> aSeq = xPageStyles->getElementNames();
1218     const OUString* pIter = aSeq.getConstArray();
1219     const OUString* pEnd   = pIter + aSeq.getLength();
1220     for(;pIter != pEnd && !xReturn.is() ;++pIter)
1221     {
1222         uno::Reference< style::XStyle> xStyle(xPageStyles->getByName(*pIter),uno::UNO_QUERY);
1223         if ( xStyle->isInUse() )
1224             xReturn = xStyle;
1225     }
1226     return xReturn;
1227 }
1228
1229
1230 } // rptui
1231
1232
1233 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */