svx/source/form/fmshell.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "fmvwimp.hxx"
  21 #include <svx/fmshell.hxx>
  22 #include "svx/fmtools.hxx"
  23 #include "fmservs.hxx"
  24 #include "fmprop.hrc"
  25 #include "fmpgeimp.hxx"
  26 #include "fmitems.hxx"
  27 #include "fmundo.hxx"
  28 #include <vcl/waitobj.hxx>
  29 #include <com/sun/star/form/XLoadable.hpp>
  30 #include <com/sun/star/container/XNamed.hpp>
  31 #include <com/sun/star/sdbcx/Privilege.hpp>
  32 #include <com/sun/star/beans/XPropertySet.hpp>
  33 #include <com/sun/star/beans/XMultiPropertySet.hpp>
  34 #include <com/sun/star/beans/XFastPropertySet.hpp>
  35 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  36 #include <com/sun/star/lang/XServiceInfo.hpp>
  37 #include <com/sun/star/container/XNameContainer.hpp>
  38 #include <com/sun/star/awt/XTabControllerModel.hpp>
  39 #include <sfx2/viewfrm.hxx>
  40 #include <vcl/layout.hxx>
  41 #include <vcl/wrkwin.hxx>
  42 #include <svl/whiter.hxx>
  43 #include <sfx2/app.hxx>
  44 #include <svl/intitem.hxx>
  45 #include <svl/visitem.hxx>
  46 #include <unotools/moduleoptions.hxx>
  47 #include <sfx2/objface.hxx>
  48 #include <sfx2/request.hxx>
  49 #include <sfx2/dispatch.hxx>
  50 #include <sfx2/objsh.hxx>
  51 #include <svx/svdobj.hxx>
  52 #include <svx/fmpage.hxx>
  53 #include "svx/svditer.hxx"
  54 #include "fmobj.hxx"
  55
  56 #include <svx/svxids.hrc>
  57
  58 #include "svx/fmresids.hrc"
  59 #include "fmexch.hxx"
  60 #include <svx/fmglob.hxx>
  61 #include <svl/eitem.hxx>
  62 #include <tools/diagnose_ex.h>
  63 #include <svx/svdpage.hxx>
  64 #include <svx/fmmodel.hxx>
  65 #include <svx/dialmgr.hxx>
  66 #include "fmshimp.hxx"
  67 #include <svx/svdpagv.hxx>
  68 #include <sfx2/objitem.hxx>
  69 #include <sfx2/viewsh.hxx>
  70 #include "fmexpl.hxx"
  71 #include "formcontrolling.hxx"
  72 #include <svl/numuno.hxx>
  73 #include <connectivity/dbtools.hxx>
  74 #include <comphelper/types.hxx>
  75 #include <comphelper/processfactory.hxx>
  76 #include "fmdocumentclassification.hxx"
  77 #include "formtoolbars.hxx"
  78
  79 #include <svx/svxdlg.hxx>
  80 #include <svx/dialogs.hrc>
  81
  82 #include "svx/sdrobjectfilter.hxx"
  83
  84 #define FmFormShell
  85 #include "svxslots.hxx"
  86
  87 #include "tbxform.hxx"
  88 #include <comphelper/property.hxx>
  89 #include <com/sun/star/beans/PropertyValue.hpp>
  90
  91 #include <boost/scoped_ptr.hpp>
  92
  93 // wird fuer Invalidate verwendet -> mitpflegen
  94 // aufsteigend sortieren !!!!!!
  95 sal_uInt16 ControllerSlotMap[] =    // slots des Controllers
  96 {
  97     SID_FM_CONFIG,
  98     SID_FM_PUSHBUTTON,
  99     SID_FM_RADIOBUTTON,
 100     SID_FM_CHECKBOX,
 101     SID_FM_FIXEDTEXT,
 102     SID_FM_GROUPBOX,
 103     SID_FM_EDIT,
 104     SID_FM_LISTBOX,
 105     SID_FM_COMBOBOX,
 106     SID_FM_DBGRID,
 107     SID_FM_IMAGEBUTTON,
 108     SID_FM_FILECONTROL,
 109     SID_FM_NAVIGATIONBAR,
 110     SID_FM_CTL_PROPERTIES,
 111     SID_FM_PROPERTIES,
 112     SID_FM_TAB_DIALOG,
 113     SID_FM_ADD_FIELD,
 114     SID_FM_DESIGN_MODE,
 115     SID_FM_SHOW_FMEXPLORER,
 116     SID_FM_SHOW_PROPERTIES,
 117     SID_FM_FMEXPLORER_CONTROL,
 118     SID_FM_DATEFIELD,
 119     SID_FM_TIMEFIELD,
 120     SID_FM_NUMERICFIELD,
 121     SID_FM_CURRENCYFIELD,
 122     SID_FM_PATTERNFIELD,
 123     SID_FM_OPEN_READONLY,
 124     SID_FM_IMAGECONTROL,
 125     SID_FM_USE_WIZARDS,
 126     SID_FM_FORMATTEDFIELD,
 127     SID_FM_FILTER_NAVIGATOR,
 128     SID_FM_AUTOCONTROLFOCUS,
 129     SID_FM_SCROLLBAR,
 130     SID_FM_SPINBUTTON,
 131     SID_FM_SHOW_DATANAVIGATOR,
 132     SID_FM_DATANAVIGATOR_CONTROL,
 133
 134     0
 135 };
 136
 137 using namespace ::com::sun::star::uno;
 138 using namespace ::com::sun::star::awt;
 139 using namespace ::com::sun::star::sdbc;
 140 using namespace ::com::sun::star::sdbcx;
 141 using namespace ::com::sun::star::beans;
 142 using namespace ::com::sun::star::form;
 143 using namespace ::com::sun::star::form::runtime;
 144 using namespace ::com::sun::star::frame;
 145 using namespace ::svxform;
 146
 147 FmDesignModeChangedHint::FmDesignModeChangedHint( bool bDesMode )
 148     :m_bDesignMode( bDesMode )
 149 {
 150 }
 151
 152
 153 FmDesignModeChangedHint::~FmDesignModeChangedHint()
 154 {
 155 }
 156
 157 const sal_uInt32 FM_UI_FEATURE_SHOW_DATABASEBAR         = 0x00000001;
 158 const sal_uInt32 FM_UI_FEATURE_SHOW_FIELD               = 0x00000002;
 159 const sal_uInt32 FM_UI_FEATURE_SHOW_PROPERTIES          = 0x00000004;
 160 const sal_uInt32 FM_UI_FEATURE_SHOW_EXPLORER            = 0x00000008;
 161 const sal_uInt32 FM_UI_FEATURE_SHOW_FILTERBAR           = 0x00000010;
 162 const sal_uInt32 FM_UI_FEATURE_SHOW_FILTERNAVIGATOR     = 0x00000020;
 163 const sal_uInt32 FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR    = 0x00000040;
 164 const sal_uInt32 FM_UI_FEATURE_TB_CONTROLS              = 0x00000080;
 165 const sal_uInt32 FM_UI_FEATURE_TB_MORECONTROLS          = 0x00000100;
 166 const sal_uInt32 FM_UI_FEATURE_TB_FORMDESIGN            = 0x00000200;
 167 const sal_uInt32 FM_UI_FEATURE_SHOW_DATANAVIGATOR       = 0x00000400;
 168
 169 SFX_IMPL_INTERFACE(FmFormShell, SfxShell)
 170
 171 void FmFormShell::InitInterface_Impl()
 172 {
 173     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION|SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_READONLYDOC,
 174                                             RID_SVXTBX_FORM_NAVIGATION,
 175                                             FM_UI_FEATURE_SHOW_DATABASEBAR);
 176
 177     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_NAVIGATION|SFX_VISIBILITY_STANDARD|SFX_VISIBILITY_READONLYDOC,
 178                                             RID_SVXTBX_FORM_FILTER,
 179                                             FM_UI_FEATURE_SHOW_FILTERBAR);
 180
 181     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD | SFX_VISIBILITY_READONLYDOC,
 182                                             RID_SVXTBX_TEXT_CONTROL_ATTRIBUTES,
 183                                             FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR);
 184
 185     GetStaticInterface()->RegisterChildWindow(SID_FM_ADD_FIELD, false, FM_UI_FEATURE_SHOW_FIELD);
 186     GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_PROPERTIES, false, FM_UI_FEATURE_SHOW_PROPERTIES);
 187     GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_FMEXPLORER, false, FM_UI_FEATURE_SHOW_EXPLORER);
 188     GetStaticInterface()->RegisterChildWindow(SID_FM_FILTER_NAVIGATOR, false, FM_UI_FEATURE_SHOW_FILTERNAVIGATOR);
 189     GetStaticInterface()->RegisterChildWindow(SID_FM_SHOW_DATANAVIGATOR, false, FM_UI_FEATURE_SHOW_DATANAVIGATOR);
 190
 191     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD,
 192                                             RID_SVXTBX_CONTROLS,
 193                                             FM_UI_FEATURE_TB_CONTROLS);
 194
 195     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD,
 196                                             RID_SVXTBX_MORECONTROLS,
 197                                             FM_UI_FEATURE_TB_MORECONTROLS);
 198
 199     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT | SFX_VISIBILITY_STANDARD,
 200                                             RID_SVXTBX_FORMDESIGN,
 201                                             FM_UI_FEATURE_TB_FORMDESIGN);
 202 }
 203
 204 TYPEINIT1(FmFormShell,SfxShell)
 205
 206 FmFormShell::FmFormShell( SfxViewShell* _pParent, FmFormView* pView )
 207             :SfxShell(_pParent)
 208             ,m_pImpl(new FmXFormShell(*this, _pParent->GetViewFrame()))
 209             ,m_pFormView( pView )
 210             ,m_pFormModel( NULL )
 211             ,m_pParentShell(_pParent)
 212             ,m_nLastSlot( 0 )
 213             ,m_bDesignMode( true )
 214             ,m_bHasForms(false)
 215 {
 216     m_pImpl->acquire();
 217     SetPool( &SfxGetpApp()->GetPool() );
 218     SetName( OUString("Form") );
 219
 220     SetView(m_pFormView);
 221 }
 222
 223
 224 FmFormShell::~FmFormShell()
 225 {
 226     if ( m_pFormView )
 227         SetView( NULL );
 228
 229     m_pImpl->dispose();
 230     m_pImpl->release();
 231     m_pImpl = NULL;
 232 }
 233
 234
 235 void FmFormShell::NotifyMarkListChanged(FmFormView* pWhichView)
 236 {
 237     FmNavViewMarksChanged aChangeNotification(pWhichView);
 238     Broadcast(aChangeNotification);
 239 }
 240
 241
 242 bool FmFormShell::PrepareClose(bool bUI)
 243 {
 244     if ( GetImpl()->didPrepareClose() )
 245         // we already did a PrepareClose for the current modifications of the current form
 246         return true;
 247
 248     bool bResult = true;
 249     // Save the data records, not in DesignMode and FilterMode
 250     if (!m_bDesignMode && !GetImpl()->isInFilterMode() &&
 251         m_pFormView && m_pFormView->GetActualOutDev() &&
 252         m_pFormView->GetActualOutDev()->GetOutDevType() == OUTDEV_WINDOW)
 253     {
 254         SdrPageView* pCurPageView = m_pFormView->GetSdrPageView();
 255
 256         // sal_uInt16 nPos = pCurPageView ? pCurPageView->GetWinList().Find((OutputDevice*)m_pFormView->GetActualOutDev()) : SDRPAGEVIEWWIN_NOTFOUND;
 257         SdrPageWindow* pWindow = pCurPageView ? pCurPageView->FindPageWindow(*const_cast<OutputDevice*>(m_pFormView->GetActualOutDev())) : 0L;
 258
 259         if(pWindow)
 260         {
 261             // Zunaechst werden die aktuellen Inhalte der Controls gespeichert
 262             // Wenn alles glatt gelaufen ist, werden die modifizierten Datensaetze gespeichert
 263             if ( GetImpl()->getActiveController().is() )
 264             {
 265                 const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures();
 266                 if ( rController->commitCurrentControl() )
 267                 {
 268                     bool bModified = rController->isModifiedRow();
 269
 270                     if ( bModified && bUI )
 271                     {
 272                         ScopedVclPtrInstance<MessageDialog> aQry(
 273                             nullptr, "SaveModifiedDialog",
 274                             "svx/ui/savemodifieddialog.ui");
 275                         switch (aQry->Execute())
 276                         {
 277                             case RET_NO:
 278                                 bModified = false;
 279                                 // fallthrough to next case
 280                             case RET_YES:
 281                                 GetImpl()->didPrepareClose( true );
 282                                 break;
 283
 284                             case RET_CANCEL:
 285                                 return false;
 286                         }
 287
 288                             if ( bModified )
 289                                 bResult = rController->commitCurrentRecord( );
 290                     }
 291                 }
 292             }
 293         }
 294     }
 295     return bResult;
 296 }
 297
 298
 299 void FmFormShell::impl_setDesignMode(bool bDesign)
 300 {
 301     if (m_pFormView)
 302     {
 303         if (!bDesign)
 304             m_nLastSlot = SID_FM_DESIGN_MODE;
 305
 306         GetImpl()->SetDesignMode(bDesign);
 307         // mein m_bDesignMode wird auch von der Impl gesetzt ...
 308     }
 309     else
 310     {
 311         m_bHasForms = false;
 312         m_bDesignMode = bDesign;
 313         UIFeatureChanged();
 314     }
 315
 316     GetViewShell()->GetViewFrame()->GetBindings().Invalidate(ControllerSlotMap);
 317 }
 318
 319
 320 bool FmFormShell::HasUIFeature( sal_uInt32 nFeature )
 321 {
 322     bool bResult = false;
 323     if ((nFeature & FM_UI_FEATURE_SHOW_DATABASEBAR) == FM_UI_FEATURE_SHOW_DATABASEBAR)
 324     {
 325         // nur wenn auch formulare verfuegbar
 326         bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && !GetImpl()->isInFilterMode();
 327     }
 328     else if ((nFeature & FM_UI_FEATURE_SHOW_FILTERBAR) == FM_UI_FEATURE_SHOW_FILTERBAR)
 329     {
 330         // nur wenn auch formulare verfuegbar
 331         bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && GetImpl()->isInFilterMode();
 332     }
 333     else if ((nFeature & FM_UI_FEATURE_SHOW_FILTERNAVIGATOR) == FM_UI_FEATURE_SHOW_FILTERNAVIGATOR)
 334     {
 335         bResult = !m_bDesignMode && GetImpl()->hasDatabaseBar() && GetImpl()->isInFilterMode();
 336     }
 337     else if ((nFeature & FM_UI_FEATURE_SHOW_FIELD) == FM_UI_FEATURE_SHOW_FIELD)
 338     {
 339         bResult = m_bDesignMode && m_pFormView && m_bHasForms;
 340     }
 341     else if ((nFeature & FM_UI_FEATURE_SHOW_PROPERTIES) == FM_UI_FEATURE_SHOW_PROPERTIES)
 342     {
 343         bResult = m_bDesignMode && m_pFormView && m_bHasForms;
 344     }
 345     else if ((nFeature & FM_UI_FEATURE_SHOW_EXPLORER) == FM_UI_FEATURE_SHOW_EXPLORER)
 346     {
 347         bResult = m_bDesignMode; // OJ #101593# && m_pFormView && m_bHasForms;
 348     }
 349     else if ( ( nFeature & FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR ) == FM_UI_FEATURE_SHOW_TEXT_CONTROL_BAR )
 350     {
 351         bResult = !GetImpl()->IsReadonlyDoc() && m_pImpl->IsActiveControl( true );
 352     }
 353     else if ((nFeature & FM_UI_FEATURE_SHOW_DATANAVIGATOR) == FM_UI_FEATURE_SHOW_DATANAVIGATOR)
 354     {
 355         bResult = GetImpl()->isEnhancedForm();
 356     }
 357     else if (  ( ( nFeature & FM_UI_FEATURE_TB_CONTROLS ) == FM_UI_FEATURE_TB_CONTROLS )
 358             || ( ( nFeature & FM_UI_FEATURE_TB_MORECONTROLS ) == FM_UI_FEATURE_TB_MORECONTROLS )
 359             || ( ( nFeature & FM_UI_FEATURE_TB_FORMDESIGN ) == FM_UI_FEATURE_TB_FORMDESIGN )
 360             )
 361     {
 362         bResult = true;
 363     }
 364
 365     return bResult;
 366 }
 367
 368
 369 void FmFormShell::Execute(SfxRequest &rReq)
 370 {
 371     sal_uInt16 nSlot = rReq.GetSlot();
 372
 373
 374     // MasterSlot setzen
 375     switch( nSlot )
 376     {
 377         case SID_FM_PUSHBUTTON:
 378         case SID_FM_RADIOBUTTON:
 379         case SID_FM_CHECKBOX:
 380         case SID_FM_FIXEDTEXT:
 381         case SID_FM_GROUPBOX:
 382         case SID_FM_LISTBOX:
 383         case SID_FM_COMBOBOX:
 384         case SID_FM_NAVIGATIONBAR:
 385         case SID_FM_EDIT:
 386         case SID_FM_DBGRID:
 387         case SID_FM_IMAGEBUTTON:
 388         case SID_FM_IMAGECONTROL:
 389         case SID_FM_FILECONTROL:
 390         case SID_FM_DATEFIELD:
 391         case SID_FM_TIMEFIELD:
 392         case SID_FM_NUMERICFIELD:
 393         case SID_FM_CURRENCYFIELD:
 394         case SID_FM_PATTERNFIELD:
 395         case SID_FM_FORMATTEDFIELD:
 396         case SID_FM_SCROLLBAR:
 397         case SID_FM_SPINBUTTON:
 398             m_nLastSlot = nSlot;
 399             GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG );
 400             break;
 401     }
 402
 403
 404     // Identifier und Inventor des Uno-Controls setzen
 405     sal_uInt16 nIdentifier = 0;
 406     switch( nSlot )
 407     {
 408         case SID_FM_CHECKBOX:
 409             nIdentifier = OBJ_FM_CHECKBOX;
 410             break;
 411         case SID_FM_PUSHBUTTON:
 412             nIdentifier = OBJ_FM_BUTTON;
 413             break;
 414         case SID_FM_FIXEDTEXT:
 415             nIdentifier = OBJ_FM_FIXEDTEXT;
 416             break;
 417         case SID_FM_LISTBOX:
 418             nIdentifier = OBJ_FM_LISTBOX;
 419             break;
 420         case SID_FM_EDIT:
 421             nIdentifier = OBJ_FM_EDIT;
 422             break;
 423         case SID_FM_RADIOBUTTON:
 424             nIdentifier = OBJ_FM_RADIOBUTTON;
 425             break;
 426         case SID_FM_GROUPBOX:
 427             nIdentifier = OBJ_FM_GROUPBOX;
 428             break;
 429         case SID_FM_COMBOBOX:
 430             nIdentifier = OBJ_FM_COMBOBOX;
 431             break;
 432         case SID_FM_NAVIGATIONBAR:
 433             nIdentifier = OBJ_FM_NAVIGATIONBAR;
 434             break;
 435         case SID_FM_DBGRID:
 436             nIdentifier = OBJ_FM_GRID;
 437             break;
 438         case SID_FM_IMAGEBUTTON:
 439             nIdentifier = OBJ_FM_IMAGEBUTTON;
 440             break;
 441         case SID_FM_IMAGECONTROL:
 442             nIdentifier = OBJ_FM_IMAGECONTROL;
 443             break;
 444         case SID_FM_FILECONTROL:
 445             nIdentifier = OBJ_FM_FILECONTROL;
 446             break;
 447         case SID_FM_DATEFIELD:
 448             nIdentifier = OBJ_FM_DATEFIELD;
 449             break;
 450         case SID_FM_TIMEFIELD:
 451             nIdentifier = OBJ_FM_TIMEFIELD;
 452             break;
 453         case SID_FM_NUMERICFIELD:
 454             nIdentifier = OBJ_FM_NUMERICFIELD;
 455             break;
 456         case SID_FM_CURRENCYFIELD:
 457             nIdentifier = OBJ_FM_CURRENCYFIELD;
 458             break;
 459         case SID_FM_PATTERNFIELD:
 460             nIdentifier = OBJ_FM_PATTERNFIELD;
 461             break;
 462         case SID_FM_FORMATTEDFIELD:
 463             nIdentifier = OBJ_FM_FORMATTEDFIELD;
 464             break;
 465         case SID_FM_SCROLLBAR:
 466             nIdentifier = OBJ_FM_SCROLLBAR;
 467             break;
 468         case SID_FM_SPINBUTTON:
 469             nIdentifier = OBJ_FM_SPINBUTTON;
 470             break;
 471     }
 472
 473     switch ( nSlot )
 474     {
 475         case SID_FM_CHECKBOX:
 476         case SID_FM_PUSHBUTTON:
 477         case SID_FM_FIXEDTEXT:
 478         case SID_FM_LISTBOX:
 479         case SID_FM_EDIT:
 480         case SID_FM_RADIOBUTTON:
 481         case SID_FM_COMBOBOX:
 482         case SID_FM_NAVIGATIONBAR:
 483         case SID_FM_GROUPBOX:
 484         case SID_FM_DBGRID:
 485         case SID_FM_IMAGEBUTTON:
 486         case SID_FM_IMAGECONTROL:
 487         case SID_FM_FILECONTROL:
 488         case SID_FM_DATEFIELD:
 489         case SID_FM_TIMEFIELD:
 490         case SID_FM_NUMERICFIELD:
 491         case SID_FM_CURRENCYFIELD:
 492         case SID_FM_PATTERNFIELD:
 493         case SID_FM_FORMATTEDFIELD:
 494         case SID_FM_SCROLLBAR:
 495         case SID_FM_SPINBUTTON:
 496         {
 497             SFX_REQUEST_ARG( rReq, pGrabFocusItem, SfxBoolItem, SID_FM_TOGGLECONTROLFOCUS, false );
 498             if ( pGrabFocusItem && pGrabFocusItem->GetValue() )
 499             {   // see below
 500                 SfxViewShell* pShell = GetViewShell();
 501                 vcl::Window* pShellWnd = pShell ? pShell->GetWindow() : NULL;
 502                 if ( pShellWnd )
 503                     pShellWnd->GrabFocus();
 504                 break;
 505             }
 506
 507             SfxUInt16Item aIdentifierItem( SID_FM_CONTROL_IDENTIFIER, nIdentifier );
 508             SfxUInt32Item aInventorItem( SID_FM_CONTROL_INVENTOR, FmFormInventor );
 509             const SfxPoolItem* pArgs[] =
 510             {
 511                 &aIdentifierItem, &aInventorItem, NULL
 512             };
 513             const SfxPoolItem* pInternalArgs[] =
 514             {
 515                 NULL
 516             };
 517
 518             GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_CREATE_CONTROL, SfxCallMode::ASYNCHRON,
 519                                       pArgs, rReq.GetModifier(), pInternalArgs );
 520
 521             if ( rReq.GetModifier() & KEY_MOD1 )
 522             {
 523                 //  #99013# if selected with control key, return focus to current view
 524                 // do this asynchron, so that the creation can be finished first
 525                 // reusing the SID_FM_TOGGLECONTROLFOCUS is somewhat hacky ... which it wouldn't if it would have another
 526                 // name, so I do not really have a big problem with this ....
 527                 SfxBoolItem aGrabFocusIndicatorItem( SID_FM_TOGGLECONTROLFOCUS, true );
 528                 GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( nSlot, SfxCallMode::ASYNCHRON,
 529                                           &aGrabFocusIndicatorItem, NULL );
 530             }
 531
 532             rReq.Done();
 533         }   break;
 534     }
 535
 536     // Individuelle Aktionen
 537     switch( nSlot )
 538     {
 539         case SID_FM_MORE_CONTROLS:
 540         case SID_FM_FORM_DESIGN_TOOLS:
 541         {
 542             FormToolboxes aToolboxAccess( GetImpl()->getHostFrame() );
 543             aToolboxAccess.toggleToolbox( nSlot );
 544             rReq.Done();
 545         }
 546         break;
 547
 548         case SID_FM_TOGGLECONTROLFOCUS:
 549         {
 550             FmFormView* pFormView = GetFormView();
 551             if ( !pFormView )
 552                 break;
 553
 554             // if we execute this ourself, then either the application does not implement an own handling for this,
 555             // of we're on the top of the dispatcher stack, which means a control has the focus.
 556             // In the latter case, we put the focus to the document window, otherwise, we focus the first control
 557             const bool bHasControlFocus = GetImpl()->HasControlFocus();
 558             if ( bHasControlFocus )
 559             {
 560                 const OutputDevice* pDevice = GetCurrentViewDevice();
 561                 vcl::Window* pWindow = dynamic_cast< vcl::Window* >( const_cast< OutputDevice* >( pDevice ) );
 562                 if ( pWindow )
 563                     pWindow->GrabFocus();
 564             }
 565             else
 566             {
 567                 pFormView->GrabFirstControlFocus( );
 568             }
 569         }
 570         break;
 571
 572         case SID_FM_VIEW_AS_GRID:
 573             GetImpl()->CreateExternalView();
 574             break;
 575         case SID_FM_CONVERTTO_EDIT          :
 576         case SID_FM_CONVERTTO_BUTTON            :
 577         case SID_FM_CONVERTTO_FIXEDTEXT     :
 578         case SID_FM_CONVERTTO_LISTBOX       :
 579         case SID_FM_CONVERTTO_CHECKBOX      :
 580         case SID_FM_CONVERTTO_RADIOBUTTON   :
 581         case SID_FM_CONVERTTO_GROUPBOX      :
 582         case SID_FM_CONVERTTO_COMBOBOX      :
 583         case SID_FM_CONVERTTO_IMAGEBUTTON   :
 584         case SID_FM_CONVERTTO_FILECONTROL   :
 585         case SID_FM_CONVERTTO_DATE          :
 586         case SID_FM_CONVERTTO_TIME          :
 587         case SID_FM_CONVERTTO_NUMERIC       :
 588         case SID_FM_CONVERTTO_CURRENCY      :
 589         case SID_FM_CONVERTTO_PATTERN       :
 590         case SID_FM_CONVERTTO_IMAGECONTROL  :
 591         case SID_FM_CONVERTTO_FORMATTED     :
 592         case SID_FM_CONVERTTO_SCROLLBAR     :
 593         case SID_FM_CONVERTTO_SPINBUTTON    :
 594         case SID_FM_CONVERTTO_NAVIGATIONBAR :
 595             GetImpl()->executeControlConversionSlot( nSlot );
 596             // nach dem Konvertieren die Selektion neu bestimmern, da sich ja das selektierte Objekt
 597             // geaendert hat
 598             GetImpl()->SetSelection(GetFormView()->GetMarkedObjectList());
 599             break;
 600         case SID_FM_LEAVE_CREATE:
 601             m_nLastSlot = 0;
 602             GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG );
 603             rReq.Done();
 604             break;
 605         case SID_FM_SHOW_PROPERTY_BROWSER:
 606         {
 607             SFX_REQUEST_ARG( rReq, pShowItem, SfxBoolItem, SID_FM_SHOW_PROPERTIES, false );
 608             bool bShow = true;
 609             if ( pShowItem )
 610                 bShow = pShowItem->GetValue();
 611             GetImpl()->ShowSelectionProperties( bShow );
 612
 613             rReq.Done();
 614         } break;
 615
 616         case SID_FM_PROPERTIES:
 617         {
 618             // PropertyBrowser anzeigen
 619             SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nSlot, false);
 620             bool bShow = pShowItem == nullptr || pShowItem->GetValue();
 621
 622             InterfaceBag aOnlyTheForm;
 623             aOnlyTheForm.insert( Reference< XInterface >( GetImpl()->getCurrentForm(), UNO_QUERY ) );
 624             GetImpl()->setCurrentSelection( aOnlyTheForm );
 625
 626             GetImpl()->ShowSelectionProperties( bShow );
 627
 628             rReq.Done();
 629         }   break;
 630
 631         case SID_FM_CTL_PROPERTIES:
 632         {
 633             SFX_REQUEST_ARG(rReq, pShowItem, SfxBoolItem, nSlot, false);
 634             bool bShow = pShowItem == nullptr || pShowItem->GetValue();
 635
 636             OSL_ENSURE( GetImpl()->onlyControlsAreMarked(), "FmFormShell::Execute: ControlProperties should be disabled!" );
 637             if ( bShow )
 638                 GetImpl()->selectLastMarkedControls();
 639             GetImpl()->ShowSelectionProperties( bShow );
 640
 641             rReq.Done();
 642         }   break;
 643         case SID_FM_SHOW_PROPERTIES:
 644         case SID_FM_ADD_FIELD:
 645         case SID_FM_FILTER_NAVIGATOR:
 646         case SID_FM_SHOW_DATANAVIGATOR :
 647         {
 648             GetViewShell()->GetViewFrame()->ChildWindowExecute( rReq );
 649             rReq.Done();
 650         }   break;
 651         case SID_FM_SHOW_FMEXPLORER:
 652         {
 653             if (!m_pFormView)   // setzen der View Forcieren
 654                 GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_CREATE_SW_DRAWVIEW);
 655
 656             GetViewShell()->GetViewFrame()->ChildWindowExecute(rReq);
 657             rReq.Done();
 658         }
 659         break;
 660
 661         case SID_FM_TAB_DIALOG:
 662         {
 663             GetImpl()->ExecuteTabOrderDialog( Reference< XTabControllerModel >( GetImpl()->getCurrentForm(), UNO_QUERY ) );
 664             rReq.Done();
 665         }
 666         break;
 667
 668         case SID_FM_DESIGN_MODE:
 669         {
 670             SFX_REQUEST_ARG(rReq, pDesignItem, SfxBoolItem, nSlot, false);
 671             bool bDesignMode = pDesignItem ? pDesignItem->GetValue() : !m_bDesignMode;
 672             SetDesignMode( bDesignMode );
 673             if ( m_bDesignMode == bDesignMode )
 674                 rReq.Done();
 675
 676             m_nLastSlot = SID_FM_DESIGN_MODE;
 677             GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_FM_CONFIG );
 678         }
 679         break;
 680
 681         case SID_FM_AUTOCONTROLFOCUS:
 682         {
 683             FmFormModel* pModel = GetFormModel();
 684             DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !");
 685                 // should have been disabled in GetState if we don't have a FormModel
 686             pModel->SetAutoControlFocus( !pModel->GetAutoControlFocus() );
 687             GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_AUTOCONTROLFOCUS);
 688         }
 689         break;
 690         case SID_FM_OPEN_READONLY:
 691         {
 692             FmFormModel* pModel = GetFormModel();
 693             DBG_ASSERT(pModel, "FmFormShell::Execute : invalid call !");
 694                 // should have been disabled in GetState if we don't have a FormModel
 695             pModel->SetOpenInDesignMode( !pModel->GetOpenInDesignMode() );
 696             GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_OPEN_READONLY);
 697         }
 698         break;
 699         case SID_FM_USE_WIZARDS:
 700         {
 701             GetImpl()->SetWizardUsing(!GetImpl()->GetWizardUsing());
 702             GetViewShell()->GetViewFrame()->GetBindings().Invalidate(SID_FM_USE_WIZARDS);
 703         }
 704         break;
 705         case SID_FM_SEARCH:
 706         {
 707             const svx::ControllerFeatures& rController = GetImpl()->getActiveControllerFeatures();
 708             if ( rController->commitCurrentControl() && rController->commitCurrentRecord() )
 709                 GetImpl()->ExecuteSearch();
 710             rReq.Done();
 711         }
 712         break;
 713
 714         case SID_FM_RECORD_FIRST:
 715         case SID_FM_RECORD_PREV:
 716         case SID_FM_RECORD_NEXT:
 717         case SID_FM_RECORD_LAST:
 718         case SID_FM_RECORD_NEW:
 719         case SID_FM_REFRESH:
 720         case SID_FM_REFRESH_FORM_CONTROL:
 721         case SID_FM_RECORD_DELETE:
 722         case SID_FM_RECORD_UNDO:
 723         case SID_FM_RECORD_SAVE:
 724         case SID_FM_REMOVE_FILTER_SORT:
 725         case SID_FM_SORTDOWN:
 726         case SID_FM_SORTUP:
 727         case SID_FM_AUTOFILTER:
 728         case SID_FM_ORDERCRIT:
 729         case SID_FM_FORM_FILTERED:
 730         {
 731             GetImpl()->ExecuteFormSlot( nSlot );
 732             rReq.Done();
 733         }
 734         break;
 735
 736         case SID_FM_RECORD_ABSOLUTE:
 737         {
 738             const svx::ControllerFeatures& rController = GetImpl()->getNavControllerFeatures();
 739             sal_Int32 nRecord = -1;
 740
 741             const SfxItemSet* pArgs = rReq.GetArgs();
 742             if ( pArgs )
 743             {
 744                 const SfxPoolItem* pItem;
 745                 if ( ( pArgs->GetItemState( FN_PARAM_1, true, &pItem ) ) == SfxItemState::SET )
 746                 {
 747                     const SfxInt32Item* pTypedItem = PTR_CAST( SfxInt32Item, pItem );
 748                     if ( pTypedItem )
 749                         nRecord = std::max( pTypedItem->GetValue(), sal_Int32(0) );
 750                 }
 751             }
 752             else
 753             {
 754                 SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
 755                 DBG_ASSERT( pFact, "no dialog factory!" );
 756                 if ( pFact )
 757                 {
 758                     boost::scoped_ptr< AbstractFmInputRecordNoDialog > dlg( pFact->CreateFmInputRecordNoDialog( NULL ) );
 759                     DBG_ASSERT( dlg.get(), "Dialog creation failed!" );
 760                     dlg->SetValue( rController->getCursor()->getRow() );
 761                     if ( dlg->Execute() == RET_OK )
 762                         nRecord = dlg->GetValue();
 763
 764                     rReq.AppendItem( SfxInt32Item( FN_PARAM_1, nRecord ) );
 765                 }
 766             }
 767
 768             if ( nRecord != -1 )
 769                 rController->execute( nSlot, OUString( "Position" ), makeAny( (sal_Int32)nRecord ) );
 770
 771             rReq.Done();
 772         }   break;
 773         case SID_FM_FILTER_EXECUTE:
 774         case SID_FM_FILTER_EXIT:
 775         {
 776             bool bCancelled = ( SID_FM_FILTER_EXIT == nSlot );
 777             bool bReopenNavigator = false;
 778
 779             if ( !bCancelled )
 780             {
 781                 // if the filter navigator is still open, we need to close it, so it can possibly
 782                 // commit it's most recent changes
 783                 if ( GetViewShell() && GetViewShell()->GetViewFrame() )
 784                     if ( GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR ) )
 785                     {
 786                         GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR );
 787                         bReopenNavigator = true;
 788                     }
 789
 790                 Reference< runtime::XFormController >  xController( GetImpl()->getActiveController() );
 791
 792                 if  (   GetViewShell()->GetViewFrame()->HasChildWindow( SID_FM_FILTER_NAVIGATOR )
 793                         // closing the window was denied, for instance because of a invalid criterion
 794
 795                     ||  (   xController.is()
 796                         &&  !GetImpl()->getActiveControllerFeatures()->commitCurrentControl( )
 797                         )
 798                         // committing the controller was denied
 799                     )
 800                 {
 801                     rReq.Done();
 802                     break;
 803                 }
 804             }
 805
 806             GetImpl()->stopFiltering( !bCancelled );
 807             rReq.Done();
 808
 809             if ( bReopenNavigator )
 810                 // we closed the navigator only to implicitly commit it (as we do not have another
 811                 // direct wire to it), but to the user, it should look as it was always open
 812                 GetViewShell()->GetViewFrame()->ToggleChildWindow( SID_FM_FILTER_NAVIGATOR );
 813         }
 814         break;
 815
 816         case SID_FM_FILTER_START:
 817         {
 818             GetImpl()->startFiltering();
 819             rReq.Done();
 820
 821             // initially open the filter navigator, the whole form based filter is pretty useless without it
 822             SfxBoolItem aIdentifierItem( SID_FM_FILTER_NAVIGATOR, true );
 823             GetViewShell()->GetViewFrame()->GetDispatcher()->Execute( SID_FM_FILTER_NAVIGATOR, SfxCallMode::ASYNCHRON,
 824                 &aIdentifierItem, NULL );
 825         }   break;
 826     }
 827 }
 828
 829
 830 void FmFormShell::GetState(SfxItemSet &rSet)
 831 {
 832     SfxWhichIter aIter( rSet );
 833     sal_uInt16 nWhich = aIter.FirstWhich();
 834     while ( nWhich )
 835     {
 836         switch( nWhich )
 837         {
 838             case SID_FM_MORE_CONTROLS:
 839             case SID_FM_FORM_DESIGN_TOOLS:
 840             {
 841                 FormToolboxes aToolboxAccess( GetImpl()->getHostFrame() );
 842                 rSet.Put( SfxBoolItem( nWhich, aToolboxAccess.isToolboxVisible( nWhich ) ) );
 843             }
 844             break;
 845
 846             case SID_FM_FILTER_EXECUTE:
 847             case SID_FM_FILTER_EXIT:
 848                 if (!GetImpl()->isInFilterMode())
 849                     rSet.DisableItem( nWhich );
 850                 break;
 851
 852             case SID_FM_USE_WIZARDS:
 853                 if  ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
 854                     rSet.Put( SfxVisibilityItem( nWhich, false ) );
 855                 else if (!GetFormModel())
 856                     rSet.DisableItem( nWhich );
 857                 else
 858                     rSet.Put( SfxBoolItem(nWhich, GetImpl()->GetWizardUsing() ) );
 859                 break;
 860             case SID_FM_AUTOCONTROLFOCUS:
 861                 if (!GetFormModel())
 862                     rSet.DisableItem( nWhich );
 863                 else
 864                     rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetAutoControlFocus() ) );
 865                 break;
 866             case SID_FM_OPEN_READONLY:
 867                 if (!GetFormModel())
 868                     rSet.DisableItem( nWhich );
 869                 else
 870                     rSet.Put( SfxBoolItem(nWhich, GetFormModel()->GetOpenInDesignMode() ) );
 871                 break;
 872
 873             case SID_FM_NAVIGATIONBAR:
 874             case SID_FM_DBGRID:
 875                 if ( !SvtModuleOptions().IsModuleInstalled( SvtModuleOptions::EModule::DATABASE ) )
 876                 {
 877                     rSet.Put( SfxVisibilityItem( nWhich, false ) );
 878                     break;
 879                 }
 880                 // NO break!
 881
 882             case SID_FM_SCROLLBAR:
 883             case SID_FM_IMAGECONTROL:
 884             case SID_FM_FILECONTROL:
 885             case SID_FM_CURRENCYFIELD:
 886             case SID_FM_PATTERNFIELD:
 887             case SID_FM_IMAGEBUTTON:
 888             case SID_FM_RADIOBUTTON:
 889             case SID_FM_COMBOBOX:
 890             case SID_FM_GROUPBOX:
 891             case SID_FM_CHECKBOX:
 892             case SID_FM_PUSHBUTTON:
 893             case SID_FM_FIXEDTEXT:
 894             case SID_FM_LISTBOX:
 895             case SID_FM_EDIT:
 896             case SID_FM_DATEFIELD:
 897             case SID_FM_TIMEFIELD:
 898             case SID_FM_NUMERICFIELD:
 899             case SID_FM_FORMATTEDFIELD:
 900             case SID_FM_SPINBUTTON:
 901                 if (!m_bDesignMode)
 902                     rSet.DisableItem( nWhich );
 903                 else
 904                 {
 905                     bool bLayerLocked = false;
 906                     if (m_pFormView)
 907                     {
 908                         // Ist der ::com::sun::star::drawing::Layer gelocked, so m???ssen die Slots disabled werden. #36897
 909                         SdrPageView* pPV = m_pFormView->GetSdrPageView();
 910                         if (pPV != NULL)
 911                             bLayerLocked = pPV->IsLayerLocked(m_pFormView->GetActiveLayer());
 912                     }
 913                     if (bLayerLocked)
 914                         rSet.DisableItem( nWhich );
 915                     else
 916                         rSet.Put( SfxBoolItem(nWhich, (nWhich==m_nLastSlot)) );
 917                 }
 918                 break;
 919             case SID_FM_FILTER_NAVIGATOR_CONTROL:
 920             {
 921                 if (GetImpl()->isInFilterMode())
 922                     rSet.Put(SfxObjectItem(nWhich, this));
 923                 else
 924                     rSet.Put(SfxObjectItem(nWhich));
 925             }   break;
 926             case SID_FM_FIELDS_CONTROL:
 927             case SID_FM_PROPERTY_CONTROL:
 928             {
 929                 if (!m_bDesignMode || !m_pFormView || !m_bHasForms)
 930                     rSet.Put(SfxObjectItem(nWhich));
 931                 else
 932                     rSet.Put(SfxObjectItem(nWhich, this));
 933
 934             }   break;
 935             case SID_FM_FMEXPLORER_CONTROL:
 936             case SID_FM_DATANAVIGATOR_CONTROL :
 937             {
 938                 if (!m_bDesignMode || !m_pFormView)
 939                     rSet.Put(SfxObjectItem(nWhich));
 940                 else
 941                     rSet.Put(SfxObjectItem(nWhich, this));
 942
 943             }   break;
 944             case SID_FM_ADD_FIELD:
 945             case SID_FM_SHOW_FMEXPLORER:
 946             case SID_FM_SHOW_PROPERTIES:
 947             case SID_FM_FILTER_NAVIGATOR:
 948             case SID_FM_SHOW_DATANAVIGATOR:
 949             {
 950                 if ( GetViewShell()->GetViewFrame()->KnowsChildWindow(nWhich) )
 951                     rSet.Put( SfxBoolItem( nWhich, GetViewShell()->GetViewFrame()->HasChildWindow(nWhich)) );
 952                 else
 953                     rSet.DisableItem(nWhich);
 954             }   break;
 955
 956             case SID_FM_SHOW_PROPERTY_BROWSER:
 957             {
 958                 rSet.Put(SfxBoolItem(nWhich, GetImpl()->IsPropBrwOpen()));
 959             }
 960             break;
 961
 962             case SID_FM_CTL_PROPERTIES:
 963             {
 964                 // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte
 965                 // auf den neuesten Stand zu bringen
 966                 if (GetImpl()->IsSelectionUpdatePending())
 967                     GetImpl()->ForceUpdateSelection(false);
 968
 969                 if ( !m_pFormView || !m_bDesignMode || !GetImpl()->onlyControlsAreMarked() )
 970                     rSet.DisableItem( nWhich );
 971                 else
 972                 {
 973                     bool bChecked  = GetImpl()->IsPropBrwOpen() && !GetImpl()->isSolelySelected( GetImpl()->getCurrentForm() );
 974                         // if the property browser is open, and only controls are marked, and the current selection
 975                         // does not consist of only the current form, then the current selection is the (composition of)
 976                         // the currently marked controls
 977                     rSet.Put( SfxBoolItem( nWhich, bChecked ) );
 978                 }
 979             }   break;
 980
 981             case SID_FM_PROPERTIES:
 982             {
 983                 // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte
 984                 // auf den neuesten Stand zu bringen
 985                 if (GetImpl()->IsSelectionUpdatePending())
 986                     GetImpl()->ForceUpdateSelection(false);
 987
 988                 if ( !m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm().is() )
 989                     rSet.DisableItem( nWhich );
 990                 else
 991                 {
 992                     bool bChecked = GetImpl()->IsPropBrwOpen() && GetImpl()->isSolelySelected( GetImpl()->getCurrentForm() );
 993                     rSet.Put(SfxBoolItem(nWhich, bChecked));
 994                 }
 995             }   break;
 996             case SID_FM_TAB_DIALOG:
 997                 // der Impl eventuell die Moeglichjkeit geben, ihre an der aktuellen MarkList ausgerichteten Objekte
 998                 // auf den neuesten Stand zu bringen
 999                 if (GetImpl()->IsSelectionUpdatePending())
1000                     GetImpl()->ForceUpdateSelection(false);
1001
1002                 if (!m_pFormView || !m_bDesignMode || !GetImpl()->getCurrentForm().is() )
1003                     rSet.DisableItem( nWhich );
1004                 break;
1005             case SID_FM_CONFIG:
1006                 rSet.Put(SfxUInt16Item(nWhich, m_nLastSlot));
1007                 break;
1008             case SID_FM_DESIGN_MODE:
1009                 if (!m_pFormView || GetImpl()->IsReadonlyDoc() )
1010                     rSet.DisableItem( nWhich );
1011                 else
1012                     rSet.Put( SfxBoolItem(nWhich, m_bDesignMode) );
1013                 break;
1014             case SID_FM_SEARCH:
1015             case SID_FM_RECORD_FIRST:
1016             case SID_FM_RECORD_NEXT:
1017             case SID_FM_RECORD_PREV:
1018             case SID_FM_RECORD_LAST:
1019             case SID_FM_RECORD_NEW:
1020             case SID_FM_RECORD_DELETE:
1021             case SID_FM_RECORD_ABSOLUTE:
1022             case SID_FM_RECORD_TOTAL:
1023             case SID_FM_RECORD_SAVE:
1024             case SID_FM_RECORD_UNDO:
1025             case SID_FM_FORM_FILTERED:
1026             case SID_FM_REMOVE_FILTER_SORT:
1027             case SID_FM_SORTUP:
1028             case SID_FM_SORTDOWN:
1029             case SID_FM_ORDERCRIT:
1030             case SID_FM_FILTER_START:
1031             case SID_FM_AUTOFILTER:
1032             case SID_FM_REFRESH:
1033             case SID_FM_REFRESH_FORM_CONTROL:
1034             case SID_FM_VIEW_AS_GRID:
1035                 GetFormState(rSet,nWhich);
1036                 break;
1037
1038             case SID_FM_CHANGECONTROLTYPE:
1039             {
1040                 if ( !m_pFormView || !m_bDesignMode )
1041                     rSet.DisableItem( nWhich );
1042                 else
1043                 {
1044                     if ( !GetImpl()->canConvertCurrentSelectionToControl( OBJ_FM_FIXEDTEXT ) )
1045                         // if it cannot be converted to a fixed text, it is no single control
1046                         rSet.DisableItem( nWhich );
1047                 }
1048             } break;
1049
1050             case SID_FM_CONVERTTO_FILECONTROL   :
1051             case SID_FM_CONVERTTO_CURRENCY      :
1052             case SID_FM_CONVERTTO_PATTERN       :
1053             case SID_FM_CONVERTTO_IMAGECONTROL  :
1054             case SID_FM_CONVERTTO_SCROLLBAR     :
1055             case SID_FM_CONVERTTO_NAVIGATIONBAR :
1056             case SID_FM_CONVERTTO_IMAGEBUTTON   :
1057             case SID_FM_CONVERTTO_EDIT          :
1058             case SID_FM_CONVERTTO_BUTTON        :
1059             case SID_FM_CONVERTTO_FIXEDTEXT     :
1060             case SID_FM_CONVERTTO_LISTBOX       :
1061             case SID_FM_CONVERTTO_CHECKBOX      :
1062             case SID_FM_CONVERTTO_RADIOBUTTON   :
1063             case SID_FM_CONVERTTO_GROUPBOX      :
1064             case SID_FM_CONVERTTO_COMBOBOX      :
1065             case SID_FM_CONVERTTO_DATE          :
1066             case SID_FM_CONVERTTO_TIME          :
1067             case SID_FM_CONVERTTO_NUMERIC       :
1068             case SID_FM_CONVERTTO_FORMATTED     :
1069             case SID_FM_CONVERTTO_SPINBUTTON    :
1070             {
1071                 if ( !m_pFormView || !m_bDesignMode || !GetImpl()->canConvertCurrentSelectionToControl( nWhich ) )
1072                     rSet.DisableItem( nWhich );
1073                 else
1074                 {
1075                     rSet.Put( SfxBoolItem( nWhich, false ) );
1076                     // just to have a defined state (available and not checked)
1077                 }
1078             }
1079             break;
1080         }
1081         nWhich = aIter.NextWhich();
1082     }
1083 }
1084
1085
1086 void FmFormShell::GetFormState(SfxItemSet &rSet, sal_uInt16 nWhich)
1087 {
1088     if  (   !GetImpl()->getNavController().is()
1089         ||  !isRowSetAlive(GetImpl()->getNavController()->getModel())
1090         ||  !m_pFormView
1091         ||  m_bDesignMode
1092         ||  !GetImpl()->getActiveForm().is()
1093         ||  GetImpl()->isInFilterMode()
1094         )
1095         rSet.DisableItem(nWhich);
1096     else
1097     {
1098         bool bEnable = false;
1099         try
1100         {
1101             switch (nWhich)
1102             {
1103             case SID_FM_VIEW_AS_GRID:
1104                 if (GetImpl()->getHostFrame().is() && GetImpl()->getNavController().is())
1105                 {
1106                     bEnable = true;
1107                     bool bDisplayingCurrent =
1108                         GetImpl()->getInternalForm(
1109                             Reference< XForm >( GetImpl()->getNavController()->getModel(), UNO_QUERY )
1110                         ) == GetImpl()->getExternallyDisplayedForm();
1111                     rSet.Put(SfxBoolItem(nWhich, bDisplayingCurrent));
1112                 }
1113                 break;
1114
1115             case SID_FM_SEARCH:
1116             {
1117                 Reference< ::com::sun::star::beans::XPropertySet >  xNavSet(GetImpl()->getActiveForm(), UNO_QUERY);
1118                 sal_Int32 nCount = ::comphelper::getINT32(xNavSet->getPropertyValue(FM_PROP_ROWCOUNT));
1119                 bEnable = nCount != 0;
1120             }   break;
1121             case SID_FM_RECORD_ABSOLUTE:
1122             case SID_FM_RECORD_TOTAL:
1123             {
1124                 FeatureState aState;
1125                 GetImpl()->getNavControllerFeatures()->getState( nWhich, aState );
1126                 if ( SID_FM_RECORD_ABSOLUTE == nWhich )
1127                 {
1128                     sal_Int32 nPosition = 0;
1129                     aState.State >>= nPosition;
1130                     rSet.Put( SfxInt32Item( nWhich, nPosition ) );
1131                 }
1132                 else if ( SID_FM_RECORD_TOTAL == nWhich )
1133                 {
1134                     OUString sTotalCount;
1135                     aState.State >>= sTotalCount;
1136                     rSet.Put( SfxStringItem( nWhich, sTotalCount ) );
1137                 }
1138                 bEnable = aState.Enabled;
1139             }
1140             break;
1141
1142             // first, prev, next, last, and absolute affect the nav controller, not the
1143             // active controller
1144             case SID_FM_RECORD_FIRST:
1145             case SID_FM_RECORD_PREV:
1146             case SID_FM_RECORD_NEXT:
1147             case SID_FM_RECORD_LAST:
1148             case SID_FM_RECORD_NEW:
1149             case SID_FM_RECORD_SAVE:
1150             case SID_FM_RECORD_UNDO:
1151             case SID_FM_RECORD_DELETE:
1152             case SID_FM_REFRESH:
1153             case SID_FM_REFRESH_FORM_CONTROL:
1154             case SID_FM_REMOVE_FILTER_SORT:
1155             case SID_FM_SORTUP:
1156             case SID_FM_SORTDOWN:
1157             case SID_FM_AUTOFILTER:
1158             case SID_FM_ORDERCRIT:
1159                 bEnable = GetImpl()->IsFormSlotEnabled( nWhich );
1160                 break;
1161
1162             case SID_FM_FORM_FILTERED:
1163             {
1164                 FeatureState aState;
1165                 bEnable = GetImpl()->IsFormSlotEnabled( nWhich, &aState );
1166
1167                 rSet.Put( SfxBoolItem( nWhich, ::comphelper::getBOOL( aState.State ) ) );
1168             }
1169             break;
1170
1171             case SID_FM_FILTER_START:
1172                 bEnable = GetImpl()->getActiveControllerFeatures()->canDoFormFilter();
1173                 break;
1174             }
1175         }
1176         catch( const Exception& )
1177         {
1178             OSL_FAIL( "FmFormShell::GetFormState: caught an exception while determining the state!" );
1179         }
1180         if (!bEnable)
1181             rSet.DisableItem(nWhich);
1182     }
1183 }
1184
1185
1186 FmFormPage* FmFormShell::GetCurPage() const
1187 {
1188     FmFormPage* pP = NULL;
1189     if (m_pFormView && m_pFormView->GetSdrPageView())
1190         pP = PTR_CAST(FmFormPage,m_pFormView->GetSdrPageView()->GetPage());
1191     return pP;
1192 }
1193
1194
1195 void FmFormShell::SetView( FmFormView* _pView )
1196 {
1197     if ( m_pFormView )
1198     {
1199         if ( IsActive() )
1200             GetImpl()->viewDeactivated( *m_pFormView );
1201
1202         m_pFormView->SetFormShell( NULL, FmFormView::FormShellAccess() );
1203         m_pFormView = NULL;
1204         m_pFormModel = NULL;
1205     }
1206
1207     if ( !_pView )
1208         return;
1209
1210     m_pFormView = _pView;
1211     m_pFormView->SetFormShell( this, FmFormView::FormShellAccess() );
1212     m_pFormModel = static_cast<FmFormModel*>(m_pFormView->GetModel());
1213
1214     impl_setDesignMode( m_pFormView->IsDesignMode() );
1215
1216     // We activate our view if we are activated ourself, but sometimes the Activate precedes the SetView.
1217     // But here we know both the view and our activation state so we at least are able to pass the latter
1218     // to the former.
1219     // FS - 30.06.99 - 67308
1220     if ( IsActive() )
1221         GetImpl()->viewActivated( *m_pFormView );
1222 }
1223
1224
1225 void FmFormShell::DetermineForms(bool bInvalidate)
1226 {
1227     // Existieren Formulare auf der aktuellen Page
1228     bool bForms = GetImpl()->hasForms();
1229     if (bForms != m_bHasForms)
1230     {
1231         m_bHasForms = bForms;
1232         if (bInvalidate)
1233             UIFeatureChanged();
1234     }
1235 }
1236
1237
1238 bool FmFormShell::GetY2KState(sal_uInt16& nReturn)
1239 {
1240     return GetImpl()->GetY2KState(nReturn);
1241 }
1242
1243
1244 void FmFormShell::SetY2KState(sal_uInt16 n)
1245 {
1246     GetImpl()->SetY2KState(n);
1247 }
1248
1249
1250 void FmFormShell::Activate(bool bMDI)
1251 {
1252     SfxShell::Activate(bMDI);
1253
1254     if ( m_pFormView )
1255         GetImpl()->viewActivated( *m_pFormView, true );
1256 }
1257
1258
1259 void FmFormShell::Deactivate(bool bMDI)
1260 {
1261     SfxShell::Deactivate(bMDI);
1262
1263     if ( m_pFormView )
1264         GetImpl()->viewDeactivated( *m_pFormView, false );
1265 }
1266
1267
1268 void FmFormShell::ExecuteTextAttribute( SfxRequest& _rReq )
1269 {
1270     m_pImpl->ExecuteTextAttribute( _rReq );
1271 }
1272
1273
1274 void FmFormShell::GetTextAttributeState( SfxItemSet& _rSet )
1275 {
1276     m_pImpl->GetTextAttributeState( _rSet );
1277 }
1278
1279
1280 bool FmFormShell::IsActiveControl() const
1281 {
1282     return m_pImpl->IsActiveControl();
1283 }
1284
1285
1286 void FmFormShell::ForgetActiveControl()
1287 {
1288     m_pImpl->ForgetActiveControl();
1289 }
1290
1291
1292 void FmFormShell::SetControlActivationHandler( const Link<>& _rHdl )
1293 {
1294     m_pImpl->SetControlActivationHandler( _rHdl );
1295 }
1296
1297
1298 namespace
1299 {
1300     SdrUnoObj* lcl_findUnoObject( const SdrObjList& _rObjList, const Reference< XControlModel >& _rxModel )
1301     {
1302         SdrObjListIter aIter( _rObjList );
1303         while ( aIter.IsMore() )
1304         {
1305             SdrObject* pObject = aIter.Next();
1306             SdrUnoObj* pUnoObject = pObject ? PTR_CAST( SdrUnoObj, pObject ) : NULL;
1307             if ( !pUnoObject )
1308                 continue;
1309
1310             Reference< XControlModel > xControlModel = pUnoObject->GetUnoControlModel();
1311             if ( !xControlModel.is() )
1312                 continue;
1313
1314             if ( _rxModel == xControlModel )
1315                 return pUnoObject;
1316         }
1317         return NULL;
1318     }
1319 }
1320
1321
1322 void FmFormShell::ToggleControlFocus( const SdrUnoObj& i_rUnoObject, const SdrView& i_rView, OutputDevice& i_rDevice ) const
1323 {
1324     try
1325     {
1326         // check if the focus currently is in a control
1327         // Well, okay, do it the other way 'round: Check whether the current control of the active controller
1328         // actually has the focus. This should be equivalent.
1329         const bool bHasControlFocus = GetImpl()->HasControlFocus();
1330
1331         if ( bHasControlFocus )
1332         {
1333             vcl::Window* pWindow( dynamic_cast< vcl::Window* >( &i_rDevice ) );
1334             OSL_ENSURE( pWindow, "FmFormShell::ToggleControlFocus: I need a Window, really!" );
1335             if ( pWindow )
1336                 pWindow->GrabFocus();
1337         }
1338         else
1339         {
1340             Reference< XControl > xControl;
1341             GetFormControl( i_rUnoObject.GetUnoControlModel(), i_rView, i_rDevice, xControl );
1342             Reference< XWindow > xControlWindow( xControl, UNO_QUERY );
1343             if ( xControlWindow.is() )
1344                 xControlWindow->setFocus();
1345         }
1346     }
1347     catch( const Exception& )
1348     {
1349         DBG_UNHANDLED_EXCEPTION();
1350     }
1351 }
1352
1353
1354 namespace
1355 {
1356     class FocusableControlsFilter : public svx::ISdrObjectFilter
1357     {
1358     public:
1359         FocusableControlsFilter( const SdrView& i_rView, const OutputDevice& i_rDevice )
1360             :m_rView( i_rView )
1361             ,m_rDevice( i_rDevice )
1362         {
1363         }
1364
1365     public:
1366         virtual bool    includeObject( const SdrObject& i_rObject ) const SAL_OVERRIDE
1367         {
1368             const SdrUnoObj* pUnoObj = dynamic_cast< const SdrUnoObj* >( &i_rObject );
1369             if ( !pUnoObj )
1370                 return false;
1371
1372             Reference< XControl > xControl = pUnoObj->GetUnoControl( m_rView, m_rDevice );
1373             return FmXFormView::isFocusable( xControl );
1374         }
1375
1376     private:
1377         const SdrView&      m_rView;
1378         const OutputDevice& m_rDevice;
1379     };
1380 }
1381
1382
1383 ::std::unique_ptr< svx::ISdrObjectFilter > FmFormShell::CreateFocusableControlFilter( const SdrView& i_rView, const OutputDevice& i_rDevice )
1384 {
1385     ::std::unique_ptr< svx::ISdrObjectFilter > pFilter;
1386
1387     if ( !i_rView.IsDesignMode() )
1388         pFilter.reset( new FocusableControlsFilter( i_rView, i_rDevice ) );
1389
1390     return pFilter;
1391 }
1392
1393
1394 SdrUnoObj* FmFormShell::GetFormControl( const Reference< XControlModel >& _rxModel, const SdrView& _rView, const OutputDevice& _rDevice, Reference< XControl >& _out_rxControl ) const
1395 {
1396     if ( !_rxModel.is() )
1397         return NULL;
1398
1399     // we can only retrieve controls for SdrObjects which belong to page which is actually displayed in the given view
1400     SdrPageView* pPageView = _rView.GetSdrPageView();
1401     SdrPage* pPage = pPageView ? pPageView->GetPage() : NULL;
1402     OSL_ENSURE( pPage, "FmFormShell::GetFormControl: no page displayed in the given view!" );
1403     if ( !pPage )
1404         return NULL;
1405
1406     SdrUnoObj* pUnoObject = lcl_findUnoObject( *pPage, _rxModel );
1407     if ( pUnoObject )
1408     {
1409         _out_rxControl = pUnoObject->GetUnoControl( _rView, _rDevice );
1410         return pUnoObject;
1411     }
1412
1413 #if OSL_DEBUG_LEVEL > 0
1414     // perhaps we are fed with a control model which lives on a page other than the one displayed
1415     // in the given view. This is worth being reported as error, in non-product builds.
1416     FmFormModel* pModel = GetFormModel();
1417     if ( pModel )
1418     {
1419         sal_uInt16 pageCount = pModel->GetPageCount();
1420         for ( sal_uInt16 page = 0; page < pageCount; ++page )
1421         {
1422             pPage = pModel->GetPage( page );
1423             OSL_ENSURE( pPage, "FmFormShell::GetFormControl: NULL page encountered!" );
1424             if  ( !pPage )
1425                 continue;
1426
1427             pUnoObject = lcl_findUnoObject( *pPage, _rxModel );
1428             OSL_ENSURE( !pUnoObject, "FmFormShell::GetFormControl: the given control model belongs to a wrong page (displayed elsewhere)!" );
1429         }
1430     }
1431 #endif
1432
1433     return NULL;
1434 }
1435
1436
1437 Reference< runtime::XFormController > FmFormShell::GetFormController( const Reference< XForm >& _rxForm, const SdrView& _rView, const OutputDevice& _rDevice )
1438 {
1439     const FmFormView* pFormView = dynamic_cast< const FmFormView* >( &_rView );
1440     if ( !pFormView )
1441         return NULL;
1442
1443     return pFormView->GetFormController( _rxForm, _rDevice );
1444 }
1445
1446
1447 void FmFormShell::SetDesignMode( bool _bDesignMode )
1448 {
1449     if ( _bDesignMode == m_bDesignMode )
1450         return;
1451
1452     FmFormModel* pModel = GetFormModel();
1453     if (pModel)
1454         // fuer die Zeit des Uebergangs das Undo-Environment ausschalten, das sichert, dass man dort auch nicht-transiente
1455         // Properties mal eben aendern kann (sollte allerdings mit Vorsicht genossen und beim Rueckschalten des Modes
1456         // auch immer wieder rueckgaegig gemacht werden. Ein Beispiel ist das Setzen der maximalen Text-Laenge durch das
1457         // OEditModel an seinem Control.)
1458         pModel->GetUndoEnv().Lock();
1459
1460     // dann die eigentliche Umschaltung
1461     if ( m_bDesignMode || PrepareClose( true ) )
1462         impl_setDesignMode(!m_bDesignMode );
1463
1464     // und mein Undo-Environment wieder an
1465     if ( pModel )
1466         pModel->GetUndoEnv().UnLock();
1467 }
1468
1469 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */