]> git.saurik.com Git - wxWidgets.git/blobdiff - interface/wx/filename.h
Correctly document the library the classes belong to.
[wxWidgets.git] / interface / wx / filename.h
index be88a2631ec5415fbecd8311fc5b11f8712b2a27..cc6ccc9d5aee2b846f382acbbeae292c14d5b7aa 100644 (file)
@@ -3,7 +3,7 @@
 // Purpose:     interface of wxFileName
 // Author:      wxWidgets team
 // RCS-ID:      $Id$
-// Licence:     wxWindows license
+// Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 
@@ -28,6 +28,25 @@ enum wxPathFormat
     wxPATH_MAX   //!< Not a valid value for specifying path format
 };
 
+/**
+    Different conventions for human readable sizes.
+
+    @see wxFileName::GetHumanReadableSize().
+
+    @since 2.9.1
+*/
+enum wxSizeConvention
+{
+    /// 1024 bytes = 1KB.
+    wxSIZE_CONV_TRADITIONAL,
+
+    /// 1024 bytes = 1KiB.
+    wxSIZE_CONV_IEC,
+
+    /// 1000 bytes = 1KB.
+    wxSIZE_CONV_SI
+};
+
 
 /**
     The kind of normalization to do with the file name: these values can be
@@ -110,7 +129,7 @@ wxULongLong wxInvalidSize;
     wxFileName::IsDirReadable() use wxFileName::GetPath() whereas methods dealing
     with file names like wxFileName::IsFileReadable() use wxFileName::GetFullPath().
 
-    If it is not known wether a string contains a directory name or a complete
+    If it is not known whether a string contains a directory name or a complete
     file name (such as when interpreting user input) you need to use the static
     function wxFileName::DirExists() (or its identical variants wxDir::Exists() and
     wxDirExists()) and construct the wxFileName instance accordingly.
@@ -313,7 +332,7 @@ public:
                 wxPathFormat format = wxPATH_NATIVE);
 
     /**
-        Creates the file name from volumne, path, name and extension.
+        Creates the file name from volume, path, name and extension.
     */
     void Assign(const wxString& volume, const wxString& path,
                 const wxString& name,
@@ -322,7 +341,7 @@ public:
                 wxPathFormat format = wxPATH_NATIVE);
 
     /**
-        Creates the file name from volumne, path, name and extension.
+        Creates the file name from volume, path, name and extension.
     */
     void Assign(const wxString& volume, const wxString& path,
                 const wxString& name,
@@ -402,42 +421,59 @@ public:
     */
     void ClearExt();
 
-    //@{
+
     /**
         Returns a temporary file name starting with the given @e prefix.
-        If the @a prefix is an absolute path, the temporary file is created in this
-        directory, otherwise it is created in the default system directory for the
-        temporary files or in the current directory.
+        If @a prefix is an absolute path and ends in a separator, the
+        temporary file is created in this directory; if it is an absolute
+        filepath or there is no separator, the temporary file is created in its
+        path, with the 'name' segment prepended to the temporary filename;
+        otherwise it is created in the default system directory for temporary
+        files or in the current directory.
 
         If the function succeeds, the temporary file is actually created.
-        If @a fileTemp is not @NULL, this file will be opened using the name of
-        the temporary file. When possible, this is done in an atomic way ensuring that
-        no race condition occurs between the temporary file name generation and opening
-        it which could often lead to security compromise on the multiuser systems.
-        If @a fileTemp is @NULL, the file is only created, but not opened.
+        If @a fileTemp is not @NULL, this wxFile will be opened using the name of
+        the temporary file. Where possible this is done in an atomic way to ensure that
+        no race condition occurs between creating the temporary file name and opening
+        it, which might lead to a security compromise on multiuser systems.
+        If @a fileTemp is @NULL, the file is created but not opened.
         Under Unix, the temporary file will have read and write permissions for the
-        owner only to minimize the security problems.
+        owner only, to minimize security problems.
 
         @param prefix
-            Prefix to use for the temporary file name construction
+            Location to use for the temporary file name construction. If @a prefix
+            is a directory it must have a terminal separator
         @param fileTemp
-            The file to open or @NULL to just get the name
+            The file to open, or @NULL just to get the name
 
-        @return The full temporary file name or an empty string on error.
+        @return The full temporary filepath, or an empty string on error.
     */
     static wxString CreateTempFileName(const wxString& prefix,
                                        wxFile* fileTemp = NULL);
+
+    /**
+        This is the same as CreateTempFileName(const wxString &prefix, wxFile *fileTemp)
+        but takes a wxFFile parameter instead of wxFile.
+    */
     static wxString CreateTempFileName(const wxString& prefix,
                                        wxFFile* fileTemp = NULL);
-    //@}
+
 
     /**
         Returns @true if the directory with this name exists.
+
+        Notice that this function tests the directory part of this object,
+        i.e. the string returned by GetPath(), and not the full path returned
+        by GetFullPath().
+
+        @see FileExists(), Exists()
     */
     bool DirExists() const;
 
     /**
-        Returns @true if the directory with this name exists.
+        Returns @true if the directory with name @a dir exists.
+
+        @see FileExists(), Exists()
     */
     static bool DirExists(const wxString& dir);
 
@@ -448,17 +484,61 @@ public:
     static wxFileName DirName(const wxString& dir,
                               wxPathFormat format = wxPATH_NATIVE);
 
+    /**
+        Turns off symlink dereferencing.
+
+        By default, all operations in this class work on the target of a
+        symbolic link (symlink) if the path of the file is actually a symlink.
+        Using this method allows to turn off this "symlink following" behaviour
+        and apply the operations to this path itself, even if it is a symlink.
+
+        The following methods are currently affected by this option:
+            - GetTimes() (but not SetTimes() as there is no portable way to
+              change the time of symlink itself).
+            - Existence checks: FileExists(), DirExists() and Exists() (notice
+              that static versions of these methods always follow symlinks).
+            - IsSameAs().
+
+        @see ShouldFollowLink()
+
+        @since 2.9.5
+    */
+    void DontFollowLink();
+
+     /**
+        Calls the static overload of this function with the full path of this
+        object.
+
+        @since 2.9.4
+     */
+    bool Exists() const;
+
+    /**
+        Returns @true if either a file or a directory or something else with
+        this name exists in the file system.
+
+        This method is equivalent to @code FileExists() || DirExists() @endcode
+        under most systems but under Unix it also returns true if the file
+        identifies a special file system object such as a device, a socket or a
+        FIFO.
+
+        @since 2.9.4
+
+        @see FileExists(), DirExists()
+     */
+    static bool Exists(const wxString& path);
+
     /**
         Returns @true if the file with this name exists.
 
-        @see DirExists()
+        @see DirExists(), Exists()
     */
     bool FileExists() const;
 
     /**
-        Returns @true if the file with this name exists.
+        Returns @true if the file with name @a file exists.
 
-        @see DirExists()
+        @see DirExists(), Exists()
     */
     static bool FileExists(const wxString& file);
 
@@ -522,30 +602,41 @@ public:
     */
     static wxString GetHomeDir();
 
+    //@{
     /**
-        Returns the size of the file in a human-readable form.
-
-        If the size could not be retrieved the @c failmsg string
-        is returned. In case of success, the returned string is
-        a floating-point number with @c precision decimal digits
-        followed by the size unit (B, kB, MB, GB, TB: respectively
-        bytes, kilobytes, megabytes, gigabytes, terabytes).
-    */
-    wxString GetHumanReadableSize(const wxString& failmsg = "Not available",
-                                  int precision = 1) const;
-
-    /**
-        Returns the size of the given number of bytes in a human-readable form.
-
-        If @a bytes is ::wxInvalidSize or zero, then @a nullsize is returned.
-
-        In case of success, the returned string is a floating-point number with
-        @a precision decimal digits followed by the size unit (B, kB, MB, GB,
-        TB: respectively bytes, kilobytes, megabytes, gigabytes, terabytes).
-    */
-    static wxString GetHumanReadableSize(const wxULongLong& bytes,
-                                         const wxString& nullsize = "Not available",
-                                         int precision = 1);
+        Returns the representation of the file size in a human-readable form.
+
+        In the first version, the size of this file is used. In the second one,
+        the specified size @a bytes is used.
+
+        If the file size could not be retrieved or @a bytes is ::wxInvalidSize
+        or zero, the @c failmsg string is returned.
+
+        Otherwise the returned string is a floating-point number with @c
+        precision decimal digits followed by the abbreviation of the unit used.
+        By default the traditional, although incorrect, convention of using SI
+        units for multiples of 1024 is used, i.e. returned string will use
+        suffixes of B, KB, MB, GB, TB for bytes, kilobytes, megabytes,
+        gigabytes and terabytes respectively. With the IEC convention the names
+        of the units are changed to B, KiB, MiB, GiB and TiB for bytes,
+        kibibytes, mebibytes, gibibytes and tebibytes. Finally, with SI
+        convention the same B, KB, MB, GB and TB suffixes are used but in their
+        correct SI meaning, i.e. as multiples of 1000 and not 1024.
+
+        Support for the different size conventions is new in wxWidgets 2.9.1,
+        in previous versions only the traditional convention was implemented.
+    */
+    wxString
+    GetHumanReadableSize(const wxString& failmsg = _("Not available"),
+                         int precision = 1,
+                         wxSizeConvention conv = wxSIZE_CONV_TRADITIONAL) const;
+
+    static wxString
+    GetHumanReadableSize(const wxULongLong& bytes,
+                         const wxString& nullsize = _("Not available"),
+                         int precision = 1,
+                         wxSizeConvention conv = wxSIZE_CONV_TRADITIONAL);
+    //@}
 
     /**
         Return the long form of the path (returns identity on non-Windows platforms).
@@ -581,6 +672,10 @@ public:
         Don't include the trailing separator in the returned string. This is
         the default (the value of this flag is 0) and exists only for symmetry
         with wxPATH_GET_SEPARATOR.
+
+        @note If the path is a toplevel one (e.g. @c "/" on Unix or @c "C:\" on
+              Windows), then the returned path will contain trailing separator
+              even with @c wxPATH_NO_SEPARATOR.
     */
     wxString GetPath(int flags = wxPATH_GET_VOLUME,
                      wxPathFormat format = wxPATH_NATIVE) const;
@@ -819,6 +914,24 @@ public:
     static bool IsPathSeparator(wxChar ch,
                                 wxPathFormat format = wxPATH_NATIVE);
 
+    /**
+        Returns @true if the volume part of the path is a unique volume name.
+
+        This function will always return @false if the path format is not
+        wxPATH_DOS.
+
+        Unique volume names are Windows volume identifiers which remain the same
+        regardless of where the volume is actually mounted. Example of a path
+        using a volume name could be
+        @code
+            \\?\Volume{8089d7d7-d0ac-11db-9dd0-806d6172696f}\Program Files\setup.exe
+        @endcode
+
+        @since 2.9.1
+    */
+    static bool IsMSWUniqueVolumeNamePath(const wxString& path,
+                                          wxPathFormat format = wxPATH_NATIVE);
+
     /**
         Returns @true if this filename is not absolute.
     */
@@ -826,6 +939,8 @@ public:
 
     /**
         On Mac OS, gets the common type and creator for the given extension.
+
+        @onlyfor{wxosx}
     */
     static bool MacFindDefaultTypeAndCreator(const wxString& ext,
                                             wxUint32* type,
@@ -834,6 +949,8 @@ public:
     /**
         On Mac OS, registers application defined extensions and their default type
         and creator.
+
+        @onlyfor{wxosx}
     */
     static void MacRegisterDefaultTypeAndCreator(const wxString& ext,
                                                 wxUint32 type,
@@ -842,6 +959,8 @@ public:
     /**
         On Mac OS, looks up the appropriate type and creator from the registration
         and then sets it.
+
+        @onlyfor{wxosx}
     */
     bool MacSetDefaultTypeAndCreator();
 
@@ -914,9 +1033,16 @@ public:
                       int flags = 0);
 
     /**
-        Normalize the path. With the default flags value, the path will be
-        made absolute, without any ".." and "." and all environment
-        variables will be expanded in it.
+        Normalize the path.
+
+        With the default flags value, the path will be made absolute, without
+        any ".." and "." and all environment variables will be expanded in it.
+
+        Notice that in some rare cases normalizing a valid path may result in
+        an invalid wxFileName object. E.g. normalizing "./" path using
+        wxPATH_NORM_DOTS but not wxPATH_NORM_ABSOLUTE will result in a
+        completely empty and thus invalid object. As long as there is a non
+        empty file name the result of normalization will be valid however.
 
         @param flags
             The kind of normalization to do with the file name. It can be
@@ -1074,6 +1200,20 @@ public:
     */
     void SetName(const wxString& name);
 
+    /**
+        Sets the path.
+
+        The @a path argument includes both the path and the volume, if
+        supported by @a format.
+
+        Calling this function doesn't affect the name and extension components,
+        to change them as well you can use Assign() or just an assignment
+        operator.
+
+        @see GetPath()
+     */
+    void SetPath(const wxString& path, wxPathFormat format = wxPATH_NATIVE);
+
     /**
         Sets the file creation and last access/modification times (any of the pointers
         may be @NULL).
@@ -1087,6 +1227,17 @@ public:
     */
     void SetVolume(const wxString& volume);
 
+    /**
+        Return whether some operations will follow symlink.
+
+        By default, file operations "follow symlink", i.e. operate on its
+        target and not on the symlink itself. See DontFollowLink() for more
+        information.
+
+        @since 2.9.5
+    */
+    bool ShouldFollowLink() const;
+
     //@{
     /**
         This function splits a full file name into components: the volume (with the