xref: /haiku/src/kits/tracker/Utilities.h (revision b247f935d133a42c427cad8a759a1bf2f65bc290)
1 /*
2 Open Tracker License
3 
4 Terms and Conditions
5 
6 Copyright (c) 1991-2000, Be Incorporated. All rights reserved.
7 
8 Permission is hereby granted, free of charge, to any person obtaining a copy of
9 this software and associated documentation files (the "Software"), to deal in
10 the Software without restriction, including without limitation the rights to
11 use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
12 of the Software, and to permit persons to whom the Software is furnished to do
13 so, subject to the following conditions:
14 
15 The above copyright notice and this permission notice applies to all licensees
16 and shall be included in all copies or substantial portions of the Software.
17 
18 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
20 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
23 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
24 
25 Except as contained in this notice, the name of Be Incorporated shall not be
26 used in advertising or otherwise to promote the sale, use or other dealings in
27 this Software without prior written authorization from Be Incorporated.
28 
29 Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
30 of Be Incorporated in the United States and other countries. Other brand product
31 names are registered trademarks or trademarks of their respective holders.
32 All rights reserved.
33 */
34 #ifndef _UTILITIES_H
35 #define _UTILITIES_H
36 
37 
38 #include <ctype.h>
39 #include <stdarg.h>
40 #include <stdlib.h>
41 
42 #include <Bitmap.h>
43 #include <ByteOrder.h>
44 #include <DataIO.h>
45 #include <Directory.h>
46 #include <Entry.h>
47 #include <GraphicsDefs.h>
48 #include <Looper.h>
49 #include <MenuItem.h>
50 #include <MessageFilter.h>
51 #include <Mime.h>
52 #include <NaturalCompare.h>
53 #include <ObjectList.h>
54 #include <Point.h>
55 #include <Path.h>
56 #include <String.h>
57 #include <StringView.h>
58 
59 
60 class BMessage;
61 class BTextView;
62 class BView;
63 class BVolume;
64 
65 namespace BPrivate {
66 
67 class Benaphore;
68 class BPose;
69 class BPoseView;
70 
71 // global variables
72 static const rgb_color kBlack = {0, 0, 0, 255};
73 static const rgb_color kWhite = {255, 255, 255 ,255};
74 
75 const int64 kHalfKBSize = 512;
76 const int64 kKBSize = 1024;
77 const int64 kMBSize = 1048576;
78 const int64 kGBSize = 1073741824;
79 const int64 kTBSize = kGBSize * kKBSize;
80 
81 const int32 kMiniIconSeparator = 3;
82 const int32 kLargeIconSeparator = 6;
83 
84 const color_space kDefaultIconDepth = B_RGBA32;
85 
86 
87 extern bool gLocalizedNamePreferred;
88 
89 
90 // misc typedefs, constants and structs
91 
92 class PeriodicUpdatePoses {
93 	// Periodically updated poses (ones with a volume space bar) register
94 	// themselfs in this global list. This way they can be iterated over instead
95 	// of sending around update messages.
96 public:
97 	PeriodicUpdatePoses();
98 	~PeriodicUpdatePoses();
99 
100 	typedef bool (*PeriodicUpdateCallback)(BPose* pose, void* cookie);
101 
102 	void AddPose(BPose* pose, BPoseView* poseView,
103 		PeriodicUpdateCallback callback, void* cookie);
104 	bool RemovePose(BPose* pose, void** cookie);
105 
106 	void DoPeriodicUpdate(bool forceRedraw);
107 
108 private:
109 	struct periodic_pose {
110 		BPose*					pose;
111 		BPoseView*				pose_view;
112 		PeriodicUpdateCallback	callback;
113 		void*					cookie;
114 	};
115 
116 	Benaphore* fLock;
117 	BObjectList<periodic_pose> fPoseList;
118 };
119 
120 extern PeriodicUpdatePoses gPeriodicUpdatePoses;
121 
122 
123 class PoseInfo {
124 	// PoseInfo is the structure that gets saved as attributes for every node
125 	// on disk, defining the node's position and visibility
126 public:
127 	static void EndianSwap(void* castToThis);
128 	void PrintToStream();
129 
130 	bool fInvisible;
131 	ino_t fInitedDirectory;
132 		// For a location to be valid, fInitedDirectory has to contain
133 		// the inode of the items parent directory. This makes it
134 		// impossible to for instance zip up files and extract them in
135 		// the same location. This should probably be reworked.
136 		// Tracker could strip the file location attributes when dropping
137 		// files into a closed folder.
138 	BPoint fLocation;
139 };
140 
141 
142 class ExtendedPoseInfo {
143 	// extends PoseInfo adding workspace support; used for desktop
144 	// poses only
145 public:
146 	size_t Size() const;
147 	static size_t Size(int32);
148 	size_t SizeWithHeadroom() const;
149 	static size_t SizeWithHeadroom(size_t);
150 	bool HasLocationForFrame(BRect) const;
151 	BPoint LocationForFrame(BRect) const;
152 	bool SetLocationForFrame(BPoint, BRect);
153 
154 	static void EndianSwap(void* castToThis);
155 	void PrintToStream();
156 
157 	uint32 fWorkspaces;
158 	bool fInvisible;
159 	bool fShowFromBootOnly;
160 	bool fReservedBool1;
161 	bool fReservedBool2;
162 	int32 fReservedInt1;
163 	int32 fReservedInt2;
164 	int32 fReservedInt3;
165 	int32 fReservedInt4;
166 	int32 fReservedInt5;
167 
168 	int32 fNumFrames;
169 	struct FrameLocation {
170 		BPoint fLocation;
171 		BRect fFrame;
172 		uint32 fWorkspaces;
173 	};
174 
175 	FrameLocation fLocations[0];
176 };
177 
178 // misc functions
179 void DisallowMetaKeys(BTextView*);
180 void DisallowFilenameKeys(BTextView*);
181 
182 
183 bool ValidateStream(BMallocIO*, uint32, int32 version);
184 
185 
186 bool SecondaryMouseButtonDown(int32 modifiers, int32 buttons);
187 uint32 HashString(const char* string, uint32 seed);
188 uint32 AttrHashString(const char* string, uint32 type);
189 
190 
191 class OffscreenBitmap {
192 	// a utility class for setting up offscreen bitmaps
193 	public:
194 		OffscreenBitmap(BRect bounds);
195 		OffscreenBitmap();
196 		~OffscreenBitmap();
197 
198 		BView* BeginUsing(BRect bounds);
199 		void DoneUsing();
200 		BBitmap* Bitmap() const;
201 			// blit this to your view when you are done rendering
202 		BView* View() const;
203 			// use this to render your image
204 
205 	private:
206 		void NewBitmap(BRect frame);
207 		BBitmap* fBitmap;
208 };
209 
210 
211 // bitmap functions
212 extern void FadeRGBA32Horizontal(uint32* bits, int32 width, int32 height,
213 	int32 from, int32 to);
214 extern void FadeRGBA32Vertical(uint32* bits, int32 width, int32 height,
215 	int32 from, int32 to);
216 
217 
218 class FlickerFreeStringView : public BStringView {
219 	// adds support for offscreen bitmap drawing for string views that update
220 	// often this would be better implemented as an option of BStringView
221 public:
222 	FlickerFreeStringView(BRect bounds, const char* name,
223 		const char* text, uint32 resizingMode = B_FOLLOW_LEFT | B_FOLLOW_TOP,
224 		uint32 flags = B_WILL_DRAW);
225 	FlickerFreeStringView(BRect bounds, const char* name,
226 		const char* text, BBitmap* existingOffscreen,
227 		uint32 resizingMode = B_FOLLOW_LEFT | B_FOLLOW_TOP,
228 		uint32 flags = B_WILL_DRAW);
229 	virtual ~FlickerFreeStringView();
230 	virtual void Draw(BRect);
231 	virtual void AttachedToWindow();
232 	virtual void SetViewColor(rgb_color);
233 	virtual void SetLowColor(rgb_color);
234 
235 private:
236 	OffscreenBitmap* fBitmap;
237 	rgb_color fViewColor;
238 	rgb_color fLowColor;
239 	BBitmap* fOriginalBitmap;
240 
241 	typedef BStringView _inherited;
242 };
243 
244 
245 class DraggableIcon : public BView {
246 	// used to determine a save location for a file
247 public:
248 	DraggableIcon(BRect rect, const char* name, const char* mimeType,
249 		icon_size which, const BMessage* message, BMessenger target,
250 		uint32 resizingMode = B_FOLLOW_LEFT | B_FOLLOW_TOP,
251 		uint32 flags = B_WILL_DRAW);
252 	virtual ~DraggableIcon();
253 
254 	static BRect PreferredRect(BPoint offset, icon_size which);
255 	void SetTarget(BMessenger);
256 
257 protected:
258 	virtual void AttachedToWindow();
259 	virtual void MouseDown(BPoint);
260 	virtual void Draw(BRect);
261 
262 	virtual bool DragStarted(BMessage* dragMessage);
263 
264 protected:
265 	BBitmap* fBitmap;
266 	BMessage fMessage;
267 	BMessenger fTarget;
268 };
269 
270 
271 class PositionPassingMenuItem : public BMenuItem {
272 public:
273 	PositionPassingMenuItem(const char* title, BMessage*,
274 		char shortcut = 0, uint32 modifiers = 0);
275 	PositionPassingMenuItem(BMenu*, BMessage*);
276 	PositionPassingMenuItem(BMessage* data);
277 
278 	static BArchivable* Instantiate(BMessage* data);
279 
280 protected:
281 	virtual status_t Invoke(BMessage* = 0);
282 		// appends the invoke location for NewFolder, etc. to use
283 
284 private:
285 	typedef BMenuItem _inherited;
286 };
287 
288 
289 class Benaphore {
290 	// aka benaphore
291 public:
292 	Benaphore(const char* name = "Light Lock")
293 	:	fSemaphore(create_sem(0, name)),
294 		fCount(1)
295 	{
296 	}
297 
298 	~Benaphore()
299 	{
300 		delete_sem(fSemaphore);
301 	}
302 
303 	bool Lock()
304 	{
305 		if (atomic_add(&fCount, -1) <= 0)
306 			return acquire_sem(fSemaphore) == B_OK;
307 
308 		return true;
309 	}
310 
311 	void Unlock()
312 	{
313 		if (atomic_add(&fCount, 1) < 0)
314 			release_sem(fSemaphore);
315 	}
316 
317 	bool IsLocked() const
318 	{
319 		return fCount <= 0;
320 	}
321 
322 private:
323 	sem_id fSemaphore;
324 	int32 fCount;
325 };
326 
327 
328 class SeparatorLine : public BView {
329 public:
330 	SeparatorLine(BPoint, float, bool vertical, const char* name = "");
331 	virtual void Draw(BRect bounds);
332 };
333 
334 
335 class TitledSeparatorItem : public BMenuItem {
336 public:
337 	TitledSeparatorItem(const char*);
338 	virtual ~TitledSeparatorItem();
339 
340 	virtual void SetEnabled(bool state);
341 
342 protected:
343 	virtual void GetContentSize(float* width, float* height);
344 	virtual void Draw();
345 
346 private:
347 	typedef BMenuItem _inherited;
348 };
349 
350 
351 class LooperAutoLocker {
352 public:
353 	LooperAutoLocker(BHandler* handler)
354 	:	fHandler(handler),
355 		fHasLock(handler->LockLooper())
356 	{
357 	}
358 
359 	~LooperAutoLocker()
360 	{
361 		if (fHasLock)
362 			fHandler->UnlockLooper();
363 	}
364 
365 	bool operator!() const
366 	{
367 		return !fHasLock;
368 	}
369 
370 	bool IsLocked() const
371 	{
372 		return fHasLock;
373 	}
374 
375 private:
376 	BHandler* fHandler;
377 	bool fHasLock;
378 };
379 
380 
381 class ShortcutFilter : public BMessageFilter {
382 public:
383 	ShortcutFilter(uint32 shortcutKey, uint32 shortcutModifier,
384 		uint32 shortcutWhat, BHandler* target);
385 
386 protected:
387 	filter_result Filter(BMessage*, BHandler**);
388 
389 private:
390 	uint32 fShortcutKey;
391 	uint32 fShortcutModifier;
392 	uint32 fShortcutWhat;
393 	BHandler* fTarget;
394 };
395 
396 
397 // iterates over all the refs in a message
398 entry_ref* EachEntryRef(BMessage*, entry_ref* (*)(entry_ref*, void*),
399 	void* passThru = 0);
400 const entry_ref* EachEntryRef(const BMessage*,
401 	const entry_ref* (*)(const entry_ref*, void*), void* passThru = 0);
402 
403 entry_ref* EachEntryRef(BMessage*, entry_ref* (*)(entry_ref*, void*),
404 	void* passThru, int32 maxCount);
405 const entry_ref* EachEntryRef(const BMessage*,
406 	const entry_ref* (*)(const entry_ref*, void*), void* passThru,
407 	int32 maxCount);
408 
409 
410 bool ContainsEntryRef(const BMessage*, const entry_ref*);
411 int32 CountRefs(const BMessage*);
412 
413 BMenuItem* EachMenuItem(BMenu* menu, bool recursive,
414 	BMenuItem* (*func)(BMenuItem*));
415 const BMenuItem* EachMenuItem(const BMenu* menu, bool recursive,
416 	BMenuItem* (*func)(const BMenuItem*));
417 
418 int64 StringToScalar(const char* text);
419 	// string to num, understands kB, MB, etc.
420 
421 // misc calls
422 void EmbedUniqueVolumeInfo(BMessage* message, const BVolume* volume);
423 status_t MatchArchivedVolume(BVolume* volume, const BMessage* message,
424 	int32 index = 0);
425 void TruncateLeaf(BString* string);
426 
427 void StringFromStream(BString*, BMallocIO*, bool endianSwap = false);
428 void StringToStream(const BString*, BMallocIO*);
429 int32 ArchiveSize(const BString*);
430 
431 extern void EnableNamedMenuItem(BMenu* menu, const char* itemName, bool on);
432 extern void MarkNamedMenuItem(BMenu* menu, const char* itemName, bool on);
433 extern void EnableNamedMenuItem(BMenu* menu, uint32 commandName, bool on);
434 extern void MarkNamedMenuItem(BMenu* menu, uint32 commandName, bool on);
435 extern void DeleteSubmenu(BMenuItem* submenuItem);
436 
437 extern bool BootedInSafeMode();
438 
439 
440 inline rgb_color
441 Color(int32 r, int32 g, int32 b, int32 alpha = 255)
442 {
443 	rgb_color result;
444 	result.red = (uchar)r;
445 	result.green = (uchar)g;
446 	result.blue = (uchar)b;
447 	result.alpha = (uchar)alpha;
448 
449 	return result;
450 }
451 
452 void PrintToStream(rgb_color color);
453 
454 template <class InitCheckable>
455 void
456 ThrowOnInitCheckError(InitCheckable* item)
457 {
458 	if (item == NULL)
459 		throw (status_t)B_ERROR;
460 
461 	status_t result = item->InitCheck();
462 	if (result != B_OK)
463 		throw (status_t)result;
464 }
465 
466 #if DEBUG
467 #	define ThrowOnError(x) _ThrowOnError(x, __FILE__, __LINE__)
468 #	define ThrowIfNotSize(x) _ThrowIfNotSize(x, __FILE__, __LINE__)
469 #	define ThrowOnAssert(x) _ThrowOnAssert(x, __FILE__, __LINE__)
470 #else
471 #	define ThrowOnError(x) _ThrowOnError(x, NULL, 0)
472 #	define ThrowIfNotSize(x) _ThrowIfNotSize(x, NULL, 0)
473 #	define ThrowOnAssert(x) _ThrowOnAssert(x, NULL, 0)
474 #endif
475 
476 void _ThrowOnError(status_t, const char*, int32);
477 void _ThrowIfNotSize(ssize_t, const char*, int32);
478 void _ThrowOnAssert(bool, const char*, int32);
479 
480 // stub calls that work around BAppFile info inefficiency
481 status_t GetAppSignatureFromAttr(BFile*, char*);
482 status_t GetAppIconFromAttr(BFile* file, BBitmap* icon, icon_size which);
483 status_t GetFileIconFromAttr(BNode* node, BBitmap* icon, icon_size which);
484 
485 // debugging
486 void HexDump(const void* buffer, int32 length);
487 
488 #if xDEBUG
489 
490 inline void
491 PrintRefToStream(const entry_ref* ref, const char* trailer = "\n")
492 {
493 	if (ref == NULL) {
494 		PRINT(("NULL entry_ref%s", trailer));
495 		return;
496 	}
497 
498 	BPath path;
499 	BEntry entry(ref);
500 	entry.GetPath(&path);
501 	PRINT(("%s%s", path.Path(), trailer));
502 }
503 
504 
505 inline void
506 PrintEntryToStream(const BEntry* entry, const char* trailer = "\n")
507 {
508 	if (entry == NULL) {
509 		PRINT(("NULL entry%s", trailer));
510 		return;
511 	}
512 
513 	BPath path;
514 	entry->GetPath(&path);
515 	PRINT(("%s%s", path.Path(), trailer));
516 }
517 
518 
519 inline void
520 PrintDirToStream(const BDirectory* dir, const char* trailer = "\n")
521 {
522 	if (dir == NULL) {
523 		PRINT(("NULL entry_ref%s", trailer));
524 		return;
525 	}
526 
527 	BPath path;
528 	BEntry entry;
529 	dir->GetEntry(&entry);
530 	entry.GetPath(&path);
531 	PRINT(("%s%s", path.Path(), trailer));
532 }
533 
534 #else
535 
536 inline void PrintRefToStream(const entry_ref*, const char* = 0) {}
537 inline void PrintEntryToStream(const BEntry*, const char* = 0) {}
538 inline void PrintDirToStream(const BDirectory*, const char* = 0) {}
539 
540 #endif
541 
542 #ifdef xDEBUG
543 
544 	extern FILE* logFile;
545 
546 	inline void PrintToLogFile(const char* format, ...)
547 	{
548 		va_list ap;
549 		va_start(ap, fmt);
550 		vfprintf(logFile, fmt, ap);
551 		va_end(ap);
552 	}
553 
554 #define WRITELOG(_ARGS_)													\
555 	if (logFile == 0) 														\
556 		logFile = fopen("/var/log/tracker.log", "a+");						\
557 																			\
558 	if (logFile != 0) {														\
559 		thread_info info;													\
560 		get_thread_info(find_thread(NULL), &info);							\
561 		PrintToLogFile("[t %Ld] \"%s\" (%s:%i) ", system_time(),			\
562 			info.name, __FILE__, __LINE__);									\
563 		PrintToLogFile _ARGS_;												\
564 		PrintToLogFile("\n");												\
565 		fflush(logFile);													\
566 	}
567 
568 #else
569 
570 #define WRITELOG(_ARGS_)
571 
572 #endif
573 
574 // fancy casting macros
575 
576 template <typename NewType, typename OldType>
577 inline NewType assert_cast(OldType castedPointer) {
578 	ASSERT(dynamic_cast<NewType>(castedPointer) != NULL);
579 	return static_cast<NewType>(castedPointer);
580 }
581 
582 // B_SWAP_INT32 have broken signedness, simple cover calls to fix that
583 // should fix up in ByteOrder.h
584 
585 inline int32 SwapInt32(int32 value)
586 	{ return (int32)B_SWAP_INT32((uint32)value); }
587 inline uint32 SwapUInt32(uint32 value) { return B_SWAP_INT32(value); }
588 inline int64 SwapInt64(int64 value)
589 	{ return (int64)B_SWAP_INT64((uint64)value); }
590 inline uint64 SwapUInt64(uint64 value) { return B_SWAP_INT64(value); }
591 
592 
593 extern const float kExactMatchScore;
594 float ComputeTypeAheadScore(const char* text, const char* match,
595 	bool wordMode = false);
596 
597 } // namespace BPrivate
598 
599 
600 #endif	// _UTILITIES_H
601