include/svtools/editbrowsebox.hxx

   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 #pragma once
  21
  22 #include <config_options.h>
  23 #include <memory>
  24 #include <svtools/svtdllapi.h>
  25 #include <tools/ref.hxx>
  26
  27 #include <svtools/brwbox.hxx>
  28 #include <svtools/brwhead.hxx>
  29 #include <tools/lineend.hxx>
  30 #include <vcl/InterimItemWindow.hxx>
  31 #include <vcl/weldutils.hxx>
  32 #include <o3tl/typed_flags_set.hxx>
  33
  34 class BrowserDataWin;
  35
  36 // EditBrowseBoxFlags (EBBF)
  37 enum class EditBrowseBoxFlags
  38 {
  39     NONE                       = 0x0000,
  40 /** if this bit is _not_ set, the handle column will be invalidated upon
  41     changing the row in the browse box.  This is for forcing the row picture to
  42     be repainted. If you do not have row pictures or text, you don't need this
  43     invalidation, then you would specify this bit to prevent flicker
  44 */
  45     NO_HANDLE_COLUMN_CONTENT   = 0x0001,
  46 /** set this bit to activate the cell on a MouseButtonDown, not a MouseButtonUp event
  47  */
  48     ACTIVATE_ON_BUTTONDOWN     = 0x0002,
  49 /** if this bit is set and EditBrowseBoxFlags::NO_HANDLE_COLUMN_CONTENT is _not_ set, the handle
  50     column is drawn with the text contained in column 0 instead of an image
  51 */
  52     HANDLE_COLUMN_TEXT         = 0x0004,
  53
  54 /** If this bit is set, tab traveling is somewhat modified<br/>
  55     If the control gets the focus because the user pressed the TAB key, then the
  56     first or last cell (depending on whether the traveling was cycling forward or backward)
  57     gets activated.
  58     @see Window::GetGetFocusFlags
  59     @see GETFOCUS_*
  60 */
  61     SMART_TAB_TRAVEL           = 0x0008,
  62
  63 };
  64 namespace o3tl
  65 {
  66     template<> struct typed_flags<EditBrowseBoxFlags> : is_typed_flags<EditBrowseBoxFlags, 0x0f> {};
  67 }
  68
  69 namespace svt
  70 {
  71     class SVT_DLLPUBLIC CellController : public SvRefBase
  72     {
  73         friend class EditBrowseBox;
  74         Link<LinkParamNone*, void> maModifyHdl;
  75
  76         VclPtr<Control>            pWindow;
  77         bool                       bSuspended;     // <true> if the window is hidden and disabled
  78
  79     public:
  80
  81         CellController(Control* pW);
  82         virtual ~CellController() override;
  83
  84         Control& GetWindow() const { return *const_cast< CellController* >( this )->pWindow; }
  85
  86         virtual void SaveValue() = 0;
  87         virtual bool IsValueChangedFromSaved() const = 0;
  88
  89         // commit any current changes. Especially, do any reformatting you need (from input formatting
  90         // to output formatting) here
  91         virtual void CommitModifications();
  92
  93         // suspending the controller is not cumulative!
  94                 void        suspend( );
  95                 void        resume( );
  96         bool        isSuspended( ) const { return bSuspended; }
  97
  98     protected:
  99         virtual bool MoveAllowed(const KeyEvent& rEvt) const;
 100         void SetModifyHdl(const Link<LinkParamNone*,void>& rLink) { maModifyHdl = rLink; }
 101         virtual void ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool bUp);
 102         virtual void callModifyHdl() { maModifyHdl.Call(nullptr); }
 103     };
 104
 105     typedef tools::SvRef<CellController> CellControllerRef;
 106
 107
 108     //= IEditImplementation
 109
 110     class UNLESS_MERGELIBS(SVT_DLLPUBLIC) IEditImplementation
 111     {
 112     public:
 113         virtual ~IEditImplementation() = 0;
 114
 115         virtual Control&            GetControl() = 0;
 116
 117         virtual OUString            GetText( LineEnd aSeparator ) const = 0;
 118         virtual void                SetText( const OUString& _rStr ) = 0;
 119
 120         virtual bool                IsReadOnly() const = 0;
 121         virtual void                SetReadOnly( bool bReadOnly ) = 0;
 122
 123         virtual sal_Int32           GetMaxTextLen() const = 0;
 124         virtual void                SetMaxTextLen( sal_Int32 _nMaxLen ) = 0;
 125
 126         virtual Selection           GetSelection() const = 0;
 127         virtual void                SetSelection( const Selection& _rSelection ) = 0;
 128
 129         virtual void                ReplaceSelected( const OUString& _rStr ) = 0;
 130         virtual OUString            GetSelected( LineEnd aSeparator ) const = 0;
 131
 132         virtual bool                IsValueChangedFromSaved() const = 0;
 133         virtual void                SaveValue() = 0;
 134
 135         virtual bool                CanUp() const = 0;
 136         virtual bool                CanDown() const = 0;
 137
 138         virtual void                Cut() = 0;
 139         virtual void                Copy() = 0;
 140         virtual void                Paste() = 0;
 141
 142         // sets a link to call when the text is changed by the user
 143         void SetModifyHdl(const Link<LinkParamNone*,void>& rLink)
 144         {
 145             m_aModify1Hdl = rLink;
 146         }
 147
 148         // sets an additional link to call when the text is changed by the user
 149         void SetAuxModifyHdl(const Link<LinkParamNone*,void>& rLink)
 150         {
 151             m_aModify2Hdl = rLink;
 152         }
 153
 154     private:
 155         Link<LinkParamNone*,void> m_aModify1Hdl;
 156         Link<LinkParamNone*,void> m_aModify2Hdl;
 157
 158     protected:
 159         void CallModifyHdls()
 160         {
 161             m_aModify1Hdl.Call(nullptr);
 162             m_aModify2Hdl.Call(nullptr);
 163         }
 164     };
 165
 166     class SVT_DLLPUBLIC ControlBase : public InterimItemWindow
 167     {
 168     public:
 169         ControlBase(BrowserDataWin* pParent, const OUString& rUIXMLDescription, const OString& rID);
 170
 171         virtual void SetEditableReadOnly(bool bReadOnly);
 172
 173         virtual bool ProcessKey(const KeyEvent& rKEvt);
 174
 175         // chain after the FocusInHdl
 176         void SetFocusInHdl(const Link<LinkParamNone*,void>& rHdl)
 177         {
 178             m_aFocusInHdl = rHdl;
 179         }
 180
 181         // chain after the FocusOutHdl
 182         void SetFocusOutHdl(const Link<LinkParamNone*,void>& rHdl)
 183         {
 184             m_aFocusOutHdl = rHdl;
 185         }
 186
 187         void SetMousePressHdl(const Link<const MouseEvent&,void>& rHdl)
 188         {
 189             m_aMousePressHdl = rHdl;
 190         }
 191
 192         void SetMouseReleaseHdl(const Link<const MouseEvent&,void>& rHdl)
 193         {
 194             m_aMouseReleaseHdl = rHdl;
 195         }
 196
 197         void SetMouseMoveHdl(const Link<const MouseEvent&,void>& rHdl)
 198         {
 199             m_aMouseMoveHdl = rHdl;
 200         }
 201
 202     protected:
 203         DECL_LINK(KeyInputHdl, const KeyEvent&, bool);
 204         DECL_LINK(FocusInHdl, weld::Widget&, void);
 205         DECL_LINK(FocusOutHdl, weld::Widget&, void);
 206         DECL_LINK(MousePressHdl, const MouseEvent&, bool);
 207         DECL_LINK(MouseReleaseHdl, const MouseEvent&, bool);
 208         DECL_LINK(MouseMoveHdl, const MouseEvent&, bool);
 209     private:
 210         Link<LinkParamNone*,void> m_aFocusInHdl;
 211         Link<LinkParamNone*,void> m_aFocusOutHdl;
 212         Link<const MouseEvent&,void> m_aMousePressHdl;
 213         Link<const MouseEvent&,void> m_aMouseReleaseHdl;
 214         Link<const MouseEvent&,void> m_aMouseMoveHdl;
 215     };
 216
 217     class SVT_DLLPUBLIC EditControlBase : public ControlBase
 218     {
 219     public:
 220         EditControlBase(BrowserDataWin* pParent);
 221
 222         virtual void SetEditableReadOnly(bool bReadOnly) override
 223         {
 224             m_pEntry->set_editable(!bReadOnly);
 225         }
 226
 227         virtual void dispose() override;
 228
 229         weld::Entry& get_widget() { return *m_pEntry; }
 230
 231         virtual void connect_changed(const Link<weld::Entry&, void>& rLink) = 0;
 232         virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) = 0;
 233
 234     protected:
 235         void InitEditControlBase(weld::Entry* pEntry);
 236
 237     private:
 238         weld::Entry* m_pEntry;
 239     };
 240
 241     class SVT_DLLPUBLIC EditControl : public EditControlBase
 242     {
 243     public:
 244         EditControl(BrowserDataWin* pParent);
 245
 246         virtual void dispose() override;
 247
 248         virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override
 249         {
 250             m_xWidget->connect_changed(rLink);
 251         }
 252
 253         virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override
 254         {
 255             m_xWidget->connect_focus_out(rLink);
 256         }
 257
 258     protected:
 259         std::unique_ptr<weld::Entry> m_xWidget;
 260     };
 261
 262     class SVT_DLLPUBLIC EntryImplementation : public IEditImplementation
 263     {
 264         EditControlBase& m_rEdit;
 265         int m_nMaxTextLen;
 266
 267         DECL_LINK(ModifyHdl, weld::Entry&, void);
 268     public:
 269         EntryImplementation(EditControlBase& rEdit)
 270             : m_rEdit(rEdit)
 271             , m_nMaxTextLen(0)
 272         {
 273             m_rEdit.connect_changed(LINK(this, EntryImplementation, ModifyHdl));
 274         }
 275
 276         virtual Control& GetControl() override
 277         {
 278             return m_rEdit;
 279         }
 280
 281         virtual OUString GetText( LineEnd /*aSeparator*/ ) const override
 282         {
 283             // ignore the line end - this base implementation does not support it
 284             return m_rEdit.get_widget().get_text();
 285         }
 286
 287         virtual void SetText( const OUString& _rStr ) override
 288         {
 289             return m_rEdit.get_widget().set_text(_rStr);
 290         }
 291
 292         virtual bool IsReadOnly() const override
 293         {
 294             return !m_rEdit.get_widget().get_editable();
 295         }
 296
 297         virtual void SetReadOnly( bool bReadOnly ) override
 298         {
 299             m_rEdit.SetEditableReadOnly(bReadOnly);
 300         }
 301
 302         virtual sal_Int32 GetMaxTextLen() const override
 303         {
 304             return m_nMaxTextLen;
 305         }
 306
 307         virtual void SetMaxTextLen( sal_Int32 nMaxLen ) override
 308         {
 309             m_nMaxTextLen = nMaxLen;
 310             m_rEdit.get_widget().set_max_length(m_nMaxTextLen);
 311         }
 312
 313         virtual Selection GetSelection() const override
 314         {
 315             int nStartPos, nEndPos;
 316             m_rEdit.get_widget().get_selection_bounds(nStartPos, nEndPos);
 317             return Selection(nStartPos, nEndPos);
 318         }
 319
 320         virtual void SetSelection( const Selection& rSelection ) override
 321         {
 322             auto nMin = rSelection.Min();
 323             auto nMax = rSelection.Max();
 324             m_rEdit.get_widget().select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
 325         }
 326
 327         virtual void ReplaceSelected( const OUString& rStr ) override
 328         {
 329             m_rEdit.get_widget().replace_selection(rStr);
 330         }
 331
 332         virtual OUString GetSelected( LineEnd /*aSeparator*/ ) const override
 333             // ignore the line end - this base implementation does not support it
 334         {
 335             int nStartPos, nEndPos;
 336             weld::Entry& rEntry = m_rEdit.get_widget();
 337             rEntry.get_selection_bounds(nStartPos, nEndPos);
 338             return rEntry.get_text().copy(nStartPos, nEndPos - nStartPos);
 339         }
 340
 341         virtual bool IsValueChangedFromSaved() const override
 342         {
 343             return m_rEdit.get_widget().get_value_changed_from_saved();
 344         }
 345
 346         virtual void SaveValue() override
 347         {
 348             m_rEdit.get_widget().save_value();
 349         }
 350
 351         virtual bool CanUp() const override
 352         {
 353             return false;
 354         }
 355
 356         virtual bool CanDown() const override
 357         {
 358             return false;
 359         }
 360
 361         virtual void Cut() override
 362         {
 363             m_rEdit.get_widget().cut_clipboard();
 364         }
 365
 366         virtual void Copy() override
 367         {
 368             m_rEdit.get_widget().copy_clipboard();
 369         }
 370
 371         virtual void Paste() override
 372         {
 373             m_rEdit.get_widget().paste_clipboard();
 374         }
 375     };
 376
 377     //= MultiLineTextCell
 378
 379     /** a multi line edit which can be used in a cell of an EditBrowseBox
 380     */
 381     class UNLESS_MERGELIBS(SVT_DLLPUBLIC) MultiLineTextCell final : public ControlBase
 382     {
 383     public:
 384         MultiLineTextCell(BrowserDataWin* pParent);
 385
 386         virtual void SetEditableReadOnly(bool bReadOnly) override
 387         {
 388             m_xWidget->set_editable(!bReadOnly);
 389         }
 390
 391         virtual void GetFocus() override;
 392
 393         virtual void dispose() override;
 394
 395         void connect_changed(const Link<weld::TextView&, void>& rLink)
 396         {
 397             m_xWidget->connect_changed(rLink);
 398         }
 399
 400         weld::TextView& get_widget() { return *m_xWidget; }
 401
 402     private:
 403         std::unique_ptr<weld::TextView> m_xWidget;
 404
 405         virtual bool ProcessKey(const KeyEvent& rKEvt) override;
 406     };
 407
 408     class SVT_DLLPUBLIC MultiLineEditImplementation : public IEditImplementation
 409     {
 410         MultiLineTextCell& m_rEdit;
 411         int m_nMaxTextLen;
 412
 413         DECL_LINK(ModifyHdl, weld::TextView&, void);
 414     public:
 415         MultiLineEditImplementation(MultiLineTextCell& rEdit)
 416             : m_rEdit(rEdit)
 417             , m_nMaxTextLen(0)
 418         {
 419             m_rEdit.connect_changed(LINK(this, MultiLineEditImplementation, ModifyHdl));
 420         }
 421
 422         virtual Control& GetControl() override
 423         {
 424             return m_rEdit;
 425         }
 426
 427         virtual OUString GetText(LineEnd aSeparator) const override;
 428
 429         virtual void SetText(const OUString& rStr) override
 430         {
 431             return m_rEdit.get_widget().set_text(rStr);
 432         }
 433
 434         virtual bool IsReadOnly() const override
 435         {
 436             return !m_rEdit.get_widget().get_editable();
 437         }
 438
 439         virtual void SetReadOnly( bool bReadOnly ) override
 440         {
 441             m_rEdit.SetEditableReadOnly(bReadOnly);
 442         }
 443
 444         virtual sal_Int32 GetMaxTextLen() const override
 445         {
 446             return m_nMaxTextLen;
 447         }
 448
 449         virtual void SetMaxTextLen( sal_Int32 nMaxLen ) override
 450         {
 451             m_nMaxTextLen = nMaxLen;
 452             m_rEdit.get_widget().set_max_length(m_nMaxTextLen);
 453         }
 454
 455         virtual Selection GetSelection() const override
 456         {
 457             int nStartPos, nEndPos;
 458             m_rEdit.get_widget().get_selection_bounds(nStartPos, nEndPos);
 459             return Selection(nStartPos, nEndPos);
 460         }
 461
 462         virtual void SetSelection( const Selection& rSelection ) override
 463         {
 464             auto nMin = rSelection.Min();
 465             auto nMax = rSelection.Max();
 466             m_rEdit.get_widget().select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
 467         }
 468
 469         virtual void ReplaceSelected( const OUString& rStr ) override
 470         {
 471             m_rEdit.get_widget().replace_selection(rStr);
 472         }
 473
 474         virtual OUString GetSelected( LineEnd aSeparator ) const override;
 475
 476         virtual bool IsValueChangedFromSaved() const override
 477         {
 478             return m_rEdit.get_widget().get_value_changed_from_saved();
 479         }
 480
 481         virtual void SaveValue() override
 482         {
 483             m_rEdit.get_widget().save_value();
 484         }
 485
 486         virtual bool CanUp() const override
 487         {
 488             return m_rEdit.get_widget().can_move_cursor_with_up();
 489         }
 490
 491         virtual bool CanDown() const override
 492         {
 493             return m_rEdit.get_widget().can_move_cursor_with_down();
 494         }
 495
 496         virtual void Cut() override
 497         {
 498             m_rEdit.get_widget().cut_clipboard();
 499         }
 500
 501         virtual void Copy() override
 502         {
 503             m_rEdit.get_widget().copy_clipboard();
 504         }
 505
 506         virtual void Paste() override
 507         {
 508             m_rEdit.get_widget().paste_clipboard();
 509         }
 510     };
 511
 512
 513     //= EditCellController
 514     class SVT_DLLPUBLIC EditCellController : public CellController
 515     {
 516         IEditImplementation*    m_pEditImplementation;
 517         bool                    m_bOwnImplementation;   // did we create m_pEditImplementation?
 518
 519     public:
 520         EditCellController( EditControlBase* _pEdit );
 521         EditCellController( IEditImplementation* _pImplementation );
 522         virtual ~EditCellController( ) override;
 523
 524         const IEditImplementation* GetEditImplementation( ) const { return m_pEditImplementation; }
 525               IEditImplementation* GetEditImplementation( )       { return m_pEditImplementation; }
 526
 527         virtual bool IsValueChangedFromSaved() const override;
 528         virtual void SaveValue() override;
 529
 530         void Modify()
 531         {
 532             ModifyHdl(nullptr);
 533         }
 534
 535     protected:
 536         virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
 537     private:
 538         DECL_LINK(ModifyHdl, LinkParamNone*, void);
 539     };
 540
 541     //= CheckBoxControl
 542     class SVT_DLLPUBLIC CheckBoxControl final : public ControlBase
 543     {
 544         std::unique_ptr<weld::CheckButton> m_xBox;
 545         weld::TriStateEnabled m_aModeState;
 546         Link<weld::Button&,void> m_aClickLink;
 547         Link<LinkParamNone*,void> m_aModify1Hdl;
 548         Link<LinkParamNone*,void> m_aModify2Hdl;
 549
 550     public:
 551         CheckBoxControl(BrowserDataWin* pParent);
 552         virtual ~CheckBoxControl() override;
 553         virtual void dispose() override;
 554
 555         void SetClickHdl(const Link<weld::Button&,void>& rHdl) {m_aClickLink = rHdl;}
 556
 557         // sets a link to call when the text is changed by the user
 558         void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
 559         {
 560             m_aModify1Hdl = rHdl;
 561         }
 562
 563         // sets an additional link to call when the text is changed by the user
 564         void SetAuxModifyHdl(const Link<LinkParamNone*,void>& rLink)
 565         {
 566             m_aModify2Hdl = rLink;
 567         }
 568
 569         void SetState(TriState eState);
 570         TriState GetState() const { return m_xBox->get_state(); }
 571
 572         void EnableTriState(bool bTriState);
 573
 574         weld::CheckButton&   GetBox() {return *m_xBox;};
 575
 576         // for pseudo-click when initially clicking in a cell activates
 577         // the cell and performs a state change on the button as if
 578         // it was clicked on
 579         void Clicked();
 580
 581     private:
 582         DECL_LINK(OnToggle, weld::ToggleButton&, void);
 583
 584         void CallModifyHdls()
 585         {
 586             m_aModify1Hdl.Call(nullptr);
 587             m_aModify2Hdl.Call(nullptr);
 588         }
 589     };
 590
 591     //= CheckBoxCellController
 592     class SVT_DLLPUBLIC CheckBoxCellController final : public CellController
 593     {
 594     public:
 595
 596         CheckBoxCellController(CheckBoxControl* pWin);
 597         weld::CheckButton& GetCheckBox() const;
 598
 599         virtual bool IsValueChangedFromSaved() const override;
 600         virtual void SaveValue() override;
 601
 602     private:
 603         virtual void ActivatingMouseEvent(const BrowserMouseEvent& rEvt, bool bUp) override;
 604         DECL_LINK(ModifyHdl, LinkParamNone*, void);
 605     };
 606
 607     //= ComboBoxControl
 608     class SVT_DLLPUBLIC ComboBoxControl final : public ControlBase
 609     {
 610     private:
 611         std::unique_ptr<weld::ComboBox> m_xWidget;
 612         Link<LinkParamNone*,void> m_aModify1Hdl;
 613         Link<bool,void> m_aModify2Hdl;
 614
 615         friend class ComboBoxCellController;
 616
 617     public:
 618         ComboBoxControl(BrowserDataWin* pParent);
 619
 620         virtual void SetEditableReadOnly(bool bReadOnly) override
 621         {
 622             m_xWidget->set_entry_editable(!bReadOnly);
 623         }
 624
 625         weld::ComboBox& get_widget() { return *m_xWidget; }
 626
 627         // sets a link to call when the selection is changed by the user
 628         void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
 629         {
 630             m_aModify1Hdl = rHdl;
 631         }
 632
 633         // sets an additional link to call when the selection is changed by the user
 634         // bool arg is true when triggered interactively by the user
 635         void SetAuxModifyHdl(const Link<bool,void>& rLink)
 636         {
 637             m_aModify2Hdl = rLink;
 638         }
 639
 640         void TriggerAuxModify()
 641         {
 642             m_aModify2Hdl.Call(false);
 643         }
 644
 645         virtual void dispose() override;
 646
 647     private:
 648         DECL_LINK(SelectHdl, weld::ComboBox&, void);
 649
 650         void CallModifyHdls()
 651         {
 652             m_aModify1Hdl.Call(nullptr);
 653             m_aModify2Hdl.Call(true);
 654         }
 655     };
 656
 657     //= ComboBoxCellController
 658     class SVT_DLLPUBLIC ComboBoxCellController : public CellController
 659     {
 660     public:
 661
 662         ComboBoxCellController(ComboBoxControl* pParent);
 663         weld::ComboBox& GetComboBox() const { return static_cast<ComboBoxControl&>(GetWindow()).get_widget(); }
 664
 665         virtual bool IsValueChangedFromSaved() const override;
 666         virtual void SaveValue() override;
 667
 668     protected:
 669         virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
 670     private:
 671         DECL_LINK(ModifyHdl, LinkParamNone*, void);
 672     };
 673
 674     //= ListBoxControl
 675     class SVT_DLLPUBLIC ListBoxControl final : public ControlBase
 676     {
 677     private:
 678         std::unique_ptr<weld::ComboBox> m_xWidget;
 679         Link<LinkParamNone*,void> m_aModify1Hdl;
 680         Link<bool,void> m_aModify2Hdl;
 681
 682         friend class ListBoxCellController;
 683
 684     public:
 685         ListBoxControl(BrowserDataWin* pParent);
 686
 687         weld::ComboBox& get_widget() { return *m_xWidget; }
 688
 689         // sets a link to call when the selection is changed by the user
 690         void SetModifyHdl(const Link<LinkParamNone*,void>& rHdl)
 691         {
 692             m_aModify1Hdl = rHdl;
 693         }
 694
 695         // sets an additional link to call when the selection is changed,
 696         // bool arg is true when triggered interactively by the user
 697         void SetAuxModifyHdl(const Link<bool,void>& rLink)
 698         {
 699             m_aModify2Hdl = rLink;
 700         }
 701
 702         void TriggerAuxModify()
 703         {
 704             m_aModify2Hdl.Call(false);
 705         }
 706
 707         virtual void dispose() override;
 708     private:
 709         DECL_LINK(SelectHdl, weld::ComboBox&, void);
 710
 711         void CallModifyHdls()
 712         {
 713             m_aModify1Hdl.Call(nullptr);
 714             m_aModify2Hdl.Call(true);
 715         }
 716     };
 717
 718     //= ListBoxCellController
 719     class SVT_DLLPUBLIC ListBoxCellController : public CellController
 720     {
 721     public:
 722
 723         ListBoxCellController(ListBoxControl* pParent);
 724         weld::ComboBox& GetListBox() const { return static_cast<ListBoxControl&>(GetWindow()).get_widget(); }
 725
 726         virtual bool IsValueChangedFromSaved() const override;
 727         virtual void SaveValue() override;
 728
 729     protected:
 730         virtual bool MoveAllowed(const KeyEvent& rEvt) const override;
 731     private:
 732         DECL_LINK(ListBoxSelectHdl, LinkParamNone*, void);
 733     };
 734
 735     class SVT_DLLPUBLIC FormattedControlBase : public EditControlBase
 736     {
 737     public:
 738         FormattedControlBase(BrowserDataWin* pParent, bool bSpinVariant);
 739
 740         virtual void dispose() override;
 741
 742         virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override;
 743         virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override;
 744
 745         weld::EntryFormatter& get_formatter();
 746
 747     protected:
 748         bool m_bSpinVariant;
 749         std::unique_ptr<weld::Entry> m_xEntry;
 750         std::unique_ptr<weld::FormattedSpinButton> m_xSpinButton;
 751         std::unique_ptr<weld::EntryFormatter> m_xEntryFormatter;
 752
 753         void InitFormattedControlBase();
 754     };
 755
 756     class SVT_DLLPUBLIC FormattedControl : public FormattedControlBase
 757     {
 758     public:
 759         FormattedControl(BrowserDataWin* pParent, bool bSpinVariant);
 760     };
 761
 762     class SVT_DLLPUBLIC DoubleNumericControl : public FormattedControlBase
 763     {
 764     public:
 765         DoubleNumericControl(BrowserDataWin* pParent, bool bSpinVariant);
 766     };
 767
 768     class SVT_DLLPUBLIC LongCurrencyControl : public FormattedControlBase
 769     {
 770     public:
 771         LongCurrencyControl(BrowserDataWin* pParent, bool bSpinVariant);
 772     };
 773
 774     class SVT_DLLPUBLIC TimeControl : public FormattedControlBase
 775     {
 776     public:
 777         TimeControl(BrowserDataWin* pParent, bool bSpinVariant);
 778     };
 779
 780     class SVT_DLLPUBLIC DateControl : public FormattedControlBase
 781     {
 782     public:
 783         DateControl(BrowserDataWin* pParent, bool bDropDown);
 784
 785         void SetDate(const Date& rDate);
 786
 787         virtual void dispose() override;
 788     private:
 789         std::unique_ptr<weld::MenuButton> m_xMenuButton;
 790         std::unique_ptr<weld::Builder> m_xCalendarBuilder;
 791         std::unique_ptr<weld::Widget> m_xTopLevel;
 792         std::unique_ptr<weld::Calendar> m_xCalendar;
 793         std::unique_ptr<weld::Widget> m_xExtras;
 794         std::unique_ptr<weld::Button> m_xTodayBtn;
 795         std::unique_ptr<weld::Button> m_xNoneBtn;
 796
 797         DECL_LINK(ToggleHdl, weld::ToggleButton&, void);
 798         DECL_LINK(ActivateHdl, weld::Calendar&, void);
 799         DECL_LINK(ImplClickHdl, weld::Button&, void);
 800     };
 801
 802     class SVT_DLLPUBLIC PatternControl final : public EditControl
 803     {
 804     public:
 805         PatternControl(BrowserDataWin* pParent);
 806
 807         weld::PatternFormatter& get_formatter() { return *m_xEntryFormatter; }
 808
 809         virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override;
 810         virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override;
 811
 812         virtual void dispose() override;
 813     private:
 814         std::unique_ptr<weld::PatternFormatter> m_xEntryFormatter;
 815     };
 816
 817     //= FormattedFieldCellController
 818     class SVT_DLLPUBLIC FormattedFieldCellController final : public EditCellController
 819     {
 820     public:
 821         FormattedFieldCellController( FormattedControlBase* _pFormatted );
 822
 823         virtual void CommitModifications() override;
 824     };
 825
 826     //= EditBrowserHeader
 827     class SVT_DLLPUBLIC EditBrowserHeader : public BrowserHeader
 828     {
 829     public:
 830         EditBrowserHeader( BrowseBox* pParent, WinBits nWinBits = WB_BUTTONSTYLE )
 831             :BrowserHeader(pParent, nWinBits){}
 832
 833     protected:
 834         virtual void DoubleClick() override;
 835     };
 836
 837
 838     //= EditBrowseBox
 839     class EditBrowseBoxImpl;
 840     class SVT_DLLPUBLIC EditBrowseBox: public BrowseBox
 841     {
 842         friend class EditBrowserHeader;
 843
 844         enum BrowseInfo
 845         {
 846             COLSELECT   =   1,
 847             ROWSELECT   =   2,
 848             ROWCHANGE   =   4,
 849             COLCHANGE   =   8
 850         };
 851
 852     public:
 853         enum RowStatus
 854         {
 855             CLEAN               =   0,
 856             CURRENT             =   1,
 857             CURRENTNEW          =   2,
 858             MODIFIED            =   3,
 859             NEW                 =   4,
 860             DELETED             =   5,
 861             PRIMARYKEY          =   6,
 862             CURRENT_PRIMARYKEY  =   7,
 863             FILTER              =   8,
 864             HEADERFOOTER        =   9
 865         };
 866
 867     private:
 868         EditBrowseBox(EditBrowseBox const &) = delete;
 869         EditBrowseBox& operator=(EditBrowseBox const &) = delete;
 870
 871         class BrowserMouseEventPtr
 872         {
 873             std::unique_ptr<BrowserMouseEvent> pEvent;
 874             bool               bDown;
 875
 876         public:
 877             BrowserMouseEventPtr()
 878                 : bDown(false)
 879             {
 880             }
 881
 882             bool Is() const {return pEvent != nullptr;}
 883             bool IsDown() const {return bDown;}
 884             const BrowserMouseEvent* operator->() const {return pEvent.get();}
 885
 886             SVT_DLLPUBLIC void Clear();
 887             void Set(const BrowserMouseEvent* pEvt, bool bIsDown);
 888         } aMouseEvent;
 889
 890         CellControllerRef        aController,
 891                                  aOldController;
 892
 893         ImplSVEvent * nStartEvent, * nEndEvent, * nCellModifiedEvent;     // event ids
 894         VclPtr<vcl::Window> m_pFocusWhileRequest;
 895             // In ActivateCell, we grab the focus asynchronously, but if between requesting activation
 896             // and the asynchronous event the focus has changed, we won't grab it for ourself.
 897
 898         sal_Int32   nPaintRow;  // row being painted
 899         sal_Int32   nEditRow;
 900         sal_uInt16  nEditCol;
 901
 902         bool            bHasFocus : 1;
 903         mutable bool    bPaintStatus : 1;   // paint a status (image) in the handle column
 904         bool            bActiveBeforeTracking;
 905
 906         VclPtr<CheckBoxControl> pCheckBoxPaint;
 907
 908         EditBrowseBoxFlags  m_nBrowserFlags;
 909         std::unique_ptr< EditBrowseBoxImpl> m_aImpl;
 910
 911     protected:
 912         VclPtr<BrowserHeader>  pHeader;
 913
 914         BrowserMouseEventPtr& getMouseEvent() { return aMouseEvent; }
 915
 916     protected:
 917         BrowserHeader*  GetHeaderBar() const {return pHeader;}
 918
 919         virtual VclPtr<BrowserHeader> CreateHeaderBar(BrowseBox* pParent) override;
 920
 921         // if you want to have an own header ...
 922         virtual VclPtr<BrowserHeader> imp_CreateHeaderBar(BrowseBox* pParent);
 923
 924         virtual void ColumnMoved(sal_uInt16 nId) override;
 925         virtual void ColumnResized(sal_uInt16 nColId) override;
 926         virtual void Resize() override;
 927         virtual void ArrangeControls(sal_uInt16& nX, sal_uInt16 nY);
 928         virtual bool SeekRow(sal_Int32 nRow) override;
 929
 930         virtual void GetFocus() override;
 931         virtual void LoseFocus() override;
 932         virtual void KeyInput(const KeyEvent& rEvt) override;
 933         virtual void MouseButtonDown(const BrowserMouseEvent& rEvt) override;
 934         virtual void MouseButtonUp(const BrowserMouseEvent& rEvt) override;
 935         virtual void StateChanged( StateChangedType nType ) override;
 936         virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
 937
 938         using BrowseBox::MouseButtonUp;
 939         using BrowseBox::MouseButtonDown;
 940
 941         virtual bool PreNotify(NotifyEvent& rNEvt ) override;
 942         virtual bool EventNotify(NotifyEvent& rNEvt) override;
 943
 944         virtual void EndScroll() override;
 945
 946         // should be used instead of GetFieldRectPixel, 'cause this method here takes into account the borders
 947         tools::Rectangle GetCellRect(sal_Int32 nRow, sal_uInt16 nColId, bool bRelToBrowser = true) const;
 948         virtual sal_uInt32 GetTotalCellWidth(sal_Int32 nRow, sal_uInt16 nColId);
 949         sal_uInt32 GetAutoColumnWidth(sal_uInt16 nColId);
 950
 951         virtual void PaintStatusCell(OutputDevice& rDev, const tools::Rectangle& rRect) const;
 952         virtual void PaintCell(OutputDevice& rDev, const tools::Rectangle& rRect, sal_uInt16 nColId) const = 0;
 953
 954         virtual RowStatus GetRowStatus(sal_Int32 nRow) const;
 955
 956         virtual void    RowHeightChanged() override;
 957
 958         // callbacks for the data window
 959         virtual void    ImplStartTracking() override;
 960         virtual void    ImplEndTracking() override;
 961
 962         // when changing a row:
 963         // CursorMoving:    cursor is being moved, but GetCurRow() still provides the old row
 964         virtual bool CursorMoving(sal_Int32 nNewRow, sal_uInt16 nNewCol);
 965
 966         // cursor has been moved
 967         virtual void CursorMoved() override;
 968
 969         virtual void CellModified();        // called whenever a cell has been modified
 970         virtual bool SaveModified();    // called whenever a cell should be left, and it's content should be saved
 971                                             // return sal_False prevents leaving the cell
 972         virtual bool SaveRow();         // commit the current row
 973
 974         virtual bool IsModified() const {return aController.is() && aController->IsValueChangedFromSaved();}
 975
 976         virtual CellController* GetController(sal_Int32 nRow, sal_uInt16 nCol);
 977         virtual void InitController(CellControllerRef& rController, sal_Int32 nRow, sal_uInt16 nCol);
 978         static void ResizeController(CellControllerRef const & rController, const tools::Rectangle&);
 979         virtual void DoubleClick(const BrowserMouseEvent&) override;
 980
 981         void ActivateCell() { ActivateCell(GetCurRow(), GetCurColumnId()); }
 982
 983         // retrieve the image for the row status
 984         Image GetImage(RowStatus) const;
 985
 986         // inserting columns
 987         // if you don't set a width, this will be calculated automatically
 988         // if the id isn't set the smallest unused will do it ...
 989         virtual sal_uInt16 AppendColumn(const OUString& rName, sal_uInt16 nWidth, sal_uInt16 nPos = HEADERBAR_APPEND, sal_uInt16 nId = sal_uInt16(-1));
 990
 991         // called whenever (Shift)Tab or Enter is pressed. If true is returned, these keys
 992         // result in traveling to the next or to th previous cell
 993         virtual bool IsTabAllowed(bool bForward) const;
 994
 995         virtual bool IsCursorMoveAllowed(sal_Int32 nNewRow, sal_uInt16 nNewColId) const override;
 996
 997         void    PaintTristate(const tools::Rectangle& rRect, const TriState& eState, bool _bEnabled=true) const;
 998
 999         void AsynchGetFocus();
1000             // secure starting of StartEditHdl
1001
1002     public:
1003         EditBrowseBox(vcl::Window* pParent, EditBrowseBoxFlags nBrowserFlags, WinBits nBits, BrowserMode nMode = BrowserMode::NONE );
1004         virtual ~EditBrowseBox() override;
1005         virtual void dispose() override;
1006
1007         bool IsEditing() const {return aController.is();}
1008         void InvalidateStatusCell(sal_Int32 nRow) {RowModified(nRow, 0);}
1009         void InvalidateHandleColumn();
1010
1011         // late construction
1012         virtual void Init();
1013         virtual void RemoveRows();
1014         virtual void Dispatch(sal_uInt16 nId);
1015
1016         const CellControllerRef& Controller() const { return aController; }
1017         EditBrowseBoxFlags  GetBrowserFlags() const { return m_nBrowserFlags; }
1018         void                SetBrowserFlags(EditBrowseBoxFlags nFlags);
1019
1020         virtual void ActivateCell(sal_Int32 nRow, sal_uInt16 nCol, bool bSetCellFocus = true);
1021         virtual void DeactivateCell(bool bUpdate = true);
1022         // Children ---------------------------------------------------------------
1023
1024         /** @return  The count of additional controls of the control area. */
1025         virtual sal_Int32 GetAccessibleControlCount() const override;
1026
1027         /** Creates the accessible object of an additional control.
1028             @param nIndex
1029                 The 0-based index of the control.
1030             @return
1031                 The XAccessible interface of the specified control. */
1032         virtual css::uno::Reference< css::accessibility::XAccessible >
1033         CreateAccessibleControl( sal_Int32 nIndex ) override;
1034
1035         /** Sets focus to current cell of the data table. */
1036         virtual void GrabTableFocus() override;
1037
1038         virtual tools::Rectangle GetFieldCharacterBounds(sal_Int32 _nRow,sal_Int32 _nColumnPos,sal_Int32 nIndex) override;
1039         virtual sal_Int32 GetFieldIndexAtPoint(sal_Int32 _nRow,sal_Int32 _nColumnPos,const Point& _rPoint) override;
1040
1041         virtual bool ProcessKey(const KeyEvent& rEvt) override;
1042
1043         virtual void ChildFocusIn() override;
1044         virtual void ChildFocusOut() override;
1045
1046         css::uno::Reference< css::accessibility::XAccessible > CreateAccessibleCheckBoxCell(sal_Int32 _nRow, sal_uInt16 _nColumnPos,const TriState& eState);
1047         bool ControlHasFocus() const;
1048     protected:
1049         // creates the accessible which wraps the active cell
1050         void    implCreateActiveAccessible( );
1051
1052     private:
1053         virtual void PaintField(vcl::RenderContext& rDev, const tools::Rectangle& rRect,
1054                                 sal_uInt16 nColumnId ) const override;
1055         using Control::ImplInitSettings;
1056         SVT_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground );
1057         SVT_DLLPRIVATE void DetermineFocus( const GetFocusFlags _nGetFocusFlags = GetFocusFlags::NONE);
1058         inline void EnableAndShow() const;
1059
1060         SVT_DLLPRIVATE void implActivateCellOnMouseEvent(const BrowserMouseEvent& _rEvt, bool _bUp);
1061
1062         DECL_DLLPRIVATE_LINK( ModifyHdl, LinkParamNone*, void );
1063         DECL_DLLPRIVATE_LINK( StartEditHdl, void*, void );
1064         DECL_DLLPRIVATE_LINK( EndEditHdl, void*, void );
1065         DECL_DLLPRIVATE_LINK( CellModifiedHdl, void*, void );
1066     };
1067
1068
1069 }   // namespace svt
1070
1071 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */