LCOV - code coverage report
Current view: top level - cui/source/options - connpooloptions.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 0 192 0.0 %
Date: 2014-11-03 Functions: 0 37 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "connpooloptions.hxx"
      21             : #include <svtools/editbrowsebox.hxx>
      22             : #include <vcl/field.hxx>
      23             : #include "connpoolsettings.hxx"
      24             : #include <svl/eitem.hxx>
      25             : #include <cuires.hrc>
      26             : #include "helpid.hrc"
      27             : #include <dialmgr.hxx>
      28             : 
      29             : using ::svt::EditBrowseBox;
      30             : 
      31             : namespace offapp
      32             : {
      33             :     /// Widget for the Connection Pool options page
      34           0 :     class DriverListControl : public EditBrowseBox
      35             :     {
      36             :         using Window::Update;
      37             :     protected:
      38             :         DriverPoolingSettings                   m_aSavedSettings;
      39             :         DriverPoolingSettings                   m_aSettings;
      40             :         DriverPoolingSettings::const_iterator   m_aSeekRow;
      41             : 
      42             :         OUString                                m_sYes;
      43             :         OUString                                m_sNo;
      44             : 
      45             :         Link                                    m_aRowChangeHandler;
      46             : 
      47             :     public:
      48             :         DriverListControl(vcl::Window* _pParent);
      49             : 
      50             :         virtual void Init() SAL_OVERRIDE;
      51             :                 void Update(const DriverPoolingSettings& _rSettings);
      52             :         virtual OUString GetCellText( long nRow, sal_uInt16 nColId ) const SAL_OVERRIDE;
      53             : 
      54             :         // the handler will be called with a DriverPoolingSettings::const_iterator as parameter,
      55             :         // or NULL if no valid current row exists
      56           0 :         void SetRowChangeHandler(const Link& _rHdl) { m_aRowChangeHandler = _rHdl; }
      57             : 
      58             :         DriverPooling* getCurrentRow();
      59             :         void                                    updateCurrentRow();
      60             : 
      61           0 :         const DriverPoolingSettings& getSettings() const { return m_aSettings; }
      62             : 
      63           0 :         void        saveValue()             { m_aSavedSettings = m_aSettings; }
      64             :         bool    isModified() const;
      65             : 
      66             :     protected:
      67             :         virtual void InitController( ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol ) SAL_OVERRIDE;
      68             :         virtual ::svt::CellController* GetController( long nRow, sal_uInt16 nCol ) SAL_OVERRIDE;
      69             : 
      70             :         virtual void PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId ) const SAL_OVERRIDE;
      71             : 
      72             :         virtual bool SeekRow( long nRow ) SAL_OVERRIDE;
      73             :         virtual bool SaveModified() SAL_OVERRIDE;
      74             : 
      75             :         virtual bool IsTabAllowed(bool _bForward) const SAL_OVERRIDE;
      76             : 
      77             :         virtual void StateChanged( StateChangedType nStateChange ) SAL_OVERRIDE;
      78             : 
      79             :         virtual void CursorMoved() SAL_OVERRIDE;
      80             : 
      81             :     protected:
      82             :         virtual sal_uInt32 GetTotalCellWidth(long nRow, sal_uInt16 nColId) SAL_OVERRIDE;
      83             : 
      84             : 
      85             :     private:
      86             :         OUString implGetCellText(DriverPoolingSettings::const_iterator _rPos, sal_uInt16 _nColId) const;
      87             :     };
      88             : 
      89             : 
      90           0 :     DriverListControl::DriverListControl(vcl::Window* _pParent)
      91             :         :EditBrowseBox(_pParent, EBBF_NOROWPICTURE, BROWSER_AUTO_VSCROLL | BROWSER_AUTO_HSCROLL | BROWSER_HIDECURSOR | BROWSER_AUTOSIZE_LASTCOL | WB_BORDER)
      92           0 :         ,m_aSeekRow(m_aSettings.end())
      93           0 :         ,m_sYes(CUI_RES(RID_SVXSTR_YES))
      94           0 :         ,m_sNo(CUI_RES(RID_SVXSTR_NO))
      95             :     {
      96           0 :         SetStyle((GetStyle() & ~WB_HSCROLL) | WB_AUTOHSCROLL);
      97             : 
      98           0 :         SetUniqueId(UID_OFA_CONNPOOL_DRIVERLIST_BACK);
      99           0 :     }
     100             : 
     101           0 :     extern "C" SAL_DLLPUBLIC_EXPORT vcl::Window* SAL_CALL makeDriverListControl(vcl::Window *pParent, VclBuilder::stringmap &)
     102             :     {
     103           0 :         return new DriverListControl(pParent);
     104             :     }
     105             : 
     106             : 
     107           0 :     bool DriverListControl::IsTabAllowed(bool /*_bForward*/) const
     108             :     {
     109             :         // no travelling within the fields via RETURN and TAB
     110           0 :         return false;
     111             :     }
     112             : 
     113             : 
     114           0 :     bool DriverListControl::isModified() const
     115             :     {
     116           0 :         if (m_aSettings.size() != m_aSavedSettings.size())
     117           0 :             return true;
     118             : 
     119           0 :         DriverPoolingSettings::const_iterator aCurrent = m_aSettings.begin();
     120           0 :         DriverPoolingSettings::const_iterator aCurrentEnd = m_aSettings.end();
     121           0 :         DriverPoolingSettings::const_iterator aSaved = m_aSavedSettings.begin();
     122           0 :         for (;aCurrent != aCurrentEnd; ++aCurrent, ++aSaved)
     123             :         {
     124           0 :             if (*aCurrent != *aSaved)
     125           0 :                 return true;
     126             :         }
     127             : 
     128           0 :         return false;
     129             :     }
     130             : 
     131             : 
     132           0 :     void DriverListControl::Init()
     133             :     {
     134           0 :         EditBrowseBox::Init();
     135             : 
     136           0 :         Size aColWidth = LogicToPixel(Size(160, 0), MAP_APPFONT);
     137           0 :         InsertDataColumn(1, OUString(CUI_RES(RID_SVXSTR_DRIVER_NAME)), aColWidth.Width());
     138           0 :         aColWidth = LogicToPixel(Size(30, 0), MAP_APPFONT);
     139           0 :         InsertDataColumn(2, OUString(CUI_RES(RID_SVXSTR_POOLED_FLAG)), aColWidth.Width());
     140           0 :         aColWidth = LogicToPixel(Size(60, 0), MAP_APPFONT);
     141           0 :         InsertDataColumn(3, OUString(CUI_RES(RID_SVXSTR_POOL_TIMEOUT)), aColWidth.Width());
     142             :             // Attention: the resource of the string is local to the resource of the enclosing dialog!
     143           0 :     }
     144             : 
     145             : 
     146           0 :     void DriverListControl::CursorMoved()
     147             :     {
     148           0 :         EditBrowseBox::CursorMoved();
     149             : 
     150             :         // call the row change handler
     151           0 :         if ( m_aRowChangeHandler.IsSet() )
     152             :         {
     153           0 :             if ( GetCurRow() >= 0 )
     154             :             {   // == -1 may happen in case the browse box has just been cleared
     155           0 :                 m_aRowChangeHandler.Call( getCurrentRow() );
     156             :             }
     157             :         }
     158           0 :     }
     159             : 
     160           0 :     DriverPooling* DriverListControl::getCurrentRow()
     161             :     {
     162             :         OSL_ENSURE( ( GetCurRow() < m_aSettings.size() ) && ( GetCurRow() >= 0 ),
     163             :             "DriverListControl::getCurrentRow: invalid current row!");
     164             : 
     165           0 :         if ( ( GetCurRow() >= 0 ) && ( GetCurRow() < m_aSettings.size() ) )
     166           0 :             return &(*(m_aSettings.begin() + GetCurRow()));
     167             : 
     168           0 :         return NULL;
     169             :     }
     170             : 
     171             : 
     172           0 :     void DriverListControl::updateCurrentRow()
     173             :     {
     174           0 :         Window::Invalidate( GetRowRectPixel( GetCurRow() ), INVALIDATE_UPDATE );
     175           0 :     }
     176             : 
     177             : 
     178           0 :     void DriverListControl::Update(const DriverPoolingSettings& _rSettings)
     179             :     {
     180           0 :         m_aSettings = _rSettings;
     181             : 
     182           0 :         SetUpdateMode(false);
     183           0 :         RowRemoved(0, GetRowCount());
     184           0 :         RowInserted(0, m_aSettings.size());
     185           0 :         SetUpdateMode(true);
     186             : 
     187           0 :         ActivateCell(1, 0);
     188           0 :     }
     189             : 
     190             : 
     191           0 :     sal_uInt32 DriverListControl::GetTotalCellWidth(long nRow, sal_uInt16 nColId)
     192             :     {
     193           0 :         return GetDataWindow().GetTextWidth(GetCellText(nRow, nColId));
     194             :     }
     195             : 
     196             : 
     197           0 :     OUString DriverListControl::implGetCellText(DriverPoolingSettings::const_iterator _rPos, sal_uInt16 _nColId) const
     198             :     {
     199             :         OSL_ENSURE(_rPos < m_aSettings.end(), "DriverListControl::implGetCellText: invalid position!");
     200             : 
     201           0 :         OUString sReturn;
     202           0 :         switch (_nColId)
     203             :         {
     204             :             case 1:
     205           0 :                 sReturn = _rPos->sName;
     206           0 :                 break;
     207             :             case 2:
     208           0 :                 sReturn = _rPos->bEnabled ? m_sYes : m_sNo;
     209           0 :                 break;
     210             :             case 3:
     211           0 :                 if (_rPos->bEnabled)
     212           0 :                     sReturn = OUString::number(_rPos->nTimeoutSeconds);
     213           0 :                 break;
     214             :             default:
     215             :                 OSL_FAIL("DriverListControl::implGetCellText: invalid column id!");
     216             :         }
     217           0 :         return sReturn;
     218             :     }
     219             : 
     220             : 
     221           0 :     void DriverListControl::StateChanged( StateChangedType nStateChange )
     222             :     {
     223           0 :         if (StateChangedType::ENABLE == nStateChange)
     224           0 :             Window::Invalidate(INVALIDATE_UPDATE);
     225           0 :         EditBrowseBox::StateChanged( nStateChange );
     226           0 :     }
     227             : 
     228             : 
     229           0 :     OUString DriverListControl::GetCellText( long nRow, sal_uInt16 nColId ) const
     230             :     {
     231           0 :         OUString sReturn;
     232           0 :         if (nRow > m_aSettings.size())
     233             :         {
     234             :             OSL_FAIL("DriverListControl::GetCellText: don't ask me for such rows!");
     235             :         }
     236             :         else
     237             :         {
     238           0 :             sReturn = implGetCellText(m_aSettings.begin() + nRow, nColId);
     239             :         }
     240           0 :         return sReturn;
     241             :     }
     242             : 
     243             : 
     244           0 :     void DriverListControl::InitController( ::svt::CellControllerRef& rController, long nRow, sal_uInt16 nCol )
     245             :     {
     246           0 :         rController->GetWindow().SetText(GetCellText(nRow, nCol));
     247           0 :     }
     248             : 
     249             : 
     250           0 :     ::svt::CellController* DriverListControl::GetController( long /*nRow*/, sal_uInt16 /*nCol*/ )
     251             :     {
     252           0 :         return NULL;
     253             :     }
     254             : 
     255             : 
     256           0 :     bool DriverListControl::SaveModified()
     257             :     {
     258           0 :         return true;
     259             :     }
     260             : 
     261             : 
     262           0 :     bool DriverListControl::SeekRow( long _nRow )
     263             :     {
     264           0 :         EditBrowseBox::SeekRow(_nRow);
     265             : 
     266           0 :         if (_nRow < m_aSettings.size())
     267           0 :             m_aSeekRow = m_aSettings.begin() + _nRow;
     268             :         else
     269           0 :             m_aSeekRow = m_aSettings.end();
     270             : 
     271           0 :         return m_aSeekRow != m_aSettings.end();
     272             :     }
     273             : 
     274             : 
     275           0 :     void DriverListControl::PaintCell( OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColId ) const
     276             :     {
     277             :         OSL_ENSURE(m_aSeekRow != m_aSettings.end(), "DriverListControl::PaintCell: invalid row!");
     278             : 
     279           0 :         if (m_aSeekRow != m_aSettings.end())
     280             :         {
     281           0 :             rDev.SetClipRegion(vcl::Region(rRect));
     282             : 
     283           0 :             sal_uInt16 nStyle = TEXT_DRAW_CLIP;
     284           0 :             if (!IsEnabled())
     285           0 :                 nStyle |= TEXT_DRAW_DISABLE;
     286           0 :             switch (nColId)
     287             :             {
     288           0 :                 case 1: nStyle |= TEXT_DRAW_LEFT; break;
     289             :                 case 2:
     290           0 :                 case 3: nStyle |= TEXT_DRAW_CENTER; break;
     291             :             }
     292             : 
     293           0 :             rDev.DrawText(rRect, implGetCellText(m_aSeekRow, nColId), nStyle);
     294             : 
     295           0 :             rDev.SetClipRegion();
     296             :         }
     297           0 :     }
     298             : 
     299             : 
     300             :     //= ConnectionPoolOptionsPage
     301             : 
     302             : 
     303           0 :     ConnectionPoolOptionsPage::ConnectionPoolOptionsPage(vcl::Window* _pParent, const SfxItemSet& _rAttrSet)
     304           0 :         : SfxTabPage(_pParent, "ConnPoolPage", "cui/ui/connpooloptions.ui", &_rAttrSet)
     305             :     {
     306           0 :         get(m_pEnablePooling, "connectionpooling");
     307           0 :         get(m_pDriversLabel, "driverslabel");
     308           0 :         get(m_pDriverList, "driverlist");
     309           0 :         get(m_pDriverLabel, "driverlabel");
     310           0 :         get(m_pDriver, "driver");
     311           0 :         get(m_pDriverPoolingEnabled, "enablepooling");
     312           0 :         get(m_pTimeoutLabel, "timeoutlabel");
     313           0 :         get(m_pTimeout, "timeout");
     314             : 
     315           0 :         Size aControlSize(248, 100);
     316           0 :         aControlSize = LogicToPixel(aControlSize, MAP_APPFONT);
     317           0 :         m_pDriverList->set_width_request(aControlSize.Width());
     318           0 :         m_pDriverList->set_height_request(aControlSize.Height());
     319           0 :         m_pDriverList->Init();
     320           0 :         m_pDriverList->Show();
     321             : 
     322           0 :         m_pEnablePooling->SetClickHdl( LINK(this, ConnectionPoolOptionsPage, OnEnabledDisabled) );
     323           0 :         m_pDriverPoolingEnabled->SetClickHdl( LINK(this, ConnectionPoolOptionsPage, OnEnabledDisabled) );
     324             : 
     325           0 :         m_pDriverList->SetRowChangeHandler( LINK(this, ConnectionPoolOptionsPage, OnDriverRowChanged) );
     326           0 :     }
     327             : 
     328             : 
     329           0 :     SfxTabPage* ConnectionPoolOptionsPage::Create(vcl::Window* _pParent, const SfxItemSet* _rAttrSet)
     330             :     {
     331           0 :         return new ConnectionPoolOptionsPage(_pParent, *_rAttrSet);
     332             :     }
     333             : 
     334             : 
     335           0 :     void ConnectionPoolOptionsPage::implInitControls(const SfxItemSet& _rSet, bool /*_bFromReset*/)
     336             :     {
     337             :         // the enabled flag
     338           0 :         SFX_ITEMSET_GET( _rSet, pEnabled, SfxBoolItem, SID_SB_POOLING_ENABLED, true );
     339             :         OSL_ENSURE(pEnabled, "ConnectionPoolOptionsPage::implInitControls: missing the Enabled item!");
     340           0 :         m_pEnablePooling->Check(pEnabled ? pEnabled->GetValue() : sal_True);
     341             : 
     342           0 :         m_pEnablePooling->SaveValue();
     343             : 
     344             :         // the settings for the single drivers
     345           0 :         SFX_ITEMSET_GET( _rSet, pDriverSettings, DriverPoolingSettingsItem, SID_SB_DRIVER_TIMEOUTS, true );
     346           0 :         if (pDriverSettings)
     347           0 :             m_pDriverList->Update(pDriverSettings->getSettings());
     348             :         else
     349             :         {
     350             :             OSL_FAIL("ConnectionPoolOptionsPage::implInitControls: missing the DriverTimeouts item!");
     351           0 :             m_pDriverList->Update(DriverPoolingSettings());
     352             :         }
     353           0 :         m_pDriverList->saveValue();
     354             : 
     355             :         // reflect the new settings
     356           0 :         OnEnabledDisabled(m_pEnablePooling);
     357           0 :     }
     358             : 
     359             : 
     360           0 :     bool ConnectionPoolOptionsPage::Notify( NotifyEvent& _rNEvt )
     361             :     {
     362           0 :         if (EVENT_LOSEFOCUS == _rNEvt.GetType())
     363           0 :             if (m_pTimeout->IsWindowOrChild(_rNEvt.GetWindow()))
     364           0 :                 commitTimeoutField();
     365             : 
     366           0 :         return SfxTabPage::Notify(_rNEvt);
     367             :     }
     368             : 
     369             : 
     370           0 :     bool ConnectionPoolOptionsPage::FillItemSet(SfxItemSet* _rSet)
     371             :     {
     372           0 :         commitTimeoutField();
     373             : 
     374           0 :         bool bModified = false;
     375             :         // the enabled flag
     376           0 :         if (m_pEnablePooling->IsValueChangedFromSaved())
     377             :         {
     378           0 :             _rSet->Put(SfxBoolItem(SID_SB_POOLING_ENABLED, m_pEnablePooling->IsChecked()), SID_SB_POOLING_ENABLED);
     379           0 :             bModified = true;
     380             :         }
     381             : 
     382             :         // the settings for the single drivers
     383           0 :         if (m_pDriverList->isModified())
     384             :         {
     385           0 :             _rSet->Put(DriverPoolingSettingsItem(SID_SB_DRIVER_TIMEOUTS, m_pDriverList->getSettings()), SID_SB_DRIVER_TIMEOUTS);
     386           0 :             bModified = true;
     387             :         }
     388             : 
     389           0 :         return bModified;
     390             :     }
     391             : 
     392             : 
     393           0 :     void ConnectionPoolOptionsPage::ActivatePage( const SfxItemSet& _rSet)
     394             :     {
     395           0 :         SfxTabPage::ActivatePage(_rSet);
     396           0 :         implInitControls(_rSet, false);
     397           0 :     }
     398             : 
     399             : 
     400           0 :     void ConnectionPoolOptionsPage::Reset(const SfxItemSet* _rSet)
     401             :     {
     402           0 :         implInitControls(*_rSet, true);
     403           0 :     }
     404             : 
     405             : 
     406           0 :     IMPL_LINK( ConnectionPoolOptionsPage, OnDriverRowChanged, const void*, _pRowIterator )
     407             :     {
     408           0 :         bool bValidRow = (NULL != _pRowIterator);
     409           0 :         m_pDriverPoolingEnabled->Enable(bValidRow && m_pEnablePooling->IsChecked());
     410           0 :         m_pTimeoutLabel->Enable(bValidRow);
     411           0 :         m_pTimeout->Enable(bValidRow);
     412             : 
     413           0 :         if (!bValidRow)
     414             :         {   // positioned on an invalid row
     415           0 :             m_pDriver->SetText(OUString());
     416             :         }
     417             :         else
     418             :         {
     419           0 :             const DriverPooling *pDriverPos = static_cast<const DriverPooling*>(_pRowIterator);
     420             : 
     421           0 :             m_pDriver->SetText(pDriverPos->sName);
     422           0 :             m_pDriverPoolingEnabled->Check(pDriverPos->bEnabled);
     423           0 :             m_pTimeout->SetText(OUString::number(pDriverPos->nTimeoutSeconds));
     424             : 
     425           0 :             OnEnabledDisabled(m_pDriverPoolingEnabled);
     426             :         }
     427             : 
     428           0 :         return 0L;
     429             :     }
     430             : 
     431             : 
     432           0 :     void ConnectionPoolOptionsPage::commitTimeoutField()
     433             :     {
     434           0 :         if (DriverPooling* pCurrentDriver = m_pDriverList->getCurrentRow())
     435             :         {
     436           0 :             pCurrentDriver->nTimeoutSeconds = static_cast<long>(m_pTimeout->GetValue());
     437           0 :             m_pDriverList->updateCurrentRow();
     438             :         }
     439           0 :     }
     440             : 
     441             : 
     442           0 :     IMPL_LINK( ConnectionPoolOptionsPage, OnEnabledDisabled, const CheckBox*, _pCheckBox )
     443             :     {
     444           0 :         bool bGloballyEnabled = m_pEnablePooling->IsChecked();
     445           0 :         bool bLocalDriverChanged = m_pDriverPoolingEnabled == _pCheckBox;
     446             : 
     447           0 :         if (m_pEnablePooling == _pCheckBox)
     448             :         {
     449           0 :             m_pDriversLabel->Enable(bGloballyEnabled);
     450           0 :             m_pDriverList->Enable(bGloballyEnabled);
     451           0 :             m_pDriverLabel->Enable(bGloballyEnabled);
     452           0 :             m_pDriver->Enable(bGloballyEnabled);
     453           0 :             m_pDriverPoolingEnabled->Enable(bGloballyEnabled);
     454             :         }
     455             :         else
     456             :             OSL_ENSURE(bLocalDriverChanged, "ConnectionPoolOptionsPage::OnEnabledDisabled: where did this come from?");
     457             : 
     458           0 :         m_pTimeoutLabel->Enable(bGloballyEnabled && m_pDriverPoolingEnabled->IsChecked());
     459           0 :         m_pTimeout->Enable(bGloballyEnabled && m_pDriverPoolingEnabled->IsChecked());
     460             : 
     461           0 :         if (bLocalDriverChanged)
     462             :         {
     463             :             // update the list
     464           0 :             m_pDriverList->getCurrentRow()->bEnabled = m_pDriverPoolingEnabled->IsChecked();
     465           0 :             m_pDriverList->updateCurrentRow();
     466             :         }
     467             : 
     468           0 :         return 0L;
     469             :     }
     470             : 
     471           0 : } // namespace offapp
     472             : 
     473             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10