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