xref: /haiku/src/kits/tracker/PoseView.h (revision 6c2abee2f5e73c3fc81c33da51ac610f8bf1117a) 
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 _POSE_VIEW_H
35 #define _POSE_VIEW_H
36 
37 
38 // BPoseView is a container for poses, handling all of the interaction, drawing,
39 // etc. The three different view modes are handled here.
40 //
41 // this is by far the fattest Tracker class and over time will undergo a lot of
42 // trimming
43 
44 
45 #include "AttributeStream.h"
46 #include "ContainerWindow.h"
47 #include "Model.h"
48 #include "PendingNodeMonitorCache.h"
49 #include "PoseList.h"
50 #include "TitleView.h"
51 #include "Utilities.h"
52 #include "ViewState.h"
53 
54 #include <Directory.h>
55 #include <FilePanel.h>
56 #include <MessageRunner.h>
57 #include <String.h>
58 #include <ScrollBar.h>
59 #include <View.h>
60 #include <hash_set>
61 #include <set>
62 
63 
64 class BRefFilter;
65 class BList;
66 
67 #if __GNUC__ > 2
68 namespace __gnu_cxx {
69 template<>
70 struct hash<node_ref>
71 #else
72 template<>
73 struct std::hash<node_ref>
74 #endif
75 {
76 	size_t
77 	operator()(node_ref ref) const
78 	{
79 		return ref.node;
80 	}
81 };
82 #if __GNUC__ > 2
83 } // namespace __gnu_cxx
84 typedef __gnu_cxx::hash_set<node_ref, __gnu_cxx::hash<node_ref> > NodeSet;
85 #else
86 typedef std::hash_set<node_ref, std::hash<node_ref> > NodeSet;
87 #endif
88 
89 
90 namespace BPrivate {
91 
92 class BCountView;
93 class BContainerWindow;
94 class EntryListBase;
95 class TScrollBar;
96 
97 
98 const int32 kSmallStep = 10;
99 const int32 kListOffset = 20;
100 
101 const uint32 kMiniIconMode = 'Tmic';
102 const uint32 kIconMode = 'Ticn';
103 const uint32 kListMode = 'Tlst';
104 
105 const uint32 kCheckTypeahead = 'Tcty';
106 
107 class BPoseView : public BView {
108 public:
109 	BPoseView(Model*, uint32 viewMode);
110 	virtual ~BPoseView();
111 
112 	// setup, teardown
113 	virtual void Init(AttributeStreamNode*);
114 	virtual void Init(const BMessage&);
115 	void InitCommon();
116 	virtual void DetachedFromWindow();
117 
118 	// Returns true if for instance, node ref is a remote desktop
119 	// directory and this is a desktop pose view.
120 	virtual bool Represents(const node_ref*) const;
121 	virtual bool Represents(const entry_ref*) const;
122 
123 	BContainerWindow* ContainerWindow() const;
124 	const char* ViewStateAttributeName() const;
125 	const char* ForeignViewStateAttributeName() const;
126 	Model* TargetModel() const;
127 
128 	virtual bool IsFilePanel() const;
129 	bool IsDesktopWindow() const;
130 	virtual bool IsDesktopView() const;
131 
132 	// state saving/restoring
133 	virtual void SaveState(AttributeStreamNode* node);
134 	virtual void RestoreState(AttributeStreamNode*);
135 	virtual void RestoreColumnState(AttributeStreamNode*);
136 	void AddColumnList(BObjectList<BColumn>*list);
137 	virtual void SaveColumnState(AttributeStreamNode*);
138 	virtual void SavePoseLocations(BRect* frameIfDesktop = NULL);
139 	void DisableSaveLocation();
140 
141 	virtual void SaveState(BMessage&) const;
142 	virtual void RestoreState(const BMessage&);
143 	virtual void RestoreColumnState(const BMessage&);
144 	virtual void SaveColumnState(BMessage&) const;
145 
146 	bool StateNeedsSaving();
147 
148 	// switch between mini icon mode, icon mode and list mode
149 	virtual void SetViewMode(uint32 mode);
150 	uint32 ViewMode() const;
151 
152 	// re-use the pose view for a new directory
153  	virtual void SwitchDir(const entry_ref*,
154  		AttributeStreamNode* node = NULL);
155 
156 	// in the rare cases where a pose view needs to be explicitly
157 	// refreshed (for instance in a query window with a dynamic
158 	// date query), this is used
159 	virtual void Refresh();
160 
161 	// callbacks
162 	virtual void MessageReceived(BMessage* message);
163 	virtual void AttachedToWindow();
164 	virtual void WindowActivated(bool active);
165 	virtual void MakeFocus(bool = true);
166 	virtual	BSize MinSize();
167 	virtual void Draw(BRect update_rect);
168 	virtual void DrawAfterChildren(BRect update_rect);
169 	virtual void MouseMoved(BPoint, uint32, const BMessage*);
170 	virtual void MouseDown(BPoint where);
171 	virtual void MouseUp(BPoint where);
172 	virtual void MouseDragged(const BMessage*);
173 	virtual void MouseLongDown(const BMessage*);
174 	virtual void MouseIdle(const BMessage*);
175 	virtual void KeyDown(const char*, int32);
176 	virtual void Pulse();
177 	virtual void ScrollTo(BPoint);
178 
179 	// misc. mode setters
180 	void SetMultipleSelection(bool);
181 	void SetDragEnabled(bool);
182 	void SetDropEnabled(bool);
183 	void SetSelectionRectEnabled(bool);
184 	void SetAlwaysAutoPlace(bool);
185 	void SetSelectionChangedHook(bool);
186 	void SetShowHideSelection(bool);
187 	void SetEnsurePosesVisible(bool);
188 	void SetIconMapping(bool);
189 	void SetAutoScroll(bool);
190 	void SetPoseEditing(bool);
191 
192 	void UpdateIcon(BPose* pose);
193 
194 	// file change notification handler
195 	virtual bool FSNotification(const BMessage*);
196 
197 	// scrollbars
198 	virtual void UpdateScrollRange();
199 	virtual void SetScrollBarsTo(BPoint);
200 	virtual void AddScrollBars();
201 	BScrollBar* HScrollBar() const;
202 	BScrollBar* VScrollBar() const ;
203 	BCountView* CountView() const;
204 	BTitleView* TitleView() const;
205 	void DisableScrollBars();
206 	void EnableScrollBars();
207 
208 	// sorting
209 	virtual void SortPoses();
210 	void SetPrimarySort(uint32 attrHash);
211 	void SetSecondarySort(uint32 attrHash);
212 	void SetReverseSort(bool reverse);
213 	uint32 PrimarySort() const;
214 	uint32 PrimarySortType() const;
215 	uint32 SecondarySort() const;
216 	uint32 SecondarySortType() const;
217 	bool ReverseSort() const;
218 	void CheckPoseSortOrder(BPose*, int32 index);
219 	void CheckPoseVisibility(BRect* = NULL);
220 		// make sure pose fits the screen and/or window bounds if needed
221 
222 	// view metrics
223 	font_height FontInfo() const;
224 		// returns height, descent, etc.
225 	float FontHeight() const;
226 	float ListElemHeight() const;
227 	void SetListElemHeight();
228 
229 	void SetIconPoseHeight();
230 	float IconPoseHeight() const;
231 	uint32 IconSizeInt() const;
232 	icon_size IconSize() const;
233 
234 	BRect Extent() const;
235 	void GetLayoutInfo(uint32 viewMode, BPoint* grid,
236 		BPoint* offset) const;
237 
238 	int32 CountItems() const;
239 	void UpdateCount();
240 
241 	rgb_color DeskTextColor() const;
242 	rgb_color DeskTextBackColor() const;
243 
244 	bool WidgetTextOutline() const;
245 	void SetWidgetTextOutline(bool);
246 		// used to not erase when we have a background image and
247 		// invalidate instead
248 
249 	void ScrollView(int32 type);
250 
251 	// column handling
252 	void ColumnRedraw(BRect updateRect);
253 	bool AddColumn(BColumn*, const BColumn* after = NULL);
254 	bool RemoveColumn(BColumn* column, bool runAlert);
255 	void MoveColumnTo(BColumn* src, BColumn* dest);
256 	bool ResizeColumnToWidest(BColumn* column);
257 	BPoint ResizeColumn(BColumn*, float, float* lastLineDrawPos = NULL,
258 		void (*drawLineFunc)(BPoseView*, BPoint, BPoint) = 0,
259 		void (*undrawLineFunc)(BPoseView*, BPoint, BPoint) = 0);
260 		// returns the bottom right of the last pose drawn or
261 		// the bottom right of bounds
262 
263 	BColumn* ColumnAt(int32 index) const;
264 	BColumn* ColumnFor(uint32 attribute_hash) const;
265 	BColumn* FirstColumn() const;
266 	BColumn* LastColumn() const;
267 	int32 IndexOfColumn(const BColumn*) const;
268 	int32 CountColumns() const;
269 
270 	// Where to start the first column
271 	float StartOffset() const;
272 
273 	// pose access
274 	int32 IndexOfPose(const BPose*) const;
275 	BPose* PoseAtIndex(int32 index) const;
276 
277 	BPose* FindPose(BPoint where, int32* index = NULL) const;
278 		// return pose at location h, v (search list starting from
279 		// bottom so drawing and hit detection reflect the same pose
280 		// ordering)
281 	BPose* FindPose(const Model*, int32* index = NULL) const;
282 	BPose* FindPose(const node_ref*, int32* index = NULL) const;
283 	BPose* FindPose(const entry_ref*, int32* index = NULL) const;
284 	BPose* FindPose(const entry_ref*, int32 specifierForm,
285 		int32* index) const;
286 		// special form of FindPose used for scripting,
287 		// <specifierForm> may ask for previous or next pose
288 	BPose* DeepFindPose(const node_ref* node, int32* index = NULL) const;
289 		// same as FindPose, node can be a target of the actual
290 		// pose if the pose is a symlink
291 	BPose* FirstVisiblePose(int32* _index = NULL) const;
292 	BPose* LastVisiblePose(int32* _index = NULL) const;
293 
294 	void OpenInfoWindows();
295 	void SetDefaultPrinter();
296 
297 	void IdentifySelection(bool force = false);
298 	void UnmountSelectedVolumes();
299 	virtual void OpenParent();
300 
301 	virtual void OpenSelection(BPose* clicked_pose = NULL,
302 		int32* index = NULL);
303 	void OpenSelectionUsing(BPose* clicked_pose = NULL,
304 		int32* index = NULL);
305 		// launches the open with window
306 	virtual void MoveSelectionTo(BPoint, BPoint, BContainerWindow*);
307 	void DuplicateSelection(BPoint* dropStart = NULL,
308 		BPoint* dropEnd = NULL);
309 
310 	// Move to trash calls try to select the next pose in the view
311 	// when they are dones
312 	virtual void MoveSelectionToTrash(bool selectNext = true);
313 	virtual void DeleteSelection(bool selectNext = true,
314 		bool askUser = true);
315 	virtual void MoveEntryToTrash(const entry_ref*,
316 		bool selectNext = true);
317 
318 	void RestoreSelectionFromTrash(bool selectNext = true);
319 
320 	// selection
321 	PoseList* SelectionList() const;
322 	void SelectAll();
323 	void InvertSelection();
324 	int32 SelectMatchingEntries(const BMessage*);
325 	void ShowSelectionWindow();
326 	void ClearSelection();
327 	void ShowSelection(bool);
328 	void AddRemovePoseFromSelection(BPose* pose, int32 index,
329 		bool select);
330 
331 	BLooper* SelectionHandler();
332 	void SetSelectionHandler(BLooper*);
333 
334 	BObjectList<BString>*MimeTypesInSelection();
335 
336 	// pose selection
337 	void SelectPose(BPose*, int32 index, bool scrollIntoView = true);
338 	void AddPoseToSelection(BPose*, int32 index,
339 		bool scrollIntoView = true);
340 	void RemovePoseFromSelection(BPose*);
341 	void SelectPoseAtLocation(BPoint);
342 	void SelectPoses(int32 start, int32 end);
343 	void MoveOrChangePoseSelection(int32 to);
344 
345 	// pose handling
346 	void ScrollIntoView(BPose* pose, int32 index);
347 	void ScrollIntoView(BRect poseRect);
348 	void SetActivePose(BPose*);
349 	BPose* ActivePose() const;
350 	void CommitActivePose(bool saveChanges = true);
351 	static bool PoseVisible(const Model*, const PoseInfo*);
352 	bool FrameForPose(BPose* targetPose, bool convert, BRect* poseRect);
353 	bool CreateSymlinkPoseTarget(Model* symlink);
354 		// used to complete a symlink pose; returns true if
355 		// target symlink should not be shown
356 	void ResetPosePlacementHint();
357 	void PlaceFolder(const entry_ref*, const BMessage*);
358 
359 	// clipboard handling for poses
360 	inline bool HasPosesInClipboard();
361 	inline void SetHasPosesInClipboard(bool hasPoses);
362 	void SetPosesClipboardMode(uint32 clipboardMode);
363 	void UpdatePosesClipboardModeFromClipboard(
364 		BMessage* clipboardReport = NULL);
365 
366 	// filtering
367 	void SetRefFilter(BRefFilter*);
368 	BRefFilter* RefFilter() const;
369 
370 	// access for mime types represented in the pose view
371 	void AddMimeType(const char* mimeType);
372 	const char* MimeTypeAt(int32 index);
373 	int32 CountMimeTypes();
374 	void RefreshMimeTypeList();
375 
376 	// drag&drop handling
377 	virtual bool HandleMessageDropped(BMessage*);
378 	static bool HandleDropCommon(BMessage* dragMessage, Model* target,
379 		BPose*, BView* view, BPoint dropPoint);
380 		// used by pose views and info windows
381 	static bool CanHandleDragSelection(const Model* target,
382 		const BMessage* dragMessage, bool ignoreTypes);
383 	virtual void DragSelectedPoses(const BPose* clickedPose, BPoint);
384 
385 	void MoveSelectionInto(Model* destFolder, BContainerWindow* srcWindow,
386 		bool forceCopy, bool forceMove = false, bool createLink = false,
387 		bool relativeLink = false);
388 	static void MoveSelectionInto(Model* destFolder,
389 		BContainerWindow* srcWindow, BContainerWindow* destWindow,
390 		uint32 buttons, BPoint loc, bool forceCopy,
391 		bool forceMove = false, bool createLink = false,
392 		bool relativeLink = false, BPoint clickPoint = BPoint(0, 0),
393 		bool pinToGrid = false);
394 
395 	bool UpdateDropTarget(BPoint, const BMessage*,
396 		bool trackingContextMenu);
397 		// return true if drop target changed
398 	void HiliteDropTarget(bool hiliteState);
399 
400 	void DragStop();
401 		// throw away cached up structures
402 
403 	static bool MenuTrackingHook(BMenu* menu, void* castToThis);
404 		// hook for spring loaded nav-menus
405 
406 	// scripting
407 	virtual BHandler* ResolveSpecifier(BMessage* message, int32 index,
408 		BMessage* specifier, int32 form, const char* property);
409 	virtual status_t GetSupportedSuites(BMessage*);
410 
411 	// string width calls that use local width caches, faster than using
412 	// the general purpose BView::StringWidth
413 	float StringWidth(const char*) const;
414 	float StringWidth(const char*, int32) const;
415 		// deliberately hide the BView StringWidth here - this makes it
416 		// easy to have the right StringWidth picked up by
417 		// template instantiation, as used by WidgetAttributeText
418 
419 	// show/hide barberpole while a background task is filling
420 	// up the view, etc.
421 	void ShowBarberPole();
422 	void HideBarberPole();
423 
424 	bool fShowSelectionWhenInactive;
425 	bool fTransparentSelection;
426 	bool fIsDrawingSelectionRect;
427 
428 	bool IsWatchingDateFormatChange();
429 	void StartWatchDateFormatChange();
430 	void StopWatchDateFormatChange();
431 
432 	// type ahead filtering
433 	bool IsFiltering() const;
434 
435 	void UpdateDateColumns(BMessage*);
436 	virtual void AdaptToVolumeChange(BMessage*);
437 	virtual void AdaptToDesktopIntegrationChange(BMessage*);
438 
439 	void SetTextWidgetToCheck(BTextWidget*, BTextWidget* = NULL);
440 
441 protected:
442 	// view setup
443 	virtual void SetUpDefaultColumnsIfNeeded();
444 
445 	virtual EntryListBase* InitDirentIterator(const entry_ref*);
446 		// sets up an entry iterator for _add_poses_
447 		// overriden by QueryPoseView, etc. to provide different iteration
448 	virtual void ReturnDirentIterator(EntryListBase* iterator);
449 		// returns the entry iterator after _add_poses_ is done
450 
451 	void Cleanup(bool doAll = false);
452 		// clean up poses
453 	void NewFolder(const BMessage*);
454 		// create a new folder, optionally specify a location
455 
456 	void NewFileFromTemplate(const BMessage*);
457 		// create a new file based on a template, optionally specify
458 		// a location
459 
460 	void ShowContextMenu(BPoint);
461 
462 	// scripting handlers
463 	virtual bool HandleScriptingMessage(BMessage* message);
464 	bool SetProperty(BMessage* message, BMessage* specifier, int32 form,
465 		const char* property, BMessage* reply);
466 	bool GetProperty(BMessage*, int32, const char*, BMessage*);
467 	bool CreateProperty(BMessage* message, BMessage* specifier, int32,
468 		const char*, BMessage* reply);
469 	bool ExecuteProperty(BMessage* specifier, int32, const char*,
470 		BMessage* reply);
471 	bool CountProperty(BMessage*, int32, const char*, BMessage*);
472 	bool DeleteProperty(BMessage*, int32, const char*, BMessage*);
473 
474 	void ClearPoses();
475 		// remove all the current poses from the view
476 
477 	// pose info read/write calls
478 	void ReadPoseInfo(Model*, PoseInfo*);
479 	ExtendedPoseInfo* ReadExtendedPoseInfo(Model*);
480 
481 	void _CheckPoseSortOrder(PoseList* list, BPose*, int32 index);
482 
483 	// pose creation
484 	BPose* EntryCreated(const node_ref*, const node_ref*, const char*,
485 		int32* index = 0);
486 
487 	void AddPoseToList(PoseList* list, bool visibleList,
488 		bool insertionSort, BPose* pose, BRect&viewBounds,
489 		float& listViewScrollBy, bool forceDraw, int32* indexPtr = NULL);
490 	BPose* CreatePose(Model*, PoseInfo*, bool insertionSort = true,
491 		int32* index = 0, BRect* boundsPointer = 0, bool forceDraw = true);
492 	virtual void CreatePoses(Model**models, PoseInfo* poseInfoArray,
493 		int32 count, BPose** resultingPoses, bool insertionSort = true,
494 		int32* lastPoseIndexPointer = 0, BRect* boundsPointer = 0,
495 		bool forceDraw = false);
496 	virtual bool ShouldShowPose(const Model*, const PoseInfo*);
497 		// filter, subclasses override to control which poses show up
498 		// subclasses should always call inherited
499 	void CreateVolumePose(BVolume*, bool watchIndividually);
500 
501 	void CreateTrashPose();
502 
503 	virtual bool AddPosesThreadValid(const entry_ref*) const;
504 		// verifies whether or not the current set of AddPoses threads
505 		// are valid and allowed to be adding poses -- returns false
506 		// in the case where the directory has been switched while
507 		// populating the view
508 
509 	virtual void AddPoses(Model* model = NULL);
510 		// if <model> is zero, PoseView has other means of iterating
511 		// through all the entries thaat it adds
512 
513 	virtual void AddRootPoses(bool watchIndividually, bool mountShared);
514 		// watchIndividually is used when placing a volume pose onto
515 		// the Desktop where unlike in the Root window it will not be
516 		// watched by the folder representing root. If set, each volume
517 		// will therefore be watched individually
518 	virtual void RemoveRootPoses();
519 	virtual void AddTrashPoses();
520 
521 	virtual bool DeletePose(const node_ref*, BPose* pose = NULL,
522 		int32 index = 0);
523 	virtual void DeleteSymLinkPoseTarget(const node_ref* itemNode,
524 		BPose* pose, int32 index);
525 		// the pose itself wasn't deleted but it's target node was - the
526 		// pose must be a symlink
527 	static void PoseHandleDeviceUnmounted(BPose* pose, Model* model,
528 		int32 index, BPoseView* poseView, dev_t device);
529 	static void RemoveNonBootDesktopModels(BPose*, Model* model, int32,
530 		BPoseView* poseView, dev_t);
531 
532 	// pose placement
533 	void CheckAutoPlacedPoses();
534 		// find poses that need placing and place them in a new spot
535 	void PlacePose(BPose*, BRect&);
536 		// find a new place for a pose, starting at fHintLocation
537 		// and place it
538 	bool IsValidLocation(const BPose* pose);
539 	bool IsValidLocation(const BRect& rect);
540 	status_t GetDeskbarFrame(BRect* frame);
541 	bool SlotOccupied(BRect poseRect, BRect viewBounds) const;
542 	void NextSlot(BPose*, BRect&poseRect, BRect viewBounds);
543 	void TrySettingPoseLocation(BNode* node, BPoint point);
544 	BPoint PinToGrid(BPoint, BPoint grid, BPoint offset) const;
545 
546 	// zombie pose handling
547 	Model* FindZombie(const node_ref*, int32* index = 0);
548 	BPose* ConvertZombieToPose(Model* zombie, int32 index);
549 
550 	// pose handling
551 	BRect CalcPoseRect(const BPose*, int32 index,
552 		bool firstColumnOnly = false) const;
553 	BRect CalcPoseRectIcon(const BPose*) const;
554 	BRect CalcPoseRectList(const BPose*, int32 index,
555 		bool firstColumnOnly = false) const;
556 	void DrawPose(BPose*, int32 index, bool fullDraw = true);
557 	void DrawViewCommon(const BRect&updateRect);
558 
559 	// pose list handling
560 	int32 BSearchList(PoseList* poseList, const BPose*, int32* index,
561 		int32 oldIndex);
562 	void InsertPoseAfter(BPose* pose, int32* index, int32 orientation,
563 		BRect* invalidRect);
564 		// does a CopyBits to scroll poses making room for a new pose,
565 		// returns rectangle that needs invalidating
566 	void CloseGapInList(BRect* invalidRect);
567 	int32 FirstIndexAtOrBelow(int32 y, bool constrainIndex = true) const;
568 	void AddToVSList(BPose*);
569 	int32 RemoveFromVSList(const BPose*);
570 	BPose* FindNearbyPose(char arrow, int32* index);
571 	BPose* FindBestMatch(int32* index);
572 	BPose* FindNextMatch(int32* index, bool reverse = false);
573 
574 	// node monitoring calls
575 	virtual void StartWatching();
576 	virtual void StopWatching();
577 
578 	status_t WatchNewNode(const node_ref* item);
579 		// the above would ideally be the only call of these three and
580 		// it would be a virtual, overriding the specific watch mask in
581 		// query pose view, etc. however we need to call WatchNewNode
582 		// from inside AddPosesTask while the window is unlocked - we
583 		// have to use the static and a cached messenger and masks.
584 	static status_t WatchNewNode(const node_ref*, uint32, BMessenger);
585 	virtual uint32 WatchNewNodeMask();
586 		// override to change different watch modes for query pose
587 		// view, etc.
588 
589 	// drag&drop handling
590 	static bool EachItemInDraggedSelection(const BMessage* message,
591 		bool (*)(BPose*, BPoseView*, void*), BPoseView* poseView,
592 		void* = NULL);
593 		// iterates through each pose in current selectiond in the source
594 		// window of the current drag message; locks the window
595 		// add const version
596 	BRect GetDragRect(int32 clickedPoseIndex);
597 	BBitmap* MakeDragBitmap(BRect dragRect, BPoint clickedPoint,
598 		int32 clickedPoseIndex, BPoint&offset);
599 	static bool FindDragNDropAction(const BMessage* dragMessage,
600 		bool&canCopy, bool&canMove, bool&canLink, bool&canErase);
601 
602 	static bool CanTrashForeignDrag(const Model*);
603 	static bool CanCopyOrMoveForeignDrag(const Model*, const BMessage*);
604 	static bool DragSelectionContains(const BPose* target,
605 		const BMessage* dragMessage);
606 	static status_t CreateClippingFile(BPoseView* poseView, BFile&result,
607 		char* resultingName, BDirectory* directory, BMessage* message,
608 		const char* fallbackName, bool setLocation = false,
609 		BPoint dropPoint = BPoint(0, 0));
610 
611 	// opening files, lanunching
612 	void OpenSelectionCommon(BPose*, int32*, bool);
613 		// used by OpenSelection and OpenSelectionUsing
614 	static void LaunchAppWithSelection(Model*, const BMessage*,
615 		bool checkTypes = true);
616 
617 	// node monitoring calls
618 	virtual bool EntryMoved(const BMessage*);
619 	virtual bool AttributeChanged(const BMessage*);
620 	virtual bool NoticeMetaMimeChanged(const BMessage*);
621 	virtual void MetaMimeChanged(const char*, const char*);
622 
623 	// click handling
624 	bool WasDoubleClick(const BPose*, BPoint point, int32 buttons);
625 	bool WasClickInPath(const BPose*, int32 index,
626 		BPoint mouseLocation) const;
627 
628 	// selection
629 	void SelectPosesListMode(BRect, BList**);
630 	void SelectPosesIconMode(BRect, BList**);
631 	void AddRemoveSelectionRange(BPoint where, bool extendSelection,
632 		BPose* pose);
633 
634 	void _BeginSelectionRect(const BPoint& point, bool extendSelection);
635 	void _UpdateSelectionRect(const BPoint& point);
636 	void _EndSelectionRect();
637 
638 	// view drawing
639 	void SynchronousUpdate(BRect, bool clip = false);
640 
641 	// scrolling
642 	void HandleAutoScroll();
643 	bool CheckAutoScroll(BPoint mouseLoc, bool shouldScroll);
644 
645 	// view extent handling
646 	void RecalcExtent();
647 	void AddToExtent(const BRect&);
648 	void ClearExtent();
649 	void RemoveFromExtent(const BRect&);
650 
651 	virtual void EditQueries();
652 
653 	void HandleAttrMenuItemSelected(BMessage*);
654 	void TryUpdatingBrokenLinks();
655 		// ran a little after a volume gets mounted
656 
657 	void MapToNewIconMode(BPose*, BPoint oldGrid, BPoint oldOffset);
658 	void ResetOrigin();
659 	void PinPointToValidRange(BPoint&);
660 		// used to ensure pose locations make sense after getting them
661 		// in pose info from attributes, etc.
662 
663 	void FinishPendingScroll(float&listViewScrollBy, BRect bounds);
664 		// utility call for CreatePoses
665 
666 	// background AddPoses task calls
667 	static status_t AddPosesTask(void*);
668 	virtual void AddPosesCompleted();
669 	bool IsValidAddPosesThread(thread_id) const;
670 
671 	// typeahead filtering
672 	void EnsurePoseUnselected(BPose* pose);
673 	void RemoveFilteredPose(BPose* pose, int32 index);
674 	void FilterChanged();
675 	void UpdateAfterFilterChange();
676 	bool FilterPose(BPose* pose);
677 	void StartFiltering();
678 	void StopFiltering();
679 	void ClearFilter();
680 	PoseList* CurrentPoseList() const;
681 
682 	// misc
683 	BList* GetDropPointList(BPoint dropPoint, BPoint startPoint,
684 		const PoseList*, bool sourceInListMode, bool dropOnGrid) const;
685 	void SendSelectionAsRefs(uint32 what, bool onlyQueries = false);
686 	void MoveListToTrash(BObjectList<entry_ref>*, bool selectNext,
687 		bool deleteDirectly);
688 	void Delete(BObjectList<entry_ref>*, bool selectNext, bool askUser);
689 	void Delete(const entry_ref&ref, bool selectNext, bool askUser);
690 	void RestoreItemsFromTrash(BObjectList<entry_ref>*, bool selectNext);
691 
692 	void WatchParentOf(const entry_ref*);
693 	void StopWatchingParentsOf(const entry_ref*);
694 
695 	void ExcludeTrashFromSelection();
696 
697 private:
698 	void DrawOpenAnimation(BRect);
699 
700 	void MoveSelectionOrEntryToTrash(const entry_ref* ref, bool selectNext);
701 
702 protected:
703 	TScrollBar* fHScrollBar;
704 	BScrollBar* fVScrollBar;
705 	Model* fModel;
706 	BPose* fActivePose;
707 	BRect fExtent;
708 	// the following should probably be just member lists, not pointers
709 	PoseList* fPoseList;
710 	PoseList* fFilteredPoseList;
711 	PoseList* fVSPoseList;
712 	PoseList* fSelectionList;
713 	NodeSet fInsertedNodes;
714 	BObjectList<BString> fMimeTypesInSelectionCache;
715 		// used for mime string based icon highliting during a drag
716 	BObjectList<Model>* fZombieList;
717 	PendingNodeMonitorCache pendingNodeMonitorCache;
718 	BObjectList<BColumn>* fColumnList;
719 	BObjectList<BString>* fMimeTypeList;
720 	BObjectList<Model>* fBrokenLinks;
721 	bool fMimeTypeListIsDirty;
722 	BViewState* fViewState;
723 	bool fStateNeedsSaving;
724 	BCountView* fCountView;
725 	float fListElemHeight;
726 	float fIconPoseHeight;
727 	BPose* fDropTarget;
728 	BPose* fAlreadySelectedDropTarget;
729 	BLooper* fSelectionHandler;
730 	BPoint fLastClickPoint;
731 	int32 fLastClickButtons;
732 	const BPose* fLastClickedPose;
733 	BPoint fLastLeftTop;
734 	BRect fLastExtent;
735 	BTitleView* fTitleView;
736 	BRefFilter* fRefFilter;
737 	BPoint fGrid;
738 	BPoint fOffset;
739 	BPoint fHintLocation;
740 	float fAutoScrollInc;
741 	int32 fAutoScrollState;
742 	std::set<thread_id> fAddPosesThreads;
743 	bool fWidgetTextOutline;
744 	const BPose* fSelectionPivotPose;
745 	const BPose* fRealPivotPose;
746 	BMessageRunner* fKeyRunner;
747 	bool fTrackRightMouseUp;
748 
749 	struct SelectionRectInfo {
750 		SelectionRectInfo()
751 			:
752 			isDragging(false),
753 			selection(NULL)
754 		{
755 		}
756 
757 		bool isDragging;
758 		BRect rect;
759 		BRect lastRect;
760 		BPoint startPoint;
761 		BPoint lastPoint;
762 		BList* selection;
763 	};
764 	SelectionRectInfo fSelectionRectInfo;
765 
766 	bool fSelectionVisible : 1;
767 	bool fMultipleSelection : 1;
768 	bool fDragEnabled : 1;
769 	bool fDropEnabled : 1;
770 	bool fSelectionRectEnabled : 1;
771 	bool fAlwaysAutoPlace : 1;
772 	bool fAllowPoseEditing : 1;
773 	bool fSelectionChangedHook : 1;
774 		// get rid of this
775 	bool fSavePoseLocations : 1;
776 	bool fShowHideSelection : 1;
777 	bool fOkToMapIcons : 1;
778 	bool fEnsurePosesVisible : 1;
779 	bool fShouldAutoScroll : 1;
780 	bool fIsDesktopWindow : 1;
781 	bool fIsWatchingDateFormatChange : 1;
782 	bool fHasPosesInClipboard : 1;
783 	bool fCursorCheck : 1;
784 	bool fFiltering : 1;
785 
786 	BObjectList<BString> fFilterStrings;
787 	int32 fLastFilterStringCount;
788 	int32 fLastFilterStringLength;
789 
790 	BRect fStartFrame;
791 
792 	static float sFontHeight;
793 	static font_height sFontInfo;
794 	static BFont sCurrentFont;
795 	static BString sMatchString;
796 		// used for typeahead - should be replaced by a typeahead state
797 
798 	bigtime_t fLastKeyTime;
799 	bigtime_t fLastDeskbarFrameCheckTime;
800 	BRect fDeskbarFrame;
801 
802 	static OffscreenBitmap* sOffscreen;
803 
804 	BTextWidget* fTextWidgetToCheck;
805 
806 	typedef BView _inherited;
807 };
808 
809 
810 class TScrollBar : public BScrollBar {
811 public:
812 	TScrollBar(const char*, BView*, float, float);
813 	void SetTitleView(BView*);
814 
815 	// BScrollBar overrides
816 	virtual	void ValueChanged(float);
817 
818 private:
819 	BView* fTitleView;
820 
821 	typedef BScrollBar _inherited;
822 };
823 
824 
825 class TPoseViewFilter : public BMessageFilter {
826 public:
827 	TPoseViewFilter(BPoseView* pose);
828 	~TPoseViewFilter();
829 
830 	filter_result Filter(BMessage*, BHandler**);
831 
832 private:
833 	filter_result ObjectDropFilter(BMessage*, BHandler**);
834 
835 	BPoseView* fPoseView;
836 };
837 
838 
839 extern bool
840 ClearViewOriginOne(const char* name, uint32 type, off_t size, void* data,
841 	void* params);
842 
843 
844 // inlines follow
845 
846 
847 inline BContainerWindow*
848 BPoseView::ContainerWindow() const
849 {
850 	return dynamic_cast<BContainerWindow*>(Window());
851 }
852 
853 
854 inline Model*
855 BPoseView::TargetModel() const
856 {
857 	return fModel;
858 }
859 
860 
861 inline float
862 BPoseView::ListElemHeight() const
863 {
864 	return fListElemHeight;
865 }
866 
867 
868 inline void
869 BPoseView::SetListElemHeight()
870 {
871 	float extra = 0;
872 	if (IconSize() > B_MINI_ICON)
873 		extra = kLargeIconSeparator;
874 
875 	fListElemHeight = std::max((float)IconSize() + extra,
876 		ceilf(sFontHeight) < 20 ? 20 : ceilf(sFontHeight * 1.1f));
877 }
878 
879 
880 inline float
881 BPoseView::IconPoseHeight() const
882 {
883 	return fIconPoseHeight;
884 }
885 
886 
887 inline uint32
888 BPoseView::IconSizeInt() const
889 {
890 	return fViewState->IconSize();
891 }
892 
893 
894 inline icon_size
895 BPoseView::IconSize() const
896 {
897 	return (icon_size)fViewState->IconSize();
898 }
899 
900 
901 inline PoseList*
902 BPoseView::SelectionList() const
903 {
904 	return fSelectionList;
905 }
906 
907 
908 inline BObjectList<BString>*
909 BPoseView::MimeTypesInSelection()
910 {
911 	return &fMimeTypesInSelectionCache;
912 }
913 
914 
915 inline BScrollBar*
916 BPoseView::HScrollBar() const
917 {
918 	return fHScrollBar;
919 }
920 
921 
922 inline BScrollBar*
923 BPoseView::VScrollBar() const
924 {
925 	return fVScrollBar;
926 }
927 
928 
929 inline BCountView*
930 BPoseView::CountView() const
931 {
932 	return fCountView;
933 }
934 
935 
936 inline BTitleView*
937 BPoseView::TitleView() const
938 {
939 	return fTitleView;
940 }
941 
942 
943 inline bool
944 BPoseView::StateNeedsSaving()
945 {
946 	return fStateNeedsSaving || fViewState->StateNeedsSaving();
947 }
948 
949 
950 inline uint32
951 BPoseView::ViewMode() const
952 {
953 	return fViewState->ViewMode();
954 }
955 
956 
957 inline font_height
958 BPoseView::FontInfo() const
959 {
960 	return sFontInfo;
961 }
962 
963 
964 inline float
965 BPoseView::FontHeight() const
966 {
967 	return sFontHeight;
968 }
969 
970 
971 inline BPose*
972 BPoseView::ActivePose() const
973 {
974 	return fActivePose;
975 }
976 
977 
978 inline void
979 BPoseView::DisableSaveLocation()
980 {
981 	fSavePoseLocations = false;
982 }
983 
984 
985 inline bool
986 BPoseView::IsFilePanel() const
987 {
988 	return false;
989 }
990 
991 
992 inline bool
993 BPoseView::IsDesktopWindow() const
994 {
995 	return fIsDesktopWindow;
996 }
997 
998 
999 inline bool
1000 BPoseView::IsDesktopView() const
1001 {
1002 	return false;
1003 }
1004 
1005 
1006 inline uint32
1007 BPoseView::PrimarySort() const
1008 {
1009 	return fViewState->PrimarySort();
1010 }
1011 
1012 
1013 inline uint32
1014 BPoseView::PrimarySortType() const
1015 {
1016 	return fViewState->PrimarySortType();
1017 }
1018 
1019 
1020 inline uint32
1021 BPoseView::SecondarySort() const
1022 {
1023 	return fViewState->SecondarySort();
1024 }
1025 
1026 
1027 inline uint32
1028 BPoseView::SecondarySortType() const
1029 {
1030 	return fViewState->SecondarySortType();
1031 }
1032 
1033 
1034 inline bool
1035 BPoseView::ReverseSort() const
1036 {
1037 	return fViewState->ReverseSort();
1038 }
1039 
1040 
1041 inline void
1042 BPoseView::SetShowHideSelection(bool on)
1043 {
1044 	fShowHideSelection = on;
1045 }
1046 
1047 
1048 inline void
1049 BPoseView::SetIconMapping(bool on)
1050 {
1051 	fOkToMapIcons = on;
1052 }
1053 
1054 
1055 inline void
1056 BPoseView::AddToExtent(const BRect&rect)
1057 {
1058 	fExtent = fExtent | rect;
1059 }
1060 
1061 
1062 inline void
1063 BPoseView::ClearExtent()
1064 {
1065 	fExtent.Set(INT32_MAX, INT32_MAX, INT32_MIN, INT32_MIN);
1066 }
1067 
1068 
1069 inline int32
1070 BPoseView::CountColumns() const
1071 {
1072 	return fColumnList->CountItems();
1073 }
1074 
1075 
1076 inline float
1077 BPoseView::StartOffset() const
1078 {
1079 	return kListOffset + IconSizeInt() + kMiniIconSeparator + 1;
1080 }
1081 
1082 
1083 inline int32
1084 BPoseView::IndexOfColumn(const BColumn* column) const
1085 {
1086 	return fColumnList->IndexOf(const_cast<BColumn*>(column));
1087 }
1088 
1089 
1090 inline int32
1091 BPoseView::IndexOfPose(const BPose* pose) const
1092 {
1093 	return CurrentPoseList()->IndexOf(pose);
1094 }
1095 
1096 
1097 inline BPose*
1098 BPoseView::PoseAtIndex(int32 index) const
1099 {
1100 	return CurrentPoseList()->ItemAt(index);
1101 }
1102 
1103 
1104 inline BColumn*
1105 BPoseView::ColumnAt(int32 index) const
1106 {
1107 	return fColumnList->ItemAt(index);
1108 }
1109 
1110 
1111 inline BColumn*
1112 BPoseView::FirstColumn() const
1113 {
1114 	return fColumnList->FirstItem();
1115 }
1116 
1117 
1118 inline BColumn*
1119 BPoseView::LastColumn() const
1120 {
1121 	return fColumnList->LastItem();
1122 }
1123 
1124 
1125 inline int32
1126 BPoseView::CountItems() const
1127 {
1128 	return CurrentPoseList()->CountItems();
1129 }
1130 
1131 
1132 inline void
1133 BPoseView::SetMultipleSelection(bool state)
1134 {
1135 	fMultipleSelection = state;
1136 }
1137 
1138 
1139 inline void
1140 BPoseView::SetSelectionChangedHook(bool state)
1141 {
1142 	fSelectionChangedHook = state;
1143 }
1144 
1145 
1146 inline void
1147 BPoseView::SetAutoScroll(bool state)
1148 {
1149 	fShouldAutoScroll = state;
1150 }
1151 
1152 
1153 inline void
1154 BPoseView::SetPoseEditing(bool state)
1155 {
1156 	fAllowPoseEditing = state;
1157 }
1158 
1159 
1160 inline void
1161 BPoseView::SetDragEnabled(bool state)
1162 {
1163 	fDragEnabled = state;
1164 }
1165 
1166 
1167 inline void
1168 BPoseView::SetDropEnabled(bool state)
1169 {
1170 	fDropEnabled = state;
1171 }
1172 
1173 
1174 inline void
1175 BPoseView::SetSelectionRectEnabled(bool state)
1176 {
1177 	fSelectionRectEnabled = state;
1178 }
1179 
1180 
1181 inline void
1182 BPoseView::SetAlwaysAutoPlace(bool state)
1183 {
1184 	fAlwaysAutoPlace = state;
1185 }
1186 
1187 
1188 inline void
1189 BPoseView::SetEnsurePosesVisible(bool state)
1190 {
1191 	fEnsurePosesVisible = state;
1192 }
1193 
1194 
1195 inline void
1196 BPoseView::SetSelectionHandler(BLooper* looper)
1197 {
1198 	fSelectionHandler = looper;
1199 }
1200 
1201 
1202 inline void
1203 TScrollBar::SetTitleView(BView* view)
1204 {
1205 	fTitleView = view;
1206 }
1207 
1208 
1209 inline void
1210 BPoseView::SetRefFilter(BRefFilter* filter)
1211 {
1212 	fRefFilter = filter;
1213 	if (filter != NULL)
1214 		FilterChanged();
1215 }
1216 
1217 
1218 inline BRefFilter*
1219 BPoseView::RefFilter() const
1220 {
1221 	return fRefFilter;
1222 }
1223 
1224 
1225 inline BPose*
1226 BPoseView::FindPose(const Model* model, int32* index) const
1227 {
1228 	return CurrentPoseList()->FindPose(model, index);
1229 }
1230 
1231 
1232 inline BPose*
1233 BPoseView::FindPose(const node_ref* node, int32* index) const
1234 {
1235 	return CurrentPoseList()->FindPose(node, index);
1236 }
1237 
1238 
1239 inline BPose*
1240 BPoseView::FindPose(const entry_ref* entry, int32* index) const
1241 {
1242 	return CurrentPoseList()->FindPose(entry, index);
1243 }
1244 
1245 
1246 inline bool
1247 BPoseView::HasPosesInClipboard()
1248 {
1249 	return fHasPosesInClipboard;
1250 }
1251 
1252 
1253 inline void
1254 BPoseView::SetHasPosesInClipboard(bool hasPoses)
1255 {
1256 	fHasPosesInClipboard = hasPoses;
1257 }
1258 
1259 
1260 inline PoseList*
1261 BPoseView::CurrentPoseList() const
1262 {
1263 	return fFiltering ? fFilteredPoseList : fPoseList;
1264 }
1265 
1266 
1267 template<class Param1>
1268 void
1269 EachTextWidget(BPose* pose, BPoseView* poseView,
1270 	void (*func)(BTextWidget*, BPose*, BPoseView*, BColumn*, Param1), Param1 p1)
1271 {
1272 	for (int32 index = 0; ;index++) {
1273 		BColumn* column = poseView->ColumnAt(index);
1274 		if (column == NULL)
1275 			break;
1276 
1277 		BTextWidget* widget = pose->WidgetFor(column->AttrHash());
1278 		if (widget != NULL)
1279 			(func)(widget, pose, poseView, column, p1);
1280 	}
1281 }
1282 
1283 
1284 template<class Param1, class Param2>
1285 void
1286 EachTextWidget(BPose* pose, BPoseView* poseView,
1287 	void (*func)(BTextWidget*, BPose*, BPoseView*, BColumn*,
1288 	Param1, Param2), Param1 p1, Param2 p2)
1289 {
1290 	for (int32 index = 0; ;index++) {
1291 		BColumn* column = poseView->ColumnAt(index);
1292 		if (column == NULL)
1293 			break;
1294 
1295 		BTextWidget* widget = pose->WidgetFor(column->AttrHash());
1296 		if (widget != NULL)
1297 			(func)(widget, pose, poseView, column, p1, p2);
1298 	}
1299 }
1300 
1301 
1302 template<class Result, class Param1, class Param2>
1303 Result
1304 WhileEachTextWidget(BPose* pose, BPoseView* poseView,
1305 	Result (*func)(BTextWidget*, BPose*, BPoseView*, BColumn*,
1306 	Param1, Param2), Param1 p1, Param2 p2)
1307 {
1308 	for (int32 index = 0; ;index++) {
1309 		BColumn* column = poseView->ColumnAt(index);
1310 		if (column == NULL)
1311 			break;
1312 
1313 		BTextWidget* widget = pose->WidgetFor(column->AttrHash());
1314 		if (widget != NULL) {
1315 			Result result = (func)(widget, pose, poseView, column, p1, p2);
1316 			if (result != 0)
1317 				return result;
1318 		}
1319 	}
1320 
1321 	return 0;
1322 }
1323 
1324 
1325 } // namespace BPrivate
1326 
1327 using namespace BPrivate;
1328 
1329 
1330 #endif	// _POSE_VIEW_H
1331