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
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
|
/**
* @file llinventoryfilter.h
* @brief Support for filtering your inventory to only display a subset of the
* available items.
*
* $LicenseInfo:firstyear=2005&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
*
* This library 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;
* version 2.1 of the License only.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
#ifndef LLINVENTORYFILTER_H
#define LLINVENTORYFILTER_H
#include "llinventorytype.h"
#include "llpermissionsflags.h"
#include "llfolderviewmodel.h"
class LLFolderViewItem;
class LLFolderViewFolder;
class LLInventoryItem;
class LLInventoryFilter : public LLFolderViewFilter
{
public:
enum EFolderShow
{
SHOW_ALL_FOLDERS,
SHOW_NON_EMPTY_FOLDERS,
SHOW_NO_FOLDERS
};
enum EFilterType {
FILTERTYPE_NONE = 0,
FILTERTYPE_OBJECT = 0x1 << 0, // normal default search-by-object-type
FILTERTYPE_CATEGORY = 0x1 << 1, // search by folder type
FILTERTYPE_UUID = 0x1 << 2, // find the object with UUID and any links to it
FILTERTYPE_DATE = 0x1 << 3, // search by date range
FILTERTYPE_WEARABLE = 0x1 << 4, // search by wearable type
FILTERTYPE_EMPTYFOLDERS = 0x1 << 5 // pass if folder is not a system folder to be hidden if
};
enum EFilterDateDirection
{
FILTERDATEDIRECTION_NEWER,
FILTERDATEDIRECTION_OLDER
};
enum EFilterLink
{
FILTERLINK_INCLUDE_LINKS, // show links too
FILTERLINK_EXCLUDE_LINKS, // don't show links
FILTERLINK_ONLY_LINKS // only show links
};
enum ESortOrderType
{
SO_NAME = 0, // Sort inventory by name
SO_DATE = 0x1, // Sort inventory by date
SO_FOLDERS_BY_NAME = 0x1 << 1, // Force folder sort by name
SO_SYSTEM_FOLDERS_TO_TOP = 0x1 << 2 // Force system folders to be on top
};
struct FilterOps
{
struct DateRange : public LLInitParam::Block<DateRange>
{
Optional<time_t> min_date,
max_date;
DateRange()
: min_date("min_date", time_min()),
max_date("max_date", time_max())
{}
bool validateBlock(bool emit_errors = true) const;
};
struct Params : public LLInitParam::Block<Params>
{
Optional<U32> types;
Optional<U64> object_types,
wearable_types,
category_types;
Optional<EFilterLink> links;
Optional<LLUUID> uuid;
Optional<DateRange> date_range;
Optional<U32> hours_ago;
Optional<U32> date_search_direction;
Optional<EFolderShow> show_folder_state;
Optional<PermissionMask> permissions;
Params()
: types("filter_types", FILTERTYPE_OBJECT),
object_types("object_types", 0xffffFFFFffffFFFFULL),
wearable_types("wearable_types", 0xffffFFFFffffFFFFULL),
category_types("category_types", 0xffffFFFFffffFFFFULL),
links("links", FILTERLINK_INCLUDE_LINKS),
uuid("uuid"),
date_range("date_range"),
hours_ago("hours_ago", 0),
date_search_direction("date_search_direction", FILTERDATEDIRECTION_NEWER),
show_folder_state("show_folder_state", SHOW_NON_EMPTY_FOLDERS),
permissions("permissions", PERM_NONE)
{}
};
FilterOps(const Params& = Params());
U32 mFilterTypes;
U64 mFilterObjectTypes, // For _OBJECT
mFilterWearableTypes,
mFilterLinks,
mFilterCategoryTypes; // For _CATEGORY
LLUUID mFilterUUID; // for UUID
time_t mMinDate,
mMaxDate;
U32 mHoursAgo;
U32 mDateSearchDirection;
EFolderShow mShowFolderState;
PermissionMask mPermissions;
};
struct Params : public LLInitParam::Block<Params>
{
Optional<std::string> name;
Optional<FilterOps::Params> filter_ops;
Optional<std::string> substring;
Optional<bool> since_logoff;
Params()
: name("name"),
filter_ops(""),
substring("substring"),
since_logoff("since_logoff")
{}
};
LLInventoryFilter(const Params& p = Params());
LLInventoryFilter(const LLInventoryFilter& other) { *this = other; }
virtual ~LLInventoryFilter() {}
// +-------------------------------------------------------------------+
// + Parameters
// +-------------------------------------------------------------------+
U64 getFilterTypes() const;
U64 getFilterObjectTypes() const;
U64 getFilterCategoryTypes() const;
U64 getFilterWearableTypes() const;
bool isFilterObjectTypesWith(LLInventoryType::EType t) const;
void setFilterObjectTypes(U64 types);
void setFilterCategoryTypes(U64 types);
void setFilterUUID(const LLUUID &object_id);
void setFilterWearableTypes(U64 types);
void setFilterEmptySystemFolders();
void updateFilterTypes(U64 types, U64& current_types);
void setFilterSubString(const std::string& string);
const std::string& getFilterSubString(BOOL trim = FALSE) const;
const std::string& getFilterSubStringOrig() const { return mFilterSubStringOrig; }
bool hasFilterString() const;
void setFilterPermissions(PermissionMask perms);
PermissionMask getFilterPermissions() const;
void setDateRange(time_t min_date, time_t max_date);
void setDateRangeLastLogoff(BOOL sl);
time_t getMinDate() const;
time_t getMaxDate() const;
void setHoursAgo(U32 hours);
U32 getHoursAgo() const;
void setDateSearchDirection(U32 direction);
U32 getDateSearchDirection() const;
void setFilterLinks(U64 filter_link);
U64 getFilterLinks() const;
// sets params for Link-only search and backs up search settings for future restoration
void setFindAllLinksMode(const std::string &search_name, const LLUUID& search_id);
// +-------------------------------------------------------------------+
// + Execution And Results
// +-------------------------------------------------------------------+
bool check(const LLFolderViewModelItem* listener);
bool check(const LLInventoryItem* item);
bool checkFolder(const LLFolderViewModelItem* listener) const;
bool checkFolder(const LLUUID& folder_id) const;
bool showAllResults() const;
std::string::size_type getStringMatchOffset(LLFolderViewModelItem* item) const;
std::string::size_type getFilterStringSize() const;
// +-------------------------------------------------------------------+
// + Presentation
// +-------------------------------------------------------------------+
void setShowFolderState( EFolderShow state);
EFolderShow getShowFolderState() const;
void setEmptyLookupMessage(const std::string& message);
std::string getEmptyLookupMessage() const;
// +-------------------------------------------------------------------+
// + Status
// +-------------------------------------------------------------------+
bool isActive() const;
bool isModified() const;
bool isSinceLogoff() const;
void clearModified();
const std::string& getName() const { return mName; }
const std::string& getFilterText();
//RN: this is public to allow system to externally force a global refilter
void setModified(EFilterModified behavior = FILTER_RESTART);
// +-------------------------------------------------------------------+
// + Time
// +-------------------------------------------------------------------+
void resetTime(S32 timeout);
bool isTimedOut();
// +-------------------------------------------------------------------+
// + Default
// +-------------------------------------------------------------------+
bool isDefault() const;
bool isNotDefault() const;
void markDefault();
void resetDefault();
// +-------------------------------------------------------------------+
// + Generation
// +-------------------------------------------------------------------+
S32 getCurrentGeneration() const;
S32 getFirstSuccessGeneration() const;
S32 getFirstRequiredGeneration() const;
// +-------------------------------------------------------------------+
// + Conversion
// +-------------------------------------------------------------------+
void toParams(Params& params) const;
void fromParams(const Params& p);
LLInventoryFilter& operator =(const LLInventoryFilter& other);
private:
bool areDateLimitsSet();
bool checkAgainstFilterType(const class LLFolderViewModelItemInventory* listener) const;
bool checkAgainstFilterType(const LLInventoryItem* item) const;
bool checkAgainstPermissions(const class LLFolderViewModelItemInventory* listener) const;
bool checkAgainstPermissions(const LLInventoryItem* item) const;
bool checkAgainstFilterLinks(const class LLFolderViewModelItemInventory* listener) const;
bool checkAgainstClipboard(const LLUUID& object_id) const;
FilterOps mFilterOps;
FilterOps mDefaultFilterOps;
FilterOps mBackupFilterOps; // for backup purposes when leaving 'search link' mode
std::string mFilterSubString;
std::string mFilterSubStringOrig;
const std::string mName;
S32 mCurrentGeneration;
// The following makes checking for pass/no pass possible even if the item is not checked against the current generation
// Any item that *did not pass* the "required generation" will *not pass* the current one
// Any item that *passes* the "success generation" will *pass* the current one
S32 mFirstRequiredGeneration;
S32 mFirstSuccessGeneration;
EFilterModified mFilterModified;
LLTimer mFilterTime;
std::string mFilterText;
std::string mEmptyLookupMessage;
};
#endif
|
