basctl/source/dlged/dlgedobj.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: dlgedobj.cxx,v $
  10  * $Revision: 1.53 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_basctl.hxx"
  33
  34 #include <vector>
  35 #include <algorithm>
  36 #include <dlgeddef.hxx>
  37 #include "dlgedobj.hxx"
  38 #include "dlged.hxx"
  39 #include "dlgedmod.hxx"
  40 #include "dlgedpage.hxx"
  41 #include "dlgedview.hxx"
  42 #include "dlgedlist.hxx"
  43 #include <iderid.hxx>
  44 #include <localizationmgr.hxx>
  45
  46 #ifndef _BASCTL_DLGRESID_HRC
  47 #include <dlgresid.hrc>
  48 #endif
  49 #include <tools/resmgr.hxx>
  50 #include <tools/shl.hxx>
  51 #include <unotools/sharedunocomponent.hxx>
  52 #include <com/sun/star/awt/XTabControllerModel.hpp>
  53 #include <com/sun/star/awt/XUnoControlContainer.hpp>
  54 #include <com/sun/star/awt/XVclContainerPeer.hpp>
  55 #include <com/sun/star/awt/XWindow.hpp>
  56 #include <com/sun/star/beans/XPropertySet.hpp>
  57 #include <com/sun/star/beans/PropertyAttribute.hpp>
  58 #include <com/sun/star/script/XScriptEventsSupplier.hpp>
  59 #include <com/sun/star/container/XContainer.hpp>
  60 #include <com/sun/star/lang/XServiceInfo.hpp>
  61 #include <comphelper/processfactory.hxx>
  62 #include <comphelper/types.hxx>
  63 #include <vcl/svapp.hxx>
  64
  65 #include <algorithm>
  66 #include <functional>
  67
  68 using namespace ::com::sun::star;
  69 using namespace ::com::sun::star::uno;
  70 using namespace ::com::sun::star::beans;
  71 using namespace ::com::sun::star::container;
  72 using namespace ::com::sun::star::script;
  73 using ::rtl::OUString;
  74
  75
  76 TYPEINIT1(DlgEdObj, SdrUnoObj);
  77 DBG_NAME(DlgEdObj);
  78
  79 //----------------------------------------------------------------------------
  80 MapMode lcl_getMapModeForForm( DlgEdForm* pForm )
  81 {
  82         MapMode aMode( MAP_APPFONT ); //Default
  83         try
  84         {
  85                 uno::Reference< beans::XPropertySet > xProps( pForm ? pForm->GetUnoControlModel() : NULL, uno::UNO_QUERY_THROW );
  86                 sal_Bool bVBAForm = sal_False;
  87                 xProps->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("VBAForm") ) ) >>= bVBAForm;
  88                 if ( bVBAForm )
  89                         aMode = MapMode( MAP_100TH_MM );
  90         }
  91         catch ( Exception& )
  92         {
  93         }
  94         return aMode;
  95 }
  96
  97 DlgEdObj::DlgEdObj()
  98           :SdrUnoObj(String(), sal_False)
  99           ,bIsListening(sal_False)
 100           ,pDlgEdForm( NULL )
 101 {
 102     DBG_CTOR(DlgEdObj, NULL);
 103 }
 104
 105 //----------------------------------------------------------------------------
 106
 107 DlgEdObj::DlgEdObj(const ::rtl::OUString& rModelName,
 108                    const com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& rxSFac)
 109           :SdrUnoObj(rModelName, rxSFac, sal_False)
 110           ,bIsListening(sal_False)
 111           ,pDlgEdForm( NULL )
 112 {
 113     DBG_CTOR(DlgEdObj, NULL);
 114 }
 115
 116 //----------------------------------------------------------------------------
 117
 118 DlgEdObj::~DlgEdObj()
 119 {
 120     DBG_DTOR(DlgEdObj, NULL);
 121
 122     if ( isListening() )
 123         EndListening();
 124 }
 125
 126 //----------------------------------------------------------------------------
 127
 128 void DlgEdObj::SetPage(SdrPage* _pNewPage)
 129 {
 130     // now set the page
 131     SdrUnoObj::SetPage(_pNewPage);
 132 }
 133
 134 //----------------------------------------------------------------------------
 135
 136 namespace
 137 {
 138     /** returns the DlgEdForm which the given DlgEdObj belongs to
 139         (which might in fact be the object itself)
 140
 141         Failure to obtain the form will be reported with an assertion in the non-product
 142         version.
 143      */
 144     bool lcl_getDlgEdForm( DlgEdObj* _pObject, DlgEdForm*& _out_pDlgEdForm )
 145     {
 146         _out_pDlgEdForm = dynamic_cast< DlgEdForm* >( _pObject );
 147         if ( !_out_pDlgEdForm )
 148             _out_pDlgEdForm = _pObject->GetDlgEdForm();
 149         DBG_ASSERT( _out_pDlgEdForm, "lcl_getDlgEdForm: no form!" );
 150         return ( _out_pDlgEdForm != NULL );
 151     }
 152 }
 153
 154 //----------------------------------------------------------------------------
 155
 156 uno::Reference< awt::XControl > DlgEdObj::GetControl() const
 157 {
 158     const DlgEdForm* pForm = GetDlgEdForm();
 159     const DlgEditor* pEditor = pForm ? pForm->GetDlgEditor() : NULL;
 160     SdrView* pView = pEditor ? pEditor->GetView() : NULL;
 161     Window* pWindow = pEditor ? pEditor->GetWindow() : NULL;
 162     OSL_ENSURE( ( pView && pWindow ) || !pForm, "DlgEdObj::GetControl: no view or no window!" );
 163
 164     uno::Reference< awt::XControl > xControl;
 165     if ( pView && pWindow )
 166         xControl = GetUnoControl( *pView, *pWindow );
 167
 168     return xControl;
 169 }
 170
 171 //----------------------------------------------------------------------------
 172
 173 bool DlgEdObj::TransformSdrToControlCoordinates(
 174     sal_Int32 nXIn, sal_Int32 nYIn, sal_Int32 nWidthIn, sal_Int32 nHeightIn,
 175     sal_Int32& nXOut, sal_Int32& nYOut, sal_Int32& nWidthOut, sal_Int32& nHeightOut )
 176 {
 177     // input position and size
 178     Size aPos( nXIn, nYIn );
 179     Size aSize( nWidthIn, nHeightIn );
 180
 181     // form position
 182     DlgEdForm* pForm = NULL;
 183     if ( !lcl_getDlgEdForm( this, pForm ) )
 184         return false;
 185     Rectangle aFormRect = pForm->GetSnapRect();
 186     Size aFormPos( aFormRect.Left(), aFormRect.Top() );
 187
 188     // convert 100th_mm to pixel
 189     OutputDevice* pDevice = Application::GetDefaultDevice();
 190     DBG_ASSERT( pDevice, "DlgEdObj::TransformSdrToControlCoordinates: missing default device!" );
 191     if ( !pDevice )
 192         return false;
 193     aPos = pDevice->LogicToPixel( aPos, MapMode( MAP_100TH_MM ) );
 194     aSize = pDevice->LogicToPixel( aSize, MapMode( MAP_100TH_MM ) );
 195     aFormPos = pDevice->LogicToPixel( aFormPos, MapMode( MAP_100TH_MM ) );
 196
 197     // subtract form position
 198     aPos.Width() -= aFormPos.Width();
 199     aPos.Height() -= aFormPos.Height();
 200
 201     // take window borders into account
 202     Reference< beans::XPropertySet > xPSetForm( pForm->GetUnoControlModel(), UNO_QUERY );
 203     DBG_ASSERT( xPSetForm.is(), "DlgEdObj::TransformFormToSdrCoordinates: no form property set!" );
 204     if ( !xPSetForm.is() )
 205         return false;
 206     bool bDecoration = true;
 207     xPSetForm->getPropertyValue( DLGED_PROP_DECORATION ) >>= bDecoration;
 208     if( bDecoration )
 209     {
 210         awt::DeviceInfo aDeviceInfo = pForm->getDeviceInfo();
 211         aPos.Width() -= aDeviceInfo.LeftInset;
 212         aPos.Height() -= aDeviceInfo.TopInset;
 213     }
 214
 215     // convert pixel to logic units
 216     MapMode aConvMode = lcl_getMapModeForForm( pForm );
 217     aPos = pDevice->PixelToLogic( aPos, aConvMode );
 218     aSize = pDevice->PixelToLogic( aSize, aConvMode );
 219
 220     // set out parameters
 221     nXOut = aPos.Width();
 222     nYOut = aPos.Height();
 223     nWidthOut = aSize.Width();
 224     nHeightOut = aSize.Height();
 225
 226     return true;
 227 }
 228
 229 //----------------------------------------------------------------------------
 230
 231 bool DlgEdObj::TransformSdrToFormCoordinates(
 232     sal_Int32 nXIn, sal_Int32 nYIn, sal_Int32 nWidthIn, sal_Int32 nHeightIn,
 233     sal_Int32& nXOut, sal_Int32& nYOut, sal_Int32& nWidthOut, sal_Int32& nHeightOut )
 234 {
 235     // input position and size
 236     Size aPos( nXIn, nYIn );
 237     Size aSize( nWidthIn, nHeightIn );
 238
 239     // convert 100th_mm to pixel
 240     OutputDevice* pDevice = Application::GetDefaultDevice();
 241     DBG_ASSERT( pDevice, "DlgEdObj::TransformSdrToFormCoordinates: missing default device!" );
 242     if ( !pDevice )
 243         return false;
 244     aPos = pDevice->LogicToPixel( aPos, MapMode( MAP_100TH_MM ) );
 245     aSize = pDevice->LogicToPixel( aSize, MapMode( MAP_100TH_MM ) );
 246
 247     // take window borders into account
 248     DlgEdForm* pForm = NULL;
 249     if ( !lcl_getDlgEdForm( this, pForm ) )
 250         return false;
 251
 252     // take window borders into account
 253     Reference< beans::XPropertySet > xPSetForm( pForm->GetUnoControlModel(), UNO_QUERY );
 254     DBG_ASSERT( xPSetForm.is(), "DlgEdObj::TransformFormToSdrCoordinates: no form property set!" );
 255     if ( !xPSetForm.is() )
 256         return false;
 257     bool bDecoration = true;
 258     xPSetForm->getPropertyValue( DLGED_PROP_DECORATION ) >>= bDecoration;
 259     if( bDecoration )
 260     {
 261         awt::DeviceInfo aDeviceInfo = pForm->getDeviceInfo();
 262         aSize.Width() -= aDeviceInfo.LeftInset + aDeviceInfo.RightInset;
 263         aSize.Height() -= aDeviceInfo.TopInset + aDeviceInfo.BottomInset;
 264     }
 265     MapMode aConvMode = lcl_getMapModeForForm( pForm );
 266     // convert pixel to logic units
 267     aPos = pDevice->PixelToLogic( aPos, aConvMode );
 268     aSize = pDevice->PixelToLogic( aSize, aConvMode );
 269
 270     // set out parameters
 271     nXOut = aPos.Width();
 272     nYOut = aPos.Height();
 273     nWidthOut = aSize.Width();
 274     nHeightOut = aSize.Height();
 275
 276     return true;
 277 }
 278
 279 //----------------------------------------------------------------------------
 280
 281 bool DlgEdObj::TransformControlToSdrCoordinates(
 282     sal_Int32 nXIn, sal_Int32 nYIn, sal_Int32 nWidthIn, sal_Int32 nHeightIn,
 283     sal_Int32& nXOut, sal_Int32& nYOut, sal_Int32& nWidthOut, sal_Int32& nHeightOut )
 284 {
 285     // input position and size
 286     Size aPos( nXIn, nYIn );
 287     Size aSize( nWidthIn, nHeightIn );
 288
 289     // form position
 290     DlgEdForm* pForm = NULL;
 291     if ( !lcl_getDlgEdForm( this, pForm ) )
 292         return false;
 293
 294     Reference< beans::XPropertySet > xPSetForm( pForm->GetUnoControlModel(), UNO_QUERY );
 295     DBG_ASSERT( xPSetForm.is(), "DlgEdObj::TransformControlToSdrCoordinates: no form property set!" );
 296     if ( !xPSetForm.is() )
 297         return false;
 298     sal_Int32 nFormX = 0, nFormY = 0, nFormWidth, nFormHeight;
 299     xPSetForm->getPropertyValue( DLGED_PROP_POSITIONX ) >>= nFormX;
 300     xPSetForm->getPropertyValue( DLGED_PROP_POSITIONY ) >>= nFormY;
 301     xPSetForm->getPropertyValue( DLGED_PROP_WIDTH ) >>= nFormWidth;
 302     xPSetForm->getPropertyValue( DLGED_PROP_HEIGHT ) >>= nFormHeight;
 303     Size aFormPos( nFormX, nFormY );
 304
 305     // convert logic units to pixel
 306     OutputDevice* pDevice = Application::GetDefaultDevice();
 307     DBG_ASSERT( pDevice, "DlgEdObj::TransformControlToSdrCoordinates: missing default device!" );
 308     if ( !pDevice )
 309         return false;
 310     MapMode aConvMode = lcl_getMapModeForForm( pForm );
 311     aPos = pDevice->LogicToPixel( aPos, aConvMode );
 312     aSize = pDevice->LogicToPixel( aSize, aConvMode );
 313     aFormPos = pDevice->LogicToPixel( aFormPos, aConvMode );
 314
 315     // add form position
 316     aPos.Width() += aFormPos.Width();
 317     aPos.Height() += aFormPos.Height();
 318
 319     // take window borders into account
 320     bool bDecoration = true;
 321     xPSetForm->getPropertyValue( DLGED_PROP_DECORATION ) >>= bDecoration;
 322     if( bDecoration )
 323     {
 324         awt::DeviceInfo aDeviceInfo = pForm->getDeviceInfo();
 325         aPos.Width() += aDeviceInfo.LeftInset;
 326         aPos.Height() += aDeviceInfo.TopInset;
 327     }
 328
 329     // convert pixel to 100th_mm
 330     aPos = pDevice->PixelToLogic( aPos, MapMode( MAP_100TH_MM ) );
 331     aSize = pDevice->PixelToLogic( aSize, MapMode( MAP_100TH_MM ) );
 332
 333     // set out parameters
 334     nXOut = aPos.Width();
 335     nYOut = aPos.Height();
 336     nWidthOut = aSize.Width();
 337     nHeightOut = aSize.Height();
 338
 339     return true;
 340 }
 341
 342 //----------------------------------------------------------------------------
 343
 344 bool DlgEdObj::TransformFormToSdrCoordinates(
 345     sal_Int32 nXIn, sal_Int32 nYIn, sal_Int32 nWidthIn, sal_Int32 nHeightIn,
 346     sal_Int32& nXOut, sal_Int32& nYOut, sal_Int32& nWidthOut, sal_Int32& nHeightOut )
 347 {
 348     // input position and size
 349     Size aPos( nXIn, nYIn );
 350     Size aSize( nWidthIn, nHeightIn );
 351
 352     // convert logic units to pixel
 353     OutputDevice* pDevice = Application::GetDefaultDevice();
 354     DBG_ASSERT( pDevice, "DlgEdObj::TransformFormToSdrCoordinates: missing default device!" );
 355     if ( !pDevice )
 356         return false;
 357
 358     // take window borders into account
 359     DlgEdForm* pForm = NULL;
 360     if ( !lcl_getDlgEdForm( this, pForm ) )
 361         return false;
 362
 363     MapMode aConvMode = lcl_getMapModeForForm( pForm );
 364     aPos = pDevice->LogicToPixel( aPos, aConvMode );
 365     aSize = pDevice->LogicToPixel( aSize, aConvMode );
 366
 367     // take window borders into account
 368     Reference< beans::XPropertySet > xPSetForm( pForm->GetUnoControlModel(), UNO_QUERY );
 369     DBG_ASSERT( xPSetForm.is(), "DlgEdObj::TransformFormToSdrCoordinates: no form property set!" );
 370     if ( !xPSetForm.is() )
 371         return false;
 372     bool bDecoration = true;
 373     xPSetForm->getPropertyValue( DLGED_PROP_DECORATION ) >>= bDecoration;
 374     if( bDecoration )
 375     {
 376         awt::DeviceInfo aDeviceInfo = pForm->getDeviceInfo();
 377         aSize.Width() += aDeviceInfo.LeftInset + aDeviceInfo.RightInset;
 378         aSize.Height() += aDeviceInfo.TopInset + aDeviceInfo.BottomInset;
 379     }
 380
 381     // convert pixel to 100th_mm
 382     aPos = pDevice->PixelToLogic( aPos, MapMode( MAP_100TH_MM ) );
 383     aSize = pDevice->PixelToLogic( aSize, MapMode( MAP_100TH_MM ) );
 384
 385     // set out parameters
 386     nXOut = aPos.Width();
 387     nYOut = aPos.Height();
 388     nWidthOut = aSize.Width();
 389     nHeightOut = aSize.Height();
 390
 391     return true;
 392 }
 393
 394 //----------------------------------------------------------------------------
 395
 396 void DlgEdObj::SetRectFromProps()
 397 {
 398     // get control position and size from properties
 399     Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
 400     if ( xPSet.is() )
 401     {
 402         sal_Int32 nXIn = 0, nYIn = 0, nWidthIn = 0, nHeightIn = 0;
 403         xPSet->getPropertyValue( DLGED_PROP_POSITIONX ) >>= nXIn;
 404         xPSet->getPropertyValue( DLGED_PROP_POSITIONY ) >>= nYIn;
 405         xPSet->getPropertyValue( DLGED_PROP_WIDTH ) >>= nWidthIn;
 406         xPSet->getPropertyValue( DLGED_PROP_HEIGHT ) >>= nHeightIn;
 407
 408         // transform coordinates
 409         sal_Int32 nXOut, nYOut, nWidthOut, nHeightOut;
 410         if ( TransformControlToSdrCoordinates( nXIn, nYIn, nWidthIn, nHeightIn, nXOut, nYOut, nWidthOut, nHeightOut ) )
 411         {
 412             // set rectangle position and size
 413             Point aPoint( nXOut, nYOut );
 414             Size aSize( nWidthOut, nHeightOut );
 415             SetSnapRect( Rectangle( aPoint, aSize ) );
 416         }
 417     }
 418 }
 419
 420 //----------------------------------------------------------------------------
 421
 422 void DlgEdObj::SetPropsFromRect()
 423 {
 424     // get control position and size from rectangle
 425     Rectangle aRect_ = GetSnapRect();
 426     sal_Int32 nXIn = aRect_.Left();
 427     sal_Int32 nYIn = aRect_.Top();
 428     sal_Int32 nWidthIn = aRect_.GetWidth();
 429     sal_Int32 nHeightIn = aRect_.GetHeight();
 430
 431     // transform coordinates
 432     sal_Int32 nXOut, nYOut, nWidthOut, nHeightOut;
 433     if ( TransformSdrToControlCoordinates( nXIn, nYIn, nWidthIn, nHeightIn, nXOut, nYOut, nWidthOut, nHeightOut ) )
 434     {
 435         // set properties
 436         Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
 437         if ( xPSet.is() )
 438         {
 439             Any aValue;
 440             aValue <<= nXOut;
 441             xPSet->setPropertyValue( DLGED_PROP_POSITIONX, aValue );
 442             aValue <<= nYOut;
 443             xPSet->setPropertyValue( DLGED_PROP_POSITIONY, aValue );
 444             aValue <<= nWidthOut;
 445             xPSet->setPropertyValue( DLGED_PROP_WIDTH, aValue );
 446             aValue <<= nHeightOut;
 447             xPSet->setPropertyValue( DLGED_PROP_HEIGHT, aValue );
 448         }
 449     }
 450 }
 451
 452 //----------------------------------------------------------------------------
 453
 454 void DlgEdObj::PositionAndSizeChange( const beans::PropertyChangeEvent& evt )
 455 {
 456     DlgEdPage* pPage_ = 0;
 457     if ( pDlgEdForm )
 458     {
 459         DlgEditor* pEditor = pDlgEdForm->GetDlgEditor();
 460         if ( pEditor )
 461             pPage_ = pEditor->GetPage();
 462     }
 463     DBG_ASSERT( pPage_, "DlgEdObj::PositionAndSizeChange: no page!" );
 464     if ( pPage_ )
 465     {
 466         sal_Int32 nPageXIn = 0;
 467         sal_Int32 nPageYIn = 0;
 468         Size aPageSize = pPage_->GetSize();
 469         sal_Int32 nPageWidthIn = aPageSize.Width();
 470         sal_Int32 nPageHeightIn = aPageSize.Height();
 471         sal_Int32 nPageX, nPageY, nPageWidth, nPageHeight;
 472         if ( TransformSdrToControlCoordinates( nPageXIn, nPageYIn, nPageWidthIn, nPageHeightIn, nPageX, nPageY, nPageWidth, nPageHeight ) )
 473         {
 474             Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
 475             if ( xPSet.is() )
 476             {
 477                 sal_Int32 nX = 0, nY = 0, nWidth = 0, nHeight = 0;
 478                 xPSet->getPropertyValue( DLGED_PROP_POSITIONX ) >>= nX;
 479                 xPSet->getPropertyValue( DLGED_PROP_POSITIONY ) >>= nY;
 480                 xPSet->getPropertyValue( DLGED_PROP_WIDTH ) >>= nWidth;
 481                 xPSet->getPropertyValue( DLGED_PROP_HEIGHT ) >>= nHeight;
 482
 483                 sal_Int32 nValue = 0;
 484                 evt.NewValue >>= nValue;
 485                 sal_Int32 nNewValue = nValue;
 486
 487                 if ( evt.PropertyName == DLGED_PROP_POSITIONX )
 488                 {
 489                     if ( nNewValue + nWidth > nPageX + nPageWidth )
 490                         nNewValue = nPageX + nPageWidth - nWidth;
 491                     if ( nNewValue < nPageX )
 492                         nNewValue = nPageX;
 493                 }
 494                 else if ( evt.PropertyName == DLGED_PROP_POSITIONY )
 495                 {
 496                     if ( nNewValue + nHeight > nPageY + nPageHeight )
 497                         nNewValue = nPageY + nPageHeight - nHeight;
 498                     if ( nNewValue < nPageY )
 499                         nNewValue = nPageY;
 500                 }
 501                 else if ( evt.PropertyName == DLGED_PROP_WIDTH )
 502                 {
 503                     if ( nX + nNewValue > nPageX + nPageWidth )
 504                         nNewValue = nPageX + nPageWidth - nX;
 505                     if ( nNewValue < 1 )
 506                         nNewValue = 1;
 507                 }
 508                 else if ( evt.PropertyName == DLGED_PROP_HEIGHT )
 509                 {
 510                     if ( nY + nNewValue > nPageY + nPageHeight )
 511                         nNewValue = nPageY + nPageHeight - nY;
 512                     if ( nNewValue < 1 )
 513                         nNewValue = 1;
 514                 }
 515
 516                 if ( nNewValue != nValue )
 517                 {
 518                     Any aNewValue;
 519                     aNewValue <<= nNewValue;
 520                     EndListening( sal_False );
 521                     xPSet->setPropertyValue( evt.PropertyName, aNewValue );
 522                     StartListening();
 523                 }
 524             }
 525         }
 526     }
 527
 528     SetRectFromProps();
 529 }
 530
 531 //----------------------------------------------------------------------------
 532
 533 void SAL_CALL DlgEdObj::NameChange( const  ::com::sun::star::beans::PropertyChangeEvent& evt ) throw( ::com::sun::star::uno::RuntimeException)
 534 {
 535     // get old name
 536     ::rtl::OUString aOldName;
 537     evt.OldValue >>= aOldName;
 538
 539     // get new name
 540     ::rtl::OUString aNewName;
 541     evt.NewValue >>= aNewName;
 542
 543     if ( !aNewName.equals(aOldName) )
 544     {
 545         Reference< container::XNameAccess > xNameAcc((GetDlgEdForm()->GetUnoControlModel()), UNO_QUERY);
 546         if ( xNameAcc.is() && xNameAcc->hasByName(aOldName) )
 547         {
 548             if ( !xNameAcc->hasByName(aNewName) && aNewName.getLength() != 0 )
 549             {
 550                 // remove the control by the old name and insert the control by the new name in the container
 551                 Reference< container::XNameContainer > xCont(xNameAcc, UNO_QUERY );
 552                 if ( xCont.is() )
 553                 {
 554                     Reference< awt::XControlModel > xCtrl(GetUnoControlModel(), UNO_QUERY);
 555                     Any aAny;
 556                     aAny <<= xCtrl;
 557                     xCont->removeByName( aOldName );
 558                     xCont->insertByName( aNewName , aAny );
 559
 560                     DlgEditor* pEditor;
 561                     if ( ISA(DlgEdForm) )
 562                         pEditor = ((DlgEdForm*)this)->GetDlgEditor();
 563                     else
 564                         pEditor = GetDlgEdForm()->GetDlgEditor();
 565                     LocalizationMgr::renameControlResourceIDsForEditorObject( pEditor, aAny, aNewName );
 566                 }
 567             }
 568             else
 569             {
 570                 // set old name property
 571                 EndListening(sal_False);
 572                 Reference< beans::XPropertySet >  xPSet(GetUnoControlModel(), UNO_QUERY);
 573                 Any aName;
 574                 aName <<= aOldName;
 575                 xPSet->setPropertyValue( DLGED_PROP_NAME, aName );
 576                 StartListening();
 577             }
 578         }
 579     }
 580 }
 581
 582 //----------------------------------------------------------------------------
 583
 584 sal_Int32 DlgEdObj::GetStep() const
 585 {
 586     // get step property
 587     sal_Int32 nStep = 0;
 588     uno::Reference< beans::XPropertySet >  xPSet( GetUnoControlModel(), uno::UNO_QUERY );
 589     if (xPSet.is())
 590     {
 591         xPSet->getPropertyValue( DLGED_PROP_STEP ) >>= nStep;
 592     }
 593     return nStep;
 594 }
 595
 596 //----------------------------------------------------------------------------
 597
 598 void DlgEdObj::UpdateStep()
 599 {
 600     sal_Int32 nCurStep = GetDlgEdForm()->GetStep();
 601     sal_Int32 nStep = GetStep();
 602
 603     SdrLayerAdmin& rLayerAdmin = GetModel()->GetLayerAdmin();
 604     SdrLayerID nHiddenLayerId   = rLayerAdmin.GetLayerID( String( RTL_CONSTASCII_USTRINGPARAM( "HiddenLayer" ) ), FALSE );
 605     SdrLayerID nControlLayerId   = rLayerAdmin.GetLayerID( rLayerAdmin.GetControlLayerName(), sal_False );
 606
 607     if( nCurStep )
 608     {
 609         if ( nStep && (nStep != nCurStep) )
 610         {
 611             SetLayer( nHiddenLayerId );
 612         }
 613         else
 614         {
 615             SetLayer( nControlLayerId );
 616         }
 617     }
 618     else
 619     {
 620         SetLayer( nControlLayerId );
 621     }
 622 }
 623
 624 //----------------------------------------------------------------------------
 625
 626 void DlgEdObj::TabIndexChange( const beans::PropertyChangeEvent& evt ) throw (RuntimeException)
 627 {
 628     DlgEdForm* pForm = GetDlgEdForm();
 629     if ( pForm )
 630     {
 631         // stop listening with all children
 632         ::std::vector<DlgEdObj*> aChildList = pForm->GetChilds();
 633         ::std::vector<DlgEdObj*>::iterator aIter;
 634         for ( aIter = aChildList.begin() ; aIter != aChildList.end() ; ++aIter )
 635         {
 636             (*aIter)->EndListening( sal_False );
 637         }
 638
 639         Reference< container::XNameAccess > xNameAcc( pForm->GetUnoControlModel() , UNO_QUERY );
 640         if ( xNameAcc.is() )
 641         {
 642             // get sequence of control names
 643             Sequence< ::rtl::OUString > aNames = xNameAcc->getElementNames();
 644             const ::rtl::OUString* pNames = aNames.getConstArray();
 645             sal_Int32 nCtrls = aNames.getLength();
 646             sal_Int16 i;
 647
 648             // create a map of tab indices and control names, sorted by tab index
 649             IndexToNameMap aIndexToNameMap;
 650             for ( i = 0; i < nCtrls; ++i )
 651             {
 652                 // get control name
 653                 ::rtl::OUString aName( pNames[i] );
 654
 655                 // get tab index
 656                 sal_Int16 nTabIndex = -1;
 657                 Any aCtrl = xNameAcc->getByName( aName );
 658                 Reference< beans::XPropertySet > xPSet;
 659                    aCtrl >>= xPSet;
 660                 if ( xPSet.is() && xPSet == Reference< beans::XPropertySet >( evt.Source, UNO_QUERY ) )
 661                     evt.OldValue >>= nTabIndex;
 662                 else if ( xPSet.is() )
 663                     xPSet->getPropertyValue( DLGED_PROP_TABINDEX ) >>= nTabIndex;
 664
 665                 // insert into map
 666                 aIndexToNameMap.insert( IndexToNameMap::value_type( nTabIndex, aName ) );
 667             }
 668
 669             // create a helper list of control names, sorted by tab index
 670             ::std::vector< ::rtl::OUString > aNameList( aIndexToNameMap.size() );
 671             ::std::transform(
 672                     aIndexToNameMap.begin(), aIndexToNameMap.end(),
 673                     aNameList.begin(),
 674                     ::std::select2nd< IndexToNameMap::value_type >( )
 675                 );
 676
 677             // check tab index
 678             sal_Int16 nOldTabIndex = 0;
 679             evt.OldValue >>= nOldTabIndex;
 680             sal_Int16 nNewTabIndex = 0;
 681             evt.NewValue >>= nNewTabIndex;
 682             if ( nNewTabIndex < 0 )
 683                 nNewTabIndex = 0;
 684             else if ( nNewTabIndex > nCtrls - 1 )
 685                 nNewTabIndex = sal::static_int_cast<sal_Int16>( nCtrls - 1 );
 686
 687             // reorder helper list
 688             ::rtl::OUString aCtrlName = aNameList[nOldTabIndex];
 689             aNameList.erase( aNameList.begin() + nOldTabIndex );
 690             aNameList.insert( aNameList.begin() + nNewTabIndex , aCtrlName );
 691
 692             // set new tab indices
 693             for ( i = 0; i < nCtrls; ++i )
 694             {
 695                 Any aCtrl = xNameAcc->getByName( aNameList[i] );
 696                 Reference< beans::XPropertySet > xPSet;
 697                    aCtrl >>= xPSet;
 698                 if ( xPSet.is() )
 699                 {
 700                     Any aTabIndex;
 701                     aTabIndex <<= (sal_Int16) i;
 702                     xPSet->setPropertyValue( DLGED_PROP_TABINDEX, aTabIndex );
 703                 }
 704             }
 705
 706             // reorder objects in drawing page
 707             GetModel()->GetPage(0)->SetObjectOrdNum( nOldTabIndex + 1, nNewTabIndex + 1 );
 708
 709             // #110559#
 710             pForm->UpdateTabOrderAndGroups();
 711         }
 712
 713         // start listening with all children
 714         for ( aIter = aChildList.begin() ; aIter != aChildList.end() ; ++aIter )
 715         {
 716             (*aIter)->StartListening();
 717         }
 718     }
 719 }
 720
 721 //----------------------------------------------------------------------------
 722
 723 sal_Bool DlgEdObj::supportsService( const sal_Char* _pServiceName ) const
 724 {
 725     sal_Bool bSupports = sal_False;
 726
 727     Reference< lang::XServiceInfo > xServiceInfo( GetUnoControlModel() , UNO_QUERY );
 728         // TODO: cache xServiceInfo as member?
 729     if ( xServiceInfo.is() )
 730         bSupports = xServiceInfo->supportsService( ::rtl::OUString::createFromAscii( _pServiceName ) );
 731
 732     return bSupports;
 733 }
 734
 735 //----------------------------------------------------------------------------
 736
 737 ::rtl::OUString DlgEdObj::GetDefaultName() const
 738 {
 739     sal_uInt16 nResId = 0;
 740     ::rtl::OUString aDefaultName;
 741     if ( supportsService( "com.sun.star.awt.UnoControlDialogModel" ) )
 742     {
 743         nResId = RID_STR_CLASS_DIALOG;
 744     }
 745     else if ( supportsService( "com.sun.star.awt.UnoControlButtonModel" ) )
 746     {
 747         nResId = RID_STR_CLASS_BUTTON;
 748     }
 749     else if ( supportsService( "com.sun.star.awt.UnoControlRadioButtonModel" ) )
 750     {
 751         nResId = RID_STR_CLASS_RADIOBUTTON;
 752     }
 753     else if ( supportsService( "com.sun.star.awt.UnoControlCheckBoxModel" ) )
 754     {
 755         nResId = RID_STR_CLASS_CHECKBOX;
 756     }
 757     else if ( supportsService( "com.sun.star.awt.UnoControlListBoxModel" ) )
 758     {
 759         nResId = RID_STR_CLASS_LISTBOX;
 760     }
 761     else if ( supportsService( "com.sun.star.awt.UnoControlComboBoxModel" ) )
 762     {
 763         nResId = RID_STR_CLASS_COMBOBOX;
 764     }
 765     else if ( supportsService( "com.sun.star.awt.UnoControlGroupBoxModel" ) )
 766     {
 767         nResId = RID_STR_CLASS_GROUPBOX;
 768     }
 769     else if ( supportsService( "com.sun.star.awt.UnoControlEditModel" ) )
 770     {
 771         nResId = RID_STR_CLASS_EDIT;
 772     }
 773     else if ( supportsService( "com.sun.star.awt.UnoControlFixedTextModel" ) )
 774     {
 775         nResId = RID_STR_CLASS_FIXEDTEXT;
 776     }
 777     else if ( supportsService( "com.sun.star.awt.UnoControlImageControlModel" ) )
 778     {
 779         nResId = RID_STR_CLASS_IMAGECONTROL;
 780     }
 781     else if ( supportsService( "com.sun.star.awt.UnoControlProgressBarModel" ) )
 782     {
 783         nResId = RID_STR_CLASS_PROGRESSBAR;
 784     }
 785     else if ( supportsService( "com.sun.star.awt.UnoControlScrollBarModel" ) )
 786     {
 787         nResId = RID_STR_CLASS_SCROLLBAR;
 788     }
 789     else if ( supportsService( "com.sun.star.awt.UnoControlFixedLineModel" ) )
 790     {
 791         nResId = RID_STR_CLASS_FIXEDLINE;
 792     }
 793     else if ( supportsService( "com.sun.star.awt.UnoControlDateFieldModel" ) )
 794     {
 795         nResId = RID_STR_CLASS_DATEFIELD;
 796     }
 797     else if ( supportsService( "com.sun.star.awt.UnoControlTimeFieldModel" ) )
 798     {
 799         nResId = RID_STR_CLASS_TIMEFIELD;
 800     }
 801     else if ( supportsService( "com.sun.star.awt.UnoControlNumericFieldModel" ) )
 802     {
 803         nResId = RID_STR_CLASS_NUMERICFIELD;
 804     }
 805     else if ( supportsService( "com.sun.star.awt.UnoControlCurrencyFieldModel" ) )
 806     {
 807         nResId = RID_STR_CLASS_CURRENCYFIELD;
 808     }
 809     else if ( supportsService( "com.sun.star.awt.UnoControlFormattedFieldModel" ) )
 810     {
 811         nResId = RID_STR_CLASS_FORMATTEDFIELD;
 812     }
 813     else if ( supportsService( "com.sun.star.awt.UnoControlPatternFieldModel" ) )
 814     {
 815         nResId = RID_STR_CLASS_PATTERNFIELD;
 816     }
 817     else if ( supportsService( "com.sun.star.awt.UnoControlFileControlModel" ) )
 818     {
 819         nResId = RID_STR_CLASS_FILECONTROL;
 820     }
 821     else if ( supportsService( "com.sun.star.awt.tree.TreeControlModel" ) )
 822     {
 823         nResId = RID_STR_CLASS_TREECONTROL;
 824     }
 825
 826     else
 827     {
 828         nResId = RID_STR_CLASS_CONTROL;
 829     }
 830
 831     if (nResId)
 832     {
 833         aDefaultName = ::rtl::OUString( String(IDEResId(nResId)) );
 834     }
 835
 836     return aDefaultName;
 837 }
 838
 839 //----------------------------------------------------------------------------
 840
 841 ::rtl::OUString DlgEdObj::GetUniqueName() const
 842 {
 843     ::rtl::OUString aUniqueName;
 844     uno::Reference< container::XNameAccess > xNameAcc((GetDlgEdForm()->GetUnoControlModel()), uno::UNO_QUERY);
 845
 846     if ( xNameAcc.is() )
 847     {
 848         sal_Int32 n = 0;
 849         ::rtl::OUString aDefaultName = GetDefaultName();
 850
 851         do
 852         {
 853             aUniqueName = aDefaultName + ::rtl::OUString::valueOf(++n);
 854         }       while (xNameAcc->hasByName(aUniqueName));
 855     }
 856
 857     return aUniqueName;
 858 }
 859
 860 //----------------------------------------------------------------------------
 861
 862 sal_uInt32 DlgEdObj::GetObjInventor()   const
 863 {
 864     return DlgInventor;
 865 }
 866
 867 //----------------------------------------------------------------------------
 868
 869 sal_uInt16 DlgEdObj::GetObjIdentifier() const
 870 {
 871     if ( supportsService( "com.sun.star.awt.UnoControlDialogModel" ))
 872     {
 873         return OBJ_DLG_DIALOG;
 874     }
 875     else if ( supportsService( "com.sun.star.awt.UnoControlButtonModel" ))
 876     {
 877         return OBJ_DLG_PUSHBUTTON;
 878     }
 879     else if ( supportsService( "com.sun.star.awt.UnoControlRadioButtonModel" ))
 880     {
 881         return OBJ_DLG_RADIOBUTTON;
 882     }
 883     else if ( supportsService( "com.sun.star.awt.UnoControlCheckBoxModel" ))
 884     {
 885         return OBJ_DLG_CHECKBOX;
 886     }
 887     else if ( supportsService( "com.sun.star.awt.UnoControlListBoxModel" ))
 888     {
 889         return OBJ_DLG_LISTBOX;
 890     }
 891     else if ( supportsService( "com.sun.star.awt.UnoControlComboBoxModel" ))
 892     {
 893         return OBJ_DLG_COMBOBOX;
 894     }
 895     else if ( supportsService( "com.sun.star.awt.UnoControlGroupBoxModel" ))
 896     {
 897         return OBJ_DLG_GROUPBOX;
 898     }
 899     else if ( supportsService( "com.sun.star.awt.UnoControlEditModel" ))
 900     {
 901         return OBJ_DLG_EDIT;
 902     }
 903     else if ( supportsService( "com.sun.star.awt.UnoControlFixedTextModel" ))
 904     {
 905         return OBJ_DLG_FIXEDTEXT;
 906     }
 907     else if ( supportsService( "com.sun.star.awt.UnoControlImageControlModel" ))
 908     {
 909         return OBJ_DLG_IMAGECONTROL;
 910     }
 911     else if ( supportsService( "com.sun.star.awt.UnoControlProgressBarModel" ))
 912     {
 913         return OBJ_DLG_PROGRESSBAR;
 914     }
 915     else if ( supportsService( "com.sun.star.awt.UnoControlScrollBarModel" ))
 916     {
 917         return OBJ_DLG_HSCROLLBAR;
 918     }
 919     else if ( supportsService( "com.sun.star.awt.UnoControlFixedLineModel" ))
 920     {
 921         return OBJ_DLG_HFIXEDLINE;
 922     }
 923     else if ( supportsService( "com.sun.star.awt.UnoControlDateFieldModel" ))
 924     {
 925         return OBJ_DLG_DATEFIELD;
 926     }
 927     else if ( supportsService( "com.sun.star.awt.UnoControlTimeFieldModel" ))
 928     {
 929         return OBJ_DLG_TIMEFIELD;
 930     }
 931     else if ( supportsService( "com.sun.star.awt.UnoControlNumericFieldModel" ))
 932     {
 933         return OBJ_DLG_NUMERICFIELD;
 934     }
 935     else if ( supportsService( "com.sun.star.awt.UnoControlCurrencyFieldModel" ))
 936     {
 937         return OBJ_DLG_CURRENCYFIELD;
 938     }
 939     else if ( supportsService( "com.sun.star.awt.UnoControlFormattedFieldModel" ))
 940     {
 941         return OBJ_DLG_FORMATTEDFIELD;
 942     }
 943     else if ( supportsService( "com.sun.star.awt.UnoControlPatternFieldModel" ))
 944     {
 945         return OBJ_DLG_PATTERNFIELD;
 946     }
 947     else if ( supportsService( "com.sun.star.awt.UnoControlFileControlModel" ))
 948     {
 949         return OBJ_DLG_FILECONTROL;
 950     }
 951     else if ( supportsService( "com.sun.star.awt.tree.TreeControlModel" ))
 952     {
 953         return OBJ_DLG_TREECONTROL;
 954     }
 955     else
 956     {
 957         return OBJ_DLG_CONTROL;
 958     }
 959 }
 960
 961 //----------------------------------------------------------------------------
 962
 963 void DlgEdObj::clonedFrom(const DlgEdObj* _pSource)
 964 {
 965     // set parent form
 966     pDlgEdForm = _pSource->pDlgEdForm;
 967
 968     // add child to parent form
 969     pDlgEdForm->AddChild( this );
 970
 971     Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
 972     if ( xPSet.is() )
 973     {
 974         // set new name
 975         ::rtl::OUString aOUniqueName( GetUniqueName() );
 976         Any aUniqueName;
 977         aUniqueName <<= aOUniqueName;
 978         xPSet->setPropertyValue( DLGED_PROP_NAME, aUniqueName );
 979
 980         Reference< container::XNameContainer > xCont( GetDlgEdForm()->GetUnoControlModel() , UNO_QUERY );
 981         if ( xCont.is() )
 982         {
 983             // set tabindex
 984                Sequence< OUString > aNames = xCont->getElementNames();
 985             Any aTabIndex;
 986             aTabIndex <<= (sal_Int16) aNames.getLength();
 987             xPSet->setPropertyValue( DLGED_PROP_TABINDEX, aTabIndex );
 988
 989             // insert control model in dialog model
 990             Reference< awt::XControlModel > xCtrl( xPSet , UNO_QUERY );
 991             Any aCtrl;
 992             aCtrl <<= xCtrl;
 993             xCont->insertByName( aOUniqueName , aCtrl );
 994
 995             // #110559#
 996             pDlgEdForm->UpdateTabOrderAndGroups();
 997         }
 998     }
 999
1000     // start listening
1001     StartListening();
1002 }
1003
1004 //----------------------------------------------------------------------------
1005
1006 SdrObject* DlgEdObj::Clone() const
1007 {
1008     SdrObject* pReturn = SdrUnoObj::Clone();
1009
1010     DlgEdObj* pDlgEdObj = PTR_CAST(DlgEdObj, pReturn);
1011     DBG_ASSERT( pDlgEdObj != NULL, "DlgEdObj::Clone: invalid clone!" );
1012     if ( pDlgEdObj )
1013         pDlgEdObj->clonedFrom( this );
1014
1015     return pReturn;
1016 }
1017
1018 //----------------------------------------------------------------------------
1019
1020 SdrObject* DlgEdObj::getFullDragClone() const
1021 {
1022     // no need to really add the clone for dragging, it's a temporary
1023     // object
1024     SdrObject* pObj = new SdrUnoObj(String());
1025     *pObj = *((const SdrUnoObj*)this);
1026
1027     return pObj;
1028 }
1029
1030 //----------------------------------------------------------------------------
1031
1032 void DlgEdObj::operator= (const SdrObject& rObj)
1033 {
1034     SdrUnoObj::operator= (rObj);
1035 }
1036
1037 //----------------------------------------------------------------------------
1038
1039 void DlgEdObj::NbcMove( const Size& rSize )
1040 {
1041     SdrUnoObj::NbcMove( rSize );
1042
1043     // stop listening
1044     EndListening(sal_False);
1045
1046     // set geometry properties
1047     SetPropsFromRect();
1048
1049     // start listening
1050     StartListening();
1051
1052     // dialog model changed
1053     GetDlgEdForm()->GetDlgEditor()->SetDialogModelChanged(TRUE);
1054 }
1055
1056 //----------------------------------------------------------------------------
1057
1058 void DlgEdObj::NbcResize(const Point& rRef, const Fraction& xFract, const Fraction& yFract)
1059 {
1060     SdrUnoObj::NbcResize( rRef, xFract, yFract );
1061
1062     // stop listening
1063     EndListening(sal_False);
1064
1065     // set geometry properties
1066     SetPropsFromRect();
1067
1068     // start listening
1069     StartListening();
1070
1071     // dialog model changed
1072     GetDlgEdForm()->GetDlgEditor()->SetDialogModelChanged(TRUE);
1073 }
1074
1075 //----------------------------------------------------------------------------
1076
1077 FASTBOOL DlgEdObj::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1078 {
1079     FASTBOOL bResult = SdrUnoObj::EndCreate(rStat, eCmd);
1080
1081     SetDefaults();
1082     StartListening();
1083
1084     return bResult;
1085 }
1086
1087 //----------------------------------------------------------------------------
1088
1089 void DlgEdObj::SetDefaults()
1090 {
1091     // set parent form
1092     pDlgEdForm = ((DlgEdPage*)GetPage())->GetDlgEdForm();
1093
1094     if ( pDlgEdForm )
1095     {
1096         // add child to parent form
1097         pDlgEdForm->AddChild( this );
1098
1099         Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
1100         if ( xPSet.is() )
1101         {
1102             // get unique name
1103             ::rtl::OUString aOUniqueName( GetUniqueName() );
1104
1105             // set name property
1106             Any aUniqueName;
1107             aUniqueName <<= aOUniqueName;
1108             xPSet->setPropertyValue( DLGED_PROP_NAME, aUniqueName );
1109
1110             // set labels
1111             if ( supportsService( "com.sun.star.awt.UnoControlButtonModel" ) ||
1112                 supportsService( "com.sun.star.awt.UnoControlRadioButtonModel" ) ||
1113                 supportsService( "com.sun.star.awt.UnoControlCheckBoxModel" ) ||
1114                 supportsService( "com.sun.star.awt.UnoControlGroupBoxModel" ) ||
1115                 supportsService( "com.sun.star.awt.UnoControlFixedTextModel" ) )
1116             {
1117                 xPSet->setPropertyValue( DLGED_PROP_LABEL, aUniqueName );
1118             }
1119
1120             // set number formats supplier for formatted field
1121             if ( supportsService( "com.sun.star.awt.UnoControlFormattedFieldModel" ) )
1122             {
1123                 Reference< util::XNumberFormatsSupplier > xSupplier = GetDlgEdForm()->GetDlgEditor()->GetNumberFormatsSupplier();
1124                 if ( xSupplier.is() )
1125                 {
1126                     Any aSupplier;
1127                     aSupplier <<= xSupplier;
1128                     xPSet->setPropertyValue( DLGED_PROP_FORMATSSUPPLIER, aSupplier );
1129                 }
1130             }
1131
1132             // set geometry properties
1133             SetPropsFromRect();
1134
1135             Reference< container::XNameContainer > xCont( GetDlgEdForm()->GetUnoControlModel() , UNO_QUERY );
1136             if ( xCont.is() )
1137             {
1138                 // set tabindex
1139                    Sequence< OUString > aNames = xCont->getElementNames();
1140                 uno::Any aTabIndex;
1141                 aTabIndex <<= (sal_Int16) aNames.getLength();
1142                 xPSet->setPropertyValue( DLGED_PROP_TABINDEX, aTabIndex );
1143
1144                 // set step
1145                 Reference< beans::XPropertySet > xPSetForm( xCont, UNO_QUERY );
1146                 if ( xPSetForm.is() )
1147                 {
1148                     Any aStep = xPSetForm->getPropertyValue( DLGED_PROP_STEP );
1149                     xPSet->setPropertyValue( DLGED_PROP_STEP, aStep );
1150                 }
1151
1152                 // insert control model in dialog model
1153                 Reference< awt::XControlModel > xCtrl( xPSet , UNO_QUERY );
1154                 Any aAny;
1155                 aAny <<= xCtrl;
1156                 xCont->insertByName( aOUniqueName , aAny );
1157
1158                 DlgEditor* pEditor;
1159                 if ( ISA(DlgEdForm) )
1160                     pEditor = ((DlgEdForm*)this)->GetDlgEditor();
1161                 else
1162                     pEditor = GetDlgEdForm()->GetDlgEditor();
1163                 LocalizationMgr::setControlResourceIDsForNewEditorObject( pEditor, aAny, aOUniqueName );
1164
1165                 // #110559#
1166                 pDlgEdForm->UpdateTabOrderAndGroups();
1167             }
1168         }
1169
1170         // dialog model changed
1171         pDlgEdForm->GetDlgEditor()->SetDialogModelChanged( TRUE );
1172     }
1173 }
1174
1175 //----------------------------------------------------------------------------
1176
1177 IMPL_LINK(DlgEdObj, OnCreate, void*, EMPTYTAG)
1178 {
1179     (void)EMPTYTAG;
1180     /*
1181     if (pTempView)
1182         pTempView->ObjectCreated(this);
1183     */
1184     return 0;
1185 }
1186
1187 //----------------------------------------------------------------------------
1188
1189 void DlgEdObj::StartListening()
1190 {
1191     DBG_ASSERT(!isListening(), "DlgEdObj::StartListening: already listening!");
1192
1193     if (!isListening())
1194     {
1195         bIsListening = sal_True;
1196
1197         // XPropertyChangeListener
1198         Reference< XPropertySet > xControlModel( GetUnoControlModel() , UNO_QUERY );
1199         if (!m_xPropertyChangeListener.is() && xControlModel.is())
1200         {
1201             // create listener
1202             m_xPropertyChangeListener = static_cast< ::com::sun::star::beans::XPropertyChangeListener*>( new DlgEdPropListenerImpl( (DlgEdObj*)this ) );
1203
1204             // register listener to properties
1205             xControlModel->addPropertyChangeListener( ::rtl::OUString() , m_xPropertyChangeListener );
1206         }
1207
1208         // XContainerListener
1209         Reference< XScriptEventsSupplier > xEventsSupplier( GetUnoControlModel() , UNO_QUERY );
1210         if( !m_xContainerListener.is() && xEventsSupplier.is() )
1211         {
1212             // create listener
1213             m_xContainerListener = static_cast< ::com::sun::star::container::XContainerListener*>( new DlgEdEvtContListenerImpl( (DlgEdObj*)this ) );
1214
1215             // register listener to script event container
1216             Reference< XNameContainer > xEventCont = xEventsSupplier->getEvents();
1217             DBG_ASSERT(xEventCont.is(), "DlgEdObj::StartListening: control model has no script event container!");
1218             Reference< XContainer > xCont( xEventCont , UNO_QUERY );
1219             if (xCont.is())
1220                 xCont->addContainerListener( m_xContainerListener );
1221         }
1222     }
1223 }
1224
1225 //----------------------------------------------------------------------------
1226
1227 void DlgEdObj::EndListening(sal_Bool bRemoveListener)
1228 {
1229     DBG_ASSERT(isListening(), "DlgEdObj::EndListening: not listening currently!");
1230
1231     if (isListening())
1232     {
1233         bIsListening = sal_False;
1234
1235         if (bRemoveListener)
1236         {
1237             // XPropertyChangeListener
1238             Reference< XPropertySet > xControlModel(GetUnoControlModel(), UNO_QUERY);
1239             if ( m_xPropertyChangeListener.is() && xControlModel.is() )
1240             {
1241                 // remove listener
1242                 xControlModel->removePropertyChangeListener( ::rtl::OUString() , m_xPropertyChangeListener );
1243             }
1244             m_xPropertyChangeListener.clear();
1245
1246             // XContainerListener
1247             Reference< XScriptEventsSupplier > xEventsSupplier( GetUnoControlModel() , UNO_QUERY );
1248             if( m_xContainerListener.is() && xEventsSupplier.is() )
1249             {
1250                 // remove listener
1251                 Reference< XNameContainer > xEventCont = xEventsSupplier->getEvents();
1252                 DBG_ASSERT(xEventCont.is(), "DlgEdObj::EndListening: control model has no script event container!");
1253                 Reference< XContainer > xCont( xEventCont , UNO_QUERY );
1254                 if (xCont.is())
1255                     xCont->removeContainerListener( m_xContainerListener );
1256             }
1257             m_xContainerListener.clear();
1258         }
1259     }
1260 }
1261
1262 //----------------------------------------------------------------------------
1263
1264 void SAL_CALL DlgEdObj::_propertyChange( const  ::com::sun::star::beans::PropertyChangeEvent& evt ) throw( ::com::sun::star::uno::RuntimeException)
1265 {
1266     if (isListening())
1267     {
1268         DlgEdForm* pRealDlgEdForm = dynamic_cast< DlgEdForm* >(this);
1269         if( pRealDlgEdForm == 0 )
1270             pRealDlgEdForm = GetDlgEdForm();
1271
1272         DlgEditor* pDlgEditor = pRealDlgEdForm ? pRealDlgEdForm->GetDlgEditor() : 0;
1273
1274         if( !pDlgEditor || pDlgEditor->isInPaint() )
1275             return;
1276
1277         // dialog model changed
1278         pDlgEditor->SetDialogModelChanged(TRUE);
1279
1280         // update position and size
1281         if ( evt.PropertyName == DLGED_PROP_POSITIONX || evt.PropertyName == DLGED_PROP_POSITIONY ||
1282              evt.PropertyName == DLGED_PROP_WIDTH || evt.PropertyName == DLGED_PROP_HEIGHT ||
1283              evt.PropertyName == DLGED_PROP_DECORATION )
1284         {
1285             PositionAndSizeChange( evt );
1286
1287             if ( evt.PropertyName == DLGED_PROP_DECORATION )
1288             {
1289                 if ( ISA(DlgEdForm) )
1290                     ((DlgEdForm*)this)->GetDlgEditor()->ResetDialog();
1291                 else
1292                     GetDlgEdForm()->GetDlgEditor()->ResetDialog();
1293             }
1294         }
1295         // change name of control in dialog model
1296         else if ( evt.PropertyName == DLGED_PROP_NAME )
1297         {
1298             if ( !ISA(DlgEdForm) )
1299             {
1300                 NameChange(evt);
1301             }
1302         }
1303         // update step
1304         else if ( evt.PropertyName == DLGED_PROP_STEP )
1305         {
1306             UpdateStep();
1307         }
1308         // change tabindex
1309         else if ( evt.PropertyName == DLGED_PROP_TABINDEX )
1310         {
1311             if ( !ISA(DlgEdForm) )
1312             {
1313                 TabIndexChange(evt);
1314             }
1315         }
1316     }
1317 }
1318
1319 //----------------------------------------------------------------------------
1320
1321 void SAL_CALL DlgEdObj::_elementInserted(const ::com::sun::star::container::ContainerEvent& ) throw(::com::sun::star::uno::RuntimeException)
1322 {
1323     if (isListening())
1324     {
1325         // dialog model changed
1326         if ( ISA(DlgEdForm) )
1327         {
1328             ((DlgEdForm*)this)->GetDlgEditor()->SetDialogModelChanged(TRUE);
1329         }
1330         else
1331         {
1332             GetDlgEdForm()->GetDlgEditor()->SetDialogModelChanged(TRUE);
1333         }
1334     }
1335 }
1336
1337 //----------------------------------------------------------------------------
1338
1339 void SAL_CALL DlgEdObj::_elementReplaced(const ::com::sun::star::container::ContainerEvent& ) throw(::com::sun::star::uno::RuntimeException)
1340 {
1341     if (isListening())
1342     {
1343         // dialog model changed
1344         if ( ISA(DlgEdForm) )
1345         {
1346             ((DlgEdForm*)this)->GetDlgEditor()->SetDialogModelChanged(TRUE);
1347         }
1348         else
1349         {
1350             GetDlgEdForm()->GetDlgEditor()->SetDialogModelChanged(TRUE);
1351         }
1352     }
1353 }
1354
1355 //----------------------------------------------------------------------------
1356
1357 void SAL_CALL DlgEdObj::_elementRemoved(const ::com::sun::star::container::ContainerEvent& ) throw(::com::sun::star::uno::RuntimeException)
1358 {
1359     if (isListening())
1360     {
1361         // dialog model changed
1362         if ( ISA(DlgEdForm) )
1363         {
1364             ((DlgEdForm*)this)->GetDlgEditor()->SetDialogModelChanged(TRUE);
1365         }
1366         else
1367         {
1368             GetDlgEdForm()->GetDlgEditor()->SetDialogModelChanged(TRUE);
1369         }
1370     }
1371 }
1372
1373 //----------------------------------------------------------------------------
1374
1375 void DlgEdObj::SetLayer(SdrLayerID nLayer)
1376 {
1377     SdrLayerID nOldLayer = GetLayer();
1378
1379     if ( nLayer != nOldLayer )
1380     {
1381         SdrUnoObj::SetLayer( nLayer );
1382
1383         DlgEdHint aHint( DLGED_HINT_LAYERCHANGED, this );
1384         GetDlgEdForm()->GetDlgEditor()->Broadcast( aHint );
1385     }
1386 }
1387
1388 //----------------------------------------------------------------------------
1389
1390 TYPEINIT1(DlgEdForm, DlgEdObj);
1391 DBG_NAME(DlgEdForm);
1392
1393 //----------------------------------------------------------------------------
1394
1395 DlgEdForm::DlgEdForm()
1396           :DlgEdObj()
1397 {
1398     DBG_CTOR(DlgEdForm, NULL);
1399 }
1400
1401 //----------------------------------------------------------------------------
1402
1403 DlgEdForm::~DlgEdForm()
1404 {
1405     DBG_DTOR(DlgEdForm, NULL);
1406 }
1407
1408 //----------------------------------------------------------------------------
1409
1410 void DlgEdForm::SetDlgEditor( DlgEditor* pEditor )
1411 {
1412     pDlgEditor = pEditor;
1413     ImplInvalidateDeviceInfo();
1414 }
1415
1416 //----------------------------------------------------------------------------
1417
1418 void DlgEdForm::ImplInvalidateDeviceInfo()
1419 {
1420     mpDeviceInfo.reset();
1421 }
1422
1423 //----------------------------------------------------------------------------
1424
1425 void DlgEdForm::SetRectFromProps()
1426 {
1427     // get form position and size from properties
1428     Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
1429     if ( xPSet.is() )
1430     {
1431         sal_Int32 nXIn = 0, nYIn = 0, nWidthIn = 0, nHeightIn = 0;
1432         xPSet->getPropertyValue( DLGED_PROP_POSITIONX ) >>= nXIn;
1433         xPSet->getPropertyValue( DLGED_PROP_POSITIONY ) >>= nYIn;
1434         xPSet->getPropertyValue( DLGED_PROP_WIDTH ) >>= nWidthIn;
1435         xPSet->getPropertyValue( DLGED_PROP_HEIGHT ) >>= nHeightIn;
1436
1437         // transform coordinates
1438         sal_Int32 nXOut, nYOut, nWidthOut, nHeightOut;
1439         if ( TransformFormToSdrCoordinates( nXIn, nYIn, nWidthIn, nHeightIn, nXOut, nYOut, nWidthOut, nHeightOut ) )
1440         {
1441             // set rectangle position and size
1442             Point aPoint( nXOut, nYOut );
1443             Size aSize( nWidthOut, nHeightOut );
1444             SetSnapRect( Rectangle( aPoint, aSize ) );
1445         }
1446     }
1447 }
1448
1449 //----------------------------------------------------------------------------
1450
1451 void DlgEdForm::SetPropsFromRect()
1452 {
1453     // get form position and size from rectangle
1454     Rectangle aRect_ = GetSnapRect();
1455     sal_Int32 nXIn = aRect_.Left();
1456     sal_Int32 nYIn = aRect_.Top();
1457     sal_Int32 nWidthIn = aRect_.GetWidth();
1458     sal_Int32 nHeightIn = aRect_.GetHeight();
1459
1460     // transform coordinates
1461     sal_Int32 nXOut, nYOut, nWidthOut, nHeightOut;
1462     if ( TransformSdrToFormCoordinates( nXIn, nYIn, nWidthIn, nHeightIn, nXOut, nYOut, nWidthOut, nHeightOut ) )
1463     {
1464         // set properties
1465         Reference< beans::XPropertySet > xPSet( GetUnoControlModel(), UNO_QUERY );
1466         if ( xPSet.is() )
1467         {
1468             Any aValue;
1469             aValue <<= nXOut;
1470             xPSet->setPropertyValue( DLGED_PROP_POSITIONX, aValue );
1471             aValue <<= nYOut;
1472             xPSet->setPropertyValue( DLGED_PROP_POSITIONY, aValue );
1473             aValue <<= nWidthOut;
1474             xPSet->setPropertyValue( DLGED_PROP_WIDTH, aValue );
1475             aValue <<= nHeightOut;
1476             xPSet->setPropertyValue( DLGED_PROP_HEIGHT, aValue );
1477         }
1478     }
1479 }
1480
1481 //----------------------------------------------------------------------------
1482
1483 void DlgEdForm::AddChild( DlgEdObj* pDlgEdObj )
1484 {
1485     pChilds.push_back( pDlgEdObj );
1486 }
1487
1488 //----------------------------------------------------------------------------
1489
1490 void DlgEdForm::RemoveChild( DlgEdObj* pDlgEdObj )
1491 {
1492     pChilds.erase( ::std::find( pChilds.begin() , pChilds.end() , pDlgEdObj ) );
1493 }
1494
1495 //----------------------------------------------------------------------------
1496
1497 void DlgEdForm::PositionAndSizeChange( const beans::PropertyChangeEvent& evt )
1498 {
1499     DlgEditor* pEditor = GetDlgEditor();
1500     DBG_ASSERT( pEditor, "DlgEdForm::PositionAndSizeChange: no dialog editor!" );
1501     if ( pEditor )
1502     {
1503         DlgEdPage* pPage_ = pEditor->GetPage();
1504         DBG_ASSERT( pPage_, "DlgEdForm::PositionAndSizeChange: no page!" );
1505         if ( pPage_ )
1506         {
1507             sal_Int32 nPageXIn = 0;
1508             sal_Int32 nPageYIn = 0;
1509             Size aPageSize = pPage_->GetSize();
1510             sal_Int32 nPageWidthIn = aPageSize.Width();
1511             sal_Int32 nPageHeightIn = aPageSize.Height();
1512             sal_Int32 nPageX, nPageY, nPageWidth, nPageHeight;
1513             if ( TransformSdrToFormCoordinates( nPageXIn, nPageYIn, nPageWidthIn, nPageHeightIn, nPageX, nPageY, nPageWidth, nPageHeight ) )
1514             {
1515                 Reference< beans::XPropertySet > xPSetForm( GetUnoControlModel(), UNO_QUERY );
1516                 if ( xPSetForm.is() )
1517                 {
1518                     sal_Int32 nValue = 0;
1519                     evt.NewValue >>= nValue;
1520                     sal_Int32 nNewValue = nValue;
1521
1522                     if ( evt.PropertyName == DLGED_PROP_POSITIONX )
1523                     {
1524                         if ( nNewValue < nPageX )
1525                             nNewValue = nPageX;
1526                     }
1527                     else if ( evt.PropertyName == DLGED_PROP_POSITIONY )
1528                     {
1529                         if ( nNewValue < nPageY )
1530                             nNewValue = nPageY;
1531                     }
1532                     else if ( evt.PropertyName == DLGED_PROP_WIDTH )
1533                     {
1534                         if ( nNewValue < 1 )
1535                             nNewValue = 1;
1536                     }
1537                     else if ( evt.PropertyName == DLGED_PROP_HEIGHT )
1538                     {
1539                         if ( nNewValue < 1 )
1540                             nNewValue = 1;
1541                     }
1542
1543                     if ( nNewValue != nValue )
1544                     {
1545                         Any aNewValue;
1546                         aNewValue <<= nNewValue;
1547                         EndListening( sal_False );
1548                         xPSetForm->setPropertyValue( evt.PropertyName, aNewValue );
1549                         StartListening();
1550                     }
1551                 }
1552             }
1553
1554             bool bAdjustedPageSize = pEditor->AdjustPageSize();
1555             SetRectFromProps();
1556             ::std::vector< DlgEdObj* >::iterator aIter;
1557             ::std::vector< DlgEdObj* > aChildList = ((DlgEdForm*)this)->GetChilds();
1558
1559             if ( bAdjustedPageSize )
1560             {
1561                 pEditor->InitScrollBars();
1562                 aPageSize = pPage_->GetSize();
1563                 nPageWidthIn = aPageSize.Width();
1564                 nPageHeightIn = aPageSize.Height();
1565                 if ( TransformSdrToControlCoordinates( nPageXIn, nPageYIn, nPageWidthIn, nPageHeightIn, nPageX, nPageY, nPageWidth, nPageHeight ) )
1566                 {
1567                     for ( aIter = aChildList.begin(); aIter != aChildList.end(); aIter++ )
1568                     {
1569                         Reference< beans::XPropertySet > xPSet( (*aIter)->GetUnoControlModel(), UNO_QUERY );
1570                         if ( xPSet.is() )
1571                         {
1572                             sal_Int32 nX = 0, nY = 0, nWidth = 0, nHeight = 0;
1573                             xPSet->getPropertyValue( DLGED_PROP_POSITIONX ) >>= nX;
1574                             xPSet->getPropertyValue( DLGED_PROP_POSITIONY ) >>= nY;
1575                             xPSet->getPropertyValue( DLGED_PROP_WIDTH ) >>= nWidth;
1576                             xPSet->getPropertyValue( DLGED_PROP_HEIGHT ) >>= nHeight;
1577
1578                             sal_Int32 nNewX = nX;
1579                             if ( nX + nWidth > nPageX + nPageWidth )
1580                             {
1581                                 nNewX = nPageX + nPageWidth - nWidth;
1582                                 if ( nNewX < nPageX )
1583                                     nNewX = nPageX;
1584                             }
1585                             if ( nNewX != nX )
1586                             {
1587                                 Any aValue;
1588                                 aValue <<= nNewX;
1589                                 EndListening( sal_False );
1590                                 xPSet->setPropertyValue( DLGED_PROP_POSITIONX, aValue );
1591                                 StartListening();
1592                             }
1593
1594                             sal_Int32 nNewY = nY;
1595                             if ( nY + nHeight > nPageY + nPageHeight )
1596                             {
1597                                 nNewY = nPageY + nPageHeight - nHeight;
1598                                 if ( nNewY < nPageY )
1599                                     nNewY = nPageY;
1600                             }
1601                             if ( nNewY != nY )
1602                             {
1603                                 Any aValue;
1604                                 aValue <<= nNewY;
1605                                 EndListening( sal_False );
1606                                 xPSet->setPropertyValue( DLGED_PROP_POSITIONY, aValue );
1607                                 StartListening();
1608                             }
1609                         }
1610                     }
1611                 }
1612             }
1613
1614             for ( aIter = aChildList.begin(); aIter != aChildList.end(); aIter++ )
1615             {
1616                 (*aIter)->SetRectFromProps();
1617             }
1618         }
1619     }
1620 }
1621
1622 //----------------------------------------------------------------------------
1623
1624 void DlgEdForm::UpdateStep()
1625 {
1626     ULONG nObjCount;
1627     SdrPage* pSdrPage = GetPage();
1628
1629     if ( pSdrPage && ( ( nObjCount = pSdrPage->GetObjCount() ) > 0 ) )
1630     {
1631         for ( ULONG i = 0 ; i < nObjCount ; i++ )
1632         {
1633             SdrObject* pObj = pSdrPage->GetObj(i);
1634             DlgEdObj* pDlgEdObj = PTR_CAST(DlgEdObj, pObj);
1635             if ( pDlgEdObj && !pDlgEdObj->ISA(DlgEdForm) )
1636                 pDlgEdObj->UpdateStep();
1637         }
1638     }
1639 }
1640
1641 //----------------------------------------------------------------------------
1642
1643 void DlgEdForm::UpdateTabIndices()
1644 {
1645     // stop listening with all children
1646     ::std::vector<DlgEdObj*>::iterator aIter;
1647     for ( aIter = pChilds.begin() ; aIter != pChilds.end() ; ++aIter )
1648     {
1649         (*aIter)->EndListening( sal_False );
1650     }
1651
1652     Reference< ::com::sun::star::container::XNameAccess > xNameAcc( GetUnoControlModel() , UNO_QUERY );
1653     if ( xNameAcc.is() )
1654     {
1655         // get sequence of control names
1656         Sequence< ::rtl::OUString > aNames = xNameAcc->getElementNames();
1657         const ::rtl::OUString* pNames = aNames.getConstArray();
1658         sal_Int32 nCtrls = aNames.getLength();
1659
1660         // create a map of tab indices and control names, sorted by tab index
1661         IndexToNameMap aIndexToNameMap;
1662         for ( sal_Int16 i = 0; i < nCtrls; ++i )
1663         {
1664             // get name
1665             ::rtl::OUString aName( pNames[i] );
1666
1667             // get tab index
1668             sal_Int16 nTabIndex = -1;
1669             Any aCtrl = xNameAcc->getByName( aName );
1670             Reference< ::com::sun::star::beans::XPropertySet > xPSet;
1671                aCtrl >>= xPSet;
1672             if ( xPSet.is() )
1673                 xPSet->getPropertyValue( DLGED_PROP_TABINDEX ) >>= nTabIndex;
1674
1675             // insert into map
1676             aIndexToNameMap.insert( IndexToNameMap::value_type( nTabIndex, aName ) );
1677         }
1678
1679         // set new tab indices
1680         sal_Int16 nNewTabIndex = 0;
1681         for ( IndexToNameMap::iterator aIt = aIndexToNameMap.begin(); aIt != aIndexToNameMap.end(); ++aIt )
1682         {
1683             Any aCtrl = xNameAcc->getByName( aIt->second );
1684             Reference< beans::XPropertySet > xPSet;
1685                aCtrl >>= xPSet;
1686             if ( xPSet.is() )
1687             {
1688                 Any aTabIndex;
1689                 aTabIndex <<= (sal_Int16) nNewTabIndex++;
1690                 xPSet->setPropertyValue( DLGED_PROP_TABINDEX, aTabIndex );
1691             }
1692         }
1693
1694         // #110559#
1695         UpdateTabOrderAndGroups();
1696     }
1697
1698     // start listening with all children
1699     for ( aIter = pChilds.begin() ; aIter != pChilds.end() ; ++aIter )
1700     {
1701         (*aIter)->StartListening();
1702     }
1703 }
1704
1705 //----------------------------------------------------------------------------
1706
1707 void DlgEdForm::UpdateTabOrder()
1708 {
1709     // #110559#
1710     // When the tabindex of a control model changes, the dialog control is
1711     // notified about those changes. Due to #109067# (bad performance of
1712     // dialog editor) the dialog control doesn't activate the tab order
1713     // in design mode. When the dialog editor has reordered all
1714     // tabindices, this method allows to activate the taborder afterwards.
1715
1716     Reference< awt::XUnoControlContainer > xCont( GetControl(), UNO_QUERY );
1717     if ( xCont.is() )
1718     {
1719         Sequence< Reference< awt::XTabController > > aSeqTabCtrls = xCont->getTabControllers();
1720         const Reference< awt::XTabController >* pTabCtrls = aSeqTabCtrls.getConstArray();
1721         sal_Int32 nCount = aSeqTabCtrls.getLength();
1722         for ( sal_Int32 i = 0; i < nCount; ++i )
1723             pTabCtrls[i]->activateTabOrder();
1724     }
1725 }
1726
1727 //----------------------------------------------------------------------------
1728
1729 void DlgEdForm::UpdateGroups()
1730 {
1731     // #110559#
1732     // The grouping of radio buttons in a dialog is done by vcl.
1733     // In the dialog editor we have two views (=controls) for one
1734     // radio button model. One control is owned by the dialog control,
1735     // but not visible in design mode. The other control is owned by
1736     // the drawing layer object. Whereas the grouping of the first
1737     // control is done by vcl, the grouping of the control in the
1738     // drawing layer has to be done here.
1739
1740     Reference< awt::XTabControllerModel > xTabModel( GetUnoControlModel() , UNO_QUERY );
1741     if ( xTabModel.is() )
1742     {
1743         // create a global list of controls that belong to the dialog
1744         ::std::vector<DlgEdObj*> aChildList = GetChilds();
1745         sal_uInt32 nSize = aChildList.size();
1746         Sequence< Reference< awt::XControl > > aSeqControls( nSize );
1747         for ( sal_uInt32 i = 0; i < nSize; ++i )
1748             aSeqControls.getArray()[i] = Reference< awt::XControl >( aChildList[i]->GetControl(), UNO_QUERY );
1749
1750         sal_Int32 nGroupCount = xTabModel->getGroupCount();
1751         for ( sal_Int32 nGroup = 0; nGroup < nGroupCount; ++nGroup )
1752         {
1753             // get a list of control models that belong to this group
1754             ::rtl::OUString aName;
1755             Sequence< Reference< awt::XControlModel > > aSeqModels;
1756             xTabModel->getGroup( nGroup, aSeqModels, aName );
1757             const Reference< awt::XControlModel >* pModels = aSeqModels.getConstArray();
1758             sal_Int32 nModelCount = aSeqModels.getLength();
1759
1760             // create a list of peers that belong to this group
1761             Sequence< Reference< awt::XWindow > > aSeqPeers( nModelCount );
1762             for ( sal_Int32 nModel = 0; nModel < nModelCount; ++nModel )
1763             {
1764                 // for each control model find the corresponding control in the global list
1765                 const Reference< awt::XControl >* pControls = aSeqControls.getConstArray();
1766                 sal_Int32 nControlCount = aSeqControls.getLength();
1767                 for ( sal_Int32 nControl = 0; nControl < nControlCount; ++nControl )
1768                 {
1769                     const Reference< awt::XControl > xCtrl( pControls[nControl] );
1770                     if ( xCtrl.is() )
1771                     {
1772                         Reference< awt::XControlModel > xCtrlModel( xCtrl->getModel() );
1773                         if ( (awt::XControlModel*)xCtrlModel.get() == (awt::XControlModel*)pModels[nModel].get() )
1774                         {
1775                             // get the control peer and insert into the list of peers
1776                             aSeqPeers.getArray()[ nModel ] = Reference< awt::XWindow >( xCtrl->getPeer(), UNO_QUERY );
1777                             break;
1778                         }
1779                     }
1780                 }
1781             }
1782
1783             // set the group at the dialog peer
1784             Reference< awt::XControl > xDlg( GetControl(), UNO_QUERY );
1785             if ( xDlg.is() )
1786             {
1787                 Reference< awt::XVclContainerPeer > xDlgPeer( xDlg->getPeer(), UNO_QUERY );
1788                 if ( xDlgPeer.is() )
1789                     xDlgPeer->setGroup( aSeqPeers );
1790             }
1791         }
1792     }
1793 }
1794
1795 //----------------------------------------------------------------------------
1796
1797 void DlgEdForm::UpdateTabOrderAndGroups()
1798 {
1799     UpdateTabOrder();
1800     UpdateGroups();
1801 }
1802
1803 //----------------------------------------------------------------------------
1804
1805 void DlgEdForm::NbcMove( const Size& rSize )
1806 {
1807     SdrUnoObj::NbcMove( rSize );
1808
1809     // set geometry properties of form
1810     EndListening(sal_False);
1811     SetPropsFromRect();
1812     StartListening();
1813
1814     // set geometry properties of all childs
1815     ::std::vector<DlgEdObj*>::iterator aIter;
1816     for ( aIter = pChilds.begin() ; aIter != pChilds.end() ; aIter++ )
1817     {
1818         (*aIter)->EndListening(sal_False);
1819         (*aIter)->SetPropsFromRect();
1820         (*aIter)->StartListening();
1821     }
1822
1823     // dialog model changed
1824     GetDlgEditor()->SetDialogModelChanged(TRUE);
1825 }
1826
1827 //----------------------------------------------------------------------------
1828
1829 void DlgEdForm::NbcResize(const Point& rRef, const Fraction& xFract, const Fraction& yFract)
1830 {
1831     SdrUnoObj::NbcResize( rRef, xFract, yFract );
1832
1833     // set geometry properties of form
1834     EndListening(sal_False);
1835     SetPropsFromRect();
1836     StartListening();
1837
1838     // set geometry properties of all childs
1839     ::std::vector<DlgEdObj*>::iterator aIter;
1840     for ( aIter = pChilds.begin() ; aIter != pChilds.end() ; aIter++ )
1841     {
1842         (*aIter)->EndListening(sal_False);
1843         (*aIter)->SetPropsFromRect();
1844         (*aIter)->StartListening();
1845     }
1846
1847     // dialog model changed
1848     GetDlgEditor()->SetDialogModelChanged(TRUE);
1849 }
1850
1851 //----------------------------------------------------------------------------
1852
1853 FASTBOOL DlgEdForm::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
1854 {
1855     FASTBOOL bResult = SdrUnoObj::EndCreate(rStat, eCmd);
1856
1857     // stop listening
1858     EndListening(sal_False);
1859
1860     // set geometry properties
1861     SetPropsFromRect();
1862
1863     // dialog model changed
1864     GetDlgEditor()->SetDialogModelChanged(TRUE);
1865
1866     // start listening
1867     StartListening();
1868
1869     return bResult;
1870 }
1871
1872 //----------------------------------------------------------------------------
1873
1874 awt::DeviceInfo DlgEdForm::getDeviceInfo() const
1875 {
1876     awt::DeviceInfo aDeviceInfo;
1877
1878     DlgEditor* pEditor = GetDlgEditor();
1879     DBG_ASSERT( pEditor, "DlgEdForm::getDeviceInfo: no editor associated with the form object!" );
1880     if ( !pEditor )
1881         return aDeviceInfo;
1882
1883     Window* pWindow = pEditor->GetWindow();
1884     DBG_ASSERT( pWindow, "DlgEdForm::getDeviceInfo: no window associated with the editor!" );
1885     if ( !pWindow )
1886         return aDeviceInfo;
1887
1888     // obtain an XControl
1889     ::utl::SharedUNOComponent< awt::XControl > xDialogControl; // ensures auto-disposal, if needed
1890     xDialogControl.reset( GetControl(), ::utl::SharedUNOComponent< awt::XControl >::NoTakeOwnership );
1891     if ( !xDialogControl.is() )
1892     {
1893         // don't create a temporary control all the time, this method here is called
1894         // way too often. Instead, use a cached DeviceInfo.
1895         // 2007-02-05 / i74065 / frank.schoenheit@sun.com
1896         if ( !!mpDeviceInfo )
1897             return *mpDeviceInfo;
1898
1899         Reference< awt::XControlContainer > xEditorControlContainer( pEditor->GetWindowControlContainer() );
1900         xDialogControl.reset(
1901             GetTemporaryControlForWindow( *pWindow, xEditorControlContainer ),
1902             ::utl::SharedUNOComponent< awt::XControl >::TakeOwnership );
1903     }
1904
1905     Reference< awt::XDevice > xDialogDevice;
1906     if ( xDialogControl.is() )
1907         xDialogDevice.set( xDialogControl->getPeer(), UNO_QUERY );
1908     DBG_ASSERT( xDialogDevice.is(), "DlgEdForm::getDeviceInfo: no device!" );
1909     if ( xDialogDevice.is() )
1910         aDeviceInfo = xDialogDevice->getInfo();
1911
1912     mpDeviceInfo.reset( aDeviceInfo );
1913
1914     return aDeviceInfo;
1915 }
1916
1917 //----------------------------------------------------------------------------
1918
1919