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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#ifndef SD_TOOLPANEL_CONTROL_CONTAINER_HXX
#define SD_TOOLPANEL_CONTROL_CONTAINER_HXX
#include <osl/mutex.hxx>
#include <vector>
#include <memory>
namespace sd { namespace toolpanel {
class TreeNode;
/** This container manages the children of a TreeNode. It handles the
expansion and visibility state of its child controls. The container
does not do the layouting or painting of the controls. Instead it asks
its owner to do that.
The difference between expansion state and visibility is that when a
control is collapsed at least a title bar is shown for it. When it is
not visible then even this title bar is not shown. In that case the
user can not expand the control. A control has to be visible in order
to be expanded or collapsed.
Whenever you expand or collapse, show or hide a child control then use
this container class. Do not call the respective methods of the child
directly.
*/
class ControlContainer
{
public:
enum VisibilityState { VS_SHOW, VS_HIDE, VS_TOGGLE };
enum ExpansionState { ES_EXPAND, ES_COLLAPSE, ES_TOGGLE };
/** Create a new control container.
@param pParent
This node is asked to re-calculate the size of its children when
a child of this container is expanded or collapsed.
*/
ControlContainer (TreeNode* pNode);
virtual ~ControlContainer (void);
/** This is function makes sure that all children are deleted. Call
this function from the destructor of a sub class to have all child
windows deleted before the destructor of another base class of that
sub class is called. When that other base class is some kind of a
window it would otherwise complain that there are living children.
*/
void DeleteChildren (void);
/** Add the given control to the set of controls managed by the
container. This control is then expanded.
@return
Return the index under which the control has been inserted in
the container. It is the same index that is returned by
GetControlIndex().
*/
sal_uInt32 AddControl (::std::auto_ptr<TreeNode> pControl);
/** Expand (default) or collapse the specified control. When
expanding a control in a single expansion environment then all
other controls are collapsed. The specified control is being
made the active control as returned by GetActiveControl().
*/
virtual void SetExpansionState (
sal_uInt32 nIndex,
ExpansionState aState);
virtual void SetExpansionState (
TreeNode* pControl,
ExpansionState aState);
virtual void SetVisibilityState (
sal_uInt32 nIndex,
VisibilityState aState);
/** Return the index of the given control.
*/
sal_uInt32 GetControlIndex (TreeNode* pControl) const;
/** Return the number of controls in the container.
*/
sal_uInt32 GetControlCount (void) const;
/** Return the number of visible controls in the container.
*/
sal_uInt32 GetVisibleControlCount (void) const;
/** Return the control with the specified index regardless of whether
that control is hidden or visible.
*/
TreeNode* GetControl (sal_uInt32 nIndex) const;
/** Return the index of the control previous to that that is specified
by the given index.
@param nIndex
Index of the control for which to return the index of the
previous control. This index is guaranteed not to be returned.
@param bIncludeHidden
This flag tells the method whether to include the controls that
are not visible in the search for the previous control. When it
is <FALSE/> the hidden controls are skipped.
@param bCycle
When this flag is <TRUE/> then the search for the previous
control wraps arround when reaching the first control.
@return
Returns the index to the previous control or (sal_uInt32)-1 when
there is no previous control. This would be the case when there
is only one (visible) child.
*/
sal_uInt32 GetPreviousIndex (
sal_uInt32 nIndex,
bool bIncludeHidden=false,
bool bCycle=false) const;
/** Return the index of the control next to that that is specified by
the given index.
@param nIndex
Index of the control for which to return the index of the next
control. This index is guaranteed not to be returned.
@param bIncludeHidden
This flag tells the method whether to include the controls that
are not visible in the search for the next control. When it is
<FALSE/> the hidden controls are skipped.
@param bCycle
When this flag is <TRUE/> then the search for the next control
wraps arround when reaching the last control.
@return
Returns the index to the next control or (sal_uInt32)-1 when
there is no next control. This would be the case when there is
only one (visible) child.
*/
sal_uInt32 GetNextIndex (
sal_uInt32 nIndex,
bool bIncludeHidden=false,
bool bCycle=false) const;
void SetMultiSelection (bool bFlag);
/** This is method is called when the list of controls has changed,
i.e. a new control has been added. The default implementation is
empty. Overwrite this method in derived classes in order to react to
such changes.
*/
virtual void ListHasChanged (void);
private:
osl::Mutex maMutex;
/// List of controls managed by a container.
typedef ::std::vector<TreeNode*> ControlList;
ControlList maControlList;
/** This parent is used for resize requests when children are expanded
or collapsed.
*/
TreeNode* mpNode;
/** The index of the currently expanded control. A value of
(sal_uInt32)-1 indicates that no control is active. This may be the
case after adding controls to the container.
*/
sal_uInt32 mnActiveControlIndex;
bool mbMultiSelection;
};
} } // end of namespace ::sd::toolpanel
#endif
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
