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