1/* 2Open Tracker License 3 4Terms and Conditions 5 6Copyright (c) 1991-2000, Be Incorporated. All rights reserved. 7 8Permission is hereby granted, free of charge, to any person obtaining a copy of 9this software and associated documentation files (the "Software"), to deal in 10the Software without restriction, including without limitation the rights to 11use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies 12of the Software, and to permit persons to whom the Software is furnished to do 13so, subject to the following conditions: 14 15The above copyright notice and this permission notice applies to all licensees 16and shall be included in all copies or substantial portions of the Software. 17 18THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF TITLE, MERCHANTABILITY, 20FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21BE INCORPORATED BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION 23WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 25Except as contained in this notice, the name of Be Incorporated shall not be 26used in advertising or otherwise to promote the sale, use or other dealings in 27this Software without prior written authorization from Be Incorporated. 28 29Tracker(TM), Be(R), BeOS(R), and BeIA(TM) are trademarks or registered trademarks 30of Be Incorporated in the United States and other countries. Other brand product 31names are registered trademarks or trademarks of their respective holders. 32All rights reserved. 33*/ 34#ifndef FS_UTILS_H 35#define FS_UTILS_H 36 37 38#include <FindDirectory.h> 39#include <List.h> 40#include <ObjectList.h> 41#include <Point.h> 42#include <StorageDefs.h> 43 44#include <vector> 45 46#include "Model.h" 47 48 49// APIs/code in FSUtils.h and FSUtils.cpp is slated for a major cleanup 50// -- in other words, you will find a lot of ugly cruft in here 51 52class BDirectory; 53class BEntry; 54class BList; 55class BFile; 56 57namespace BPrivate { 58 59class BInfoWindow; 60 61//! Controls the copy engine; may be overriden to specify how conflicts are 62// handled, etc. 63class CopyLoopControl { 64public: 65 virtual ~CopyLoopControl(); 66 67 virtual void Init(uint32 jobKind); 68 virtual void Init(int32 totalItems, off_t totalSize, 69 const entry_ref* destDir = NULL, 70 bool showCount = true); 71 72 //! Inform that a file error occurred while copying <name>. 73 // \return \c True if user decided to continue 74 virtual bool FileError(const char* message, 75 const char* name, status_t error, 76 bool allowContinue); 77 78 virtual void UpdateStatus(const char* name, 79 const entry_ref& ref, int32 count, 80 bool optional = false); 81 82 //! \return \c true if canceled 83 virtual bool CheckUserCanceled(); 84 85 enum OverwriteMode { 86 kSkip, // do not replace, go to next entry 87 kReplace, // remove entry before copying new one 88 kMerge // for folders: leave existing folder, update 89 // contents leaving nonconflicting items 90 // for files: save original attributes on file 91 }; 92 93 //! Override to always overwrite, never overwrite, let user decide, 94 // compare dates, etc. 95 virtual OverwriteMode OverwriteOnConflict(const BEntry* srcEntry, 96 const char* destName, 97 const BDirectory* destDir, 98 bool srcIsDir, bool dstIsDir); 99 100 //! Override to prevent copying of a given file or directory 101 virtual bool SkipEntry(const BEntry*, bool file); 102 103 //! During a file copy, this is called every time a chunk of data 104 // is copied. Users may override to keep a running checksum. 105 virtual void ChecksumChunk(const char* block, size_t size); 106 107 //! This is called when a file is finished copying. Users of this 108 // class may override to verify that the checksum they've been 109 // computing in ChecksumChunk matches. If this returns true, 110 // the copy will continue. If false, if will abort. 111 virtual bool ChecksumFile(const entry_ref*); 112 113 virtual bool SkipAttribute(const char* attributeName); 114 virtual bool PreserveAttribute(const char* attributeName); 115}; 116 117 118//! This is the Tracker copy-specific version of CopyLoopControl. 119class TrackerCopyLoopControl : public CopyLoopControl { 120public: 121 TrackerCopyLoopControl(); 122 TrackerCopyLoopControl(uint32 jobKind); 123 TrackerCopyLoopControl(int32 totalItems, 124 off_t totalSize); 125 virtual ~TrackerCopyLoopControl(); 126 127 virtual void Init(uint32 state); 128 virtual void Init(int32 totalItems, off_t totalSize, 129 const entry_ref* destDir = NULL, 130 bool showCount = true); 131 132 virtual bool FileError(const char* message, 133 const char* name, status_t error, 134 bool allowContinue); 135 136 virtual void UpdateStatus(const char* name, 137 const entry_ref& ref, int32 count, 138 bool optional = false); 139 140 virtual bool CheckUserCanceled(); 141 142 virtual bool SkipAttribute(const char* attributeName); 143 144 145 // One can specify an entry_ref list with the source entries. This will 146 // then trigger the feature to pull additional source entries from the 147 // status window, such that the user can drop additional items onto the 148 // progress display of the ongoing copy process to copy these items to 149 // the same target directory. 150 typedef BObjectList<entry_ref> EntryList; 151 152 void SetSourceList(EntryList* list); 153 154private: 155 thread_id fThread; 156 157 EntryList* fSourceList; 158}; 159 160 161#define B_DESKTOP_DIR_NAME "Desktop" 162#define B_DISKS_DIR_NAME "Disks" 163#define B_TRASH_DIR_NAME "Trash" 164 165#ifndef _IMPEXP_TRACKER 166#define _IMPEXP_TRACKER 167#endif 168_IMPEXP_TRACKER status_t FSCopyAttributesAndStats(BNode*, BNode*, bool = true); 169 170_IMPEXP_TRACKER void FSDuplicate(BObjectList<entry_ref>* srcList, 171 BList* pointList); 172_IMPEXP_TRACKER void FSMoveToFolder(BObjectList<entry_ref>* srcList, BEntry*, 173 uint32 moveMode, BList* pointList = NULL); 174_IMPEXP_TRACKER void FSMakeOriginalName(char* name, BDirectory* destDir, 175 const char* suffix); 176_IMPEXP_TRACKER bool FSIsTrashDir(const BEntry*); 177_IMPEXP_TRACKER bool FSIsPrintersDir(const BEntry*); 178_IMPEXP_TRACKER bool FSIsDeskDir(const BEntry*); 179_IMPEXP_TRACKER bool FSIsHomeDir(const BEntry*); 180_IMPEXP_TRACKER bool FSIsRootDir(const BEntry*); 181_IMPEXP_TRACKER void FSMoveToTrash(BObjectList<entry_ref>* srcList, 182 BList* pointList = NULL, bool async = true); 183 // Deprecated 184 185void FSDeleteRefList(BObjectList<entry_ref>*, bool, bool confirm = true); 186void FSDelete(entry_ref*, bool, bool confirm = true); 187void FSRestoreRefList(BObjectList<entry_ref>* list, bool async); 188 189_IMPEXP_TRACKER status_t FSLaunchItem(const entry_ref* application, 190 const BMessage* refsReceived, bool async, bool openWithOK); 191 // Preferred way of launching; only pass an actual application in 192 // <application>, not a document; to open documents with the preferred 193 // app, pase 0 in <application> and stuff all the document refs into 194 // <refsReceived> Consider having silent mode that does not show alerts, 195 // just returns error code 196 197_IMPEXP_TRACKER status_t FSOpenWith(BMessage* listOfRefs); 198 // runs the Open With window; pas a list of refs 199 200_IMPEXP_TRACKER void FSEmptyTrash(); 201_IMPEXP_TRACKER status_t FSCreateNewFolderIn(const node_ref* destDir, 202 entry_ref* newRef, node_ref* new_node); 203_IMPEXP_TRACKER void FSCreateTrashDirs(); 204_IMPEXP_TRACKER status_t FSGetTrashDir(BDirectory* trashDir, dev_t volume); 205_IMPEXP_TRACKER status_t FSGetDeskDir(BDirectory* deskDir); 206_IMPEXP_TRACKER status_t FSRecursiveCalcSize(BInfoWindow*, 207 CopyLoopControl* loopControl, BDirectory*, off_t* runningSize, 208 int32* fileCount, int32* dirCount); 209 210bool FSInTrashDir(const entry_ref*); 211 212// doesn't need to be exported 213bool FSGetPoseLocation(const BNode* node, BPoint* point); 214status_t FSSetPoseLocation(BEntry* entry, BPoint point); 215status_t FSSetPoseLocation(ino_t destDirInode, BNode* destNode, BPoint point); 216status_t FSGetBootDeskDir(BDirectory* deskDir); 217 218status_t FSGetOriginalPath(BEntry* entry, BPath* path); 219 220enum ReadAttrResult { 221 kReadAttrFailed, 222 kReadAttrNativeOK, 223 kReadAttrForeignOK 224}; 225 226ReadAttrResult ReadAttr(const BNode*, const char* hostAttrName, 227 const char* foreignAttrName, type_code, off_t, void*, size_t, 228 void (*swapFunc)(void*) = 0, bool isForeign = false); 229 // Endian swapping ReadAttr call; endianness is determined by trying 230 // first the native attribute name, then the foreign one; an endian 231 // swapping function can be passed, if null data won't be swapped; 232 // if <isForeign> set the foreign endianness will be read directly 233 // without first trying the native one 234 235ReadAttrResult GetAttrInfo(const BNode*, const char* hostAttrName, 236 const char* foreignAttrName, type_code* = NULL, size_t* = NULL); 237 238status_t FSCreateNewFolder(const entry_ref*); 239status_t FSRecursiveCreateFolder(const char* path); 240void FSMakeOriginalName(BString &name, const BDirectory* destDir, 241 const char* suffix = 0); 242 243status_t FSGetParentVirtualDirectoryAware(const BEntry& entry, entry_ref& _ref); 244status_t FSGetParentVirtualDirectoryAware(const BEntry& entry, BEntry& _entry); 245status_t FSGetParentVirtualDirectoryAware(const BEntry& entry, BNode& _node); 246 247status_t TrackerLaunch(const entry_ref* appRef, bool async); 248status_t TrackerLaunch(const BMessage* refs, bool async, 249 bool okToRunOpenWith = true); 250status_t TrackerLaunch(const entry_ref* appRef, const BMessage* refs, 251 bool async, bool okToRunOpenWith = true); 252 253status_t FSFindTrackerSettingsDir(BPath*, bool autoCreate = true); 254 255bool FSIsDeskDir(const BEntry*); 256 257enum DestructiveAction { 258 kRename, 259 kMove 260}; 261 262bool ConfirmChangeIfWellKnownDirectory(const BEntry* entry, 263 DestructiveAction action, bool dontAsk = false, 264 int32* confirmedAlready = NULL); 265 266status_t EditModelName(const Model* model, const char* name, size_t); 267 // return B_OK if name was edited 268status_t ShouldEditRefName(const entry_ref* ref, const char* name, size_t); 269 // return B_OK if name should be edited 270 271bool CheckDevicesEqual(const entry_ref* entry, const Model* targetModel); 272 273// Deprecated calls use newer calls above instead 274_IMPEXP_TRACKER void FSLaunchItem(const entry_ref* appRef, 275 BMessage* refs = NULL, int32 workspace = -1); 276_IMPEXP_TRACKER status_t FSLaunchItem(const entry_ref* appRef, 277 BMessage* refs, int32 workspace, bool asynch); 278_IMPEXP_TRACKER void FSOpenWithDocuments(const entry_ref* executableToLaunch, 279 BMessage* documentEntryRefs); 280_IMPEXP_TRACKER status_t FSLaunchUsing(const entry_ref* ref, 281 BMessage* listOfRefs); 282 283 284// some extra directory_which values 285// move these to FindDirectory.h 286const uint32 B_USER_MAIL_DIRECTORY = 3500; 287const uint32 B_USER_QUERIES_DIRECTORY = 3501; 288const uint32 B_USER_PEOPLE_DIRECTORY = 3502; 289const uint32 B_USER_DOWNLOADS_DIRECTORY = 3503; 290const uint32 B_USER_DESKBAR_APPS_DIRECTORY = 3504; 291const uint32 B_USER_DESKBAR_PREFERENCES_DIRECTORY = 3505; 292const uint32 B_USER_DESKBAR_DEVELOP_DIRECTORY = 3506; 293const uint32 B_BOOT_DISK = 3507; 294 // map /boot into the directory_which enum for convenience 295 296class WellKnowEntryList { 297 // matches up names, id's and node_refs of well known entries in the 298 // system hierarchy 299 public: 300 struct WellKnownEntry { 301 WellKnownEntry(const node_ref* node, directory_which which, 302 const char* name) 303 : 304 node(*node), 305 which(which), 306 name(name) 307 { 308 } 309 310 // mwcc needs these explicitly to use vector 311 WellKnownEntry(const WellKnownEntry &clone) 312 : 313 node(clone.node), 314 which(clone.which), 315 name(clone.name) 316 { 317 } 318 319 WellKnownEntry() 320 { 321 } 322 323 node_ref node; 324 directory_which which; 325 BString name; 326 }; 327 328 static directory_which Match(const node_ref*); 329 static const WellKnownEntry* MatchEntry(const node_ref*); 330 static void Quit(); 331 332 private: 333 const WellKnownEntry* MatchEntryCommon(const node_ref*); 334 WellKnowEntryList(); 335 void AddOne(directory_which, const char* name); 336 void AddOne(directory_which, const char* path, const char* name); 337 void AddOne(directory_which, directory_which base, 338 const char* extension, const char* name); 339 340 std::vector<WellKnownEntry> entries; 341 static WellKnowEntryList* self; 342}; 343 344#if B_BEOS_VERSION_DANO 345#undef _IMPEXP_TRACKER 346#endif 347 348} // namespace BPrivate 349 350using namespace BPrivate; 351 352#endif // FS_UTILS_H 353