dbaccess/source/ui/querydesign/limitboxcontroller.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
  10 #include "limitboxcontroller.hxx"
  11 #include "uiservices.hxx"
  12
  13 #include <com/sun/star/frame/XDispatchProvider.hpp>
  14 #include <com/sun/star/beans/PropertyValue.hpp>
  15
  16 #include <vcl/svapp.hxx>
  17 #include <vcl/window.hxx>
  18 #include <toolkit/helper/vclunohelper.hxx>
  19 #include <osl/mutex.hxx>
  20 #include <cppuhelper/queryinterface.hxx>
  21 #include <comphelper/processfactory.hxx>
  22
  23 #include "LimitBox.hxx"
  24 #include "dbu_reghelper.hxx"
  25 #include "moduledbu.hxx"
  26
  27
  28 using namespace ::com::sun::star;
  29
  30 namespace dbaui
  31 {
  32
  33 class LimitBoxImpl: public LimitBox
  34 {
  35     public:
  36         LimitBoxImpl( vcl::Window* pParent, LimitBoxController* pCtrl );
  37
  38         virtual bool Notify( NotifyEvent& rNEvt ) override;
  39
  40     private:
  41         LimitBoxController* m_pControl;
  42 };
  43
  44 LimitBoxImpl::LimitBoxImpl( vcl::Window* pParent, LimitBoxController* pCtrl )
  45     : LimitBox( pParent, WinBits( WB_DROPDOWN | WB_VSCROLL) )
  46     , m_pControl( pCtrl )
  47 {
  48 }
  49
  50 bool LimitBoxImpl::Notify( NotifyEvent& rNEvt )
  51 {
  52     bool bHandled = false;
  53     switch ( rNEvt.GetType() )
  54     {
  55         case MouseNotifyEvent::LOSEFOCUS:
  56         {
  57             bHandled = LimitBox::Notify( rNEvt );
  58             uno::Sequence< beans::PropertyValue > aArgs( 1 );
  59             aArgs[0].Name  = "DBLimit.Value";
  60             aArgs[0].Value = uno::makeAny( GetValue() );
  61             m_pControl->dispatchCommand( aArgs );
  62             break;
  63         }
  64         case MouseNotifyEvent::KEYINPUT:
  65         {
  66             const sal_uInt16 nCode = rNEvt.GetKeyEvent()->GetKeyCode().GetCode();
  67             switch ( nCode )
  68             {
  69                 case KEY_ESCAPE:
  70                     Undo();
  71                     SAL_FALLTHROUGH;
  72                 case KEY_RETURN:
  73                     GrabFocusToDocument();
  74                     bHandled = true;
  75                     break;
  76                 case KEY_TAB:
  77                     Select();
  78                     break;
  79             }
  80             break;
  81         }
  82         default:
  83             break;
  84     }
  85     return bHandled || LimitBox::Notify( rNEvt );
  86 }
  87
  88
  89 LimitBoxController::LimitBoxController(
  90     const uno::Reference< uno::XComponentContext >& rxContext ) :
  91     svt::ToolboxController( rxContext,
  92                             uno::Reference< frame::XFrame >(),
  93                             OUString( ".uno:DBLimit" ) ),
  94     m_pLimitBox( nullptr )
  95 {
  96 }
  97
  98 LimitBoxController::~LimitBoxController()
  99 {
 100 }
 101
 102 /// XInterface
 103 uno::Any SAL_CALL LimitBoxController::queryInterface( const uno::Type& aType )
 104 throw (uno::RuntimeException, std::exception)
 105 {
 106     uno::Any a = ToolboxController::queryInterface( aType );
 107     if ( a.hasValue() )
 108         return a;
 109
 110     return ::cppu::queryInterface( aType, static_cast< lang::XServiceInfo* >( this ));
 111 }
 112
 113 void SAL_CALL LimitBoxController::acquire() throw ()
 114 {
 115     ToolboxController::acquire();
 116 }
 117
 118 void SAL_CALL LimitBoxController::release() throw ()
 119 {
 120     ToolboxController::release();
 121 }
 122
 123
 124 /// XServiceInfo
 125 IMPLEMENT_SERVICE_INFO_IMPLNAME_STATIC(LimitBoxController, "org.libreoffice.comp.dbu.LimitBoxController")
 126 IMPLEMENT_SERVICE_INFO_SUPPORTS(LimitBoxController)
 127 IMPLEMENT_SERVICE_INFO_GETSUPPORTED1_STATIC(LimitBoxController, "com.sun.star.frame.ToolbarController")
 128
 129 uno::Reference< uno::XInterface >
 130     SAL_CALL LimitBoxController::Create(const uno::Reference< css::lang::XMultiServiceFactory >& _rxORB)
 131 {
 132     return static_cast< XServiceInfo* >(new LimitBoxController( comphelper::getComponentContext(_rxORB) ));
 133 }
 134
 135 /// XComponent
 136 void SAL_CALL LimitBoxController::dispose()
 137 throw (uno::RuntimeException, std::exception)
 138 {
 139     svt::ToolboxController::dispose();
 140
 141     SolarMutexGuard aSolarMutexGuard;
 142     m_pLimitBox.disposeAndClear();
 143 }
 144
 145 /// XStatusListener
 146 void SAL_CALL LimitBoxController::statusChanged(
 147     const frame::FeatureStateEvent& rEvent )
 148 throw ( uno::RuntimeException, std::exception )
 149 {
 150     if ( m_pLimitBox )
 151     {
 152         SolarMutexGuard aSolarMutexGuard;
 153         if ( rEvent.FeatureURL.Path == "DBLimit" )
 154         {
 155             if ( rEvent.IsEnabled )
 156             {
 157                 m_pLimitBox->Enable();
 158                 sal_Int64 nLimit = 0;
 159                 if ( (rEvent.State >>= nLimit) )
 160                 {
 161                     m_pLimitBox->SetValue( nLimit );
 162                 }
 163             }
 164             else
 165                 m_pLimitBox->Disable();
 166         }
 167     }
 168 }
 169
 170 /// XToolbarController
 171 void SAL_CALL LimitBoxController::execute( sal_Int16 /*KeyModifier*/ )
 172 throw (uno::RuntimeException, std::exception)
 173 {
 174 }
 175
 176 void SAL_CALL LimitBoxController::click()
 177 throw (uno::RuntimeException, std::exception)
 178 {
 179 }
 180
 181 void SAL_CALL LimitBoxController::doubleClick()
 182 throw (uno::RuntimeException, std::exception)
 183 {
 184 }
 185
 186 uno::Reference< awt::XWindow > SAL_CALL LimitBoxController::createPopupWindow()
 187 throw (uno::RuntimeException, std::exception)
 188 {
 189     return uno::Reference< awt::XWindow >();
 190 }
 191
 192 uno::Reference< awt::XWindow > SAL_CALL LimitBoxController::createItemWindow(
 193     const uno::Reference< awt::XWindow >& xParent )
 194     throw (uno::RuntimeException, std::exception)
 195 {
 196     uno::Reference< awt::XWindow > xItemWindow;
 197
 198     vcl::Window* pParent = VCLUnoHelper::GetWindow( xParent );
 199     if ( pParent )
 200     {
 201         SolarMutexGuard aSolarMutexGuard;
 202         m_pLimitBox = VclPtr<LimitBoxImpl>::Create(pParent, this);
 203         m_pLimitBox->SetSizePixel(m_pLimitBox->CalcBlockSize(6,1));
 204         xItemWindow = VCLUnoHelper::GetInterface( m_pLimitBox );
 205     }
 206
 207     return xItemWindow;
 208 }
 209
 210 void LimitBoxController::dispatchCommand(
 211     const uno::Sequence< beans::PropertyValue >& rArgs )
 212 {
 213     uno::Reference< frame::XDispatchProvider > xDispatchProvider( m_xFrame, uno::UNO_QUERY );
 214     if ( xDispatchProvider.is() )
 215     {
 216         util::URL                               aURL;
 217         uno::Reference< frame::XDispatch >      xDispatch;
 218         uno::Reference< util::XURLTransformer > xURLTransformer = getURLTransformer();
 219
 220         aURL.Complete = ".uno:DBLimit";
 221         xURLTransformer->parseStrict( aURL );
 222         xDispatch = xDispatchProvider->queryDispatch( aURL, OUString(), 0 );
 223         if ( xDispatch.is() )
 224             xDispatch->dispatch( aURL, rArgs );
 225     }
 226 }
 227
 228 } ///dbaui namespace
 229
 230 extern "C" void SAL_CALL createRegistryInfo_LimitBoxController()
 231 {
 232     static ::dbaui::OMultiInstanceAutoRegistration< ::dbaui::LimitBoxController > aAutoRegistration;
 233 }
 234
 235 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */