svx/source/form/fmvwimp.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
  21 #include "fmdocumentclassification.hxx"
  22 #include "fmobj.hxx"
  23 #include "fmpgeimp.hxx"
  24 #include "fmprop.hrc"
  25 #include "svx/fmresids.hrc"
  26 #include "fmservs.hxx"
  27 #include "fmshimp.hxx"
  28 #include "svx/fmtools.hxx"
  29 #include "fmundo.hxx"
  30 #include "fmvwimp.hxx"
  31 #include "formcontrolfactory.hxx"
  32 #include "svx/sdrpaintwindow.hxx"
  33 #include "svx/svditer.hxx"
  34 #include "svx/dataaccessdescriptor.hxx"
  35 #include "svx/dialmgr.hxx"
  36 #include "svx/fmglob.hxx"
  37 #include "svx/fmmodel.hxx"
  38 #include "svx/fmpage.hxx"
  39 #include "svx/fmshell.hxx"
  40 #include "svx/fmview.hxx"
  41 #include "svx/sdrpagewindow.hxx"
  42 #include "svx/svdogrp.hxx"
  43 #include "svx/svdpagv.hxx"
  44 #include "svx/xmlexchg.hxx"
  45
  46 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  47 #include <com/sun/star/style/VerticalAlignment.hpp>
  48 #include <com/sun/star/lang/XInitialization.hpp>
  49 #include <com/sun/star/sdbc/XRowSet.hpp>
  50 #include <com/sun/star/form/XLoadable.hpp>
  51 #include <com/sun/star/awt/VisualEffect.hpp>
  52 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
  53 #include <com/sun/star/util/XNumberFormats.hpp>
  54 #include <com/sun/star/sdb/CommandType.hpp>
  55 #include <com/sun/star/sdbc/DataType.hpp>
  56 #include <com/sun/star/sdbc/ColumnValue.hpp>
  57 #include <com/sun/star/form/FormComponentType.hpp>
  58 #include <com/sun/star/form/FormButtonType.hpp>
  59 #include <com/sun/star/form/XReset.hpp>
  60 #include <com/sun/star/form/binding/XBindableValue.hpp>
  61 #include <com/sun/star/form/binding/XValueBinding.hpp>
  62 #include <com/sun/star/form/runtime/FormController.hpp>
  63 #include <com/sun/star/form/submission/XSubmissionSupplier.hpp>
  64 #include <com/sun/star/awt/XTabControllerModel.hpp>
  65 #include <com/sun/star/awt/XControlContainer.hpp>
  66 #include <com/sun/star/awt/XTabController.hpp>
  67 #include <com/sun/star/container/XIndexAccess.hpp>
  68 #include <com/sun/star/awt/XControl.hpp>
  69 #include <com/sun/star/lang/XUnoTunnel.hpp>
  70 #include <com/sun/star/sdbcx/XTablesSupplier.hpp>
  71 #include <com/sun/star/sdbc/XPreparedStatement.hpp>
  72 #include <com/sun/star/sdb/XQueriesSupplier.hpp>
  73 #include <com/sun/star/container/XContainer.hpp>
  74
  75 #include <comphelper/enumhelper.hxx>
  76 #include <comphelper/extract.hxx>
  77 #include <comphelper/namedvaluecollection.hxx>
  78 #include <comphelper/numbers.hxx>
  79 #include <comphelper/property.hxx>
  80 #include <comphelper/processfactory.hxx>
  81 #include <cppuhelper/exc_hlp.hxx>
  82 #include <unotools/moduleoptions.hxx>
  83 #include <tools/diagnose_ex.h>
  84 #include <vcl/msgbox.hxx>
  85 #include <vcl/stdtext.hxx>
  86 #include <osl/mutex.hxx>
  87 #include <connectivity/dbtools.hxx>
  88
  89 #include <algorithm>
  90
  91 using namespace ::comphelper;
  92 using namespace ::svx;
  93 using namespace ::svxform;
  94 using namespace ::dbtools;
  95
  96     using namespace ::com::sun::star;
  97     using ::com::sun::star::uno::Exception;
  98     using ::com::sun::star::uno::RuntimeException;
  99     using ::com::sun::star::uno::XInterface;
 100     using ::com::sun::star::uno::Sequence;
 101     using ::com::sun::star::uno::UNO_QUERY;
 102     using ::com::sun::star::uno::UNO_QUERY_THROW;
 103     using ::com::sun::star::uno::UNO_SET_THROW;
 104     using ::com::sun::star::uno::Type;
 105     using ::com::sun::star::uno::Reference;
 106     using ::com::sun::star::uno::Any;
 107     using ::com::sun::star::uno::makeAny;
 108     using ::com::sun::star::uno::XComponentContext;
 109     using ::com::sun::star::style::VerticalAlignment_MIDDLE;
 110     using ::com::sun::star::form::FormButtonType_SUBMIT;
 111     using ::com::sun::star::form::binding::XValueBinding;
 112     using ::com::sun::star::form::binding::XBindableValue;
 113     using ::com::sun::star::lang::XComponent;
 114     using ::com::sun::star::container::XIndexAccess;
 115     using ::com::sun::star::form::runtime::FormController;
 116     using ::com::sun::star::form::runtime::XFormController;
 117     using ::com::sun::star::script::XEventAttacherManager;
 118     using ::com::sun::star::awt::XTabControllerModel;
 119     using ::com::sun::star::container::XChild;
 120     using ::com::sun::star::container::XEnumeration;
 121     using ::com::sun::star::task::XInteractionHandler;
 122     using ::com::sun::star::lang::XInitialization;
 123     using ::com::sun::star::awt::XTabController;
 124     using ::com::sun::star::lang::XUnoTunnel;
 125     using ::com::sun::star::awt::XControlContainer;
 126     using ::com::sun::star::awt::XControl;
 127     using ::com::sun::star::form::XFormComponent;
 128     using ::com::sun::star::form::XForm;
 129     using ::com::sun::star::lang::IndexOutOfBoundsException;
 130     using ::com::sun::star::lang::WrappedTargetException;
 131     using ::com::sun::star::container::XContainer;
 132     using ::com::sun::star::container::ContainerEvent;
 133     using ::com::sun::star::lang::EventObject;
 134     using ::com::sun::star::beans::NamedValue;
 135     using ::com::sun::star::sdb::SQLErrorEvent;
 136     using ::com::sun::star::sdbc::XRowSet;
 137     using ::com::sun::star::beans::XPropertySet;
 138     using ::com::sun::star::container::XElementAccess;
 139     using ::com::sun::star::awt::XWindow;
 140     using ::com::sun::star::awt::FocusEvent;
 141     using ::com::sun::star::ui::dialogs::XExecutableDialog;
 142     using ::com::sun::star::sdbc::XDataSource;
 143     using ::com::sun::star::container::XIndexContainer;
 144     using ::com::sun::star::sdbc::XConnection;
 145     using ::com::sun::star::container::XNameAccess;
 146     using ::com::sun::star::sdb::SQLContext;
 147     using ::com::sun::star::sdbc::SQLWarning;
 148     using ::com::sun::star::sdbc::SQLException;
 149     using ::com::sun::star::util::XNumberFormatsSupplier;
 150     using ::com::sun::star::util::XNumberFormats;
 151     using ::com::sun::star::beans::XPropertySetInfo;
 152
 153     namespace FormComponentType = ::com::sun::star::form::FormComponentType;
 154     namespace CommandType = ::com::sun::star::sdb::CommandType;
 155     namespace DataType = ::com::sun::star::sdbc::DataType;
 156
 157
 158 class FmXFormView::ObjectRemoveListener : public SfxListener
 159 {
 160     FmXFormView* m_pParent;
 161 public:
 162     ObjectRemoveListener( FmXFormView* pParent );
 163     virtual void Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) SAL_OVERRIDE;
 164 };
 165
 166
 167
 168 FormViewPageWindowAdapter::FormViewPageWindowAdapter( const css::uno::Reference<css::uno::XComponentContext>& _rContext, const SdrPageWindow& _rWindow, FmXFormView* _pViewImpl )
 169 :   m_xControlContainer( _rWindow.GetControlContainer() ),
 170     m_xContext( _rContext ),
 171     m_pViewImpl( _pViewImpl ),
 172     m_pWindow( dynamic_cast< vcl::Window* >( &_rWindow.GetPaintWindow().GetOutputDevice() ) )
 173 {
 174
 175     // create an XFormController for every form
 176     FmFormPage* pFormPage = dynamic_cast< FmFormPage* >( _rWindow.GetPageView().GetPage() );
 177     DBG_ASSERT( pFormPage, "FormViewPageWindowAdapter::FormViewPageWindowAdapter: no FmFormPage found!" );
 178     if ( pFormPage )
 179     {
 180         try
 181         {
 182             Reference< XIndexAccess > xForms( pFormPage->GetForms(), UNO_QUERY_THROW );
 183             sal_uInt32 nLength = xForms->getCount();
 184             for (sal_uInt32 i = 0; i < nLength; i++)
 185             {
 186                 Reference< XForm > xForm( xForms->getByIndex(i), UNO_QUERY );
 187                 if ( xForm.is() )
 188                     setController( xForm, NULL );
 189             }
 190         }
 191         catch (const Exception&)
 192         {
 193             DBG_UNHANDLED_EXCEPTION();
 194         }
 195     }
 196 }
 197
 198 FormViewPageWindowAdapter::~FormViewPageWindowAdapter()
 199 {
 200 }
 201
 202 void FormViewPageWindowAdapter::dispose()
 203 {
 204     for (   ::std::vector< Reference< XFormController > >::const_iterator i = m_aControllerList.begin();
 205             i != m_aControllerList.end();
 206             ++i
 207         )
 208     {
 209         try
 210         {
 211             Reference< XFormController > xController( *i, UNO_QUERY_THROW );
 212
 213             // detaching the events
 214             Reference< XChild > xControllerModel( xController->getModel(), UNO_QUERY );
 215             if ( xControllerModel.is() )
 216             {
 217                 Reference< XEventAttacherManager >  xEventManager( xControllerModel->getParent(), UNO_QUERY_THROW );
 218                 Reference< XInterface > xControllerNormalized( xController, UNO_QUERY_THROW );
 219                 xEventManager->detach( i - m_aControllerList.begin(), xControllerNormalized );
 220             }
 221
 222             // dispose the formcontroller
 223             xController->dispose();
 224         }
 225         catch (const Exception&)
 226         {
 227             DBG_UNHANDLED_EXCEPTION();
 228         }
 229     }
 230
 231     m_aControllerList.clear();
 232 }
 233
 234 sal_Bool SAL_CALL FormViewPageWindowAdapter::hasElements() throw( RuntimeException, std::exception )
 235 {
 236     return getCount() != 0;
 237 }
 238
 239 Type SAL_CALL  FormViewPageWindowAdapter::getElementType() throw( RuntimeException, std::exception )
 240 {
 241     return cppu::UnoType<XFormController>::get();
 242 }
 243
 244 // XIndexAccess
 245 sal_Int32 SAL_CALL FormViewPageWindowAdapter::getCount() throw( RuntimeException, std::exception )
 246 {
 247     return m_aControllerList.size();
 248 }
 249
 250 Any SAL_CALL FormViewPageWindowAdapter::getByIndex(sal_Int32 nIndex) throw( IndexOutOfBoundsException, WrappedTargetException, RuntimeException, std::exception )
 251 {
 252     if (nIndex < 0 ||
 253         nIndex >= getCount())
 254         throw IndexOutOfBoundsException();
 255
 256     Any aElement;
 257     aElement <<= m_aControllerList[nIndex];
 258     return aElement;
 259 }
 260
 261 void SAL_CALL FormViewPageWindowAdapter::makeVisible( const Reference< XControl >& _Control ) throw (RuntimeException, std::exception)
 262 {
 263     SolarMutexGuard aSolarGuard;
 264
 265     Reference< XWindow >  xWindow( _Control, UNO_QUERY );
 266     if ( xWindow.is() && m_pViewImpl->getView() && m_pWindow )
 267     {
 268         awt::Rectangle aRect = xWindow->getPosSize();
 269         ::Rectangle aNewRect( aRect.X, aRect.Y, aRect.X + aRect.Width, aRect.Y + aRect.Height );
 270         aNewRect = m_pWindow->PixelToLogic( aNewRect );
 271         m_pViewImpl->getView()->MakeVisible( aNewRect, *m_pWindow );
 272     }
 273 }
 274
 275 Reference< XFormController >  getControllerSearchChildren( const Reference< XIndexAccess > & xIndex, const Reference< XTabControllerModel > & xModel)
 276 {
 277     if (xIndex.is() && xIndex->getCount())
 278     {
 279         Reference< XFormController >  xController;
 280
 281         for (sal_Int32 n = xIndex->getCount(); n-- && !xController.is(); )
 282         {
 283             xIndex->getByIndex(n) >>= xController;
 284             if ((XTabControllerModel*)xModel.get() == (XTabControllerModel*)xController->getModel().get())
 285                 return xController;
 286             else
 287             {
 288                 xController = getControllerSearchChildren(xController, xModel);
 289                 if ( xController.is() )
 290                     return xController;
 291             }
 292         }
 293     }
 294     return Reference< XFormController > ();
 295 }
 296
 297 // Search the according controller
 298 Reference< XFormController >  FormViewPageWindowAdapter::getController( const Reference< XForm > & xForm ) const
 299 {
 300     Reference< XTabControllerModel >  xModel(xForm, UNO_QUERY);
 301     for (::std::vector< Reference< XFormController > >::const_iterator i = m_aControllerList.begin();
 302          i != m_aControllerList.end(); ++i)
 303     {
 304         if ((XTabControllerModel*)(*i)->getModel().get() == (XTabControllerModel*)xModel.get())
 305             return *i;
 306
 307         // the current-round controller isn't the right one. perhaps one of its children ?
 308         Reference< XFormController >  xChildSearch = getControllerSearchChildren(Reference< XIndexAccess > (*i, UNO_QUERY), xModel);
 309         if (xChildSearch.is())
 310             return xChildSearch;
 311     }
 312     return Reference< XFormController > ();
 313 }
 314
 315
 316 void FormViewPageWindowAdapter::setController(const Reference< XForm > & xForm, const Reference< XFormController >& _rxParentController )
 317 {
 318     DBG_ASSERT( xForm.is(), "FormViewPageWindowAdapter::setController: there should be a form!" );
 319     Reference< XIndexAccess >  xFormCps(xForm, UNO_QUERY);
 320     if (!xFormCps.is())
 321         return;
 322
 323     Reference< XTabControllerModel >  xTabOrder(xForm, UNO_QUERY);
 324
 325     // create a form controller
 326     Reference< XFormController > xController( FormController::create(m_xContext) );
 327
 328     Reference< XInteractionHandler > xHandler;
 329     if ( _rxParentController.is() )
 330         xHandler = _rxParentController->getInteractionHandler();
 331     else
 332     {
 333         // TODO: should we create a default handler? Not really necessary, since the
 334         // FormController itself has a default fallback
 335     }
 336     if ( xHandler.is() )
 337         xController->setInteractionHandler( xHandler );
 338
 339     xController->setContext( this );
 340
 341     xController->setModel( xTabOrder );
 342     xController->setContainer( m_xControlContainer );
 343     xController->activateTabOrder();
 344     xController->addActivateListener( m_pViewImpl );
 345
 346     if ( _rxParentController.is() )
 347         _rxParentController->addChildController( xController );
 348     else
 349     {
 350         m_aControllerList.push_back(xController);
 351
 352         xController->setParent( *this );
 353
 354         // attaching the events
 355         Reference< XEventAttacherManager > xEventManager( xForm->getParent(), UNO_QUERY );
 356         xEventManager->attach(m_aControllerList.size() - 1, Reference<XInterface>( xController, UNO_QUERY ), makeAny(xController) );
 357     }
 358
 359     // jetzt die Subforms durchgehen
 360     sal_uInt32 nLength = xFormCps->getCount();
 361     Reference< XForm >  xSubForm;
 362     for (sal_uInt32 i = 0; i < nLength; i++)
 363     {
 364         if ( xFormCps->getByIndex(i) >>= xSubForm )
 365             setController( xSubForm, xController );
 366     }
 367 }
 368
 369
 370 void FormViewPageWindowAdapter::updateTabOrder( const Reference< XForm >& _rxForm )
 371 {
 372     OSL_PRECOND( _rxForm.is(), "FormViewPageWindowAdapter::updateTabOrder: illegal argument!" );
 373     if ( !_rxForm.is() )
 374         return;
 375
 376     try
 377     {
 378         Reference< XTabController > xTabCtrl( getController( _rxForm ).get() );
 379         if ( xTabCtrl.is() )
 380         {   // if there already is a TabController for this form, then delegate the "updateTabOrder" request
 381             xTabCtrl->activateTabOrder();
 382         }
 383         else
 384         {   // otherwise, create a TabController
 385
 386             // if it's a sub form, then we must ensure there exist TabControllers
 387             // for all its ancestors, too
 388             Reference< XForm > xParentForm( _rxForm->getParent(), UNO_QUERY );
 389             // there is a parent form -> look for the respective controller
 390             Reference< XFormController > xParentController;
 391             if ( xParentForm.is() )
 392                 xParentController.set( getController( xParentForm ), UNO_QUERY );
 393
 394             setController( _rxForm, xParentController );
 395         }
 396     }
 397     catch (const Exception&)
 398     {
 399         DBG_UNHANDLED_EXCEPTION();
 400     }
 401 }
 402
 403
 404 FmXFormView::FmXFormView(FmFormView* _pView )
 405     :m_pMarkedGrid(NULL)
 406     ,m_pView(_pView)
 407     ,m_nActivationEvent(0)
 408     ,m_nErrorMessageEvent( 0 )
 409     ,m_nAutoFocusEvent( 0 )
 410     ,m_nControlWizardEvent( 0 )
 411     ,m_pWatchStoredList( NULL )
 412     ,m_bFirstActivation( true )
 413     ,m_isTabOrderUpdateSuspended( false )
 414 {
 415 }
 416
 417
 418 void FmXFormView::cancelEvents()
 419 {
 420     if ( m_nActivationEvent )
 421     {
 422         Application::RemoveUserEvent( m_nActivationEvent );
 423         m_nActivationEvent = 0;
 424     }
 425
 426     if ( m_nErrorMessageEvent )
 427     {
 428         Application::RemoveUserEvent( m_nErrorMessageEvent );
 429         m_nErrorMessageEvent = 0;
 430     }
 431
 432     if ( m_nAutoFocusEvent )
 433     {
 434         Application::RemoveUserEvent( m_nAutoFocusEvent );
 435         m_nAutoFocusEvent = 0;
 436     }
 437
 438     if ( m_nControlWizardEvent )
 439     {
 440         Application::RemoveUserEvent( m_nControlWizardEvent );
 441         m_nControlWizardEvent = 0;
 442     }
 443 }
 444
 445
 446 void FmXFormView::notifyViewDying( )
 447 {
 448     DBG_ASSERT( m_pView, "FmXFormView::notifyViewDying: my view already died!" );
 449     m_pView = NULL;
 450     cancelEvents();
 451 }
 452
 453
 454 FmXFormView::~FmXFormView()
 455 {
 456     DBG_ASSERT( m_aPageWindowAdapters.empty(), "FmXFormView::~FmXFormView: Window list not empty!" );
 457     if ( !m_aPageWindowAdapters.empty() )
 458     {
 459         for (   PageWindowAdapterList::const_iterator loop = m_aPageWindowAdapters.begin();
 460                 loop != m_aPageWindowAdapters.end();
 461                 ++loop
 462             )
 463         {
 464             (*loop)->dispose();
 465         }
 466     }
 467
 468     cancelEvents();
 469
 470     delete m_pWatchStoredList;
 471     m_pWatchStoredList = NULL;
 472 }
 473
 474 //      EventListener
 475
 476 void SAL_CALL FmXFormView::disposing(const EventObject& Source) throw( RuntimeException, std::exception )
 477 {
 478     if ( m_xWindow.is() && Source.Source == m_xWindow )
 479         removeGridWindowListening();
 480 }
 481
 482 // XFormControllerListener
 483
 484 void SAL_CALL FmXFormView::formActivated(const EventObject& rEvent) throw( RuntimeException, std::exception )
 485 {
 486     if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() )
 487         m_pView->GetFormShell()->GetImpl()->formActivated( rEvent );
 488 }
 489
 490
 491 void SAL_CALL FmXFormView::formDeactivated(const EventObject& rEvent) throw( RuntimeException, std::exception )
 492 {
 493     if ( m_pView && m_pView->GetFormShell() && m_pView->GetFormShell()->GetImpl() )
 494         m_pView->GetFormShell()->GetImpl()->formDeactivated( rEvent );
 495 }
 496
 497 // XContainerListener
 498
 499 void SAL_CALL FmXFormView::elementInserted(const ContainerEvent& evt) throw( RuntimeException, std::exception )
 500 {
 501     try
 502     {
 503         Reference< XControlContainer > xControlContainer( evt.Source, UNO_QUERY_THROW );
 504         Reference< XControl > xControl( evt.Element, UNO_QUERY_THROW );
 505         Reference< XFormComponent > xControlModel( xControl->getModel(), UNO_QUERY_THROW );
 506         Reference< XForm > xForm( xControlModel->getParent(), UNO_QUERY_THROW );
 507
 508         if ( m_isTabOrderUpdateSuspended )
 509         {
 510             // remember the container and the control, so we can update the tab order on resumeTabOrderUpdate
 511             m_aNeedTabOrderUpdate[ xControlContainer ].insert( xForm );
 512         }
 513         else
 514         {
 515             PFormViewPageWindowAdapter pAdapter = findWindow( xControlContainer );
 516             if ( pAdapter.is() )
 517                 pAdapter->updateTabOrder( xForm );
 518         }
 519     }
 520     catch (const Exception&)
 521     {
 522         DBG_UNHANDLED_EXCEPTION();
 523     }
 524 }
 525
 526
 527 void SAL_CALL FmXFormView::elementReplaced(const ContainerEvent& evt) throw( RuntimeException, std::exception )
 528 {
 529     elementInserted(evt);
 530 }
 531
 532
 533 void SAL_CALL FmXFormView::elementRemoved(const ContainerEvent& /*evt*/) throw( RuntimeException, std::exception )
 534 {
 535 }
 536
 537
 538 PFormViewPageWindowAdapter FmXFormView::findWindow( const Reference< XControlContainer >& _rxCC )  const
 539 {
 540     for (   PageWindowAdapterList::const_iterator i = m_aPageWindowAdapters.begin();
 541             i != m_aPageWindowAdapters.end();
 542             ++i
 543         )
 544     {
 545         if ( _rxCC == (*i)->getControlContainer() )
 546             return *i;
 547     }
 548     return NULL;
 549 }
 550
 551
 552 void FmXFormView::addWindow(const SdrPageWindow& rWindow)
 553 {
 554     FmFormPage* pFormPage = PTR_CAST( FmFormPage, rWindow.GetPageView().GetPage() );
 555     if ( !pFormPage )
 556         return;
 557
 558     Reference< XControlContainer > xCC = rWindow.GetControlContainer();
 559     if  (   xCC.is()
 560         &&  ( !findWindow( xCC ).is() )
 561         )
 562     {
 563         PFormViewPageWindowAdapter pAdapter = new FormViewPageWindowAdapter( comphelper::getProcessComponentContext(), rWindow, this );
 564         m_aPageWindowAdapters.push_back( pAdapter );
 565
 566         // Am ControlContainer horchen um Aenderungen mitzbekommen
 567         Reference< XContainer >  xContainer( xCC, UNO_QUERY );
 568         if ( xContainer.is() )
 569             xContainer->addContainerListener( this );
 570     }
 571 }
 572
 573
 574 void FmXFormView::removeWindow( const Reference< XControlContainer >& _rxCC )
 575 {
 576     // Wird gerufen, wenn
 577     // - in den Design-Modus geschaltet wird
 578     // - ein Window geloescht wird, waehrend man im Design-Modus ist
 579     // - der Control-Container fuer ein Window entfernt wird, waehrend
 580     //   der aktive Modus eingeschaltet ist.
 581
 582     for (   PageWindowAdapterList::iterator i = m_aPageWindowAdapters.begin();
 583             i != m_aPageWindowAdapters.end();
 584             ++i
 585         )
 586     {
 587         if ( _rxCC != (*i)->getControlContainer() )
 588             continue;
 589
 590         Reference< XContainer >  xContainer( _rxCC, UNO_QUERY );
 591         if ( xContainer.is() )
 592             xContainer->removeContainerListener( this );
 593
 594         (*i)->dispose();
 595         m_aPageWindowAdapters.erase( i );
 596         break;
 597     }
 598 }
 599
 600
 601 void FmXFormView::displayAsyncErrorMessage( const SQLErrorEvent& _rEvent )
 602 {
 603     DBG_ASSERT( 0 == m_nErrorMessageEvent, "FmXFormView::displayAsyncErrorMessage: not too fast, please!" );
 604         // This should not happen - usually, the PostUserEvent is faster than any possible user
 605         // interaction which could trigger a new error. If it happens, we need a queue for the events.
 606     m_aAsyncError = _rEvent;
 607     m_nErrorMessageEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnDelayedErrorMessage ) );
 608 }
 609
 610
 611 IMPL_LINK_NOARG(FmXFormView, OnDelayedErrorMessage)
 612 {
 613     m_nErrorMessageEvent = 0;
 614     displayException( m_aAsyncError );
 615     return 0L;
 616 }
 617
 618
 619 void FmXFormView::onFirstViewActivation( const FmFormModel* _pDocModel )
 620 {
 621     if ( _pDocModel && _pDocModel->GetAutoControlFocus() )
 622         m_nAutoFocusEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnAutoFocus ) );
 623 }
 624
 625
 626 void FmXFormView::suspendTabOrderUpdate()
 627 {
 628     OSL_ENSURE( !m_isTabOrderUpdateSuspended, "FmXFormView::suspendTabOrderUpdate: nesting not allowed!" );
 629     m_isTabOrderUpdateSuspended = true;
 630 }
 631
 632
 633 void FmXFormView::resumeTabOrderUpdate()
 634 {
 635     OSL_ENSURE( m_isTabOrderUpdateSuspended, "FmXFormView::resumeTabOrderUpdate: not suspended!" );
 636     m_isTabOrderUpdateSuspended = false;
 637
 638     // update the tab orders for all components which were collected since the suspendTabOrderUpdate call.
 639     for (   MapControlContainerToSetOfForms::const_iterator container = m_aNeedTabOrderUpdate.begin();
 640             container != m_aNeedTabOrderUpdate.end();
 641             ++container
 642         )
 643     {
 644         PFormViewPageWindowAdapter pAdapter = findWindow( container->first );
 645         if ( !pAdapter.is() )
 646             continue;
 647
 648         for (   SetOfForms::const_iterator form = container->second.begin();
 649                 form != container->second.end();
 650                 ++form
 651             )
 652         {
 653             pAdapter->updateTabOrder( *form );
 654         }
 655     }
 656     m_aNeedTabOrderUpdate.clear();
 657 }
 658
 659 namespace
 660 {
 661     bool isActivableDatabaseForm(const Reference< XFormController > &xController)
 662     {
 663         // only database forms are to be activated
 664         Reference< XRowSet >  xForm(xController->getModel(), UNO_QUERY);
 665         if ( !xForm.is() || !getConnection( xForm ).is() )
 666             return false;
 667
 668         Reference< XPropertySet > xFormSet( xForm, UNO_QUERY );
 669         if ( !xFormSet.is() )
 670         {
 671             SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form which does not have properties?" );
 672             return false;
 673         }
 674
 675         const OUString aSource = ::comphelper::getString( xFormSet->getPropertyValue( FM_PROP_COMMAND ) );
 676
 677         return !aSource.isEmpty();
 678     }
 679
 680     class find_active_databaseform
 681     {
 682         const Reference< XFormController > xActiveController;
 683
 684     public:
 685
 686         find_active_databaseform( const Reference< XFormController > _xActiveController )
 687             : xActiveController(_xActiveController )
 688         {}
 689
 690         Reference < XFormController > operator() (const Reference< XFormController > &xController)
 691         {
 692             if(xController == xActiveController && isActivableDatabaseForm(xController))
 693                 return xController;
 694
 695             Reference< XIndexAccess > xSubControllers( xController, UNO_QUERY );
 696             if ( !xSubControllers.is() )
 697             {
 698                 SAL_WARN( "svx.form", "FmXFormView::OnActivate: a form controller which does not have children?" );
 699                 return nullptr;
 700             }
 701
 702             for(sal_Int32 i = 0; i < xSubControllers->getCount(); ++i)
 703             {
 704                 const Any a(xSubControllers->getByIndex(i));
 705                 Reference < XFormController > xI;
 706                 if ((a >>= xI) && xI.is())
 707                 {
 708                     Reference < XFormController > xRes(operator()(xI));
 709                     if (xRes.is())
 710                         return xRes;
 711                 }
 712             }
 713
 714             return nullptr;
 715         }
 716     };
 717 }
 718
 719
 720 IMPL_LINK_NOARG(FmXFormView, OnActivate)
 721 {
 722     m_nActivationEvent = 0;
 723
 724     if ( !m_pView )
 725     {
 726         OSL_FAIL( "FmXFormView::OnActivate: well .... seems we have a timing problem (the view already died)!" );
 727         return 0;
 728     }
 729
 730     // setting the controller to activate
 731     if (m_pView->GetFormShell() && m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)
 732     {
 733         FmXFormShell* const pShImpl =  m_pView->GetFormShell()->GetImpl();
 734
 735         if(!pShImpl)
 736             return 0;
 737
 738         find_active_databaseform fad(pShImpl->getActiveController());
 739
 740         vcl::Window* pWindow = const_cast<vcl::Window*>(static_cast<const vcl::Window*>(m_pView->GetActualOutDev()));
 741         PFormViewPageWindowAdapter pAdapter = m_aPageWindowAdapters.empty() ? NULL : m_aPageWindowAdapters[0];
 742         for (   PageWindowAdapterList::const_iterator i = m_aPageWindowAdapters.begin();
 743                 i != m_aPageWindowAdapters.end();
 744                 ++i
 745             )
 746         {
 747             if ( pWindow == (*i)->getWindow() )
 748                 pAdapter =*i;
 749         }
 750
 751         if ( pAdapter.get() )
 752         {
 753             Reference< XFormController > xControllerToActivate;
 754             for (   ::std::vector< Reference< XFormController > >::const_iterator i = pAdapter->GetList().begin();
 755                     i != pAdapter->GetList().end();
 756                     ++i
 757                 )
 758             {
 759                 const Reference< XFormController > & xController = *i;
 760                 if ( !xController.is() )
 761                     continue;
 762
 763                 {
 764                     Reference< XFormController > xActiveController(fad(xController));
 765                     if (xActiveController.is())
 766                     {
 767                         xControllerToActivate = xActiveController;
 768                         break;
 769                     }
 770                 }
 771
 772                 if(xControllerToActivate.is() || !isActivableDatabaseForm(xController))
 773                     continue;
 774
 775                 xControllerToActivate = xController;
 776             }
 777             pShImpl->setActiveController( xControllerToActivate );
 778         }
 779     }
 780     return 0;
 781 }
 782
 783
 784 void FmXFormView::Activate(bool bSync)
 785 {
 786     if (m_nActivationEvent)
 787     {
 788         Application::RemoveUserEvent(m_nActivationEvent);
 789         m_nActivationEvent = 0;
 790     }
 791
 792     if (bSync)
 793     {
 794         LINK(this,FmXFormView,OnActivate).Call(NULL);
 795     }
 796     else
 797         m_nActivationEvent = Application::PostUserEvent(LINK(this,FmXFormView,OnActivate));
 798 }
 799
 800
 801 void FmXFormView::Deactivate(bool bDeactivateController)
 802 {
 803     if (m_nActivationEvent)
 804     {
 805         Application::RemoveUserEvent(m_nActivationEvent);
 806         m_nActivationEvent = 0;
 807     }
 808
 809     FmXFormShell* pShImpl =  m_pView->GetFormShell() ? m_pView->GetFormShell()->GetImpl() : NULL;
 810     if (pShImpl && bDeactivateController)
 811         pShImpl->setActiveController( NULL );
 812 }
 813
 814
 815 FmFormShell* FmXFormView::GetFormShell() const
 816 {
 817     return m_pView ? m_pView->GetFormShell() : NULL;
 818 }
 819
 820 void FmXFormView::AutoFocus( bool _bSync )
 821 {
 822     if (m_nAutoFocusEvent)
 823         Application::RemoveUserEvent(m_nAutoFocusEvent);
 824
 825     if ( _bSync )
 826         OnAutoFocus( NULL );
 827     else
 828         m_nAutoFocusEvent = Application::PostUserEvent(LINK(this, FmXFormView, OnAutoFocus));
 829 }
 830
 831
 832 bool FmXFormView::isFocusable( const Reference< XControl >& i_rControl )
 833 {
 834     if ( !i_rControl.is() )
 835         return false;
 836
 837     try
 838     {
 839         Reference< XPropertySet > xModelProps( i_rControl->getModel(), UNO_QUERY_THROW );
 840
 841         // only enabled controls are allowed to participate
 842         bool bEnabled = false;
 843         OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_ENABLED ) >>= bEnabled );
 844         if ( !bEnabled )
 845             return false;
 846
 847         // check the class id of the control model
 848         sal_Int16 nClassId = FormComponentType::CONTROL;
 849         OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId );
 850
 851         // controls which are not focussable
 852         if  (   ( FormComponentType::CONTROL != nClassId )
 853             &&  ( FormComponentType::IMAGEBUTTON != nClassId )
 854             &&  ( FormComponentType::GROUPBOX != nClassId )
 855             &&  ( FormComponentType::FIXEDTEXT != nClassId )
 856             &&  ( FormComponentType::HIDDENCONTROL != nClassId )
 857             &&  ( FormComponentType::IMAGECONTROL != nClassId )
 858             &&  ( FormComponentType::SCROLLBAR != nClassId )
 859             &&  ( FormComponentType::SPINBUTTON!= nClassId )
 860             )
 861         {
 862             return true;
 863         }
 864     }
 865     catch (const Exception&)
 866     {
 867         DBG_UNHANDLED_EXCEPTION();
 868     }
 869     return false;
 870 }
 871
 872
 873 static Reference< XControl > lcl_firstFocussableControl( const Sequence< Reference< XControl > >& _rControls )
 874 {
 875     Reference< XControl > xReturn;
 876
 877     // loop through all the controls
 878     const Reference< XControl >* pControls = _rControls.getConstArray();
 879     const Reference< XControl >* pControlsEnd = _rControls.getConstArray() + _rControls.getLength();
 880     for ( ; pControls != pControlsEnd; ++pControls )
 881     {
 882         if ( !pControls->is() )
 883             continue;
 884
 885         if ( FmXFormView::isFocusable( *pControls ) )
 886         {
 887             xReturn = *pControls;
 888             break;
 889         }
 890     }
 891
 892     if ( !xReturn.is() && _rControls.getLength() )
 893         xReturn = _rControls[0];
 894
 895     return xReturn;
 896 }
 897
 898
 899 namespace
 900 {
 901
 902     void lcl_ensureControlsOfFormExist_nothrow( const SdrPage& _rPage, const SdrView& _rView, const vcl::Window& _rWindow, const Reference< XForm >& _rxForm )
 903     {
 904         try
 905         {
 906             Reference< XInterface > xNormalizedForm( _rxForm, UNO_QUERY_THROW );
 907
 908             SdrObjListIter aSdrObjectLoop( _rPage, IM_DEEPNOGROUPS );
 909             while ( aSdrObjectLoop.IsMore() )
 910             {
 911                 FmFormObj* pFormObject = FmFormObj::GetFormObject( aSdrObjectLoop.Next() );
 912                 if ( !pFormObject )
 913                     continue;
 914
 915                 Reference< XChild > xModel( pFormObject->GetUnoControlModel(), UNO_QUERY_THROW );
 916                 Reference< XInterface > xModelParent( xModel->getParent(), UNO_QUERY_THROW );
 917
 918                 if ( xNormalizedForm.get() != xModelParent.get() )
 919                     continue;
 920
 921                 pFormObject->GetUnoControl( _rView, _rWindow );
 922             }
 923         }
 924         catch (const Exception&)
 925         {
 926             DBG_UNHANDLED_EXCEPTION();
 927         }
 928     }
 929 }
 930
 931
 932 Reference< XFormController > FmXFormView::getFormController( const Reference< XForm >& _rxForm, const OutputDevice& _rDevice ) const
 933 {
 934     Reference< XFormController > xController;
 935
 936     for (   PageWindowAdapterList::const_iterator pos = m_aPageWindowAdapters.begin();
 937             pos != m_aPageWindowAdapters.end();
 938             ++pos
 939         )
 940     {
 941         const PFormViewPageWindowAdapter pAdapter( *pos );
 942         if ( !pAdapter.get() )
 943         {
 944             SAL_WARN( "svx.form", "FmXFormView::getFormController: invalid page window adapter!" );
 945             continue;
 946         }
 947
 948         if ( pAdapter->getWindow() != &_rDevice )
 949             // wrong device
 950             continue;
 951
 952         xController = pAdapter->getController( _rxForm );
 953         if ( xController.is() )
 954             break;
 955     }
 956     return xController;
 957 }
 958
 959
 960 IMPL_LINK_NOARG(FmXFormView, OnAutoFocus)
 961 {
 962     m_nAutoFocusEvent = 0;
 963
 964     // go to the first form of our page, examine it's TabController, go to it's first (in terms of the tab order)
 965     // control, give it the focus
 966
 967     do
 968     {
 969
 970     SdrPageView *pPageView = m_pView ? m_pView->GetSdrPageView() : NULL;
 971     SdrPage *pSdrPage = pPageView ? pPageView->GetPage() : NULL;
 972     // get the forms collection of the page we belong to
 973     FmFormPage* pPage = PTR_CAST( FmFormPage, pSdrPage );
 974     Reference< XIndexAccess > xForms( pPage ? Reference< XIndexAccess >( pPage->GetForms(), UNO_QUERY ) : Reference< XIndexAccess >() );
 975
 976     const PFormViewPageWindowAdapter pAdapter = m_aPageWindowAdapters.empty() ? NULL : m_aPageWindowAdapters[0];
 977     const vcl::Window* pWindow = pAdapter.get() ? pAdapter->getWindow() : NULL;
 978
 979     ENSURE_OR_RETURN( xForms.is() && pWindow, "FmXFormView::OnAutoFocus: could not collect all essentials!", 0L );
 980
 981     try
 982     {
 983         // go for the tab controller of the first form
 984         if ( !xForms->getCount() )
 985             break;
 986         Reference< XForm > xForm( xForms->getByIndex( 0 ), UNO_QUERY_THROW );
 987         Reference< XTabController > xTabController( pAdapter->getController( xForm ), UNO_QUERY_THROW );
 988
 989         // go for the first control of the controller
 990         Sequence< Reference< XControl > > aControls( xTabController->getControls() );
 991         if ( aControls.getLength() == 0 )
 992         {
 993             Reference< XElementAccess > xFormElementAccess( xForm, UNO_QUERY_THROW );
 994             if (xFormElementAccess->hasElements() && pPage && m_pView)
 995             {
 996                 // there are control models in the form, but no controls, yet.
 997                 // Well, since some time controls are created on demand only. In particular,
 998                 // they're normally created when they're first painted.
 999                 // Unfortunately, the FormController does not have any way to
1000                 // trigger the creation itself, so we must hack this ...
1001                 lcl_ensureControlsOfFormExist_nothrow( *pPage, *m_pView, *pWindow, xForm );
1002                 aControls = xTabController->getControls();
1003                 OSL_ENSURE( aControls.getLength(), "FmXFormView::OnAutoFocus: no controls at all!" );
1004             }
1005         }
1006
1007         // set the focus to this first control
1008         Reference< XWindow > xControlWindow( lcl_firstFocussableControl( aControls ), UNO_QUERY );
1009         if ( !xControlWindow.is() )
1010             break;
1011
1012         xControlWindow->setFocus();
1013
1014         // ensure that the control is visible
1015         // 80210 - 12/07/00 - FS
1016         const vcl::Window* pCurrentWindow = m_pView ? dynamic_cast<const vcl::Window*>(m_pView->GetActualOutDev()) : NULL;
1017         if ( pCurrentWindow )
1018         {
1019             awt::Rectangle aRect = xControlWindow->getPosSize();
1020             ::Rectangle aNonUnoRect( aRect.X, aRect.Y, aRect.X + aRect.Width, aRect.Y + aRect.Height );
1021             m_pView->MakeVisible( pCurrentWindow->PixelToLogic( aNonUnoRect ), *const_cast< vcl::Window* >( pCurrentWindow ) );
1022         }
1023     }
1024     catch (const Exception&)
1025     {
1026         DBG_UNHANDLED_EXCEPTION();
1027     }
1028
1029     }   // do
1030     while ( false );
1031
1032     return 1L;
1033 }
1034
1035
1036 void FmXFormView::onCreatedFormObject( FmFormObj& _rFormObject )
1037 {
1038     FmFormShell* pShell = m_pView ? m_pView->GetFormShell() : NULL;
1039     FmXFormShell* pShellImpl = pShell ? pShell->GetImpl() : NULL;
1040     OSL_ENSURE( pShellImpl, "FmXFormView::onCreatedFormObject: no form shell!" );
1041     if ( !pShellImpl )
1042         return;
1043
1044     // it is valid that the form shell's forms collection is not initialized, yet
1045     pShellImpl->UpdateForms( true );
1046
1047     m_xLastCreatedControlModel.set( _rFormObject.GetUnoControlModel(), UNO_QUERY );
1048     if ( !m_xLastCreatedControlModel.is() )
1049         return;
1050
1051     // some initial property defaults
1052     FormControlFactory aControlFactory;
1053     aControlFactory.initializeControlModel( pShellImpl->getDocumentType(), _rFormObject );
1054
1055     if ( !pShellImpl->GetWizardUsing() )
1056         return;
1057
1058     // #i31958# don't call wizards in XForms mode
1059     if ( pShellImpl->isEnhancedForm() )
1060         return;
1061
1062     // #i46898# no wizards if there is no Base installed - currently, all wizards are
1063     // database related
1064     if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
1065         return;
1066
1067     if ( m_nControlWizardEvent )
1068         Application::RemoveUserEvent( m_nControlWizardEvent );
1069     m_nControlWizardEvent = Application::PostUserEvent( LINK( this, FmXFormView, OnStartControlWizard ) );
1070 }
1071
1072 void FmXFormView::breakCreateFormObject()
1073 {
1074     if (m_nControlWizardEvent != 0)
1075     {
1076         Application::RemoveUserEvent(m_nControlWizardEvent);
1077         m_nControlWizardEvent = 0;
1078     }
1079     m_xLastCreatedControlModel.clear();
1080 }
1081
1082 IMPL_LINK_NOARG( FmXFormView, OnStartControlWizard )
1083 {
1084     m_nControlWizardEvent = 0;
1085     OSL_PRECOND( m_xLastCreatedControlModel.is(), "FmXFormView::OnStartControlWizard: illegal call!" );
1086     if ( !m_xLastCreatedControlModel.is() )
1087         return 0L;
1088
1089     sal_Int16 nClassId = FormComponentType::CONTROL;
1090     try
1091     {
1092         OSL_VERIFY( m_xLastCreatedControlModel->getPropertyValue( FM_PROP_CLASSID ) >>= nClassId );
1093     }
1094     catch (const Exception&)
1095     {
1096         DBG_UNHANDLED_EXCEPTION();
1097     }
1098
1099     const sal_Char* pWizardAsciiName = NULL;
1100     switch ( nClassId )
1101     {
1102         case FormComponentType::GRIDCONTROL:
1103             pWizardAsciiName = "com.sun.star.sdb.GridControlAutoPilot";
1104             break;
1105         case FormComponentType::LISTBOX:
1106         case FormComponentType::COMBOBOX:
1107             pWizardAsciiName = "com.sun.star.sdb.ListComboBoxAutoPilot";
1108             break;
1109         case FormComponentType::GROUPBOX:
1110             pWizardAsciiName = "com.sun.star.sdb.GroupBoxAutoPilot";
1111             break;
1112     }
1113
1114     if ( pWizardAsciiName )
1115     {
1116         // build the argument list
1117         ::comphelper::NamedValueCollection aWizardArgs;
1118         aWizardArgs.put( "ObjectModel", m_xLastCreatedControlModel );
1119
1120         // create the wizard object
1121         Reference< XExecutableDialog > xWizard;
1122         try
1123         {
1124             Reference<XComponentContext> xContext = comphelper::getProcessComponentContext();
1125             xWizard.set( xContext->getServiceManager()->createInstanceWithArgumentsAndContext( OUString::createFromAscii(pWizardAsciiName), aWizardArgs.getWrappedPropertyValues(), xContext ), UNO_QUERY);;
1126         }
1127         catch (const Exception&)
1128         {
1129             DBG_UNHANDLED_EXCEPTION();
1130         }
1131
1132         if ( !xWizard.is() )
1133         {
1134             ShowServiceNotAvailableError( NULL, OUString::createFromAscii(pWizardAsciiName), true );
1135         }
1136         else
1137         {
1138             // execute the wizard
1139             try
1140             {
1141                 xWizard->execute();
1142             }
1143             catch (const Exception&)
1144             {
1145                 DBG_UNHANDLED_EXCEPTION();
1146             }
1147         }
1148     }
1149
1150     m_xLastCreatedControlModel.clear();
1151     return 1L;
1152 }
1153
1154
1155 namespace
1156 {
1157     void lcl_insertIntoFormComponentHierarchy_throw( const FmFormView& _rView, const SdrUnoObj& _rSdrObj,
1158         const Reference< XDataSource >& _rxDataSource = NULL, const OUString& _rDataSourceName = OUString(),
1159         const OUString& _rCommand = OUString(), const sal_Int32 _nCommandType = -1 )
1160     {
1161         FmFormPage& rPage = static_cast< FmFormPage& >( *_rView.GetSdrPageView()->GetPage() );
1162
1163         Reference< XFormComponent > xFormComponent( _rSdrObj.GetUnoControlModel(), UNO_QUERY_THROW );
1164         Reference< XForm > xTargetForm(
1165             rPage.GetImpl().findPlaceInFormComponentHierarchy( xFormComponent, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType ),
1166             UNO_SET_THROW );
1167
1168         FmFormPageImpl::setUniqueName( xFormComponent, xTargetForm );
1169
1170         Reference< XIndexContainer > xFormAsContainer( xTargetForm, UNO_QUERY_THROW );
1171         xFormAsContainer->insertByIndex( xFormAsContainer->getCount(), makeAny( xFormComponent ) );
1172     }
1173 }
1174
1175
1176 SdrObject* FmXFormView::implCreateFieldControl( const svx::ODataAccessDescriptor& _rColumnDescriptor )
1177 {
1178     // not if we're in design mode
1179     if ( !m_pView->IsDesignMode() )
1180         return NULL;
1181
1182     OUString sCommand, sFieldName;
1183     sal_Int32 nCommandType = CommandType::COMMAND;
1184     SharedConnection xConnection;
1185
1186     OUString sDataSource = _rColumnDescriptor.getDataSource();
1187     _rColumnDescriptor[ daCommand ]     >>= sCommand;
1188     _rColumnDescriptor[ daColumnName ]  >>= sFieldName;
1189     _rColumnDescriptor[ daCommandType ] >>= nCommandType;
1190     {
1191         Reference< XConnection > xExternalConnection;
1192         _rColumnDescriptor[ daConnection ]  >>= xExternalConnection;
1193         xConnection.reset( xExternalConnection, SharedConnection::NoTakeOwnership );
1194     }
1195
1196     if  (   sCommand.isEmpty()
1197         ||  sFieldName.isEmpty()
1198         ||  (   sDataSource.isEmpty()
1199             &&  !xConnection.is()
1200             )
1201         )
1202     {
1203         OSL_FAIL( "FmXFormView::implCreateFieldControl: nonsense!" );
1204     }
1205
1206     Reference< XDataSource > xDataSource;
1207     SQLErrorEvent aError;
1208     try
1209     {
1210         if ( xConnection.is() && !xDataSource.is() && sDataSource.isEmpty() )
1211         {
1212             Reference< XChild > xChild( xConnection, UNO_QUERY );
1213             if ( xChild.is() )
1214                 xDataSource.set(xChild->getParent(), css::uno::UNO_QUERY);
1215         }
1216
1217         // obtain the data source
1218         if ( !xDataSource.is() )
1219             xDataSource = getDataSource( sDataSource, comphelper::getProcessComponentContext() );
1220
1221         // and the connection, if necessary
1222         if ( !xConnection.is() )
1223             xConnection.reset( getConnection_withFeedback(
1224                 sDataSource,
1225                 OUString(),
1226                 OUString(),
1227                 comphelper::getProcessComponentContext()
1228             ) );
1229     }
1230     catch (const SQLException&)
1231     {
1232         aError.Reason = ::cppu::getCaughtException();
1233     }
1234     catch (const Exception& )
1235     {
1236         /* will be asserted below */
1237     }
1238     if (aError.Reason.hasValue())
1239     {
1240         displayAsyncErrorMessage( aError );
1241         return NULL;
1242     }
1243
1244     // need a data source and a connection here
1245     if (!xDataSource.is() || !xConnection.is())
1246     {
1247         OSL_FAIL("FmXFormView::implCreateFieldControl : could not retrieve the data source or the connection!");
1248         return NULL;
1249     }
1250
1251     Reference< XComponent > xKeepFieldsAlive;
1252     // go
1253     try
1254     {
1255         // determine the table/query field which we should create a control for
1256         Reference< XPropertySet >   xField;
1257
1258         Reference< XNameAccess >    xFields = getFieldsByCommandDescriptor(
1259             xConnection, nCommandType, sCommand, xKeepFieldsAlive );
1260
1261         if (xFields.is() && xFields->hasByName(sFieldName))
1262             xFields->getByName(sFieldName) >>= xField;
1263         if ( !xField.is() )
1264             return NULL;
1265
1266         Reference< XNumberFormatsSupplier > xSupplier( getNumberFormats( xConnection, false ), UNO_SET_THROW );
1267         Reference< XNumberFormats >  xNumberFormats( xSupplier->getNumberFormats(), UNO_SET_THROW );
1268
1269         OUString sLabelPostfix;
1270
1271
1272         // nur fuer Textgroesse
1273         OutputDevice* pOutDev = NULL;
1274         if (m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)
1275             pOutDev = const_cast<OutputDevice*>(m_pView->GetActualOutDev());
1276         else
1277         {// OutDev suchen
1278             SdrPageView* pPageView = m_pView->GetSdrPageView();
1279             if( pPageView && !pOutDev )
1280             {
1281                 // const SdrPageViewWinList& rWinList = pPageView->GetWinList();
1282                 // const SdrPageViewWindows& rPageViewWindows = pPageView->GetPageViewWindows();
1283
1284                 for( sal_uInt32 i = 0L; i < pPageView->PageWindowCount(); i++ )
1285                 {
1286                     const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i);
1287
1288                     if( rPageWindow.GetPaintWindow().OutputToWindow())
1289                     {
1290                         pOutDev = &rPageWindow.GetPaintWindow().GetOutputDevice();
1291                         break;
1292                     }
1293                 }
1294             }
1295         }
1296
1297         if ( !pOutDev )
1298             return NULL;
1299
1300         sal_Int32 nDataType = ::comphelper::getINT32(xField->getPropertyValue(FM_PROP_FIELDTYPE));
1301         if ((DataType::BINARY == nDataType) || (DataType::VARBINARY == nDataType))
1302             return NULL;
1303
1304
1305         // determine the control type by examining the data type of the bound column
1306         sal_uInt16 nOBJID = 0;
1307         bool bDateNTimeField = false;
1308
1309         bool bIsCurrency = false;
1310         if (::comphelper::hasProperty(FM_PROP_ISCURRENCY, xField))
1311             bIsCurrency = ::comphelper::getBOOL(xField->getPropertyValue(FM_PROP_ISCURRENCY));
1312
1313         if (bIsCurrency)
1314             nOBJID = OBJ_FM_CURRENCYFIELD;
1315         else
1316             switch (nDataType)
1317             {
1318                 case DataType::BLOB:
1319                 case DataType::LONGVARBINARY:
1320                     nOBJID = OBJ_FM_IMAGECONTROL;
1321                     break;
1322                 case DataType::LONGVARCHAR:
1323                 case DataType::CLOB:
1324                     nOBJID = OBJ_FM_EDIT;
1325                     break;
1326                 case DataType::BINARY:
1327                 case DataType::VARBINARY:
1328                     return NULL;
1329                 case DataType::BIT:
1330                 case DataType::BOOLEAN:
1331                     nOBJID = OBJ_FM_CHECKBOX;
1332                     break;
1333                 case DataType::TINYINT:
1334                 case DataType::SMALLINT:
1335                 case DataType::INTEGER:
1336                     nOBJID = OBJ_FM_NUMERICFIELD;
1337                     break;
1338                 case DataType::REAL:
1339                 case DataType::DOUBLE:
1340                 case DataType::NUMERIC:
1341                 case DataType::DECIMAL:
1342                     nOBJID = OBJ_FM_FORMATTEDFIELD;
1343                     break;
1344                 case DataType::TIMESTAMP:
1345                     bDateNTimeField = true;
1346                     sLabelPostfix = SVX_RESSTR(RID_STR_POSTFIX_DATE);
1347                     // DON'T break !
1348                 case DataType::DATE:
1349                     nOBJID = OBJ_FM_DATEFIELD;
1350                     break;
1351                 case DataType::TIME:
1352                     nOBJID = OBJ_FM_TIMEFIELD;
1353                     break;
1354                 case DataType::CHAR:
1355                 case DataType::VARCHAR:
1356                 default:
1357                     nOBJID = OBJ_FM_EDIT;
1358                     break;
1359             }
1360         if (!nOBJID)
1361             return NULL;
1362
1363         SdrUnoObj* pLabel( NULL );
1364         SdrUnoObj* pControl( NULL );
1365         if  (   !createControlLabelPair( *pOutDev, 0, 0, xField, xNumberFormats, nOBJID, sLabelPostfix,
1366                     pLabel, pControl, xDataSource, sDataSource, sCommand, nCommandType )
1367             )
1368         {
1369             return NULL;
1370         }
1371
1372
1373         // group objects
1374         bool bCheckbox = ( OBJ_FM_CHECKBOX == nOBJID );
1375         OSL_ENSURE( !bCheckbox || !pLabel, "FmXFormView::implCreateFieldControl: why was there a label created for a check box?" );
1376         if ( bCheckbox )
1377             return pControl;
1378
1379         SdrObjGroup* pGroup  = new SdrObjGroup();
1380         SdrObjList* pObjList = pGroup->GetSubList();
1381         pObjList->InsertObject( pLabel );
1382         pObjList->InsertObject( pControl );
1383
1384         if ( bDateNTimeField )
1385         {   // so far we created a date field only, but we also need a time field
1386             pLabel = pControl = NULL;
1387             if  (   createControlLabelPair( *pOutDev, 0, 1000, xField, xNumberFormats, OBJ_FM_TIMEFIELD,
1388                         SVX_RESSTR(RID_STR_POSTFIX_TIME), pLabel, pControl,
1389                         xDataSource, sDataSource, sCommand, nCommandType )
1390                 )
1391             {
1392                 pObjList->InsertObject( pLabel );
1393                 pObjList->InsertObject( pControl );
1394             }
1395         }
1396
1397         return pGroup; // und fertig
1398     }
1399     catch (const Exception&)
1400     {
1401         DBG_UNHANDLED_EXCEPTION();
1402     }
1403
1404
1405     return NULL;
1406 }
1407
1408
1409 SdrObject* FmXFormView::implCreateXFormsControl( const svx::OXFormsDescriptor &_rDesc )
1410 {
1411     // not if we're in design mode
1412     if ( !m_pView->IsDesignMode() )
1413         return NULL;
1414
1415     Reference< XComponent > xKeepFieldsAlive;
1416
1417     // go
1418     try
1419     {
1420         // determine the table/query field which we should create a control for
1421         Reference< XNumberFormats > xNumberFormats;
1422         OUString sLabelPostfix = _rDesc.szName;
1423
1424
1425         // nur fuer Textgroesse
1426         OutputDevice* pOutDev = NULL;
1427         if (m_pView->GetActualOutDev() && m_pView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)
1428             pOutDev = const_cast<OutputDevice*>(m_pView->GetActualOutDev());
1429         else
1430         {// OutDev suchen
1431             SdrPageView* pPageView = m_pView->GetSdrPageView();
1432             if( pPageView && !pOutDev )
1433             {
1434                 // const SdrPageViewWinList& rWinList = pPageView->GetWinList();
1435                 // const SdrPageViewWindows& rPageViewWindows = pPageView->GetPageViewWindows();
1436
1437                 for( sal_uInt32 i = 0L; i < pPageView->PageWindowCount(); i++ )
1438                 {
1439                     const SdrPageWindow& rPageWindow = *pPageView->GetPageWindow(i);
1440
1441                     if( rPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType() == OUTDEV_WINDOW)
1442                     {
1443                         pOutDev = &rPageWindow.GetPaintWindow().GetOutputDevice();
1444                         break;
1445                     }
1446                 }
1447             }
1448         }
1449
1450         if ( !pOutDev )
1451             return NULL;
1452
1453
1454         // The service name decides which control should be created
1455         sal_uInt16 nOBJID = OBJ_FM_EDIT;
1456         if(OUString(_rDesc.szServiceName) == FM_SUN_COMPONENT_NUMERICFIELD)
1457             nOBJID = OBJ_FM_NUMERICFIELD;
1458         if(OUString(_rDesc.szServiceName) == FM_SUN_COMPONENT_CHECKBOX)
1459             nOBJID = OBJ_FM_CHECKBOX;
1460         if(OUString(_rDesc.szServiceName) == FM_COMPONENT_COMMANDBUTTON)
1461             nOBJID = OBJ_FM_BUTTON;
1462
1463         typedef ::com::sun::star::form::submission::XSubmission XSubmission_t;
1464         Reference< XSubmission_t > xSubmission(_rDesc.xPropSet, UNO_QUERY);
1465
1466         // xform control or submission button?
1467         if ( !xSubmission.is() )
1468         {
1469             SdrUnoObj* pLabel( NULL );
1470             SdrUnoObj* pControl( NULL );
1471             if  (   !createControlLabelPair( *pOutDev, 0, 0, NULL, xNumberFormats, nOBJID, sLabelPostfix,
1472                         pLabel, pControl )
1473                 )
1474             {
1475                 return NULL;
1476             }
1477
1478
1479             // Now build the connection between the control and the data item.
1480             Reference< XValueBinding > xValueBinding(_rDesc.xPropSet,UNO_QUERY);
1481             Reference< XBindableValue > xBindableValue(pControl->GetUnoControlModel(),UNO_QUERY);
1482
1483             DBG_ASSERT( xBindableValue.is(), "FmXFormView::implCreateXFormsControl: control's not bindable!" );
1484             if ( xBindableValue.is() )
1485                 xBindableValue->setValueBinding(xValueBinding);
1486
1487             bool bCheckbox = ( OBJ_FM_CHECKBOX == nOBJID );
1488             OSL_ENSURE( !bCheckbox || !pLabel, "FmXFormView::implCreateXFormsControl: why was there a label created for a check box?" );
1489             if ( bCheckbox )
1490                 return pControl;
1491
1492
1493             // group objects
1494             SdrObjGroup* pGroup  = new SdrObjGroup();
1495             SdrObjList* pObjList = pGroup->GetSubList();
1496             pObjList->InsertObject(pLabel);
1497             pObjList->InsertObject(pControl);
1498
1499             return pGroup;
1500         }
1501         else {
1502
1503             // create a button control
1504             const MapMode eTargetMode( pOutDev->GetMapMode() );
1505             const MapMode eSourceMode(MAP_100TH_MM);
1506             const sal_uInt16 nObjID = OBJ_FM_BUTTON;
1507             ::Size controlSize(4000, 500);
1508             FmFormObj *pControl = static_cast<FmFormObj*>(SdrObjFactory::MakeNewObject( FmFormInventor, nObjID, NULL, NULL ));
1509             controlSize.Width() = Fraction(controlSize.Width(), 1) * eTargetMode.GetScaleX();
1510             controlSize.Height() = Fraction(controlSize.Height(), 1) * eTargetMode.GetScaleY();
1511             ::Point controlPos( OutputDevice::LogicToLogic( ::Point( controlSize.Width(), 0 ), eSourceMode, eTargetMode ) );
1512             ::Rectangle controlRect( controlPos, OutputDevice::LogicToLogic( controlSize, eSourceMode, eTargetMode ) );
1513             pControl->SetLogicRect(controlRect);
1514
1515             // set the button label
1516             Reference< XPropertySet > xControlSet(pControl->GetUnoControlModel(), UNO_QUERY);
1517             xControlSet->setPropertyValue(FM_PROP_LABEL, makeAny(OUString(_rDesc.szName)));
1518
1519             // connect the submission with the submission supplier (aka the button)
1520             xControlSet->setPropertyValue( FM_PROP_BUTTON_TYPE,
1521                                            makeAny( FormButtonType_SUBMIT ) );
1522             typedef ::com::sun::star::form::submission::XSubmissionSupplier XSubmissionSupplier_t;
1523             Reference< XSubmissionSupplier_t > xSubmissionSupplier(pControl->GetUnoControlModel(), UNO_QUERY);
1524             xSubmissionSupplier->setSubmission(xSubmission);
1525
1526             return pControl;
1527         }
1528     }
1529     catch (const Exception&)
1530     {
1531         OSL_FAIL("FmXFormView::implCreateXFormsControl: caught an exception while creating the control !");
1532     }
1533
1534
1535     return NULL;
1536 }
1537
1538
1539 bool FmXFormView::createControlLabelPair( OutputDevice& _rOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM,
1540         const Reference< XPropertySet >& _rxField, const Reference< XNumberFormats >& _rxNumberFormats,
1541         sal_uInt16 _nControlObjectID, const OUString& _rFieldPostfix,
1542         SdrUnoObj*& _rpLabel, SdrUnoObj*& _rpControl,
1543         const Reference< XDataSource >& _rxDataSource, const OUString& _rDataSourceName,
1544         const OUString& _rCommand, const sal_Int32 _nCommandType )
1545 {
1546     if  (   !createControlLabelPair( _rOutDev, _nXOffsetMM, _nYOffsetMM,
1547                 _rxField, _rxNumberFormats, _nControlObjectID, _rFieldPostfix, FmFormInventor, OBJ_FM_FIXEDTEXT,
1548                 NULL, NULL, NULL, _rpLabel, _rpControl )
1549         )
1550         return false;
1551
1552     // insert the control model(s) into the form component hierarchy
1553     if ( _rpLabel )
1554         lcl_insertIntoFormComponentHierarchy_throw( *m_pView, *_rpLabel, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType );
1555     lcl_insertIntoFormComponentHierarchy_throw( *m_pView, *_rpControl, _rxDataSource, _rDataSourceName, _rCommand, _nCommandType );
1556
1557     // some context-dependent initializations
1558     FormControlFactory aControlFactory;
1559     if ( _rpLabel )
1560         aControlFactory.initializeControlModel( impl_getDocumentType(), *_rpLabel );
1561     aControlFactory.initializeControlModel( impl_getDocumentType(), *_rpControl );
1562
1563     return true;
1564 }
1565
1566
1567 bool FmXFormView::createControlLabelPair( OutputDevice& _rOutDev, sal_Int32 _nXOffsetMM, sal_Int32 _nYOffsetMM,
1568     const Reference< XPropertySet >& _rxField,
1569     const Reference< XNumberFormats >& _rxNumberFormats, sal_uInt16 _nControlObjectID,
1570     const OUString& _rFieldPostfix, sal_uInt32 _nInventor, sal_uInt16 _nLabelObjectID,
1571     SdrPage* _pLabelPage, SdrPage* _pControlPage, SdrModel* _pModel, SdrUnoObj*& _rpLabel, SdrUnoObj*& _rpControl)
1572 {
1573     sal_Int32 nDataType = 0;
1574     OUString sFieldName;
1575     Any aFieldName;
1576     if ( _rxField.is() )
1577     {
1578         nDataType = ::comphelper::getINT32(_rxField->getPropertyValue(FM_PROP_FIELDTYPE));
1579         aFieldName = Any(_rxField->getPropertyValue(FM_PROP_NAME));
1580         aFieldName >>= sFieldName;
1581     }
1582
1583     // calculate the positions, respecting the settings of the target device
1584     ::Size aTextSize( _rOutDev.GetTextWidth(sFieldName + _rFieldPostfix), _rOutDev.GetTextHeight() );
1585
1586     MapMode   eTargetMode( _rOutDev.GetMapMode() ),
1587               eSourceMode( MAP_100TH_MM );
1588
1589     // Textbreite ist mindestens 4cm
1590     // Texthoehe immer halber cm
1591     ::Size aDefTxtSize(4000, 500);
1592     ::Size aDefSize(4000, 500);
1593     ::Size aDefImageSize(4000, 4000);
1594
1595     ::Size aRealSize = OutputDevice::LogicToLogic(aTextSize, eTargetMode, eSourceMode);
1596     aRealSize.Width() = std::max(aRealSize.Width(), aDefTxtSize.Width());
1597     aRealSize.Height()= aDefSize.Height();
1598
1599     // adjust to scaling of the target device (#53523#)
1600     aRealSize.Width() = long(Fraction(aRealSize.Width(), 1) * eTargetMode.GetScaleX());
1601     aRealSize.Height() = long(Fraction(aRealSize.Height(), 1) * eTargetMode.GetScaleY());
1602
1603     // for boolean fields, we do not create a label, but just a checkbox
1604     bool bNeedLabel = ( _nControlObjectID != OBJ_FM_CHECKBOX );
1605
1606     // the label
1607     ::std::unique_ptr< SdrUnoObj > pLabel;
1608     Reference< XPropertySet > xLabelModel;
1609     if ( bNeedLabel )
1610     {
1611         pLabel.reset( dynamic_cast< SdrUnoObj* >(
1612             SdrObjFactory::MakeNewObject( _nInventor, _nLabelObjectID, _pLabelPage, _pModel ) ) );
1613         OSL_ENSURE( pLabel.get(), "FmXFormView::createControlLabelPair: could not create the label!" );
1614         if ( !pLabel.get() )
1615             return false;
1616
1617         xLabelModel.set( pLabel->GetUnoControlModel(), UNO_QUERY );
1618         if ( xLabelModel.is() )
1619         {
1620             OUString sLabel;
1621             if ( _rxField.is() && _rxField->getPropertySetInfo()->hasPropertyByName(FM_PROP_LABEL) )
1622                 _rxField->getPropertyValue(FM_PROP_LABEL) >>= sLabel;
1623             if ( sLabel.isEmpty() )
1624                 sLabel = sFieldName;
1625
1626             xLabelModel->setPropertyValue( FM_PROP_LABEL, makeAny( sLabel + _rFieldPostfix ) );
1627             OUString sObjectLabel(SVX_RESSTR(RID_STR_OBJECT_LABEL).replaceAll("#object#", sFieldName));
1628             xLabelModel->setPropertyValue(FM_PROP_NAME, makeAny(sObjectLabel));
1629         }
1630
1631         pLabel->SetLogicRect( ::Rectangle(
1632             OutputDevice::LogicToLogic( ::Point( _nXOffsetMM, _nYOffsetMM ), eSourceMode, eTargetMode ),
1633             OutputDevice::LogicToLogic( aRealSize, eSourceMode, eTargetMode )
1634         ) );
1635     }
1636
1637     // the control
1638     ::std::unique_ptr< SdrUnoObj > pControl( dynamic_cast< SdrUnoObj* >(
1639         SdrObjFactory::MakeNewObject( _nInventor, _nControlObjectID, _pControlPage, _pModel ) ) );
1640     OSL_ENSURE( pControl.get(), "FmXFormView::createControlLabelPair: could not create the control!" );
1641     if ( !pControl.get() )
1642         return false;
1643
1644     Reference< XPropertySet > xControlSet( pControl->GetUnoControlModel(), UNO_QUERY );
1645     if ( !xControlSet.is() )
1646         return false;
1647
1648     // size of the control
1649     ::Size aControlSize( aDefSize );
1650     switch ( nDataType )
1651     {
1652     case DataType::BIT:
1653     case DataType::BOOLEAN:
1654         aControlSize = aDefSize;
1655         break;
1656     case DataType::LONGVARCHAR:
1657     case DataType::CLOB:
1658     case DataType::LONGVARBINARY:
1659     case DataType::BLOB:
1660         aControlSize = aDefImageSize;
1661         break;
1662     }
1663
1664     if ( OBJ_FM_IMAGECONTROL == _nControlObjectID )
1665         aControlSize = aDefImageSize;
1666
1667     aControlSize.Width() = long(Fraction(aControlSize.Width(), 1) * eTargetMode.GetScaleX());
1668     aControlSize.Height() = long(Fraction(aControlSize.Height(), 1) * eTargetMode.GetScaleY());
1669
1670     pControl->SetLogicRect( ::Rectangle(
1671         OutputDevice::LogicToLogic( ::Point( aRealSize.Width() + _nXOffsetMM, _nYOffsetMM ), eSourceMode, eTargetMode ),
1672         OutputDevice::LogicToLogic( aControlSize, eSourceMode, eTargetMode )
1673     ) );
1674
1675     // some initializations
1676     Reference< XPropertySetInfo > xControlPropInfo = xControlSet->getPropertySetInfo();
1677
1678     if ( aFieldName.hasValue() )
1679     {
1680         xControlSet->setPropertyValue( FM_PROP_CONTROLSOURCE, aFieldName );
1681         xControlSet->setPropertyValue( FM_PROP_NAME, aFieldName );
1682         if ( !bNeedLabel )
1683         {
1684             // no dedicated label control => use the label property
1685             if ( xControlPropInfo->hasPropertyByName( FM_PROP_LABEL ) )
1686                 xControlSet->setPropertyValue( FM_PROP_LABEL, makeAny( sFieldName + _rFieldPostfix ) );
1687             else
1688                 OSL_FAIL( "FmXFormView::createControlLabelPair: can't set a label for the control!" );
1689         }
1690     }
1691
1692     if ( (nDataType == DataType::LONGVARCHAR || nDataType == DataType::CLOB) && xControlPropInfo->hasPropertyByName( FM_PROP_MULTILINE ) )
1693     {
1694         xControlSet->setPropertyValue( FM_PROP_MULTILINE, makeAny( true ) );
1695     }
1696
1697     // announce the label to the control
1698     if ( xControlPropInfo->hasPropertyByName( FM_PROP_CONTROLLABEL ) && xLabelModel.is() )
1699     {
1700         try
1701         {
1702             xControlSet->setPropertyValue( FM_PROP_CONTROLLABEL, makeAny( xLabelModel ) );
1703         }
1704         catch (const Exception&)
1705         {
1706             DBG_UNHANDLED_EXCEPTION();
1707         }
1708     }
1709
1710     if ( _rxField.is() )
1711     {
1712         FormControlFactory::initializeFieldDependentProperties( _rxField, xControlSet, _rxNumberFormats );
1713     }
1714
1715     _rpLabel = pLabel.release();
1716     _rpControl = pControl.release();
1717     return true;
1718 }
1719
1720
1721 FmXFormView::ObjectRemoveListener::ObjectRemoveListener( FmXFormView* pParent )
1722     :m_pParent( pParent )
1723 {
1724 }
1725
1726
1727 void FmXFormView::ObjectRemoveListener::Notify( SfxBroadcaster& /*rBC*/, const SfxHint& rHint )
1728 {
1729     const SdrHint* pSdrHint = dynamic_cast<const SdrHint*>(&rHint);
1730     if (pSdrHint && pSdrHint->GetKind() == HINT_OBJREMOVED)
1731         m_pParent->ObjectRemovedInAliveMode(pSdrHint->GetObject());
1732 }
1733
1734
1735 void FmXFormView::ObjectRemovedInAliveMode( const SdrObject* pObject )
1736 {
1737     // wenn das entfernte Objekt in meiner MarkList, die ich mir beim Umschalten in den Alive-Mode gemerkt habe, steht,
1738     // muss ich es jetzt da rausnehmen, da ich sonst beim Zurueckschalten versuche, die Markierung wieder zu setzen
1739     // (interesanterweise geht das nur bei gruppierten Objekten schief (beim Zugriff auf deren ObjList GPF), nicht bei einzelnen)
1740
1741     const size_t nCount = m_aMark.GetMarkCount();
1742     for (size_t i = 0; i < nCount; ++i)
1743     {
1744         SdrMark* pMark = m_aMark.GetMark(i);
1745         SdrObject* pCurrent = pMark->GetMarkedSdrObj();
1746         if (pObject == pCurrent)
1747         {
1748             m_aMark.DeleteMark(i);
1749             return;
1750         }
1751         // ich brauche nicht in GroupObjects absteigen : wenn dort unten ein Objekt geloescht wird, dann bleibt der
1752         // Zeiger auf das GroupObject, den ich habe, trotzdem weiter gueltig bleibt ...
1753     }
1754 }
1755
1756
1757 void FmXFormView::stopMarkListWatching()
1758 {
1759     if ( m_pWatchStoredList )
1760     {
1761         m_pWatchStoredList->EndListeningAll();
1762         delete m_pWatchStoredList;
1763         m_pWatchStoredList = NULL;
1764     }
1765 }
1766
1767
1768 void FmXFormView::startMarkListWatching()
1769 {
1770     if ( !m_pWatchStoredList )
1771     {
1772         FmFormModel* pModel = GetFormShell() ? GetFormShell()->GetFormModel() : NULL;
1773         DBG_ASSERT( pModel != NULL, "FmXFormView::startMarkListWatching: shell has no model!" );
1774         if (pModel)
1775         {
1776             m_pWatchStoredList = new ObjectRemoveListener( this );
1777             m_pWatchStoredList->StartListening( *static_cast< SfxBroadcaster* >( pModel ) );
1778         }
1779     }
1780     else
1781     {
1782         OSL_FAIL( "FmXFormView::startMarkListWatching: already listening!" );
1783     }
1784 }
1785
1786
1787 void FmXFormView::saveMarkList( bool _bSmartUnmark )
1788 {
1789     if ( m_pView )
1790     {
1791         m_aMark = m_pView->GetMarkedObjectList();
1792         if ( _bSmartUnmark )
1793         {
1794             const size_t nCount = m_aMark.GetMarkCount( );
1795             for ( size_t i = 0; i < nCount; ++i )
1796             {
1797                 SdrMark*   pMark = m_aMark.GetMark(i);
1798                 SdrObject* pObj  = pMark->GetMarkedSdrObj();
1799
1800                 if ( m_pView->IsObjMarked( pObj ) )
1801                 {
1802                     if ( pObj->IsGroupObject() )
1803                     {
1804                         SdrObjListIter aIter( *pObj->GetSubList() );
1805                         bool bMixed = false;
1806                         while ( aIter.IsMore() && !bMixed )
1807                             bMixed = ( aIter.Next()->GetObjInventor() != FmFormInventor );
1808
1809                         if ( !bMixed )
1810                         {
1811                             // all objects in the group are form objects
1812                             m_pView->MarkObj( pMark->GetMarkedSdrObj(), pMark->GetPageView(), true /* unmark! */ );
1813                         }
1814                     }
1815                     else
1816                     {
1817                         if ( pObj->GetObjInventor() == FmFormInventor )
1818                         {   // this is a form layer object
1819                             m_pView->MarkObj( pMark->GetMarkedSdrObj(), pMark->GetPageView(), true /* unmark! */ );
1820                         }
1821                     }
1822                 }
1823             }
1824         }
1825     }
1826     else
1827     {
1828         OSL_FAIL( "FmXFormView::saveMarkList: invalid view!" );
1829         m_aMark = SdrMarkList();
1830     }
1831 }
1832
1833
1834 static bool lcl_hasObject( SdrObjListIter& rIter, SdrObject* pObj )
1835 {
1836     bool bFound = false;
1837     while (rIter.IsMore() && !bFound)
1838         bFound = pObj == rIter.Next();
1839
1840     rIter.Reset();
1841     return bFound;
1842 }
1843
1844
1845 void FmXFormView::restoreMarkList( SdrMarkList& _rRestoredMarkList )
1846 {
1847     if ( !m_pView )
1848         return;
1849
1850     _rRestoredMarkList.Clear();
1851
1852     const SdrMarkList& rCurrentList = m_pView->GetMarkedObjectList();
1853     FmFormPage* pPage = GetFormShell() ? GetFormShell()->GetCurPage() : NULL;
1854     if (pPage)
1855     {
1856         if (rCurrentList.GetMarkCount())
1857         {   // there is a current mark ... hmm. Is it a subset of the mark we remembered in saveMarkList?
1858             bool bMisMatch = false;
1859
1860             // loop through all current marks
1861             const size_t nCurrentCount = rCurrentList.GetMarkCount();
1862             for ( size_t i=0; i<nCurrentCount && !bMisMatch; ++i )
1863             {
1864                 const SdrObject* pCurrentMarked = rCurrentList.GetMark( i )->GetMarkedSdrObj();
1865
1866                 // loop through all saved marks, check for equality
1867                 bool bFound = false;
1868                 const size_t nSavedCount = m_aMark.GetMarkCount();
1869                 for ( size_t j=0; j<nSavedCount && !bFound; ++j )
1870                 {
1871                     if ( m_aMark.GetMark( j )->GetMarkedSdrObj() == pCurrentMarked )
1872                         bFound = true;
1873                 }
1874
1875                 // did not find a current mark in the saved marks
1876                 if ( !bFound )
1877                     bMisMatch = true;
1878             }
1879
1880             if ( bMisMatch )
1881             {
1882                 m_aMark.Clear();
1883                 _rRestoredMarkList = rCurrentList;
1884                 return;
1885             }
1886         }
1887         // wichtig ist das auf die Objecte der markliste nicht zugegriffen wird
1888         // da diese bereits zerstoert sein koennen
1889         SdrPageView* pCurPageView = m_pView->GetSdrPageView();
1890         SdrObjListIter aPageIter( *pPage );
1891         bool bFound = true;
1892
1893         // gibt es noch alle Objecte
1894         const size_t nCount = m_aMark.GetMarkCount();
1895         for (size_t i = 0; i < nCount && bFound; ++i)
1896         {
1897             SdrMark*   pMark = m_aMark.GetMark(i);
1898             SdrObject* pObj  = pMark->GetMarkedSdrObj();
1899             if (pObj->IsGroupObject())
1900             {
1901                 SdrObjListIter aIter(*pObj->GetSubList());
1902                 while (aIter.IsMore() && bFound)
1903                     bFound = lcl_hasObject(aPageIter, aIter.Next());
1904             }
1905             else
1906                 bFound = lcl_hasObject(aPageIter, pObj);
1907
1908             bFound = bFound && pCurPageView == pMark->GetPageView();
1909         }
1910
1911         if (bFound)
1912         {
1913             // Das LastObject auswerten
1914             if (nCount) // Objecte jetzt Markieren
1915             {
1916                 for (size_t i = 0; i < nCount; ++i)
1917                 {
1918                     SdrMark* pMark = m_aMark.GetMark(i);
1919                     SdrObject* pObj = pMark->GetMarkedSdrObj();
1920                     if ( pObj->GetObjInventor() == FmFormInventor )
1921                         if ( !m_pView->IsObjMarked( pObj ) )
1922                             m_pView->MarkObj( pObj, pMark->GetPageView() );
1923                 }
1924
1925                 _rRestoredMarkList = m_aMark;
1926             }
1927         }
1928         m_aMark.Clear();
1929     }
1930 }
1931
1932 void SAL_CALL FmXFormView::focusGained( const FocusEvent& /*e*/ ) throw (RuntimeException, std::exception)
1933 {
1934     if ( m_xWindow.is() && m_pView )
1935     {
1936         m_pView->SetMoveOutside( true, FmFormView::ImplAccess() );
1937     }
1938 }
1939
1940 void SAL_CALL FmXFormView::focusLost( const FocusEvent& /*e*/ ) throw (RuntimeException, std::exception)
1941 {
1942     // when switch the focus outside the office the mark didn't change
1943     // so we can not remove us as focus listener
1944     if ( m_xWindow.is() && m_pView )
1945     {
1946         m_pView->SetMoveOutside( false, FmFormView::ImplAccess() );
1947     }
1948 }
1949
1950 void FmXFormView::removeGridWindowListening()
1951 {
1952     if ( m_xWindow.is() )
1953     {
1954         m_xWindow->removeFocusListener(this);
1955         if ( m_pView )
1956         {
1957             m_pView->SetMoveOutside( false, FmFormView::ImplAccess() );
1958         }
1959         m_xWindow = NULL;
1960     }
1961 }
1962
1963
1964 DocumentType FmXFormView::impl_getDocumentType() const
1965 {
1966     if ( GetFormShell() && GetFormShell()->GetImpl() )
1967         return GetFormShell()->GetImpl()->getDocumentType();
1968     return eUnknownDocumentType;
1969 }
1970
1971 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */