Note that VMS uses different separators unlike Unix:
: always after the device. If the path does not contain : than
the default (the device of the current directory) is assumed.
- [ start of directory specyfication
+ [ start of directory specification
. separator between directory and subdirectory
] between directory and file
*/
// headers
// ----------------------------------------------------------------------------
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "filename.h"
-#endif
-
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
// For GetShort/LongPathName
#ifdef __WIN32__
#include "wx/msw/wrapwin.h"
+#if defined(__MINGW32__)
+#include "wx/msw/gccpriv.h"
+#endif
#endif
#ifdef __WXWINCE__
{
SYSTEMTIME st;
st.wDay = dt.GetDay();
- st.wMonth = dt.GetMonth() + 1;
- st.wYear = dt.GetYear();
+ st.wMonth = (WORD)(dt.GetMonth() + 1);
+ st.wYear = (WORD)dt.GetYear();
st.wHour = dt.GetHour();
st.wMinute = dt.GetMinute();
st.wSecond = dt.GetSecond();
m_name = filepath.GetName();
m_ext = filepath.GetExt();
m_relative = filepath.m_relative;
+ m_hasExt = filepath.m_hasExt;
}
void wxFileName::Assign(const wxString& volume,
const wxString& path,
const wxString& name,
const wxString& ext,
+ bool hasExt,
wxPathFormat format )
{
SetPath( path, format );
m_volume = volume;
m_ext = ext;
m_name = name;
+
+ m_hasExt = hasExt;
}
-void wxFileName::SetPath( const wxString &path, wxPathFormat format )
+void wxFileName::SetPath( const wxString& pathOrig, wxPathFormat format )
{
m_dirs.Clear();
- if ( !path.empty() )
+ if ( pathOrig.empty() )
{
- wxPathFormat my_format = GetFormat( format );
- wxString my_path = path;
+ // no path at all
+ m_relative = true;
- // 1) Determine if the path is relative or absolute.
- wxChar leadingChar = my_path[0u];
+ return;
+ }
- switch (my_format)
- {
- case wxPATH_MAC:
- m_relative = leadingChar == wxT(':');
-
- // We then remove a leading ":". The reason is in our
- // storage form for relative paths:
- // ":dir:file.txt" actually means "./dir/file.txt" in
- // DOS notation and should get stored as
- // (relative) (dir) (file.txt)
- // "::dir:file.txt" actually means "../dir/file.txt"
- // stored as (relative) (..) (dir) (file.txt)
- // This is important only for the Mac as an empty dir
- // actually means <UP>, whereas under DOS, double
- // slashes can be ignored: "\\\\" is the same as "\\".
- if (m_relative)
- my_path.erase( 0, 1 );
- break;
+ format = GetFormat( format );
- case wxPATH_VMS:
- // TODO: what is the relative path format here?
- m_relative = false;
- break;
+ // 0) deal with possible volume part first
+ wxString volume,
+ path;
+ SplitVolume(pathOrig, &volume, &path, format);
+ if ( !volume.empty() )
+ {
+ m_relative = false;
- default:
- wxFAIL_MSG( _T("Unknown path format") );
- // !! Fall through !!
+ SetVolume(volume);
+ }
- case wxPATH_UNIX:
- // the paths of the form "~" or "~username" are absolute
- m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
- break;
+ // 1) Determine if the path is relative or absolute.
+ wxChar leadingChar = path[0u];
- case wxPATH_DOS:
- m_relative = !IsPathSeparator(leadingChar, my_format);
- break;
+ switch (format)
+ {
+ case wxPATH_MAC:
+ m_relative = leadingChar == wxT(':');
+
+ // We then remove a leading ":". The reason is in our
+ // storage form for relative paths:
+ // ":dir:file.txt" actually means "./dir/file.txt" in
+ // DOS notation and should get stored as
+ // (relative) (dir) (file.txt)
+ // "::dir:file.txt" actually means "../dir/file.txt"
+ // stored as (relative) (..) (dir) (file.txt)
+ // This is important only for the Mac as an empty dir
+ // actually means <UP>, whereas under DOS, double
+ // slashes can be ignored: "\\\\" is the same as "\\".
+ if (m_relative)
+ path.erase( 0, 1 );
+ break;
- }
+ case wxPATH_VMS:
+ // TODO: what is the relative path format here?
+ m_relative = false;
+ break;
- // 2) Break up the path into its members. If the original path
- // was just "/" or "\\", m_dirs will be empty. We know from
- // the m_relative field, if this means "nothing" or "root dir".
+ default:
+ wxFAIL_MSG( _T("Unknown path format") );
+ // !! Fall through !!
- wxStringTokenizer tn( my_path, GetPathSeparators(my_format) );
+ case wxPATH_UNIX:
+ // the paths of the form "~" or "~username" are absolute
+ m_relative = leadingChar != wxT('/') && leadingChar != _T('~');
+ break;
- while ( tn.HasMoreTokens() )
- {
- wxString token = tn.GetNextToken();
+ case wxPATH_DOS:
+ m_relative = !IsPathSeparator(leadingChar, format);
+ break;
- // Remove empty token under DOS and Unix, interpret them
- // as .. under Mac.
- if (token.empty())
- {
- if (my_format == wxPATH_MAC)
- m_dirs.Add( wxT("..") );
- // else ignore
- }
- else
- {
- m_dirs.Add( token );
- }
- }
}
- else // no path at all
+
+ // 2) Break up the path into its members. If the original path
+ // was just "/" or "\\", m_dirs will be empty. We know from
+ // the m_relative field, if this means "nothing" or "root dir".
+
+ wxStringTokenizer tn( path, GetPathSeparators(format) );
+
+ while ( tn.HasMoreTokens() )
{
- m_relative = true;
+ wxString token = tn.GetNextToken();
+
+ // Remove empty token under DOS and Unix, interpret them
+ // as .. under Mac.
+ if (token.empty())
+ {
+ if (format == wxPATH_MAC)
+ m_dirs.Add( wxT("..") );
+ // else ignore
+ }
+ else
+ {
+ m_dirs.Add( token );
+ }
}
}
wxPathFormat format)
{
wxString volume, path, name, ext;
- SplitPath(fullpath, &volume, &path, &name, &ext, format);
+ bool hasExt;
+ SplitPath(fullpath, &volume, &path, &name, &ext, &hasExt, format);
- Assign(volume, path, name, ext, format);
+ Assign(volume, path, name, ext, hasExt, format);
}
void wxFileName::Assign(const wxString& fullpathOrig,
}
wxString volume, path, name, ext;
+ bool hasExt;
// do some consistency checks in debug mode: the name should be really just
// the filename and the path should be really just a path
#ifdef __WXDEBUG__
- wxString pathDummy, nameDummy, extDummy;
+ wxString volDummy, pathDummy, nameDummy, extDummy;
- SplitPath(fullname, &pathDummy, &name, &ext, format);
+ SplitPath(fullname, &volDummy, &pathDummy, &name, &ext, &hasExt, format);
- wxASSERT_MSG( pathDummy.empty(),
+ wxASSERT_MSG( volDummy.empty() && pathDummy.empty(),
_T("the file name shouldn't contain the path") );
SplitPath(fullpath, &volume, &path, &nameDummy, &extDummy, format);
_T("the path shouldn't contain file name nor extension") );
#else // !__WXDEBUG__
- SplitPath(fullname, NULL /* no path */, &name, &ext, format);
+ SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
+ &name, &ext, &hasExt, format);
SplitPath(fullpath, &volume, &path, NULL, NULL, format);
#endif // __WXDEBUG__/!__WXDEBUG__
+ Assign(volume, path, name, ext, hasExt, format);
+}
+
+void wxFileName::Assign(const wxString& pathOrig,
+ const wxString& name,
+ const wxString& ext,
+ wxPathFormat format)
+{
+ wxString volume,
+ path;
+ SplitVolume(pathOrig, &volume, &path, format);
+
Assign(volume, path, name, ext, format);
}
void wxFileName::AssignDir(const wxString& dir, wxPathFormat format)
{
- Assign(dir, _T(""), format);
+ Assign(dir, wxEmptyString, format);
}
void wxFileName::Clear()
// we don't have any absolute path for now
m_relative = true;
+
+ // nor any extension
+ m_hasExt = false;
}
/* static */
return ::wxGetHomeDir();
}
+#if wxUSE_FILE
+
void wxFileName::AssignTempFileName(const wxString& prefix, wxFile *fileTemp)
{
wxString tempname = CreateTempFileName(prefix, fileTemp);
// use the directory specified by the prefix
SplitPath(prefix, &dir, &name, NULL /* extension */);
+ if (dir.empty())
+ {
+ dir = wxGetenv(_T("TMPDIR"));
+ if (dir.empty())
+ {
+ dir = wxGetenv(_T("TMP"));
+ if (dir.empty())
+ {
+ dir = wxGetenv(_T("TEMP"));
+ }
+ }
+ }
+
#if defined(__WXWINCE__)
if (dir.empty())
{
// FIXME. Create \temp dir?
- dir = wxT("\\");
+ if (DirExists(wxT("\\temp")))
+ dir = wxT("\\temp");
}
- path = dir + wxT("\\") + prefix;
+ path = dir + wxT("\\") + name;
int i = 1;
- while (wxFileExists(path))
+ while (FileExists(path))
{
- path = dir + wxT("\\") + prefix ;
+ path = dir + wxT("\\") + name ;
path << i;
i ++;
}
#else // !Windows
if ( dir.empty() )
{
-#if defined(__WXMAC__) && !defined(__DARWIN__)
- dir = wxMacFindFolder( (short) kOnSystemDisk, kTemporaryFolderType, kCreateFolder ) ;
-#else // !Mac
- dir = wxGetenv(_T("TMP"));
- if ( dir.empty() )
- {
- dir = wxGetenv(_T("TEMP"));
- }
-
- if ( dir.empty() )
- {
- // default
- #if defined(__DOS__) || defined(__OS2__)
- dir = _T(".");
- #else
- dir = _T("/tmp");
- #endif
- }
-#endif // Mac/!Mac
+ // default
+#if defined(__DOS__) || defined(__OS2__)
+ dir = _T(".");
+#elif defined(__WXMAC__)
+ dir = wxMacFindFolder(short(kOnSystemDisk), kTemporaryFolderType, kCreateFolder);
+#else
+ dir = _T("/tmp");
+#endif
}
path = dir;
else // mkstemp() succeeded
{
path = wxConvFile.cMB2WX( (const char*) buf );
-
+
// avoid leaking the fd
if ( fileTemp )
{
}
#else // !HAVE_MKTEMP (includes __DOS__)
// generate the unique file name ourselves
- #if !defined(__DOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
+ #if !defined(__DOS__) && !defined(__PALMOS__) && (!defined(__MWERKS__) || defined(__DARWIN__) )
path << (unsigned int)getpid();
#endif
{
// 3 hex digits is enough for numTries == 1000 < 4096
pathTry = path + wxString::Format(_T("%.03x"), (unsigned int) n);
- if ( !wxFile::Exists(pathTry) )
+ if ( !FileExists(pathTry) )
{
break;
}
path = pathTry;
#endif // HAVE_MKTEMP/!HAVE_MKTEMP
- if ( !path.empty() )
- {
- }
#endif // HAVE_MKSTEMP/!HAVE_MKSTEMP
#endif // Windows/!Windows
return path;
}
+#endif // wxUSE_FILE
+
// ----------------------------------------------------------------------------
// directory operations
// ----------------------------------------------------------------------------
size_t count = dirs.GetCount();
for ( size_t i = 0; i < count; i++ )
{
- if ( i > 0 ||
+ if ( i > 0 ||
#if defined(__WXMAC__) && !defined(__DARWIN__)
- // relative pathnames are exactely the other way round under mac...
- !filename.IsAbsolute()
+ // relative pathnames are exactely the other way round under mac...
+ !filename.IsAbsolute()
#else
- filename.IsAbsolute()
+ filename.IsAbsolute()
#endif
)
currPath += wxFILE_SEP_PATH;
m_dirs.Add(dir);
}
-
+
#if defined(__WIN32__) && !defined(__WXWINCE__) && wxUSE_OLE
if ( (flags & wxPATH_NORM_SHORTCUT) )
{
{
wxString path, file, ext;
wxSplitPath(shortcutPath, & path, & file, & ext);
-
- HRESULT hres;
- IShellLink* psl;
- bool success = FALSE;
+
+ HRESULT hres;
+ IShellLink* psl;
+ bool success = false;
// Assume it's not a shortcut if it doesn't end with lnk
- if (ext.Lower() != wxT("lnk"))
- return FALSE;
-
- // create a ShellLink object
- hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
- IID_IShellLink, (LPVOID*) &psl);
-
- if (SUCCEEDED(hres))
- {
- IPersistFile* ppf;
- hres = psl->QueryInterface( IID_IPersistFile, (LPVOID *) &ppf);
- if (SUCCEEDED(hres))
- {
- WCHAR wsz[MAX_PATH];
-
- MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, shortcutPath.mb_str(), -1, wsz,
- MAX_PATH);
-
- hres = ppf->Load(wsz, 0);
- if (SUCCEEDED(hres))
- {
+ if (ext.CmpNoCase(wxT("lnk"))!=0)
+ return false;
+
+ // create a ShellLink object
+ hres = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
+ IID_IShellLink, (LPVOID*) &psl);
+
+ if (SUCCEEDED(hres))
+ {
+ IPersistFile* ppf;
+ hres = psl->QueryInterface( IID_IPersistFile, (LPVOID *) &ppf);
+ if (SUCCEEDED(hres))
+ {
+ WCHAR wsz[MAX_PATH];
+
+ MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, shortcutPath.mb_str(), -1, wsz,
+ MAX_PATH);
+
+ hres = ppf->Load(wsz, 0);
+ if (SUCCEEDED(hres))
+ {
wxChar buf[2048];
- psl->GetPath(buf, 2048, NULL, SLGP_UNCPRIORITY);
- targetFilename = wxString(buf);
+ // Wrong prototype in early versions
+#if defined(__MINGW32__) && !wxCHECK_W32API_VERSION(2, 2)
+ psl->GetPath((CHAR*) buf, 2048, NULL, SLGP_UNCPRIORITY);
+#else
+ psl->GetPath(buf, 2048, NULL, SLGP_UNCPRIORITY);
+#endif
+ targetFilename = wxString(buf);
success = (shortcutPath != targetFilename);
- psl->GetArguments(buf, 2048);
+ psl->GetArguments(buf, 2048);
wxString args(buf);
- if (!args.IsEmpty() && arguments)
+ if (!args.empty() && arguments)
{
*arguments = args;
- }
- }
- }
- }
- psl->Release();
- return success;
+ }
+ }
+ }
+ }
+ psl->Release();
+ return success;
}
#endif
}
/* static */
-wxString wxFileName::GetVolumeSeparator(wxPathFormat format)
+wxString wxFileName::GetVolumeSeparator(wxPathFormat WXUNUSED_IN_WINCE(format))
{
+#ifdef __WXWINCE__
+ return wxEmptyString;
+#else
wxString sepVol;
if ( (GetFormat(format) == wxPATH_DOS) ||
//else: leave empty
return sepVol;
+#endif
}
/* static */
return seps;
}
+/* static */
+wxString wxFileName::GetPathTerminators(wxPathFormat format)
+{
+ format = GetFormat(format);
+
+ // under VMS the end of the path is ']', not the path separator used to
+ // separate the components
+ return format == wxPATH_VMS ? wxString(_T(']')) : GetPathSeparators(format);
+}
+
/* static */
bool wxFileName::IsPathSeparator(wxChar ch, wxPathFormat format)
{
// wxString::Find() doesn't work as expected with NUL - it will always find
- // it, so it is almost surely a bug if this function is called with NUL arg
- wxASSERT_MSG( ch != _T('\0'), _T("shouldn't be called with NUL") );
-
- return GetPathSeparators(format).Find(ch) != wxNOT_FOUND;
+ // it, so test for it separately
+ return ch != _T('\0') && GetPathSeparators(format).Find(ch) != wxNOT_FOUND;
}
// ----------------------------------------------------------------------------
return true;
}
-void wxFileName::AppendDir( const wxString &dir )
+void wxFileName::AppendDir( const wxString& dir )
{
if ( IsValidDirComponent(dir) )
m_dirs.Add( dir );
}
-void wxFileName::PrependDir( const wxString &dir )
+void wxFileName::PrependDir( const wxString& dir )
{
InsertDir(0, dir);
}
-void wxFileName::InsertDir( int before, const wxString &dir )
+void wxFileName::InsertDir(size_t before, const wxString& dir)
{
if ( IsValidDirComponent(dir) )
- m_dirs.Insert( dir, before );
+ m_dirs.Insert(dir, before);
}
-void wxFileName::RemoveDir( int pos )
+void wxFileName::RemoveDir(size_t pos)
{
- m_dirs.RemoveAt( (size_t)pos );
+ m_dirs.RemoveAt(pos);
}
// ----------------------------------------------------------------------------
void wxFileName::SetFullName(const wxString& fullname)
{
- SplitPath(fullname, NULL /* no path */, &m_name, &m_ext);
+ SplitPath(fullname, NULL /* no volume */, NULL /* no path */,
+ &m_name, &m_ext, &m_hasExt);
}
wxString wxFileName::GetFullName() const
{
wxString fullname = m_name;
- if ( !m_ext.empty() )
+ if ( m_hasExt )
{
fullname << wxFILE_SEP_EXT << m_ext;
}
}
// convert back from ".." to nothing
- if ( m_dirs[i] != wxT("..") )
+ if ( !m_dirs[i].IsSameAs(wxT("..")) )
fullpath += m_dirs[i];
break;
// TODO: What to do with ".." under VMS
// convert back from ".." to nothing
- if ( m_dirs[i] != wxT("..") )
+ if ( !m_dirs[i].IsSameAs(wxT("..")) )
fullpath += m_dirs[i];
break;
}
// Return the short form of the path (returns identity on non-Windows platforms)
wxString wxFileName::GetShortPath() const
{
-#if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
wxString path(GetFullPath());
- wxString pathOut;
+
+#if defined(__WXMSW__) && defined(__WIN32__) && !defined(__WXMICROWIN__) && !defined(__WXWINCE__)
DWORD sz = ::GetShortPathName(path, NULL, 0);
- bool ok = sz != 0;
- if ( ok )
+ if ( sz != 0 )
{
- ok = ::GetShortPathName
+ wxString pathOut;
+ if ( ::GetShortPathName
(
path,
wxStringBuffer(pathOut, sz),
sz
- ) != 0;
+ ) != 0 )
+ {
+ return pathOut;
+ }
}
- if (ok)
- return pathOut;
+#endif // Windows
return path;
-#else
- return GetFullPath();
-#endif
}
// Return the long form of the path (returns identity on non-Windows platforms)
path = GetFullPath();
#if defined(__WIN32__) && !defined(__WXMICROWIN__)
- bool success = false;
#if wxUSE_DYNAMIC_LOADER
typedef DWORD (WINAPI *GET_LONG_PATH_NAME)(const wxChar *, wxChar *, DWORD);
- static bool s_triedToLoad = false;
-
- if ( !s_triedToLoad )
+ // this is MT-safe as in the worst case we're going to resolve the function
+ // twice -- but as the result is the same in both threads, it's ok
+ static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
+ if ( !s_pfnGetLongPathName )
{
- // suppress the errors about missing GetLongPathName[AW]
- wxLogNull noLog;
+ static bool s_triedToLoad = false;
- s_triedToLoad = true;
- wxDynamicLibrary dllKernel(_T("kernel32"));
- if ( dllKernel.IsLoaded() )
+ if ( !s_triedToLoad )
{
- // may succeed or fail depending on the Windows version
- static GET_LONG_PATH_NAME s_pfnGetLongPathName = NULL;
-#ifdef _UNICODE
- s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameW"));
-#else
- s_pfnGetLongPathName = (GET_LONG_PATH_NAME) dllKernel.GetSymbol(_T("GetLongPathNameA"));
-#endif
+ s_triedToLoad = true;
- if ( s_pfnGetLongPathName )
- {
- DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
- bool ok = dwSize > 0;
+ wxDynamicLibrary dllKernel(_T("kernel32"));
- if ( ok )
- {
- DWORD sz = (*s_pfnGetLongPathName)(path, NULL, 0);
- ok = sz != 0;
- if ( ok )
- {
- ok = (*s_pfnGetLongPathName)
- (
- path,
- wxStringBuffer(pathOut, sz),
- sz
- ) != 0;
- success = true;
- }
- }
+ const wxChar* GetLongPathName = _T("GetLongPathName")
+#if wxUSE_UNICODE
+ _T("W");
+#else // ANSI
+ _T("A");
+#endif // Unicode/ANSI
+
+ if ( dllKernel.HasSymbol(GetLongPathName) )
+ {
+ s_pfnGetLongPathName = (GET_LONG_PATH_NAME)
+ dllKernel.GetSymbol(GetLongPathName);
}
+
+ // note that kernel32.dll can be unloaded, it stays in memory
+ // anyhow as all Win32 programs link to it and so it's safe to call
+ // GetLongPathName() even after unloading it
}
}
- if (success)
- return pathOut;
+ if ( s_pfnGetLongPathName )
+ {
+ DWORD dwSize = (*s_pfnGetLongPathName)(path, NULL, 0);
+ if ( dwSize > 0 )
+ {
+ if ( (*s_pfnGetLongPathName)
+ (
+ path,
+ wxStringBuffer(pathOut, dwSize),
+ dwSize
+ ) != 0 )
+ {
+ return pathOut;
+ }
+ }
+ }
#endif // wxUSE_DYNAMIC_LOADER
- if (!success)
- {
- // The OS didn't support GetLongPathName, or some other error.
- // We need to call FindFirstFile on each component in turn.
+ // The OS didn't support GetLongPathName, or some other error.
+ // We need to call FindFirstFile on each component in turn.
- WIN32_FIND_DATA findFileData;
- HANDLE hFind;
+ WIN32_FIND_DATA findFileData;
+ HANDLE hFind;
- if ( HasVolume() )
- pathOut = GetVolume() +
- GetVolumeSeparator(wxPATH_DOS) +
- GetPathSeparator(wxPATH_DOS);
- else
- pathOut = wxEmptyString;
+ if ( HasVolume() )
+ pathOut = GetVolume() +
+ GetVolumeSeparator(wxPATH_DOS) +
+ GetPathSeparator(wxPATH_DOS);
+ else
+ pathOut = wxEmptyString;
- wxArrayString dirs = GetDirs();
- dirs.Add(GetFullName());
+ wxArrayString dirs = GetDirs();
+ dirs.Add(GetFullName());
- wxString tmpPath;
+ wxString tmpPath;
- size_t count = dirs.GetCount();
- for ( size_t i = 0; i < count; i++ )
- {
- // We're using pathOut to collect the long-name path, but using a
- // temporary for appending the last path component which may be
- // short-name
- tmpPath = pathOut + dirs[i];
+ size_t count = dirs.GetCount();
+ for ( size_t i = 0; i < count; i++ )
+ {
+ // We're using pathOut to collect the long-name path, but using a
+ // temporary for appending the last path component which may be
+ // short-name
+ tmpPath = pathOut + dirs[i];
- if ( tmpPath.empty() )
- continue;
+ if ( tmpPath.empty() )
+ continue;
- // can't see this being necessary? MF
- if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
- {
- // Can't pass a drive and root dir to FindFirstFile,
- // so continue to next dir
- tmpPath += wxFILE_SEP_PATH;
- pathOut = tmpPath;
- continue;
- }
+ // can't see this being necessary? MF
+ if ( tmpPath.Last() == GetVolumeSeparator(wxPATH_DOS) )
+ {
+ // Can't pass a drive and root dir to FindFirstFile,
+ // so continue to next dir
+ tmpPath += wxFILE_SEP_PATH;
+ pathOut = tmpPath;
+ continue;
+ }
- hFind = ::FindFirstFile(tmpPath, &findFileData);
- if (hFind == INVALID_HANDLE_VALUE)
- {
- // Error: most likely reason is that path doesn't exist, so
- // append any unprocessed parts and return
- for ( i += 1; i < count; i++ )
- tmpPath += wxFILE_SEP_PATH + dirs[i];
+ hFind = ::FindFirstFile(tmpPath, &findFileData);
+ if (hFind == INVALID_HANDLE_VALUE)
+ {
+ // Error: most likely reason is that path doesn't exist, so
+ // append any unprocessed parts and return
+ for ( i += 1; i < count; i++ )
+ tmpPath += wxFILE_SEP_PATH + dirs[i];
- return tmpPath;
- }
+ return tmpPath;
+ }
- pathOut += findFileData.cFileName;
- if ( (i < (count-1)) )
- pathOut += wxFILE_SEP_PATH;
+ pathOut += findFileData.cFileName;
+ if ( (i < (count-1)) )
+ pathOut += wxFILE_SEP_PATH;
- ::FindClose(hFind);
- }
+ ::FindClose(hFind);
}
#else // !Win32
pathOut = path;
// ----------------------------------------------------------------------------
/* static */
-void wxFileName::SplitPath(const wxString& fullpathWithVolume,
- wxString *pstrVolume,
- wxString *pstrPath,
- wxString *pstrName,
- wxString *pstrExt,
- wxPathFormat format)
+void
+wxFileName::SplitVolume(const wxString& fullpathWithVolume,
+ wxString *pstrVolume,
+ wxString *pstrPath,
+ wxPathFormat format)
{
format = GetFormat(format);
wxString fullpath = fullpathWithVolume;
- // under VMS the end of the path is ']', not the path separator used to
- // separate the components
- wxString sepPath = format == wxPATH_VMS ? wxString(_T(']'))
- : GetPathSeparators(format);
-
// special Windows UNC paths hack: transform \\share\path into share:path
if ( format == wxPATH_DOS )
{
{
fullpath.erase(0, 2);
- size_t posFirstSlash = fullpath.find_first_of(sepPath);
+ size_t posFirstSlash =
+ fullpath.find_first_of(GetPathTerminators(format));
if ( posFirstSlash != wxString::npos )
{
fullpath[posFirstSlash] = wxFILE_SEP_DSK;
}
}
+ if ( pstrPath )
+ *pstrPath = fullpath;
+}
+
+/* static */
+void wxFileName::SplitPath(const wxString& fullpathWithVolume,
+ wxString *pstrVolume,
+ wxString *pstrPath,
+ wxString *pstrName,
+ wxString *pstrExt,
+ bool *hasExt,
+ wxPathFormat format)
+{
+ format = GetFormat(format);
+
+ wxString fullpath;
+ SplitVolume(fullpathWithVolume, pstrVolume, &fullpath, format);
+
// find the positions of the last dot and last path separator in the path
size_t posLastDot = fullpath.find_last_of(wxFILE_SEP_EXT);
- size_t posLastSlash = fullpath.find_last_of(sepPath);
+ size_t posLastSlash = fullpath.find_last_of(GetPathTerminators(format));
// check whether this dot occurs at the very beginning of a path component
if ( (posLastDot != wxString::npos) &&
(posLastDot == 0 ||
IsPathSeparator(fullpath[posLastDot - 1]) ||
(format == wxPATH_VMS && fullpath[posLastDot - 1] == _T(']'))) )
- {
- // dot may be (and commonly -- at least under Unix -- is) the first
- // character of the filename, don't treat the entire filename as
- // extension in this case
- posLastDot = wxString::npos;
- }
+ {
+ // dot may be (and commonly -- at least under Unix -- is) the first
+ // character of the filename, don't treat the entire filename as
+ // extension in this case
+ posLastDot = wxString::npos;
+ }
// if we do have a dot and a slash, check that the dot is in the name part
if ( (posLastDot != wxString::npos) &&
*pstrName = fullpath.Mid(nStart, count);
}
- if ( pstrExt )
+ // finally deal with the extension here: we have an added complication that
+ // extension may be empty (but present) as in "foo." where trailing dot
+ // indicates the empty extension at the end -- and hence we must remember
+ // that we have it independently of pstrExt
+ if ( posLastDot == wxString::npos )
{
- if ( posLastDot == wxString::npos )
- {
- // no extension
- pstrExt->Empty();
- }
- else
- {
- // take everything after the dot
+ // no extension
+ if ( pstrExt )
+ pstrExt->clear();
+ if ( hasExt )
+ *hasExt = false;
+ }
+ else
+ {
+ // take everything after the dot
+ if ( pstrExt )
*pstrExt = fullpath.Mid(posLastDot + 1);
- }
+ if ( hasExt )
+ *hasExt = true;
}
}
}
}
#elif defined(__UNIX_LIKE__) || (defined(__DOS__) && defined(__WATCOMC__))
+ wxUnusedVar(dtCreate);
+
if ( !dtAccess && !dtMod )
{
// can't modify the creation time anyhow, don't try
return true;
}
#else // other platform
+ wxUnusedVar(dtAccess);
+ wxUnusedVar(dtMod);
+ wxUnusedVar(dtCreate);
#endif // platforms
wxLogSysError(_("Failed to modify file times for '%s'"),
return true;
}
-#elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || (defined(__DOS__) && defined(__WATCOMC__))
+#elif defined(__UNIX_LIKE__) || defined(__WXMAC__) || defined(__OS2__) || (defined(__DOS__) && defined(__WATCOMC__))
wxStructStat stBuf;
if ( wxStat( GetFullPath().c_str(), &stBuf) == 0 )
{
return true;
}
#else // other platform
+ wxUnusedVar(dtAccess);
+ wxUnusedVar(dtMod);
+ wxUnusedVar(dtCreate);
#endif // platforms
wxLogSysError(_("Failed to retrieve file times for '%s'"),
MacDefaultExtensionRecord()
{
m_ext[0] = 0 ;
- m_type = m_creator = NULL ;
+ m_type = m_creator = 0 ;
}
MacDefaultExtensionRecord( const MacDefaultExtensionRecord& from )
{
gMacDefaultExtensionsInited = true ;
}
}
+
bool wxFileName::MacSetTypeAndCreator( wxUint32 type , wxUint32 creator )
{
- FInfo fndrInfo ;
- FSSpec spec ;
- wxMacFilename2FSSpec(GetFullPath(),&spec) ;
- OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
- wxCHECK( err == noErr , false ) ;
+ FSRef fsRef ;
+ FSCatalogInfo catInfo;
+ FileInfo *finfo ;
- fndrInfo.fdType = type ;
- fndrInfo.fdCreator = creator ;
- FSpSetFInfo( &spec , &fndrInfo ) ;
- return true ;
+ if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
+ {
+ if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
+ {
+ finfo = (FileInfo*)&catInfo.finderInfo;
+ finfo->fileType = type ;
+ finfo->fileCreator = creator ;
+ FSSetCatalogInfo( &fsRef, kFSCatInfoFinderInfo, &catInfo ) ;
+ return true ;
+ }
+ }
+ return false ;
}
bool wxFileName::MacGetTypeAndCreator( wxUint32 *type , wxUint32 *creator )
{
- FInfo fndrInfo ;
- FSSpec spec ;
- wxMacFilename2FSSpec(GetFullPath(),&spec) ;
- OSErr err = FSpGetFInfo( &spec , &fndrInfo ) ;
- wxCHECK( err == noErr , false ) ;
+ FSRef fsRef ;
+ FSCatalogInfo catInfo;
+ FileInfo *finfo ;
- *type = fndrInfo.fdType ;
- *creator = fndrInfo.fdCreator ;
- return true ;
+ if ( wxMacPathToFSRef( GetFullPath() , &fsRef ) == noErr )
+ {
+ if ( FSGetCatalogInfo (&fsRef, kFSCatInfoFinderInfo, &catInfo, NULL, NULL, NULL) == noErr )
+ {
+ finfo = (FileInfo*)&catInfo.finderInfo;
+ *type = finfo->fileType ;
+ *creator = finfo->fileCreator ;
+ return true ;
+ }
+ }
+ return false ;
}
bool wxFileName::MacSetDefaultTypeAndCreator()
projects / wxWidgets.git / blobdiff