Skip to content

O
onlyoffice_core
Commit 1d55b122 authored by ElenaSubbotina's avatar ElenaSubbotina
Browse files
Options

.

parent ac959e32
Hide whitespace changes
Inline Side-by-side
Showing with 399 additions and 610 deletions
ASCOfficePPTXFile/Editor/imagemanager.h
View file @ 1d55b122
...@@ -65,9 +65,7 @@ namespace NSShapeImageGen ...@@ -65,9 +65,7 @@ namespace NSShapeImageGen
static bool _CopyFile(std::wstring strExists, std::wstring strNew, LPVOID lpFunc, LPVOID lpData) static bool _CopyFile(std::wstring strExists, std::wstring strNew, LPVOID lpFunc, LPVOID lpData)
{ {
//::DeleteFile(strNew); return CDirectory::CopyFile (strExists, strNew);
//return ::CopyFileEx(strExists, strNew, lpFunc, lpData, false, 0);
return CDirectory::CopyFile (strExists, strNew, lpFunc, lpData);
} }
enum ImageType enum ImageType
...@@ -369,7 +367,7 @@ namespace NSShapeImageGen ...@@ -369,7 +367,7 @@ namespace NSShapeImageGen
oInfo.m_eType = itJPG; oInfo.m_eType = itJPG;
OOX::CPath pathSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + oInfo.GetPath2(); OOX::CPath pathSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + oInfo.GetPath2();
CDirectory::CopyFile(strFileSrc, pathSaveItem.GetPath(), NULL, NULL); CDirectory::CopyFile(strFileSrc, pathSaveItem.GetPath());
return true; return true;
} }
...@@ -382,7 +380,7 @@ namespace NSShapeImageGen ...@@ -382,7 +380,7 @@ namespace NSShapeImageGen
oInfo.m_eType = itPNG; oInfo.m_eType = itPNG;
OOX::CPath pathSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + oInfo.GetPath2(); OOX::CPath pathSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + oInfo.GetPath2();
CDirectory::CopyFile(strFileSrc, pathSaveItem.GetPath(), NULL, NULL); CDirectory::CopyFile(strFileSrc, pathSaveItem.GetPath());
return true; return true;
} }
...@@ -408,7 +406,7 @@ namespace NSShapeImageGen ...@@ -408,7 +406,7 @@ namespace NSShapeImageGen
strSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + strSaveItem + pathOriginal.GetExtention(); strSaveItem = m_strDstMedia + FILE_SEPARATOR_STR + strSaveItem + pathOriginal.GetExtention();
CDirectory::CopyFile(strFileSrc, strSaveItem, NULL, NULL); CDirectory::CopyFile(strFileSrc, strSaveItem);
} }
} }
void SaveImage(CBgraFrame& oBgraFrame, CImageInfo& oInfo, LONG __width, LONG __height) void SaveImage(CBgraFrame& oBgraFrame, CImageInfo& oInfo, LONG __width, LONG __height)
...@@ -524,14 +522,14 @@ namespace NSShapeImageGen ...@@ -524,14 +522,14 @@ namespace NSShapeImageGen
if(bOle) if(bOle)
{ {
std::wstring sCopyOlePath = strSaveItemWE + L".bin"; std::wstring sCopyOlePath = strSaveItemWE + L".bin";
CDirectory::CopyFile(strOleFile, sCopyOlePath, NULL, NULL); CDirectory::CopyFile(strOleFile, sCopyOlePath);
} }
if (bVector) if (bVector)
{ {
//copy source vector image //copy source vector image
OOX::CPath pathSaveItem = strSaveDir + oInfo.GetPath2(); OOX::CPath pathSaveItem = strSaveDir + oInfo.GetPath2();
CDirectory::CopyFile(strFileName, pathSaveItem.GetPath(), NULL, NULL); CDirectory::CopyFile(strFileName, pathSaveItem.GetPath());
::MetaFile::CMetaFile oMetafile(m_pFontManager->m_pApplication); ::MetaFile::CMetaFile oMetafile(m_pFontManager->m_pApplication);
if (oMetafile.LoadFromFile(strFileName.c_str())) if (oMetafile.LoadFromFile(strFileName.c_str()))
......
Common/DocxFormat/Source/SystemUtility/File.h
View file @ 1d55b122
...@@ -38,8 +38,6 @@ ...@@ -38,8 +38,6 @@
#include "../Base/unicode_util.h" #include "../Base/unicode_util.h"
#include "../Base/Types_32.h" #include "../Base/Types_32.h"
//по аналогии с /DesktopEditor/common/File.h только для CString
#ifndef COINIT_MULTITHREADED #ifndef COINIT_MULTITHREADED
#define COINIT_MULTITHREADED 0 //for win64 .... oO #define COINIT_MULTITHREADED 0 //for win64 .... oO
#endif #endif
...@@ -47,669 +45,463 @@ ...@@ -47,669 +45,463 @@
class CFile class CFile
{ {
private: private:
HRESULT _Open(const std::wstring& strFileName, bool bOpen = false, bool bCreate = false, bool bReadWrite = false) HRESULT _Open(const std::wstring& strFileName, bool bOpen = false, bool bCreate = false, bool bReadWrite = false)
{ {
HRESULT hRes = S_OK; HRESULT hRes = S_OK;
CloseFile(); CloseFile();
#if defined(_WIN32) || defined(_WIN32_WCE) ||defined(_WIN64) #if defined(_WIN32) || defined(_WIN32_WCE) ||defined(_WIN64)
wchar_t* pModeOpen; wchar_t* pModeOpen;
wchar_t* pModeCreate; wchar_t* pModeCreate;
if(bReadWrite) if(bReadWrite)
{ {
pModeOpen = L"rb+"; pModeOpen = L"rb+";
pModeCreate = L"wb+"; pModeCreate = L"wb+";
} }
else else
{ {
pModeOpen = L"rb"; pModeOpen = L"rb";
pModeCreate = L"wb"; pModeCreate = L"wb";
} }
if(NULL == m_pFile && bOpen) if(NULL == m_pFile && bOpen)
m_pFile = _wfopen(strFileName.c_str(), pModeOpen); m_pFile = _wfopen(strFileName.c_str(), pModeOpen);
if(NULL == m_pFile && bCreate) if(NULL == m_pFile && bCreate)
m_pFile = _wfopen(strFileName.c_str(), pModeCreate); m_pFile = _wfopen(strFileName.c_str(), pModeCreate);
#else #else
BYTE* pUtf8 = NULL; BYTE* pUtf8 = NULL;
LONG lLen = 0; LONG lLen = 0;
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strFileName.c_str(), strFileName.length(), pUtf8, lLen, false); NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strFileName.c_str(), strFileName.length(), pUtf8, lLen, false);
char* pModeOpen; char* pModeOpen;
char* pModeCreate; char* pModeCreate;
if(bReadWrite) if(bReadWrite)
{ {
pModeOpen = "rb+"; pModeOpen = "rb+";
pModeCreate = "wb+"; pModeCreate = "wb+";
} }
else else
{ {
pModeOpen = "rb"; pModeOpen = "rb";
pModeCreate = "wb"; pModeCreate = "wb";
} }
if(NULL == m_pFile && bOpen) if(NULL == m_pFile && bOpen)
m_pFile = fopen((char*)pUtf8, pModeOpen); m_pFile = fopen((char*)pUtf8, pModeOpen);
if(NULL == m_pFile && bCreate) if(NULL == m_pFile && bCreate)
m_pFile = fopen((char*)pUtf8, pModeCreate); m_pFile = fopen((char*)pUtf8, pModeCreate);
RELEASEARRAYOBJECTS(pUtf8); RELEASEARRAYOBJECTS(pUtf8);
#endif #endif
if (NULL == m_pFile) if (NULL == m_pFile)
return S_FALSE; return S_FALSE;
fseek(m_pFile, 0, SEEK_END); fseek(m_pFile, 0, SEEK_END);
m_lFileSize = ftell(m_pFile); m_lFileSize = ftell(m_pFile);
fseek(m_pFile, 0, SEEK_SET); fseek(m_pFile, 0, SEEK_SET);
m_lFilePosition = 0; m_lFilePosition = 0;
if (0 < strFileName.length()) if (0 < strFileName.length())
{ {
if (((wchar_t)'/') == strFileName[strFileName.length() - 1]) if (((wchar_t)'/') == strFileName[strFileName.length() - 1])
m_lFileSize = 0x7FFFFFFF; m_lFileSize = 0x7FFFFFFF;
} }
unsigned int err = 0x7FFFFFFF; unsigned int err = 0x7FFFFFFF;
unsigned int cur = (unsigned int)m_lFileSize; unsigned int cur = (unsigned int)m_lFileSize;
if (err == cur) if (err == cur)
{ {
CloseFile(); CloseFile();
return S_FALSE; return S_FALSE;
} }
return hRes; return hRes;
} }
public: public:
CFile() CFile()
{ {
m_pFile = NULL; m_pFile = NULL;
m_lFilePosition = 0; m_lFilePosition = 0;
m_lFileSize = 0; m_lFileSize = 0;
} }
virtual ~CFile()
{
CloseFile();
}
HRESULT OpenOrCreate(std::wstring strFileName, bool bOnlyOpen = false, bool bReadWrite = false)
{
return _Open(strFileName, true, true, true);
}
virtual HRESULT OpenFile(std::wstring FileName)
{
return _Open(FileName, true, false, false);
}
virtual HRESULT OpenFileRW(std::wstring FileName)
{
return _Open(FileName, true, false, true);
}
HRESULT ReadFile(BYTE* pData, DWORD nBytesToRead)
{
if (!m_pFile)
return S_FALSE;
SetPosition(m_lFilePosition);
DWORD dwSizeRead = (DWORD)fread((void*)pData, 1, nBytesToRead, m_pFile);
m_lFilePosition += dwSizeRead;
return S_OK;
}
HRESULT ReadFile2(BYTE* pData, DWORD nBytesToRead)
{
HRESULT hRes = ReadFile(pData, nBytesToRead);
//reverse bytes
for (size_t index = 0; index < nBytesToRead / 2; ++index)
{
BYTE temp = pData[index];
pData[index] = pData[nBytesToRead - index - 1];
pData[nBytesToRead - index - 1] = temp;
}
return S_OK;
}
HRESULT ReadFile3(void* pData, DWORD nBytesToRead)
{
return ReadFile((BYTE*)pData, nBytesToRead);
}
HRESULT WriteFile(void* pData, DWORD nBytesToWrite)
{
if (!m_pFile)
return S_FALSE;
size_t nCountWrite = fwrite((void*)pData, 1, nBytesToWrite, m_pFile);
m_lFilePosition += nBytesToWrite;
return S_OK;
}
HRESULT WriteFile2(void* pData, DWORD nBytesToWrite)
{
if (!m_pFile)
return S_FALSE;
BYTE* mem = new BYTE[nBytesToWrite];
memcpy(mem, pData, nBytesToWrite);
for (size_t index = 0; index < nBytesToWrite / 2; ++index)
{
BYTE temp = mem[index];
mem[index] = mem[nBytesToWrite - index - 1];
mem[nBytesToWrite - index - 1] = temp;
}
return WriteFile(mem, nBytesToWrite);
}
HRESULT CreateFile(std::wstring strFileName)
{
return _Open(strFileName, false, true, true);
}
HRESULT SetPosition( ULONG64 nPos )
{
if (m_pFile && nPos <= (ULONG)m_lFileSize)
{
m_lFilePosition = (long)nPos;
fseek(m_pFile, m_lFilePosition, SEEK_SET);
return S_OK;
}
else
{
return !m_pFile ? S_FALSE : S_OK;
}
}
LONG64 GetPosition()
{
return m_lFilePosition;
}
HRESULT SkipBytes(ULONG64 nCount)
{
return SetPosition(m_lFilePosition + nCount);
}
HRESULT CloseFile()
{
m_lFilePosition = 0;
m_lFileSize = 0;
if (m_pFile != NULL)
{
fclose(m_pFile);
m_pFile = NULL;
}
return S_OK;
}
ULONG64 GetFileSize()
{
return m_lFileSize;
}
HRESULT WriteReserved(DWORD dwCount)
{
BYTE* buf = new BYTE[dwCount];
memset(buf, 0, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT WriteReserved2(DWORD dwCount)
{
BYTE* buf = new BYTE[dwCount];
memset(buf, 0xFF, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT WriteReservedTo(DWORD dwPoint)
{
if ((DWORD)m_lFilePosition >= dwPoint)
return S_OK;
DWORD dwCount = dwPoint - (DWORD)m_lFilePosition;
BYTE* buf = new BYTE[dwCount];
memset(buf, 0, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT SkipReservedTo(DWORD dwPoint)
{
if ((DWORD)m_lFilePosition >= dwPoint)
return S_OK;
DWORD dwCount = dwPoint - (DWORD)m_lFilePosition;
return SkipBytes(dwCount);
}
LONG GetProgress()
{
if (0 >= m_lFileSize)
return -1;
double dVal = (double)(100 * m_lFilePosition);
LONG lProgress = (LONG)(dVal / m_lFileSize);
return lProgress;
}
void WriteStringUTF8(const std::wstring& strXml)
{
BYTE* pData = NULL;
LONG lLen = 0;
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strXml.c_str(), (LONG)strXml.length(), pData, lLen, false);
WriteFile(pData, lLen);
RELEASEARRAYOBJECTS(pData);
}
protected:
FILE* m_pFile;
long m_lFilePosition; virtual ~CFile()
long m_lFileSize; {
}; CloseFile();
namespace StreamUtils }
{
static BYTE ReadBYTE(POLE::Stream* pStream) HRESULT OpenOrCreate(std::wstring strFileName, bool bOnlyOpen = false, bool bReadWrite = false)
{ {
if (pStream == NULL) return 0; return _Open(strFileName, true, true, true);
}
BYTE lMem = 0; virtual HRESULT OpenFile(std::wstring FileName)
ULONG lReadByte = 0; {
return _Open(FileName, true, false, false);
lReadByte = (ULONG)pStream->read(&lMem, 1); }
if (lReadByte < 1)
{ virtual HRESULT OpenFileRW(std::wstring FileName)
lMem = 0; {
} return _Open(FileName, true, false, true);
return lMem; }
}
static WORD ReadWORD(POLE::Stream* pStream)
{
if (pStream == NULL) return 0;
WORD lWord = 0;
BYTE pMem[2];
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(pMem, 2);
if (lReadByte == 2)
{
lWord = ((pMem[1] << 8) | pMem[0]);
}
return lWord;
}
static DWORD ReadDWORD(POLE::Stream* pStream)
{
if (pStream == NULL) return 0;
DWORD lDWord = 0;
BYTE pMem[4];
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(pMem, 4);
//#if defined(_DEBUG) && (defined(_WIN32) || defined(_WIN64))
// ATLASSERT(4 == lReadByte);
//#endif
if (lReadByte == 4)
{
lDWord = ((pMem[3] << 24) | (pMem[2] << 16) | (pMem[1] << 8) | pMem[0]);
}
return 0xFFFFFFFF & lDWord;
}
static SHORT ReadSHORT(POLE::Stream* pStream)
{
return (short)ReadWORD(pStream);
}
static LONG ReadLONG(POLE::Stream* pStream)
{
return (_INT32)ReadDWORD(pStream);
}
static FLOAT ReadFLOAT( POLE::Stream* pStream)
{
if (pStream == NULL) return 0;
FLOAT Value = 0.0f;
pStream->read ((unsigned char*) &Value, sizeof (FLOAT));
return Value;
}
static std::string ReadStringA(POLE::Stream* pStream, LONG lLen)
{
if (pStream == NULL) return ("");
char* pData = new char[lLen + 1];
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read((unsigned char*)pData, lLen);
pData[lLen] = 0;
std::string str(pData);
delete[] pData;
return str;
}
static std::wstring ReadStringW(POLE::Stream* pStream, LONG lLen)
{
if (pStream == NULL) return _T("");
unsigned char* pData = new unsigned char[2 * (lLen + 1)];
memset (pData, 0, 2 * (lLen + 1));
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(pData, 2 * lLen);
if (sizeof(wchar_t) == 4)
{
ConversionResult eUnicodeConversionResult;
UTF32 *pStrUtf32 = new UTF32 [lLen + 1];
pStrUtf32[lLen] = 0 ;
const UTF16 *pStrUtf16_Conv = (const UTF16 *) pData; HRESULT ReadFile(BYTE* pData, DWORD nBytesToRead)
UTF32 *pStrUtf32_Conv = pStrUtf32; {
if (!m_pFile)
return S_FALSE;
eUnicodeConversionResult = ConvertUTF16toUTF32 ( &pStrUtf16_Conv SetPosition(m_lFilePosition);
, &pStrUtf16_Conv[lLen] DWORD dwSizeRead = (DWORD)fread((void*)pData, 1, nBytesToRead, m_pFile);
, &pStrUtf32_Conv m_lFilePosition += dwSizeRead;
, &pStrUtf32 [lLen] return S_OK;
, strictConversion); }
if (conversionOK != eUnicodeConversionResult) HRESULT ReadFile2(BYTE* pData, DWORD nBytesToRead)
{ {
delete [] pStrUtf32; HRESULT hRes = ReadFile(pData, nBytesToRead);
return _T(""); //reverse bytes
} for (size_t index = 0; index < nBytesToRead / 2; ++index)
std::wstring res((wchar_t*)pStrUtf32, lLen); {
if (pStrUtf32) delete [] pStrUtf32; BYTE temp = pData[index];
return res; pData[index] = pData[nBytesToRead - index - 1];
pData[nBytesToRead - index - 1] = temp;
} }
else return S_OK;
{ }
std::wstring str((wchar_t*)pData); HRESULT ReadFile3(void* pData, DWORD nBytesToRead)
delete[] pData; {
return str; return ReadFile((BYTE*)pData, nBytesToRead);
} }
}
static std::string ConvertCStringWToCStringA(std::wstring& strW)
{
std::string str_a(strW.begin(), strW.end());
return str_a;
}
static void StreamSeek(long lOffset, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(lOffset);
}
static void StreamPosition(long& lPosition, POLE::Stream* pStream)
{
if (pStream == NULL) return ;
lPosition = (LONG)pStream->tell();
}
static void StreamSkip(long lCount, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(pStream->tell() + lCount);
}
static void StreamSkipBack(long lCount, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(pStream->tell()-lCount);
}
}
#if defined(_WIN32) || defined(_WIN64) HRESULT WriteFile(void* pData, DWORD nBytesToWrite)
namespace CDirectory
{
static std::wstring GetFolderName(std::wstring strFolderPath)
{
int n1 = (int)strFolderPath.rfind('\\');
if (-1 == n1)
return _T("");
return strFolderPath.substr(n1 + 1);
}
static std::wstring GetFolderPath(std::wstring strFolderPath)
{
int n1 = (int)strFolderPath.rfind('\\');
if (-1 == n1)
return _T("");
return strFolderPath.substr(0, n1);
}
static bool OpenFile(std::wstring strFolderPath, std::wstring strFileName, CFile* pFile)
{
std::wstring strFile = strFolderPath + FILE_SEPARATOR_STR + strFileName;
return (S_OK == pFile->OpenFile(strFile));
}
static bool CreateFile(std::wstring strFolderPath, std::wstring strFileName, CFile* pFile)
{
std::wstring strFile = strFolderPath + FILE_SEPARATOR_STR + strFileName;
return (S_OK == pFile->CreateFile(strFile));
}
static bool CreateDirectory(std::wstring strFolderPathRoot, std::wstring strFolderName)
{
std::wstring strFolder = strFolderPathRoot + FILE_SEPARATOR_STR + strFolderName;
return (bool)CreateDirectory(strFolder, NULL);
}
static bool CreateDirectory(std::wstring strFolderPath)
{
return (bool)CreateDirectory(strFolderPath, NULL);
}
static bool DeleteFile (std::wstring strFileName)
{ {
::DeleteFile (strFileName.c_str()); if (!m_pFile)
return true; return S_FALSE;
size_t nCountWrite = fwrite((void*)pData, 1, nBytesToWrite, m_pFile);
m_lFilePosition += nBytesToWrite;
return S_OK;
} }
static bool MoveFile(std::wstring strExists, std::wstring strNew, LPVOID lpFunc, LPVOID lpData) HRESULT WriteFile2(void* pData, DWORD nBytesToWrite)
{ {
#if (_WIN32_WINNT >= 0x0500) && !defined (_WIN64) if (!m_pFile)
return (bool)MoveFileWithProgress(strExists.c_str(), strNew.c_str(), (LPPROGRESS_ROUTINE)lpFunc, lpData, MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH); return S_FALSE;
#else
return (bool)MoveFileEx(strExists.c_str(), strNew.c_str(), MOVEFILE_REPLACE_EXISTING | MOVEFILE_WRITE_THROUGH);
#endif
}
static bool CopyFile(std::wstring strExists, std::wstring strNew, LPVOID lpFunc, LPVOID lpData)
{
DeleteFile(strNew);
//#if (_WIN32_WINNT >= 0x0500) && !defined (_WIN64)
// return (bool)CopyFile(strExists.c_str(), strNew.c_str(), true);
//#else
return (bool)CopyFileEx(strExists.c_str(), strNew.c_str(), (LPPROGRESS_ROUTINE)lpFunc, lpData, FALSE, 0);
//#endif
}
static std::wstring GetUnder(std::wstring strFolderPathRoot, std::wstring strFolderName)
{
std::wstring strFolder = strFolderPathRoot + L"\\" + strFolderName;
return strFolder;
}
static std::wstring GetFileName(std::wstring strFullName)
{
size_t nStart = strFullName.rfind(L"\\");
std::wstring strName = strFullName.substr(nStart + 1);
return strName;
}
static std::wstring BYTEArrayToString2(USHORT* arr, size_t nCount)
{
std::wstring str;
for (size_t index = 0; index < nCount; ++index)
{
if ('\0' != (char)(arr[index]))
str += (char)(arr[index]);
}
if (str.length() == 0)
str = _T("0");
return str;
}
static std::wstring ToString(DWORD val)
{
return std::to_wstring(val);
}
static std::wstring ToString(UINT64 val, bool bInit)
{
std::wstring strCoarse = ToString((DWORD)(val >> 32));
if (_T("0") != strCoarse)
{
return strCoarse + ToString((DWORD)val);
}
return ToString((DWORD)val);
}
static UINT64 GetUINT64(std::wstring strVal)
{
UINT64 nRet = 0;
int nLen = (int)strVal.length();
while (nLen > 0)
{
int nDig = XmlUtils::GetDigit(strVal[0]);
nRet *= 10;
nRet += nDig;
strVal.erase(0);
--nLen;
}
return nRet;
}
static UINT GetUINT(std::wstring strVal)
{
return (UINT)GetUINT64(strVal);
}
static void SaveToFile(std::wstring strFileName, std::wstring strXml)
{
int nLength = (int)strXml.length();
std::string saStr; saStr.reserve(nLength*3 + 1);
#ifdef UNICODE
// Encoding Unicode to UTF-8
WideCharToMultiByte(CP_UTF8, 0, strXml.c_str(), nLength + 1, (LPSTR)saStr.c_str(), nLength * 3, NULL, NULL);
#else
wchar_t* pWStr = new wchar_t[nLength + 1];
if (!pWStr)
return;
// set end string BYTE* mem = new BYTE[nBytesToWrite];
pWStr[nLength] = 0; memcpy(mem, pData, nBytesToWrite);
// Encoding ASCII to Unicode for (size_t index = 0; index < nBytesToWrite / 2; ++index)
MultiByteToWideChar(CP_ACP, 0, strXml, nLength, pWStr, nLength); {
BYTE temp = mem[index];
mem[index] = mem[nBytesToWrite - index - 1];
mem[nBytesToWrite - index - 1] = temp;
}
int nLengthW = (int)wcslen(pWStr); return WriteFile(mem, nBytesToWrite);
}
// Encoding Unicode to UTF-8 HRESULT CreateFile(std::wstring strFileName)
WideCharToMultiByte(CP_UTF8, 0, pWStr, nLengthW + 1, saStr.GetBuffer(nLengthW*3 + 1), nLengthW*3, NULL, NULL); {
saStr.ReleaseBuffer(); return _Open(strFileName, false, true, true);
}
HRESULT SetPosition( ULONG64 nPos )
{
if (m_pFile && nPos <= (ULONG)m_lFileSize)
{
m_lFilePosition = (long)nPos;
fseek(m_pFile, m_lFilePosition, SEEK_SET);
return S_OK;
}
else
{
return !m_pFile ? S_FALSE : S_OK;
}
}
LONG64 GetPosition()
{
return m_lFilePosition;
}
HRESULT SkipBytes(ULONG64 nCount)
{
return SetPosition(m_lFilePosition + nCount);
}
delete[] pWStr; HRESULT CloseFile()
#endif {
m_lFilePosition = 0;
CFile oFile; m_lFileSize = 0;
oFile.CreateFile(strFileName);
oFile.WriteFile((void*)saStr.c_str(), (DWORD)saStr.length());
oFile.CloseFile();
}
static void SaveToFile2(std::wstring strFileName, std::string strVal)
{
CFile oFile;
HRESULT hr = oFile.OpenFileRW(strFileName);
if (S_OK != hr)
oFile.CreateFile(strFileName);
oFile.SkipBytes(oFile.GetFileSize());
oFile.WriteFile((void*)strVal.c_str(), (DWORD)strVal.length());
oFile.CloseFile();
}
}
#else if (m_pFile != NULL)
{
fclose(m_pFile);
m_pFile = NULL;
}
return S_OK;
}
#include <iostream> ULONG64 GetFileSize()
#include <fstream> // instream {
#include <unistd.h> // unlink return m_lFileSize;
}
#include "../../../../DesktopEditor/common/Types.h" HRESULT WriteReserved(DWORD dwCount)
#include "../../../../DesktopEditor/common/File.h" {
BYTE* buf = new BYTE[dwCount];
memset(buf, 0, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT WriteReserved2(DWORD dwCount)
{
BYTE* buf = new BYTE[dwCount];
memset(buf, 0xFF, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT WriteReservedTo(DWORD dwPoint)
{
if ((DWORD)m_lFilePosition >= dwPoint)
return S_OK;
DWORD dwCount = dwPoint - (DWORD)m_lFilePosition;
BYTE* buf = new BYTE[dwCount];
memset(buf, 0, (size_t)dwCount);
HRESULT hr = WriteFile(buf, dwCount);
RELEASEARRAYOBJECTS(buf);
return hr;
}
HRESULT SkipReservedTo(DWORD dwPoint)
{
if ((DWORD)m_lFilePosition >= dwPoint)
return S_OK;
namespace CDirectory DWORD dwCount = dwPoint - (DWORD)m_lFilePosition;
return SkipBytes(dwCount);
}
LONG GetProgress()
{
if (0 >= m_lFileSize)
return -1;
double dVal = (double)(100 * m_lFilePosition);
LONG lProgress = (LONG)(dVal / m_lFileSize);
return lProgress;
}
void WriteStringUTF8(const std::wstring& strXml)
{
BYTE* pData = NULL;
LONG lLen = 0;
NSFile::CUtf8Converter::GetUtf8StringFromUnicode(strXml.c_str(), (LONG)strXml.length(), pData, lLen, false);
WriteFile(pData, lLen);
RELEASEARRAYOBJECTS(pData);
}
protected:
FILE* m_pFile;
long m_lFilePosition;
long m_lFileSize;
};
namespace StreamUtils
{ {
static BYTE ReadBYTE(POLE::Stream* pStream)
{
if (pStream == NULL) return 0;
static void SaveToFile(std::wstring strFileName, std::wstring strXml) BYTE lMem = 0;
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(&lMem, 1);
if (lReadByte < 1)
{
lMem = 0;
}
return lMem;
}
static WORD ReadWORD(POLE::Stream* pStream)
{ {
std::string aContentUtf8 = stringWstingToUtf8String (strXml); if (pStream == NULL) return 0;
std::string aFileNameUtf8 = stringWstingToUtf8String (strFileName);
FILE *pFile = fopen(aFileNameUtf8.c_str(), "wb"); WORD lWord = 0;
BYTE pMem[2];
ULONG lReadByte = 0;
if (NULL == pFile) lReadByte = (ULONG)pStream->read(pMem, 2);
if (lReadByte == 2)
{ {
throw std::exception(); lWord = ((pMem[1] << 8) | pMem[0]);
} }
fwrite (aContentUtf8.c_str() , sizeof(char), aContentUtf8.size(), pFile); return lWord;
fclose (pFile);
} }
static bool DeleteFile (std::wstring strFileName) static DWORD ReadDWORD(POLE::Stream* pStream)
{ {
std::string aFileNameUtf8 = stringWstingToUtf8String (strFileName); if (pStream == NULL) return 0;
return 0 == unlink (aFileNameUtf8.c_str());
DWORD lDWord = 0;
BYTE pMem[4];
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(pMem, 4);
//#if defined(_DEBUG) && (defined(_WIN32) || defined(_WIN64))
// ATLASSERT(4 == lReadByte);
//#endif
if (lReadByte == 4)
{
lDWord = ((pMem[3] << 24) | (pMem[2] << 16) | (pMem[1] << 8) | pMem[0]);
}
return 0xFFFFFFFF & lDWord;
} }
static std::wstring ToString(DWORD val) static SHORT ReadSHORT(POLE::Stream* pStream)
{ {
return std::to_wstring(val); return (short)ReadWORD(pStream);
}
static LONG ReadLONG(POLE::Stream* pStream)
{
return (_INT32)ReadDWORD(pStream);
}
static FLOAT ReadFLOAT( POLE::Stream* pStream)
{
if (pStream == NULL) return 0;
FLOAT Value = 0.0f;
pStream->read ((unsigned char*) &Value, sizeof (FLOAT));
return Value;
} }
static std::string ReadStringA(POLE::Stream* pStream, LONG lLen)
{
if (pStream == NULL) return ("");
char* pData = new char[lLen + 1];
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read((unsigned char*)pData, lLen);
pData[lLen] = 0;
std::string str(pData);
static bool CopyFile (std::wstring strExists, std::wstring strNew, LPVOID lpFunc = NULL, LPVOID lpData = NULL) delete[] pData;
return str;
}
static std::wstring ReadStringW(POLE::Stream* pStream, LONG lLen)
{ {
bool bRes = true; if (pStream == NULL) return _T("");
try
unsigned char* pData = new unsigned char[2 * (lLen + 1)];
memset (pData, 0, 2 * (lLen + 1));
ULONG lReadByte = 0;
lReadByte = (ULONG)pStream->read(pData, 2 * lLen);
if (sizeof(wchar_t) == 4)
{ {
std::string stdstrFrom = stringWstingToUtf8String(strExists); ConversionResult eUnicodeConversionResult;
std::string stdstrTo = stringWstingToUtf8String(strNew); UTF32 *pStrUtf32 = new UTF32 [lLen + 1];
std::ifstream src (stdstrFrom.c_str(), std::ios::binary); pStrUtf32[lLen] = 0 ;
std::ofstream dst (stdstrTo.c_str(), std::ios::binary);
dst << src.rdbuf(); const UTF16 *pStrUtf16_Conv = (const UTF16 *) pData;
UTF32 *pStrUtf32_Conv = pStrUtf32;
eUnicodeConversionResult = ConvertUTF16toUTF32 ( &pStrUtf16_Conv
, &pStrUtf16_Conv[lLen]
, &pStrUtf32_Conv
, &pStrUtf32 [lLen]
, strictConversion);
if (conversionOK != eUnicodeConversionResult)
{
delete [] pStrUtf32;
return _T("");
}
std::wstring res((wchar_t*)pStrUtf32, lLen);
if (pStrUtf32) delete [] pStrUtf32;
return res;
} }
catch (...) else
{ {
bRes = false; std::wstring str((wchar_t*)pData);
delete[] pData;
return str;
} }
return bRes;
}
static std::string ConvertCStringWToCStringA(std::wstring& strW)
{
std::string str_a(strW.begin(), strW.end());
return str_a;
}
static void StreamSeek(long lOffset, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(lOffset);
}
static void StreamPosition(long& lPosition, POLE::Stream* pStream)
{
if (pStream == NULL) return ;
lPosition = (LONG)pStream->tell();
}
static void StreamSkip(long lCount, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(pStream->tell() + lCount);
}
static void StreamSkipBack(long lCount, POLE::Stream* pStream)
{
if (pStream == NULL) return;
pStream->seek(pStream->tell()-lCount);
} }
} }
#endif
namespace CDirectory namespace CDirectory
{ {
static void SaveToFile(std::wstring strFileName, std::wstring strXml)
{
NSFile::CFileBinary file;
file.CreateFileW(strFileName);
file.WriteStringUTF8(strXml);
file.CloseFile();
}
static bool DeleteFile (std::wstring strFileName)
{
return NSFile::CFileBinary::Remove(strFileName);
}
static std::wstring ToString(DWORD val)
{
return std::to_wstring(val);
}
static bool CopyFile (std::wstring strExists, std::wstring strNew)
{
return NSFile::CFileBinary::Copy(strExists, strNew);
}
static void WriteValueToNode(std::wstring strName, DWORD value, XmlUtils::CXmlWriter* pWriter) static void WriteValueToNode(std::wstring strName, DWORD value, XmlUtils::CXmlWriter* pWriter)
{ {
pWriter->WriteNodeBegin(strName); pWriter->WriteNodeBegin(strName);
pWriter->WriteString(CDirectory::ToString(value)); pWriter->WriteString(CDirectory::ToString(value));
pWriter->WriteNodeEnd(strName); pWriter->WriteNodeEnd(strName);
} }
static void WriteValueToNode(std::wstring strName, LONG value, XmlUtils::CXmlWriter* pWriter) static void WriteValueToNode(std::wstring strName, LONG value, XmlUtils::CXmlWriter* pWriter)
{ {
pWriter->WriteNodeBegin(strName); pWriter->WriteNodeBegin(strName);
std::wstring strLONG = std::to_wstring(value); std::wstring strLONG = std::to_wstring(value);
pWriter->WriteString(strLONG); pWriter->WriteString(strLONG);
pWriter->WriteNodeEnd(strName); pWriter->WriteNodeEnd(strName);
} }
static void WriteValueToNode(std::wstring strName, std::wstring value, XmlUtils::CXmlWriter* pWriter) static void WriteValueToNode(std::wstring strName, std::wstring value, XmlUtils::CXmlWriter* pWriter)
...@@ -747,7 +539,6 @@ namespace CDirectory ...@@ -747,7 +539,6 @@ namespace CDirectory
return (LONG)(FixedPointToDouble(point) * base); return (LONG)(FixedPointToDouble(point) * base);
} }
static std::wstring BYTEArrayToString(BYTE* arr, size_t nCount) static std::wstring BYTEArrayToString(BYTE* arr, size_t nCount)
{ {
std::wstring str; std::wstring str;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7