xevion/easy7zip
1
0
Fork 0
mirror of https://github.com/Xevion/easy7zip.git synced 2025-12-13 18:11:37 -06:00
Code Issues Packages Projects Releases Wiki Activity

4.20

Browse Source
This commit is contained in:
Igor Pavlov
2005-05-30 00:00:00 +00:00
committed by Kornel Lesiński
parent 8c1b5c7b7e
commit 3c510ba80b
926 changed files with 40559 additions and 23519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Windows/COM.h
View File

@@ -1,7 +1,5 @@
// Windows/COM.h
#pragma once
#ifndef __WINDOWS_COM_H
#define __WINDOWS_COM_H

2
Windows/Console.h
View File

@@ -3,8 +3,6 @@
#ifndef __WINDOWS_CONSOLE_H
#define __WINDOWS_CONSOLE_H
#pragma once
#include "Windows/Defs.h"
namespace NWindows{

2
Windows/Control/ComboBox.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ComboBox.h
#pragma once
#ifndef __WINDOWS_CONTROL_COMBOBOX_H
#define __WINDOWS_CONTROL_COMBOBOX_H

2
Windows/Control/Dialog.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/Dialog.h
#pragma once
#ifndef __WINDOWS_CONTROL_DIALOG_H
#define __WINDOWS_CONTROL_DIALOG_H

2
Windows/Control/Edit.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/Edit.h
#pragma once
#ifndef __WINDOWS_CONTROL_EDIT_H
#define __WINDOWS_CONTROL_EDIT_H

2
Windows/Control/ImageList.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ImageList.h
#pragma once
#ifndef __WINDOWS_CONTROL_IMAGELIST_H
#define __WINDOWS_CONTROL_IMAGELIST_H

2
Windows/Control/ListView.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ListView.h
#pragma once
#ifndef __WINDOWS_CONTROL_LISTVIEW_H
#define __WINDOWS_CONTROL_LISTVIEW_H

2
Windows/Control/ProgressBar.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ProgressBar.h
#pragma once
#ifndef __WINDOWS_CONTROL_PROGRESSBAR_H
#define __WINDOWS_CONTROL_PROGRESSBAR_H

2
Windows/Control/PropertyPage.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/PropertyPage.h
#pragma once
#ifndef __WINDOWS_CONTROL_PROPERTYPAGE_H
#define __WINDOWS_CONTROL_PROPERTYPAGE_H

2
Windows/Control/ReBar.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ReBar.h
#pragma once
#ifndef __WINDOWS_CONTROL_REBAR_H
#define __WINDOWS_CONTROL_REBAR_H

2
Windows/Control/Static.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/Static.h
#pragma once
#ifndef __WINDOWS_CONTROL_STATIC_H
#define __WINDOWS_CONTROL_STATIC_H

2
Windows/Control/StatusBar.h
View File

@@ -1,6 +1,4 @@
// Windows/Control/StatusBar.h
#pragma once
#ifndef __WINDOWS_CONTROL_STATUSBAR_H
#define __WINDOWS_CONTROL_STATUSBAR_H

2
Windows/Control/ToolBar.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/ToolBar.h
#pragma once
#ifndef __WINDOWS_CONTROL_TOOLBAR_H
#define __WINDOWS_CONTROL_TOOLBAR_H

2
Windows/Control/Trackbar.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/Trackbar.h
#pragma once
#ifndef __WINDOWS_CONTROL_TRACKBAR_H
#define __WINDOWS_CONTROL_TRACKBAR_H

2
Windows/Control/Window2.h
View File

@@ -1,7 +1,5 @@
// Windows/Control/Window2.h
#pragma once
#ifndef __WINDOWS_CONTROL_WINDOW2_H
#define __WINDOWS_CONTROL_WINDOW2_H

2
Windows/DLL.h
View File

@@ -3,8 +3,6 @@
#ifndef __WINDOWS_DLL_H
#define __WINDOWS_DLL_H
#pragma once
#include "../Common/String.h"
namespace NWindows {

5
Windows/Defs.h
View File

@@ -1,7 +1,5 @@
// Windows/Defs.h
#pragma once
#ifndef __WINDOWS_DEFS_H
#define __WINDOWS_DEFS_H
@@ -17,7 +15,4 @@ inline VARIANT_BOOL BoolToVARIANT_BOOL(bool value)
inline bool VARIANT_BOOLToBool(VARIANT_BOOL value)
{ return (value != VARIANT_FALSE); }
// #define RETURN_IF_NOT_S_OK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }
// #define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }
#endif

2
Windows/Error.h
View File

@@ -1,7 +1,5 @@
// Windows/Error.h
#pragma once
#ifndef __WINDOWS_ERROR_H
#define __WINDOWS_ERROR_H

2
Windows/FileDir.h
View File

@@ -1,7 +1,5 @@
// Windows/FileDir.h
#pragma once
#ifndef __WINDOWS_FILEDIR_H
#define __WINDOWS_FILEDIR_H

23
Windows/FileFind.cpp
View File

@@ -221,6 +221,17 @@ bool CEnumerator::Next(CFileInfo &fileInfo)
}
}
bool CEnumerator::Next(CFileInfo &fileInfo, bool &found)
{
if (Next(fileInfo))
{
found = true;
return true;
}
found = false;
return (::GetLastError() == ERROR_NO_MORE_FILES);
}
#ifndef _UNICODE
bool CEnumeratorW::NextAny(CFileInfoW &fileInfo)
{
@@ -240,6 +251,18 @@ bool CEnumeratorW::Next(CFileInfoW &fileInfo)
return true;
}
}
bool CEnumeratorW::Next(CFileInfoW &fileInfo, bool &found)
{
if (Next(fileInfo))
{
found = true;
return true;
}
found = false;
return (::GetLastError() == ERROR_NO_MORE_FILES);
}
#endif
////////////////////////////////

4
Windows/FileFind.h
View File

@@ -1,7 +1,5 @@
// Windows/FileFind.h
#pragma once
#ifndef __WINDOWS_FILEFIND_H
#define __WINDOWS_FILEFIND_H
@@ -109,6 +107,7 @@ public:
CEnumerator(): _wildcard(NName::kAnyStringWildcard) {}
CEnumerator(const CSysString &wildcard): _wildcard(wildcard) {}
bool Next(CFileInfo &fileInfo);
bool Next(CFileInfo &fileInfo, bool &found);
};
#ifdef _UNICODE
@@ -123,6 +122,7 @@ public:
CEnumeratorW(): _wildcard(NName::kAnyStringWildcard) {}
CEnumeratorW(const UString &wildcard): _wildcard(wildcard) {}
bool Next(CFileInfoW &fileInfo);
bool Next(CFileInfoW &fileInfo, bool &found);
};
#endif

27
Windows/FileIO.cpp
View File

@@ -158,13 +158,22 @@ bool CInFile::Read(void *data, UINT32 size, UINT32 &processedSize)
bool COutFile::Open(LPCTSTR fileName, DWORD shareMode,
DWORD creationDisposition, DWORD flagsAndAttributes)
{
return Create(fileName, GENERIC_WRITE, shareMode,
return CFileBase::Create(fileName, GENERIC_WRITE, shareMode,
creationDisposition, flagsAndAttributes);
}
bool COutFile::Open(LPCTSTR fileName)
static inline DWORD GetCreationDisposition(bool createAlways)
{ return createAlways? CREATE_ALWAYS: CREATE_NEW; }
bool COutFile::Open(LPCTSTR fileName, DWORD creationDisposition)
{
return Open(fileName, FILE_SHARE_READ, m_CreationDisposition, FILE_ATTRIBUTE_NORMAL);
return Open(fileName, FILE_SHARE_READ,
creationDisposition, FILE_ATTRIBUTE_NORMAL);
}
bool COutFile::Create(LPCTSTR fileName, bool createAlways)
{
return Open(fileName, GetCreationDisposition(createAlways));
}
#ifndef _UNICODE
@@ -172,13 +181,19 @@ bool COutFile::Open(LPCTSTR fileName)
bool COutFile::Open(LPCWSTR fileName, DWORD shareMode,
DWORD creationDisposition, DWORD flagsAndAttributes)
{
return Create(fileName, GENERIC_WRITE, shareMode,
return CFileBase::Create(fileName, GENERIC_WRITE, shareMode,
creationDisposition, flagsAndAttributes);
}
bool COutFile::Open(LPCWSTR fileName)
bool COutFile::Open(LPCWSTR fileName, DWORD creationDisposition)
{
return Open(fileName, FILE_SHARE_READ, m_CreationDisposition, FILE_ATTRIBUTE_NORMAL);
return Open(fileName, FILE_SHARE_READ,
creationDisposition, FILE_ATTRIBUTE_NORMAL);
}
bool COutFile::Create(LPCWSTR fileName, bool createAlways)
{
return Open(fileName, GetCreationDisposition(createAlways));
}
#endif

14
Windows/FileIO.h
View File

@@ -1,7 +1,5 @@
// Windows/FileIO.h
#pragma once
#ifndef __WINDOWS_FILEIO_H
#define __WINDOWS_FILEIO_H
@@ -67,23 +65,27 @@ public:
class COutFile: public CFileBase
{
DWORD m_CreationDisposition;
// DWORD m_CreationDisposition;
public:
COutFile(): m_CreationDisposition(CREATE_NEW){};
// COutFile(): m_CreationDisposition(CREATE_NEW){};
bool Open(LPCTSTR fileName, DWORD shareMode,
DWORD creationDisposition, DWORD flagsAndAttributes);
bool Open(LPCTSTR fileName);
bool Open(LPCTSTR fileName, DWORD creationDisposition);
bool Create(LPCTSTR fileName, bool createAlways);
#ifndef _UNICODE
bool Open(LPCWSTR fileName, DWORD shareMode,
DWORD creationDisposition, DWORD flagsAndAttributes);
bool Open(LPCWSTR fileName);
bool Open(LPCWSTR fileName, DWORD creationDisposition);
bool Create(LPCWSTR fileName, bool createAlways);
#endif
/*
void SetOpenCreationDisposition(DWORD creationDisposition)
{ m_CreationDisposition = creationDisposition; }
void SetOpenCreationDispositionCreateAlways()
{ m_CreationDisposition = CREATE_ALWAYS; }
*/
bool SetTime(const FILETIME *creationTime,
const FILETIME *lastAccessTime, const FILETIME *lastWriteTime);

2
Windows/FileMapping.h
View File

@@ -1,7 +1,5 @@
// Windows/FileMapping.h
#pragma once
#ifndef __WINDOWS_FILEMAPPING_H
#define __WINDOWS_FILEMAPPING_H

2
Windows/FileName.cpp
View File

@@ -3,7 +3,7 @@
#include "StdAfx.h"
#include "Windows/FileName.h"
#include "Common/WildCard.h"
#include "Common/Wildcard.h"
namespace NWindows {
namespace NFile {

2
Windows/FileName.h
View File

@@ -1,7 +1,5 @@
// Windows/FileName.h
#pragma once
#ifndef __WINDOWS_FILENAME_H
#define __WINDOWS_FILENAME_H

2
Windows/FileSystem.h
View File

@@ -1,7 +1,5 @@
// Windows/FileSystem.h
#pragma once
#ifndef __WINDOWS_FILESYSTEM_H
#define __WINDOWS_FILESYSTEM_H

2
Windows/Handle.h
View File

@@ -1,7 +1,5 @@
// Windows/Handle.h
#pragma once
#ifndef __WINDOWS_HANDLE_H
#define __WINDOWS_HANDLE_H

166
Windows/ItemIDListUtils.cpp
View File

@@ -1,166 +0,0 @@
// ItemIDListUtils.h
#include "StdAfx.h"
#include "ItemIDListUtils.h"
namespace NItemIDList {
CHolder::CHolder(const CHolder& anItemIDList):
m_Object(NULL)
{
*this = anItemIDList;
}
bool CHolder::Create(UINT16 aPureSize)
{
Free();
m_Object = LPITEMIDLIST(CoTaskMemAlloc(2 + aPureSize + 2));
if(m_Object == NULL)
return false;
m_Object->mkid.cb = 2 + aPureSize;
LPITEMIDLIST aNewIDListEnd = LPITEMIDLIST(((BYTE *)m_Object) + 2 + aPureSize);
aNewIDListEnd->mkid.cb = 0;
return (m_Object != NULL);
}
void CHolder::Free()
{
if(m_Object == NULL)
return;
CoTaskMemFree(m_Object);
m_Object = NULL;
}
CHolder& CHolder::operator=(LPCITEMIDLIST anObject)
{
if(m_Object != NULL)
Free();
UINT32 aSize = GetSize(anObject);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(aSize);
if(m_Object != NULL)
MoveMemory(m_Object, anObject, aSize);
return *this;
}
CHolder& CHolder::operator=(const CHolder &anObject)
{
if(m_Object != NULL)
Free();
if(anObject.m_Object != NULL)
{
UINT32 aSize = GetSize(anObject.m_Object);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(aSize);
if(m_Object != NULL)
MoveMemory(m_Object, anObject.m_Object, aSize);
}
return *this;
}
////////////////////////
// static
LPITEMIDLIST GetNextItem(LPCITEMIDLIST anIDList)
{
if (anIDList)
return (LPITEMIDLIST)(LPBYTE) ( ((LPBYTE)anIDList) + anIDList->mkid.cb);
return (NULL);
}
UINT32 GetSize(LPCITEMIDLIST anIDList)
{
UINT32 aSizeTotal = 0;
if(anIDList != NULL)
{
while(anIDList->mkid.cb != 0)
{
aSizeTotal += anIDList->mkid.cb;
anIDList = GetNextItem(anIDList);
}
aSizeTotal += sizeof(ITEMIDLIST) - 1;
}
return (aSizeTotal);
}
LPITEMIDLIST GetLastItem(LPCITEMIDLIST anIDList)
{
LPITEMIDLIST anIDListLast = NULL;
if(anIDList)
while(anIDList->mkid.cb != 0)
{
anIDListLast = (LPITEMIDLIST)anIDList;
anIDList = GetNextItem(anIDList);
}
return anIDListLast;
}
}
////////////////////////////////////////////////////////////////
// CItemIDListManager : Class to manage pidls
CItemIDListManager::CItemIDListManager():
m_pMalloc(NULL)
{
SHGetMalloc(&m_pMalloc);
}
CItemIDListManager::~CItemIDListManager()
{
if (m_pMalloc)
m_pMalloc->Release();
}
LPITEMIDLIST CItemIDListManager::Create(UINT16 aPureSize)
{
LPITEMIDLIST aPointer = LPITEMIDLIST(m_pMalloc->Alloc(2 + aPureSize + 2));
if(aPointer == NULL)
return NULL;
aPointer->mkid.cb = 2 + aPureSize;
LPITEMIDLIST aNewIDListEnd = LPITEMIDLIST(((BYTE *)aPointer) + 2 + aPureSize);
aNewIDListEnd->mkid.cb = 0;
return aPointer;
}
void CItemIDListManager::Delete(LPITEMIDLIST anIDList)
{
m_pMalloc->Free(anIDList);
}
LPITEMIDLIST CItemIDListManager::Copy(LPCITEMIDLIST anIDListSrc)
{
if (NULL == anIDListSrc)
return (NULL);
LPITEMIDLIST anIDListTarget = NULL;
UINT32 aSize = NItemIDList::GetSize(anIDListSrc);
anIDListTarget = (LPITEMIDLIST)m_pMalloc->Alloc(aSize);
if (!anIDListTarget)
return (NULL);
MoveMemory(anIDListTarget, anIDListSrc, aSize);
return anIDListTarget;
}
LPITEMIDLIST CItemIDListManager::Concatenate(LPCITEMIDLIST anIDList1,
LPCITEMIDLIST anIDList2)
{
if(!anIDList1 && !anIDList2)
return NULL;
if(!anIDList1)
return Copy(anIDList2);
if(!anIDList2)
return Copy(anIDList1);
UINT32 cb1 = NItemIDList::GetSize(anIDList1) - 2;
UINT32 cb2 = NItemIDList::GetSize(anIDList2);
LPITEMIDLIST anIDListNew = (LPITEMIDLIST)m_pMalloc->Alloc(cb1 + cb2);
if(anIDListNew)
{
MoveMemory(anIDListNew, anIDList1, cb1);
MoveMemory(((LPBYTE)anIDListNew) + cb1, anIDList2, cb2);
}
return anIDListNew;
}

98
Windows/ItemIDListUtils.h
View File

@@ -1,98 +0,0 @@
// ItemIDListUtils.h
#pragma once
#ifndef __ITEMIDLISTUTILS_H
#define __ITEMIDLISTUTILS_H
#include "Common/Types.h"
/////////////////////////////
// It is not for shell using
// It's for internal using only
// since it uses CoTaskMemFree instead SHGetMalloc
namespace NItemIDList {
LPITEMIDLIST GetNextItem(LPCITEMIDLIST anIDList);
UINT32 GetSize(LPCITEMIDLIST anIDList);
LPITEMIDLIST GetLastItem(LPCITEMIDLIST anIDList);
class CHolder
{
LPITEMIDLIST m_Object;
public:
CHolder(): m_Object(NULL) {}
CHolder(const CHolder& anItemIDList);
~CHolder() { Free(); }
void Attach(LPITEMIDLIST anObject)
{
if (m_Object != NULL)
Free();
m_Object = anObject;
}
LPITEMIDLIST Detach()
{
LPITEMIDLIST anObject = m_Object;
m_Object = NULL;
return anObject;
}
void Free();
bool Create(UINT16 aPureSize);
operator LPITEMIDLIST() { return m_Object;}
operator LPCITEMIDLIST() const { return m_Object;}
LPITEMIDLIST* operator&() { return &m_Object; }
LPITEMIDLIST operator->() { return m_Object; }
CHolder& operator=(LPCITEMIDLIST anObject);
CHolder& operator=(const CHolder &anObject);
};
}
class CItemIDListManager
{
public:
CItemIDListManager();
~CItemIDListManager();
public:
LPITEMIDLIST Create(UINT16 aPureSize);
void Delete(LPITEMIDLIST anIDList);
LPITEMIDLIST Copy(LPCITEMIDLIST anIDListSrc);
// CZipIDData* GetDataPointer(LPCITEMIDLIST anIDList);
LPITEMIDLIST Concatenate(LPCITEMIDLIST anIDList1, LPCITEMIDLIST anIDList2);
private:
LPMALLOC m_pMalloc;
};
class CShellItemIDList
{
CItemIDListManager *m_Manager;
LPITEMIDLIST m_Object;
public:
CShellItemIDList(CItemIDListManager *aManager):
m_Manager(aManager),
m_Object(NULL) {}
bool Create(UINT16 aPureSize)
{
Free();
m_Object = m_Manager->Create(aPureSize);
return (m_Object != NULL);
}
~CShellItemIDList() { Free(); }
void Free()
{
if(m_Object != NULL)
m_Manager->Delete(m_Object);
m_Object = NULL;
}
void Attach(LPITEMIDLIST anObject)
{
Free();
m_Object = anObject;
}
operator LPITEMIDLIST() { return m_Object;}
LPITEMIDLIST* operator&() { return &m_Object; }
};
#endif

2
Windows/Memory.h
View File

@@ -1,7 +1,5 @@
// Windows/Memory.h
#pragma once
#ifndef __WINDOWS_MEMORY_H
#define __WINDOWS_MEMORY_H

2
Windows/Menu.h
View File

@@ -1,7 +1,5 @@
// Windows/Menu.h
#pragma once
#ifndef __WINDOWS_MENU_H
#define __WINDOWS_MENU_H

2
Windows/NationalTime.h
View File

@@ -1,7 +1,5 @@
// Windows/NationalTime.h
#pragma once
#ifndef __WINDOWS_NATIONALTIME_H
#define __WINDOWS_NATIONALTIME_H

2
Windows/Net.h
View File

@@ -1,7 +1,5 @@
// Windows/Net.h
#pragma once
#ifndef __WINDOWS_NET_H
#define __WINDOWS_NET_H

2
Windows/ProcessMessages.h
View File

@@ -1,7 +1,5 @@
// Windows/ProcessMessages.h
#pragma once
#ifndef __WINDOWS_PROCESSMESSAGES_H
#define __WINDOWS_PROCESSMESSAGES_H

221
Windows/PropVariant.cpp
View File

@@ -33,8 +33,6 @@ CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
*this = lpszSrc;
}
///////////////////////////
// Assignment Operators
CPropVariant& CPropVariant::operator=(const CPropVariant& varSrc)
{
InternalCopy(&varSrc);
@@ -48,14 +46,7 @@ CPropVariant& CPropVariant::operator=(const PROPVARIANT& varSrc)
CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
{
InternalClear();
vt = VT_BSTR;
bstrVal = ::SysAllocString(bstrSrc);
if (bstrVal == NULL && bstrSrc != NULL)
{
vt = VT_ERROR;
scode = E_OUTOFMEMORY;
}
*this = (LPCOLESTR)bstrSrc;
return *this;
}
@@ -64,7 +55,6 @@ CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
InternalClear();
vt = VT_BSTR;
bstrVal = ::SysAllocString(lpszSrc);
if (bstrVal == NULL && lpszSrc != NULL)
{
vt = VT_ERROR;
@@ -85,7 +75,7 @@ CPropVariant& CPropVariant::operator=(bool bSrc)
return *this;
}
CPropVariant& CPropVariant::operator=(UINT32 value)
CPropVariant& CPropVariant::operator=(UInt32 value)
{
if (vt != VT_UI4)
{
@@ -96,14 +86,14 @@ CPropVariant& CPropVariant::operator=(UINT32 value)
return *this;
}
CPropVariant& CPropVariant::operator=(UINT64 value)
CPropVariant& CPropVariant::operator=(UInt64 value)
{
if (vt != VT_UI8)
{
InternalClear();
vt = VT_UI8;
}
uhVal = *(ULARGE_INTEGER*)&value;
uhVal.QuadPart = value;
return *this;
}
@@ -118,7 +108,7 @@ CPropVariant& CPropVariant::operator=(const FILETIME &value)
return *this;
}
CPropVariant& CPropVariant::operator=(int value)
CPropVariant& CPropVariant::operator=(Int32 value)
{
if (vt != VT_I4)
{
@@ -130,7 +120,7 @@ CPropVariant& CPropVariant::operator=(int value)
return *this;
}
CPropVariant& CPropVariant::operator=(BYTE value)
CPropVariant& CPropVariant::operator=(Byte value)
{
if (vt != VT_UI1)
{
@@ -141,7 +131,7 @@ CPropVariant& CPropVariant::operator=(BYTE value)
return *this;
}
CPropVariant& CPropVariant::operator=(short value)
CPropVariant& CPropVariant::operator=(Int16 value)
{
if (vt != VT_I2)
{
@@ -163,9 +153,9 @@ CPropVariant& CPropVariant::operator=(long value)
return *this;
}
static HRESULT MyPropVariantClear(PROPVARIANT *aPropVariant)
static HRESULT MyPropVariantClear(PROPVARIANT *propVariant)
{
switch(aPropVariant->vt)
switch(propVariant->vt)
{
case VT_UI1:
case VT_I1:
@@ -183,10 +173,10 @@ static HRESULT MyPropVariantClear(PROPVARIANT *aPropVariant)
case VT_R8:
case VT_CY:
case VT_DATE:
aPropVariant->vt = VT_EMPTY;
propVariant->vt = VT_EMPTY;
return S_OK;
}
return ::VariantClear((tagVARIANT *)aPropVariant);
return ::VariantClear((VARIANTARG *)propVariant);
}
HRESULT CPropVariant::Clear()
@@ -215,7 +205,7 @@ HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc)
case VT_R8:
case VT_CY:
case VT_DATE:
MoveMemory((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
return S_OK;
}
return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)(pSrc));
@@ -224,41 +214,22 @@ HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc)
HRESULT CPropVariant::Attach(PROPVARIANT* pSrc)
{
// Clear out the variant
HRESULT hr = Clear();
if (!FAILED(hr))
{
// Copy the contents and give control to CPropVariant
memcpy(this, pSrc, sizeof(PROPVARIANT));
pSrc->vt = VT_EMPTY;
hr = S_OK;
}
return hr;
if (FAILED(hr))
return hr;
memcpy(this, pSrc, sizeof(PROPVARIANT));
pSrc->vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::Detach(PROPVARIANT* pDest)
{
// Clear out the variant
HRESULT hr = MyPropVariantClear(pDest);
// HRESULT hr = ::VariantClear((VARIANT* )pDest);
if (!FAILED(hr))
{
// Copy the contents and remove control from CPropVariant
memcpy(pDest, this, sizeof(PROPVARIANT));
vt = VT_EMPTY;
hr = S_OK;
}
return hr;
}
HRESULT CPropVariant::ChangeType(VARTYPE vtNew, const PROPVARIANT* pSrc)
{
PROPVARIANT* pVar = const_cast<PROPVARIANT*>(pSrc);
// Convert in place if pSrc is NULL
if (pVar == NULL)
pVar = this;
// Do nothing if doing in place convert and vts not different
return ::VariantChangeType((VARIANT *)this, (VARIANT *)pVar, 0, vtNew);
if (FAILED(hr))
return hr;
memcpy(pDest, this, sizeof(PROPVARIANT));
vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::InternalClear()
@@ -282,148 +253,6 @@ void CPropVariant::InternalCopy(const PROPVARIANT* pSrc)
}
}
HRESULT CPropVariant::WriteToStream(ISequentialStream *stream) const
{
HRESULT aResult = stream->Write(&vt, sizeof(vt), NULL);
if (FAILED(aResult))
return aResult;
if (vt == VT_EMPTY)
return S_OK;
int aNumBytes = 0;
switch (vt)
{
case VT_UI1:
case VT_I1:
aNumBytes = sizeof(BYTE);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
aNumBytes = sizeof(short);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
aNumBytes = sizeof(long);
break;
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
aNumBytes = sizeof(double);
break;
default:
break;
}
if (aNumBytes != 0)
return stream->Write(&bVal, aNumBytes, NULL);
if (vt == VT_BSTR)
{
UINT32 aLen = 0;
if(bstrVal != NULL)
aLen = SysStringLen(bstrVal);
HRESULT aResult = stream->Write(&aLen, sizeof(UINT32), NULL);
if (FAILED(aResult))
return aResult;
if(bstrVal == NULL)
return S_OK;
if(aLen == 0)
return S_OK;
return stream->Write(bstrVal, aLen * sizeof(wchar_t), NULL);
}
else
{
return E_FAIL;
/*
CPropVariant varBSTR;
HRESULT hr = VariantChangeType(&varBSTR, this, VARIANT_NOVALUEPROP, VT_BSTR);
if (FAILED(hr))
return;
MoveMemory(aMemoryPointer, varBSTR.bstrVal, SysStringLen(varBSTR.bstrVal));
*/
}
}
HRESULT CPropVariant::ReadFromStream(ISequentialStream *stream)
{
HRESULT hr = Clear();
if (FAILED(hr))
return hr;
VARTYPE vtRead;
hr = stream->Read(&vtRead, sizeof(VARTYPE), NULL);
if (hr == S_FALSE)
hr = E_FAIL;
if (FAILED(hr))
return hr;
vt = vtRead;
if (vt == VT_EMPTY)
return S_OK;
int aNumBytes = 0;
switch (vt)
{
case VT_UI1:
case VT_I1:
aNumBytes = sizeof(BYTE);
break;
case VT_I2:
case VT_UI2:
case VT_BOOL:
aNumBytes = sizeof(short);
break;
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
aNumBytes = sizeof(long);
break;
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
aNumBytes = sizeof(double);
break;
default:
break;
}
if (aNumBytes != 0)
{
hr = stream->Read(&bVal, aNumBytes, NULL);
if (hr == S_FALSE)
hr = E_FAIL;
return hr;
}
if (vt == VT_BSTR)
{
bstrVal = NULL;
UINT32 aLen = 0;
hr = stream->Read(&aLen, sizeof(UINT32), NULL);
if (hr != S_OK)
return E_FAIL;
bstrVal = SysAllocStringLen(NULL, aLen);
if(bstrVal == NULL)
return E_OUTOFMEMORY;
hr = stream->Read(bstrVal, aLen * sizeof(wchar_t), NULL);
if (hr == S_FALSE)
hr = E_FAIL;
return hr;
}
else
return E_FAIL;
}
int CPropVariant::Compare(const CPropVariant &a)
{
if(vt != a.vt)
@@ -458,12 +287,12 @@ int CPropVariant::Compare(const CPropVariant &a)
return MyCompare(uintVal, a.uintVal);
*/
case VT_I8:
return MyCompare(INT64(*(const INT64 *)&hVal), INT64(*(const INT64 *)&a.hVal));
return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
case VT_UI8:
return MyCompare(UINT64(*(const UINT64 *)&uhVal), UINT64(*(const UINT64 *)&a.uhVal));
return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
case VT_BOOL:
return -MyCompare(boolVal, a.boolVal); // Test it
return -MyCompare(boolVal, a.boolVal);
case VT_FILETIME:
return ::CompareFileTime(&filetime, &a.filetime);

29
Windows/PropVariant.h
View File

@@ -1,10 +1,11 @@
// Windows/PropVariant.h
// #pragma once
#ifndef __WINDOWS_PROPVARIANT_H
#define __WINDOWS_PROPVARIANT_H
#include "../Common/MyWindows.h"
#include "../Common/Types.h"
namespace NWindows {
namespace NCOM {
@@ -18,12 +19,12 @@ public:
CPropVariant(BSTR bstrSrc);
CPropVariant(LPCOLESTR lpszSrc);
CPropVariant(bool bSrc) { vt = VT_BOOL; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); };
CPropVariant(UINT32 value) { vt = VT_UI4; ulVal = value; }
CPropVariant(UINT64 value) { vt = VT_UI8; uhVal = *(ULARGE_INTEGER*)&value; }
CPropVariant(UInt32 value) { vt = VT_UI4; ulVal = value; }
CPropVariant(UInt64 value) { vt = VT_UI8; uhVal = *(ULARGE_INTEGER*)&value; }
CPropVariant(const FILETIME &value) { vt = VT_FILETIME; filetime = value; }
CPropVariant(int value) { vt = VT_I4; lVal = value; }
CPropVariant(BYTE value) { vt = VT_UI1; bVal = value; }
CPropVariant(short value) { vt = VT_I2; iVal = value; }
CPropVariant(Int32 value) { vt = VT_I4; lVal = value; }
CPropVariant(Byte value) { vt = VT_UI1; bVal = value; }
CPropVariant(Int16 value) { vt = VT_I2; iVal = value; }
CPropVariant(long value, VARTYPE vtSrc = VT_I4) { vt = vtSrc; lVal = value; }
CPropVariant& operator=(const CPropVariant& varSrc);
@@ -31,27 +32,23 @@ public:
CPropVariant& operator=(BSTR bstrSrc);
CPropVariant& operator=(LPCOLESTR lpszSrc);
CPropVariant& operator=(bool bSrc);
CPropVariant& operator=(UINT32 value);
CPropVariant& operator=(UINT64 value);
CPropVariant& operator=(UInt32 value);
CPropVariant& operator=(UInt64 value);
CPropVariant& operator=(const FILETIME &value);
CPropVariant& operator=(int value);
CPropVariant& operator=(BYTE value);
CPropVariant& operator=(short value);
CPropVariant& operator=(Int32 value);
CPropVariant& operator=(Byte value);
CPropVariant& operator=(Int16 value);
CPropVariant& operator=(long value);
HRESULT Clear();
HRESULT Copy(const PROPVARIANT* pSrc);
HRESULT Attach(PROPVARIANT* pSrc);
HRESULT Detach(PROPVARIANT* pDest);
HRESULT ChangeType(VARTYPE vtNew, const PROPVARIANT* pSrc = NULL);
HRESULT InternalClear();
void InternalCopy(const PROPVARIANT* pSrc);
HRESULT WriteToStream(ISequentialStream *stream) const;
HRESULT ReadFromStream(ISequentialStream *stream);
int Compare(const CPropVariant &a1);
};

121
Windows/PropVariantConversions.cpp
View File

@@ -2,6 +2,8 @@
#include "StdAfx.h"
#include <stdio.h>
#include "PropVariantConversions.h"
#include "Windows/NationalTime.h"
@@ -12,70 +14,75 @@
using namespace NWindows;
static UString ConvertUINT64ToString(UINT64 value)
static UString ConvertUInt64ToString(UInt64 value)
{
wchar_t buffer[32];
ConvertUINT64ToString(value, buffer);
ConvertUInt64ToString(value, buffer);
return buffer;
}
static UString ConvertINT64ToString(INT64 value)
static UString ConvertInt64ToString(Int64 value)
{
wchar_t buffer[32];
ConvertINT64ToString(value, buffer);
ConvertInt64ToString(value, buffer);
return buffer;
}
/*
CSysString ConvertFileTimeToString(const FILETIME &fileTime, bool includeTime)
static void UIntToStringSpec(UInt32 value, char *s, int numPos)
{
SYSTEMTIME systemTime;
if(!BOOLToBool(FileTimeToSystemTime(&fileTime, &systemTime)))
#ifndef _WIN32_WCE
throw 311907;
#else
return CSysString();
#endif
const int kBufferSize = 64;
CSysString stringDate;
if(!NNational::NTime::MyGetDateFormat(LOCALE_USER_DEFAULT,
0, &systemTime, NULL, stringDate))
#ifndef _WIN32_WCE
throw 311908;
#else
return CSysString();
#endif
if (!includeTime)
return stringDate;
CSysString stringTime;
if(!NNational::NTime::MyGetTimeFormat(LOCALE_USER_DEFAULT,
0, &systemTime, NULL, stringTime))
#ifndef _WIN32_WCE
throw 311909;
#else
return CSysString();
#endif
return stringDate + _T(" ") + stringTime;
char s2[32];
ConvertUInt64ToString(value, s2);
int len = strlen(s2);
int i;
for (i = 0; i < numPos - len; i++)
s[i] = '0';
for (int j = 0; j < len; j++, i++)
s[i] = s2[j];
s[i] = '\0';
}
*/
UString ConvertFileTimeToString2(const FILETIME &fileTime,
bool includeTime, bool includeSeconds)
bool ConvertFileTimeToString(const FILETIME &ft, char *s, bool includeTime, bool includeSeconds)
{
CSysString string;
SYSTEMTIME systemTime;
if(!BOOLToBool(FileTimeToSystemTime(&fileTime, &systemTime)))
return UString();
TCHAR buffer[64];
wsprintf(buffer, TEXT("%04d-%02d-%02d"), systemTime.wYear, systemTime.wMonth, systemTime.wDay);
s[0] = '\0';
SYSTEMTIME st;
if(!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
return false;
/*
UIntToStringSpec(st.wYear, s, 4);
strcat(s, "-");
UIntToStringSpec(st.wMonth, s + strlen(s), 2);
strcat(s, "-");
UIntToStringSpec(st.wDay, s + strlen(s), 2);
if (includeTime)
{
wsprintf(buffer + lstrlen(buffer), TEXT(" %02d:%02d"), systemTime.wHour, systemTime.wMinute);
strcat(s, " ");
UIntToStringSpec(st.wHour, s + strlen(s), 2);
strcat(s, ":");
UIntToStringSpec(st.wMinute, s + strlen(s), 2);
if (includeSeconds)
wsprintf(buffer + lstrlen(buffer), TEXT(":%02d"), systemTime.wSecond);
{
strcat(s, ":");
UIntToStringSpec(st.wSecond, s + strlen(s), 2);
}
}
return GetUnicodeString(buffer);
*/
sprintf(s, "%04d-%02d-%02d", st.wYear, st.wMonth, st.wDay);
if (includeTime)
{
sprintf(s + strlen(s), " %02d:%02d", st.wHour, st.wMinute);
if (includeSeconds)
sprintf(s + strlen(s), ":%02d", st.wSecond);
}
return true;
}
UString ConvertFileTimeToString(const FILETIME &fileTime, bool includeTime, bool includeSeconds)
{
char s[32];
ConvertFileTimeToString(fileTime, s, includeTime, includeSeconds);
return GetUnicodeString(s);
}
@@ -88,27 +95,25 @@ UString ConvertPropVariantToString(const PROPVARIANT &propVariant)
case VT_BSTR:
return propVariant.bstrVal;
case VT_UI1:
return ConvertUINT64ToString(propVariant.bVal);
return ConvertUInt64ToString(propVariant.bVal);
case VT_UI2:
return ConvertUINT64ToString(propVariant.uiVal);
return ConvertUInt64ToString(propVariant.uiVal);
case VT_UI4:
return ConvertUINT64ToString(propVariant.ulVal);
return ConvertUInt64ToString(propVariant.ulVal);
case VT_UI8:
return ConvertUINT64ToString(*(UINT64 *)(&propVariant.uhVal));
return ConvertUInt64ToString(propVariant.uhVal.QuadPart);
case VT_FILETIME:
return ConvertFileTimeToString2(propVariant.filetime, true, true);
return ConvertFileTimeToString(propVariant.filetime, true, true);
/*
case VT_I1:
return ConvertINT64ToString(propVariant.cVal);
return ConvertInt64ToString(propVariant.cVal);
*/
case VT_I2:
return ConvertINT64ToString(propVariant.iVal);
return ConvertInt64ToString(propVariant.iVal);
case VT_I4:
return ConvertINT64ToString(propVariant.lVal);
return ConvertInt64ToString(propVariant.lVal);
case VT_I8:
return ConvertINT64ToString(*(INT64 *)(&propVariant.hVal));
return ConvertInt64ToString(propVariant.hVal.QuadPart);
case VT_BOOL:
return VARIANT_BOOLToBool(propVariant.boolVal) ? L"1" : L"0";
@@ -116,12 +121,12 @@ UString ConvertPropVariantToString(const PROPVARIANT &propVariant)
#ifndef _WIN32_WCE
throw 150245;
#else
return CSysString();
return UString();
#endif
}
}
UINT64 ConvertPropVariantToUINT64(const PROPVARIANT &propVariant)
UInt64 ConvertPropVariantToUInt64(const PROPVARIANT &propVariant)
{
switch (propVariant.vt)
{
@@ -132,7 +137,7 @@ UINT64 ConvertPropVariantToUINT64(const PROPVARIANT &propVariant)
case VT_UI4:
return propVariant.ulVal;
case VT_UI8:
return (*(UINT64 *)(&propVariant.uhVal));
return (UInt64)propVariant.uhVal.QuadPart;
default:
#ifndef _WIN32_WCE
throw 151199;

11
Windows/PropVariantConversions.h
View File

@@ -1,17 +1,14 @@
// Windows/PropVariantConversions.h
#pragma once
#ifndef __PROPVARIANTCONVERSIONS_H
#define __PROPVARIANTCONVERSIONS_H
#include "Common/Types.h"
#include "Common/String.h"
// CSysString ConvertFileTimeToString(const FILETIME &fileTime, bool includeTime = true);
UString ConvertFileTimeToString2(const FILETIME &fileTime, bool includeTime = true,
bool includeSeconds = true);
bool ConvertFileTimeToString(const FILETIME &ft, char *s, bool includeTime = true, bool includeSeconds = true);
UString ConvertFileTimeToString(const FILETIME &ft, bool includeTime = true, bool includeSeconds = true);
UString ConvertPropVariantToString(const PROPVARIANT &propVariant);
UINT64 ConvertPropVariantToUINT64(const PROPVARIANT &propVariant);
UInt64 ConvertPropVariantToUInt64(const PROPVARIANT &propVariant);
#endif

2
Windows/Registry.h
View File

@@ -1,7 +1,5 @@
// Windows/Registry.h
#pragma once
#ifndef __WINDOWS_REGISTRY_H
#define __WINDOWS_REGISTRY_H

2
Windows/ResourceString.h
View File

@@ -1,7 +1,5 @@
// Windows/ResourceString.h
#pragma once
#ifndef __WINDOWS_RESOURCESTRING_H
#define __WINDOWS_RESOURCESTRING_H

2
Windows/Shell.h
View File

@@ -1,7 +1,5 @@
// Windows/Shell.h
#pragma once
#ifndef __WINDOWS_SHELL_H
#define __WINDOWS_SHELL_H

4
Windows/StdAfx.h
View File

@@ -1,8 +1,8 @@
// stdafx.h
// StdAfx.h
#ifndef __STDAFX_H
#define __STDAFX_H
#include <windows.h>
#include "../Common/MyWindows.h"
#endif

2
Windows/Synchronization.h
View File

@@ -1,7 +1,5 @@
// Windows/Synchronization.h
#pragma once
#ifndef __WINDOWS_SYNCHRONIZATION_H
#define __WINDOWS_SYNCHRONIZATION_H

15
Windows/System.cpp
View File

@@ -1,15 +0,0 @@
// Windows/System.h
#include "StdAfx.h"
#include "System.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
namespace NWindows {
namespace NSystem {
}}

15
Windows/System.h
View File

@@ -1,15 +0,0 @@
// Windows/System.h
#pragma once
#ifndef __WINDOWS_SYSTEM_H
#define __WINDOWS_SYSTEM_H
#include "../Common/String.h"
namespace NWindows {
namespace NSystem {
}}
#endif

11
Windows/Thread.h
View File

@@ -1,7 +1,5 @@
// Windows/Thread.h
#pragma once
#ifndef __WINDOWS_THREAD_H
#define __WINDOWS_THREAD_H
@@ -12,6 +10,7 @@ namespace NWindows {
class CThread: public CHandle
{
bool IsOpen() const { return _handle != 0; }
public:
bool Create(LPSECURITY_ATTRIBUTES threadAttributes,
SIZE_T stackSize, LPTHREAD_START_ROUTINE startAddress,
@@ -38,6 +37,14 @@ public:
{ return ::GetThreadPriority(_handle); }
bool SetPriority(int priority)
{ return BOOLToBool(::SetThreadPriority(_handle, priority)); }
bool Wait()
{
if (!IsOpen())
return true;
return (::WaitForSingleObject(_handle, INFINITE) == WAIT_OBJECT_0);
}
};
}

45
Windows/Time.h
View File

@@ -1,55 +1,48 @@
// Windows/Time.h
#pragma once
#ifndef __WINDOWS_TIME_H
#define __WINDOWS_TIME_H
#include "Common/Types.h"
// #include <windows.h>
// #include <time.h>
#include "Windows/Defs.h"
namespace NWindows {
namespace NTime {
inline bool DosTimeToFileTime(UINT32 dosTime, FILETIME &fileTime)
inline bool DosTimeToFileTime(UInt32 dosTime, FILETIME &fileTime)
{
return BOOLToBool(::DosDateTimeToFileTime(UINT16(dosTime >> 16),
UINT16(dosTime & 0xFFFF), &fileTime));
return BOOLToBool(::DosDateTimeToFileTime(UInt16(dosTime >> 16),
UInt16(dosTime & 0xFFFF), &fileTime));
}
inline bool FileTimeToDosTime(const FILETIME &fileTime, UINT32 &dosTime)
inline bool FileTimeToDosTime(const FILETIME &fileTime, UInt32 &dosTime)
{
return BOOLToBool(::FileTimeToDosDateTime(&fileTime,
((LPWORD)&dosTime) + 1, (LPWORD)&dosTime));
WORD datePart, timePart;
if (!::FileTimeToDosDateTime(&fileTime, &datePart, &timePart))
return false;
dosTime = (((UInt32)datePart) << 16) + timePart;
return true;
}
const UINT64 kUnixTimeStartValue =
#if ( __GNUC__)
116444736000000000LL;
#else
116444736000000000;
#endif
const UINT32 kNumTimeQuantumsInSecond = 10000000;
const UInt32 kNumTimeQuantumsInSecond = 10000000;
const UInt64 kUnixTimeStartValue = ((UInt64)kNumTimeQuantumsInSecond) * 60 * 60 * 24 * 134774;
inline void UnixTimeToFileTime(long unixTime, FILETIME &fileTime)
inline void UnixTimeToFileTime(UInt32 unixTime, FILETIME &fileTime)
{
ULONGLONG ll = UInt32x32To64(unixTime, kNumTimeQuantumsInSecond) +
kUnixTimeStartValue;
fileTime.dwLowDateTime = (DWORD) ll;
fileTime.dwHighDateTime = DWORD(ll >> 32);
UInt64 v = kUnixTimeStartValue + ((UInt64)unixTime) * kNumTimeQuantumsInSecond;
fileTime.dwLowDateTime = (DWORD)v;
fileTime.dwHighDateTime = (DWORD)(v >> 32);
}
inline bool FileTimeToUnixTime(const FILETIME &fileTime, long &unixTime)
inline bool FileTimeToUnixTime(const FILETIME &fileTime, UInt32 &unixTime)
{
UINT64 winTime = (((UINT64)fileTime.dwHighDateTime) << 32) + fileTime.dwLowDateTime;
UInt64 winTime = (((UInt64)fileTime.dwHighDateTime) << 32) + fileTime.dwLowDateTime;
if (winTime < kUnixTimeStartValue)
return false;
winTime = (winTime - kUnixTimeStartValue) / kNumTimeQuantumsInSecond;
if (winTime >= 0xFFFFFFFF)
if (winTime > 0xFFFFFFFF)
return false;
unixTime = (long)winTime;
unixTime = (UInt32)winTime;
return true;
}

2
Windows/Window.h
View File

@@ -1,7 +1,5 @@
// Windows/Window.h
#pragma once
#ifndef __WINDOWS_WINDOW_H
#define __WINDOWS_WINDOW_H