~hikiko/nux/arb-srgba-shader

int NFileManagerGeneric::Copy(const TCHAR* InDestFile, const TCHAR* InSrcFile, bool OverWriteExisting, bool OverWriteReadOnly, NFileTransferMonitor* Monitor)

{

// Direct file copier.

if(Monitor && !Monitor->Progress(0.0))

{

return COPY_Canceled;

}

int Result = COPY_OK;

NString SrcFile = InSrcFile;

NString DestFile = InDestFile;

NSerializer* Src = CreateFileReader(SrcFile.GetTCharPtr());

if(!Src)

{

Result = COPY_ReadFail;

}

else

{

t_u32 Size = Src->GetFileSize();

NSerializer* Dest = CreateFileWriter(DestFile.GetTCharPtr(), (OverWriteExisting?0:FILEWRITE_NoReplaceExisting) | (OverWriteReadOnly?FILEWRITE_EvenIfReadOnly:0));

if(!Dest)

{

Result = COPY_WriteFail;

}

else

{

t_u32 Percent=0, NewPercent=0;

BYTE Buffer[COPYBLOCKSIZE];

for(t_u32 Total=0; Total<Size; Total+=sizeof(Buffer))

{

t_u32 Count = Min<t_u32>(Size-Total, (t_u32)sizeof(Buffer));

Src->Serialize(Buffer, Count);

if(Src->IsError())

{

Result = COPY_ReadFail;

break;

}

Dest->Serialize(Buffer, Count);

if(Dest->IsError())

{

Result = COPY_WriteFail;

break;

}

NewPercent = Total * 100 / Size;

if(Monitor && Percent != NewPercent && !Monitor->Progress((float)NewPercent / 100.f))

{

Result = COPY_Canceled;

break;

}

Percent = NewPercent;

}

if(Result == COPY_OK)

{

if(!Dest->Close())

{

Result = COPY_WriteFail;

}

delete Dest;

if(Result != COPY_OK)

{

Delete(DestFile.GetTCharPtr());

}

if(Result == COPY_OK)

{

if(!Src->Close())

{

Result = COPY_ReadFail;

}

delete Src;

}

if(Monitor && Result==COPY_OK && !Monitor->Progress(1.0))

{

Result = COPY_Canceled;

}

return Result;

}

bool NFileManagerGeneric::IsDrive(const TCHAR* Path)

{

// Does Path refer to a drive letter or UNC path?

// A UNC is a naming convention that permits you to use a network resource,

// such as a network server, without formally connecting to the network resource

// with a mapped drive. A UNC path uses the following syntax:

// \\<Server>\<Share>

// The share is a drive: D:\Folder of ServerA = "\\ServerA\D\Folder"

if(Stricmp(Path,TEXT(""))==0)

return 1;

100

else if((ToUpperCase(Path[0]) != ToLowerCase(Path[0])) && (Path[1] == TEXT(':')) && (Path[2] == 0)) // look for "a:", "c:", "d:" ...

101

return 1;

102

else if(Stricmp(Path,TEXT("\\"))==0) // look for "\"

103

return 1;

104

else if(Stricmp(Path,TEXT("\\\\"))==0) // look for "\\"

105

return 1;

106

else if(Path[0]==TEXT('\\') && Path[1]==TEXT('\\') && !Strchr(Path+2,TEXT('\\'))) // look for "\\Server"

107

return 1;

108

else if(Path[0]==TEXT('\\') && Path[1]==TEXT('\\') && Strchr(Path+2,TEXT('\\')) && !Strchr(Strchr(Path+2,TEXT('\\')) + 1, TEXT('\\')))

109

// look for "\\Server\share"

110

return 1;

111

else

112

return 0;

113

}

114

115

bool NFileManagerGeneric::MakeDirectory(const TCHAR* Path, bool CreateCompletePath)

116

{

117

// Support code for making a directory tree.

118

nuxAssert(CreateCompletePath);

119

t_u32 SlashCount=0, CreateCount=0;

120

for(TCHAR Full[256] = TEXT(""), *Ptr = Full; ; *Ptr++ = *Path++)

121

{

122

if((*Path == INL_BACKSLASH_CHAR) || (*Path == INL_SLASH_CHAR) || (*Path == 0))

123

{

124

if((SlashCount++ > 0) && !IsDrive(Full))

125

{

126

*Ptr = 0;

127

if(MakeDirectory(Full, 0) != INL_OK)

128

return 0;

129

CreateCount++;

130

}

131

}

132

if(*Path == 0)

133

break;

134

}

135

return CreateCount!=0;

136

}

137

138

bool NFileManagerGeneric::DeleteDirectory(const TCHAR* Path, bool DeleteContentFirst)

139

{

140

nuxAssert(DeleteContentFirst);

141

nuxAssert(Path != NULL);

142

143

t_size PathLength = StringLength(Path);

144

if(PathLength == 0)

145

return false;

146

147

NString WildcardPath = NString(Path);

148

if((WildcardPath[PathLength - 1] != INL_BACKSLASH_CHAR) && (WildcardPath[PathLength - 1] != INL_SLASH_CHAR))

149

WildcardPath += INL_BACKSLASH_CHAR;

150

WildcardPath += TEXT("*");

151

152

std::vector<NString> List;

153

FindFiles(List, *WildcardPath, 1, 0);

154

for(t_u32 i = 0; i < List.size(); i++)

155

{

156

if(!Delete(*(NString(Path) + INL_BACKSLASH_CHAR + List[i]), 1))

157

return 0;

158

}

159

List.clear();

160

FindFiles(List, *WildcardPath, 0, 1);

161

for(t_u32 i = 0; i < List.size(); i++)

162

{

163

if(!DeleteDirectory(*(NString(Path) + INL_BACKSLASH_CHAR + List[i]), true))

164

return 0;

165

}

166

List.clear();

167

return DeleteDirectory(Path, false);

168

}

169

170

bool NFileManagerGeneric::Move(const TCHAR* Dest, const TCHAR* Src, bool OverWriteExisting, bool OverWriteReadOnly, NFileTransferMonitor* Monitor)

171

{

172

// Move file manually.

173

if(Copy(Dest, Src, OverWriteExisting, OverWriteReadOnly, NULL) != COPY_OK)

174

return 0;

175

Delete(Src, 1);

176

return 1;

177

}

178

179

180

int NFileManagerGeneric::CreateUniqueFileName(const TCHAR* Filename, const TCHAR* Extension, NString& OutputFilename, unsigned int BaseIndex)

181

{

182

nuxAssert(Filename);

183

nuxAssert(Extension);

184

185

NString FullPath(Filename);

186

const t_size IndexMarker = FullPath.Length(); // Marks location of the four-digit index.

187

FullPath += TEXT("0000.");

188

FullPath += Extension;

189

190

// Iterate over indices, searching for a file that doesn't exist.

191

for(DWORD i = BaseIndex + 1 ; i < 10000 ; ++i)

192

{

193

FullPath[IndexMarker ] = i / 1000 + TEXT('0');

194

FullPath[IndexMarker+1] = (i/100) % 10 + TEXT('0');

195

FullPath[IndexMarker+2] = (i/10) % 10 + TEXT('0');

196

FullPath[IndexMarker+3] = i % 10 + TEXT('0');

197

198

if (GFileManager.FileSize(FullPath.GetTCharPtr()) == -1)

199

{

200

// The file doesn't exist; output success.

201

OutputFilename = FullPath;

202

return static_cast<int>(i);

203

}

204

}

205

206

// Can't find an empty filename slot with index in (StartVal, 9999].

207

return -1;

208

}

209

210

NAMESPACE_END

211

Older »