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
  12 #include <com/sun/star/frame/XDispatchProvider.hpp>
  13 #include <com/sun/star/frame/XFrame.hpp>
  14 #include <com/sun/star/beans/PropertyValue.hpp>
  15 #include <com/sun/star/util/XURLTransformer.hpp>
  16
  17 #include <comphelper/propertyvalue.hxx>
  18 #include <vcl/InterimItemWindow.hxx>
  19 #include <vcl/event.hxx>
  20 #include <vcl/svapp.hxx>
  21 #include <vcl/window.hxx>
  22 #include <toolkit/helper/vclunohelper.hxx>
  23 #include <cppuhelper/queryinterface.hxx>
  24
  25 #include <core_resource.hxx>
  26 #include <strings.hrc>
  27
  28 using namespace ::com::sun::star;
  29
  30 namespace
  31 {
  32
  33 /// Default values
  34 sal_Int64 const aDefLimitAry[] =
  35 {
  36     5,
  37     10,
  38     20,
  39     50
  40 };
  41
  42 }
  43
  44 namespace dbaui
  45 {
  46
  47 /**
  48  * Input box to add limit to an SQL query (maximum number of result's rows)
  49  * This box is reachable on the Query Design Toolbar
  50  */
  51 class LimitBox final : public InterimItemWindow
  52 {
  53 public:
  54     LimitBox(vcl::Window* pParent, LimitBoxController* pCtrl)
  55         : InterimItemWindow(pParent, u"dbaccess/ui/limitbox.ui"_ustr, u"LimitBox"_ustr)
  56         , m_pControl( pCtrl )
  57         , m_xWidget(m_xBuilder->weld_combo_box(u"limit"_ustr))
  58     {
  59         InitControlBase(m_xWidget.get());
  60
  61         LoadDefaultLimits();
  62
  63         m_xWidget->connect_key_press(LINK(this, LimitBox, KeyInputHdl));
  64         m_xWidget->connect_entry_activate(LINK(this, LimitBox, ActivateHdl));
  65         m_xWidget->connect_changed(LINK(this, LimitBox, ChangeHdl));
  66         m_xWidget->connect_focus_out(LINK(this, LimitBox, FocusOutHdl));
  67         m_xWidget->set_entry_width_chars(6);
  68         SetSizePixel(m_xContainer->get_preferred_size());
  69     }
  70
  71     virtual void dispose() override
  72     {
  73         m_xWidget.reset();
  74         InterimItemWindow::dispose();
  75     }
  76
  77     virtual ~LimitBox() override
  78     {
  79         disposeOnce();
  80     }
  81
  82     void set_sensitive(bool bSensitive)
  83     {
  84         m_xWidget->set_sensitive(bSensitive);
  85     }
  86
  87     void set_value(int nLimit)
  88     {
  89         if (nLimit < 0)
  90             m_xWidget->set_active(0);
  91         else
  92             m_xWidget->set_entry_text(OUString::number(nLimit));
  93         m_xWidget->save_value();
  94     }
  95
  96 private:
  97     LimitBoxController* m_pControl;
  98     std::unique_ptr<weld::ComboBox> m_xWidget;
  99
 100     DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
 101     DECL_LINK(ActivateHdl, weld::ComboBox&, bool);
 102     DECL_LINK(ChangeHdl, weld::ComboBox&, void);
 103     DECL_LINK(FocusOutHdl, weld::Widget&, void);
 104
 105     void Apply()
 106     {
 107         if (!m_xWidget->get_value_changed_from_saved())
 108             return;
 109         sal_Int64 nLimit;
 110         OUString sActiveText = m_xWidget->get_active_text();
 111         if (sActiveText == DBA_RES(STR_QUERY_LIMIT_ALL))
 112             nLimit = -1;
 113         else
 114         {
 115             nLimit = m_xWidget->get_active_text().toInt64();
 116             if (nLimit < 0)
 117                 nLimit = -1;
 118         }
 119         set_value(nLimit);
 120         m_pControl->dispatchCommand({ comphelper::makePropertyValue(u"DBLimit.Value"_ustr, nLimit) });
 121     }
 122
 123     ///Initialize entries
 124     void LoadDefaultLimits()
 125     {
 126         m_xWidget->freeze();
 127         m_xWidget->append_text(DBA_RES(STR_QUERY_LIMIT_ALL));
 128         for (auto nIndex : aDefLimitAry)
 129         {
 130             m_xWidget->append_text(OUString::number(nIndex));
 131         }
 132         m_xWidget->thaw();
 133     }
 134 };
 135
 136 IMPL_LINK(LimitBox, KeyInputHdl, const KeyEvent&, rKEvt, bool)
 137 {
 138     bool bHandled = false;
 139     const sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
 140     switch (nCode)
 141     {
 142         case KEY_ESCAPE:
 143             m_xWidget->set_entry_text(m_xWidget->get_saved_value());
 144             bHandled = true;
 145             break;
 146         case KEY_RETURN:
 147         {
 148             bHandled = ActivateHdl(*m_xWidget);
 149             break;
 150         }
 151     }
 152     return bHandled || ChildKeyInput(rKEvt);
 153 }
 154
 155 IMPL_LINK_NOARG(LimitBox, FocusOutHdl, weld::Widget&, void)
 156 {
 157     if (!m_xWidget || m_xWidget->has_focus()) // comboboxes can be comprised of multiple widgets, ensure all have lost focus
 158         return;
 159     Apply();
 160 }
 161
 162 IMPL_LINK(LimitBox, ChangeHdl, weld::ComboBox&, rComboBox, void)
 163 {
 164     if (rComboBox.changed_by_direct_pick())
 165         ActivateHdl(rComboBox);
 166 }
 167
 168 IMPL_LINK_NOARG(LimitBox, ActivateHdl, weld::ComboBox&, bool)
 169 {
 170     GrabFocusToDocument();
 171     Apply();
 172     return true;
 173 }
 174
 175 LimitBoxController::LimitBoxController(
 176     const uno::Reference< uno::XComponentContext >& rxContext ) :
 177     LimitBoxController_Base( rxContext,
 178                             uno::Reference< frame::XFrame >(),
 179                             ".uno:DBLimit" ),
 180     m_xLimitBox( nullptr )
 181 {
 182 }
 183
 184 LimitBoxController::~LimitBoxController()
 185 {
 186 }
 187
 188 /// XServiceInfo
 189 OUString SAL_CALL LimitBoxController::getImplementationName()
 190 {
 191     return u"org.libreoffice.comp.dbu.LimitBoxController"_ustr;
 192 }
 193
 194 sal_Bool SAL_CALL LimitBoxController::supportsService(const OUString& _rServiceName)
 195     {
 196         const css::uno::Sequence< OUString > aSupported(getSupportedServiceNames());
 197         for (const OUString& s : aSupported)
 198             if (s == _rServiceName)
 199                 return true;
 200
 201         return false;
 202     }
 203
 204 css::uno::Sequence< OUString > SAL_CALL LimitBoxController::getSupportedServiceNames()
 205 {
 206     return { u"com.sun.star.frame.ToolbarController"_ustr };
 207 }
 208
 209 /// XComponent
 210 void SAL_CALL LimitBoxController::dispose()
 211 {
 212     svt::ToolboxController::dispose();
 213
 214     SolarMutexGuard aSolarMutexGuard;
 215     m_xLimitBox.disposeAndClear();
 216 }
 217
 218 /// XStatusListener
 219 void SAL_CALL LimitBoxController::statusChanged(
 220     const frame::FeatureStateEvent& rEvent )
 221 {
 222     if ( !m_xLimitBox )
 223         return;
 224
 225     SolarMutexGuard aSolarMutexGuard;
 226     if ( rEvent.FeatureURL.Path == "DBLimit" )
 227     {
 228         if ( rEvent.IsEnabled )
 229         {
 230             m_xLimitBox->set_sensitive(true);
 231             sal_Int64 nLimit = 0;
 232             if (rEvent.State >>= nLimit)
 233                 m_xLimitBox->set_value(nLimit);
 234         }
 235         else
 236             m_xLimitBox->set_sensitive(false);
 237     }
 238 }
 239
 240 /// XToolbarController
 241 void SAL_CALL LimitBoxController::execute( sal_Int16 /*KeyModifier*/ )
 242 {
 243 }
 244
 245 void SAL_CALL LimitBoxController::click()
 246 {
 247 }
 248
 249 void SAL_CALL LimitBoxController::doubleClick()
 250 {
 251 }
 252
 253 uno::Reference< awt::XWindow > SAL_CALL LimitBoxController::createPopupWindow()
 254 {
 255     return uno::Reference< awt::XWindow >();
 256 }
 257
 258 uno::Reference< awt::XWindow > SAL_CALL LimitBoxController::createItemWindow(
 259     const uno::Reference< awt::XWindow >& xParent )
 260 {
 261     uno::Reference< awt::XWindow > xItemWindow;
 262
 263     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow( xParent );
 264     if ( pParent )
 265     {
 266         SolarMutexGuard aSolarMutexGuard;
 267         m_xLimitBox = VclPtr<LimitBox>::Create(pParent, this);
 268         xItemWindow = VCLUnoHelper::GetInterface(m_xLimitBox);
 269     }
 270
 271     return xItemWindow;
 272 }
 273
 274 void LimitBoxController::dispatchCommand(
 275     const uno::Sequence< beans::PropertyValue >& rArgs )
 276 {
 277     uno::Reference< frame::XDispatchProvider > xDispatchProvider( m_xFrame, uno::UNO_QUERY );
 278     if ( xDispatchProvider.is() )
 279     {
 280         util::URL                               aURL;
 281         uno::Reference< frame::XDispatch >      xDispatch;
 282         uno::Reference< util::XURLTransformer > xURLTransformer = getURLTransformer();
 283
 284         aURL.Complete = ".uno:DBLimit";
 285         xURLTransformer->parseStrict( aURL );
 286         xDispatch = xDispatchProvider->queryDispatch( aURL, OUString(), 0 );
 287         if ( xDispatch.is() )
 288             xDispatch->dispatch( aURL, rArgs );
 289     }
 290 }
 291
 292 } // dbaui namespace
 293
 294 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 295 org_libreoffice_comp_dbu_LimitBoxController_get_implementation(
 296     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
 297 {
 298     return cppu::acquire(new ::dbaui::LimitBoxController(context));
 299 }
 300
 301 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */