File: TextSelection.h

package info (click to toggle)
lsp-plugins 1.2.21-5
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 120,408 kB
  • sloc: cpp: 589,849; xml: 74,078; makefile: 13,396; php: 1,268; sh: 185
file content (133 lines) | stat: -rw-r--r-- 6,038 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
/*
 * Copyright (C) 2025 Linux Studio Plugins Project <https://lsp-plug.in/>
 *           (C) 2025 Vladimir Sadovnikov <sadko4u@gmail.com>
 *
 * This file is part of lsp-tk-lib
 * Created on: 9 июн. 2020 г.
 *
 * lsp-tk-lib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * any later version.
 *
 * lsp-tk-lib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with lsp-tk-lib. If not, see <https://www.gnu.org/licenses/>.
 */

#ifndef LSP_PLUG_IN_TK_PROP_MULTI_TEXTSELECTION_H_
#define LSP_PLUG_IN_TK_PROP_MULTI_TEXTSELECTION_H_

#ifndef LSP_PLUG_IN_TK_IMPL
    #error "use <lsp-plug.in/tk/tk.h>"
#endif

namespace lsp
{
    namespace tk
    {
        /**
         * Text Selection property.
         * Allows to control text selection in such widgets like Edit
         */
        class TextSelection: public MultiProperty
        {
            protected:
                enum property_t
                {
                    P_VALUE,
                    P_FIRST,
                    P_LAST,

                    P_COUNT
                };

            protected:
                static const prop::desc_t   DESC[];

            protected:
                atom_t              vAtoms[P_COUNT];    // Atom bindings
                ssize_t             nFirst;             // First element in selection
                ssize_t             nLast;              // Last element in selection
                ssize_t             nLimit;             // Selection limit, invisible property

            protected:
                virtual void        push() override;
                virtual void        commit(atom_t property) override;

                void                parse(const LSPString *s);

            protected:
                explicit TextSelection(prop::Listener *listener = NULL);
                TextSelection(const TextSelection &) = delete;
                TextSelection(TextSelection &&) = delete;
                virtual ~TextSelection() override;

                TextSelection & operator = (const TextSelection &) = delete;
                TextSelection & operator = (TextSelection &&) = delete;

            public:
                inline ssize_t      first() const               { return nFirst;                            }
                inline ssize_t      last() const                { return nLast;                             }
                inline bool         valid() const               { return (nFirst >= 0) && (nLast >= 0);     }
                inline bool         invalid() const             { return (nFirst < 0) || (nLast < 0);       }
                inline bool         is_empty() const            { return nFirst == nLast;                   }
                inline bool         non_empty() const           { return nFirst != nLast;                   }
                inline ssize_t      length() const              { return (nFirst < nLast) ? nLast - nFirst : nFirst - nLast; }
                inline bool         reverted() const            { return nFirst > nLast;                    }
                inline ssize_t      starting() const            { return lsp_min(nFirst, nLast);            }
                inline ssize_t      ending() const              { return lsp_max(nFirst, nLast);            }
                inline ssize_t      limit() const               { return nLimit;                            }

                void                set(ssize_t first, ssize_t last);
                void                set(ssize_t first);
                ssize_t             set_first(ssize_t value);
                ssize_t             set_last(ssize_t value);
                void                set_all();
                void                truncate();
                void                unset();
                inline void         clear()                     { unset();                                  }
        };

        namespace prop
        {
            /**
             * TextSelection property implementation
             */
            class TextSelection: public tk::TextSelection
            {
                public:
                    explicit TextSelection(prop::Listener *listener = NULL): tk::TextSelection(listener) {};
                    TextSelection(const TextSelection &) = delete;
                    TextSelection(TextSelection &&) = delete;

                    TextSelection & operator = (const TextSelection &) = delete;
                    TextSelection & operator = (TextSelection &&) = delete;

                public:
                    void                set_limit(ssize_t limit);

                    /**
                     * Bind property with specified name to the style of linked widget
                     */
                    inline status_t     bind(atom_t property, Style *style)             { return tk::TextSelection::bind(property, style, vAtoms, DESC, &sListener); }
                    inline status_t     bind(const char *property, Style *style)        { return tk::TextSelection::bind(property, style, vAtoms, DESC, &sListener); }
                    inline status_t     bind(const LSPString *property, Style *style)   { return tk::TextSelection::bind(property, style, vAtoms, DESC, &sListener); }

                    /**
                     * Unbind property
                     */
                    inline status_t     unbind()                                        { return tk::TextSelection::unbind(vAtoms, DESC, &sListener); };
            };

        } /* namespace prop */
    } /* namespace tk */
} /* namespace lsp */



#endif /* LSP_PLUG_IN_TK_PROP_MULTI_TEXTSELECTION_H_ */