haiku.git

/*
Open Tracker License

Terms and Conditions

Copyright (c) 1991-2000, Be Incorporated. All rights reserved.

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice applies to all licensees
and shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of Be Incorporated shall not be
used in advertising or otherwise to promote the sale, use or other dealings in
this Software without prior written authorization from Be Incorporated.

Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks
of Be Incorporated in the United States and other countries. Other brand product
names are registered trademarks or trademarks of their respective holders.
All rights reserved.
*/
#ifndef _FIND_PANEL_H
#define _FIND_PANEL_H


#include <ByteOrder.h>
#include <FilePanel.h>
#include <ObjectList.h>
#include <View.h>
#include <Window.h>

#include "DialogPane.h"
#include "MimeTypeList.h"
#include "Utilities.h"
#include "NodeWalker.h"


class BFilePanel;
class BQuery;
class BBox;
class BTextControl;
class BCheckBox;
class BMenuBar;
class BMenuField;
class BFile;
class BPopUpMenu;
class BGroupView;
class BGridLayout;

namespace BPrivate {

class FindPanel;
class Model;
class DraggableIcon;
class TAttrView;

const uint32 kVolumeItem = 'Fvol';
const uint32 kAttributeItemMain = 'Fatr';
const uint32 kByNameItem = 'Fbyn';
const uint32 kByAttributeItem = 'Fbya';
const uint32 kByFormulaItem = 'Fbyq';
const uint32 kAddItem = 'Fadd';
const uint32 kRemoveItem = 'Frem';

const uint32 kSaveQueryOrTemplate = 'FSaQ';
const uint32 kOpenSaveAsPanel = 'Fosv';
const uint32 kOpenLoadQueryPanel = 'Folo';
const uint32 kTemporaryOptionClicked = 'FTCl';
const uint32 kSearchInTrashOptionClicked = 'FSCl';

const uint32 kSelectDirectoryFilter = 'FSeD';
const uint32 kAddDirectoryFilters = 'FAdF';
const uint32 kRemoveDirectoryFilter = 'FRmD';

#ifdef _IMPEXP_TRACKER
_IMPEXP_TRACKER
#endif
BMenu* TrackerBuildRecentFindItemsMenu(const char* title);

struct MoreOptionsStruct {
			// Some options used to be in a collapsable part of the window, but
			// this was removed. Now the options are always visible.
			bool 				showMoreOptions;
			bool 				searchTrash;
			// reserve a bunch of fields so that we can add stuff later but not
			// make old queries incompatible. Reserved fields are set to 0 when
			// saved
			int32 				reserved1;
			bool 				temporary;
			bool 				reserved9;
			bool 				reserved10;
			bool 				reserved11;
			int32 				reserved3;
			int32 				reserved4;
			int32 				reserved5;
			int32 				reserved6;
			int32 				reserved7;
			int32 				reserved8;

								MoreOptionsStruct()
									:
									showMoreOptions(true),
									searchTrash(false),
									reserved1(0),
									temporary(true),
									reserved9(false),
									reserved10(false),
									reserved11(false),
									reserved3(0),
									reserved4(0),
									reserved5(0),
									reserved6(0),
									reserved7(0),
									reserved8(0)
								{}

	static	void				EndianSwap(void* castToThis);

	static	void 				SetQueryTemporary(BNode*, bool on);
	static	bool 				QueryTemporary(const BNode*);
};


class FindWindow : public BWindow {
public:
								FindWindow(const entry_ref* ref = NULL,
									bool editIfTemplateOnly = false);
	virtual 					~FindWindow();

			FindPanel* 			BackgroundView() const { return fBackground; }

			BNode* 				QueryNode() const { return fFile; }

	// reads in the query name from either a saved name in a template
	// or form a saved query name
	const 	char* 				QueryName() const;

	static 	bool 				IsQueryTemplate(BNode* file);
			void				SetOptions(bool searchInTrash);
			void				AddIconToMenuBar(BView*);

protected:
	virtual	void 				MessageReceived(BMessage* message);

private:
	static 	BFile* 				TryOpening(const entry_ref* ref);
	static 	BPath 				GetQueriesDirectory();
			void 				SaveQueryAttributes(BNode* file, bool templateQuery);

			// retrieve the results
			void 				Find();
			// save the contents of the find window into the query file
			void 				Save();

			void 				SwitchToTemplate(const entry_ref*);
			bool 				FindSaveCommon(bool find);

			status_t 			SaveQueryAsAttributes(BNode*, BEntry*, bool queryTemplate,
									const BMessage* oldAttributes = 0,
									const BPoint* oldLocation = 0, bool temporary = true);

			void 				GetDefaultName(BString&);
			// dynamic date is a date such as 'today'
			void 				GetPredicateString(BString&, bool& dynamicDate);

			void				BuildMenuBar();
			void				PopulateTemplatesMenu();
			void				UpdateFileReferences(const entry_ref*);
			void				ClearHistoryOrTemplates(bool clearTemplates, bool temporaryOnly);
			status_t			DeleteQueryOrTemplate(BEntry*);

private:
			BFile* 				fFile;
			entry_ref 			fRef;
			bool 				fFromTemplate;
			bool 				fEditTemplateOnly;
			FindPanel* 			fBackground;
	mutable BString 			fQueryNameFromTemplate;
			BFilePanel* 		fSaveAsPanel;
			BFilePanel*			fOpenQueryPanel;

			// Menu Bar For New Panel
			BGroupView*			fMenuBarContainer;
			BMenuBar*			fMenuBar;
			BMenu*				fQueryMenu;
			BMenuItem*			fSaveQueryOrTemplateItem;
			BMenu*				fOptionsMenu;
			BMenu*				fTemplatesMenu;
			BMenu*				fHistoryMenu;
			BMenu*				fSaveAsMenu;
			BMenuItem*			fSearchInTrash;

	typedef BWindow _inherited;
};


class FindPanel : public BView {
public:
								FindPanel(BFile*, FindWindow* parent, bool fromTemplate,
									bool editTemplateOnly);
	virtual 					~FindPanel();

	virtual	void 				AttachedToWindow();
	virtual	void 				Draw(BRect updateRect);
	virtual	void 				MessageReceived(BMessage*);

			void 				BuildAttrQuery(BQuery*, bool& dynamicDate) const;
			BPopUpMenu* 		MimeTypeMenu() const { return fMimeTypeMenu; }
			BMenuItem* 			CurrentMimeType(const char** type = NULL) const;
			status_t 			SetCurrentMimeType(BMenuItem* item);
			status_t 			SetCurrentMimeType(const char* label);

			BPopUpMenu* 		VolMenu(int32* firstVolumeItem = NULL,
									int32* volumeItemsCount = NULL) const;
			uint32 				Mode() const { return fMode; }

	static 	uint32 				InitialMode(const BNode* entry);
			void 				SaveWindowState(BNode*, bool editTemplate);

			void 				SwitchToTemplate(const BNode*);

			// build up a query from by-attribute items
			void 				GetByAttrPredicate(BQuery*, bool& dynamicDate) const;
			// build up a simple query from the name we are searching for
			void 				GetByNamePredicate(BQuery*) const;

			void 				GetDefaultName(BString&) const;
			void 				GetDefaultAttrName(BString&, int32) const;
	// name filled out in the query name text field
	const 	char* 				UserSpecifiedName() const;

	// populate the recent query menu with query templates and recent queries
	static 	void 				AddRecentQueries(BMenu*, bool addSaveAsItem,
									const BMessenger* target, uint32 what,
									bool includeTemplates = true);

			status_t			SaveDirectoryFiltersToFile(BNode*);
			void				LoadDirectoryFiltersFromFile(const BNode*);

private:
	void 						AddMimeTypesToMenu();
	static 	bool 				AddOneMimeTypeToMenu(const ShortMimeInfo*, void* castToMenu);

			void 				AddVolumes();

			void 				ShowVolumeMenuLabel();
			BString				MultipleSelectionsTitle(int32);

			// add one more attribute item to the attr view
			void 				AddAttrRow();
			// remove the last attribute item
			void 				RemoveAttrRow();
			void 				AddFirstAttr();

			// panel building/restoring calls
			void 				RestoreWindowState(const BNode*);
			void 				RestoreMimeTypeMenuSelection(const BNode*);
			void 				AddByAttributeItems(const BNode*);
			void 				RemoveByAttributeItems();
			void 				RemoveAttrViewItems(bool removeGrid = true);
			// MimeTypeWindow is only shown in kByNameItem and kByAttributeItem modes
			void 				ShowOrHideMimeTypeMenu();

			void 				AddAttributeControls(int32);

			// fMode gets set by this and the call relies on it being up-to-date
			void 				ShowOrHideMoreOptions(bool show);
	static 	int32 				InitialAttrCount(const BNode*);
			void 				FillCurrentQueryName(BTextControl*, FindWindow*);
			void 				AddByNameOrFormulaItems();
			void 				SetupAddRemoveButtons();

			// go from search by name to search by attribute, etc.
			void 				SwitchMode(uint32);

			void 				PushMimeType(BQuery* query) const;

			void 				SaveAsQueryOrTemplate(const entry_ref*,
									const char*, bool queryTemplate);

			BView* 				FindAttrView(const char*, int row) const;

			void 				AddAttributes(BMenu* menu, const BMimeType& type);
			void 				AddMimeTypeAttrs(BMenu* menu);
			void 				RestoreAttrState(const BMessage&, int32);
			void 				SaveAttrState(BMessage*, int32);
			void 				AddLogicMenu(int32, bool selectAnd = true);
			void 				RemoveLogicMenu(int32);

			void 				ResizeMenuField(BMenuField*);

			status_t			AddDirectoryFiltersToMenu(BMenu*, BHandler* target);
			status_t			AddDirectoryFilter(const entry_ref* ref, bool addToMenu = true);
			void				RemoveDirectoryFilter(const entry_ref* ref);
	static	status_t			AddDirectoryFilterItemToMenu(BMenu*, const entry_ref* ref,
									BHandler* target, int32 index = -1);
			void				UnmarkDisks();
			void				MarkDiskAccordingToDirectoryFilter(entry_ref*);

public:
			BObjectList<entry_ref>	fDirectoryFilters;

private:
			uint32 				fMode;
			BGridLayout*		fAttrGrid;
			BPopUpMenu* 		fMimeTypeMenu;
			BMenuField* 		fMimeTypeField;
			BPopUpMenu*			fSearchModeMenu;
			BMenuField* 		fSearchModeField;
			BPopUpMenu* 		fVolMenu;
			int32				fFirstVolumeItem, fVolumeItemsCount;
			BMenuField* 		fVolumeField;
			BPopUpMenu* 		fRecentQueries;
			BBox* 				fMoreOptions;
			BTextControl* 		fQueryName;
			BString 			fInitialQueryName;

			DraggableIcon* 		fDraggableIcon;

			BFilePanel*			fDirectorySelectPanel;

			bool				fAddSeparatorItemState;

	typedef BView _inherited;

	friend class RecentQueriesPopUp;
};


// transient queries get deleted if they didn't get used in a while;
// this is the task that takes care of it
class DeleteTransientQueriesTask {
public:
	virtual 					~DeleteTransientQueriesTask();

	static 	void 				StartUpTransientQueryCleaner();

			// returns true when done
			bool 				DoSomeWork();

protected:
								DeleteTransientQueriesTask();

			void 				Initialize();
			bool 				GetSome();

			bool 				ProcessOneRef(Model*);

protected:
			enum State {
				kInitial,
				kAllocatedWalker,
				kTraversing,
				kError
			};

			static bool			QueryOldEnough(Model* model);

protected:
			State 				state;

private:
			static const int32 kBatchCount = 100;
			static const int32 kDaysToExpire = 7;

			BTrackerPrivate::TNodeWalker* fWalker;
};


class RecentFindItemsMenu : public BMenu {
public:
								RecentFindItemsMenu(const char* title,
									const BMessenger* target, uint32 what);

protected:
	virtual void 				AttachedToWindow();

private:
			BMessenger 			fTarget;
			uint32 				fWhat;
};


// query/query template drag&drop helper
class DraggableQueryIcon : public DraggableIcon {
public:
								DraggableQueryIcon(BRect frame, const char* name,
									const BMessage* message, BMessenger target,
									uint32 resizeFlags = B_FOLLOW_LEFT | B_FOLLOW_TOP,
									uint32 flags = B_WILL_DRAW);

protected:
	virtual bool 				DragStarted(BMessage*);
};


class FolderFilter : public BRefFilter {
public:
	virtual	bool				Filter(const entry_ref*, BNode*, struct stat_beos*, const char*);
};

} // namespace BPrivate

using namespace BPrivate;

#endif	// _FIND_PANEL_H