home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2240.zip / wxWindows-2.4.0 / include / wx / filename.h < prev    next >
C/C++ Source or Header  |  2002-11-09  |  16KB  |  419 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        wx/filename.h
  3. // Purpose:     wxFileName - encapsulates a file path
  4. // Author:      Robert Roebling, Vadim Zeitlin
  5. // Modified by:
  6. // Created:     28.12.00
  7. // RCS-ID:      $Id: filename.h,v 1.32.2.1 2002/11/07 13:16:28 VZ Exp $
  8. // Copyright:   (c) 2000 Robert Roebling
  9. // Licence:     wxWindows license
  10. /////////////////////////////////////////////////////////////////////////////
  11.  
  12. #ifndef   _WX_FILENAME_H_
  13. #define   _WX_FILENAME_H_
  14.  
  15. #if defined(__GNUG__) && !defined(__APPLE__)
  16.     #pragma interface "filename.h"
  17. #endif
  18.  
  19. #ifndef WX_PRECOMP
  20.     #include  "wx/string.h"
  21. #endif
  22.  
  23. /*
  24.     TODO:
  25.  
  26.     1. support for drives under Windows
  27.     2. more file operations:
  28.         a) chmod()
  29.         b) [acm]time() - get and set
  30.         c) file size
  31.         d) file permissions with readable accessors for most common bits
  32.            such as IsReadable() &c
  33.         e) rename()?
  34.     3. SameFileAs() function to compare inodes under Unix
  35.  */
  36.  
  37. // ridiculously enough, this will replace DirExists with wxDirExists etc
  38. #include "wx/filefn.h"
  39. #include "wx/datetime.h"
  40.  
  41. class WXDLLEXPORT wxFile;
  42.  
  43. // ----------------------------------------------------------------------------
  44. // constants
  45. // ----------------------------------------------------------------------------
  46.  
  47. // the various values for the path format: this mainly affects the path
  48. // separator but also whether or not the path has the drive part (as under
  49. // Windows)
  50. enum wxPathFormat
  51. {
  52.     wxPATH_NATIVE = 0,      // the path format for the current platform
  53.     wxPATH_UNIX,
  54.     wxPATH_MAC,
  55.     wxPATH_DOS,
  56.     wxPATH_VMS,
  57.  
  58.     wxPATH_BEOS = wxPATH_UNIX,
  59.     wxPATH_WIN = wxPATH_DOS,
  60.     wxPATH_OS2 = wxPATH_DOS
  61. };
  62.  
  63. // the kind of normalization to do with the file name: these values can be
  64. // or'd together to perform several operations at once
  65. enum wxPathNormalize
  66. {
  67.     wxPATH_NORM_ENV_VARS = 0x0001,  // replace env vars with their values
  68.     wxPATH_NORM_DOTS     = 0x0002,  // squeeze all .. and . and prepend cwd
  69.     wxPATH_NORM_TILDE    = 0x0004,  // Unix only: replace ~ and ~user
  70.     wxPATH_NORM_CASE     = 0x0008,  // if case insensitive => tolower
  71.     wxPATH_NORM_ABSOLUTE = 0x0010,  // make the path absolute
  72.     wxPATH_NORM_LONG =     0x0020,  // make the path the long form
  73.     wxPATH_NORM_ALL      = 0x003f
  74. };
  75.  
  76. // what exactly should GetPath() return?
  77. enum
  78. {
  79.     wxPATH_GET_VOLUME    = 0x0001,  // include the volume if applicable
  80.     wxPATH_GET_SEPARATOR = 0x0002   // terminate the path with the separator
  81. };
  82.  
  83. // MkDir flags
  84. enum
  85. {
  86.     wxPATH_MKDIR_FULL    = 0x0001   // create directories recursively
  87. };
  88.  
  89. // ----------------------------------------------------------------------------
  90. // wxFileName: encapsulates a file path
  91. // ----------------------------------------------------------------------------
  92.  
  93. class WXDLLEXPORT wxFileName
  94. {
  95. public:
  96.     // constructors and assignment
  97.  
  98.         // the usual stuff
  99.     wxFileName() { Clear(); }
  100.     wxFileName( const wxFileName &filepath ) { Assign(filepath); }
  101.  
  102.         // from a full filename: if it terminates with a '/', a directory path
  103.         // is contructed (the name will be empty), otherwise a file name and
  104.         // extension are extracted from it
  105.     wxFileName( const wxString& fullpath, wxPathFormat format = wxPATH_NATIVE )
  106.         { Assign( fullpath, format ); }
  107.  
  108.         // from a directory name and a file name
  109.     wxFileName(const wxString& path,
  110.                const wxString& name,
  111.                wxPathFormat format = wxPATH_NATIVE)
  112.         { Assign(path, name, format); }
  113.  
  114.         // from a volume, directory name, file base name and extension
  115.     wxFileName(const wxString& volume,
  116.                const wxString& path,
  117.                const wxString& name,
  118.                const wxString& ext,
  119.                wxPathFormat format = wxPATH_NATIVE)
  120.         { Assign(volume, path, name, ext, format); }
  121.  
  122.         // from a directory name, file base name and extension
  123.     wxFileName(const wxString& path,
  124.                const wxString& name,
  125.                const wxString& ext,
  126.                wxPathFormat format = wxPATH_NATIVE)
  127.         { Assign(path, name, ext, format); }
  128.  
  129.         // the same for delayed initialization
  130.  
  131.     void Assign(const wxFileName& filepath);
  132.  
  133.     void Assign(const wxString& fullpath,
  134.                 wxPathFormat format = wxPATH_NATIVE);
  135.  
  136.     void Assign(const wxString& volume,
  137.                 const wxString& path,
  138.                 const wxString& name,
  139.                 const wxString& ext,
  140.                 wxPathFormat format = wxPATH_NATIVE);
  141.  
  142.     void Assign(const wxString& path,
  143.                 const wxString& name,
  144.                 wxPathFormat format = wxPATH_NATIVE);
  145.  
  146.     void Assign(const wxString& path,
  147.                 const wxString& name,
  148.                 const wxString& ext,
  149.                 wxPathFormat format = wxPATH_NATIVE)
  150.     {
  151.         // empty volume
  152.         Assign(_T(""), path, name, ext, format);
  153.     }
  154.  
  155.     void AssignDir(const wxString& dir, wxPathFormat format = wxPATH_NATIVE);
  156.  
  157.         // assorted assignment operators
  158.  
  159.     wxFileName& operator=(const wxFileName& filename)
  160.         { Assign(filename); return *this; }
  161.  
  162.     wxFileName& operator=(const wxString& filename)
  163.         { Assign(filename); return *this; }
  164.  
  165.         // reset all components to default, uninitialized state
  166.     void Clear();
  167.  
  168.         // static pseudo constructors
  169.     static wxFileName FileName(const wxString& file);
  170.     static wxFileName DirName(const wxString& dir);
  171.  
  172.     // file tests
  173.  
  174.         // is the filename valid at all?
  175.     bool IsOk() const { return !m_dirs.IsEmpty() || !m_name.IsEmpty(); }
  176.  
  177.         // does the file with this name exists?
  178.     bool FileExists();
  179.     static bool FileExists( const wxString &file );
  180.  
  181.         // does the directory with this name exists?
  182.     bool DirExists();
  183.     static bool DirExists( const wxString &dir );
  184.  
  185.         // VZ: also need: IsDirWritable(), IsFileExecutable() &c (TODO)
  186.  
  187.     // time functions
  188.  
  189.         // set the file last access/mod and creation times
  190.         // (any of the pointers may be NULL)
  191.     bool SetTimes(const wxDateTime *dtAccess,
  192.                   const wxDateTime *dtMod,
  193.                   const wxDateTime *dtCreate);
  194.  
  195.         // set the access and modification times to the current moment
  196.     bool Touch();
  197.  
  198.         // return the last access, last modification and create times
  199.         // (any of the pointers may be NULL)
  200.     bool GetTimes(wxDateTime *dtAccess,
  201.                   wxDateTime *dtMod,
  202.                   wxDateTime *dtCreate) const;
  203.  
  204.         // convenience wrapper: get just the last mod time of the file
  205.     wxDateTime GetModificationTime() const
  206.     {
  207.         wxDateTime dtMod;
  208.         (void)GetTimes(NULL, &dtMod, NULL);
  209.         return dtMod;
  210.     }
  211.  
  212. #ifdef __WXMAC__
  213.     bool MacSetTypeAndCreator( wxUint32 type , wxUint32 creator ) ;
  214.     bool MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator ) ;
  215.     // gets the 'common' type and creator for a certain extension
  216.     static bool MacFindDefaultTypeAndCreator( const wxString& ext , wxUint32 *type , wxUint32 *creator ) ;
  217.     // registers application defined extensions and their default type and creator
  218.     static void MacRegisterDefaultTypeAndCreator( const wxString& ext , wxUint32 type , wxUint32 creator ) ;
  219.     // looks up the appropriate type and creator from the registration and then sets
  220.     bool MacSetDefaultTypeAndCreator() ;
  221. #endif
  222.  
  223.     // various file/dir operations
  224.  
  225.         // retrieve the value of the current working directory
  226.     void AssignCwd(const wxString& volume = wxEmptyString);
  227.     static wxString GetCwd(const wxString& volume = wxEmptyString);
  228.  
  229.         // change the current working directory
  230.     bool SetCwd();
  231.     static bool SetCwd( const wxString &cwd );
  232.  
  233.         // get the value of user home (Unix only mainly)
  234.     void AssignHomeDir();
  235.     static wxString GetHomeDir();
  236.  
  237.         // get a temp file name starting with the specified prefix and open the
  238.         // file passed to us using this name for writing (atomically if
  239.         // possible)
  240.     void AssignTempFileName(const wxString& prefix, wxFile *fileTemp = NULL);
  241.     static wxString CreateTempFileName(const wxString& prefix,
  242.                                        wxFile *fileTemp = NULL);
  243.  
  244.     // directory creation and removal.
  245.     // if full is TRUE, will try to make each directory in the path.
  246.     bool Mkdir( int perm = 0777, int flags = 0);
  247.     static bool Mkdir( const wxString &dir, int perm = 0777, int flags = 0 );
  248.  
  249.     bool Rmdir();
  250.     static bool Rmdir( const wxString &dir );
  251.  
  252.     // operations on the path
  253.  
  254.         // normalize the path: with the default flags value, the path will be
  255.         // made absolute, without any ".." and "." and all environment
  256.         // variables will be expanded in it
  257.         //
  258.         // this may be done using another (than current) value of cwd
  259.     bool Normalize(int flags = wxPATH_NORM_ALL,
  260.                    const wxString& cwd = wxEmptyString,
  261.                    wxPathFormat format = wxPATH_NATIVE);
  262.  
  263.         // get a path path relative to the given base directory, i.e. opposite
  264.         // of Normalize
  265.         //
  266.         // pass an empty string to get a path relative to the working directory
  267.         //
  268.         // returns TRUE if the file name was modified, FALSE if we failed to do
  269.         // anything with it (happens when the file is on a different volume,
  270.         // for example)
  271.     bool MakeRelativeTo(const wxString& pathBase = _T(""),
  272.                         wxPathFormat format = wxPATH_NATIVE);
  273.  
  274.  
  275.     // Comparison
  276.  
  277.         // compares with the rules of the given platforms format
  278.     bool SameAs(const wxFileName& filepath,
  279.                 wxPathFormat format = wxPATH_NATIVE) const;
  280.  
  281.         // compare with another filename object
  282.     bool operator==(const wxFileName& filename) const
  283.         { return SameAs(filename); }
  284.     bool operator!=(const wxFileName& filename) const
  285.         { return !SameAs(filename); }
  286.  
  287.         // compare with a filename string interpreted as a native file name
  288.     bool operator==(const wxString& filename) const
  289.         { return SameAs(wxFileName(filename)); }
  290.     bool operator!=(const wxString& filename) const
  291.         { return !SameAs(wxFileName(filename)); }
  292.  
  293.         // are the file names of this type cases sensitive?
  294.     static bool IsCaseSensitive( wxPathFormat format = wxPATH_NATIVE );
  295.  
  296.         // is this filename absolute?
  297.     bool IsAbsolute(wxPathFormat format = wxPATH_NATIVE) const;
  298.  
  299.         // is this filename relative?
  300.     bool IsRelative(wxPathFormat format = wxPATH_NATIVE) const
  301.         { return !IsAbsolute(format); }
  302.  
  303.     // Information about path format
  304.  
  305.     // get the string separating the volume from the path for this format,
  306.     // return an empty string if this format doesn't support the notion of
  307.     // volumes at all
  308.     static wxString GetVolumeSeparator(wxPathFormat format = wxPATH_NATIVE);
  309.  
  310.     // get the string of path separators for this format
  311.     static wxString GetPathSeparators(wxPathFormat format = wxPATH_NATIVE);
  312.  
  313.     // get the canonical path separator for this format
  314.     static wxChar GetPathSeparator(wxPathFormat format = wxPATH_NATIVE)
  315.         { return GetPathSeparators(format)[0u]; }
  316.  
  317.     // is the char a path separator for this format?
  318.     static bool IsPathSeparator(wxChar ch, wxPathFormat format = wxPATH_NATIVE);
  319.  
  320.     // Dir accessors
  321.     void AppendDir( const wxString &dir );
  322.     void PrependDir( const wxString &dir );
  323.     void InsertDir( int before, const wxString &dir );
  324.     void RemoveDir( int pos );
  325.     size_t GetDirCount() const { return m_dirs.GetCount(); }
  326.  
  327.     // Other accessors
  328.     void SetExt( const wxString &ext )          { m_ext = ext; }
  329.     wxString GetExt() const                     { return m_ext; }
  330.     bool HasExt() const                         { return !m_ext.empty(); }
  331.  
  332.     void SetName( const wxString &name )        { m_name = name; }
  333.     wxString GetName() const                    { return m_name; }
  334.     bool HasName() const                        { return !m_name.empty(); }
  335.  
  336.     void SetVolume( const wxString &volume )    { m_volume = volume; }
  337.     wxString GetVolume() const                  { return m_volume; }
  338.     bool HasVolume() const                      { return !m_volume.empty(); }
  339.  
  340.     // full name is the file name + extension (but without the path)
  341.     void SetFullName(const wxString& fullname);
  342.     wxString GetFullName() const;
  343.  
  344.     const wxArrayString& GetDirs() const        { return m_dirs; }
  345.  
  346.     // flags are combination of wxPATH_GET_XXX flags
  347.     wxString GetPath(int flags = 0, wxPathFormat format = wxPATH_NATIVE) const;
  348.  
  349.     // Replace current path with this one
  350.     void SetPath( const wxString &path, wxPathFormat format = wxPATH_NATIVE );
  351.  
  352.     // Construct full path with name and ext
  353.     wxString GetFullPath( wxPathFormat format = wxPATH_NATIVE ) const;
  354.  
  355.     // Return the short form of the path (returns identity on non-Windows platforms)
  356.     wxString GetShortPath() const;
  357.  
  358.     // Return the long form of the path (returns identity on non-Windows platforms)
  359.     wxString GetLongPath() const;
  360.  
  361.     // Is this a file or directory (not necessarily an existing one)
  362.     bool IsDir() const { return m_name.empty() && m_ext.empty(); }
  363.  
  364.     // various helpers
  365.  
  366.         // get the canonical path format for this platform
  367.     static wxPathFormat GetFormat( wxPathFormat format = wxPATH_NATIVE );
  368.  
  369.         // split a fullpath into the volume, path, (base) name and extension
  370.         // (all of the pointers can be NULL)
  371.     static void SplitPath(const wxString& fullpath,
  372.                           wxString *volume,
  373.                           wxString *path,
  374.                           wxString *name,
  375.                           wxString *ext,
  376.                           wxPathFormat format = wxPATH_NATIVE);
  377.  
  378.         // compatibility version
  379.     static void SplitPath(const wxString& fullpath,
  380.                           wxString *path,
  381.                           wxString *name,
  382.                           wxString *ext,
  383.                           wxPathFormat format = wxPATH_NATIVE);
  384.  
  385.  
  386.     // deprecated methods, don't use any more
  387.     // --------------------------------------
  388.  
  389.     wxString GetPath( bool withSep, wxPathFormat format = wxPATH_NATIVE ) const
  390.         { return GetPath(withSep ? wxPATH_GET_SEPARATOR : 0, format); }
  391.  
  392.     wxString GetPathWithSep(wxPathFormat format = wxPATH_NATIVE ) const
  393.         { return GetPath(wxPATH_GET_SEPARATOR, format); }
  394.  
  395. private:
  396.     // the drive/volume/device specification (always empty for Unix)
  397.     wxString        m_volume;
  398.  
  399.     // the path components of the file
  400.     wxArrayString   m_dirs;
  401.  
  402.     // the file name and extension (empty for directories)
  403.     wxString        m_name,
  404.                     m_ext;
  405.  
  406.     // when m_dirs is empty it may mean either that we have no path at all or
  407.     // that our path is '/', i.e. the root directory
  408.     //
  409.     // we use m_relative to distinguish between these two cases, it will be
  410.     // TRUE in the former and FALSE in the latter
  411.     //
  412.     // NB: the path is not absolute just because m_relative is FALSE, it still
  413.     //     needs the drive (i.e. volume) in some formats (Windows)
  414.     bool            m_relative;
  415. };
  416.  
  417. #endif // _WX_FILENAME_H_
  418.  
  419.