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