extensions/source/bibliography/framectr.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 <vcl/waitobj.hxx>
  21 #include <com/sun/star/util/URL.hpp>
  22 #include <vcl/msgbox.hxx>
  23 #include <vcl/stdtext.hxx>
  24 #include <comphelper/types.hxx>
  25 #include <comphelper/sequence.hxx>
  26 #include "framectr.hxx"
  27 #include "datman.hxx"
  28 #include "bibview.hxx"
  29 #include "bibresid.hxx"
  30 #include "bib.hrc"
  31 #include <toolkit/helper/vclunohelper.hxx>
  32 #include "bibconfig.hxx"
  33 #include <cppuhelper/implbase.hxx>
  34 #include <vcl/svapp.hxx>
  35 #include "bibliography.hrc"
  36 #include <comphelper/processfactory.hxx>
  37 #include <com/sun/star/form/XConfirmDeleteListener.hpp>
  38 #include <com/sun/star/form/runtime/XFormController.hpp>
  39 #include <com/sun/star/beans/PropertyState.hpp>
  40 #include <com/sun/star/beans/PropertyValue.hpp>
  41 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
  42 #include <com/sun/star/sdbcx/Privilege.hpp>
  43 #include <com/sun/star/sdbc/XResultSetUpdate.hpp>
  44 #include <com/sun/star/sdb/FilterDialog.hpp>
  45 #include <com/sun/star/sdb/RowChangeAction.hpp>
  46 #include <com/sun/star/frame/CommandGroup.hpp>
  47 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
  48 #include <cppuhelper/interfacecontainer.hxx>
  49 #include <cppuhelper/supportsservice.hxx>
  50 #include <sot/exchange.hxx>
  51 #include <sot/formats.hxx>
  52 #include <vcl/edit.hxx>
  53 #include <osl/mutex.hxx>
  54 #include <o3tl/make_unique.hxx>
  55
  56 #include <unordered_map>
  57
  58 using namespace osl;
  59 using namespace cppu;
  60 using namespace com::sun::star::sdbc;
  61 using namespace com::sun::star::frame;
  62 using namespace com::sun::star::uno;
  63 using namespace com::sun::star;
  64
  65
  66 struct DispatchInfo
  67 {
  68     const char*   pCommand;
  69     sal_Int16     nGroupId;
  70     bool      bActiveConnection;
  71 };
  72
  73 struct CacheDispatchInfo
  74 {
  75     sal_Int16     nGroupId;
  76     bool      bActiveConnection;
  77 };
  78
  79 // Attention: commands must be sorted by command groups. Implementation is dependent
  80 // on this!!
  81 static const DispatchInfo SupportedCommandsArray[] =
  82 {
  83     { ".uno:Undo"               ,   frame::CommandGroup::EDIT       , false },
  84     { ".uno:Cut"                ,   frame::CommandGroup::EDIT       , false },
  85     { ".uno:Copy"               ,   frame::CommandGroup::EDIT       , false },
  86     { ".uno:Paste"              ,   frame::CommandGroup::EDIT       , false },
  87     { ".uno:SelectAll"          ,   frame::CommandGroup::EDIT       , false },
  88     { ".uno:CloseDoc"           ,   frame::CommandGroup::DOCUMENT   , false },
  89     { ".uno:StatusBarVisible"   ,   frame::CommandGroup::VIEW       , false },
  90     { ".uno:AvailableToolbars"  ,   frame::CommandGroup::VIEW       , false },
  91     { ".uno:Bib/standardFilter" ,   frame::CommandGroup::DATA       , true  },
  92     { ".uno:Bib/DeleteRecord"   ,   frame::CommandGroup::DATA       , true  },
  93     { ".uno:Bib/InsertRecord"   ,   frame::CommandGroup::DATA       , true  },
  94     { ".uno:Bib/query"          ,   frame::CommandGroup::DATA       , true  },
  95     { ".uno:Bib/autoFilter"     ,   frame::CommandGroup::DATA       , true  },
  96     { ".uno:Bib/source"         ,   frame::CommandGroup::DATA       , true  },
  97     { ".uno:Bib/removeFilter"   ,   frame::CommandGroup::DATA       , true  },
  98     { ".uno:Bib/sdbsource"      ,   frame::CommandGroup::DATA       , true  },
  99     { ".uno:Bib/Mapping"        ,   frame::CommandGroup::DATA       , true  },
 100     { nullptr                         ,   0                               , false }
 101 };
 102
 103 typedef std::unordered_map< OUString, CacheDispatchInfo, OUStringHash > CmdToInfoCache;
 104
 105 const CmdToInfoCache& GetCommandToInfoCache()
 106 {
 107     static bool       bCacheInitialized = false;
 108     static CmdToInfoCache aCmdToInfoCache;
 109
 110     if ( !bCacheInitialized )
 111     {
 112         ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 113         if ( !bCacheInitialized )
 114         {
 115             sal_Int32 i( 0 );
 116             while ( SupportedCommandsArray[i].pCommand != nullptr )
 117             {
 118                 OUString aCommand( OUString::createFromAscii( SupportedCommandsArray[i].pCommand ));
 119
 120                 CacheDispatchInfo aDispatchInfo;
 121                 aDispatchInfo.nGroupId          = SupportedCommandsArray[i].nGroupId;
 122                 aDispatchInfo.bActiveConnection = SupportedCommandsArray[i].bActiveConnection;
 123                 aCmdToInfoCache.insert( CmdToInfoCache::value_type( aCommand, aDispatchInfo ));
 124                 ++i;
 125             }
 126             bCacheInitialized = true;
 127         }
 128     }
 129
 130     return aCmdToInfoCache;
 131 }
 132
 133
 134 class BibFrameCtrl_Impl : public cppu::WeakImplHelper < XFrameActionListener >
 135 {
 136 public:
 137     Mutex                               aMutex;
 138     OMultiTypeInterfaceContainerHelper  aLC;
 139
 140     BibFrameController_Impl*            pController;
 141
 142                                         BibFrameCtrl_Impl()
 143                                             : aLC( aMutex )
 144                                             , pController(nullptr)
 145                                         {}
 146
 147     virtual void                        SAL_CALL frameAction(const FrameActionEvent& aEvent) override;
 148     virtual void                        SAL_CALL disposing( const lang::EventObject& Source ) override;
 149 };
 150
 151 void BibFrameCtrl_Impl::frameAction(const FrameActionEvent& )
 152 {
 153 }
 154
 155 void BibFrameCtrl_Impl::disposing( const lang::EventObject& /*Source*/ )
 156 {
 157     ::SolarMutexGuard aGuard;
 158     if ( pController )
 159         pController->getFrame()->removeFrameActionListener( this );
 160 }
 161
 162 BibFrameController_Impl::BibFrameController_Impl( const uno::Reference< awt::XWindow > & xComponent,
 163                                                 BibDataManager* pDataManager)
 164     :xWindow( xComponent )
 165     ,m_xDatMan( pDataManager )
 166     ,pBibMod(nullptr)
 167 {
 168     bDisposing=false;
 169     bHierarchical=true;
 170     mxImpl = new BibFrameCtrl_Impl;
 171     mxImpl->pController = this;
 172 }
 173
 174 BibFrameController_Impl::~BibFrameController_Impl()
 175 {
 176     mxImpl->pController = nullptr;
 177     m_xDatMan.clear();
 178     if(pBibMod)
 179         CloseBibModul(pBibMod);
 180 }
 181
 182 OUString SAL_CALL BibFrameController_Impl::getImplementationName()
 183 {
 184     return OUString("com.sun.star.comp.extensions.Bibliography");
 185 }
 186
 187 sal_Bool SAL_CALL BibFrameController_Impl::supportsService( const OUString& sServiceName )
 188 {
 189     return cppu::supportsService( this, sServiceName );
 190 }
 191
 192 css::uno::Sequence< OUString > SAL_CALL BibFrameController_Impl::getSupportedServiceNames()
 193 {
 194     // return only top level services ...
 195     // base services are included there and should be asked by uno-rtti.
 196     css::uno::Sequence< OUString > lNames { "com.sun.star.frame.Bibliography" };
 197     return lNames;
 198 }
 199
 200 void BibFrameController_Impl::attachFrame( const uno::Reference< XFrame > & xArg )
 201 {
 202     xFrame = xArg;
 203     xFrame->addFrameActionListener( mxImpl.get() );
 204 }
 205
 206 sal_Bool BibFrameController_Impl::attachModel( const uno::Reference< XModel > & /*xModel*/ )
 207 {
 208     return false;
 209 }
 210
 211 sal_Bool BibFrameController_Impl::suspend( sal_Bool bSuspend )
 212 {
 213     if ( bSuspend )
 214         getFrame()->removeFrameActionListener( mxImpl.get() );
 215     else
 216         getFrame()->addFrameActionListener( mxImpl.get() );
 217     return true;
 218 }
 219
 220 uno::Any BibFrameController_Impl::getViewData()
 221 {
 222     return uno::Any();
 223 }
 224
 225 void BibFrameController_Impl::restoreViewData( const uno::Any& /*Value*/ )
 226 {
 227 }
 228
 229 uno::Reference< XFrame >  BibFrameController_Impl::getFrame()
 230 {
 231     return xFrame;
 232 }
 233
 234 uno::Reference< XModel >  BibFrameController_Impl::getModel()
 235 {
 236     return uno::Reference< XModel > ();
 237 }
 238
 239 void BibFrameController_Impl::dispose()
 240 {
 241     bDisposing = true;
 242     lang::EventObject aObject;
 243     aObject.Source = static_cast<XController*>(this);
 244     mxImpl->aLC.disposeAndClear(aObject);
 245     m_xDatMan.clear();
 246     aStatusListeners.clear();
 247  }
 248
 249 void BibFrameController_Impl::addEventListener( const uno::Reference< lang::XEventListener > & aListener )
 250 {
 251     mxImpl->aLC.addInterface( cppu::UnoType<lang::XEventListener>::get(), aListener );
 252 }
 253
 254 void BibFrameController_Impl::removeEventListener( const uno::Reference< lang::XEventListener > & aListener )
 255 {
 256     mxImpl->aLC.removeInterface( cppu::UnoType<lang::XEventListener>::get(), aListener );
 257 }
 258
 259 uno::Reference< frame::XDispatch >  BibFrameController_Impl::queryDispatch( const util::URL& aURL, const OUString& /*aTarget*/, sal_Int32 /*nSearchFlags*/ )
 260 {
 261     if ( !bDisposing )
 262     {
 263         const CmdToInfoCache& rCmdCache = GetCommandToInfoCache();
 264         CmdToInfoCache::const_iterator pIter = rCmdCache.find( aURL.Complete );
 265         if ( pIter != rCmdCache.end() )
 266         {
 267             if (( m_xDatMan->HasActiveConnection() ) ||
 268                 ( !pIter->second.bActiveConnection ))
 269                 return static_cast<frame::XDispatch*>(this);
 270         }
 271     }
 272
 273     return uno::Reference< frame::XDispatch > ();
 274 }
 275
 276 uno::Sequence<uno::Reference< XDispatch > > BibFrameController_Impl::queryDispatches( const uno::Sequence<DispatchDescriptor>& aDescripts )
 277 {
 278     uno::Sequence< uno::Reference< XDispatch > > aDispatches( aDescripts.getLength() );
 279     for ( sal_Int32 i=0; i<aDescripts.getLength(); ++i )
 280         aDispatches[i] = queryDispatch( aDescripts[i].FeatureURL, aDescripts[i].FrameName, aDescripts[i].SearchFlags );
 281     return aDispatches;
 282 }
 283
 284 uno::Sequence< ::sal_Int16 > SAL_CALL BibFrameController_Impl::getSupportedCommandGroups()
 285 {
 286     uno::Sequence< ::sal_Int16 > aDispatchInfo( 4 );
 287
 288     aDispatchInfo[0] = frame::CommandGroup::EDIT;
 289     aDispatchInfo[1] = frame::CommandGroup::DOCUMENT;
 290     aDispatchInfo[2] = frame::CommandGroup::DATA;
 291     aDispatchInfo[3] = frame::CommandGroup::VIEW;
 292
 293     return aDispatchInfo;
 294 }
 295
 296 uno::Sequence< frame::DispatchInformation > SAL_CALL BibFrameController_Impl::getConfigurableDispatchInformation( ::sal_Int16 nCommandGroup )
 297 {
 298     const CmdToInfoCache& rCmdCache = GetCommandToInfoCache();
 299
 300     frame::DispatchInformation                  aDispatchInfo;
 301     std::list< frame::DispatchInformation >     aDispatchInfoList;
 302
 303     if (( nCommandGroup == frame::CommandGroup::EDIT ) ||
 304         ( nCommandGroup == frame::CommandGroup::DOCUMENT ) ||
 305         ( nCommandGroup == frame::CommandGroup::DATA ) ||
 306         ( nCommandGroup == frame::CommandGroup::VIEW ))
 307     {
 308         bool bGroupFound = false;
 309         CmdToInfoCache::const_iterator pIter = rCmdCache.begin();
 310         while ( pIter != rCmdCache.end() )
 311         {
 312             if ( pIter->second.nGroupId == nCommandGroup )
 313             {
 314                 bGroupFound = true;
 315                 aDispatchInfo.Command = pIter->first;
 316                 aDispatchInfo.GroupId = pIter->second.nGroupId;
 317                 aDispatchInfoList.push_back( aDispatchInfo );
 318             }
 319             else if ( bGroupFound )
 320                 break;
 321
 322             ++pIter;
 323         }
 324     }
 325
 326     return comphelper::containerToSequence( aDispatchInfoList );
 327 }
 328
 329 bool canInsertRecords(const Reference< beans::XPropertySet>& _rxCursorSet)
 330 {
 331     sal_Int32 nPriv = 0;
 332     _rxCursorSet->getPropertyValue("Privileges") >>= nPriv;
 333     return ((_rxCursorSet.is() && (nPriv & sdbcx::Privilege::INSERT) != 0));
 334 }
 335
 336 bool BibFrameController_Impl::SaveModified(const Reference< form::runtime::XFormController>& xController)
 337 {
 338     if (!xController.is())
 339         return false;
 340
 341     Reference< XResultSetUpdate> _xCursor(xController->getModel(), UNO_QUERY);
 342
 343     if (!_xCursor.is())
 344         return false;
 345
 346     Reference< beans::XPropertySet> _xSet(_xCursor, UNO_QUERY);
 347     if (!_xSet.is())
 348         return false;
 349
 350     // need to save?
 351     bool  bIsNew        = ::comphelper::getBOOL(_xSet->getPropertyValue("IsNew"));
 352     bool  bIsModified   = ::comphelper::getBOOL(_xSet->getPropertyValue("IsModified"));
 353     bool bResult = !bIsModified;
 354     if (bIsModified)
 355     {
 356         try
 357         {
 358             if (bIsNew)
 359                 _xCursor->insertRow();
 360             else
 361                 _xCursor->updateRow();
 362             bResult = true;
 363         }
 364         catch(const Exception&)
 365         {
 366             OSL_FAIL("SaveModified: Exception occurred!");
 367         }
 368     }
 369     return bResult;
 370 }
 371
 372 static vcl::Window* lcl_GetFocusChild( vcl::Window* pParent )
 373 {
 374     sal_uInt16 nChildren = pParent->GetChildCount();
 375     for( sal_uInt16 nChild = 0; nChild < nChildren; ++nChild)
 376     {
 377         vcl::Window* pChild = pParent->GetChild( nChild );
 378         if(pChild->HasFocus())
 379             return pChild;
 380         vcl::Window* pSubChild = lcl_GetFocusChild( pChild );
 381         if(pSubChild)
 382             return pSubChild;
 383     }
 384     return nullptr;
 385 }
 386
 387 //class XDispatch
 388 void BibFrameController_Impl::dispatch(const util::URL& _rURL, const uno::Sequence< beans::PropertyValue >& aArgs)
 389 {
 390     if ( !bDisposing )
 391     {
 392         ::SolarMutexGuard aGuard;
 393         VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( xWindow );
 394         WaitObject aWaitObject( pParent );
 395
 396         OUString aCommand( _rURL.Path);
 397         if(aCommand == "Bib/Mapping")
 398         {
 399             m_xDatMan->CreateMappingDialog(pParent);
 400         }
 401         else if(aCommand == "Bib/source")
 402         {
 403             ChangeDataSource(aArgs);
 404         }
 405         else if(aCommand == "Bib/sdbsource")
 406         {
 407             OUString aURL = m_xDatMan->CreateDBChangeDialog(pParent);
 408             if(!aURL.isEmpty())
 409             {
 410                 try
 411                 {
 412                     uno::Sequence< beans::PropertyValue > aNewDataSource(2);
 413                     beans::PropertyValue* pProps = aNewDataSource.getArray();
 414                     pProps[0].Value <<= OUString();
 415                     pProps[1].Value <<= aURL;
 416                     ChangeDataSource(aNewDataSource);
 417                 }
 418                 catch(const Exception&)
 419                 {
 420                     OSL_FAIL("Exception catched while changing the data source");
 421                 }
 422             }
 423         }
 424         else if(aCommand == "Bib/autoFilter")
 425         {
 426             sal_uInt16 nCount = aStatusListeners.size();
 427             for ( sal_uInt16 n=0; n<nCount; n++ )
 428             {
 429                 BibStatusDispatch *pObj = aStatusListeners[n].get();
 430                 if ( pObj->aURL.Path == "Bib/removeFilter" )
 431                 {
 432                     FeatureStateEvent  aEvent;
 433                     aEvent.FeatureURL = pObj->aURL;
 434                     aEvent.IsEnabled  = true;
 435                     aEvent.Requery    = false;
 436                     aEvent.Source     = static_cast<XDispatch *>(this);
 437                     pObj->xListener->statusChanged( aEvent );
 438                     //break; because there are more than one
 439                 }
 440             }
 441
 442             const beans::PropertyValue* pPropertyValue = aArgs.getConstArray();
 443             uno::Any aValue=pPropertyValue[0].Value;
 444             OUString aQuery;
 445             aValue >>= aQuery;
 446
 447             aValue=pPropertyValue[1].Value;
 448             OUString aQueryField;
 449             aValue >>= aQueryField;
 450             BibConfig* pConfig = BibModul::GetConfig();
 451             pConfig->setQueryField(aQueryField);
 452             m_xDatMan->startQueryWith(aQuery);
 453         }
 454         else if(aCommand == "Bib/standardFilter")
 455         {
 456             try
 457             {
 458                 uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 459
 460                 // create the dialog object
 461                 uno::Reference< ui::dialogs::XExecutableDialog > xDialog = sdb::FilterDialog::createWithQuery(xContext, m_xDatMan->getParser(),
 462                            Reference<sdbc::XRowSet>(m_xDatMan->getForm(), uno::UNO_QUERY_THROW), xWindow);
 463                 // execute it
 464                 if ( xDialog->execute( ) )
 465                 {
 466                     // the dialog has been executed successfully, and the filter on the query composer
 467                     // has been changed
 468                     OUString sNewFilter = m_xDatMan->getParser()->getFilter();
 469                     m_xDatMan->setFilter( sNewFilter );
 470                 }
 471             }
 472             catch( const uno::Exception& )
 473             {
 474                 OSL_FAIL( "BibFrameController_Impl::dispatch: caught an exception!" );
 475             }
 476
 477             sal_uInt16 nCount = aStatusListeners.size();
 478             for ( sal_uInt16 n=0; n<nCount; n++ )
 479             {
 480                 BibStatusDispatch *pObj = aStatusListeners[n].get();
 481                 if ( pObj->aURL.Path == "Bib/removeFilter" && m_xDatMan->getParser().is())
 482                 {
 483                     FeatureStateEvent  aEvent;
 484                     aEvent.FeatureURL = pObj->aURL;
 485                     aEvent.IsEnabled  = !m_xDatMan->getParser()->getFilter().isEmpty();
 486                     aEvent.Requery    = false;
 487                     aEvent.Source     = static_cast<XDispatch *>(this);
 488                     pObj->xListener->statusChanged( aEvent );
 489                 }
 490             }
 491         }
 492         else if(aCommand == "Bib/removeFilter")
 493         {
 494             RemoveFilter();
 495         }
 496         else if( _rURL.Complete == "slot:5503" || aCommand == "CloseDoc" )
 497         {
 498             Application::PostUserEvent( LINK( this, BibFrameController_Impl,
 499                                         DisposeHdl ) );
 500
 501         }
 502         else if(aCommand == "Bib/InsertRecord")
 503         {
 504             Reference<form::runtime::XFormController > xFormCtrl = m_xDatMan->GetFormController();
 505             if(SaveModified(xFormCtrl))
 506             {
 507                 try
 508                 {
 509                     Reference< sdbc::XResultSet >  xCursor( m_xDatMan->getForm(), UNO_QUERY );
 510                     xCursor->last();
 511
 512                     Reference< XResultSetUpdate >  xUpdateCursor( m_xDatMan->getForm(), UNO_QUERY );
 513                     xUpdateCursor->moveToInsertRow();
 514                 }
 515                 catch(const Exception&)
 516                 {
 517                     OSL_FAIL("Exception in last() or moveToInsertRow()");
 518                 }
 519             }
 520         }
 521         else if(aCommand == "Bib/DeleteRecord")
 522         {
 523             Reference< css::sdbc::XResultSet >  xCursor(m_xDatMan->getForm(), UNO_QUERY);
 524             Reference< XResultSetUpdate >       xUpdateCursor(xCursor, UNO_QUERY);
 525             Reference< beans::XPropertySet >    xSet(m_xDatMan->getForm(), UNO_QUERY);
 526             bool  bIsNew  = ::comphelper::getBOOL(xSet->getPropertyValue("IsNew"));
 527             if(!bIsNew)
 528             {
 529                 sal_uInt32 nCount = 0;
 530                 xSet->getPropertyValue("RowCount") >>= nCount;
 531                 // determine next position
 532                 bool bSuccess = false;
 533                 bool bLeft = false;
 534                 bool bRight = false;
 535                 try
 536                 {
 537                     bLeft = xCursor->isLast() && nCount > 1;
 538                     bRight= !xCursor->isLast();
 539                     // ask for confirmation
 540                     Reference< frame::XController > xCtrl = mxImpl->pController;
 541                     Reference< form::XConfirmDeleteListener >  xConfirm(m_xDatMan->GetFormController(),UNO_QUERY);
 542                     if (xConfirm.is())
 543                     {
 544                         sdb::RowChangeEvent aEvent;
 545                         aEvent.Source.set(xCursor, UNO_QUERY);
 546                         aEvent.Action = sdb::RowChangeAction::DELETE;
 547                         aEvent.Rows = 1;
 548                         bSuccess = xConfirm->confirmDelete(aEvent);
 549                     }
 550
 551                     // delete it
 552                     if (bSuccess)
 553                         xUpdateCursor->deleteRow();
 554                 }
 555                 catch(const Exception&)
 556                 {
 557                     bSuccess = false;
 558                 }
 559                 if (bSuccess)
 560                 {
 561                     if (bLeft || bRight)
 562                         xCursor->relative(bRight ? 1 : -1);
 563                     else
 564                     {
 565                         bool bCanInsert = canInsertRecords(xSet);
 566                         // can another entry be inserted?
 567                         try
 568                         {
 569                             if (bCanInsert)
 570                                 xUpdateCursor->moveToInsertRow();
 571                             else
 572                                 // move data entry to reset state
 573                                 xCursor->first();
 574                         }
 575                         catch(const Exception&)
 576                         {
 577                             OSL_FAIL("DeleteRecord: exception caught!");
 578                         }
 579                     }
 580                 }
 581             }
 582         }
 583         else if(aCommand == "Cut")
 584         {
 585             vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 586             if(pChild)
 587             {
 588                 KeyEvent aEvent( 0, KeyFuncType::CUT );
 589                 pChild->KeyInput( aEvent );
 590             }
 591         }
 592         else if(aCommand == "Copy")
 593         {
 594             vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 595             if(pChild)
 596             {
 597                 KeyEvent aEvent( 0, KeyFuncType::COPY );
 598                 pChild->KeyInput( aEvent );
 599             }
 600         }
 601         else if(aCommand == "Paste")
 602         {
 603             vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 604             if(pChild)
 605             {
 606                 KeyEvent aEvent( 0, KeyFuncType::PASTE );
 607                 pChild->KeyInput( aEvent );
 608             }
 609         }
 610     }
 611 }
 612 IMPL_LINK_NOARG( BibFrameController_Impl, DisposeHdl, void*, void )
 613 {
 614     xFrame->dispose();
 615 };
 616
 617 void BibFrameController_Impl::addStatusListener(
 618     const uno::Reference< frame::XStatusListener > & aListener,
 619     const util::URL& aURL)
 620 {
 621     BibConfig* pConfig = BibModul::GetConfig();
 622     // create a new Reference and insert into listener array
 623     aStatusListeners.push_back( o3tl::make_unique<BibStatusDispatch>( aURL, aListener ) );
 624
 625     // send first status synchronously
 626     FeatureStateEvent aEvent;
 627     aEvent.FeatureURL = aURL;
 628     aEvent.Requery    = false;
 629     aEvent.Source     = static_cast<XDispatch *>(this);
 630     if ( aURL.Path == "StatusBarVisible" )
 631     {
 632         aEvent.IsEnabled  = false;
 633         aEvent.State <<= false;
 634     }
 635     else if ( aURL.Path == "Bib/hierarchical" )
 636     {
 637         aEvent.IsEnabled  = true;
 638         const char*  pHier = bHierarchical? "" : "*" ;
 639         aEvent.State <<= OUString::createFromAscii(pHier);
 640     }
 641     else if(aURL.Path == "Bib/MenuFilter")
 642     {
 643         aEvent.IsEnabled  = true;
 644         aEvent.FeatureDescriptor=m_xDatMan->getQueryField();
 645
 646         aEvent.State <<= m_xDatMan->getQueryFields();
 647
 648     }
 649     else if ( aURL.Path == "Bib/source")
 650     {
 651         aEvent.IsEnabled  = true;
 652         aEvent.FeatureDescriptor=m_xDatMan->getActiveDataTable();
 653
 654         aEvent.State <<= m_xDatMan->getDataSources();
 655     }
 656     else if( aURL.Path == "Bib/sdbsource" ||
 657              aURL.Path == "Bib/Mapping" ||
 658              aURL.Path == "Bib/autoFilter" ||
 659              aURL.Path == "Bib/standardFilter" )
 660     {
 661         aEvent.IsEnabled  = true;
 662     }
 663     else if(aURL.Path == "Bib/query")
 664     {
 665         aEvent.IsEnabled  = true;
 666         aEvent.State <<= pConfig->getQueryText();
 667     }
 668     else if (aURL.Path == "Bib/removeFilter" )
 669     {
 670         OUString aFilterStr=m_xDatMan->getFilter();
 671         aEvent.IsEnabled  = !aFilterStr.isEmpty();
 672     }
 673     else if(aURL.Path == "Cut")
 674     {
 675         vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 676         Edit* pEdit = dynamic_cast<Edit*>( pChild );
 677         if( pEdit )
 678             aEvent.IsEnabled  = !pEdit->IsReadOnly() && pEdit->GetSelection().Len();
 679     }
 680     if(aURL.Path == "Copy")
 681     {
 682         vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 683         Edit* pEdit = dynamic_cast<Edit*>( pChild );
 684         if( pEdit )
 685             aEvent.IsEnabled  = pEdit->GetSelection().Len() > 0;
 686     }
 687     else if(aURL.Path == "Paste" )
 688     {
 689         aEvent.IsEnabled  = false;
 690         vcl::Window* pChild = lcl_GetFocusChild( VCLUnoHelper::GetWindow( xWindow ) );
 691         if(pChild)
 692         {
 693             uno::Reference< datatransfer::clipboard::XClipboard > xClip = pChild->GetClipboard();
 694             if(xClip.is())
 695             {
 696                 uno::Reference< datatransfer::XTransferable > xDataObj;
 697
 698                 try
 699                     {
 700                         SolarMutexReleaser aReleaser;
 701                         xDataObj = xClip->getContents();
 702                     }
 703                 catch( const uno::Exception& )
 704                     {
 705                     }
 706
 707                 if ( xDataObj.is() )
 708                 {
 709                     datatransfer::DataFlavor aFlavor;
 710                     SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor );
 711                     try
 712                     {
 713                         uno::Any aData = xDataObj->getTransferData( aFlavor );
 714                         OUString aText;
 715                         aData >>= aText;
 716                         aEvent.IsEnabled  = !aText.isEmpty();
 717                     }
 718                     catch( const uno::Exception& )
 719                     {
 720                     }
 721                 }
 722             }
 723         }
 724     }
 725     else if(aURL.Path == "Bib/DeleteRecord")
 726     {
 727         Reference< beans::XPropertySet >    xSet(m_xDatMan->getForm(), UNO_QUERY);
 728         bool  bIsNew  = ::comphelper::getBOOL(xSet->getPropertyValue("IsNew"));
 729         if(!bIsNew)
 730         {
 731             sal_uInt32 nCount = 0;
 732             xSet->getPropertyValue("RowCount") >>= nCount;
 733             aEvent.IsEnabled  = nCount > 0;
 734         }
 735     }
 736     else if (aURL.Path == "Bib/InsertRecord")
 737     {
 738         Reference< beans::XPropertySet >  xSet(m_xDatMan->getForm(), UNO_QUERY);
 739         aEvent.IsEnabled = canInsertRecords(xSet);
 740     }
 741     aListener->statusChanged( aEvent );
 742 }
 743
 744 void BibFrameController_Impl::removeStatusListener(
 745     const uno::Reference< frame::XStatusListener > & aObject, const util::URL& aURL)
 746 {
 747     // search listener array for given listener
 748     // for checking equality always "cast" to XInterface
 749     if ( !bDisposing )
 750     {
 751         sal_uInt16 nCount = aStatusListeners.size();
 752         for ( sal_uInt16 n=0; n<nCount; n++ )
 753         {
 754             BibStatusDispatch *pObj = aStatusListeners[n].get();
 755             bool bFlag=pObj->xListener.is();
 756             if (!bFlag || (pObj->xListener == aObject &&
 757                 ( aURL.Complete.isEmpty() || pObj->aURL.Path == aURL.Path  )))
 758             {
 759                 aStatusListeners.erase( aStatusListeners.begin() + n );
 760                 break;
 761             }
 762         }
 763     }
 764 }
 765
 766 void BibFrameController_Impl::RemoveFilter()
 767 {
 768     OUString aQuery;
 769     m_xDatMan->startQueryWith(aQuery);
 770
 771     sal_uInt16 nCount = aStatusListeners.size();
 772
 773     bool bRemoveFilter=false;
 774     bool bQueryText=false;
 775
 776     for ( sal_uInt16 n=0; n<nCount; n++ )
 777     {
 778         BibStatusDispatch *pObj = aStatusListeners[n].get();
 779         if ( pObj->aURL.Path == "Bib/removeFilter" )
 780         {
 781             FeatureStateEvent  aEvent;
 782             aEvent.FeatureURL = pObj->aURL;
 783             aEvent.IsEnabled  = false;
 784             aEvent.Requery    = false;
 785             aEvent.Source     = static_cast<XDispatch *>(this);
 786             pObj->xListener->statusChanged( aEvent );
 787             bRemoveFilter=true;
 788         }
 789         else if(pObj->aURL.Path == "Bib/query")
 790         {
 791             FeatureStateEvent  aEvent;
 792             aEvent.FeatureURL = pObj->aURL;
 793             aEvent.IsEnabled  = true;
 794             aEvent.Requery    = false;
 795             aEvent.Source     = static_cast<XDispatch *>(this);
 796             aEvent.State <<= aQuery;
 797             pObj->xListener->statusChanged( aEvent );
 798             bQueryText=true;
 799         }
 800
 801         if(bRemoveFilter && bQueryText)
 802             break;
 803
 804     }
 805 }
 806
 807 void BibFrameController_Impl::ChangeDataSource(const uno::Sequence< beans::PropertyValue >& aArgs)
 808 {
 809     const beans::PropertyValue* pPropertyValue = aArgs.getConstArray();
 810     uno::Any aValue=pPropertyValue[0].Value;
 811     OUString aDBTableName;
 812     aValue >>= aDBTableName;
 813
 814
 815     if(aArgs.getLength() > 1)
 816     {
 817         uno::Any aDB = pPropertyValue[1].Value;
 818         OUString aURL;
 819         aDB >>= aURL;
 820         m_xDatMan->setActiveDataSource(aURL);
 821         aDBTableName = m_xDatMan->getActiveDataTable();
 822     }
 823     else
 824     {
 825         Reference<css::form::XLoadable> xLoadable(m_xDatMan.get());
 826         xLoadable->unload();
 827         m_xDatMan->setActiveDataTable(aDBTableName);
 828         m_xDatMan->updateGridModel();
 829         xLoadable->load();
 830     }
 831
 832
 833     sal_uInt16 nCount = aStatusListeners.size();
 834
 835     bool bMenuFilter=false;
 836     bool bQueryText=false;
 837     for ( sal_uInt16 n=0; n<nCount; n++ )
 838     {
 839         BibStatusDispatch *pObj = aStatusListeners[n].get();
 840         if (pObj->aURL.Path == "Bib/MenuFilter")
 841         {
 842             FeatureStateEvent  aEvent;
 843             aEvent.FeatureURL = pObj->aURL;
 844             aEvent.IsEnabled  = true;
 845             aEvent.Requery    = false;
 846             aEvent.Source     = static_cast<XDispatch *>(this);
 847             aEvent.FeatureDescriptor=m_xDatMan->getQueryField();
 848
 849             uno::Sequence<OUString> aStringSeq=m_xDatMan->getQueryFields();
 850             aEvent.State <<= aStringSeq;
 851
 852             pObj->xListener->statusChanged( aEvent );
 853             bMenuFilter=true;
 854         }
 855         else if (pObj->aURL.Path == "Bib/query")
 856         {
 857             FeatureStateEvent  aEvent;
 858             aEvent.FeatureURL = pObj->aURL;
 859             aEvent.IsEnabled  = true;
 860             aEvent.Requery    = false;
 861             aEvent.Source     = static_cast<XDispatch *>(this);
 862             BibConfig* pConfig = BibModul::GetConfig();
 863             aEvent.State <<= pConfig->getQueryText();
 864             pObj->xListener->statusChanged( aEvent );
 865             bQueryText=true;
 866         }
 867
 868         if (bMenuFilter && bQueryText)
 869             break;
 870
 871     }
 872 }
 873
 874 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */