svx/source/form/fmobj.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "fmobj.hxx"
  21 #include "fmprop.hrc"
  22 #include "fmvwimp.hxx"
  23 #include "fmpgeimp.hxx"
  24 #include "svx/fmresids.hrc"
  25 #include "svx/fmview.hxx"
  26 #include "svx/fmglob.hxx"
  27 #include "svx/fmpage.hxx"
  28 #include "editeng/editeng.hxx"
  29 #include "svx/svdovirt.hxx"
  30 #include "svx/fmmodel.hxx"
  31 #include "svx/dialmgr.hxx"
  32
  33 #include <com/sun/star/awt/XDevice.hpp>
  34 #include <com/sun/star/awt/XControlContainer.hpp>
  35 #include <com/sun/star/form/Forms.hpp>
  36 #include <com/sun/star/io/XPersistObject.hpp>
  37 #include <com/sun/star/script/XEventAttacherManager.hpp>
  38 #include <com/sun/star/util/XCloneable.hpp>
  39 #include "svx/fmtools.hxx"
  40
  41 #include <tools/shl.hxx>
  42 #include <comphelper/property.hxx>
  43 #include <comphelper/processfactory.hxx>
  44 #include <toolkit/awt/vclxdevice.hxx>
  45 #include <vcl/svapp.hxx>
  46 #include <tools/diagnose_ex.h>
  47
  48 using namespace ::com::sun::star::io;
  49 using namespace ::com::sun::star::uno;
  50 using namespace ::com::sun::star::awt;
  51 using namespace ::com::sun::star::lang;
  52 using namespace ::com::sun::star::util;
  53 using namespace ::com::sun::star::form;
  54 using namespace ::com::sun::star::beans;
  55 using namespace ::com::sun::star::script;
  56 using namespace ::com::sun::star::container;
  57 using namespace ::svxform;
  58
  59 TYPEINIT1(FmFormObj, SdrUnoObj);
  60 DBG_NAME(FmFormObj);
  61 //------------------------------------------------------------------
  62 FmFormObj::FmFormObj(const OUString& rModelName)
  63           :SdrUnoObj                ( rModelName    )
  64           ,m_nPos                   ( -1            )
  65           ,m_pLastKnownRefDevice    ( NULL          )
  66 {
  67     DBG_CTOR(FmFormObj, NULL);
  68
  69     // normally, this is done in SetUnoControlModel, but if the call happened in the base class ctor,
  70     // then our incarnation of it was not called (since we were not constructed at this time).
  71     impl_checkRefDevice_nothrow( true );
  72 }
  73
  74 //------------------------------------------------------------------
  75 FmFormObj::FmFormObj()
  76           :SdrUnoObj                ( String()  )
  77           ,m_nPos                   ( -1        )
  78           ,m_pLastKnownRefDevice    ( NULL      )
  79 {
  80     DBG_CTOR(FmFormObj, NULL);
  81 }
  82
  83 //------------------------------------------------------------------
  84 FmFormObj::~FmFormObj()
  85 {
  86     DBG_DTOR(FmFormObj, NULL);
  87
  88     if (m_xEnvironmentHistory.is())
  89         m_xEnvironmentHistory->dispose();
  90
  91     m_xEnvironmentHistory = NULL;
  92     m_aEventsHistory.realloc(0);
  93 }
  94
  95 //------------------------------------------------------------------
  96 void FmFormObj::SetObjEnv(const Reference< XIndexContainer > & xForm, const sal_Int32 nIdx,
  97                           const Sequence< ScriptEventDescriptor >& rEvts)
  98 {
  99     m_xParent = xForm;
 100     aEvts     = rEvts;
 101     m_nPos    = nIdx;
 102 }
 103
 104 //------------------------------------------------------------------
 105 void FmFormObj::ClearObjEnv()
 106 {
 107     m_xParent.clear();
 108     aEvts.realloc( 0 );
 109     m_nPos = -1;
 110 }
 111
 112 //------------------------------------------------------------------
 113 void FmFormObj::impl_checkRefDevice_nothrow( bool _force )
 114 {
 115     const FmFormModel* pFormModel = PTR_CAST( FmFormModel, GetModel() );
 116     if ( !pFormModel || !pFormModel->ControlsUseRefDevice() )
 117         return;
 118
 119     OutputDevice* pCurrentRefDevice = pFormModel ? pFormModel->GetRefDevice() : NULL;
 120     if ( ( m_pLastKnownRefDevice == pCurrentRefDevice ) && !_force )
 121         return;
 122
 123     Reference< XControlModel > xControlModel( GetUnoControlModel() );
 124     if ( !xControlModel.is() )
 125         return;
 126
 127     m_pLastKnownRefDevice = pCurrentRefDevice;
 128     if ( m_pLastKnownRefDevice == NULL )
 129         return;
 130
 131     try
 132     {
 133         Reference< XPropertySet > xModelProps( GetUnoControlModel(), UNO_QUERY_THROW );
 134         Reference< XPropertySetInfo > xPropertyInfo( xModelProps->getPropertySetInfo(), UNO_SET_THROW );
 135
 136         static const OUString sRefDevicePropName( "ReferenceDevice" );
 137         if ( xPropertyInfo->hasPropertyByName( sRefDevicePropName ) )
 138         {
 139             VCLXDevice* pUnoRefDevice = new VCLXDevice;
 140             pUnoRefDevice->SetOutputDevice( m_pLastKnownRefDevice );
 141             Reference< XDevice > xRefDevice( pUnoRefDevice );
 142             xModelProps->setPropertyValue( sRefDevicePropName, makeAny( xRefDevice ) );
 143         }
 144     }
 145     catch( const Exception& )
 146     {
 147         DBG_UNHANDLED_EXCEPTION();
 148     }
 149 }
 150
 151 //------------------------------------------------------------------
 152 void FmFormObj::impl_isolateControlModel_nothrow()
 153 {
 154     try
 155     {
 156         Reference< XChild > xControlModel( GetUnoControlModel(), UNO_QUERY );
 157         if ( xControlModel.is() )
 158         {
 159             Reference< XIndexContainer> xParent( xControlModel->getParent(), UNO_QUERY );
 160             if ( xParent.is() )
 161             {
 162                 sal_Int32 nPos = getElementPos( xParent.get(), xControlModel );
 163                 xParent->removeByIndex( nPos );
 164             }
 165         }
 166     }
 167     catch( const Exception& )
 168     {
 169         DBG_UNHANDLED_EXCEPTION();
 170     }
 171 }
 172
 173 //------------------------------------------------------------------
 174 void FmFormObj::SetPage(SdrPage* _pNewPage)
 175 {
 176     if ( GetPage() == _pNewPage )
 177     {
 178         SdrUnoObj::SetPage(_pNewPage);
 179         return;
 180     }
 181
 182     FmFormPage* pOldFormPage = PTR_CAST( FmFormPage, GetPage() );
 183     if ( pOldFormPage )
 184         pOldFormPage->GetImpl().formObjectRemoved( *this );
 185
 186     FmFormPage* pNewFormPage = PTR_CAST( FmFormPage, _pNewPage );
 187     if ( !pNewFormPage )
 188     {   // Maybe it makes sense to create an environment history here : if somebody set's our page to NULL, and we have a valid page before,
 189         // me may want to remember our place within the old page. For this we could create a new m_xEnvironmentHistory to store it.
 190         // So the next SetPage with a valid new page would restore that environment within the new page.
 191         // But for the original Bug (#57300#) we don't need that, so I omit it here. Maybe this will be implemented later.
 192         impl_isolateControlModel_nothrow();
 193         SdrUnoObj::SetPage(_pNewPage);
 194         return;
 195     }
 196
 197     Reference< css::form::XForms >      xNewPageForms = pNewFormPage->GetForms( true );
 198     Reference< XIndexContainer >        xNewParent;
 199     Sequence< ScriptEventDescriptor>    aNewEvents;
 200
 201     // calc the new parent for my model (within the new page's forms hierarchy)
 202     // do we have a history ? (from :Clone)
 203     if ( m_xEnvironmentHistory.is() )
 204     {
 205         // the element in m_xEnvironmentHistory which is equivalent to my new parent (which (perhaps) has to be created within _pNewPage->GetForms)
 206         // is the right-most element in the tree.
 207         Reference< XIndexContainer > xRightMostLeaf( m_xEnvironmentHistory, UNO_QUERY_THROW );
 208         try
 209         {
 210             while ( xRightMostLeaf->getCount() )
 211             {
 212                 xRightMostLeaf.set(
 213                     xRightMostLeaf->getByIndex( xRightMostLeaf->getCount() - 1 ),
 214                     UNO_QUERY_THROW
 215                 );
 216             }
 217
 218             xNewParent.set( ensureModelEnv( xRightMostLeaf, xNewPageForms ), UNO_QUERY_THROW );
 219
 220             // we successfully cloned the environment in m_xEnvironmentHistory, so we can use m_aEventsHistory
 221             // (which describes the events of our model at the moment m_xEnvironmentHistory was created)
 222             aNewEvents = m_aEventsHistory;
 223         }
 224         catch( const Exception& )
 225         {
 226             DBG_UNHANDLED_EXCEPTION();
 227         }
 228     }
 229
 230     if ( !xNewParent.is() )
 231     {
 232         // are we a valid part of our current page forms ?
 233         Reference< XIndexContainer > xOldForms;
 234         if ( pOldFormPage )
 235             xOldForms.set( pOldFormPage->GetForms(), UNO_QUERY_THROW );
 236
 237         if ( xOldForms.is() )
 238         {
 239             // search (upward from our model) for xOldForms
 240             Reference< XChild > xSearch( GetUnoControlModel(), UNO_QUERY );
 241             while (xSearch.is())
 242             {
 243                 if ( xSearch == xOldForms )
 244                     break;
 245                 xSearch = Reference< XChild >( xSearch->getParent(), UNO_QUERY );
 246             }
 247             if ( xSearch.is() ) // implies xSearch == xOldForms, which means we're a valid part of our current page forms hierarchy
 248             {
 249                 Reference< XChild >  xMeAsChild( GetUnoControlModel(), UNO_QUERY );
 250                 xNewParent.set( ensureModelEnv( xMeAsChild->getParent(), xNewPageForms ), UNO_QUERY );
 251
 252                 if ( xNewParent.is() )
 253                 {
 254                     try
 255                     {
 256                         // transfer the events from our (model's) parent to the new (model's) parent, too
 257                         Reference< XEventAttacherManager >  xEventManager(xMeAsChild->getParent(), UNO_QUERY);
 258                         Reference< XIndexAccess >  xManagerAsIndex(xEventManager, UNO_QUERY);
 259                         if (xManagerAsIndex.is())
 260                         {
 261                             sal_Int32 nPos = getElementPos(xManagerAsIndex, xMeAsChild);
 262                             if (nPos >= 0)
 263                                 aNewEvents = xEventManager->getScriptEvents(nPos);
 264                         }
 265                         else
 266                             aNewEvents = aEvts;
 267                     }
 268                     catch( const Exception& )
 269                     {
 270                         DBG_UNHANDLED_EXCEPTION();
 271                     }
 272                 }
 273             }
 274         }
 275     }
 276
 277     // now set the page
 278     SdrUnoObj::SetPage(_pNewPage);
 279
 280     // place my model within the new parent container
 281     if (xNewParent.is())
 282     {
 283         Reference< XFormComponent >  xMeAsFormComp(GetUnoControlModel(), UNO_QUERY);
 284         if (xMeAsFormComp.is())
 285         {
 286             // check if I have another parent (and remove me, if necessary)
 287             Reference< XIndexContainer >  xOldParent(xMeAsFormComp->getParent(), UNO_QUERY);
 288             if (xOldParent.is())
 289             {
 290                 sal_Int32 nPos = getElementPos(Reference< XIndexAccess > (xOldParent, UNO_QUERY), xMeAsFormComp);
 291                 if (nPos > -1)
 292                     xOldParent->removeByIndex(nPos);
 293             }
 294             // and insert into the new container
 295             xNewParent->insertByIndex(xNewParent->getCount(), makeAny(xMeAsFormComp));
 296
 297             // transfer the events
 298             if (aNewEvents.getLength())
 299             {
 300                 try
 301                 {
 302                     Reference< XEventAttacherManager >  xEventManager(xNewParent, UNO_QUERY);
 303                     Reference< XIndexAccess >  xManagerAsIndex(xEventManager, UNO_QUERY);
 304                     if (xManagerAsIndex.is())
 305                     {
 306                         sal_Int32 nPos = getElementPos(xManagerAsIndex, xMeAsFormComp);
 307                         DBG_ASSERT(nPos >= 0, "FmFormObj::SetPage : inserted but not present ?");
 308                         xEventManager->registerScriptEvents(nPos, aNewEvents);
 309                     }
 310                 }
 311                 catch( const Exception& )
 312                 {
 313                     DBG_UNHANDLED_EXCEPTION();
 314                 }
 315
 316             }
 317         }
 318     }
 319
 320     // delete my history
 321     if (m_xEnvironmentHistory.is())
 322         m_xEnvironmentHistory->dispose();
 323
 324     m_xEnvironmentHistory = NULL;
 325     m_aEventsHistory.realloc(0);
 326
 327     if ( pNewFormPage )
 328         pNewFormPage->GetImpl().formObjectInserted( *this );
 329 }
 330
 331 //------------------------------------------------------------------
 332 sal_uInt32 FmFormObj::GetObjInventor()   const
 333 {
 334     return FmFormInventor;
 335 }
 336
 337 //------------------------------------------------------------------
 338 sal_uInt16 FmFormObj::GetObjIdentifier() const
 339 {
 340     return OBJ_UNO;
 341 }
 342
 343 //------------------------------------------------------------------
 344 void FmFormObj::clonedFrom(const FmFormObj* _pSource)
 345 {
 346     DBG_ASSERT(_pSource != NULL, "FmFormObj::clonedFrom : invalid source !");
 347     if (m_xEnvironmentHistory.is())
 348        m_xEnvironmentHistory->dispose();
 349
 350     m_xEnvironmentHistory = NULL;
 351     m_aEventsHistory.realloc(0);
 352
 353     Reference< XChild >  xSourceAsChild(_pSource->GetUnoControlModel(), UNO_QUERY);
 354     if (!xSourceAsChild.is())
 355         return;
 356
 357     Reference< XInterface >  xSourceContainer = xSourceAsChild->getParent();
 358
 359     m_xEnvironmentHistory = css::form::Forms::create( comphelper::getProcessComponentContext() );
 360
 361     ensureModelEnv(xSourceContainer, m_xEnvironmentHistory);
 362     m_aEventsHistory = aEvts;
 363         // if we we're clone there was a call to operator=, so aEvts are excatly the events we need here ...
 364 }
 365
 366 //------------------------------------------------------------------
 367 FmFormObj* FmFormObj::Clone() const
 368 {
 369     FmFormObj* pFormObject = CloneHelper< FmFormObj >();
 370     DBG_ASSERT(pFormObject != NULL, "FmFormObj::Clone : invalid clone !");
 371     if (pFormObject)
 372         pFormObject->clonedFrom(this);
 373
 374     return pFormObject;
 375 }
 376
 377 //------------------------------------------------------------------
 378 void FmFormObj::NbcReformatText()
 379 {
 380     impl_checkRefDevice_nothrow( false );
 381     SdrUnoObj::NbcReformatText();
 382 }
 383
 384 //------------------------------------------------------------------
 385 FmFormObj& FmFormObj::operator= (const FmFormObj& rObj)
 386 {
 387     if( this == &rObj )
 388         return *this;
 389     SdrUnoObj::operator= (rObj);
 390
 391     // liegt das UnoControlModel in einer Eventumgebung,
 392     // dann koennen noch Events zugeordnet sein
 393     Reference< XFormComponent >  xContent(rObj.xUnoControlModel, UNO_QUERY);
 394     if (xContent.is())
 395     {
 396         Reference< XEventAttacherManager >  xManager(xContent->getParent(), UNO_QUERY);
 397         Reference< XIndexAccess >  xManagerAsIndex(xManager, UNO_QUERY);
 398         if (xManagerAsIndex.is())
 399         {
 400             sal_Int32 nPos = getElementPos( xManagerAsIndex, xContent );
 401             if ( nPos >= 0 )
 402                 aEvts = xManager->getScriptEvents( nPos );
 403         }
 404     }
 405     else
 406         aEvts = rObj.aEvts;
 407     return *this;
 408 }
 409
 410 //------------------------------------------------------------------
 411 namespace
 412 {
 413     OUString lcl_getFormComponentAccessPath(const Reference< XInterface >& _xElement, Reference< XInterface >& _rTopLevelElement)
 414     {
 415         Reference< ::com::sun::star::form::XFormComponent> xChild(_xElement, UNO_QUERY);
 416         Reference< ::com::sun::star::container::XIndexAccess> xParent;
 417         if (xChild.is())
 418             xParent = Reference< ::com::sun::star::container::XIndexAccess>(xChild->getParent(), UNO_QUERY);
 419
 420         // while the current content is a form
 421         String sReturn;
 422         String sCurrentIndex;
 423         while (xChild.is())
 424         {
 425             // get the content's relative pos within it's parent container
 426             sal_Int32 nPos = getElementPos(xParent, xChild);
 427
 428             // prepend this current relaive pos
 429             sCurrentIndex = OUString::number(nPos);
 430             if (sReturn.Len() != 0)
 431             {
 432                 sCurrentIndex += '\\';
 433                 sCurrentIndex += sReturn;
 434             }
 435
 436             sReturn = sCurrentIndex;
 437
 438             // travel up
 439             if (::comphelper::query_interface((Reference< XInterface >)xParent,xChild))
 440                 xParent = Reference< ::com::sun::star::container::XIndexAccess>(xChild->getParent(), UNO_QUERY);
 441         }
 442
 443         _rTopLevelElement = xParent;
 444         return sReturn;
 445     }
 446 }
 447
 448 //------------------------------------------------------------------
 449 Reference< XInterface >  FmFormObj::ensureModelEnv(const Reference< XInterface > & _rSourceContainer, const Reference<css::form::XForms>& _rTopLevelDestContainer)
 450 {
 451     Reference< XInterface >  xTopLevelSouce;
 452     OUString sAccessPath = lcl_getFormComponentAccessPath(_rSourceContainer, xTopLevelSouce);
 453     if (!xTopLevelSouce.is())
 454         // something went wrong, maybe _rSourceContainer isn't part of a valid forms hierarchy
 455         return Reference< XInterface > ();
 456
 457     Reference< XIndexContainer >  xDestContainer(_rTopLevelDestContainer, UNO_QUERY_THROW);
 458     Reference< XIndexContainer >  xSourceContainer(xTopLevelSouce, UNO_QUERY);
 459     DBG_ASSERT(xSourceContainer.is(), "FmFormObj::ensureModelEnv : the top level source is invalid !");
 460
 461     sal_Int32 nTokIndex = 0;
 462     do
 463     {
 464         OUString aToken = sAccessPath.getToken( 0, '\\', nTokIndex );
 465         sal_uInt16 nIndex = (sal_uInt16)aToken.toInt32();
 466
 467         // get the DSS of the source form (we have to find an aquivalent for)
 468         DBG_ASSERT(nIndex<xSourceContainer->getCount(), "FmFormObj::ensureModelEnv : invalid access path !");
 469         Reference< XPropertySet >  xSourceForm;
 470         xSourceContainer->getByIndex(nIndex) >>= xSourceForm;
 471         DBG_ASSERT(xSourceForm.is(), "FmFormObj::ensureModelEnv : invalid source form !");
 472
 473         Any aSrcCursorSource, aSrcCursorSourceType, aSrcDataSource;
 474         DBG_ASSERT(::comphelper::hasProperty(FM_PROP_COMMAND, xSourceForm) && ::comphelper::hasProperty(FM_PROP_COMMANDTYPE, xSourceForm)
 475             && ::comphelper::hasProperty(FM_PROP_DATASOURCE, xSourceForm), "FmFormObj::ensureModelEnv : invalid access path or invalid form (missing props) !");
 476             // the parent access path should refer to a row set
 477         try
 478         {
 479             aSrcCursorSource        = xSourceForm->getPropertyValue(FM_PROP_COMMAND);
 480             aSrcCursorSourceType    = xSourceForm->getPropertyValue(FM_PROP_COMMANDTYPE);
 481             aSrcDataSource          = xSourceForm->getPropertyValue(FM_PROP_DATASOURCE);
 482         }
 483         catch(Exception&)
 484         {
 485             OSL_FAIL("FmFormObj::ensureModelEnv : could not retrieve a source DSS !");
 486         }
 487
 488
 489         // calc the number of (source) form siblings with the same DSS
 490         Reference< XPropertySet >  xCurrentSourceForm, xCurrentDestForm;
 491         sal_Int16 nCurrentSourceIndex = 0, nCurrentDestIndex = 0;
 492         while (nCurrentSourceIndex <= nIndex)
 493         {
 494             sal_Bool bEqualDSS = sal_False;
 495             while (!bEqualDSS)  // (we don't have to check nCurrentSourceIndex here : it's bound by nIndex)
 496             {
 497                 xSourceContainer->getByIndex(nCurrentSourceIndex) >>= xCurrentSourceForm;
 498                 DBG_ASSERT(xCurrentSourceForm.is(), "FmFormObj::ensureModelEnv : invalid form ancestor (2) !");
 499                 bEqualDSS = sal_False;
 500                 if (::comphelper::hasProperty(FM_PROP_DATASOURCE, xCurrentSourceForm))
 501                 {   // it is a form
 502                     try
 503                     {
 504                         if  (   ::comphelper::compare(xCurrentSourceForm->getPropertyValue(FM_PROP_COMMAND), aSrcCursorSource)
 505                             &&  ::comphelper::compare(xCurrentSourceForm->getPropertyValue(FM_PROP_COMMANDTYPE), aSrcCursorSourceType)
 506                             &&  ::comphelper::compare(xCurrentSourceForm->getPropertyValue(FM_PROP_DATASOURCE), aSrcDataSource)
 507                             )
 508                         {
 509                             bEqualDSS = sal_True;
 510                         }
 511                     }
 512                     catch(Exception&)
 513                     {
 514                         OSL_FAIL("FmFormObj::ensureModelEnv : exception while getting a sibling's DSS !");
 515                     }
 516
 517                 }
 518                 ++nCurrentSourceIndex;
 519             }
 520
 521             DBG_ASSERT(bEqualDSS, "FmFormObj::ensureModelEnv : found no source form !");
 522             // ??? at least the nIndex-th one should have been found ???
 523
 524             // now search the next one with the given DSS (within the destination container)
 525             bEqualDSS = sal_False;
 526             while (!bEqualDSS && (nCurrentDestIndex < xDestContainer->getCount()))
 527             {
 528                 xDestContainer->getByIndex(nCurrentDestIndex) >>= xCurrentDestForm;
 529                 DBG_ASSERT(xCurrentDestForm.is(), "FmFormObj::ensureModelEnv : invalid destination form !");
 530                 bEqualDSS = sal_False;
 531                 if (::comphelper::hasProperty(FM_PROP_DATASOURCE, xCurrentDestForm))
 532                 {   // it is a form
 533                     try
 534                     {
 535                         if  (   ::comphelper::compare(xCurrentDestForm->getPropertyValue(FM_PROP_COMMAND), aSrcCursorSource)
 536                             &&  ::comphelper::compare(xCurrentDestForm->getPropertyValue(FM_PROP_COMMANDTYPE), aSrcCursorSourceType)
 537                             &&  ::comphelper::compare(xCurrentDestForm->getPropertyValue(FM_PROP_DATASOURCE), aSrcDataSource)
 538                             )
 539                         {
 540                             bEqualDSS = sal_True;
 541                         }
 542                     }
 543                     catch(Exception&)
 544                     {
 545                         OSL_FAIL("FmFormObj::ensureModelEnv : exception while getting a destination DSS !");
 546                     }
 547
 548                 }
 549                 ++nCurrentDestIndex;
 550             }
 551
 552             if (!bEqualDSS)
 553             {   // There is at least one more source form with the given DSS than destination forms are.
 554                 // correct this ...
 555                 try
 556                 {
 557                     // create and insert (into the destination) a copy of the form
 558                     xCurrentDestForm.set(
 559                         ::comphelper::getProcessServiceFactory()->createInstance(OUString( "com.sun.star.form.component.DataForm" ) ),
 560                         UNO_QUERY_THROW );
 561                     ::comphelper::copyProperties( xCurrentSourceForm, xCurrentDestForm );
 562
 563                     DBG_ASSERT(nCurrentDestIndex == xDestContainer->getCount(), "FmFormObj::ensureModelEnv : something went wrong with the numbers !");
 564                     xDestContainer->insertByIndex(nCurrentDestIndex, makeAny(xCurrentDestForm));
 565
 566                     ++nCurrentDestIndex;
 567                         // like nCurrentSourceIndex, nCurrentDestIndex now points 'behind' the form it actally means
 568                 }
 569                 catch(Exception&)
 570                 {
 571                     OSL_FAIL("FmFormObj::ensureModelEnv : something went seriously wrong while creating a new form !");
 572                     // no more options anymore ...
 573                     return Reference< XInterface > ();
 574                 }
 575
 576             }
 577         }
 578
 579         // now xCurrentDestForm is a form equivalent to xSourceForm (which means they have the same DSS and the same number
 580         // of left siblings with the same DSS, which counts for all their ancestors, too)
 581
 582         // go down
 583         xDestContainer = Reference< XIndexContainer > (xCurrentDestForm, UNO_QUERY);
 584         xSourceContainer = Reference< XIndexContainer > (xSourceForm, UNO_QUERY);
 585         DBG_ASSERT(xDestContainer.is() && xSourceContainer.is(), "FmFormObj::ensureModelEnv : invalid container !");
 586     }
 587     while ( nTokIndex >= 0 );
 588
 589     return Reference< XInterface > (xDestContainer, UNO_QUERY);
 590 }
 591
 592 //------------------------------------------------------------------
 593 void FmFormObj::SetModel( SdrModel* _pNewModel )
 594 {
 595     SdrUnoObj::SetModel( _pNewModel );
 596     impl_checkRefDevice_nothrow();
 597 }
 598
 599 //------------------------------------------------------------------
 600 FmFormObj* FmFormObj::GetFormObject( SdrObject* _pSdrObject )
 601 {
 602     FmFormObj* pFormObject = dynamic_cast< FmFormObj* >( _pSdrObject );
 603     if ( !pFormObject )
 604     {
 605         SdrVirtObj* pVirtualObject = dynamic_cast< SdrVirtObj* >( _pSdrObject );
 606         if ( pVirtualObject )
 607             pFormObject = dynamic_cast< FmFormObj* >( &pVirtualObject->ReferencedObj() );
 608     }
 609     return pFormObject;
 610 }
 611
 612 //------------------------------------------------------------------
 613 const FmFormObj* FmFormObj::GetFormObject( const SdrObject* _pSdrObject )
 614 {
 615     const FmFormObj* pFormObject = dynamic_cast< const FmFormObj* >( _pSdrObject );
 616     if ( !pFormObject )
 617     {
 618         const SdrVirtObj* pVirtualObject = dynamic_cast< const SdrVirtObj* >( _pSdrObject );
 619         if ( pVirtualObject )
 620             pFormObject = dynamic_cast< const FmFormObj* >( &pVirtualObject->GetReferencedObj() );
 621     }
 622     return pFormObject;
 623 }
 624
 625 //------------------------------------------------------------------
 626 void FmFormObj::SetUnoControlModel( const Reference< com::sun::star::awt::XControlModel >& _rxModel )
 627 {
 628     SdrUnoObj::SetUnoControlModel( _rxModel );
 629
 630     FmFormPage* pFormPage = PTR_CAST( FmFormPage, GetPage() );
 631     if ( pFormPage )
 632         pFormPage->GetImpl().formModelAssigned( *this );
 633
 634     impl_checkRefDevice_nothrow( true );
 635 }
 636
 637 //------------------------------------------------------------------
 638 bool FmFormObj::EndCreate( SdrDragStat& rStat, SdrCreateCmd eCmd )
 639 {
 640     bool bResult = SdrUnoObj::EndCreate(rStat, eCmd);
 641     if ( bResult && SDRCREATE_FORCEEND == eCmd && rStat.GetView() )
 642     {
 643         if ( pPage )
 644         {
 645             FmFormPage& rPage = dynamic_cast< FmFormPage& >( *pPage );
 646
 647             try
 648             {
 649                 Reference< XFormComponent >  xContent( xUnoControlModel, UNO_QUERY_THROW );
 650                 Reference< XForm > xParentForm( xContent->getParent(), UNO_QUERY );
 651
 652                 Reference< XIndexContainer > xFormToInsertInto;
 653
 654                 if ( !xParentForm.is() )
 655                 {   // model is not yet part of a form component hierachy
 656                     xParentForm.set( rPage.GetImpl().findPlaceInFormComponentHierarchy( xContent ), UNO_SET_THROW );
 657                     xFormToInsertInto.set( xParentForm, UNO_QUERY_THROW );
 658                 }
 659
 660                 rPage.GetImpl().setUniqueName( xContent, xParentForm );
 661
 662                 if ( xFormToInsertInto.is() )
 663                     xFormToInsertInto->insertByIndex( xFormToInsertInto->getCount(), makeAny( xContent ) );
 664             }
 665             catch( const Exception& )
 666             {
 667                 DBG_UNHANDLED_EXCEPTION();
 668             }
 669         }
 670
 671         FmFormView* pView( dynamic_cast< FmFormView* >( rStat.GetView() ) );
 672         FmXFormView* pViewImpl = pView ? pView->GetImpl() : NULL;
 673         OSL_ENSURE( pViewImpl, "FmFormObj::EndCreate: no view!?" );
 674         if ( pViewImpl )
 675             pViewImpl->onCreatedFormObject( *this );
 676     }
 677     return bResult;
 678 }
 679
 680 //------------------------------------------------------------------------------
 681 void FmFormObj::BrkCreate( SdrDragStat& rStat )
 682 {
 683     SdrUnoObj::BrkCreate( rStat );
 684     impl_isolateControlModel_nothrow();
 685 }
 686
 687 // -----------------------------------------------------------------------------
 688 // #i70852# overload Layer interface to force to FormColtrol layer
 689
 690 SdrLayerID FmFormObj::GetLayer() const
 691 {
 692     // #i72535#
 693     // i70852 was too radical, in SW obects (and thus, FormControls, too)
 694     // get moved to invisible layers to hide them (e.g. in hidden sections).
 695     // This means that form controls ARE allowed to be on other layers than
 696     // the form control layer ATM and that being member of form control layer
 697     // is no criteria to find all FormControls of a document.
 698     // To fix, use parent functionality
 699     return SdrUnoObj::GetLayer();
 700 }
 701
 702 void FmFormObj::NbcSetLayer(SdrLayerID nLayer)
 703 {
 704     // #i72535#
 705     // See above. To fix, use parent functionality
 706     return SdrUnoObj::NbcSetLayer(nLayer);
 707 }
 708
 709 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */