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

Normalize all the line endings

Browse Source
This commit is contained in:
Tino Reichardt
2020-05-31 13:08:03 +02:00
parent d8345ee3b3
commit 9c3c277ad7
1156 changed files with 292304 additions and 292304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
CPP/Windows/COM.cpp
View File

@@ -1,41 +1,41 @@
// Windows/COM.cpp
#include "StdAfx.h"
/*
#include "COM.h"
#include "../Common/StringConvert.h"
namespace NWindows {
namespace NCOM {
// CoInitialize (NULL); must be called!
UString GUIDToStringW(REFGUID guid)
{
UString s;
const unsigned kSize = 48;
StringFromGUID2(guid, s.GetBuf(kSize), kSize);
s.ReleaseBuf_CalcLen(kSize);
return s;
}
AString GUIDToStringA(REFGUID guid)
{
return UnicodeStringToMultiByte(GUIDToStringW(guid));
}
HRESULT StringToGUIDW(const wchar_t *string, GUID &classID)
{
return CLSIDFromString((wchar_t *)string, &classID);
}
HRESULT StringToGUIDA(const char *string, GUID &classID)
{
return StringToGUIDW(MultiByteToUnicodeString(string), classID);
}
}}
*/
// Windows/COM.cpp
#include "StdAfx.h"
/*
#include "COM.h"
#include "../Common/StringConvert.h"
namespace NWindows {
namespace NCOM {
// CoInitialize (NULL); must be called!
UString GUIDToStringW(REFGUID guid)
{
UString s;
const unsigned kSize = 48;
StringFromGUID2(guid, s.GetBuf(kSize), kSize);
s.ReleaseBuf_CalcLen(kSize);
return s;
}
AString GUIDToStringA(REFGUID guid)
{
return UnicodeStringToMultiByte(GUIDToStringW(guid));
}
HRESULT StringToGUIDW(const wchar_t *string, GUID &classID)
{
return CLSIDFromString((wchar_t *)string, &classID);
}
HRESULT StringToGUIDA(const char *string, GUID &classID)
{
return StringToGUIDW(MultiByteToUnicodeString(string), classID);
}
}}
*/

140
CPP/Windows/COM.h
View File

@@ -1,70 +1,70 @@
// Windows/COM.h
#ifndef __WINDOWS_COM_H
#define __WINDOWS_COM_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NCOM {
#ifdef _WIN32
class CComInitializer
{
public:
CComInitializer()
{
#ifdef UNDER_CE
CoInitializeEx(NULL, COINIT_MULTITHREADED);
#else
// it's single thread. Do we need multithread?
CoInitialize(NULL);
#endif
};
~CComInitializer() { CoUninitialize(); }
};
class CStgMedium
{
STGMEDIUM _object;
public:
bool _mustBeReleased;
CStgMedium(): _mustBeReleased(false) {}
~CStgMedium() { Free(); }
void Free()
{
if (_mustBeReleased)
ReleaseStgMedium(&_object);
_mustBeReleased = false;
}
const STGMEDIUM* operator->() const { return &_object;}
STGMEDIUM* operator->() { return &_object;}
STGMEDIUM* operator&() { return &_object; }
};
#endif
/*
//////////////////////////////////
// GUID <--> String Conversions
UString GUIDToStringW(REFGUID guid);
AString GUIDToStringA(REFGUID guid);
#ifdef UNICODE
#define GUIDToString GUIDToStringW
#else
#define GUIDToString GUIDToStringA
#endif
HRESULT StringToGUIDW(const wchar_t *string, GUID &classID);
HRESULT StringToGUIDA(const char *string, GUID &classID);
#ifdef UNICODE
#define StringToGUID StringToGUIDW
#else
#define StringToGUID StringToGUIDA
#endif
*/
}}
#endif
// Windows/COM.h
#ifndef __WINDOWS_COM_H
#define __WINDOWS_COM_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NCOM {
#ifdef _WIN32
class CComInitializer
{
public:
CComInitializer()
{
#ifdef UNDER_CE
CoInitializeEx(NULL, COINIT_MULTITHREADED);
#else
// it's single thread. Do we need multithread?
CoInitialize(NULL);
#endif
};
~CComInitializer() { CoUninitialize(); }
};
class CStgMedium
{
STGMEDIUM _object;
public:
bool _mustBeReleased;
CStgMedium(): _mustBeReleased(false) {}
~CStgMedium() { Free(); }
void Free()
{
if (_mustBeReleased)
ReleaseStgMedium(&_object);
_mustBeReleased = false;
}
const STGMEDIUM* operator->() const { return &_object;}
STGMEDIUM* operator->() { return &_object;}
STGMEDIUM* operator&() { return &_object; }
};
#endif
/*
//////////////////////////////////
// GUID <--> String Conversions
UString GUIDToStringW(REFGUID guid);
AString GUIDToStringA(REFGUID guid);
#ifdef UNICODE
#define GUIDToString GUIDToStringW
#else
#define GUIDToString GUIDToStringA
#endif
HRESULT StringToGUIDW(const wchar_t *string, GUID &classID);
HRESULT StringToGUIDA(const char *string, GUID &classID);
#ifdef UNICODE
#define StringToGUID StringToGUIDW
#else
#define StringToGUID StringToGUIDA
#endif
*/
}}
#endif

260
CPP/Windows/Clipboard.cpp
View File

@@ -1,130 +1,130 @@
// Windows/Clipboard.cpp
#include "StdAfx.h"
#ifdef UNDER_CE
#include <winuserm.h>
#endif
#include "../Common/StringConvert.h"
#include "Clipboard.h"
#include "Defs.h"
#include "MemoryGlobal.h"
#include "Shell.h"
namespace NWindows {
bool CClipboard::Open(HWND wndNewOwner) throw()
{
m_Open = BOOLToBool(::OpenClipboard(wndNewOwner));
return m_Open;
}
bool CClipboard::Close() throw()
{
if (!m_Open)
return true;
m_Open = !BOOLToBool(CloseClipboard());
return !m_Open;
}
bool ClipboardIsFormatAvailableHDROP()
{
return BOOLToBool(IsClipboardFormatAvailable(CF_HDROP));
}
/*
bool ClipboardGetTextString(AString &s)
{
s.Empty();
if (!IsClipboardFormatAvailable(CF_TEXT))
return false;
CClipboard clipboard;
if (!clipboard.Open(NULL))
return false;
HGLOBAL h = ::GetClipboardData(CF_TEXT);
if (h != NULL)
{
NMemory::CGlobalLock globalLock(h);
const char *p = (const char *)globalLock.GetPointer();
if (p != NULL)
{
s = p;
return true;
}
}
return false;
}
*/
/*
bool ClipboardGetFileNames(UStringVector &names)
{
names.Clear();
if (!IsClipboardFormatAvailable(CF_HDROP))
return false;
CClipboard clipboard;
if (!clipboard.Open(NULL))
return false;
HGLOBAL h = ::GetClipboardData(CF_HDROP);
if (h != NULL)
{
NMemory::CGlobalLock globalLock(h);
void *p = (void *)globalLock.GetPointer();
if (p != NULL)
{
NShell::CDrop drop(false);
drop.Attach((HDROP)p);
drop.QueryFileNames(names);
return true;
}
}
return false;
}
*/
static bool ClipboardSetData(UINT uFormat, const void *data, size_t size) throw()
{
NMemory::CGlobal global;
if (!global.Alloc(GMEM_DDESHARE | GMEM_MOVEABLE, size))
return false;
{
NMemory::CGlobalLock globalLock(global);
LPVOID p = globalLock.GetPointer();
if (!p)
return false;
memcpy(p, data, size);
}
if (::SetClipboardData(uFormat, global) == NULL)
return false;
global.Detach();
return true;
}
bool ClipboardSetText(HWND owner, const UString &s)
{
CClipboard clipboard;
if (!clipboard.Open(owner))
return false;
if (!::EmptyClipboard())
return false;
bool res;
res = ClipboardSetData(CF_UNICODETEXT, (const wchar_t *)s, (s.Len() + 1) * sizeof(wchar_t));
#ifndef _UNICODE
AString a (UnicodeStringToMultiByte(s, CP_ACP));
if (ClipboardSetData(CF_TEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
res = true;
a = UnicodeStringToMultiByte(s, CP_OEMCP);
if (ClipboardSetData(CF_OEMTEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
res = true;
#endif
return res;
}
}
// Windows/Clipboard.cpp
#include "StdAfx.h"
#ifdef UNDER_CE
#include <winuserm.h>
#endif
#include "../Common/StringConvert.h"
#include "Clipboard.h"
#include "Defs.h"
#include "MemoryGlobal.h"
#include "Shell.h"
namespace NWindows {
bool CClipboard::Open(HWND wndNewOwner) throw()
{
m_Open = BOOLToBool(::OpenClipboard(wndNewOwner));
return m_Open;
}
bool CClipboard::Close() throw()
{
if (!m_Open)
return true;
m_Open = !BOOLToBool(CloseClipboard());
return !m_Open;
}
bool ClipboardIsFormatAvailableHDROP()
{
return BOOLToBool(IsClipboardFormatAvailable(CF_HDROP));
}
/*
bool ClipboardGetTextString(AString &s)
{
s.Empty();
if (!IsClipboardFormatAvailable(CF_TEXT))
return false;
CClipboard clipboard;
if (!clipboard.Open(NULL))
return false;
HGLOBAL h = ::GetClipboardData(CF_TEXT);
if (h != NULL)
{
NMemory::CGlobalLock globalLock(h);
const char *p = (const char *)globalLock.GetPointer();
if (p != NULL)
{
s = p;
return true;
}
}
return false;
}
*/
/*
bool ClipboardGetFileNames(UStringVector &names)
{
names.Clear();
if (!IsClipboardFormatAvailable(CF_HDROP))
return false;
CClipboard clipboard;
if (!clipboard.Open(NULL))
return false;
HGLOBAL h = ::GetClipboardData(CF_HDROP);
if (h != NULL)
{
NMemory::CGlobalLock globalLock(h);
void *p = (void *)globalLock.GetPointer();
if (p != NULL)
{
NShell::CDrop drop(false);
drop.Attach((HDROP)p);
drop.QueryFileNames(names);
return true;
}
}
return false;
}
*/
static bool ClipboardSetData(UINT uFormat, const void *data, size_t size) throw()
{
NMemory::CGlobal global;
if (!global.Alloc(GMEM_DDESHARE | GMEM_MOVEABLE, size))
return false;
{
NMemory::CGlobalLock globalLock(global);
LPVOID p = globalLock.GetPointer();
if (!p)
return false;
memcpy(p, data, size);
}
if (::SetClipboardData(uFormat, global) == NULL)
return false;
global.Detach();
return true;
}
bool ClipboardSetText(HWND owner, const UString &s)
{
CClipboard clipboard;
if (!clipboard.Open(owner))
return false;
if (!::EmptyClipboard())
return false;
bool res;
res = ClipboardSetData(CF_UNICODETEXT, (const wchar_t *)s, (s.Len() + 1) * sizeof(wchar_t));
#ifndef _UNICODE
AString a (UnicodeStringToMultiByte(s, CP_ACP));
if (ClipboardSetData(CF_TEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
res = true;
a = UnicodeStringToMultiByte(s, CP_OEMCP);
if (ClipboardSetData(CF_OEMTEXT, (const char *)a, (a.Len() + 1) * sizeof(char)))
res = true;
#endif
return res;
}
}

56
CPP/Windows/Clipboard.h
View File

@@ -1,28 +1,28 @@
// Windows/Clipboard.h
#ifndef __CLIPBOARD_H
#define __CLIPBOARD_H
#include "../Common/MyString.h"
namespace NWindows {
class CClipboard
{
bool m_Open;
public:
CClipboard(): m_Open(false) {};
~CClipboard() { Close(); }
bool Open(HWND wndNewOwner) throw();
bool Close() throw();
};
bool ClipboardIsFormatAvailableHDROP();
// bool ClipboardGetFileNames(UStringVector &names);
// bool ClipboardGetTextString(AString &s);
bool ClipboardSetText(HWND owner, const UString &s);
}
#endif
// Windows/Clipboard.h
#ifndef __CLIPBOARD_H
#define __CLIPBOARD_H
#include "../Common/MyString.h"
namespace NWindows {
class CClipboard
{
bool m_Open;
public:
CClipboard(): m_Open(false) {};
~CClipboard() { Close(); }
bool Open(HWND wndNewOwner) throw();
bool Close() throw();
};
bool ClipboardIsFormatAvailableHDROP();
// bool ClipboardGetFileNames(UStringVector &names);
// bool ClipboardGetTextString(AString &s);
bool ClipboardSetText(HWND owner, const UString &s);
}
#endif

370
CPP/Windows/CommonDialog.cpp
View File

@@ -1,185 +1,185 @@
// Windows/CommonDialog.cpp
#include "StdAfx.h"
#include "../Common/MyWindows.h"
#ifdef UNDER_CE
#include <commdlg.h>
#endif
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "CommonDialog.h"
#include "Defs.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
class CDoubleZeroStringListA
{
LPTSTR Buf;
unsigned Size;
public:
CDoubleZeroStringListA(LPSTR buf, unsigned size): Buf(buf), Size(size) {}
bool Add(LPCSTR s) throw();
void Finish() { *Buf = 0; }
};
bool CDoubleZeroStringListA::Add(LPCSTR s) throw()
{
unsigned len = MyStringLen(s) + 1;
if (len >= Size)
return false;
MyStringCopy(Buf, s);
Buf += len;
Size -= len;
return true;
}
#endif
class CDoubleZeroStringListW
{
LPWSTR Buf;
unsigned Size;
public:
CDoubleZeroStringListW(LPWSTR buf, unsigned size): Buf(buf), Size(size) {}
bool Add(LPCWSTR s) throw();
void Finish() { *Buf = 0; }
};
bool CDoubleZeroStringListW::Add(LPCWSTR s) throw()
{
unsigned len = MyStringLen(s) + 1;
if (len >= Size)
return false;
MyStringCopy(Buf, s);
Buf += len;
Size -= len;
return true;
}
#define MY__OFN_PROJECT 0x00400000
#define MY__OFN_SHOW_ALL 0x01000000
/* if (lpstrFilter == NULL && nFilterIndex == 0)
MSDN : "the system doesn't show any files",
but WinXP-64 shows all files. Why ??? */
/*
structures
OPENFILENAMEW
OPENFILENAMEA
contain additional members:
#if (_WIN32_WINNT >= 0x0500)
void *pvReserved;
DWORD dwReserved;
DWORD FlagsEx;
#endif
If we compile the source code with (_WIN32_WINNT >= 0x0500), some functions
will not work at NT 4.0, if we use sizeof(OPENFILENAME*).
So we use size of old version of structure. */
#if defined(UNDER_CE) || defined(_WIN64) || (_WIN32_WINNT < 0x0500)
// || !defined(WINVER)
#define my_compatib_OPENFILENAMEA_size sizeof(OPENFILENAMEA)
#define my_compatib_OPENFILENAMEW_size sizeof(OPENFILENAMEW)
#else
#define my_compatib_OPENFILENAMEA_size OPENFILENAME_SIZE_VERSION_400A
#define my_compatib_OPENFILENAMEW_size OPENFILENAME_SIZE_VERSION_400W
#endif
#define CONV_U_To_A(dest, src, temp) AString temp; if (src) { temp = GetSystemString(src); dest = temp; }
bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
LPCWSTR initialDir,
LPCWSTR filePath,
LPCWSTR filterDescription,
LPCWSTR filter,
UString &resPath
#ifdef UNDER_CE
, bool openFolder
#endif
)
{
const unsigned kBufSize = MAX_PATH * 2;
const unsigned kFilterBufSize = MAX_PATH;
if (!filter)
filter = L"*.*";
#ifndef _UNICODE
if (!g_IsNT)
{
CHAR buf[kBufSize];
MyStringCopy(buf, (const char *)GetSystemString(filePath));
// OPENFILENAME_NT4A
OPENFILENAMEA p;
memset(&p, 0, sizeof(p));
p.lStructSize = my_compatib_OPENFILENAMEA_size;
p.hwndOwner = hwnd;
CHAR filterBuf[kFilterBufSize];
{
CDoubleZeroStringListA dz(filterBuf, kFilterBufSize);
dz.Add(GetSystemString(filterDescription ? filterDescription : filter));
dz.Add(GetSystemString(filter));
dz.Finish();
p.lpstrFilter = filterBuf;
p.nFilterIndex = 1;
}
p.lpstrFile = buf;
p.nMaxFile = kBufSize;
CONV_U_To_A(p.lpstrInitialDir, initialDir, initialDirA);
CONV_U_To_A(p.lpstrTitle, title, titleA);
p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY;
bool res = BOOLToBool(::GetOpenFileNameA(&p));
resPath = GetUnicodeString(buf);
return res;
}
else
#endif
{
WCHAR buf[kBufSize];
MyStringCopy(buf, filePath);
// OPENFILENAME_NT4W
OPENFILENAMEW p;
memset(&p, 0, sizeof(p));
p.lStructSize = my_compatib_OPENFILENAMEW_size;
p.hwndOwner = hwnd;
WCHAR filterBuf[kFilterBufSize];
{
CDoubleZeroStringListW dz(filterBuf, kFilterBufSize);
dz.Add(filterDescription ? filterDescription : filter);
dz.Add(filter);
dz.Finish();
p.lpstrFilter = filterBuf;
p.nFilterIndex = 1;
}
p.lpstrFile = buf;
p.nMaxFile = kBufSize;
p.lpstrInitialDir = initialDir;
p.lpstrTitle = title;
p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
#ifdef UNDER_CE
| (openFolder ? (MY__OFN_PROJECT | MY__OFN_SHOW_ALL) : 0)
#endif
;
bool res = BOOLToBool(::GetOpenFileNameW(&p));
resPath = buf;
return res;
}
}
}
// Windows/CommonDialog.cpp
#include "StdAfx.h"
#include "../Common/MyWindows.h"
#ifdef UNDER_CE
#include <commdlg.h>
#endif
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "CommonDialog.h"
#include "Defs.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
class CDoubleZeroStringListA
{
LPTSTR Buf;
unsigned Size;
public:
CDoubleZeroStringListA(LPSTR buf, unsigned size): Buf(buf), Size(size) {}
bool Add(LPCSTR s) throw();
void Finish() { *Buf = 0; }
};
bool CDoubleZeroStringListA::Add(LPCSTR s) throw()
{
unsigned len = MyStringLen(s) + 1;
if (len >= Size)
return false;
MyStringCopy(Buf, s);
Buf += len;
Size -= len;
return true;
}
#endif
class CDoubleZeroStringListW
{
LPWSTR Buf;
unsigned Size;
public:
CDoubleZeroStringListW(LPWSTR buf, unsigned size): Buf(buf), Size(size) {}
bool Add(LPCWSTR s) throw();
void Finish() { *Buf = 0; }
};
bool CDoubleZeroStringListW::Add(LPCWSTR s) throw()
{
unsigned len = MyStringLen(s) + 1;
if (len >= Size)
return false;
MyStringCopy(Buf, s);
Buf += len;
Size -= len;
return true;
}
#define MY__OFN_PROJECT 0x00400000
#define MY__OFN_SHOW_ALL 0x01000000
/* if (lpstrFilter == NULL && nFilterIndex == 0)
MSDN : "the system doesn't show any files",
but WinXP-64 shows all files. Why ??? */
/*
structures
OPENFILENAMEW
OPENFILENAMEA
contain additional members:
#if (_WIN32_WINNT >= 0x0500)
void *pvReserved;
DWORD dwReserved;
DWORD FlagsEx;
#endif
If we compile the source code with (_WIN32_WINNT >= 0x0500), some functions
will not work at NT 4.0, if we use sizeof(OPENFILENAME*).
So we use size of old version of structure. */
#if defined(UNDER_CE) || defined(_WIN64) || (_WIN32_WINNT < 0x0500)
// || !defined(WINVER)
#define my_compatib_OPENFILENAMEA_size sizeof(OPENFILENAMEA)
#define my_compatib_OPENFILENAMEW_size sizeof(OPENFILENAMEW)
#else
#define my_compatib_OPENFILENAMEA_size OPENFILENAME_SIZE_VERSION_400A
#define my_compatib_OPENFILENAMEW_size OPENFILENAME_SIZE_VERSION_400W
#endif
#define CONV_U_To_A(dest, src, temp) AString temp; if (src) { temp = GetSystemString(src); dest = temp; }
bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
LPCWSTR initialDir,
LPCWSTR filePath,
LPCWSTR filterDescription,
LPCWSTR filter,
UString &resPath
#ifdef UNDER_CE
, bool openFolder
#endif
)
{
const unsigned kBufSize = MAX_PATH * 2;
const unsigned kFilterBufSize = MAX_PATH;
if (!filter)
filter = L"*.*";
#ifndef _UNICODE
if (!g_IsNT)
{
CHAR buf[kBufSize];
MyStringCopy(buf, (const char *)GetSystemString(filePath));
// OPENFILENAME_NT4A
OPENFILENAMEA p;
memset(&p, 0, sizeof(p));
p.lStructSize = my_compatib_OPENFILENAMEA_size;
p.hwndOwner = hwnd;
CHAR filterBuf[kFilterBufSize];
{
CDoubleZeroStringListA dz(filterBuf, kFilterBufSize);
dz.Add(GetSystemString(filterDescription ? filterDescription : filter));
dz.Add(GetSystemString(filter));
dz.Finish();
p.lpstrFilter = filterBuf;
p.nFilterIndex = 1;
}
p.lpstrFile = buf;
p.nMaxFile = kBufSize;
CONV_U_To_A(p.lpstrInitialDir, initialDir, initialDirA);
CONV_U_To_A(p.lpstrTitle, title, titleA);
p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY;
bool res = BOOLToBool(::GetOpenFileNameA(&p));
resPath = GetUnicodeString(buf);
return res;
}
else
#endif
{
WCHAR buf[kBufSize];
MyStringCopy(buf, filePath);
// OPENFILENAME_NT4W
OPENFILENAMEW p;
memset(&p, 0, sizeof(p));
p.lStructSize = my_compatib_OPENFILENAMEW_size;
p.hwndOwner = hwnd;
WCHAR filterBuf[kFilterBufSize];
{
CDoubleZeroStringListW dz(filterBuf, kFilterBufSize);
dz.Add(filterDescription ? filterDescription : filter);
dz.Add(filter);
dz.Finish();
p.lpstrFilter = filterBuf;
p.nFilterIndex = 1;
}
p.lpstrFile = buf;
p.nMaxFile = kBufSize;
p.lpstrInitialDir = initialDir;
p.lpstrTitle = title;
p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
#ifdef UNDER_CE
| (openFolder ? (MY__OFN_PROJECT | MY__OFN_SHOW_ALL) : 0)
#endif
;
bool res = BOOLToBool(::GetOpenFileNameW(&p));
resPath = buf;
return res;
}
}
}

46
CPP/Windows/CommonDialog.h
View File

@@ -1,23 +1,23 @@
// Windows/CommonDialog.h
#ifndef __WINDOWS_COMMON_DIALOG_H
#define __WINDOWS_COMMON_DIALOG_H
#include "../Common/MyString.h"
namespace NWindows {
bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
LPCWSTR initialDir, // can be NULL, so dir prefix in filePath will be used
LPCWSTR filePath, // full path
LPCWSTR filterDescription, // like "All files (*.*)"
LPCWSTR filter, // like "*.exe"
UString &resPath
#ifdef UNDER_CE
, bool openFolder = false
#endif
);
}
#endif
// Windows/CommonDialog.h
#ifndef __WINDOWS_COMMON_DIALOG_H
#define __WINDOWS_COMMON_DIALOG_H
#include "../Common/MyString.h"
namespace NWindows {
bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
LPCWSTR initialDir, // can be NULL, so dir prefix in filePath will be used
LPCWSTR filePath, // full path
LPCWSTR filterDescription, // like "All files (*.*)"
LPCWSTR filter, // like "*.exe"
UString &resPath
#ifdef UNDER_CE
, bool openFolder = false
#endif
);
}
#endif

20
CPP/Windows/Console.cpp
View File

@@ -1,10 +1,10 @@
// Windows/Console.cpp
#include "StdAfx.h"
#include "Console.h"
namespace NWindows{
namespace NConsole{
}}
// Windows/Console.cpp
#include "StdAfx.h"
#include "Console.h"
namespace NWindows{
namespace NConsole{
}}

104
CPP/Windows/Console.h
View File

@@ -1,52 +1,52 @@
// Windows/Console.h
#ifndef __WINDOWS_CONSOLE_H
#define __WINDOWS_CONSOLE_H
#include "Defs.h"
namespace NWindows {
namespace NConsole {
class CBase
{
protected:
HANDLE m_Object;
public:
void Attach(HANDLE handle) { m_Object = handle; }
bool GetMode(DWORD &mode)
{ return BOOLToBool(::GetConsoleMode(m_Object, &mode)); }
bool SetMode(DWORD mode)
{ return BOOLToBool(::SetConsoleMode(m_Object, mode)); }
};
class CIn: public CBase
{
public:
bool PeekEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
{ return BOOLToBool(::PeekConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
bool PeekEvent(INPUT_RECORD &event, DWORD &numEventsRead)
{ return PeekEvents(&event, 1, numEventsRead); }
bool ReadEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
{ return BOOLToBool(::ReadConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
bool ReadEvent(INPUT_RECORD &event, DWORD &numEventsRead)
{ return ReadEvents(&event, 1, numEventsRead); }
bool GetNumberOfEvents(DWORD &numEvents)
{ return BOOLToBool(::GetNumberOfConsoleInputEvents(m_Object, &numEvents)); }
bool WriteEvents(const INPUT_RECORD *events, DWORD numEvents, DWORD &numEventsWritten)
{ return BOOLToBool(::WriteConsoleInput(m_Object, events, numEvents, &numEventsWritten)); }
bool WriteEvent(const INPUT_RECORD &event, DWORD &numEventsWritten)
{ return WriteEvents(&event, 1, numEventsWritten); }
bool Read(LPVOID buffer, DWORD numChars, DWORD &numCharsRead)
{ return BOOLToBool(::ReadConsole(m_Object, buffer, numChars, &numCharsRead, NULL)); }
bool Flush()
{ return BOOLToBool(::FlushConsoleInputBuffer(m_Object)); }
};
}}
#endif
// Windows/Console.h
#ifndef __WINDOWS_CONSOLE_H
#define __WINDOWS_CONSOLE_H
#include "Defs.h"
namespace NWindows {
namespace NConsole {
class CBase
{
protected:
HANDLE m_Object;
public:
void Attach(HANDLE handle) { m_Object = handle; }
bool GetMode(DWORD &mode)
{ return BOOLToBool(::GetConsoleMode(m_Object, &mode)); }
bool SetMode(DWORD mode)
{ return BOOLToBool(::SetConsoleMode(m_Object, mode)); }
};
class CIn: public CBase
{
public:
bool PeekEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
{ return BOOLToBool(::PeekConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
bool PeekEvent(INPUT_RECORD &event, DWORD &numEventsRead)
{ return PeekEvents(&event, 1, numEventsRead); }
bool ReadEvents(PINPUT_RECORD events, DWORD numEvents, DWORD &numEventsRead)
{ return BOOLToBool(::ReadConsoleInput(m_Object, events, numEvents, &numEventsRead)); }
bool ReadEvent(INPUT_RECORD &event, DWORD &numEventsRead)
{ return ReadEvents(&event, 1, numEventsRead); }
bool GetNumberOfEvents(DWORD &numEvents)
{ return BOOLToBool(::GetNumberOfConsoleInputEvents(m_Object, &numEvents)); }
bool WriteEvents(const INPUT_RECORD *events, DWORD numEvents, DWORD &numEventsWritten)
{ return BOOLToBool(::WriteConsoleInput(m_Object, events, numEvents, &numEventsWritten)); }
bool WriteEvent(const INPUT_RECORD &event, DWORD &numEventsWritten)
{ return WriteEvents(&event, 1, numEventsWritten); }
bool Read(LPVOID buffer, DWORD numChars, DWORD &numCharsRead)
{ return BOOLToBool(::ReadConsole(m_Object, buffer, numChars, &numCharsRead, NULL)); }
bool Flush()
{ return BOOLToBool(::FlushConsoleInputBuffer(m_Object)); }
};
}}
#endif

132
CPP/Windows/Control/ComboBox.cpp
View File

@@ -1,66 +1,66 @@
// Windows/Control/ComboBox.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "ComboBox.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
LRESULT CComboBox::GetLBText(int index, CSysString &s)
{
s.Empty();
LRESULT len = GetLBTextLen(index); // length, excluding the terminating null character
if (len == CB_ERR)
return len;
LRESULT len2 = GetLBText(index, s.GetBuf((unsigned)len));
if (len2 == CB_ERR)
return len;
if (len > len2)
len = len2;
s.ReleaseBuf_CalcLen((unsigned)len);
return len;
}
#ifndef _UNICODE
LRESULT CComboBox::AddString(LPCWSTR s)
{
if (g_IsNT)
return SendMsgW(CB_ADDSTRING, 0, (LPARAM)s);
return AddString(GetSystemString(s));
}
LRESULT CComboBox::GetLBText(int index, UString &s)
{
s.Empty();
if (g_IsNT)
{
LRESULT len = SendMsgW(CB_GETLBTEXTLEN, index, 0);
if (len == CB_ERR)
return len;
LRESULT len2 = SendMsgW(CB_GETLBTEXT, index, (LPARAM)s.GetBuf((unsigned)len));
if (len2 == CB_ERR)
return len;
if (len > len2)
len = len2;
s.ReleaseBuf_CalcLen((unsigned)len);
return len;
}
AString sa;
LRESULT len = GetLBText(index, sa);
if (len == CB_ERR)
return len;
s = GetUnicodeString(sa);
return s.Len();
}
#endif
}}
// Windows/Control/ComboBox.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "ComboBox.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
LRESULT CComboBox::GetLBText(int index, CSysString &s)
{
s.Empty();
LRESULT len = GetLBTextLen(index); // length, excluding the terminating null character
if (len == CB_ERR)
return len;
LRESULT len2 = GetLBText(index, s.GetBuf((unsigned)len));
if (len2 == CB_ERR)
return len;
if (len > len2)
len = len2;
s.ReleaseBuf_CalcLen((unsigned)len);
return len;
}
#ifndef _UNICODE
LRESULT CComboBox::AddString(LPCWSTR s)
{
if (g_IsNT)
return SendMsgW(CB_ADDSTRING, 0, (LPARAM)s);
return AddString(GetSystemString(s));
}
LRESULT CComboBox::GetLBText(int index, UString &s)
{
s.Empty();
if (g_IsNT)
{
LRESULT len = SendMsgW(CB_GETLBTEXTLEN, index, 0);
if (len == CB_ERR)
return len;
LRESULT len2 = SendMsgW(CB_GETLBTEXT, index, (LPARAM)s.GetBuf((unsigned)len));
if (len2 == CB_ERR)
return len;
if (len > len2)
len = len2;
s.ReleaseBuf_CalcLen((unsigned)len);
return len;
}
AString sa;
LRESULT len = GetLBText(index, sa);
if (len == CB_ERR)
return len;
s = GetUnicodeString(sa);
return s.Len();
}
#endif
}}

130
CPP/Windows/Control/ComboBox.h
View File

@@ -1,65 +1,65 @@
// Windows/Control/ComboBox.h
#ifndef __WINDOWS_CONTROL_COMBOBOX_H
#define __WINDOWS_CONTROL_COMBOBOX_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CComboBox: public CWindow
{
public:
void ResetContent() { SendMsg(CB_RESETCONTENT, 0, 0); }
LRESULT AddString(LPCTSTR s) { return SendMsg(CB_ADDSTRING, 0, (LPARAM)s); }
#ifndef _UNICODE
LRESULT AddString(LPCWSTR s);
#endif
LRESULT SetCurSel(int index) { return SendMsg(CB_SETCURSEL, index, 0); }
int GetCurSel() { return (int)SendMsg(CB_GETCURSEL, 0, 0); }
int GetCount() { return (int)SendMsg(CB_GETCOUNT, 0, 0); }
LRESULT GetLBTextLen(int index) { return SendMsg(CB_GETLBTEXTLEN, index, 0); }
LRESULT GetLBText(int index, LPTSTR s) { return SendMsg(CB_GETLBTEXT, index, (LPARAM)s); }
LRESULT GetLBText(int index, CSysString &s);
#ifndef _UNICODE
LRESULT GetLBText(int index, UString &s);
#endif
LRESULT SetItemData(int index, LPARAM lParam) { return SendMsg(CB_SETITEMDATA, index, lParam); }
LRESULT GetItemData(int index) { return SendMsg(CB_GETITEMDATA, index, 0); }
LRESULT GetItemData_of_CurSel() { return GetItemData(GetCurSel()); }
void ShowDropDown(bool show = true) { SendMsg(CB_SHOWDROPDOWN, show ? TRUE : FALSE, 0); }
};
#ifndef UNDER_CE
class CComboBoxEx: public CComboBox
{
public:
bool SetUnicodeFormat(bool fUnicode) { return LRESULTToBool(SendMsg(CBEM_SETUNICODEFORMAT, BOOLToBool(fUnicode), 0)); }
LRESULT DeleteItem(int index) { return SendMsg(CBEM_DELETEITEM, index, 0); }
LRESULT InsertItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_INSERTITEM, 0, (LPARAM)item); }
#ifndef _UNICODE
LRESULT InsertItem(COMBOBOXEXITEMW *item) { return SendMsg(CBEM_INSERTITEMW, 0, (LPARAM)item); }
#endif
LRESULT SetItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_SETITEM, 0, (LPARAM)item); }
DWORD SetExtendedStyle(DWORD exMask, DWORD exStyle) { return (DWORD)SendMsg(CBEM_SETEXTENDEDSTYLE, exMask, exStyle); }
HWND GetEditControl() { return (HWND)SendMsg(CBEM_GETEDITCONTROL, 0, 0); }
HIMAGELIST SetImageList(HIMAGELIST imageList) { return (HIMAGELIST)SendMsg(CBEM_SETIMAGELIST, 0, (LPARAM)imageList); }
};
#endif
}}
#endif
// Windows/Control/ComboBox.h
#ifndef __WINDOWS_CONTROL_COMBOBOX_H
#define __WINDOWS_CONTROL_COMBOBOX_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CComboBox: public CWindow
{
public:
void ResetContent() { SendMsg(CB_RESETCONTENT, 0, 0); }
LRESULT AddString(LPCTSTR s) { return SendMsg(CB_ADDSTRING, 0, (LPARAM)s); }
#ifndef _UNICODE
LRESULT AddString(LPCWSTR s);
#endif
LRESULT SetCurSel(int index) { return SendMsg(CB_SETCURSEL, index, 0); }
int GetCurSel() { return (int)SendMsg(CB_GETCURSEL, 0, 0); }
int GetCount() { return (int)SendMsg(CB_GETCOUNT, 0, 0); }
LRESULT GetLBTextLen(int index) { return SendMsg(CB_GETLBTEXTLEN, index, 0); }
LRESULT GetLBText(int index, LPTSTR s) { return SendMsg(CB_GETLBTEXT, index, (LPARAM)s); }
LRESULT GetLBText(int index, CSysString &s);
#ifndef _UNICODE
LRESULT GetLBText(int index, UString &s);
#endif
LRESULT SetItemData(int index, LPARAM lParam) { return SendMsg(CB_SETITEMDATA, index, lParam); }
LRESULT GetItemData(int index) { return SendMsg(CB_GETITEMDATA, index, 0); }
LRESULT GetItemData_of_CurSel() { return GetItemData(GetCurSel()); }
void ShowDropDown(bool show = true) { SendMsg(CB_SHOWDROPDOWN, show ? TRUE : FALSE, 0); }
};
#ifndef UNDER_CE
class CComboBoxEx: public CComboBox
{
public:
bool SetUnicodeFormat(bool fUnicode) { return LRESULTToBool(SendMsg(CBEM_SETUNICODEFORMAT, BOOLToBool(fUnicode), 0)); }
LRESULT DeleteItem(int index) { return SendMsg(CBEM_DELETEITEM, index, 0); }
LRESULT InsertItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_INSERTITEM, 0, (LPARAM)item); }
#ifndef _UNICODE
LRESULT InsertItem(COMBOBOXEXITEMW *item) { return SendMsg(CBEM_INSERTITEMW, 0, (LPARAM)item); }
#endif
LRESULT SetItem(COMBOBOXEXITEM *item) { return SendMsg(CBEM_SETITEM, 0, (LPARAM)item); }
DWORD SetExtendedStyle(DWORD exMask, DWORD exStyle) { return (DWORD)SendMsg(CBEM_SETEXTENDEDSTYLE, exMask, exStyle); }
HWND GetEditControl() { return (HWND)SendMsg(CBEM_GETEDITCONTROL, 0, 0); }
HIMAGELIST SetImageList(HIMAGELIST imageList) { return (HIMAGELIST)SendMsg(CBEM_SETIMAGELIST, 0, (LPARAM)imageList); }
};
#endif
}}
#endif

104
CPP/Windows/Control/CommandBar.h
View File

@@ -1,52 +1,52 @@
// Windows/Control/CommandBar.h
#ifndef __WINDOWS_CONTROL_COMMANDBAR_H
#define __WINDOWS_CONTROL_COMMANDBAR_H
#ifdef UNDER_CE
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CCommandBar: public NWindows::CWindow
{
public:
bool Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar)
{
_window = ::CommandBar_Create(hInst, hwndParent, idCmdBar);
return (_window != NULL);
}
// Macros
// void Destroy() { CommandBar_Destroy(_window); }
// bool AddButtons(UINT numButtons, LPTBBUTTON buttons) { return BOOLToBool(SendMsg(TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)buttons)); }
bool InsertButton(int iButton, LPTBBUTTON button) { return BOOLToBool(SendMsg(TB_INSERTBUTTON, (WPARAM)iButton, (LPARAM)button)); }
BOOL AddToolTips(UINT numToolTips, LPTSTR toolTips) { return BOOLToBool(SendMsg(TB_SETTOOLTIPS, (WPARAM)numToolTips, (LPARAM)toolTips)); }
void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
bool AddAdornments(DWORD dwFlags) { return BOOLToBool(::CommandBar_AddAdornments(_window, dwFlags, 0)); }
int AddBitmap(HINSTANCE hInst, int idBitmap, int iNumImages, int iImageWidth, int iImageHeight) { return ::CommandBar_AddBitmap(_window, hInst, idBitmap, iNumImages, iImageWidth, iImageHeight); }
bool DrawMenuBar(WORD iButton) { return BOOLToBool(::CommandBar_DrawMenuBar(_window, iButton)); }
HMENU GetMenu(WORD iButton) { return ::CommandBar_GetMenu(_window, iButton); }
int Height() { return CommandBar_Height(_window); }
HWND InsertComboBox(HINSTANCE hInst, int iWidth, UINT dwStyle, WORD idComboBox, WORD iButton) { return ::CommandBar_InsertComboBox(_window, hInst, iWidth, dwStyle, idComboBox, iButton); }
bool InsertMenubar(HINSTANCE hInst, WORD idMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubar(_window, hInst, idMenu, iButton)); }
bool InsertMenubarEx(HINSTANCE hInst, LPTSTR pszMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubarEx(_window, hInst, pszMenu, iButton)); }
bool Show(bool cmdShow) { return BOOLToBool(::CommandBar_Show(_window, BoolToBOOL(cmdShow))); }
// CE 4.0
void AlignAdornments() { CommandBar_AlignAdornments(_window); }
};
}}
#endif
#endif
// Windows/Control/CommandBar.h
#ifndef __WINDOWS_CONTROL_COMMANDBAR_H
#define __WINDOWS_CONTROL_COMMANDBAR_H
#ifdef UNDER_CE
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CCommandBar: public NWindows::CWindow
{
public:
bool Create(HINSTANCE hInst, HWND hwndParent, int idCmdBar)
{
_window = ::CommandBar_Create(hInst, hwndParent, idCmdBar);
return (_window != NULL);
}
// Macros
// void Destroy() { CommandBar_Destroy(_window); }
// bool AddButtons(UINT numButtons, LPTBBUTTON buttons) { return BOOLToBool(SendMsg(TB_ADDBUTTONS, (WPARAM)numButtons, (LPARAM)buttons)); }
bool InsertButton(int iButton, LPTBBUTTON button) { return BOOLToBool(SendMsg(TB_INSERTBUTTON, (WPARAM)iButton, (LPARAM)button)); }
BOOL AddToolTips(UINT numToolTips, LPTSTR toolTips) { return BOOLToBool(SendMsg(TB_SETTOOLTIPS, (WPARAM)numToolTips, (LPARAM)toolTips)); }
void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
bool AddAdornments(DWORD dwFlags) { return BOOLToBool(::CommandBar_AddAdornments(_window, dwFlags, 0)); }
int AddBitmap(HINSTANCE hInst, int idBitmap, int iNumImages, int iImageWidth, int iImageHeight) { return ::CommandBar_AddBitmap(_window, hInst, idBitmap, iNumImages, iImageWidth, iImageHeight); }
bool DrawMenuBar(WORD iButton) { return BOOLToBool(::CommandBar_DrawMenuBar(_window, iButton)); }
HMENU GetMenu(WORD iButton) { return ::CommandBar_GetMenu(_window, iButton); }
int Height() { return CommandBar_Height(_window); }
HWND InsertComboBox(HINSTANCE hInst, int iWidth, UINT dwStyle, WORD idComboBox, WORD iButton) { return ::CommandBar_InsertComboBox(_window, hInst, iWidth, dwStyle, idComboBox, iButton); }
bool InsertMenubar(HINSTANCE hInst, WORD idMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubar(_window, hInst, idMenu, iButton)); }
bool InsertMenubarEx(HINSTANCE hInst, LPTSTR pszMenu, WORD iButton) { return BOOLToBool(::CommandBar_InsertMenubarEx(_window, hInst, pszMenu, iButton)); }
bool Show(bool cmdShow) { return BOOLToBool(::CommandBar_Show(_window, BoolToBOOL(cmdShow))); }
// CE 4.0
void AlignAdornments() { CommandBar_AlignAdornments(_window); }
};
}}
#endif
#endif

502
CPP/Windows/Control/Dialog.cpp
View File

@@ -1,251 +1,251 @@
// Windows/Control/Dialog.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "Dialog.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
static INT_PTR APIENTRY DialogProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempDialog(dialogHWND);
if (message == WM_INITDIALOG)
tempDialog.SetUserDataLongPtr(lParam);
CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
if (dialog == NULL)
return FALSE;
if (message == WM_INITDIALOG)
dialog->Attach(dialogHWND);
try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
catch(...) { return TRUE; }
}
bool CDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG: return OnInit();
case WM_COMMAND: return OnCommand(wParam, lParam);
case WM_NOTIFY: return OnNotify((UINT)wParam, (LPNMHDR) lParam);
case WM_TIMER: return OnTimer(wParam, lParam);
case WM_SIZE: return OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
case WM_HELP: OnHelp(); return true;
/*
OnHelp(
#ifdef UNDER_CE
(void *)
#else
(LPHELPINFO)
#endif
lParam);
return true;
*/
default: return false;
}
}
bool CDialog::OnCommand(WPARAM wParam, LPARAM lParam)
{
return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
}
bool CDialog::OnCommand(int code, int itemID, LPARAM lParam)
{
if (code == BN_CLICKED)
return OnButtonClicked(itemID, (HWND)lParam);
return false;
}
bool CDialog::OnButtonClicked(int buttonID, HWND /* buttonHWND */)
{
switch (buttonID)
{
case IDOK: OnOK(); break;
case IDCANCEL: OnCancel(); break;
case IDCLOSE: OnClose(); break;
case IDHELP: OnHelp(); break;
default: return false;
}
return true;
}
static bool GetWorkAreaRect(RECT *rect)
{
// use another function for multi-monitor.
return BOOLToBool(::SystemParametersInfo(SPI_GETWORKAREA, 0, rect, 0));
}
bool IsDialogSizeOK(int xSize, int ySize)
{
// it returns for system font. Real font uses another values
LONG v = GetDialogBaseUnits();
int x = LOWORD(v);
int y = HIWORD(v);
RECT rect;
GetWorkAreaRect(&rect);
int wx = RECT_SIZE_X(rect);
int wy = RECT_SIZE_Y(rect);
return
xSize / 4 * x <= wx &&
ySize / 8 * y <= wy;
}
bool CDialog::GetMargins(int margin, int &x, int &y)
{
x = margin;
y = margin;
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = margin;
rect.bottom = margin;
if (!MapRect(&rect))
return false;
x = rect.right - rect.left;
y = rect.bottom - rect.top;
return true;
}
int CDialog::Units_To_Pixels_X(int units)
{
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = units;
rect.bottom = units;
if (!MapRect(&rect))
return units * 3 / 2;
return rect.right - rect.left;
}
bool CDialog::GetItemSizes(int id, int &x, int &y)
{
RECT rect;
if (!::GetWindowRect(GetItem(id), &rect))
return false;
x = RECT_SIZE_X(rect);
y = RECT_SIZE_Y(rect);
return true;
}
void CDialog::GetClientRectOfItem(int id, RECT &rect)
{
::GetWindowRect(GetItem(id), &rect);
ScreenToClient(&rect);
}
bool CDialog::MoveItem(int id, int x, int y, int width, int height, bool repaint)
{
return BOOLToBool(::MoveWindow(GetItem(id), x, y, width, height, BoolToBOOL(repaint)));
}
void CDialog::NormalizeSize(bool fullNormalize)
{
RECT workRect;
GetWorkAreaRect(&workRect);
int xSize = RECT_SIZE_X(workRect);
int ySize = RECT_SIZE_Y(workRect);
RECT rect;
GetWindowRect(&rect);
int xSize2 = RECT_SIZE_X(rect);
int ySize2 = RECT_SIZE_Y(rect);
bool needMove = (xSize2 > xSize || ySize2 > ySize);
if (xSize2 > xSize || (needMove && fullNormalize))
{
rect.left = workRect.left;
rect.right = workRect.right;
xSize2 = xSize;
}
if (ySize2 > ySize || (needMove && fullNormalize))
{
rect.top = workRect.top;
rect.bottom = workRect.bottom;
ySize2 = ySize;
}
if (needMove)
{
if (fullNormalize)
Show(SW_SHOWMAXIMIZED);
else
Move(rect.left, rect.top, xSize2, ySize2, true);
}
}
void CDialog::NormalizePosition()
{
RECT workRect, rect;
GetWorkAreaRect(&workRect);
GetWindowRect(&rect);
if (rect.bottom > workRect.bottom && rect.top > workRect.top)
Move(rect.left, workRect.top, RECT_SIZE_X(rect), RECT_SIZE_Y(rect), true);
}
bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
{
HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
if (aHWND == 0)
return false;
Attach(aHWND);
return true;
}
INT_PTR CModalDialog::Create(LPCTSTR templateName, HWND parentWindow)
{
return DialogBoxParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
}
#ifndef _UNICODE
bool CModelessDialog::Create(LPCWSTR templateName, HWND parentWindow)
{
HWND aHWND;
if (g_IsNT)
aHWND = CreateDialogParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
else
{
AString name;
LPCSTR templateNameA;
if (IS_INTRESOURCE(templateName))
templateNameA = (LPCSTR)templateName;
else
{
name = GetSystemString(templateName);
templateNameA = name;
}
aHWND = CreateDialogParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
}
if (aHWND == 0)
return false;
Attach(aHWND);
return true;
}
INT_PTR CModalDialog::Create(LPCWSTR templateName, HWND parentWindow)
{
if (g_IsNT)
return DialogBoxParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
AString name;
LPCSTR templateNameA;
if (IS_INTRESOURCE(templateName))
templateNameA = (LPCSTR)templateName;
else
{
name = GetSystemString(templateName);
templateNameA = name;
}
return DialogBoxParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
}
#endif
}}
// Windows/Control/Dialog.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "Dialog.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
static INT_PTR APIENTRY DialogProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempDialog(dialogHWND);
if (message == WM_INITDIALOG)
tempDialog.SetUserDataLongPtr(lParam);
CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
if (dialog == NULL)
return FALSE;
if (message == WM_INITDIALOG)
dialog->Attach(dialogHWND);
try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
catch(...) { return TRUE; }
}
bool CDialog::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG: return OnInit();
case WM_COMMAND: return OnCommand(wParam, lParam);
case WM_NOTIFY: return OnNotify((UINT)wParam, (LPNMHDR) lParam);
case WM_TIMER: return OnTimer(wParam, lParam);
case WM_SIZE: return OnSize(wParam, LOWORD(lParam), HIWORD(lParam));
case WM_HELP: OnHelp(); return true;
/*
OnHelp(
#ifdef UNDER_CE
(void *)
#else
(LPHELPINFO)
#endif
lParam);
return true;
*/
default: return false;
}
}
bool CDialog::OnCommand(WPARAM wParam, LPARAM lParam)
{
return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
}
bool CDialog::OnCommand(int code, int itemID, LPARAM lParam)
{
if (code == BN_CLICKED)
return OnButtonClicked(itemID, (HWND)lParam);
return false;
}
bool CDialog::OnButtonClicked(int buttonID, HWND /* buttonHWND */)
{
switch (buttonID)
{
case IDOK: OnOK(); break;
case IDCANCEL: OnCancel(); break;
case IDCLOSE: OnClose(); break;
case IDHELP: OnHelp(); break;
default: return false;
}
return true;
}
static bool GetWorkAreaRect(RECT *rect)
{
// use another function for multi-monitor.
return BOOLToBool(::SystemParametersInfo(SPI_GETWORKAREA, 0, rect, 0));
}
bool IsDialogSizeOK(int xSize, int ySize)
{
// it returns for system font. Real font uses another values
LONG v = GetDialogBaseUnits();
int x = LOWORD(v);
int y = HIWORD(v);
RECT rect;
GetWorkAreaRect(&rect);
int wx = RECT_SIZE_X(rect);
int wy = RECT_SIZE_Y(rect);
return
xSize / 4 * x <= wx &&
ySize / 8 * y <= wy;
}
bool CDialog::GetMargins(int margin, int &x, int &y)
{
x = margin;
y = margin;
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = margin;
rect.bottom = margin;
if (!MapRect(&rect))
return false;
x = rect.right - rect.left;
y = rect.bottom - rect.top;
return true;
}
int CDialog::Units_To_Pixels_X(int units)
{
RECT rect;
rect.left = 0;
rect.top = 0;
rect.right = units;
rect.bottom = units;
if (!MapRect(&rect))
return units * 3 / 2;
return rect.right - rect.left;
}
bool CDialog::GetItemSizes(int id, int &x, int &y)
{
RECT rect;
if (!::GetWindowRect(GetItem(id), &rect))
return false;
x = RECT_SIZE_X(rect);
y = RECT_SIZE_Y(rect);
return true;
}
void CDialog::GetClientRectOfItem(int id, RECT &rect)
{
::GetWindowRect(GetItem(id), &rect);
ScreenToClient(&rect);
}
bool CDialog::MoveItem(int id, int x, int y, int width, int height, bool repaint)
{
return BOOLToBool(::MoveWindow(GetItem(id), x, y, width, height, BoolToBOOL(repaint)));
}
void CDialog::NormalizeSize(bool fullNormalize)
{
RECT workRect;
GetWorkAreaRect(&workRect);
int xSize = RECT_SIZE_X(workRect);
int ySize = RECT_SIZE_Y(workRect);
RECT rect;
GetWindowRect(&rect);
int xSize2 = RECT_SIZE_X(rect);
int ySize2 = RECT_SIZE_Y(rect);
bool needMove = (xSize2 > xSize || ySize2 > ySize);
if (xSize2 > xSize || (needMove && fullNormalize))
{
rect.left = workRect.left;
rect.right = workRect.right;
xSize2 = xSize;
}
if (ySize2 > ySize || (needMove && fullNormalize))
{
rect.top = workRect.top;
rect.bottom = workRect.bottom;
ySize2 = ySize;
}
if (needMove)
{
if (fullNormalize)
Show(SW_SHOWMAXIMIZED);
else
Move(rect.left, rect.top, xSize2, ySize2, true);
}
}
void CDialog::NormalizePosition()
{
RECT workRect, rect;
GetWorkAreaRect(&workRect);
GetWindowRect(&rect);
if (rect.bottom > workRect.bottom && rect.top > workRect.top)
Move(rect.left, workRect.top, RECT_SIZE_X(rect), RECT_SIZE_Y(rect), true);
}
bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
{
HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
if (aHWND == 0)
return false;
Attach(aHWND);
return true;
}
INT_PTR CModalDialog::Create(LPCTSTR templateName, HWND parentWindow)
{
return DialogBoxParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
}
#ifndef _UNICODE
bool CModelessDialog::Create(LPCWSTR templateName, HWND parentWindow)
{
HWND aHWND;
if (g_IsNT)
aHWND = CreateDialogParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
else
{
AString name;
LPCSTR templateNameA;
if (IS_INTRESOURCE(templateName))
templateNameA = (LPCSTR)templateName;
else
{
name = GetSystemString(templateName);
templateNameA = name;
}
aHWND = CreateDialogParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
}
if (aHWND == 0)
return false;
Attach(aHWND);
return true;
}
INT_PTR CModalDialog::Create(LPCWSTR templateName, HWND parentWindow)
{
if (g_IsNT)
return DialogBoxParamW(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
AString name;
LPCSTR templateNameA;
if (IS_INTRESOURCE(templateName))
templateNameA = (LPCSTR)templateName;
else
{
name = GetSystemString(templateName);
templateNameA = name;
}
return DialogBoxParamA(g_hInstance, templateNameA, parentWindow, DialogProcedure, (LPARAM)this);
}
#endif
}}

340
CPP/Windows/Control/Dialog.h
View File

@@ -1,170 +1,170 @@
// Windows/Control/Dialog.h
#ifndef __WINDOWS_CONTROL_DIALOG_H
#define __WINDOWS_CONTROL_DIALOG_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CDialog: public CWindow
{
public:
CDialog(HWND wnd = NULL): CWindow(wnd){};
virtual ~CDialog() {};
HWND GetItem(int itemID) const
{ return GetDlgItem(_window, itemID); }
bool EnableItem(int itemID, bool enable) const
{ return BOOLToBool(::EnableWindow(GetItem(itemID), BoolToBOOL(enable))); }
bool ShowItem(int itemID, int cmdShow) const
{ return BOOLToBool(::ShowWindow(GetItem(itemID), cmdShow)); }
bool ShowItem_Bool(int itemID, bool show) const
{ return ShowItem(itemID, show ? SW_SHOW: SW_HIDE); }
bool HideItem(int itemID) const { return ShowItem(itemID, SW_HIDE); }
bool SetItemText(int itemID, LPCTSTR s)
{ return BOOLToBool(SetDlgItemText(_window, itemID, s)); }
#ifndef _UNICODE
bool SetItemText(int itemID, LPCWSTR s)
{
CWindow window(GetItem(itemID));
return window.SetText(s);
}
#endif
UINT GetItemText(int itemID, LPTSTR string, int maxCount)
{ return GetDlgItemText(_window, itemID, string, maxCount); }
#ifndef _UNICODE
/*
bool GetItemText(int itemID, LPWSTR string, int maxCount)
{
CWindow window(GetItem(itemID));
return window.GetText(string, maxCount);
}
*/
#endif
bool SetItemInt(int itemID, UINT value, bool isSigned)
{ return BOOLToBool(SetDlgItemInt(_window, itemID, value, BoolToBOOL(isSigned))); }
bool GetItemInt(int itemID, bool isSigned, UINT &value)
{
BOOL result;
value = GetDlgItemInt(_window, itemID, &result, BoolToBOOL(isSigned));
return BOOLToBool(result);
}
HWND GetNextGroupItem(HWND control, bool previous)
{ return GetNextDlgGroupItem(_window, control, BoolToBOOL(previous)); }
HWND GetNextTabItem(HWND control, bool previous)
{ return GetNextDlgTabItem(_window, control, BoolToBOOL(previous)); }
bool MapRect(LPRECT rect)
{ return BOOLToBool(MapDialogRect(_window, rect)); }
bool IsMessage(LPMSG message)
{ return BOOLToBool(IsDialogMessage(_window, message)); }
LRESULT SendItemMessage(int itemID, UINT message, WPARAM wParam, LPARAM lParam)
{ return SendDlgItemMessage(_window, itemID, message, wParam, lParam); }
bool CheckButton(int buttonID, UINT checkState)
{ return BOOLToBool(CheckDlgButton(_window, buttonID, checkState)); }
bool CheckButton(int buttonID, bool checkState)
{ return CheckButton(buttonID, UINT(checkState ? BST_CHECKED : BST_UNCHECKED)); }
UINT IsButtonChecked(int buttonID) const
{ return IsDlgButtonChecked(_window, buttonID); }
bool IsButtonCheckedBool(int buttonID) const
{ return (IsButtonChecked(buttonID) == BST_CHECKED); }
bool CheckRadioButton(int firstButtonID, int lastButtonID, int checkButtonID)
{ return BOOLToBool(::CheckRadioButton(_window, firstButtonID, lastButtonID, checkButtonID)); }
virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
virtual bool OnInit() { return true; }
virtual bool OnCommand(WPARAM wParam, LPARAM lParam);
virtual bool OnCommand(int code, int itemID, LPARAM lParam);
virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
/*
#ifdef UNDER_CE
virtual void OnHelp(void *) { OnHelp(); }
#else
virtual void OnHelp(LPHELPINFO) { OnHelp(); }
#endif
*/
virtual void OnHelp() {};
virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
virtual void OnOK() {};
virtual void OnCancel() {};
virtual void OnClose() {}
virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */) { return false; }
virtual bool OnTimer(WPARAM /* timerID */, LPARAM /* callback */) { return false; }
LONG_PTR SetMsgResult(LONG_PTR newLongPtr )
{ return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
LONG_PTR GetMsgResult() const
{ return GetLongPtr(DWLP_MSGRESULT); }
bool GetMargins(int margin, int &x, int &y);
int Units_To_Pixels_X(int units);
bool GetItemSizes(int id, int &x, int &y);
void GetClientRectOfItem(int id, RECT &rect);
bool MoveItem(int id, int x, int y, int width, int height, bool repaint = true);
void NormalizeSize(bool fullNormalize = false);
void NormalizePosition();
};
class CModelessDialog: public CDialog
{
public:
bool Create(LPCTSTR templateName, HWND parentWindow);
bool Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
#ifndef _UNICODE
bool Create(LPCWSTR templateName, HWND parentWindow);
#endif
virtual void OnOK() { Destroy(); }
virtual void OnCancel() { Destroy(); }
virtual void OnClose() { Destroy(); }
};
class CModalDialog: public CDialog
{
public:
INT_PTR Create(LPCTSTR templateName, HWND parentWindow);
INT_PTR Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
#ifndef _UNICODE
INT_PTR Create(LPCWSTR templateName, HWND parentWindow);
#endif
bool End(INT_PTR result) { return BOOLToBool(::EndDialog(_window, result)); }
virtual void OnOK() { End(IDOK); }
virtual void OnCancel() { End(IDCANCEL); }
virtual void OnClose() { End(IDCLOSE); }
};
class CDialogChildControl: public NWindows::CWindow
{
int m_ID;
public:
void Init(const NWindows::NControl::CDialog &parentDialog, int id)
{
m_ID = id;
Attach(parentDialog.GetItem(id));
}
};
bool IsDialogSizeOK(int xSize, int ySize);
}}
#endif
// Windows/Control/Dialog.h
#ifndef __WINDOWS_CONTROL_DIALOG_H
#define __WINDOWS_CONTROL_DIALOG_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CDialog: public CWindow
{
public:
CDialog(HWND wnd = NULL): CWindow(wnd){};
virtual ~CDialog() {};
HWND GetItem(int itemID) const
{ return GetDlgItem(_window, itemID); }
bool EnableItem(int itemID, bool enable) const
{ return BOOLToBool(::EnableWindow(GetItem(itemID), BoolToBOOL(enable))); }
bool ShowItem(int itemID, int cmdShow) const
{ return BOOLToBool(::ShowWindow(GetItem(itemID), cmdShow)); }
bool ShowItem_Bool(int itemID, bool show) const
{ return ShowItem(itemID, show ? SW_SHOW: SW_HIDE); }
bool HideItem(int itemID) const { return ShowItem(itemID, SW_HIDE); }
bool SetItemText(int itemID, LPCTSTR s)
{ return BOOLToBool(SetDlgItemText(_window, itemID, s)); }
#ifndef _UNICODE
bool SetItemText(int itemID, LPCWSTR s)
{
CWindow window(GetItem(itemID));
return window.SetText(s);
}
#endif
UINT GetItemText(int itemID, LPTSTR string, int maxCount)
{ return GetDlgItemText(_window, itemID, string, maxCount); }
#ifndef _UNICODE
/*
bool GetItemText(int itemID, LPWSTR string, int maxCount)
{
CWindow window(GetItem(itemID));
return window.GetText(string, maxCount);
}
*/
#endif
bool SetItemInt(int itemID, UINT value, bool isSigned)
{ return BOOLToBool(SetDlgItemInt(_window, itemID, value, BoolToBOOL(isSigned))); }
bool GetItemInt(int itemID, bool isSigned, UINT &value)
{
BOOL result;
value = GetDlgItemInt(_window, itemID, &result, BoolToBOOL(isSigned));
return BOOLToBool(result);
}
HWND GetNextGroupItem(HWND control, bool previous)
{ return GetNextDlgGroupItem(_window, control, BoolToBOOL(previous)); }
HWND GetNextTabItem(HWND control, bool previous)
{ return GetNextDlgTabItem(_window, control, BoolToBOOL(previous)); }
bool MapRect(LPRECT rect)
{ return BOOLToBool(MapDialogRect(_window, rect)); }
bool IsMessage(LPMSG message)
{ return BOOLToBool(IsDialogMessage(_window, message)); }
LRESULT SendItemMessage(int itemID, UINT message, WPARAM wParam, LPARAM lParam)
{ return SendDlgItemMessage(_window, itemID, message, wParam, lParam); }
bool CheckButton(int buttonID, UINT checkState)
{ return BOOLToBool(CheckDlgButton(_window, buttonID, checkState)); }
bool CheckButton(int buttonID, bool checkState)
{ return CheckButton(buttonID, UINT(checkState ? BST_CHECKED : BST_UNCHECKED)); }
UINT IsButtonChecked(int buttonID) const
{ return IsDlgButtonChecked(_window, buttonID); }
bool IsButtonCheckedBool(int buttonID) const
{ return (IsButtonChecked(buttonID) == BST_CHECKED); }
bool CheckRadioButton(int firstButtonID, int lastButtonID, int checkButtonID)
{ return BOOLToBool(::CheckRadioButton(_window, firstButtonID, lastButtonID, checkButtonID)); }
virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
virtual bool OnInit() { return true; }
virtual bool OnCommand(WPARAM wParam, LPARAM lParam);
virtual bool OnCommand(int code, int itemID, LPARAM lParam);
virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
/*
#ifdef UNDER_CE
virtual void OnHelp(void *) { OnHelp(); }
#else
virtual void OnHelp(LPHELPINFO) { OnHelp(); }
#endif
*/
virtual void OnHelp() {};
virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
virtual void OnOK() {};
virtual void OnCancel() {};
virtual void OnClose() {}
virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */) { return false; }
virtual bool OnTimer(WPARAM /* timerID */, LPARAM /* callback */) { return false; }
LONG_PTR SetMsgResult(LONG_PTR newLongPtr )
{ return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
LONG_PTR GetMsgResult() const
{ return GetLongPtr(DWLP_MSGRESULT); }
bool GetMargins(int margin, int &x, int &y);
int Units_To_Pixels_X(int units);
bool GetItemSizes(int id, int &x, int &y);
void GetClientRectOfItem(int id, RECT &rect);
bool MoveItem(int id, int x, int y, int width, int height, bool repaint = true);
void NormalizeSize(bool fullNormalize = false);
void NormalizePosition();
};
class CModelessDialog: public CDialog
{
public:
bool Create(LPCTSTR templateName, HWND parentWindow);
bool Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
#ifndef _UNICODE
bool Create(LPCWSTR templateName, HWND parentWindow);
#endif
virtual void OnOK() { Destroy(); }
virtual void OnCancel() { Destroy(); }
virtual void OnClose() { Destroy(); }
};
class CModalDialog: public CDialog
{
public:
INT_PTR Create(LPCTSTR templateName, HWND parentWindow);
INT_PTR Create(UINT resID, HWND parentWindow) { return Create(MAKEINTRESOURCEW(resID), parentWindow); }
#ifndef _UNICODE
INT_PTR Create(LPCWSTR templateName, HWND parentWindow);
#endif
bool End(INT_PTR result) { return BOOLToBool(::EndDialog(_window, result)); }
virtual void OnOK() { End(IDOK); }
virtual void OnCancel() { End(IDCANCEL); }
virtual void OnClose() { End(IDCLOSE); }
};
class CDialogChildControl: public NWindows::CWindow
{
int m_ID;
public:
void Init(const NWindows::NControl::CDialog &parentDialog, int id)
{
m_ID = id;
Attach(parentDialog.GetItem(id));
}
};
bool IsDialogSizeOK(int xSize, int ySize);
}}
#endif

38
CPP/Windows/Control/Edit.h
View File

@@ -1,19 +1,19 @@
// Windows/Control/Edit.h
#ifndef __WINDOWS_CONTROL_EDIT_H
#define __WINDOWS_CONTROL_EDIT_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CEdit: public CWindow
{
public:
void SetPasswordChar(WPARAM c) { SendMsg(EM_SETPASSWORDCHAR, c); }
};
}}
#endif
// Windows/Control/Edit.h
#ifndef __WINDOWS_CONTROL_EDIT_H
#define __WINDOWS_CONTROL_EDIT_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CEdit: public CWindow
{
public:
void SetPasswordChar(WPARAM c) { SendMsg(EM_SETPASSWORDCHAR, c); }
};
}}
#endif

20
CPP/Windows/Control/ImageList.cpp
View File

@@ -1,10 +1,10 @@
// Windows/Control/ImageList.cpp
#include "StdAfx.h"
#include "ImageList.h"
namespace NWindows {
namespace NControl {
}}
// Windows/Control/ImageList.cpp
#include "StdAfx.h"
#include "ImageList.h"
namespace NWindows {
namespace NControl {
}}

174
CPP/Windows/Control/ImageList.h
View File

@@ -1,87 +1,87 @@
// Windows/Control/ImageList.h
#ifndef __WINDOWS_CONTROL_IMAGE_LIST_H
#define __WINDOWS_CONTROL_IMAGE_LIST_H
#include <commctrl.h>
#include "../Defs.h"
namespace NWindows {
namespace NControl {
class CImageList
{
HIMAGELIST m_Object;
public:
operator HIMAGELIST() const {return m_Object; }
CImageList(): m_Object(NULL) {}
bool Attach(HIMAGELIST imageList)
{
if (imageList == NULL)
return false;
m_Object = imageList;
return true;
}
HIMAGELIST Detach()
{
HIMAGELIST imageList = m_Object;
m_Object = NULL;
return imageList;
}
bool Create(int width, int height, UINT flags, int initialNumber, int grow)
{
HIMAGELIST a = ImageList_Create(width, height, flags,
initialNumber, grow);
if (a == NULL)
return false;
return Attach(a);
}
bool Destroy() // DeleteImageList() in MFC
{
if (m_Object == NULL)
return false;
return BOOLToBool(ImageList_Destroy(Detach()));
}
~CImageList()
{ Destroy(); }
int GetImageCount() const
{ return ImageList_GetImageCount(m_Object); }
bool GetImageInfo(int index, IMAGEINFO* imageInfo) const
{ return BOOLToBool(ImageList_GetImageInfo(m_Object, index, imageInfo)); }
int Add(HBITMAP hbmImage, HBITMAP hbmMask = 0)
{ return ImageList_Add(m_Object, hbmImage, hbmMask); }
int AddMasked(HBITMAP hbmImage, COLORREF mask)
{ return ImageList_AddMasked(m_Object, hbmImage, mask); }
int AddIcon(HICON icon)
{ return ImageList_AddIcon(m_Object, icon); }
int Replace(int index, HICON icon)
{ return ImageList_ReplaceIcon(m_Object, index, icon); }
// If index is -1, the function removes all images.
bool Remove(int index)
{ return BOOLToBool(ImageList_Remove(m_Object, index)); }
bool RemoveAll()
{ return BOOLToBool(ImageList_RemoveAll(m_Object)); }
HICON ExtractIcon(int index)
{ return ImageList_ExtractIcon(NULL, m_Object, index); }
HICON GetIcon(int index, UINT flags)
{ return ImageList_GetIcon(m_Object, index, flags); }
bool GetIconSize(int &width, int &height) const
{ return BOOLToBool(ImageList_GetIconSize(m_Object, &width, &height)); }
bool SetIconSize(int width, int height)
{ return BOOLToBool(ImageList_SetIconSize(m_Object, width, height)); }
};
}}
#endif
// Windows/Control/ImageList.h
#ifndef __WINDOWS_CONTROL_IMAGE_LIST_H
#define __WINDOWS_CONTROL_IMAGE_LIST_H
#include <commctrl.h>
#include "../Defs.h"
namespace NWindows {
namespace NControl {
class CImageList
{
HIMAGELIST m_Object;
public:
operator HIMAGELIST() const {return m_Object; }
CImageList(): m_Object(NULL) {}
bool Attach(HIMAGELIST imageList)
{
if (imageList == NULL)
return false;
m_Object = imageList;
return true;
}
HIMAGELIST Detach()
{
HIMAGELIST imageList = m_Object;
m_Object = NULL;
return imageList;
}
bool Create(int width, int height, UINT flags, int initialNumber, int grow)
{
HIMAGELIST a = ImageList_Create(width, height, flags,
initialNumber, grow);
if (a == NULL)
return false;
return Attach(a);
}
bool Destroy() // DeleteImageList() in MFC
{
if (m_Object == NULL)
return false;
return BOOLToBool(ImageList_Destroy(Detach()));
}
~CImageList()
{ Destroy(); }
int GetImageCount() const
{ return ImageList_GetImageCount(m_Object); }
bool GetImageInfo(int index, IMAGEINFO* imageInfo) const
{ return BOOLToBool(ImageList_GetImageInfo(m_Object, index, imageInfo)); }
int Add(HBITMAP hbmImage, HBITMAP hbmMask = 0)
{ return ImageList_Add(m_Object, hbmImage, hbmMask); }
int AddMasked(HBITMAP hbmImage, COLORREF mask)
{ return ImageList_AddMasked(m_Object, hbmImage, mask); }
int AddIcon(HICON icon)
{ return ImageList_AddIcon(m_Object, icon); }
int Replace(int index, HICON icon)
{ return ImageList_ReplaceIcon(m_Object, index, icon); }
// If index is -1, the function removes all images.
bool Remove(int index)
{ return BOOLToBool(ImageList_Remove(m_Object, index)); }
bool RemoveAll()
{ return BOOLToBool(ImageList_RemoveAll(m_Object)); }
HICON ExtractIcon(int index)
{ return ImageList_ExtractIcon(NULL, m_Object, index); }
HICON GetIcon(int index, UINT flags)
{ return ImageList_GetIcon(m_Object, index, flags); }
bool GetIconSize(int &width, int &height) const
{ return BOOLToBool(ImageList_GetIconSize(m_Object, &width, &height)); }
bool SetIconSize(int width, int height)
{ return BOOLToBool(ImageList_SetIconSize(m_Object, width, height)); }
};
}}
#endif

310
CPP/Windows/Control/ListView.cpp
View File

@@ -1,155 +1,155 @@
// Windows/Control/ListView.cpp
#include "StdAfx.h"
#include "ListView.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
bool CListView::CreateEx(DWORD exStyle, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
return CWindow::CreateEx(exStyle, WC_LISTVIEW, TEXT(""), style, x, y, width,
height, parentWindow, idOrHMenu, instance, createParam);
}
bool CListView::GetItemParam(int index, LPARAM &param) const
{
LVITEM item;
item.iItem = index;
item.iSubItem = 0;
item.mask = LVIF_PARAM;
bool aResult = GetItem(&item);
param = item.lParam;
return aResult;
}
int CListView::InsertColumn(int columnIndex, LPCTSTR text, int width)
{
LVCOLUMN ci;
ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
ci.pszText = (LPTSTR)text;
ci.iSubItem = columnIndex;
ci.cx = width;
return InsertColumn(columnIndex, &ci);
}
int CListView::InsertItem(int index, LPCTSTR text)
{
LVITEM item;
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = index;
item.lParam = index;
item.pszText = (LPTSTR)text;
item.iSubItem = 0;
return InsertItem(&item);
}
int CListView::SetSubItem(int index, int subIndex, LPCTSTR text)
{
LVITEM item;
item.mask = LVIF_TEXT;
item.iItem = index;
item.pszText = (LPTSTR)text;
item.iSubItem = subIndex;
return SetItem(&item);
}
#ifndef _UNICODE
int CListView::InsertColumn(int columnIndex, LPCWSTR text, int width)
{
LVCOLUMNW ci;
ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
ci.pszText = (LPWSTR)text;
ci.iSubItem = columnIndex;
ci.cx = width;
return InsertColumn(columnIndex, &ci);
}
int CListView::InsertItem(int index, LPCWSTR text)
{
LVITEMW item;
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = index;
item.lParam = index;
item.pszText = (LPWSTR)text;
item.iSubItem = 0;
return InsertItem(&item);
}
int CListView::SetSubItem(int index, int subIndex, LPCWSTR text)
{
LVITEMW item;
item.mask = LVIF_TEXT;
item.iItem = index;
item.pszText = (LPWSTR)text;
item.iSubItem = subIndex;
return SetItem(&item);
}
#endif
static LRESULT APIENTRY ListViewSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow window(hwnd);
CListView2 *w = (CListView2 *)(window.GetUserDataLongPtr());
if (w == NULL)
return 0;
return w->OnMessage(message, wParam, lParam);
}
LRESULT CListView2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef _UNICODE
if (g_IsNT)
return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
else
#endif
return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
}
void CListView2::SetWindowProc()
{
SetUserDataLongPtr((LONG_PTR)this);
#ifndef _UNICODE
if (g_IsNT)
_origWindowProc = (WNDPROC)SetLongPtrW(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
else
#endif
_origWindowProc = (WNDPROC)SetLongPtr(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
}
/*
LRESULT CListView3::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT res = CListView2::OnMessage(message, wParam, lParam);
if (message == WM_GETDLGCODE)
{
// when user presses RETURN, windows sends default (first) button command to parent dialog.
// we disable this:
MSG *msg = (MSG *)lParam;
WPARAM key = wParam;
bool change = false;
if (msg)
{
if (msg->message == WM_KEYDOWN && msg->wParam == VK_RETURN)
change = true;
}
else if (wParam == VK_RETURN)
change = true;
if (change)
res |= DLGC_WANTALLKEYS;
}
return res;
}
*/
}}
// Windows/Control/ListView.cpp
#include "StdAfx.h"
#include "ListView.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
bool CListView::CreateEx(DWORD exStyle, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
return CWindow::CreateEx(exStyle, WC_LISTVIEW, TEXT(""), style, x, y, width,
height, parentWindow, idOrHMenu, instance, createParam);
}
bool CListView::GetItemParam(int index, LPARAM &param) const
{
LVITEM item;
item.iItem = index;
item.iSubItem = 0;
item.mask = LVIF_PARAM;
bool aResult = GetItem(&item);
param = item.lParam;
return aResult;
}
int CListView::InsertColumn(int columnIndex, LPCTSTR text, int width)
{
LVCOLUMN ci;
ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
ci.pszText = (LPTSTR)text;
ci.iSubItem = columnIndex;
ci.cx = width;
return InsertColumn(columnIndex, &ci);
}
int CListView::InsertItem(int index, LPCTSTR text)
{
LVITEM item;
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = index;
item.lParam = index;
item.pszText = (LPTSTR)text;
item.iSubItem = 0;
return InsertItem(&item);
}
int CListView::SetSubItem(int index, int subIndex, LPCTSTR text)
{
LVITEM item;
item.mask = LVIF_TEXT;
item.iItem = index;
item.pszText = (LPTSTR)text;
item.iSubItem = subIndex;
return SetItem(&item);
}
#ifndef _UNICODE
int CListView::InsertColumn(int columnIndex, LPCWSTR text, int width)
{
LVCOLUMNW ci;
ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
ci.pszText = (LPWSTR)text;
ci.iSubItem = columnIndex;
ci.cx = width;
return InsertColumn(columnIndex, &ci);
}
int CListView::InsertItem(int index, LPCWSTR text)
{
LVITEMW item;
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = index;
item.lParam = index;
item.pszText = (LPWSTR)text;
item.iSubItem = 0;
return InsertItem(&item);
}
int CListView::SetSubItem(int index, int subIndex, LPCWSTR text)
{
LVITEMW item;
item.mask = LVIF_TEXT;
item.iItem = index;
item.pszText = (LPWSTR)text;
item.iSubItem = subIndex;
return SetItem(&item);
}
#endif
static LRESULT APIENTRY ListViewSubclassProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow window(hwnd);
CListView2 *w = (CListView2 *)(window.GetUserDataLongPtr());
if (w == NULL)
return 0;
return w->OnMessage(message, wParam, lParam);
}
LRESULT CListView2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef _UNICODE
if (g_IsNT)
return CallWindowProcW(_origWindowProc, *this, message, wParam, lParam);
else
#endif
return CallWindowProc(_origWindowProc, *this, message, wParam, lParam);
}
void CListView2::SetWindowProc()
{
SetUserDataLongPtr((LONG_PTR)this);
#ifndef _UNICODE
if (g_IsNT)
_origWindowProc = (WNDPROC)SetLongPtrW(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
else
#endif
_origWindowProc = (WNDPROC)SetLongPtr(GWLP_WNDPROC, (LONG_PTR)ListViewSubclassProc);
}
/*
LRESULT CListView3::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT res = CListView2::OnMessage(message, wParam, lParam);
if (message == WM_GETDLGCODE)
{
// when user presses RETURN, windows sends default (first) button command to parent dialog.
// we disable this:
MSG *msg = (MSG *)lParam;
WPARAM key = wParam;
bool change = false;
if (msg)
{
if (msg->message == WM_KEYDOWN && msg->wParam == VK_RETURN)
change = true;
}
else if (wParam == VK_RETURN)
change = true;
if (change)
res |= DLGC_WANTALLKEYS;
}
return res;
}
*/
}}

292
CPP/Windows/Control/ListView.h
View File

@@ -1,146 +1,146 @@
// Windows/Control/ListView.h
#ifndef __WINDOWS_CONTROL_LISTVIEW_H
#define __WINDOWS_CONTROL_LISTVIEW_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CListView: public NWindows::CWindow
{
public:
bool CreateEx(DWORD exStyle, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
void SetUnicodeFormat()
{
#ifndef UNDER_CE
ListView_SetUnicodeFormat(_window, TRUE);
#endif
}
bool DeleteAllItems() { return BOOLToBool(ListView_DeleteAllItems(_window)); }
bool DeleteColumn(int columnIndex) { return BOOLToBool(ListView_DeleteColumn(_window, columnIndex)); }
int InsertColumn(int columnIndex, const LVCOLUMN *columnInfo) { return ListView_InsertColumn(_window, columnIndex, columnInfo); }
int InsertColumn(int columnIndex, LPCTSTR text, int width);
bool SetColumnOrderArray(int count, const int *columns) { return BOOLToBool(ListView_SetColumnOrderArray(_window, count, columns)); }
/*
int GetNumColumns()
{
HWND header = ListView_GetHeader(_window);
if (!header)
return -1;
return Header_GetItemCount(header);
}
*/
int InsertItem(const LVITEM* item) { return ListView_InsertItem(_window, item); }
int InsertItem(int index, LPCTSTR text);
bool SetItem(const LVITEM* item) { return BOOLToBool(ListView_SetItem(_window, item)); }
int SetSubItem(int index, int subIndex, LPCTSTR text);
#ifndef _UNICODE
int InsertColumn(int columnIndex, const LVCOLUMNW *columnInfo) { return (int)SendMsg(LVM_INSERTCOLUMNW, (WPARAM)columnIndex, (LPARAM)columnInfo); }
int InsertColumn(int columnIndex, LPCWSTR text, int width);
int InsertItem(const LV_ITEMW* item) { return (int)SendMsg(LVM_INSERTITEMW, 0, (LPARAM)item); }
int InsertItem(int index, LPCWSTR text);
bool SetItem(const LV_ITEMW* item) { return BOOLToBool((BOOL)SendMsg(LVM_SETITEMW, 0, (LPARAM)item)); }
int SetSubItem(int index, int subIndex, LPCWSTR text);
#endif
bool DeleteItem(int itemIndex) { return BOOLToBool(ListView_DeleteItem(_window, itemIndex)); }
UINT GetSelectedCount() const { return ListView_GetSelectedCount(_window); }
int GetItemCount() const { return ListView_GetItemCount(_window); }
INT GetSelectionMark() const { return ListView_GetSelectionMark(_window); }
void SetItemCount(int numItems) { ListView_SetItemCount(_window, numItems); }
void SetItemCountEx(int numItems, DWORD flags) { ListView_SetItemCountEx(_window, numItems, flags); }
int GetNextItem(int startIndex, UINT flags) const { return ListView_GetNextItem(_window, startIndex, flags); }
int GetNextSelectedItem(int startIndex) const { return GetNextItem(startIndex, LVNI_SELECTED); }
int GetFocusedItem() const { return GetNextItem(-1, LVNI_FOCUSED); }
bool GetItem(LVITEM* item) const { return BOOLToBool(ListView_GetItem(_window, item)); }
bool GetItemParam(int itemIndex, LPARAM &param) const;
void GetItemText(int itemIndex, int subItemIndex, LPTSTR text, int textSizeMax) const
{ ListView_GetItemText(_window, itemIndex, subItemIndex, text, textSizeMax); }
bool SortItems(PFNLVCOMPARE compareFunction, LPARAM dataParam)
{ return BOOLToBool(ListView_SortItems(_window, compareFunction, dataParam)); }
void SetItemState(int index, UINT state, UINT mask) { ListView_SetItemState(_window, index, state, mask); }
void SetItemState_Selected(int index, bool select) { SetItemState(index, select ? LVIS_SELECTED : 0, LVIS_SELECTED); }
void SetItemState_Selected(int index) { SetItemState(index, LVIS_SELECTED, LVIS_SELECTED); }
void SelectAll() { SetItemState_Selected(-1); }
void SetItemState_FocusedSelected(int index) { SetItemState(index, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); }
UINT GetItemState(int index, UINT mask) const { return ListView_GetItemState(_window, index, mask); }
bool IsItemSelected(int index) const { return GetItemState(index, LVIS_SELECTED) == LVIS_SELECTED; }
bool GetColumn(int columnIndex, LVCOLUMN* columnInfo) const
{ return BOOLToBool(ListView_GetColumn(_window, columnIndex, columnInfo)); }
HIMAGELIST SetImageList(HIMAGELIST imageList, int imageListType)
{ return ListView_SetImageList(_window, imageList, imageListType); }
// version 4.70: NT5 | (NT4 + ie3) | w98 | (w95 + ie3)
DWORD GetExtendedListViewStyle() { return ListView_GetExtendedListViewStyle(_window); }
void SetExtendedListViewStyle(DWORD exStyle) { ListView_SetExtendedListViewStyle(_window, exStyle); }
void SetExtendedListViewStyle(DWORD exMask, DWORD exStyle) { ListView_SetExtendedListViewStyleEx(_window, exMask, exStyle); }
void SetCheckState(UINT index, bool checkState) { ListView_SetCheckState(_window, index, BoolToBOOL(checkState)); }
bool GetCheckState(UINT index) { return BOOLToBool(ListView_GetCheckState(_window, index)); }
bool EnsureVisible(int index, bool partialOK) { return BOOLToBool(ListView_EnsureVisible(_window, index, BoolToBOOL(partialOK))); }
bool GetItemRect(int index, RECT *rect, int code) { return BOOLToBool(ListView_GetItemRect(_window, index, rect, code)); }
HWND GetEditControl() { return ListView_GetEditControl(_window) ; }
HWND EditLabel(int itemIndex) { return ListView_EditLabel(_window, itemIndex) ; }
bool RedrawItems(int firstIndex, int lastIndex) { return BOOLToBool(ListView_RedrawItems(_window, firstIndex, lastIndex)); }
bool RedrawAllItems()
{
if (GetItemCount() > 0)
return RedrawItems(0, GetItemCount() - 1);
return true;
}
bool RedrawItem(int index) { return RedrawItems(index, index); }
int HitTest(LPLVHITTESTINFO info) { return ListView_HitTest(_window, info); }
COLORREF GetBkColor() { return ListView_GetBkColor(_window); }
bool SetColumnWidth(int iCol, int cx) { return BOOLToBool(ListView_SetColumnWidth(_window, iCol, cx)); }
bool SetColumnWidthAuto(int iCol) { return SetColumnWidth(iCol, LVSCW_AUTOSIZE); }
};
class CListView2: public CListView
{
WNDPROC _origWindowProc;
public:
void SetWindowProc();
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
};
/*
class CListView3: public CListView2
{
public:
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
};
*/
}}
#endif
// Windows/Control/ListView.h
#ifndef __WINDOWS_CONTROL_LISTVIEW_H
#define __WINDOWS_CONTROL_LISTVIEW_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CListView: public NWindows::CWindow
{
public:
bool CreateEx(DWORD exStyle, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
void SetUnicodeFormat()
{
#ifndef UNDER_CE
ListView_SetUnicodeFormat(_window, TRUE);
#endif
}
bool DeleteAllItems() { return BOOLToBool(ListView_DeleteAllItems(_window)); }
bool DeleteColumn(int columnIndex) { return BOOLToBool(ListView_DeleteColumn(_window, columnIndex)); }
int InsertColumn(int columnIndex, const LVCOLUMN *columnInfo) { return ListView_InsertColumn(_window, columnIndex, columnInfo); }
int InsertColumn(int columnIndex, LPCTSTR text, int width);
bool SetColumnOrderArray(int count, const int *columns) { return BOOLToBool(ListView_SetColumnOrderArray(_window, count, columns)); }
/*
int GetNumColumns()
{
HWND header = ListView_GetHeader(_window);
if (!header)
return -1;
return Header_GetItemCount(header);
}
*/
int InsertItem(const LVITEM* item) { return ListView_InsertItem(_window, item); }
int InsertItem(int index, LPCTSTR text);
bool SetItem(const LVITEM* item) { return BOOLToBool(ListView_SetItem(_window, item)); }
int SetSubItem(int index, int subIndex, LPCTSTR text);
#ifndef _UNICODE
int InsertColumn(int columnIndex, const LVCOLUMNW *columnInfo) { return (int)SendMsg(LVM_INSERTCOLUMNW, (WPARAM)columnIndex, (LPARAM)columnInfo); }
int InsertColumn(int columnIndex, LPCWSTR text, int width);
int InsertItem(const LV_ITEMW* item) { return (int)SendMsg(LVM_INSERTITEMW, 0, (LPARAM)item); }
int InsertItem(int index, LPCWSTR text);
bool SetItem(const LV_ITEMW* item) { return BOOLToBool((BOOL)SendMsg(LVM_SETITEMW, 0, (LPARAM)item)); }
int SetSubItem(int index, int subIndex, LPCWSTR text);
#endif
bool DeleteItem(int itemIndex) { return BOOLToBool(ListView_DeleteItem(_window, itemIndex)); }
UINT GetSelectedCount() const { return ListView_GetSelectedCount(_window); }
int GetItemCount() const { return ListView_GetItemCount(_window); }
INT GetSelectionMark() const { return ListView_GetSelectionMark(_window); }
void SetItemCount(int numItems) { ListView_SetItemCount(_window, numItems); }
void SetItemCountEx(int numItems, DWORD flags) { ListView_SetItemCountEx(_window, numItems, flags); }
int GetNextItem(int startIndex, UINT flags) const { return ListView_GetNextItem(_window, startIndex, flags); }
int GetNextSelectedItem(int startIndex) const { return GetNextItem(startIndex, LVNI_SELECTED); }
int GetFocusedItem() const { return GetNextItem(-1, LVNI_FOCUSED); }
bool GetItem(LVITEM* item) const { return BOOLToBool(ListView_GetItem(_window, item)); }
bool GetItemParam(int itemIndex, LPARAM &param) const;
void GetItemText(int itemIndex, int subItemIndex, LPTSTR text, int textSizeMax) const
{ ListView_GetItemText(_window, itemIndex, subItemIndex, text, textSizeMax); }
bool SortItems(PFNLVCOMPARE compareFunction, LPARAM dataParam)
{ return BOOLToBool(ListView_SortItems(_window, compareFunction, dataParam)); }
void SetItemState(int index, UINT state, UINT mask) { ListView_SetItemState(_window, index, state, mask); }
void SetItemState_Selected(int index, bool select) { SetItemState(index, select ? LVIS_SELECTED : 0, LVIS_SELECTED); }
void SetItemState_Selected(int index) { SetItemState(index, LVIS_SELECTED, LVIS_SELECTED); }
void SelectAll() { SetItemState_Selected(-1); }
void SetItemState_FocusedSelected(int index) { SetItemState(index, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED); }
UINT GetItemState(int index, UINT mask) const { return ListView_GetItemState(_window, index, mask); }
bool IsItemSelected(int index) const { return GetItemState(index, LVIS_SELECTED) == LVIS_SELECTED; }
bool GetColumn(int columnIndex, LVCOLUMN* columnInfo) const
{ return BOOLToBool(ListView_GetColumn(_window, columnIndex, columnInfo)); }
HIMAGELIST SetImageList(HIMAGELIST imageList, int imageListType)
{ return ListView_SetImageList(_window, imageList, imageListType); }
// version 4.70: NT5 | (NT4 + ie3) | w98 | (w95 + ie3)
DWORD GetExtendedListViewStyle() { return ListView_GetExtendedListViewStyle(_window); }
void SetExtendedListViewStyle(DWORD exStyle) { ListView_SetExtendedListViewStyle(_window, exStyle); }
void SetExtendedListViewStyle(DWORD exMask, DWORD exStyle) { ListView_SetExtendedListViewStyleEx(_window, exMask, exStyle); }
void SetCheckState(UINT index, bool checkState) { ListView_SetCheckState(_window, index, BoolToBOOL(checkState)); }
bool GetCheckState(UINT index) { return BOOLToBool(ListView_GetCheckState(_window, index)); }
bool EnsureVisible(int index, bool partialOK) { return BOOLToBool(ListView_EnsureVisible(_window, index, BoolToBOOL(partialOK))); }
bool GetItemRect(int index, RECT *rect, int code) { return BOOLToBool(ListView_GetItemRect(_window, index, rect, code)); }
HWND GetEditControl() { return ListView_GetEditControl(_window) ; }
HWND EditLabel(int itemIndex) { return ListView_EditLabel(_window, itemIndex) ; }
bool RedrawItems(int firstIndex, int lastIndex) { return BOOLToBool(ListView_RedrawItems(_window, firstIndex, lastIndex)); }
bool RedrawAllItems()
{
if (GetItemCount() > 0)
return RedrawItems(0, GetItemCount() - 1);
return true;
}
bool RedrawItem(int index) { return RedrawItems(index, index); }
int HitTest(LPLVHITTESTINFO info) { return ListView_HitTest(_window, info); }
COLORREF GetBkColor() { return ListView_GetBkColor(_window); }
bool SetColumnWidth(int iCol, int cx) { return BOOLToBool(ListView_SetColumnWidth(_window, iCol, cx)); }
bool SetColumnWidthAuto(int iCol) { return SetColumnWidth(iCol, LVSCW_AUTOSIZE); }
};
class CListView2: public CListView
{
WNDPROC _origWindowProc;
public:
void SetWindowProc();
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
};
/*
class CListView3: public CListView2
{
public:
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
};
*/
}}
#endif

70
CPP/Windows/Control/ProgressBar.h
View File

@@ -1,35 +1,35 @@
// Windows/Control/ProgressBar.h
#ifndef __WINDOWS_CONTROL_PROGRESSBAR_H
#define __WINDOWS_CONTROL_PROGRESSBAR_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CProgressBar: public CWindow
{
public:
LRESULT SetPos(int pos) { return SendMsg(PBM_SETPOS, pos, 0); }
LRESULT DeltaPos(int increment) { return SendMsg(PBM_DELTAPOS, increment, 0); }
UINT GetPos() { return (UINT)SendMsg(PBM_GETPOS, 0, 0); }
LRESULT SetRange(unsigned short minValue, unsigned short maxValue) { return SendMsg(PBM_SETRANGE, 0, MAKELPARAM(minValue, maxValue)); }
DWORD SetRange32(int minValue, int maxValue) { return (DWORD)SendMsg(PBM_SETRANGE32, minValue, maxValue); }
int SetStep(int step) { return (int)SendMsg(PBM_SETSTEP, step, 0); }
LRESULT StepIt() { return SendMsg(PBM_STEPIT, 0, 0); }
INT GetRange(bool minValue, PPBRANGE range) { return (INT)SendMsg(PBM_GETRANGE, BoolToBOOL(minValue), (LPARAM)range); }
#ifndef UNDER_CE
COLORREF SetBarColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBARCOLOR, 0, color); }
COLORREF SetBackgroundColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBKCOLOR, 0, color); }
#endif
};
}}
#endif
// Windows/Control/ProgressBar.h
#ifndef __WINDOWS_CONTROL_PROGRESSBAR_H
#define __WINDOWS_CONTROL_PROGRESSBAR_H
#include "../../Common/MyWindows.h"
#include <commctrl.h>
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CProgressBar: public CWindow
{
public:
LRESULT SetPos(int pos) { return SendMsg(PBM_SETPOS, pos, 0); }
LRESULT DeltaPos(int increment) { return SendMsg(PBM_DELTAPOS, increment, 0); }
UINT GetPos() { return (UINT)SendMsg(PBM_GETPOS, 0, 0); }
LRESULT SetRange(unsigned short minValue, unsigned short maxValue) { return SendMsg(PBM_SETRANGE, 0, MAKELPARAM(minValue, maxValue)); }
DWORD SetRange32(int minValue, int maxValue) { return (DWORD)SendMsg(PBM_SETRANGE32, minValue, maxValue); }
int SetStep(int step) { return (int)SendMsg(PBM_SETSTEP, step, 0); }
LRESULT StepIt() { return SendMsg(PBM_STEPIT, 0, 0); }
INT GetRange(bool minValue, PPBRANGE range) { return (INT)SendMsg(PBM_GETRANGE, BoolToBOOL(minValue), (LPARAM)range); }
#ifndef UNDER_CE
COLORREF SetBarColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBARCOLOR, 0, color); }
COLORREF SetBackgroundColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBKCOLOR, 0, color); }
#endif
};
}}
#endif

286
CPP/Windows/Control/PropertyPage.cpp
View File

@@ -1,143 +1,143 @@
// Windows/Control/PropertyPage.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "PropertyPage.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
static INT_PTR APIENTRY MyProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempDialog(dialogHWND);
if (message == WM_INITDIALOG)
tempDialog.SetUserDataLongPtr(((PROPSHEETPAGE *)lParam)->lParam);
CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
if (dialog == NULL)
return FALSE;
if (message == WM_INITDIALOG)
dialog->Attach(dialogHWND);
try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
catch(...) { return TRUE; }
}
bool CPropertyPage::OnNotify(UINT /* controlID */, LPNMHDR lParam)
{
switch (lParam->code)
{
case PSN_APPLY: SetMsgResult(OnApply(LPPSHNOTIFY(lParam))); break;
case PSN_KILLACTIVE: SetMsgResult(BoolToBOOL(OnKillActive(LPPSHNOTIFY(lParam)))); break;
case PSN_SETACTIVE: SetMsgResult(OnSetActive(LPPSHNOTIFY(lParam))); break;
case PSN_RESET: OnReset(LPPSHNOTIFY(lParam)); break;
case PSN_HELP: OnNotifyHelp(LPPSHNOTIFY(lParam)); break;
default: return false;
}
return true;
}
INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title)
{
#ifndef _UNICODE
AStringVector titles;
#endif
#ifndef _UNICODE
CRecordVector<PROPSHEETPAGEA> pagesA;
#endif
CRecordVector<PROPSHEETPAGEW> pagesW;
unsigned i;
#ifndef _UNICODE
for (i = 0; i < pagesInfo.Size(); i++)
titles.Add(GetSystemString(pagesInfo[i].Title));
#endif
for (i = 0; i < pagesInfo.Size(); i++)
{
const CPageInfo &pageInfo = pagesInfo[i];
#ifndef _UNICODE
{
PROPSHEETPAGE page;
page.dwSize = sizeof(page);
page.dwFlags = PSP_HASHELP;
page.hInstance = g_hInstance;
page.pszTemplate = MAKEINTRESOURCE(pageInfo.ID);
page.pszIcon = NULL;
page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
if (titles[i].IsEmpty())
page.pszTitle = NULL;
else
{
page.dwFlags |= PSP_USETITLE;
page.pszTitle = titles[i];
}
page.lParam = (LPARAM)pageInfo.Page;
page.pfnCallback = NULL;
pagesA.Add(page);
}
#endif
{
PROPSHEETPAGEW page;
page.dwSize = sizeof(page);
page.dwFlags = PSP_HASHELP;
page.hInstance = g_hInstance;
page.pszTemplate = MAKEINTRESOURCEW(pageInfo.ID);
page.pszIcon = NULL;
page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
if (pageInfo.Title.IsEmpty())
page.pszTitle = NULL;
else
{
page.dwFlags |= PSP_USETITLE;
page.pszTitle = pageInfo.Title;
}
page.lParam = (LPARAM)pageInfo.Page;
page.pfnCallback = NULL;
pagesW.Add(page);
}
}
#ifndef _UNICODE
if (!g_IsNT)
{
PROPSHEETHEADER sheet;
sheet.dwSize = sizeof(sheet);
sheet.dwFlags = PSH_PROPSHEETPAGE;
sheet.hwndParent = hwndParent;
sheet.hInstance = g_hInstance;
AString titleA (GetSystemString(title));
sheet.pszCaption = titleA;
sheet.nPages = pagesInfo.Size();
sheet.nStartPage = 0;
sheet.ppsp = &pagesA.Front();
sheet.pfnCallback = NULL;
return ::PropertySheetA(&sheet);
}
else
#endif
{
PROPSHEETHEADERW sheet;
sheet.dwSize = sizeof(sheet);
sheet.dwFlags = PSH_PROPSHEETPAGE;
sheet.hwndParent = hwndParent;
sheet.hInstance = g_hInstance;
sheet.pszCaption = title;
sheet.nPages = pagesInfo.Size();
sheet.nStartPage = 0;
sheet.ppsp = &pagesW.Front();
sheet.pfnCallback = NULL;
return ::PropertySheetW(&sheet);
}
}
}}
// Windows/Control/PropertyPage.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "PropertyPage.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NControl {
static INT_PTR APIENTRY MyProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempDialog(dialogHWND);
if (message == WM_INITDIALOG)
tempDialog.SetUserDataLongPtr(((PROPSHEETPAGE *)lParam)->lParam);
CDialog *dialog = (CDialog *)(tempDialog.GetUserDataLongPtr());
if (dialog == NULL)
return FALSE;
if (message == WM_INITDIALOG)
dialog->Attach(dialogHWND);
try { return BoolToBOOL(dialog->OnMessage(message, wParam, lParam)); }
catch(...) { return TRUE; }
}
bool CPropertyPage::OnNotify(UINT /* controlID */, LPNMHDR lParam)
{
switch (lParam->code)
{
case PSN_APPLY: SetMsgResult(OnApply(LPPSHNOTIFY(lParam))); break;
case PSN_KILLACTIVE: SetMsgResult(BoolToBOOL(OnKillActive(LPPSHNOTIFY(lParam)))); break;
case PSN_SETACTIVE: SetMsgResult(OnSetActive(LPPSHNOTIFY(lParam))); break;
case PSN_RESET: OnReset(LPPSHNOTIFY(lParam)); break;
case PSN_HELP: OnNotifyHelp(LPPSHNOTIFY(lParam)); break;
default: return false;
}
return true;
}
INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title)
{
#ifndef _UNICODE
AStringVector titles;
#endif
#ifndef _UNICODE
CRecordVector<PROPSHEETPAGEA> pagesA;
#endif
CRecordVector<PROPSHEETPAGEW> pagesW;
unsigned i;
#ifndef _UNICODE
for (i = 0; i < pagesInfo.Size(); i++)
titles.Add(GetSystemString(pagesInfo[i].Title));
#endif
for (i = 0; i < pagesInfo.Size(); i++)
{
const CPageInfo &pageInfo = pagesInfo[i];
#ifndef _UNICODE
{
PROPSHEETPAGE page;
page.dwSize = sizeof(page);
page.dwFlags = PSP_HASHELP;
page.hInstance = g_hInstance;
page.pszTemplate = MAKEINTRESOURCE(pageInfo.ID);
page.pszIcon = NULL;
page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
if (titles[i].IsEmpty())
page.pszTitle = NULL;
else
{
page.dwFlags |= PSP_USETITLE;
page.pszTitle = titles[i];
}
page.lParam = (LPARAM)pageInfo.Page;
page.pfnCallback = NULL;
pagesA.Add(page);
}
#endif
{
PROPSHEETPAGEW page;
page.dwSize = sizeof(page);
page.dwFlags = PSP_HASHELP;
page.hInstance = g_hInstance;
page.pszTemplate = MAKEINTRESOURCEW(pageInfo.ID);
page.pszIcon = NULL;
page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
if (pageInfo.Title.IsEmpty())
page.pszTitle = NULL;
else
{
page.dwFlags |= PSP_USETITLE;
page.pszTitle = pageInfo.Title;
}
page.lParam = (LPARAM)pageInfo.Page;
page.pfnCallback = NULL;
pagesW.Add(page);
}
}
#ifndef _UNICODE
if (!g_IsNT)
{
PROPSHEETHEADER sheet;
sheet.dwSize = sizeof(sheet);
sheet.dwFlags = PSH_PROPSHEETPAGE;
sheet.hwndParent = hwndParent;
sheet.hInstance = g_hInstance;
AString titleA (GetSystemString(title));
sheet.pszCaption = titleA;
sheet.nPages = pagesInfo.Size();
sheet.nStartPage = 0;
sheet.ppsp = &pagesA.Front();
sheet.pfnCallback = NULL;
return ::PropertySheetA(&sheet);
}
else
#endif
{
PROPSHEETHEADERW sheet;
sheet.dwSize = sizeof(sheet);
sheet.dwFlags = PSH_PROPSHEETPAGE;
sheet.hwndParent = hwndParent;
sheet.hInstance = g_hInstance;
sheet.pszCaption = title;
sheet.nPages = pagesInfo.Size();
sheet.nStartPage = 0;
sheet.ppsp = &pagesW.Front();
sheet.pfnCallback = NULL;
return ::PropertySheetW(&sheet);
}
}
}}

100
CPP/Windows/Control/PropertyPage.h
View File

@@ -1,50 +1,50 @@
// Windows/Control/PropertyPage.h
#ifndef __WINDOWS_CONTROL_PROPERTYPAGE_H
#define __WINDOWS_CONTROL_PROPERTYPAGE_H
#include "../../Common/MyWindows.h"
#include <prsht.h>
#include "Dialog.h"
namespace NWindows {
namespace NControl {
INT_PTR APIENTRY ProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam);
class CPropertyPage: public CDialog
{
public:
CPropertyPage(HWND window = NULL): CDialog(window){};
void Changed() { PropSheet_Changed(GetParent(), (HWND)*this); }
void UnChanged() { PropSheet_UnChanged(GetParent(), (HWND)*this); }
virtual bool OnNotify(UINT controlID, LPNMHDR lParam);
virtual bool OnKillActive() { return false; } // false = OK
virtual bool OnKillActive(const PSHNOTIFY *) { return OnKillActive(); }
virtual LONG OnSetActive() { return false; } // false = OK
virtual LONG OnSetActive(const PSHNOTIFY *) { return OnSetActive(); }
virtual LONG OnApply() { return PSNRET_NOERROR; }
virtual LONG OnApply(const PSHNOTIFY *) { return OnApply(); }
virtual void OnNotifyHelp() {}
virtual void OnNotifyHelp(const PSHNOTIFY *) { OnNotifyHelp(); }
virtual void OnReset() {}
virtual void OnReset(const PSHNOTIFY *) { OnReset(); }
};
struct CPageInfo
{
CPropertyPage *Page;
UString Title;
UINT ID;
};
INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title);
}}
#endif
// Windows/Control/PropertyPage.h
#ifndef __WINDOWS_CONTROL_PROPERTYPAGE_H
#define __WINDOWS_CONTROL_PROPERTYPAGE_H
#include "../../Common/MyWindows.h"
#include <prsht.h>
#include "Dialog.h"
namespace NWindows {
namespace NControl {
INT_PTR APIENTRY ProperyPageProcedure(HWND dialogHWND, UINT message, WPARAM wParam, LPARAM lParam);
class CPropertyPage: public CDialog
{
public:
CPropertyPage(HWND window = NULL): CDialog(window){};
void Changed() { PropSheet_Changed(GetParent(), (HWND)*this); }
void UnChanged() { PropSheet_UnChanged(GetParent(), (HWND)*this); }
virtual bool OnNotify(UINT controlID, LPNMHDR lParam);
virtual bool OnKillActive() { return false; } // false = OK
virtual bool OnKillActive(const PSHNOTIFY *) { return OnKillActive(); }
virtual LONG OnSetActive() { return false; } // false = OK
virtual LONG OnSetActive(const PSHNOTIFY *) { return OnSetActive(); }
virtual LONG OnApply() { return PSNRET_NOERROR; }
virtual LONG OnApply(const PSHNOTIFY *) { return OnApply(); }
virtual void OnNotifyHelp() {}
virtual void OnNotifyHelp(const PSHNOTIFY *) { OnNotifyHelp(); }
virtual void OnReset() {}
virtual void OnReset(const PSHNOTIFY *) { OnReset(); }
};
struct CPageInfo
{
CPropertyPage *Page;
UString Title;
UINT ID;
};
INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title);
}}
#endif

68
CPP/Windows/Control/ReBar.h
View File

@@ -1,34 +1,34 @@
// Windows/Control/ReBar.h
#ifndef __WINDOWS_CONTROL_REBAR_H
#define __WINDOWS_CONTROL_REBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CReBar: public NWindows::CWindow
{
public:
bool SetBarInfo(LPREBARINFO barInfo)
{ return LRESULTToBool(SendMsg(RB_SETBARINFO, 0, (LPARAM)barInfo)); }
bool InsertBand(int index, LPREBARBANDINFO bandInfo)
{ return LRESULTToBool(SendMsg(RB_INSERTBAND, index, (LPARAM)bandInfo)); }
bool SetBandInfo(unsigned index, LPREBARBANDINFO bandInfo)
{ return LRESULTToBool(SendMsg(RB_SETBANDINFO, index, (LPARAM)bandInfo)); }
void MaximizeBand(unsigned index, bool ideal)
{ SendMsg(RB_MAXIMIZEBAND, index, BoolToBOOL(ideal)); }
bool SizeToRect(LPRECT rect)
{ return LRESULTToBool(SendMsg(RB_SIZETORECT, 0, (LPARAM)rect)); }
UINT GetHeight()
{ return (UINT)SendMsg(RB_GETBARHEIGHT); }
UINT GetBandCount()
{ return (UINT)SendMsg(RB_GETBANDCOUNT); }
bool DeleteBand(UINT index)
{ return LRESULTToBool(SendMsg(RB_DELETEBAND, index)); }
};
}}
#endif
// Windows/Control/ReBar.h
#ifndef __WINDOWS_CONTROL_REBAR_H
#define __WINDOWS_CONTROL_REBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CReBar: public NWindows::CWindow
{
public:
bool SetBarInfo(LPREBARINFO barInfo)
{ return LRESULTToBool(SendMsg(RB_SETBARINFO, 0, (LPARAM)barInfo)); }
bool InsertBand(int index, LPREBARBANDINFO bandInfo)
{ return LRESULTToBool(SendMsg(RB_INSERTBAND, index, (LPARAM)bandInfo)); }
bool SetBandInfo(unsigned index, LPREBARBANDINFO bandInfo)
{ return LRESULTToBool(SendMsg(RB_SETBANDINFO, index, (LPARAM)bandInfo)); }
void MaximizeBand(unsigned index, bool ideal)
{ SendMsg(RB_MAXIMIZEBAND, index, BoolToBOOL(ideal)); }
bool SizeToRect(LPRECT rect)
{ return LRESULTToBool(SendMsg(RB_SIZETORECT, 0, (LPARAM)rect)); }
UINT GetHeight()
{ return (UINT)SendMsg(RB_GETBARHEIGHT); }
UINT GetBandCount()
{ return (UINT)SendMsg(RB_GETBANDCOUNT); }
bool DeleteBand(UINT index)
{ return LRESULTToBool(SendMsg(RB_DELETEBAND, index)); }
};
}}
#endif

56
CPP/Windows/Control/Static.h
View File

@@ -1,28 +1,28 @@
// Windows/Control/Static.h
#ifndef __WINDOWS_CONTROL_STATIC_H
#define __WINDOWS_CONTROL_STATIC_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CStatic: public CWindow
{
public:
HANDLE SetImage(WPARAM imageType, HANDLE handle) { return (HANDLE)SendMsg(STM_SETIMAGE, imageType, (LPARAM)handle); }
HANDLE GetImage(WPARAM imageType) { return (HANDLE)SendMsg(STM_GETIMAGE, imageType, 0); }
#ifdef UNDER_CE
HICON SetIcon(HICON icon) { return (HICON)SetImage(IMAGE_ICON, icon); }
HICON GetIcon() { return (HICON)GetImage(IMAGE_ICON); }
#else
HICON SetIcon(HICON icon) { return (HICON)SendMsg(STM_SETICON, (WPARAM)icon, 0); }
HICON GetIcon() { return (HICON)SendMsg(STM_GETICON, 0, 0); }
#endif
};
}}
#endif
// Windows/Control/Static.h
#ifndef __WINDOWS_CONTROL_STATIC_H
#define __WINDOWS_CONTROL_STATIC_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CStatic: public CWindow
{
public:
HANDLE SetImage(WPARAM imageType, HANDLE handle) { return (HANDLE)SendMsg(STM_SETIMAGE, imageType, (LPARAM)handle); }
HANDLE GetImage(WPARAM imageType) { return (HANDLE)SendMsg(STM_GETIMAGE, imageType, 0); }
#ifdef UNDER_CE
HICON SetIcon(HICON icon) { return (HICON)SetImage(IMAGE_ICON, icon); }
HICON GetIcon() { return (HICON)GetImage(IMAGE_ICON); }
#else
HICON SetIcon(HICON icon) { return (HICON)SendMsg(STM_SETICON, (WPARAM)icon, 0); }
HICON GetIcon() { return (HICON)SendMsg(STM_GETICON, 0, 0); }
#endif
};
}}
#endif

84
CPP/Windows/Control/StatusBar.h
View File

@@ -1,42 +1,42 @@
// Windows/Control/StatusBar.h
#ifndef __WINDOWS_CONTROL_STATUSBAR_H
#define __WINDOWS_CONTROL_STATUSBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CStatusBar: public NWindows::CWindow
{
public:
bool Create(LONG style, LPCTSTR text, HWND hwndParent, UINT id)
{ return (_window = ::CreateStatusWindow(style, text, hwndParent, id)) != 0; }
bool SetText(LPCTSTR text)
{ return CWindow::SetText(text); }
bool SetText(unsigned index, LPCTSTR text, UINT type)
{ return LRESULTToBool(SendMsg(SB_SETTEXT, index | type, (LPARAM)text)); }
bool SetText(unsigned index, LPCTSTR text)
{ return SetText(index, text, 0); }
#ifndef _UNICODE
bool Create(LONG style, LPCWSTR text, HWND hwndParent, UINT id)
{ return (_window = ::CreateStatusWindowW(style, text, hwndParent, id)) != 0; }
bool SetText(LPCWSTR text)
{ return CWindow::SetText(text); }
bool SetText(unsigned index, LPCWSTR text, UINT type)
{ return LRESULTToBool(SendMsg(SB_SETTEXTW, index | type, (LPARAM)text)); }
bool SetText(unsigned index, LPCWSTR text)
{ return SetText(index, text, 0); }
#endif
bool SetParts(unsigned numParts, const int *edgePostions)
{ return LRESULTToBool(SendMsg(SB_SETPARTS, numParts, (LPARAM)edgePostions)); }
void Simple(bool simple)
{ SendMsg(SB_SIMPLE, BoolToBOOL(simple), 0); }
};
}}
#endif
// Windows/Control/StatusBar.h
#ifndef __WINDOWS_CONTROL_STATUSBAR_H
#define __WINDOWS_CONTROL_STATUSBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CStatusBar: public NWindows::CWindow
{
public:
bool Create(LONG style, LPCTSTR text, HWND hwndParent, UINT id)
{ return (_window = ::CreateStatusWindow(style, text, hwndParent, id)) != 0; }
bool SetText(LPCTSTR text)
{ return CWindow::SetText(text); }
bool SetText(unsigned index, LPCTSTR text, UINT type)
{ return LRESULTToBool(SendMsg(SB_SETTEXT, index | type, (LPARAM)text)); }
bool SetText(unsigned index, LPCTSTR text)
{ return SetText(index, text, 0); }
#ifndef _UNICODE
bool Create(LONG style, LPCWSTR text, HWND hwndParent, UINT id)
{ return (_window = ::CreateStatusWindowW(style, text, hwndParent, id)) != 0; }
bool SetText(LPCWSTR text)
{ return CWindow::SetText(text); }
bool SetText(unsigned index, LPCWSTR text, UINT type)
{ return LRESULTToBool(SendMsg(SB_SETTEXTW, index | type, (LPARAM)text)); }
bool SetText(unsigned index, LPCWSTR text)
{ return SetText(index, text, 0); }
#endif
bool SetParts(unsigned numParts, const int *edgePostions)
{ return LRESULTToBool(SendMsg(SB_SETPARTS, numParts, (LPARAM)edgePostions)); }
void Simple(bool simple)
{ SendMsg(SB_SIMPLE, BoolToBOOL(simple), 0); }
};
}}
#endif

16
CPP/Windows/Control/StdAfx.h
View File

@@ -1,8 +1,8 @@
// StdAfx.h
#ifndef __STDAFX_H
#define __STDAFX_H
#include "../../Common/Common.h"
#endif
// StdAfx.h
#ifndef __STDAFX_H
#define __STDAFX_H
#include "../../Common/Common.h"
#endif

86
CPP/Windows/Control/ToolBar.h
View File

@@ -1,43 +1,43 @@
// Windows/Control/ToolBar.h
#ifndef __WINDOWS_CONTROL_TOOLBAR_H
#define __WINDOWS_CONTROL_TOOLBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CToolBar: public NWindows::CWindow
{
public:
void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
DWORD GetButtonSize() { return (DWORD)SendMsg(TB_GETBUTTONSIZE, 0, 0); }
bool GetMaxSize(LPSIZE size)
#ifdef UNDER_CE
{
// maybe it must be fixed for more than 1 buttons
DWORD val = GetButtonSize();
size->cx = LOWORD(val);
size->cy = HIWORD(val);
return true;
}
#else
{
return LRESULTToBool(SendMsg(TB_GETMAXSIZE, 0, (LPARAM)size));
}
#endif
bool EnableButton(UINT buttonID, bool enable) { return LRESULTToBool(SendMsg(TB_ENABLEBUTTON, buttonID, MAKELONG(BoolToBOOL(enable), 0))); }
void ButtonStructSize() { SendMsg(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON)); }
HIMAGELIST SetImageList(UINT listIndex, HIMAGELIST imageList) { return HIMAGELIST(SendMsg(TB_SETIMAGELIST, listIndex, (LPARAM)imageList)); }
bool AddButton(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONS, numButtons, (LPARAM)buttons)); }
#ifndef _UNICODE
bool AddButtonW(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONSW, numButtons, (LPARAM)buttons)); }
#endif
};
}}
#endif
// Windows/Control/ToolBar.h
#ifndef __WINDOWS_CONTROL_TOOLBAR_H
#define __WINDOWS_CONTROL_TOOLBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CToolBar: public NWindows::CWindow
{
public:
void AutoSize() { SendMsg(TB_AUTOSIZE, 0, 0); }
DWORD GetButtonSize() { return (DWORD)SendMsg(TB_GETBUTTONSIZE, 0, 0); }
bool GetMaxSize(LPSIZE size)
#ifdef UNDER_CE
{
// maybe it must be fixed for more than 1 buttons
DWORD val = GetButtonSize();
size->cx = LOWORD(val);
size->cy = HIWORD(val);
return true;
}
#else
{
return LRESULTToBool(SendMsg(TB_GETMAXSIZE, 0, (LPARAM)size));
}
#endif
bool EnableButton(UINT buttonID, bool enable) { return LRESULTToBool(SendMsg(TB_ENABLEBUTTON, buttonID, MAKELONG(BoolToBOOL(enable), 0))); }
void ButtonStructSize() { SendMsg(TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON)); }
HIMAGELIST SetImageList(UINT listIndex, HIMAGELIST imageList) { return HIMAGELIST(SendMsg(TB_SETIMAGELIST, listIndex, (LPARAM)imageList)); }
bool AddButton(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONS, numButtons, (LPARAM)buttons)); }
#ifndef _UNICODE
bool AddButtonW(UINT numButtons, LPTBBUTTON buttons) { return LRESULTToBool(SendMsg(TB_ADDBUTTONSW, numButtons, (LPARAM)buttons)); }
#endif
};
}}
#endif

54
CPP/Windows/Control/Trackbar.h
View File

@@ -1,27 +1,27 @@
// Windows/Control/Trackbar.h
#ifndef __WINDOWS_CONTROL_TRACKBAR_H
#define __WINDOWS_CONTROL_TRACKBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CTrackbar: public CWindow
{
public:
void SetRange(int minimum, int maximum, bool redraw = true)
{ SendMsg(TBM_SETRANGE, BoolToBOOL(redraw), MAKELONG(minimum, maximum)); }
void SetPos(int pos, bool redraw = true)
{ SendMsg(TBM_SETPOS, BoolToBOOL(redraw), pos); }
void SetTicFreq(int freq)
{ SendMsg(TBM_SETTICFREQ, freq); }
int GetPos()
{ return (int)SendMsg(TBM_GETPOS); }
};
}}
#endif
// Windows/Control/Trackbar.h
#ifndef __WINDOWS_CONTROL_TRACKBAR_H
#define __WINDOWS_CONTROL_TRACKBAR_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CTrackbar: public CWindow
{
public:
void SetRange(int minimum, int maximum, bool redraw = true)
{ SendMsg(TBM_SETRANGE, BoolToBOOL(redraw), MAKELONG(minimum, maximum)); }
void SetPos(int pos, bool redraw = true)
{ SendMsg(TBM_SETPOS, BoolToBOOL(redraw), pos); }
void SetTicFreq(int freq)
{ SendMsg(TBM_SETTICFREQ, freq); }
int GetPos()
{ return (int)SendMsg(TBM_GETPOS); }
};
}}
#endif

400
CPP/Windows/Control/Window2.cpp
View File

@@ -1,200 +1,200 @@
// Windows/Control/Window2.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "Window2.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
#endif
namespace NControl {
#ifdef UNDER_CE
#define MY_START_WM_CREATE WM_CREATE
#else
#define MY_START_WM_CREATE WM_NCCREATE
#endif
static LRESULT CALLBACK WindowProcedure(HWND aHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempWindow(aHWND);
if (message == MY_START_WM_CREATE)
tempWindow.SetUserDataLongPtr((LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
CWindow2 *window = (CWindow2 *)(tempWindow.GetUserDataLongPtr());
if (window != NULL && message == MY_START_WM_CREATE)
window->Attach(aHWND);
if (window == 0)
{
#ifndef _UNICODE
if (g_IsNT)
return DefWindowProcW(aHWND, message, wParam, lParam);
else
#endif
return DefWindowProc(aHWND, message, wParam, lParam);
}
return window->OnMessage(message, wParam, lParam);
}
bool CWindow2::CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
{
WNDCLASS wc;
if (!::GetClassInfo(instance, className, &wc))
{
// wc.style = CS_HREDRAW | CS_VREDRAW;
wc.style = 0;
wc.lpfnWndProc = WindowProcedure;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = instance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
if (::RegisterClass(&wc) == 0)
return false;
}
return CWindow::CreateEx(exStyle, className, windowName, style,
x, y, width, height, parentWindow, idOrHMenu, instance, this);
}
#ifndef _UNICODE
bool CWindow2::CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
{
bool needRegister;
if (g_IsNT)
{
WNDCLASSW wc;
needRegister = ::GetClassInfoW(instance, className, &wc) == 0;
}
else
{
WNDCLASSA windowClassA;
AString classNameA;
LPCSTR classNameP;
if (IS_INTRESOURCE(className))
classNameP = (LPCSTR)className;
else
{
classNameA = GetSystemString(className);
classNameP = classNameA;
}
needRegister = ::GetClassInfoA(instance, classNameP, &windowClassA) == 0;
}
if (needRegister)
{
WNDCLASSW wc;
// wc.style = CS_HREDRAW | CS_VREDRAW;
wc.style = 0;
wc.lpfnWndProc = WindowProcedure;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = instance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
if (MyRegisterClass(&wc) == 0)
return false;
}
return CWindow::CreateEx(exStyle, className, windowName, style,
x, y, width, height, parentWindow, idOrHMenu, instance, this);
}
#endif
LRESULT CWindow2::DefProc(UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef _UNICODE
if (g_IsNT)
return DefWindowProcW(_window, message, wParam, lParam);
else
#endif
return DefWindowProc(_window, message, wParam, lParam);
}
LRESULT CWindow2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT result;
switch (message)
{
case WM_CREATE:
if (!OnCreate((CREATESTRUCT *)lParam))
return -1;
break;
case WM_COMMAND:
if (OnCommand(wParam, lParam, result))
return result;
break;
case WM_NOTIFY:
if (OnNotify((UINT)wParam, (LPNMHDR) lParam, result))
return result;
break;
case WM_DESTROY:
OnDestroy();
break;
case WM_CLOSE:
OnClose();
return 0;
case WM_SIZE:
if (OnSize(wParam, LOWORD(lParam), HIWORD(lParam)))
return 0;
}
return DefProc(message, wParam, lParam);
}
bool CWindow2::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result)
{
return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam, result);
}
bool CWindow2::OnCommand(int /* code */, int /* itemID */, LPARAM /* lParam */, LRESULT & /* result */)
{
return false;
// return DefProc(message, wParam, lParam);
/*
if (code == BN_CLICKED)
return OnButtonClicked(itemID, (HWND)lParam);
*/
}
/*
bool CDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
{
switch (buttonID)
{
case IDOK:
OnOK();
break;
case IDCANCEL:
OnCancel();
break;
case IDHELP:
OnHelp();
break;
default:
return false;
}
return true;
}
*/
}}
// Windows/Control/Window2.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../../Common/StringConvert.h"
#endif
#include "Window2.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
#endif
namespace NControl {
#ifdef UNDER_CE
#define MY_START_WM_CREATE WM_CREATE
#else
#define MY_START_WM_CREATE WM_NCCREATE
#endif
static LRESULT CALLBACK WindowProcedure(HWND aHWND, UINT message, WPARAM wParam, LPARAM lParam)
{
CWindow tempWindow(aHWND);
if (message == MY_START_WM_CREATE)
tempWindow.SetUserDataLongPtr((LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
CWindow2 *window = (CWindow2 *)(tempWindow.GetUserDataLongPtr());
if (window != NULL && message == MY_START_WM_CREATE)
window->Attach(aHWND);
if (window == 0)
{
#ifndef _UNICODE
if (g_IsNT)
return DefWindowProcW(aHWND, message, wParam, lParam);
else
#endif
return DefWindowProc(aHWND, message, wParam, lParam);
}
return window->OnMessage(message, wParam, lParam);
}
bool CWindow2::CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
{
WNDCLASS wc;
if (!::GetClassInfo(instance, className, &wc))
{
// wc.style = CS_HREDRAW | CS_VREDRAW;
wc.style = 0;
wc.lpfnWndProc = WindowProcedure;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = instance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
if (::RegisterClass(&wc) == 0)
return false;
}
return CWindow::CreateEx(exStyle, className, windowName, style,
x, y, width, height, parentWindow, idOrHMenu, instance, this);
}
#ifndef _UNICODE
bool CWindow2::CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance)
{
bool needRegister;
if (g_IsNT)
{
WNDCLASSW wc;
needRegister = ::GetClassInfoW(instance, className, &wc) == 0;
}
else
{
WNDCLASSA windowClassA;
AString classNameA;
LPCSTR classNameP;
if (IS_INTRESOURCE(className))
classNameP = (LPCSTR)className;
else
{
classNameA = GetSystemString(className);
classNameP = classNameA;
}
needRegister = ::GetClassInfoA(instance, classNameP, &windowClassA) == 0;
}
if (needRegister)
{
WNDCLASSW wc;
// wc.style = CS_HREDRAW | CS_VREDRAW;
wc.style = 0;
wc.lpfnWndProc = WindowProcedure;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = instance;
wc.hIcon = NULL;
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszMenuName = NULL;
wc.lpszClassName = className;
if (MyRegisterClass(&wc) == 0)
return false;
}
return CWindow::CreateEx(exStyle, className, windowName, style,
x, y, width, height, parentWindow, idOrHMenu, instance, this);
}
#endif
LRESULT CWindow2::DefProc(UINT message, WPARAM wParam, LPARAM lParam)
{
#ifndef _UNICODE
if (g_IsNT)
return DefWindowProcW(_window, message, wParam, lParam);
else
#endif
return DefWindowProc(_window, message, wParam, lParam);
}
LRESULT CWindow2::OnMessage(UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT result;
switch (message)
{
case WM_CREATE:
if (!OnCreate((CREATESTRUCT *)lParam))
return -1;
break;
case WM_COMMAND:
if (OnCommand(wParam, lParam, result))
return result;
break;
case WM_NOTIFY:
if (OnNotify((UINT)wParam, (LPNMHDR) lParam, result))
return result;
break;
case WM_DESTROY:
OnDestroy();
break;
case WM_CLOSE:
OnClose();
return 0;
case WM_SIZE:
if (OnSize(wParam, LOWORD(lParam), HIWORD(lParam)))
return 0;
}
return DefProc(message, wParam, lParam);
}
bool CWindow2::OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result)
{
return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam, result);
}
bool CWindow2::OnCommand(int /* code */, int /* itemID */, LPARAM /* lParam */, LRESULT & /* result */)
{
return false;
// return DefProc(message, wParam, lParam);
/*
if (code == BN_CLICKED)
return OnButtonClicked(itemID, (HWND)lParam);
*/
}
/*
bool CDialog::OnButtonClicked(int buttonID, HWND buttonHWND)
{
switch (buttonID)
{
case IDOK:
OnOK();
break;
case IDCANCEL:
OnCancel();
break;
case IDHELP:
OnHelp();
break;
default:
return false;
}
return true;
}
*/
}}

102
CPP/Windows/Control/Window2.h
View File

@@ -1,51 +1,51 @@
// Windows/Control/Window2.h
#ifndef __WINDOWS_CONTROL_WINDOW2_H
#define __WINDOWS_CONTROL_WINDOW2_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CWindow2: public CWindow
{
LRESULT DefProc(UINT message, WPARAM wParam, LPARAM lParam);
public:
CWindow2(HWND newWindow = NULL): CWindow(newWindow){};
virtual ~CWindow2() {};
bool CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
#ifndef _UNICODE
bool CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
#endif
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
virtual bool OnCreate(CREATESTRUCT * /* createStruct */) { return true; }
// virtual LRESULT OnCommand(WPARAM wParam, LPARAM lParam);
virtual bool OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result);
virtual bool OnCommand(int code, int itemID, LPARAM lParam, LRESULT &result);
virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */, LRESULT & /* result */) { return false; }
virtual void OnDestroy() { PostQuitMessage(0); }
virtual void OnClose() { Destroy(); }
/*
virtual LRESULT OnHelp(LPHELPINFO helpInfo) { OnHelp(); }
virtual LRESULT OnHelp() {};
virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
virtual void OnOK() {};
virtual void OnCancel() {};
*/
LONG_PTR SetMsgResult(LONG_PTR newLongPtr) { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
LONG_PTR GetMsgResult() const { return GetLongPtr(DWLP_MSGRESULT); }
};
}}
#endif
// Windows/Control/Window2.h
#ifndef __WINDOWS_CONTROL_WINDOW2_H
#define __WINDOWS_CONTROL_WINDOW2_H
#include "../Window.h"
namespace NWindows {
namespace NControl {
class CWindow2: public CWindow
{
LRESULT DefProc(UINT message, WPARAM wParam, LPARAM lParam);
public:
CWindow2(HWND newWindow = NULL): CWindow(newWindow){};
virtual ~CWindow2() {};
bool CreateEx(DWORD exStyle, LPCTSTR className, LPCTSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
#ifndef _UNICODE
bool CreateEx(DWORD exStyle, LPCWSTR className, LPCWSTR windowName,
DWORD style, int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu, HINSTANCE instance);
#endif
virtual LRESULT OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
virtual bool OnCreate(CREATESTRUCT * /* createStruct */) { return true; }
// virtual LRESULT OnCommand(WPARAM wParam, LPARAM lParam);
virtual bool OnCommand(WPARAM wParam, LPARAM lParam, LRESULT &result);
virtual bool OnCommand(int code, int itemID, LPARAM lParam, LRESULT &result);
virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
virtual bool OnNotify(UINT /* controlID */, LPNMHDR /* lParam */, LRESULT & /* result */) { return false; }
virtual void OnDestroy() { PostQuitMessage(0); }
virtual void OnClose() { Destroy(); }
/*
virtual LRESULT OnHelp(LPHELPINFO helpInfo) { OnHelp(); }
virtual LRESULT OnHelp() {};
virtual bool OnButtonClicked(int buttonID, HWND buttonHWND);
virtual void OnOK() {};
virtual void OnCancel() {};
*/
LONG_PTR SetMsgResult(LONG_PTR newLongPtr) { return SetLongPtr(DWLP_MSGRESULT, newLongPtr); }
LONG_PTR GetMsgResult() const { return GetLongPtr(DWLP_MSGRESULT); }
};
}}
#endif

218
CPP/Windows/DLL.cpp
View File

@@ -1,109 +1,109 @@
// Windows/DLL.cpp
#include "StdAfx.h"
#include "DLL.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
extern HINSTANCE g_hInstance;
namespace NWindows {
namespace NDLL {
bool CLibrary::Free() throw()
{
if (_module == 0)
return true;
if (!::FreeLibrary(_module))
return false;
_module = 0;
return true;
}
bool CLibrary::LoadEx(CFSTR path, DWORD flags) throw()
{
if (!Free())
return false;
#ifndef _UNICODE
if (!g_IsNT)
{
_module = ::LoadLibraryEx(fs2fas(path), NULL, flags);
}
else
#endif
{
_module = ::LoadLibraryExW(fs2us(path), NULL, flags);
}
return (_module != NULL);
}
bool CLibrary::Load(CFSTR path) throw()
{
if (!Free())
return false;
#ifndef _UNICODE
if (!g_IsNT)
{
_module = ::LoadLibrary(fs2fas(path));
}
else
#endif
{
_module = ::LoadLibraryW(fs2us(path));
}
return (_module != NULL);
}
bool MyGetModuleFileName(FString &path)
{
HMODULE hModule = g_hInstance;
path.Empty();
#ifndef _UNICODE
if (!g_IsNT)
{
TCHAR s[MAX_PATH + 2];
s[0] = 0;
DWORD size = ::GetModuleFileName(hModule, s, MAX_PATH + 1);
if (size <= MAX_PATH && size != 0)
{
path = fas2fs(s);
return true;
}
}
else
#endif
{
WCHAR s[MAX_PATH + 2];
s[0] = 0;
DWORD size = ::GetModuleFileNameW(hModule, s, MAX_PATH + 1);
if (size <= MAX_PATH && size != 0)
{
path = us2fs(s);
return true;
}
}
return false;
}
#ifndef _SFX
FString GetModuleDirPrefix()
{
FString s;
if (MyGetModuleFileName(s))
{
int pos = s.ReverseFind_PathSepar();
if (pos >= 0)
s.DeleteFrom(pos + 1);
}
if (s.IsEmpty())
s = "." STRING_PATH_SEPARATOR;
return s;
}
#endif
}}
// Windows/DLL.cpp
#include "StdAfx.h"
#include "DLL.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
extern HINSTANCE g_hInstance;
namespace NWindows {
namespace NDLL {
bool CLibrary::Free() throw()
{
if (_module == 0)
return true;
if (!::FreeLibrary(_module))
return false;
_module = 0;
return true;
}
bool CLibrary::LoadEx(CFSTR path, DWORD flags) throw()
{
if (!Free())
return false;
#ifndef _UNICODE
if (!g_IsNT)
{
_module = ::LoadLibraryEx(fs2fas(path), NULL, flags);
}
else
#endif
{
_module = ::LoadLibraryExW(fs2us(path), NULL, flags);
}
return (_module != NULL);
}
bool CLibrary::Load(CFSTR path) throw()
{
if (!Free())
return false;
#ifndef _UNICODE
if (!g_IsNT)
{
_module = ::LoadLibrary(fs2fas(path));
}
else
#endif
{
_module = ::LoadLibraryW(fs2us(path));
}
return (_module != NULL);
}
bool MyGetModuleFileName(FString &path)
{
HMODULE hModule = g_hInstance;
path.Empty();
#ifndef _UNICODE
if (!g_IsNT)
{
TCHAR s[MAX_PATH + 2];
s[0] = 0;
DWORD size = ::GetModuleFileName(hModule, s, MAX_PATH + 1);
if (size <= MAX_PATH && size != 0)
{
path = fas2fs(s);
return true;
}
}
else
#endif
{
WCHAR s[MAX_PATH + 2];
s[0] = 0;
DWORD size = ::GetModuleFileNameW(hModule, s, MAX_PATH + 1);
if (size <= MAX_PATH && size != 0)
{
path = us2fs(s);
return true;
}
}
return false;
}
#ifndef _SFX
FString GetModuleDirPrefix()
{
FString s;
if (MyGetModuleFileName(s))
{
int pos = s.ReverseFind_PathSepar();
if (pos >= 0)
s.DeleteFrom(pos + 1);
}
if (s.IsEmpty())
s = "." STRING_PATH_SEPARATOR;
return s;
}
#endif
}}

116
CPP/Windows/DLL.h
View File

@@ -1,58 +1,58 @@
// Windows/DLL.h
#ifndef __WINDOWS_DLL_H
#define __WINDOWS_DLL_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NDLL {
#ifdef UNDER_CE
#define My_GetProcAddress(module, procName) ::GetProcAddressA(module, procName)
#else
#define My_GetProcAddress(module, procName) ::GetProcAddress(module, procName)
#endif
/* Win32: Don't call CLibrary::Free() and FreeLibrary() from another
FreeLibrary() code: detaching code in DLL entry-point or in
destructors of global objects in DLL module. */
class CLibrary
{
HMODULE _module;
// CLASS_NO_COPY(CLibrary);
public:
CLibrary(): _module(NULL) {};
~CLibrary() { Free(); }
operator HMODULE() const { return _module; }
HMODULE* operator&() { return &_module; }
bool IsLoaded() const { return (_module != NULL); }
void Attach(HMODULE m)
{
Free();
_module = m;
}
HMODULE Detach()
{
HMODULE m = _module;
_module = NULL;
return m;
}
bool Free() throw();
bool LoadEx(CFSTR path, DWORD flags = LOAD_LIBRARY_AS_DATAFILE) throw();
bool Load(CFSTR path) throw();
FARPROC GetProc(LPCSTR procName) const { return My_GetProcAddress(_module, procName); }
};
bool MyGetModuleFileName(FString &path);
FString GetModuleDirPrefix();
}}
#endif
// Windows/DLL.h
#ifndef __WINDOWS_DLL_H
#define __WINDOWS_DLL_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NDLL {
#ifdef UNDER_CE
#define My_GetProcAddress(module, procName) ::GetProcAddressA(module, procName)
#else
#define My_GetProcAddress(module, procName) ::GetProcAddress(module, procName)
#endif
/* Win32: Don't call CLibrary::Free() and FreeLibrary() from another
FreeLibrary() code: detaching code in DLL entry-point or in
destructors of global objects in DLL module. */
class CLibrary
{
HMODULE _module;
// CLASS_NO_COPY(CLibrary);
public:
CLibrary(): _module(NULL) {};
~CLibrary() { Free(); }
operator HMODULE() const { return _module; }
HMODULE* operator&() { return &_module; }
bool IsLoaded() const { return (_module != NULL); }
void Attach(HMODULE m)
{
Free();
_module = m;
}
HMODULE Detach()
{
HMODULE m = _module;
_module = NULL;
return m;
}
bool Free() throw();
bool LoadEx(CFSTR path, DWORD flags = LOAD_LIBRARY_AS_DATAFILE) throw();
bool Load(CFSTR path) throw();
FARPROC GetProc(LPCSTR procName) const { return My_GetProcAddress(_module, procName); }
};
bool MyGetModuleFileName(FString &path);
FString GetModuleDirPrefix();
}}
#endif

34
CPP/Windows/Defs.h
View File

@@ -1,17 +1,17 @@
// Windows/Defs.h
#ifndef __WINDOWS_DEFS_H
#define __WINDOWS_DEFS_H
#include "../Common/MyWindows.h"
#ifdef _WIN32
inline bool LRESULTToBool(LRESULT v) { return (v != FALSE); }
inline bool BOOLToBool(BOOL v) { return (v != FALSE); }
inline BOOL BoolToBOOL(bool v) { return (v ? TRUE: FALSE); }
#endif
inline VARIANT_BOOL BoolToVARIANT_BOOL(bool v) { return (v ? VARIANT_TRUE: VARIANT_FALSE); }
inline bool VARIANT_BOOLToBool(VARIANT_BOOL v) { return (v != VARIANT_FALSE); }
#endif
// Windows/Defs.h
#ifndef __WINDOWS_DEFS_H
#define __WINDOWS_DEFS_H
#include "../Common/MyWindows.h"
#ifdef _WIN32
inline bool LRESULTToBool(LRESULT v) { return (v != FALSE); }
inline bool BOOLToBool(BOOL v) { return (v != FALSE); }
inline BOOL BoolToBOOL(bool v) { return (v ? TRUE: FALSE); }
#endif
inline VARIANT_BOOL BoolToVARIANT_BOOL(bool v) { return (v ? VARIANT_TRUE: VARIANT_FALSE); }
inline bool VARIANT_BOOLToBool(VARIANT_BOOL v) { return (v != VARIANT_FALSE); }
#endif

132
CPP/Windows/ErrorMsg.cpp
View File

@@ -1,66 +1,66 @@
// Windows/ErrorMsg.h
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "ErrorMsg.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NError {
static bool MyFormatMessage(DWORD errorCode, UString &message)
{
LPVOID msgBuf;
#ifndef _UNICODE
if (!g_IsNT)
{
if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorCode, 0, (LPTSTR) &msgBuf, 0, NULL) == 0)
return false;
message = GetUnicodeString((LPCTSTR)msgBuf);
}
else
#endif
{
if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
return false;
message = (LPCWSTR)msgBuf;
}
::LocalFree(msgBuf);
return true;
}
UString MyFormatMessage(DWORD errorCode)
{
UString m;
if (!MyFormatMessage(errorCode, m) || m.IsEmpty())
{
char s[16];
for (int i = 0; i < 8; i++)
{
unsigned t = errorCode & 0xF;
errorCode >>= 4;
s[7 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
}
s[8] = 0;
m += "Error #";
m += s;
}
else if (m.Len() >= 2
&& m[m.Len() - 1] == 0x0A
&& m[m.Len() - 2] == 0x0D)
m.DeleteFrom(m.Len() - 2);
return m;
}
}}
// Windows/ErrorMsg.h
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "ErrorMsg.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NError {
static bool MyFormatMessage(DWORD errorCode, UString &message)
{
LPVOID msgBuf;
#ifndef _UNICODE
if (!g_IsNT)
{
if (::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorCode, 0, (LPTSTR) &msgBuf, 0, NULL) == 0)
return false;
message = GetUnicodeString((LPCTSTR)msgBuf);
}
else
#endif
{
if (::FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, errorCode, 0, (LPWSTR) &msgBuf, 0, NULL) == 0)
return false;
message = (LPCWSTR)msgBuf;
}
::LocalFree(msgBuf);
return true;
}
UString MyFormatMessage(DWORD errorCode)
{
UString m;
if (!MyFormatMessage(errorCode, m) || m.IsEmpty())
{
char s[16];
for (int i = 0; i < 8; i++)
{
unsigned t = errorCode & 0xF;
errorCode >>= 4;
s[7 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
}
s[8] = 0;
m += "Error #";
m += s;
}
else if (m.Len() >= 2
&& m[m.Len() - 1] == 0x0A
&& m[m.Len() - 2] == 0x0D)
m.DeleteFrom(m.Len() - 2);
return m;
}
}}

30
CPP/Windows/ErrorMsg.h
View File

@@ -1,15 +1,15 @@
// Windows/ErrorMsg.h
#ifndef __WINDOWS_ERROR_MSG_H
#define __WINDOWS_ERROR_MSG_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NError {
UString MyFormatMessage(DWORD errorCode);
}}
#endif
// Windows/ErrorMsg.h
#ifndef __WINDOWS_ERROR_MSG_H
#define __WINDOWS_ERROR_MSG_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NError {
UString MyFormatMessage(DWORD errorCode);
}}
#endif

1428
CPP/Windows/FileDir.cpp
View File

File diff suppressed because it is too large Load Diff

234
CPP/Windows/FileDir.h
View File

@@ -1,117 +1,117 @@
// Windows/FileDir.h
#ifndef __WINDOWS_FILE_DIR_H
#define __WINDOWS_FILE_DIR_H
#include "../Common/MyString.h"
#include "FileIO.h"
namespace NWindows {
namespace NFile {
namespace NDir {
bool GetWindowsDir(FString &path);
bool GetSystemDir(FString &path);
bool SetDirTime(CFSTR path, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime);
bool SetFileAttrib(CFSTR path, DWORD attrib);
/*
Some programs store posix attributes in high 16 bits of windows attributes field.
Also some programs use additional flag markers: 0x8000 or 0x4000.
SetFileAttrib_PosixHighDetect() tries to detect posix field, and it extracts only attribute
bits that are related to current system only.
*/
bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib);
bool MyMoveFile(CFSTR existFileName, CFSTR newFileName);
#ifndef UNDER_CE
bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName);
#endif
bool RemoveDir(CFSTR path);
bool CreateDir(CFSTR path);
/* CreateComplexDir returns true, if directory can contain files after the call (two cases):
1) the directory already exists (network shares and drive paths are supported)
2) the directory was created
path can be WITH or WITHOUT trailing path separator. */
bool CreateComplexDir(CFSTR path);
bool DeleteFileAlways(CFSTR name);
bool RemoveDirWithSubItems(const FString &path);
bool MyGetFullPathName(CFSTR path, FString &resFullPath);
bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix);
#ifndef UNDER_CE
bool SetCurrentDir(CFSTR path);
bool GetCurrentDir(FString &resultPath);
#endif
bool MyGetTempPath(FString &resultPath);
class CTempFile
{
bool _mustBeDeleted;
FString _path;
void DisableDeleting() { _mustBeDeleted = false; }
public:
CTempFile(): _mustBeDeleted(false) {}
~CTempFile() { Remove(); }
const FString &GetPath() const { return _path; }
bool Create(CFSTR pathPrefix, NIO::COutFile *outFile); // pathPrefix is not folder prefix
bool CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile);
bool Remove();
bool MoveTo(CFSTR name, bool deleteDestBefore);
};
class CTempDir
{
bool _mustBeDeleted;
FString _path;
public:
CTempDir(): _mustBeDeleted(false) {}
~CTempDir() { Remove(); }
const FString &GetPath() const { return _path; }
void DisableDeleting() { _mustBeDeleted = false; }
bool Create(CFSTR namePrefix) ;
bool Remove();
};
#if !defined(UNDER_CE)
class CCurrentDirRestorer
{
FString _path;
public:
bool NeedRestore;
CCurrentDirRestorer(): NeedRestore(true)
{
GetCurrentDir(_path);
}
~CCurrentDirRestorer()
{
if (!NeedRestore)
return;
FString s;
if (GetCurrentDir(s))
if (s != _path)
SetCurrentDir(_path);
}
};
#endif
}}}
#endif
// Windows/FileDir.h
#ifndef __WINDOWS_FILE_DIR_H
#define __WINDOWS_FILE_DIR_H
#include "../Common/MyString.h"
#include "FileIO.h"
namespace NWindows {
namespace NFile {
namespace NDir {
bool GetWindowsDir(FString &path);
bool GetSystemDir(FString &path);
bool SetDirTime(CFSTR path, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime);
bool SetFileAttrib(CFSTR path, DWORD attrib);
/*
Some programs store posix attributes in high 16 bits of windows attributes field.
Also some programs use additional flag markers: 0x8000 or 0x4000.
SetFileAttrib_PosixHighDetect() tries to detect posix field, and it extracts only attribute
bits that are related to current system only.
*/
bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib);
bool MyMoveFile(CFSTR existFileName, CFSTR newFileName);
#ifndef UNDER_CE
bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName);
#endif
bool RemoveDir(CFSTR path);
bool CreateDir(CFSTR path);
/* CreateComplexDir returns true, if directory can contain files after the call (two cases):
1) the directory already exists (network shares and drive paths are supported)
2) the directory was created
path can be WITH or WITHOUT trailing path separator. */
bool CreateComplexDir(CFSTR path);
bool DeleteFileAlways(CFSTR name);
bool RemoveDirWithSubItems(const FString &path);
bool MyGetFullPathName(CFSTR path, FString &resFullPath);
bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName);
bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix);
#ifndef UNDER_CE
bool SetCurrentDir(CFSTR path);
bool GetCurrentDir(FString &resultPath);
#endif
bool MyGetTempPath(FString &resultPath);
class CTempFile
{
bool _mustBeDeleted;
FString _path;
void DisableDeleting() { _mustBeDeleted = false; }
public:
CTempFile(): _mustBeDeleted(false) {}
~CTempFile() { Remove(); }
const FString &GetPath() const { return _path; }
bool Create(CFSTR pathPrefix, NIO::COutFile *outFile); // pathPrefix is not folder prefix
bool CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile);
bool Remove();
bool MoveTo(CFSTR name, bool deleteDestBefore);
};
class CTempDir
{
bool _mustBeDeleted;
FString _path;
public:
CTempDir(): _mustBeDeleted(false) {}
~CTempDir() { Remove(); }
const FString &GetPath() const { return _path; }
void DisableDeleting() { _mustBeDeleted = false; }
bool Create(CFSTR namePrefix) ;
bool Remove();
};
#if !defined(UNDER_CE)
class CCurrentDirRestorer
{
FString _path;
public:
bool NeedRestore;
CCurrentDirRestorer(): NeedRestore(true)
{
GetCurrentDir(_path);
}
~CCurrentDirRestorer()
{
if (!NeedRestore)
return;
FString s;
if (GetCurrentDir(s))
if (s != _path)
SetCurrentDir(_path);
}
};
#endif
}}}
#endif

1498
CPP/Windows/FileFind.cpp
View File

File diff suppressed because it is too large Load Diff

322
CPP/Windows/FileFind.h
View File

@@ -1,161 +1,161 @@
// Windows/FileFind.h
#ifndef __WINDOWS_FILE_FIND_H
#define __WINDOWS_FILE_FIND_H
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows {
namespace NFile {
namespace NFind {
namespace NAttributes
{
inline bool IsReadOnly(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_READONLY) != 0; }
inline bool IsHidden(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_HIDDEN) != 0; }
inline bool IsSystem(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_SYSTEM) != 0; }
inline bool IsDir(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0; }
inline bool IsArchived(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ARCHIVE) != 0; }
inline bool IsCompressed(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_COMPRESSED) != 0; }
inline bool IsEncrypted(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ENCRYPTED) != 0; }
}
class CFileInfoBase
{
bool MatchesMask(UINT32 mask) const { return ((Attrib & mask) != 0); }
public:
UInt64 Size;
FILETIME CTime;
FILETIME ATime;
FILETIME MTime;
DWORD Attrib;
bool IsAltStream;
bool IsDevice;
/*
#ifdef UNDER_CE
DWORD ObjectID;
#else
UINT32 ReparseTag;
#endif
*/
CFileInfoBase() { ClearBase(); }
void ClearBase() throw();
void SetAsDir() { Attrib = FILE_ATTRIBUTE_DIRECTORY; }
bool IsArchived() const { return MatchesMask(FILE_ATTRIBUTE_ARCHIVE); }
bool IsCompressed() const { return MatchesMask(FILE_ATTRIBUTE_COMPRESSED); }
bool IsDir() const { return MatchesMask(FILE_ATTRIBUTE_DIRECTORY); }
bool IsEncrypted() const { return MatchesMask(FILE_ATTRIBUTE_ENCRYPTED); }
bool IsHidden() const { return MatchesMask(FILE_ATTRIBUTE_HIDDEN); }
bool IsNormal() const { return MatchesMask(FILE_ATTRIBUTE_NORMAL); }
bool IsOffline() const { return MatchesMask(FILE_ATTRIBUTE_OFFLINE); }
bool IsReadOnly() const { return MatchesMask(FILE_ATTRIBUTE_READONLY); }
bool HasReparsePoint() const { return MatchesMask(FILE_ATTRIBUTE_REPARSE_POINT); }
bool IsSparse() const { return MatchesMask(FILE_ATTRIBUTE_SPARSE_FILE); }
bool IsSystem() const { return MatchesMask(FILE_ATTRIBUTE_SYSTEM); }
bool IsTemporary() const { return MatchesMask(FILE_ATTRIBUTE_TEMPORARY); }
};
struct CFileInfo: public CFileInfoBase
{
FString Name;
#if defined(_WIN32) && !defined(UNDER_CE)
// FString ShortName;
#endif
bool IsDots() const throw();
bool Find(CFSTR path);
};
class CFindFileBase
{
protected:
HANDLE _handle;
public:
bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE; }
CFindFileBase(): _handle(INVALID_HANDLE_VALUE) {}
~CFindFileBase() { Close(); }
bool Close() throw();
};
class CFindFile: public CFindFileBase
{
public:
bool FindFirst(CFSTR wildcard, CFileInfo &fileInfo);
bool FindNext(CFileInfo &fileInfo);
};
#if defined(_WIN32) && !defined(UNDER_CE)
struct CStreamInfo
{
UString Name;
UInt64 Size;
UString GetReducedName() const; // returns ":Name"
// UString GetReducedName2() const; // returns "Name"
bool IsMainStream() const throw();
};
class CFindStream: public CFindFileBase
{
public:
bool FindFirst(CFSTR filePath, CStreamInfo &streamInfo);
bool FindNext(CStreamInfo &streamInfo);
};
class CStreamEnumerator
{
CFindStream _find;
FString _filePath;
bool NextAny(CFileInfo &fileInfo);
public:
CStreamEnumerator(const FString &filePath): _filePath(filePath) {}
bool Next(CStreamInfo &streamInfo, bool &found);
};
#endif
bool DoesFileExist(CFSTR name);
bool DoesDirExist(CFSTR name);
bool DoesFileOrDirExist(CFSTR name);
DWORD GetFileAttrib(CFSTR path);
class CEnumerator
{
CFindFile _findFile;
FString _wildcard;
bool NextAny(CFileInfo &fileInfo);
public:
void SetDirPrefix(const FString &dirPrefix);
bool Next(CFileInfo &fileInfo);
bool Next(CFileInfo &fileInfo, bool &found);
};
class CFindChangeNotification
{
HANDLE _handle;
public:
operator HANDLE () { return _handle; }
bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE && _handle != 0; }
CFindChangeNotification(): _handle(INVALID_HANDLE_VALUE) {}
~CFindChangeNotification() { Close(); }
bool Close() throw();
HANDLE FindFirst(CFSTR pathName, bool watchSubtree, DWORD notifyFilter);
bool FindNext() { return BOOLToBool(::FindNextChangeNotification(_handle)); }
};
#ifndef UNDER_CE
bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings);
#endif
}}}
#endif
// Windows/FileFind.h
#ifndef __WINDOWS_FILE_FIND_H
#define __WINDOWS_FILE_FIND_H
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows {
namespace NFile {
namespace NFind {
namespace NAttributes
{
inline bool IsReadOnly(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_READONLY) != 0; }
inline bool IsHidden(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_HIDDEN) != 0; }
inline bool IsSystem(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_SYSTEM) != 0; }
inline bool IsDir(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0; }
inline bool IsArchived(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ARCHIVE) != 0; }
inline bool IsCompressed(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_COMPRESSED) != 0; }
inline bool IsEncrypted(DWORD attrib) { return (attrib & FILE_ATTRIBUTE_ENCRYPTED) != 0; }
}
class CFileInfoBase
{
bool MatchesMask(UINT32 mask) const { return ((Attrib & mask) != 0); }
public:
UInt64 Size;
FILETIME CTime;
FILETIME ATime;
FILETIME MTime;
DWORD Attrib;
bool IsAltStream;
bool IsDevice;
/*
#ifdef UNDER_CE
DWORD ObjectID;
#else
UINT32 ReparseTag;
#endif
*/
CFileInfoBase() { ClearBase(); }
void ClearBase() throw();
void SetAsDir() { Attrib = FILE_ATTRIBUTE_DIRECTORY; }
bool IsArchived() const { return MatchesMask(FILE_ATTRIBUTE_ARCHIVE); }
bool IsCompressed() const { return MatchesMask(FILE_ATTRIBUTE_COMPRESSED); }
bool IsDir() const { return MatchesMask(FILE_ATTRIBUTE_DIRECTORY); }
bool IsEncrypted() const { return MatchesMask(FILE_ATTRIBUTE_ENCRYPTED); }
bool IsHidden() const { return MatchesMask(FILE_ATTRIBUTE_HIDDEN); }
bool IsNormal() const { return MatchesMask(FILE_ATTRIBUTE_NORMAL); }
bool IsOffline() const { return MatchesMask(FILE_ATTRIBUTE_OFFLINE); }
bool IsReadOnly() const { return MatchesMask(FILE_ATTRIBUTE_READONLY); }
bool HasReparsePoint() const { return MatchesMask(FILE_ATTRIBUTE_REPARSE_POINT); }
bool IsSparse() const { return MatchesMask(FILE_ATTRIBUTE_SPARSE_FILE); }
bool IsSystem() const { return MatchesMask(FILE_ATTRIBUTE_SYSTEM); }
bool IsTemporary() const { return MatchesMask(FILE_ATTRIBUTE_TEMPORARY); }
};
struct CFileInfo: public CFileInfoBase
{
FString Name;
#if defined(_WIN32) && !defined(UNDER_CE)
// FString ShortName;
#endif
bool IsDots() const throw();
bool Find(CFSTR path);
};
class CFindFileBase
{
protected:
HANDLE _handle;
public:
bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE; }
CFindFileBase(): _handle(INVALID_HANDLE_VALUE) {}
~CFindFileBase() { Close(); }
bool Close() throw();
};
class CFindFile: public CFindFileBase
{
public:
bool FindFirst(CFSTR wildcard, CFileInfo &fileInfo);
bool FindNext(CFileInfo &fileInfo);
};
#if defined(_WIN32) && !defined(UNDER_CE)
struct CStreamInfo
{
UString Name;
UInt64 Size;
UString GetReducedName() const; // returns ":Name"
// UString GetReducedName2() const; // returns "Name"
bool IsMainStream() const throw();
};
class CFindStream: public CFindFileBase
{
public:
bool FindFirst(CFSTR filePath, CStreamInfo &streamInfo);
bool FindNext(CStreamInfo &streamInfo);
};
class CStreamEnumerator
{
CFindStream _find;
FString _filePath;
bool NextAny(CFileInfo &fileInfo);
public:
CStreamEnumerator(const FString &filePath): _filePath(filePath) {}
bool Next(CStreamInfo &streamInfo, bool &found);
};
#endif
bool DoesFileExist(CFSTR name);
bool DoesDirExist(CFSTR name);
bool DoesFileOrDirExist(CFSTR name);
DWORD GetFileAttrib(CFSTR path);
class CEnumerator
{
CFindFile _findFile;
FString _wildcard;
bool NextAny(CFileInfo &fileInfo);
public:
void SetDirPrefix(const FString &dirPrefix);
bool Next(CFileInfo &fileInfo);
bool Next(CFileInfo &fileInfo, bool &found);
};
class CFindChangeNotification
{
HANDLE _handle;
public:
operator HANDLE () { return _handle; }
bool IsHandleAllocated() const { return _handle != INVALID_HANDLE_VALUE && _handle != 0; }
CFindChangeNotification(): _handle(INVALID_HANDLE_VALUE) {}
~CFindChangeNotification() { Close(); }
bool Close() throw();
HANDLE FindFirst(CFSTR pathName, bool watchSubtree, DWORD notifyFilter);
bool FindNext() { return BOOLToBool(::FindNextChangeNotification(_handle)); }
};
#ifndef UNDER_CE
bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings);
#endif
}}}
#endif

864
CPP/Windows/FileIO.cpp
View File

@@ -1,432 +1,432 @@
// Windows/FileIO.cpp
#include "StdAfx.h"
#ifdef SUPPORT_DEVICE_FILE
#include "../../C/Alloc.h"
#endif
#include "FileIO.h"
#include "FileName.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
using namespace NWindows;
using namespace NFile;
using namespace NName;
namespace NWindows {
namespace NFile {
#ifdef SUPPORT_DEVICE_FILE
namespace NSystem
{
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}
#endif
namespace NIO {
/*
WinXP-64 CreateFile():
"" - ERROR_PATH_NOT_FOUND
:stream - OK
.:stream - ERROR_PATH_NOT_FOUND
.\:stream - OK
folder\:stream - ERROR_INVALID_NAME
folder:stream - OK
c:\:stream - OK
c::stream - ERROR_INVALID_NAME, if current dir is NOT ROOT ( c:\dir1 )
c::stream - OK, if current dir is ROOT ( c:\ )
*/
bool CFileBase::Create(CFSTR path, DWORD desiredAccess,
DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{
if (!Close())
return false;
#ifdef SUPPORT_DEVICE_FILE
IsDeviceFile = false;
#endif
#ifndef _UNICODE
if (!g_IsNT)
{
_handle = ::CreateFile(fs2fas(path), desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
}
else
#endif
{
IF_USE_MAIN_PATH
_handle = ::CreateFileW(fs2us(path), desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
#ifdef WIN_LONG_PATH
if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
{
UString superPath;
if (GetSuperPath(path, superPath, USE_MAIN_PATH))
_handle = ::CreateFileW(superPath, desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
}
#endif
}
return (_handle != INVALID_HANDLE_VALUE);
}
bool CFileBase::Close() throw()
{
if (_handle == INVALID_HANDLE_VALUE)
return true;
if (!::CloseHandle(_handle))
return false;
_handle = INVALID_HANDLE_VALUE;
return true;
}
bool CFileBase::GetPosition(UInt64 &position) const throw()
{
return Seek(0, FILE_CURRENT, position);
}
bool CFileBase::GetLength(UInt64 &length) const throw()
{
#ifdef SUPPORT_DEVICE_FILE
if (IsDeviceFile && SizeDefined)
{
length = Size;
return true;
}
#endif
DWORD sizeHigh;
DWORD sizeLow = ::GetFileSize(_handle, &sizeHigh);
if (sizeLow == 0xFFFFFFFF)
if (::GetLastError() != NO_ERROR)
return false;
length = (((UInt64)sizeHigh) << 32) + sizeLow;
return true;
}
bool CFileBase::Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw()
{
#ifdef SUPPORT_DEVICE_FILE
if (IsDeviceFile && SizeDefined && moveMethod == FILE_END)
{
distanceToMove += Size;
moveMethod = FILE_BEGIN;
}
#endif
LONG high = (LONG)(distanceToMove >> 32);
DWORD low = ::SetFilePointer(_handle, (LONG)(distanceToMove & 0xFFFFFFFF), &high, moveMethod);
if (low == 0xFFFFFFFF)
if (::GetLastError() != NO_ERROR)
return false;
newPosition = (((UInt64)(UInt32)high) << 32) + low;
return true;
}
bool CFileBase::Seek(UInt64 position, UInt64 &newPosition) const throw()
{
return Seek(position, FILE_BEGIN, newPosition);
}
bool CFileBase::SeekToBegin() const throw()
{
UInt64 newPosition;
return Seek(0, newPosition);
}
bool CFileBase::SeekToEnd(UInt64 &newPosition) const throw()
{
return Seek(0, FILE_END, newPosition);
}
// ---------- CInFile ---------
#ifdef SUPPORT_DEVICE_FILE
void CInFile::CorrectDeviceSize()
{
// maybe we must decrease kClusterSize to 1 << 12, if we want correct size at tail
static const UInt32 kClusterSize = 1 << 14;
UInt64 pos = Size & ~(UInt64)(kClusterSize - 1);
UInt64 realNewPosition;
if (!Seek(pos, realNewPosition))
return;
Byte *buf = (Byte *)MidAlloc(kClusterSize);
bool needbackward = true;
for (;;)
{
UInt32 processed = 0;
// up test is slow for "PhysicalDrive".
// processed size for latest block for "PhysicalDrive0" is 0.
if (!Read1(buf, kClusterSize, processed))
break;
if (processed == 0)
break;
needbackward = false;
Size = pos + processed;
if (processed != kClusterSize)
break;
pos += kClusterSize;
}
if (needbackward && pos != 0)
{
pos -= kClusterSize;
for (;;)
{
// break;
if (!Seek(pos, realNewPosition))
break;
if (!buf)
{
buf = (Byte *)MidAlloc(kClusterSize);
if (!buf)
break;
}
UInt32 processed = 0;
// that code doesn't work for "PhysicalDrive0"
if (!Read1(buf, kClusterSize, processed))
break;
if (processed != 0)
{
Size = pos + processed;
break;
}
if (pos == 0)
break;
pos -= kClusterSize;
}
}
MidFree(buf);
}
void CInFile::CalcDeviceSize(CFSTR s)
{
SizeDefined = false;
Size = 0;
if (_handle == INVALID_HANDLE_VALUE || !IsDeviceFile)
return;
#ifdef UNDER_CE
SizeDefined = true;
Size = 128 << 20;
#else
PARTITION_INFORMATION partInfo;
bool needCorrectSize = true;
/*
WinXP 64-bit:
HDD \\.\PhysicalDrive0 (MBR):
GetPartitionInfo == GeometryEx : corrrect size? (includes tail)
Geometry : smaller than GeometryEx (no tail, maybe correct too?)
MyGetDiskFreeSpace : FAIL
Size correction is slow and block size (kClusterSize) must be small?
HDD partition \\.\N: (NTFS):
MyGetDiskFreeSpace : Size of NTFS clusters. Same size can be calculated after correction
GetPartitionInfo : size of partition data: NTFS clusters + TAIL; TAIL contains extra empty sectors and copy of first sector of NTFS
Geometry / CdRomGeometry / GeometryEx : size of HDD (not that partition)
CD-ROM drive (ISO):
MyGetDiskFreeSpace : correct size. Same size can be calculated after correction
Geometry == CdRomGeometry : smaller than corrrect size
GetPartitionInfo == GeometryEx : larger than corrrect size
Floppy \\.\a: (FAT):
Geometry : correct size.
CdRomGeometry / GeometryEx / GetPartitionInfo / MyGetDiskFreeSpace - FAIL
correction works OK for FAT.
correction works OK for non-FAT, if kClusterSize = 512.
*/
if (GetPartitionInfo(&partInfo))
{
Size = partInfo.PartitionLength.QuadPart;
SizeDefined = true;
needCorrectSize = false;
if ((s)[0] == '\\' && (s)[1] == '\\' && (s)[2] == '.' && (s)[3] == '\\' && (s)[5] == ':' && (s)[6] == 0)
{
FChar path[4] = { s[4], ':', '\\', 0 };
UInt64 clusterSize, totalSize, freeSize;
if (NSystem::MyGetDiskFreeSpace(path, clusterSize, totalSize, freeSize))
Size = totalSize;
else
needCorrectSize = true;
}
}
if (!SizeDefined)
{
my_DISK_GEOMETRY_EX geomEx;
SizeDefined = GetGeometryEx(&geomEx);
if (SizeDefined)
Size = geomEx.DiskSize.QuadPart;
else
{
DISK_GEOMETRY geom;
SizeDefined = GetGeometry(&geom);
if (!SizeDefined)
SizeDefined = GetCdRomGeometry(&geom);
if (SizeDefined)
Size = geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;
}
}
if (needCorrectSize && SizeDefined && Size != 0)
{
CorrectDeviceSize();
SeekToBegin();
}
// SeekToBegin();
#endif
}
// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&
#define MY_DEVICE_EXTRA_CODE \
IsDeviceFile = IsDevicePath(fileName); \
CalcDeviceSize(fileName);
#else
#define MY_DEVICE_EXTRA_CODE
#endif
bool CInFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{
bool res = Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes);
MY_DEVICE_EXTRA_CODE
return res;
}
bool CInFile::OpenShared(CFSTR fileName, bool shareForWrite)
{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
bool CInFile::Open(CFSTR fileName)
{ return OpenShared(fileName, false); }
// ReadFile and WriteFile functions in Windows have BUG:
// If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
// from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
// (Insufficient system resources exist to complete the requested service).
// Probably in some version of Windows there are problems with other sizes:
// for 32 MB (maybe also for 16 MB).
// And message can be "Network connection was lost"
static UInt32 kChunkSizeMax = (1 << 22);
bool CInFile::Read1(void *data, UInt32 size, UInt32 &processedSize) throw()
{
DWORD processedLoc = 0;
bool res = BOOLToBool(::ReadFile(_handle, data, size, &processedLoc, NULL));
processedSize = (UInt32)processedLoc;
return res;
}
bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw()
{
if (size > kChunkSizeMax)
size = kChunkSizeMax;
return Read1(data, size, processedSize);
}
bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize) throw()
{
processedSize = 0;
do
{
UInt32 processedLoc = 0;
bool res = ReadPart(data, size, processedLoc);
processedSize += processedLoc;
if (!res)
return false;
if (processedLoc == 0)
return true;
data = (void *)((unsigned char *)data + processedLoc);
size -= processedLoc;
}
while (size > 0);
return true;
}
// ---------- COutFile ---------
static inline DWORD GetCreationDisposition(bool createAlways)
{ return createAlways? CREATE_ALWAYS: CREATE_NEW; }
bool COutFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{ return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }
bool COutFile::Open(CFSTR fileName, DWORD creationDisposition)
{ return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
bool COutFile::Create(CFSTR fileName, bool createAlways)
{ return Open(fileName, GetCreationDisposition(createAlways)); }
bool COutFile::CreateAlways(CFSTR fileName, DWORD flagsAndAttributes)
{ return Open(fileName, FILE_SHARE_READ, GetCreationDisposition(true), flagsAndAttributes); }
bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw()
{ return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }
bool COutFile::SetMTime(const FILETIME *mTime) throw() { return SetTime(NULL, NULL, mTime); }
bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw()
{
if (size > kChunkSizeMax)
size = kChunkSizeMax;
DWORD processedLoc = 0;
bool res = BOOLToBool(::WriteFile(_handle, data, size, &processedLoc, NULL));
processedSize = (UInt32)processedLoc;
return res;
}
bool COutFile::Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
{
processedSize = 0;
do
{
UInt32 processedLoc = 0;
bool res = WritePart(data, size, processedLoc);
processedSize += processedLoc;
if (!res)
return false;
if (processedLoc == 0)
return true;
data = (const void *)((const unsigned char *)data + processedLoc);
size -= processedLoc;
}
while (size > 0);
return true;
}
bool COutFile::SetEndOfFile() throw() { return BOOLToBool(::SetEndOfFile(_handle)); }
bool COutFile::SetLength(UInt64 length) throw()
{
UInt64 newPosition;
if (!Seek(length, newPosition))
return false;
if (newPosition != length)
return false;
return SetEndOfFile();
}
}}}
// Windows/FileIO.cpp
#include "StdAfx.h"
#ifdef SUPPORT_DEVICE_FILE
#include "../../C/Alloc.h"
#endif
#include "FileIO.h"
#include "FileName.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
using namespace NWindows;
using namespace NFile;
using namespace NName;
namespace NWindows {
namespace NFile {
#ifdef SUPPORT_DEVICE_FILE
namespace NSystem
{
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}
#endif
namespace NIO {
/*
WinXP-64 CreateFile():
"" - ERROR_PATH_NOT_FOUND
:stream - OK
.:stream - ERROR_PATH_NOT_FOUND
.\:stream - OK
folder\:stream - ERROR_INVALID_NAME
folder:stream - OK
c:\:stream - OK
c::stream - ERROR_INVALID_NAME, if current dir is NOT ROOT ( c:\dir1 )
c::stream - OK, if current dir is ROOT ( c:\ )
*/
bool CFileBase::Create(CFSTR path, DWORD desiredAccess,
DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{
if (!Close())
return false;
#ifdef SUPPORT_DEVICE_FILE
IsDeviceFile = false;
#endif
#ifndef _UNICODE
if (!g_IsNT)
{
_handle = ::CreateFile(fs2fas(path), desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
}
else
#endif
{
IF_USE_MAIN_PATH
_handle = ::CreateFileW(fs2us(path), desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
#ifdef WIN_LONG_PATH
if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
{
UString superPath;
if (GetSuperPath(path, superPath, USE_MAIN_PATH))
_handle = ::CreateFileW(superPath, desiredAccess, shareMode,
(LPSECURITY_ATTRIBUTES)NULL, creationDisposition, flagsAndAttributes, (HANDLE)NULL);
}
#endif
}
return (_handle != INVALID_HANDLE_VALUE);
}
bool CFileBase::Close() throw()
{
if (_handle == INVALID_HANDLE_VALUE)
return true;
if (!::CloseHandle(_handle))
return false;
_handle = INVALID_HANDLE_VALUE;
return true;
}
bool CFileBase::GetPosition(UInt64 &position) const throw()
{
return Seek(0, FILE_CURRENT, position);
}
bool CFileBase::GetLength(UInt64 &length) const throw()
{
#ifdef SUPPORT_DEVICE_FILE
if (IsDeviceFile && SizeDefined)
{
length = Size;
return true;
}
#endif
DWORD sizeHigh;
DWORD sizeLow = ::GetFileSize(_handle, &sizeHigh);
if (sizeLow == 0xFFFFFFFF)
if (::GetLastError() != NO_ERROR)
return false;
length = (((UInt64)sizeHigh) << 32) + sizeLow;
return true;
}
bool CFileBase::Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw()
{
#ifdef SUPPORT_DEVICE_FILE
if (IsDeviceFile && SizeDefined && moveMethod == FILE_END)
{
distanceToMove += Size;
moveMethod = FILE_BEGIN;
}
#endif
LONG high = (LONG)(distanceToMove >> 32);
DWORD low = ::SetFilePointer(_handle, (LONG)(distanceToMove & 0xFFFFFFFF), &high, moveMethod);
if (low == 0xFFFFFFFF)
if (::GetLastError() != NO_ERROR)
return false;
newPosition = (((UInt64)(UInt32)high) << 32) + low;
return true;
}
bool CFileBase::Seek(UInt64 position, UInt64 &newPosition) const throw()
{
return Seek(position, FILE_BEGIN, newPosition);
}
bool CFileBase::SeekToBegin() const throw()
{
UInt64 newPosition;
return Seek(0, newPosition);
}
bool CFileBase::SeekToEnd(UInt64 &newPosition) const throw()
{
return Seek(0, FILE_END, newPosition);
}
// ---------- CInFile ---------
#ifdef SUPPORT_DEVICE_FILE
void CInFile::CorrectDeviceSize()
{
// maybe we must decrease kClusterSize to 1 << 12, if we want correct size at tail
static const UInt32 kClusterSize = 1 << 14;
UInt64 pos = Size & ~(UInt64)(kClusterSize - 1);
UInt64 realNewPosition;
if (!Seek(pos, realNewPosition))
return;
Byte *buf = (Byte *)MidAlloc(kClusterSize);
bool needbackward = true;
for (;;)
{
UInt32 processed = 0;
// up test is slow for "PhysicalDrive".
// processed size for latest block for "PhysicalDrive0" is 0.
if (!Read1(buf, kClusterSize, processed))
break;
if (processed == 0)
break;
needbackward = false;
Size = pos + processed;
if (processed != kClusterSize)
break;
pos += kClusterSize;
}
if (needbackward && pos != 0)
{
pos -= kClusterSize;
for (;;)
{
// break;
if (!Seek(pos, realNewPosition))
break;
if (!buf)
{
buf = (Byte *)MidAlloc(kClusterSize);
if (!buf)
break;
}
UInt32 processed = 0;
// that code doesn't work for "PhysicalDrive0"
if (!Read1(buf, kClusterSize, processed))
break;
if (processed != 0)
{
Size = pos + processed;
break;
}
if (pos == 0)
break;
pos -= kClusterSize;
}
}
MidFree(buf);
}
void CInFile::CalcDeviceSize(CFSTR s)
{
SizeDefined = false;
Size = 0;
if (_handle == INVALID_HANDLE_VALUE || !IsDeviceFile)
return;
#ifdef UNDER_CE
SizeDefined = true;
Size = 128 << 20;
#else
PARTITION_INFORMATION partInfo;
bool needCorrectSize = true;
/*
WinXP 64-bit:
HDD \\.\PhysicalDrive0 (MBR):
GetPartitionInfo == GeometryEx : corrrect size? (includes tail)
Geometry : smaller than GeometryEx (no tail, maybe correct too?)
MyGetDiskFreeSpace : FAIL
Size correction is slow and block size (kClusterSize) must be small?
HDD partition \\.\N: (NTFS):
MyGetDiskFreeSpace : Size of NTFS clusters. Same size can be calculated after correction
GetPartitionInfo : size of partition data: NTFS clusters + TAIL; TAIL contains extra empty sectors and copy of first sector of NTFS
Geometry / CdRomGeometry / GeometryEx : size of HDD (not that partition)
CD-ROM drive (ISO):
MyGetDiskFreeSpace : correct size. Same size can be calculated after correction
Geometry == CdRomGeometry : smaller than corrrect size
GetPartitionInfo == GeometryEx : larger than corrrect size
Floppy \\.\a: (FAT):
Geometry : correct size.
CdRomGeometry / GeometryEx / GetPartitionInfo / MyGetDiskFreeSpace - FAIL
correction works OK for FAT.
correction works OK for non-FAT, if kClusterSize = 512.
*/
if (GetPartitionInfo(&partInfo))
{
Size = partInfo.PartitionLength.QuadPart;
SizeDefined = true;
needCorrectSize = false;
if ((s)[0] == '\\' && (s)[1] == '\\' && (s)[2] == '.' && (s)[3] == '\\' && (s)[5] == ':' && (s)[6] == 0)
{
FChar path[4] = { s[4], ':', '\\', 0 };
UInt64 clusterSize, totalSize, freeSize;
if (NSystem::MyGetDiskFreeSpace(path, clusterSize, totalSize, freeSize))
Size = totalSize;
else
needCorrectSize = true;
}
}
if (!SizeDefined)
{
my_DISK_GEOMETRY_EX geomEx;
SizeDefined = GetGeometryEx(&geomEx);
if (SizeDefined)
Size = geomEx.DiskSize.QuadPart;
else
{
DISK_GEOMETRY geom;
SizeDefined = GetGeometry(&geom);
if (!SizeDefined)
SizeDefined = GetCdRomGeometry(&geom);
if (SizeDefined)
Size = geom.Cylinders.QuadPart * geom.TracksPerCylinder * geom.SectorsPerTrack * geom.BytesPerSector;
}
}
if (needCorrectSize && SizeDefined && Size != 0)
{
CorrectDeviceSize();
SeekToBegin();
}
// SeekToBegin();
#endif
}
// ((desiredAccess & (FILE_WRITE_DATA | FILE_APPEND_DATA | GENERIC_WRITE)) == 0 &&
#define MY_DEVICE_EXTRA_CODE \
IsDeviceFile = IsDevicePath(fileName); \
CalcDeviceSize(fileName);
#else
#define MY_DEVICE_EXTRA_CODE
#endif
bool CInFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{
bool res = Create(fileName, GENERIC_READ, shareMode, creationDisposition, flagsAndAttributes);
MY_DEVICE_EXTRA_CODE
return res;
}
bool CInFile::OpenShared(CFSTR fileName, bool shareForWrite)
{ return Open(fileName, FILE_SHARE_READ | (shareForWrite ? FILE_SHARE_WRITE : 0), OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL); }
bool CInFile::Open(CFSTR fileName)
{ return OpenShared(fileName, false); }
// ReadFile and WriteFile functions in Windows have BUG:
// If you Read or Write 64MB or more (probably min_failure_size = 64MB - 32KB + 1)
// from/to Network file, it returns ERROR_NO_SYSTEM_RESOURCES
// (Insufficient system resources exist to complete the requested service).
// Probably in some version of Windows there are problems with other sizes:
// for 32 MB (maybe also for 16 MB).
// And message can be "Network connection was lost"
static UInt32 kChunkSizeMax = (1 << 22);
bool CInFile::Read1(void *data, UInt32 size, UInt32 &processedSize) throw()
{
DWORD processedLoc = 0;
bool res = BOOLToBool(::ReadFile(_handle, data, size, &processedLoc, NULL));
processedSize = (UInt32)processedLoc;
return res;
}
bool CInFile::ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw()
{
if (size > kChunkSizeMax)
size = kChunkSizeMax;
return Read1(data, size, processedSize);
}
bool CInFile::Read(void *data, UInt32 size, UInt32 &processedSize) throw()
{
processedSize = 0;
do
{
UInt32 processedLoc = 0;
bool res = ReadPart(data, size, processedLoc);
processedSize += processedLoc;
if (!res)
return false;
if (processedLoc == 0)
return true;
data = (void *)((unsigned char *)data + processedLoc);
size -= processedLoc;
}
while (size > 0);
return true;
}
// ---------- COutFile ---------
static inline DWORD GetCreationDisposition(bool createAlways)
{ return createAlways? CREATE_ALWAYS: CREATE_NEW; }
bool COutFile::Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes)
{ return CFileBase::Create(fileName, GENERIC_WRITE, shareMode, creationDisposition, flagsAndAttributes); }
bool COutFile::Open(CFSTR fileName, DWORD creationDisposition)
{ return Open(fileName, FILE_SHARE_READ, creationDisposition, FILE_ATTRIBUTE_NORMAL); }
bool COutFile::Create(CFSTR fileName, bool createAlways)
{ return Open(fileName, GetCreationDisposition(createAlways)); }
bool COutFile::CreateAlways(CFSTR fileName, DWORD flagsAndAttributes)
{ return Open(fileName, FILE_SHARE_READ, GetCreationDisposition(true), flagsAndAttributes); }
bool COutFile::SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw()
{ return BOOLToBool(::SetFileTime(_handle, cTime, aTime, mTime)); }
bool COutFile::SetMTime(const FILETIME *mTime) throw() { return SetTime(NULL, NULL, mTime); }
bool COutFile::WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw()
{
if (size > kChunkSizeMax)
size = kChunkSizeMax;
DWORD processedLoc = 0;
bool res = BOOLToBool(::WriteFile(_handle, data, size, &processedLoc, NULL));
processedSize = (UInt32)processedLoc;
return res;
}
bool COutFile::Write(const void *data, UInt32 size, UInt32 &processedSize) throw()
{
processedSize = 0;
do
{
UInt32 processedLoc = 0;
bool res = WritePart(data, size, processedLoc);
processedSize += processedLoc;
if (!res)
return false;
if (processedLoc == 0)
return true;
data = (const void *)((const unsigned char *)data + processedLoc);
size -= processedLoc;
}
while (size > 0);
return true;
}
bool COutFile::SetEndOfFile() throw() { return BOOLToBool(::SetEndOfFile(_handle)); }
bool COutFile::SetLength(UInt64 length) throw()
{
UInt64 newPosition;
if (!Seek(length, newPosition))
return false;
if (newPosition != length)
return false;
return SetEndOfFile();
}
}}}

424
CPP/Windows/FileIO.h
View File

@@ -1,212 +1,212 @@
// Windows/FileIO.h
#ifndef __WINDOWS_FILE_IO_H
#define __WINDOWS_FILE_IO_H
#include "../Common/MyWindows.h"
#if defined(_WIN32) && !defined(UNDER_CE)
#include <winioctl.h>
#endif
#include "../Common/MyString.h"
#include "../Common/MyBuffer.h"
#include "Defs.h"
#define _my_IO_REPARSE_TAG_MOUNT_POINT (0xA0000003L)
#define _my_IO_REPARSE_TAG_SYMLINK (0xA000000CL)
#define _my_SYMLINK_FLAG_RELATIVE 1
#define my_FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER
#define my_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
namespace NWindows {
namespace NFile {
#if defined(_WIN32) && !defined(UNDER_CE)
bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
#endif
struct CReparseShortInfo
{
unsigned Offset;
unsigned Size;
bool Parse(const Byte *p, size_t size);
};
struct CReparseAttr
{
UInt32 Tag;
UInt32 Flags;
UString SubsName;
UString PrintName;
CReparseAttr(): Tag(0), Flags(0) {}
// Parse()
// returns true and (errorCode = 0), if (correct MOUNT_POINT or SYMLINK)
// returns false and (errorCode = ERROR_REPARSE_TAG_MISMATCH), if not (MOUNT_POINT or SYMLINK)
bool Parse(const Byte *p, size_t size, DWORD &errorCode);
bool IsMountPoint() const { return Tag == _my_IO_REPARSE_TAG_MOUNT_POINT; } // it's Junction
bool IsSymLink() const { return Tag == _my_IO_REPARSE_TAG_SYMLINK; }
bool IsRelative() const { return Flags == _my_SYMLINK_FLAG_RELATIVE; }
// bool IsVolume() const;
bool IsOkNamePair() const;
UString GetPath() const;
};
namespace NIO {
bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo = NULL);
bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size);
class CFileBase
{
protected:
HANDLE _handle;
bool Create(CFSTR path, DWORD desiredAccess,
DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
public:
bool DeviceIoControl(DWORD controlCode, LPVOID inBuffer, DWORD inSize,
LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned, LPOVERLAPPED overlapped = NULL) const
{
return BOOLToBool(::DeviceIoControl(_handle, controlCode, inBuffer, inSize,
outBuffer, outSize, bytesReturned, overlapped));
}
bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned) const
{
return DeviceIoControl(controlCode, NULL, 0, outBuffer, outSize, bytesReturned);
}
bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize) const
{
DWORD bytesReturned;
return DeviceIoControlOut(controlCode, outBuffer, outSize, &bytesReturned);
}
public:
#ifdef SUPPORT_DEVICE_FILE
bool IsDeviceFile;
bool SizeDefined;
UInt64 Size; // it can be larger than real available size
#endif
CFileBase(): _handle(INVALID_HANDLE_VALUE) {};
~CFileBase() { Close(); }
bool Close() throw();
bool GetPosition(UInt64 &position) const throw();
bool GetLength(UInt64 &length) const throw();
bool Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw();
bool Seek(UInt64 position, UInt64 &newPosition) const throw();
bool SeekToBegin() const throw();
bool SeekToEnd(UInt64 &newPosition) const throw();
bool GetFileInformation(BY_HANDLE_FILE_INFORMATION *info) const
{ return BOOLToBool(GetFileInformationByHandle(_handle, info)); }
static bool GetFileInformation(CFSTR path, BY_HANDLE_FILE_INFORMATION *info)
{
NIO::CFileBase file;
if (!file.Create(path, 0, FILE_SHARE_READ, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS))
return false;
return file.GetFileInformation(info);
}
};
#ifndef UNDER_CE
#define IOCTL_CDROM_BASE FILE_DEVICE_CD_ROM
#define IOCTL_CDROM_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_CDROM_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS)
// #define IOCTL_CDROM_MEDIA_REMOVAL CTL_CODE(IOCTL_CDROM_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX works since WinXP
#define my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
struct my_DISK_GEOMETRY_EX
{
DISK_GEOMETRY Geometry;
LARGE_INTEGER DiskSize;
BYTE Data[1];
};
#endif
class CInFile: public CFileBase
{
#ifdef SUPPORT_DEVICE_FILE
#ifndef UNDER_CE
bool GetGeometry(DISK_GEOMETRY *res) const
{ return DeviceIoControlOut(IOCTL_DISK_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
bool GetGeometryEx(my_DISK_GEOMETRY_EX *res) const
{ return DeviceIoControlOut(my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, res, sizeof(*res)); }
bool GetCdRomGeometry(DISK_GEOMETRY *res) const
{ return DeviceIoControlOut(IOCTL_CDROM_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
bool GetPartitionInfo(PARTITION_INFORMATION *res)
{ return DeviceIoControlOut(IOCTL_DISK_GET_PARTITION_INFO, LPVOID(res), sizeof(*res)); }
#endif
void CorrectDeviceSize();
void CalcDeviceSize(CFSTR name);
#endif
public:
bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
bool OpenShared(CFSTR fileName, bool shareForWrite);
bool Open(CFSTR fileName);
#ifndef UNDER_CE
bool OpenReparse(CFSTR fileName)
{
// 17.02 fix: to support Windows XP compatibility junctions:
// we use Create() with (desiredAccess = 0) instead of Open() with GENERIC_READ
return
Create(fileName, 0,
// Open(fileName,
FILE_SHARE_READ, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
}
#endif
bool Read1(void *data, UInt32 size, UInt32 &processedSize) throw();
bool ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw();
bool Read(void *data, UInt32 size, UInt32 &processedSize) throw();
};
class COutFile: public CFileBase
{
public:
bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
bool Open(CFSTR fileName, DWORD creationDisposition);
bool Create(CFSTR fileName, bool createAlways);
bool CreateAlways(CFSTR fileName, DWORD flagsAndAttributes);
bool SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw();
bool SetMTime(const FILETIME *mTime) throw();
bool WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw();
bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw();
bool SetEndOfFile() throw();
bool SetLength(UInt64 length) throw();
};
}}}
#endif
// Windows/FileIO.h
#ifndef __WINDOWS_FILE_IO_H
#define __WINDOWS_FILE_IO_H
#include "../Common/MyWindows.h"
#if defined(_WIN32) && !defined(UNDER_CE)
#include <winioctl.h>
#endif
#include "../Common/MyString.h"
#include "../Common/MyBuffer.h"
#include "Defs.h"
#define _my_IO_REPARSE_TAG_MOUNT_POINT (0xA0000003L)
#define _my_IO_REPARSE_TAG_SYMLINK (0xA000000CL)
#define _my_SYMLINK_FLAG_RELATIVE 1
#define my_FSCTL_SET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 41, METHOD_BUFFERED, FILE_SPECIAL_ACCESS) // REPARSE_DATA_BUFFER
#define my_FSCTL_GET_REPARSE_POINT CTL_CODE(FILE_DEVICE_FILE_SYSTEM, 42, METHOD_BUFFERED, FILE_ANY_ACCESS) // REPARSE_DATA_BUFFER
namespace NWindows {
namespace NFile {
#if defined(_WIN32) && !defined(UNDER_CE)
bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink);
#endif
struct CReparseShortInfo
{
unsigned Offset;
unsigned Size;
bool Parse(const Byte *p, size_t size);
};
struct CReparseAttr
{
UInt32 Tag;
UInt32 Flags;
UString SubsName;
UString PrintName;
CReparseAttr(): Tag(0), Flags(0) {}
// Parse()
// returns true and (errorCode = 0), if (correct MOUNT_POINT or SYMLINK)
// returns false and (errorCode = ERROR_REPARSE_TAG_MISMATCH), if not (MOUNT_POINT or SYMLINK)
bool Parse(const Byte *p, size_t size, DWORD &errorCode);
bool IsMountPoint() const { return Tag == _my_IO_REPARSE_TAG_MOUNT_POINT; } // it's Junction
bool IsSymLink() const { return Tag == _my_IO_REPARSE_TAG_SYMLINK; }
bool IsRelative() const { return Flags == _my_SYMLINK_FLAG_RELATIVE; }
// bool IsVolume() const;
bool IsOkNamePair() const;
UString GetPath() const;
};
namespace NIO {
bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo = NULL);
bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size);
class CFileBase
{
protected:
HANDLE _handle;
bool Create(CFSTR path, DWORD desiredAccess,
DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
public:
bool DeviceIoControl(DWORD controlCode, LPVOID inBuffer, DWORD inSize,
LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned, LPOVERLAPPED overlapped = NULL) const
{
return BOOLToBool(::DeviceIoControl(_handle, controlCode, inBuffer, inSize,
outBuffer, outSize, bytesReturned, overlapped));
}
bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize, LPDWORD bytesReturned) const
{
return DeviceIoControl(controlCode, NULL, 0, outBuffer, outSize, bytesReturned);
}
bool DeviceIoControlOut(DWORD controlCode, LPVOID outBuffer, DWORD outSize) const
{
DWORD bytesReturned;
return DeviceIoControlOut(controlCode, outBuffer, outSize, &bytesReturned);
}
public:
#ifdef SUPPORT_DEVICE_FILE
bool IsDeviceFile;
bool SizeDefined;
UInt64 Size; // it can be larger than real available size
#endif
CFileBase(): _handle(INVALID_HANDLE_VALUE) {};
~CFileBase() { Close(); }
bool Close() throw();
bool GetPosition(UInt64 &position) const throw();
bool GetLength(UInt64 &length) const throw();
bool Seek(Int64 distanceToMove, DWORD moveMethod, UInt64 &newPosition) const throw();
bool Seek(UInt64 position, UInt64 &newPosition) const throw();
bool SeekToBegin() const throw();
bool SeekToEnd(UInt64 &newPosition) const throw();
bool GetFileInformation(BY_HANDLE_FILE_INFORMATION *info) const
{ return BOOLToBool(GetFileInformationByHandle(_handle, info)); }
static bool GetFileInformation(CFSTR path, BY_HANDLE_FILE_INFORMATION *info)
{
NIO::CFileBase file;
if (!file.Create(path, 0, FILE_SHARE_READ, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS))
return false;
return file.GetFileInformation(info);
}
};
#ifndef UNDER_CE
#define IOCTL_CDROM_BASE FILE_DEVICE_CD_ROM
#define IOCTL_CDROM_GET_DRIVE_GEOMETRY CTL_CODE(IOCTL_CDROM_BASE, 0x0013, METHOD_BUFFERED, FILE_READ_ACCESS)
// #define IOCTL_CDROM_MEDIA_REMOVAL CTL_CODE(IOCTL_CDROM_BASE, 0x0201, METHOD_BUFFERED, FILE_READ_ACCESS)
// IOCTL_DISK_GET_DRIVE_GEOMETRY_EX works since WinXP
#define my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX CTL_CODE(IOCTL_DISK_BASE, 0x0028, METHOD_BUFFERED, FILE_ANY_ACCESS)
struct my_DISK_GEOMETRY_EX
{
DISK_GEOMETRY Geometry;
LARGE_INTEGER DiskSize;
BYTE Data[1];
};
#endif
class CInFile: public CFileBase
{
#ifdef SUPPORT_DEVICE_FILE
#ifndef UNDER_CE
bool GetGeometry(DISK_GEOMETRY *res) const
{ return DeviceIoControlOut(IOCTL_DISK_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
bool GetGeometryEx(my_DISK_GEOMETRY_EX *res) const
{ return DeviceIoControlOut(my_IOCTL_DISK_GET_DRIVE_GEOMETRY_EX, res, sizeof(*res)); }
bool GetCdRomGeometry(DISK_GEOMETRY *res) const
{ return DeviceIoControlOut(IOCTL_CDROM_GET_DRIVE_GEOMETRY, res, sizeof(*res)); }
bool GetPartitionInfo(PARTITION_INFORMATION *res)
{ return DeviceIoControlOut(IOCTL_DISK_GET_PARTITION_INFO, LPVOID(res), sizeof(*res)); }
#endif
void CorrectDeviceSize();
void CalcDeviceSize(CFSTR name);
#endif
public:
bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
bool OpenShared(CFSTR fileName, bool shareForWrite);
bool Open(CFSTR fileName);
#ifndef UNDER_CE
bool OpenReparse(CFSTR fileName)
{
// 17.02 fix: to support Windows XP compatibility junctions:
// we use Create() with (desiredAccess = 0) instead of Open() with GENERIC_READ
return
Create(fileName, 0,
// Open(fileName,
FILE_SHARE_READ, OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS);
}
#endif
bool Read1(void *data, UInt32 size, UInt32 &processedSize) throw();
bool ReadPart(void *data, UInt32 size, UInt32 &processedSize) throw();
bool Read(void *data, UInt32 size, UInt32 &processedSize) throw();
};
class COutFile: public CFileBase
{
public:
bool Open(CFSTR fileName, DWORD shareMode, DWORD creationDisposition, DWORD flagsAndAttributes);
bool Open(CFSTR fileName, DWORD creationDisposition);
bool Create(CFSTR fileName, bool createAlways);
bool CreateAlways(CFSTR fileName, DWORD flagsAndAttributes);
bool SetTime(const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime) throw();
bool SetMTime(const FILETIME *mTime) throw();
bool WritePart(const void *data, UInt32 size, UInt32 &processedSize) throw();
bool Write(const void *data, UInt32 size, UInt32 &processedSize) throw();
bool SetEndOfFile() throw();
bool SetLength(UInt64 length) throw();
};
}}}
#endif

880
CPP/Windows/FileLink.cpp
View File

@@ -1,440 +1,440 @@
// Windows/FileLink.cpp
#include "StdAfx.h"
#include "../../C/CpuArch.h"
#ifdef SUPPORT_DEVICE_FILE
#include "../../C/Alloc.h"
#endif
#include "FileDir.h"
#include "FileFind.h"
#include "FileIO.h"
#include "FileName.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NFile {
using namespace NName;
/*
Reparse Points (Junctions and Symbolic Links):
struct
{
UInt32 Tag;
UInt16 Size; // not including starting 8 bytes
UInt16 Reserved; // = 0
UInt16 SubstituteOffset; // offset in bytes from start of namesChars
UInt16 SubstituteLen; // size in bytes, it doesn't include tailed NUL
UInt16 PrintOffset; // offset in bytes from start of namesChars
UInt16 PrintLen; // size in bytes, it doesn't include tailed NUL
[UInt32] Flags; // for Symbolic Links only.
UInt16 namesChars[]
}
MOUNT_POINT (Junction point):
1) there is NUL wchar after path
2) Default Order in table:
Substitute Path
Print Path
3) pathnames can not contain dot directory names
SYMLINK:
1) there is no NUL wchar after path
2) Default Order in table:
Print Path
Substitute Path
*/
/*
static const UInt32 kReparseFlags_Alias = (1 << 29);
static const UInt32 kReparseFlags_HighLatency = (1 << 30);
static const UInt32 kReparseFlags_Microsoft = ((UInt32)1 << 31);
#define _my_IO_REPARSE_TAG_HSM (0xC0000004L)
#define _my_IO_REPARSE_TAG_HSM2 (0x80000006L)
#define _my_IO_REPARSE_TAG_SIS (0x80000007L)
#define _my_IO_REPARSE_TAG_WIM (0x80000008L)
#define _my_IO_REPARSE_TAG_CSV (0x80000009L)
#define _my_IO_REPARSE_TAG_DFS (0x8000000AL)
#define _my_IO_REPARSE_TAG_DFSR (0x80000012L)
*/
#define Get16(p) GetUi16(p)
#define Get32(p) GetUi32(p)
#define Set16(p, v) SetUi16(p, v)
#define Set32(p, v) SetUi32(p, v)
static const wchar_t * const k_LinkPrefix = L"\\??\\";
static const unsigned k_LinkPrefix_Size = 4;
static const bool IsLinkPrefix(const wchar_t *s)
{
return IsString1PrefixedByString2(s, k_LinkPrefix);
}
/*
static const wchar_t * const k_VolumePrefix = L"Volume{";
static const bool IsVolumeName(const wchar_t *s)
{
return IsString1PrefixedByString2(s, k_VolumePrefix);
}
*/
void WriteString(Byte *dest, const wchar_t *path)
{
for (;;)
{
wchar_t c = *path++;
if (c == 0)
return;
Set16(dest, (UInt16)c);
dest += 2;
}
}
#if defined(_WIN32) && !defined(UNDER_CE)
bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
{
bool isAbs = IsAbsolutePath(path);
if (!isAbs && !isSymLink)
return false;
bool needPrintName = true;
if (IsSuperPath(path))
{
path += kSuperPathPrefixSize;
if (!IsDrivePath(path))
needPrintName = false;
}
const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
unsigned len2 = MyStringLen(path) * 2;
const unsigned len1 = len2 + add_Prefix_Len * 2;
if (!needPrintName)
len2 = 0;
unsigned totalNamesSize = (len1 + len2);
/* some WIM imagex software uses old scheme for symbolic links.
so we can old scheme for byte to byte compatibility */
bool newOrderScheme = isSymLink;
// newOrderScheme = false;
if (!newOrderScheme)
totalNamesSize += 2 * 2;
const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
dest.Alloc(size);
memset(dest, 0, size);
const UInt32 tag = isSymLink ?
_my_IO_REPARSE_TAG_SYMLINK :
_my_IO_REPARSE_TAG_MOUNT_POINT;
Byte *p = dest;
Set32(p, tag);
Set16(p + 4, (UInt16)(size - 8));
Set16(p + 6, 0);
p += 8;
unsigned subOffs = 0;
unsigned printOffs = 0;
if (newOrderScheme)
subOffs = len2;
else
printOffs = len1 + 2;
Set16(p + 0, (UInt16)subOffs);
Set16(p + 2, (UInt16)len1);
Set16(p + 4, (UInt16)printOffs);
Set16(p + 6, (UInt16)len2);
p += 8;
if (isSymLink)
{
UInt32 flags = isAbs ? 0 : _my_SYMLINK_FLAG_RELATIVE;
Set32(p, flags);
p += 4;
}
if (add_Prefix_Len != 0)
WriteString(p + subOffs, k_LinkPrefix);
WriteString(p + subOffs + add_Prefix_Len * 2, path);
if (needPrintName)
WriteString(p + printOffs, path);
return true;
}
#endif
static void GetString(const Byte *p, unsigned len, UString &res)
{
wchar_t *s = res.GetBuf(len);
unsigned i;
for (i = 0; i < len; i++)
{
wchar_t c = Get16(p + i * 2);
if (c == 0)
break;
s[i] = c;
}
s[i] = 0;
res.ReleaseBuf_SetLen(i);
}
bool CReparseAttr::Parse(const Byte *p, size_t size, DWORD &errorCode)
{
errorCode = ERROR_INVALID_REPARSE_DATA;
if (size < 8)
return false;
Tag = Get32(p);
UInt32 len = Get16(p + 4);
if (len + 8 > size)
return false;
/*
if ((type & kReparseFlags_Alias) == 0 ||
(type & kReparseFlags_Microsoft) == 0 ||
(type & 0xFFFF) != 3)
*/
if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
Tag != _my_IO_REPARSE_TAG_SYMLINK)
{
errorCode = ERROR_REPARSE_TAG_MISMATCH; // ERROR_REPARSE_TAG_INVALID
return false;
}
if (Get16(p + 6) != 0) // padding
return false;
p += 8;
size -= 8;
if (len != size) // do we need that check?
return false;
if (len < 8)
return false;
unsigned subOffs = Get16(p);
unsigned subLen = Get16(p + 2);
unsigned printOffs = Get16(p + 4);
unsigned printLen = Get16(p + 6);
len -= 8;
p += 8;
Flags = 0;
if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
{
if (len < 4)
return false;
Flags = Get32(p);
len -= 4;
p += 4;
}
if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
return false;
if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
return false;
GetString(p + subOffs, subLen >> 1, SubsName);
GetString(p + printOffs, printLen >> 1, PrintName);
errorCode = 0;
return true;
}
bool CReparseShortInfo::Parse(const Byte *p, size_t size)
{
const Byte *start = p;
Offset= 0;
Size = 0;
if (size < 8)
return false;
UInt32 Tag = Get32(p);
UInt32 len = Get16(p + 4);
if (len + 8 > size)
return false;
/*
if ((type & kReparseFlags_Alias) == 0 ||
(type & kReparseFlags_Microsoft) == 0 ||
(type & 0xFFFF) != 3)
*/
if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
Tag != _my_IO_REPARSE_TAG_SYMLINK)
// return true;
return false;
if (Get16(p + 6) != 0) // padding
return false;
p += 8;
size -= 8;
if (len != size) // do we need that check?
return false;
if (len < 8)
return false;
unsigned subOffs = Get16(p);
unsigned subLen = Get16(p + 2);
unsigned printOffs = Get16(p + 4);
unsigned printLen = Get16(p + 6);
len -= 8;
p += 8;
// UInt32 Flags = 0;
if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
{
if (len < 4)
return false;
// Flags = Get32(p);
len -= 4;
p += 4;
}
if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
return false;
if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
return false;
Offset = (unsigned)(p - start) + subOffs;
Size = subLen;
return true;
}
bool CReparseAttr::IsOkNamePair() const
{
if (IsLinkPrefix(SubsName))
{
if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
return PrintName.IsEmpty();
if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
return true;
}
return wcscmp(SubsName, PrintName) == 0;
}
/*
bool CReparseAttr::IsVolume() const
{
if (!IsLinkPrefix(SubsName))
return false;
return IsVolumeName(SubsName.Ptr(k_LinkPrefix_Size));
}
*/
UString CReparseAttr::GetPath() const
{
UString s (SubsName);
if (IsLinkPrefix(s))
{
s.ReplaceOneCharAtPos(1, '\\');
if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
s.DeleteFrontal(k_LinkPrefix_Size);
}
return s;
}
#ifdef SUPPORT_DEVICE_FILE
namespace NSystem
{
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}
#endif
#ifndef UNDER_CE
namespace NIO {
bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo)
{
reparseData.Free();
CInFile file;
if (!file.OpenReparse(path))
return false;
if (fileInfo)
file.GetFileInformation(fileInfo);
const unsigned kBufSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
CByteArr buf(kBufSize);
DWORD returnedSize;
if (!file.DeviceIoControlOut(my_FSCTL_GET_REPARSE_POINT, buf, kBufSize, &returnedSize))
return false;
reparseData.CopyFrom(buf, returnedSize);
return true;
}
static bool CreatePrefixDirOfFile(CFSTR path)
{
FString path2 (path);
int pos = path2.ReverseFind_PathSepar();
if (pos < 0)
return true;
#ifdef _WIN32
if (pos == 2 && path2[1] == L':')
return true; // we don't create Disk folder;
#endif
path2.DeleteFrom(pos);
return NDir::CreateComplexDir(path2);
}
// If there is Reprase data already, it still writes new Reparse data
bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
{
NFile::NFind::CFileInfo fi;
if (fi.Find(path))
{
if (fi.IsDir() != isDir)
{
::SetLastError(ERROR_DIRECTORY);
return false;
}
}
else
{
if (isDir)
{
if (!NDir::CreateComplexDir(path))
return false;
}
else
{
CreatePrefixDirOfFile(path);
COutFile file;
if (!file.Create(path, CREATE_NEW))
return false;
}
}
COutFile file;
if (!file.Open(path,
FILE_SHARE_WRITE,
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS))
return false;
DWORD returnedSize;
if (!file.DeviceIoControl(my_FSCTL_SET_REPARSE_POINT, (void *)data, size, NULL, 0, &returnedSize))
return false;
return true;
}
}
#endif
}}
// Windows/FileLink.cpp
#include "StdAfx.h"
#include "../../C/CpuArch.h"
#ifdef SUPPORT_DEVICE_FILE
#include "../../C/Alloc.h"
#endif
#include "FileDir.h"
#include "FileFind.h"
#include "FileIO.h"
#include "FileName.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NFile {
using namespace NName;
/*
Reparse Points (Junctions and Symbolic Links):
struct
{
UInt32 Tag;
UInt16 Size; // not including starting 8 bytes
UInt16 Reserved; // = 0
UInt16 SubstituteOffset; // offset in bytes from start of namesChars
UInt16 SubstituteLen; // size in bytes, it doesn't include tailed NUL
UInt16 PrintOffset; // offset in bytes from start of namesChars
UInt16 PrintLen; // size in bytes, it doesn't include tailed NUL
[UInt32] Flags; // for Symbolic Links only.
UInt16 namesChars[]
}
MOUNT_POINT (Junction point):
1) there is NUL wchar after path
2) Default Order in table:
Substitute Path
Print Path
3) pathnames can not contain dot directory names
SYMLINK:
1) there is no NUL wchar after path
2) Default Order in table:
Print Path
Substitute Path
*/
/*
static const UInt32 kReparseFlags_Alias = (1 << 29);
static const UInt32 kReparseFlags_HighLatency = (1 << 30);
static const UInt32 kReparseFlags_Microsoft = ((UInt32)1 << 31);
#define _my_IO_REPARSE_TAG_HSM (0xC0000004L)
#define _my_IO_REPARSE_TAG_HSM2 (0x80000006L)
#define _my_IO_REPARSE_TAG_SIS (0x80000007L)
#define _my_IO_REPARSE_TAG_WIM (0x80000008L)
#define _my_IO_REPARSE_TAG_CSV (0x80000009L)
#define _my_IO_REPARSE_TAG_DFS (0x8000000AL)
#define _my_IO_REPARSE_TAG_DFSR (0x80000012L)
*/
#define Get16(p) GetUi16(p)
#define Get32(p) GetUi32(p)
#define Set16(p, v) SetUi16(p, v)
#define Set32(p, v) SetUi32(p, v)
static const wchar_t * const k_LinkPrefix = L"\\??\\";
static const unsigned k_LinkPrefix_Size = 4;
static const bool IsLinkPrefix(const wchar_t *s)
{
return IsString1PrefixedByString2(s, k_LinkPrefix);
}
/*
static const wchar_t * const k_VolumePrefix = L"Volume{";
static const bool IsVolumeName(const wchar_t *s)
{
return IsString1PrefixedByString2(s, k_VolumePrefix);
}
*/
void WriteString(Byte *dest, const wchar_t *path)
{
for (;;)
{
wchar_t c = *path++;
if (c == 0)
return;
Set16(dest, (UInt16)c);
dest += 2;
}
}
#if defined(_WIN32) && !defined(UNDER_CE)
bool FillLinkData(CByteBuffer &dest, const wchar_t *path, bool isSymLink)
{
bool isAbs = IsAbsolutePath(path);
if (!isAbs && !isSymLink)
return false;
bool needPrintName = true;
if (IsSuperPath(path))
{
path += kSuperPathPrefixSize;
if (!IsDrivePath(path))
needPrintName = false;
}
const unsigned add_Prefix_Len = isAbs ? k_LinkPrefix_Size : 0;
unsigned len2 = MyStringLen(path) * 2;
const unsigned len1 = len2 + add_Prefix_Len * 2;
if (!needPrintName)
len2 = 0;
unsigned totalNamesSize = (len1 + len2);
/* some WIM imagex software uses old scheme for symbolic links.
so we can old scheme for byte to byte compatibility */
bool newOrderScheme = isSymLink;
// newOrderScheme = false;
if (!newOrderScheme)
totalNamesSize += 2 * 2;
const size_t size = 8 + 8 + (isSymLink ? 4 : 0) + totalNamesSize;
dest.Alloc(size);
memset(dest, 0, size);
const UInt32 tag = isSymLink ?
_my_IO_REPARSE_TAG_SYMLINK :
_my_IO_REPARSE_TAG_MOUNT_POINT;
Byte *p = dest;
Set32(p, tag);
Set16(p + 4, (UInt16)(size - 8));
Set16(p + 6, 0);
p += 8;
unsigned subOffs = 0;
unsigned printOffs = 0;
if (newOrderScheme)
subOffs = len2;
else
printOffs = len1 + 2;
Set16(p + 0, (UInt16)subOffs);
Set16(p + 2, (UInt16)len1);
Set16(p + 4, (UInt16)printOffs);
Set16(p + 6, (UInt16)len2);
p += 8;
if (isSymLink)
{
UInt32 flags = isAbs ? 0 : _my_SYMLINK_FLAG_RELATIVE;
Set32(p, flags);
p += 4;
}
if (add_Prefix_Len != 0)
WriteString(p + subOffs, k_LinkPrefix);
WriteString(p + subOffs + add_Prefix_Len * 2, path);
if (needPrintName)
WriteString(p + printOffs, path);
return true;
}
#endif
static void GetString(const Byte *p, unsigned len, UString &res)
{
wchar_t *s = res.GetBuf(len);
unsigned i;
for (i = 0; i < len; i++)
{
wchar_t c = Get16(p + i * 2);
if (c == 0)
break;
s[i] = c;
}
s[i] = 0;
res.ReleaseBuf_SetLen(i);
}
bool CReparseAttr::Parse(const Byte *p, size_t size, DWORD &errorCode)
{
errorCode = ERROR_INVALID_REPARSE_DATA;
if (size < 8)
return false;
Tag = Get32(p);
UInt32 len = Get16(p + 4);
if (len + 8 > size)
return false;
/*
if ((type & kReparseFlags_Alias) == 0 ||
(type & kReparseFlags_Microsoft) == 0 ||
(type & 0xFFFF) != 3)
*/
if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
Tag != _my_IO_REPARSE_TAG_SYMLINK)
{
errorCode = ERROR_REPARSE_TAG_MISMATCH; // ERROR_REPARSE_TAG_INVALID
return false;
}
if (Get16(p + 6) != 0) // padding
return false;
p += 8;
size -= 8;
if (len != size) // do we need that check?
return false;
if (len < 8)
return false;
unsigned subOffs = Get16(p);
unsigned subLen = Get16(p + 2);
unsigned printOffs = Get16(p + 4);
unsigned printLen = Get16(p + 6);
len -= 8;
p += 8;
Flags = 0;
if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
{
if (len < 4)
return false;
Flags = Get32(p);
len -= 4;
p += 4;
}
if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
return false;
if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
return false;
GetString(p + subOffs, subLen >> 1, SubsName);
GetString(p + printOffs, printLen >> 1, PrintName);
errorCode = 0;
return true;
}
bool CReparseShortInfo::Parse(const Byte *p, size_t size)
{
const Byte *start = p;
Offset= 0;
Size = 0;
if (size < 8)
return false;
UInt32 Tag = Get32(p);
UInt32 len = Get16(p + 4);
if (len + 8 > size)
return false;
/*
if ((type & kReparseFlags_Alias) == 0 ||
(type & kReparseFlags_Microsoft) == 0 ||
(type & 0xFFFF) != 3)
*/
if (Tag != _my_IO_REPARSE_TAG_MOUNT_POINT &&
Tag != _my_IO_REPARSE_TAG_SYMLINK)
// return true;
return false;
if (Get16(p + 6) != 0) // padding
return false;
p += 8;
size -= 8;
if (len != size) // do we need that check?
return false;
if (len < 8)
return false;
unsigned subOffs = Get16(p);
unsigned subLen = Get16(p + 2);
unsigned printOffs = Get16(p + 4);
unsigned printLen = Get16(p + 6);
len -= 8;
p += 8;
// UInt32 Flags = 0;
if (Tag == _my_IO_REPARSE_TAG_SYMLINK)
{
if (len < 4)
return false;
// Flags = Get32(p);
len -= 4;
p += 4;
}
if ((subOffs & 1) != 0 || subOffs > len || len - subOffs < subLen)
return false;
if ((printOffs & 1) != 0 || printOffs > len || len - printOffs < printLen)
return false;
Offset = (unsigned)(p - start) + subOffs;
Size = subLen;
return true;
}
bool CReparseAttr::IsOkNamePair() const
{
if (IsLinkPrefix(SubsName))
{
if (!IsDrivePath(SubsName.Ptr(k_LinkPrefix_Size)))
return PrintName.IsEmpty();
if (wcscmp(SubsName.Ptr(k_LinkPrefix_Size), PrintName) == 0)
return true;
}
return wcscmp(SubsName, PrintName) == 0;
}
/*
bool CReparseAttr::IsVolume() const
{
if (!IsLinkPrefix(SubsName))
return false;
return IsVolumeName(SubsName.Ptr(k_LinkPrefix_Size));
}
*/
UString CReparseAttr::GetPath() const
{
UString s (SubsName);
if (IsLinkPrefix(s))
{
s.ReplaceOneCharAtPos(1, '\\');
if (IsDrivePath(s.Ptr(k_LinkPrefix_Size)))
s.DeleteFrontal(k_LinkPrefix_Size);
}
return s;
}
#ifdef SUPPORT_DEVICE_FILE
namespace NSystem
{
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}
#endif
#ifndef UNDER_CE
namespace NIO {
bool GetReparseData(CFSTR path, CByteBuffer &reparseData, BY_HANDLE_FILE_INFORMATION *fileInfo)
{
reparseData.Free();
CInFile file;
if (!file.OpenReparse(path))
return false;
if (fileInfo)
file.GetFileInformation(fileInfo);
const unsigned kBufSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE;
CByteArr buf(kBufSize);
DWORD returnedSize;
if (!file.DeviceIoControlOut(my_FSCTL_GET_REPARSE_POINT, buf, kBufSize, &returnedSize))
return false;
reparseData.CopyFrom(buf, returnedSize);
return true;
}
static bool CreatePrefixDirOfFile(CFSTR path)
{
FString path2 (path);
int pos = path2.ReverseFind_PathSepar();
if (pos < 0)
return true;
#ifdef _WIN32
if (pos == 2 && path2[1] == L':')
return true; // we don't create Disk folder;
#endif
path2.DeleteFrom(pos);
return NDir::CreateComplexDir(path2);
}
// If there is Reprase data already, it still writes new Reparse data
bool SetReparseData(CFSTR path, bool isDir, const void *data, DWORD size)
{
NFile::NFind::CFileInfo fi;
if (fi.Find(path))
{
if (fi.IsDir() != isDir)
{
::SetLastError(ERROR_DIRECTORY);
return false;
}
}
else
{
if (isDir)
{
if (!NDir::CreateComplexDir(path))
return false;
}
else
{
CreatePrefixDirOfFile(path);
COutFile file;
if (!file.Create(path, CREATE_NEW))
return false;
}
}
COutFile file;
if (!file.Open(path,
FILE_SHARE_WRITE,
OPEN_EXISTING,
FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS))
return false;
DWORD returnedSize;
if (!file.DeviceIoControl(my_FSCTL_SET_REPARSE_POINT, (void *)data, size, NULL, 0, &returnedSize))
return false;
return true;
}
}
#endif
}}

24
CPP/Windows/FileMapping.cpp
View File

@@ -1,12 +1,12 @@
// Windows/FileMapping.cpp
#include "StdAfx.h"
#include "FileMapping.h"
namespace NWindows {
namespace NFile {
namespace NMapping {
}}}
// Windows/FileMapping.cpp
#include "StdAfx.h"
#include "FileMapping.h"
namespace NWindows {
namespace NFile {
namespace NMapping {
}}}

132
CPP/Windows/FileMapping.h
View File

@@ -1,66 +1,66 @@
// Windows/FileMapping.h
#ifndef __WINDOWS_FILEMAPPING_H
#define __WINDOWS_FILEMAPPING_H
#include "../Common/MyTypes.h"
#include "Handle.h"
namespace NWindows {
class CFileMapping: public CHandle
{
public:
WRes Create(DWORD protect, UInt64 maxSize, LPCTSTR name)
{
_handle = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, protect, (DWORD)(maxSize >> 32), (DWORD)maxSize, name);
return ::GetLastError();
}
WRes Open(DWORD
#ifndef UNDER_CE
desiredAccess
#endif
, LPCTSTR name)
{
#ifdef UNDER_CE
WRes res = Create(PAGE_READONLY, 0, name);
if (res == ERROR_ALREADY_EXISTS)
return 0;
Close();
if (res == 0)
res = ERROR_FILE_NOT_FOUND;
return res;
#else
_handle = ::OpenFileMapping(desiredAccess, FALSE, name);
if (_handle != 0)
return 0;
return ::GetLastError();
#endif
}
LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap)
{
return ::MapViewOfFile(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap);
}
#ifndef UNDER_CE
LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap, LPVOID baseAddress)
{
return ::MapViewOfFileEx(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap, baseAddress);
}
#endif
};
class CFileUnmapper
{
const void *_data;
public:
CFileUnmapper(const void *data) : _data(data) {}
~CFileUnmapper() { ::UnmapViewOfFile(_data); }
};
}
#endif
// Windows/FileMapping.h
#ifndef __WINDOWS_FILEMAPPING_H
#define __WINDOWS_FILEMAPPING_H
#include "../Common/MyTypes.h"
#include "Handle.h"
namespace NWindows {
class CFileMapping: public CHandle
{
public:
WRes Create(DWORD protect, UInt64 maxSize, LPCTSTR name)
{
_handle = ::CreateFileMapping(INVALID_HANDLE_VALUE, NULL, protect, (DWORD)(maxSize >> 32), (DWORD)maxSize, name);
return ::GetLastError();
}
WRes Open(DWORD
#ifndef UNDER_CE
desiredAccess
#endif
, LPCTSTR name)
{
#ifdef UNDER_CE
WRes res = Create(PAGE_READONLY, 0, name);
if (res == ERROR_ALREADY_EXISTS)
return 0;
Close();
if (res == 0)
res = ERROR_FILE_NOT_FOUND;
return res;
#else
_handle = ::OpenFileMapping(desiredAccess, FALSE, name);
if (_handle != 0)
return 0;
return ::GetLastError();
#endif
}
LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap)
{
return ::MapViewOfFile(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap);
}
#ifndef UNDER_CE
LPVOID Map(DWORD desiredAccess, UInt64 fileOffset, SIZE_T numberOfBytesToMap, LPVOID baseAddress)
{
return ::MapViewOfFileEx(_handle, desiredAccess, (DWORD)(fileOffset >> 32), (DWORD)fileOffset, numberOfBytesToMap, baseAddress);
}
#endif
};
class CFileUnmapper
{
const void *_data;
public:
CFileUnmapper(const void *data) : _data(data) {}
~CFileUnmapper() { ::UnmapViewOfFile(_data); }
};
}
#endif

1678
CPP/Windows/FileName.cpp
View File

File diff suppressed because it is too large Load Diff

230
CPP/Windows/FileName.h
View File

@@ -1,115 +1,115 @@
// Windows/FileName.h
#ifndef __WINDOWS_FILE_NAME_H
#define __WINDOWS_FILE_NAME_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NFile {
namespace NName {
int FindSepar(const wchar_t *s) throw();
#ifndef USE_UNICODE_FSTRING
int FindSepar(const FChar *s) throw();
#endif
void NormalizeDirPathPrefix(FString &dirPath); // ensures that it ended with '\\', if dirPath is not epmty
void NormalizeDirPathPrefix(UString &dirPath);
bool IsDrivePath(const wchar_t *s) throw(); // first 3 chars are drive chars like "a:\\"
bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
#if defined(_WIN32) && !defined(UNDER_CE)
extern const char * const kSuperPathPrefix; /* \\?\ */
const unsigned kDevicePathPrefixSize = 4;
const unsigned kSuperPathPrefixSize = 4;
const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
bool IsDevicePath(CFSTR s) throw(); /* \\.\ */
bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
bool IsNetworkPath(CFSTR s) throw(); /* \\?\UNC\ or \\SERVER */
/* GetNetworkServerPrefixSize() returns size of server prefix:
\\?\UNC\SERVER\
\\SERVER\
in another cases it returns 0
*/
unsigned GetNetworkServerPrefixSize(CFSTR s) throw();
bool IsNetworkShareRootPath(CFSTR s) throw(); /* \\?\UNC\SERVER\share or \\SERVER\share or with slash */
bool IsDrivePath_SuperAllowed(CFSTR s) throw(); // first chars are drive chars like "a:\" or "\\?\a:\"
bool IsDriveRootPath_SuperAllowed(CFSTR s) throw(); // exact drive root path "a:\" or "\\?\a:\"
bool IsDrivePath2(const wchar_t *s) throw(); // first 2 chars are drive chars like "a:"
// bool IsDriveName2(const wchar_t *s) throw(); // is drive name like "a:"
bool IsSuperPath(const wchar_t *s) throw();
bool IsSuperOrDevicePath(const wchar_t *s) throw();
#ifndef USE_UNICODE_FSTRING
bool IsDrivePath2(CFSTR s) throw(); // first 2 chars are drive chars like "a:"
// bool IsDriveName2(CFSTR s) throw(); // is drive name like "a:"
bool IsDrivePath(CFSTR s) throw();
bool IsSuperPath(CFSTR s) throw();
bool IsSuperOrDevicePath(CFSTR s) throw();
/* GetRootPrefixSize() returns size of ROOT PREFIX for cases:
\
\\.\
C:\
\\?\C:\
\\?\UNC\SERVER\Shared\
\\SERVER\Shared\
in another cases it returns 0
*/
unsigned GetRootPrefixSize(CFSTR s) throw();
#endif
int FindAltStreamColon(CFSTR path) throw();
#endif // _WIN32
bool IsAbsolutePath(const wchar_t *s) throw();
unsigned GetRootPrefixSize(const wchar_t *s) throw();
#ifdef WIN_LONG_PATH
const int kSuperPathType_UseOnlyMain = 0;
const int kSuperPathType_UseOnlySuper = 1;
const int kSuperPathType_UseMainAndSuper = 2;
int GetUseSuperPathType(CFSTR s) throw();
bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew);
bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew);
#define USE_MAIN_PATH (__useSuperPathType != kSuperPathType_UseOnlySuper)
#define USE_MAIN_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlySuper && __useSuperPathType2 != kSuperPathType_UseOnlySuper)
#define USE_SUPER_PATH (__useSuperPathType != kSuperPathType_UseOnlyMain)
#define USE_SUPER_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlyMain || __useSuperPathType2 != kSuperPathType_UseOnlyMain)
#define IF_USE_MAIN_PATH int __useSuperPathType = GetUseSuperPathType(path); if (USE_MAIN_PATH)
#define IF_USE_MAIN_PATH_2(x1, x2) \
int __useSuperPathType1 = GetUseSuperPathType(x1); \
int __useSuperPathType2 = GetUseSuperPathType(x2); \
if (USE_MAIN_PATH_2)
#else
#define IF_USE_MAIN_PATH
#define IF_USE_MAIN_PATH_2(x1, x2)
#endif // WIN_LONG_PATH
bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
bool GetFullPath(CFSTR path, FString &fullPath);
}}}
#endif
// Windows/FileName.h
#ifndef __WINDOWS_FILE_NAME_H
#define __WINDOWS_FILE_NAME_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NFile {
namespace NName {
int FindSepar(const wchar_t *s) throw();
#ifndef USE_UNICODE_FSTRING
int FindSepar(const FChar *s) throw();
#endif
void NormalizeDirPathPrefix(FString &dirPath); // ensures that it ended with '\\', if dirPath is not epmty
void NormalizeDirPathPrefix(UString &dirPath);
bool IsDrivePath(const wchar_t *s) throw(); // first 3 chars are drive chars like "a:\\"
bool IsAltPathPrefix(CFSTR s) throw(); /* name: */
#if defined(_WIN32) && !defined(UNDER_CE)
extern const char * const kSuperPathPrefix; /* \\?\ */
const unsigned kDevicePathPrefixSize = 4;
const unsigned kSuperPathPrefixSize = 4;
const unsigned kSuperUncPathPrefixSize = kSuperPathPrefixSize + 4;
bool IsDevicePath(CFSTR s) throw(); /* \\.\ */
bool IsSuperUncPath(CFSTR s) throw(); /* \\?\UNC\ */
bool IsNetworkPath(CFSTR s) throw(); /* \\?\UNC\ or \\SERVER */
/* GetNetworkServerPrefixSize() returns size of server prefix:
\\?\UNC\SERVER\
\\SERVER\
in another cases it returns 0
*/
unsigned GetNetworkServerPrefixSize(CFSTR s) throw();
bool IsNetworkShareRootPath(CFSTR s) throw(); /* \\?\UNC\SERVER\share or \\SERVER\share or with slash */
bool IsDrivePath_SuperAllowed(CFSTR s) throw(); // first chars are drive chars like "a:\" or "\\?\a:\"
bool IsDriveRootPath_SuperAllowed(CFSTR s) throw(); // exact drive root path "a:\" or "\\?\a:\"
bool IsDrivePath2(const wchar_t *s) throw(); // first 2 chars are drive chars like "a:"
// bool IsDriveName2(const wchar_t *s) throw(); // is drive name like "a:"
bool IsSuperPath(const wchar_t *s) throw();
bool IsSuperOrDevicePath(const wchar_t *s) throw();
#ifndef USE_UNICODE_FSTRING
bool IsDrivePath2(CFSTR s) throw(); // first 2 chars are drive chars like "a:"
// bool IsDriveName2(CFSTR s) throw(); // is drive name like "a:"
bool IsDrivePath(CFSTR s) throw();
bool IsSuperPath(CFSTR s) throw();
bool IsSuperOrDevicePath(CFSTR s) throw();
/* GetRootPrefixSize() returns size of ROOT PREFIX for cases:
\
\\.\
C:\
\\?\C:\
\\?\UNC\SERVER\Shared\
\\SERVER\Shared\
in another cases it returns 0
*/
unsigned GetRootPrefixSize(CFSTR s) throw();
#endif
int FindAltStreamColon(CFSTR path) throw();
#endif // _WIN32
bool IsAbsolutePath(const wchar_t *s) throw();
unsigned GetRootPrefixSize(const wchar_t *s) throw();
#ifdef WIN_LONG_PATH
const int kSuperPathType_UseOnlyMain = 0;
const int kSuperPathType_UseOnlySuper = 1;
const int kSuperPathType_UseMainAndSuper = 2;
int GetUseSuperPathType(CFSTR s) throw();
bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew);
bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew);
#define USE_MAIN_PATH (__useSuperPathType != kSuperPathType_UseOnlySuper)
#define USE_MAIN_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlySuper && __useSuperPathType2 != kSuperPathType_UseOnlySuper)
#define USE_SUPER_PATH (__useSuperPathType != kSuperPathType_UseOnlyMain)
#define USE_SUPER_PATH_2 (__useSuperPathType1 != kSuperPathType_UseOnlyMain || __useSuperPathType2 != kSuperPathType_UseOnlyMain)
#define IF_USE_MAIN_PATH int __useSuperPathType = GetUseSuperPathType(path); if (USE_MAIN_PATH)
#define IF_USE_MAIN_PATH_2(x1, x2) \
int __useSuperPathType1 = GetUseSuperPathType(x1); \
int __useSuperPathType2 = GetUseSuperPathType(x2); \
if (USE_MAIN_PATH_2)
#else
#define IF_USE_MAIN_PATH
#define IF_USE_MAIN_PATH_2(x1, x2)
#endif // WIN_LONG_PATH
bool GetFullPath(CFSTR dirPrefix, CFSTR path, FString &fullPath);
bool GetFullPath(CFSTR path, FString &fullPath);
}}}
#endif

262
CPP/Windows/FileSystem.cpp
View File

@@ -1,131 +1,131 @@
// Windows/FileSystem.cpp
#include "StdAfx.h"
#ifndef UNDER_CE
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "FileSystem.h"
#include "Defs.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NFile {
namespace NSystem {
bool MyGetVolumeInformation(
CFSTR rootPath,
UString &volumeName,
LPDWORD volumeSerialNumber,
LPDWORD maximumComponentLength,
LPDWORD fileSystemFlags,
UString &fileSystemName)
{
BOOL res;
#ifndef _UNICODE
if (!g_IsNT)
{
TCHAR v[MAX_PATH + 2]; v[0] = 0;
TCHAR f[MAX_PATH + 2]; f[0] = 0;
res = GetVolumeInformation(fs2fas(rootPath),
v, MAX_PATH,
volumeSerialNumber, maximumComponentLength, fileSystemFlags,
f, MAX_PATH);
volumeName = MultiByteToUnicodeString(v);
fileSystemName = MultiByteToUnicodeString(f);
}
else
#endif
{
WCHAR v[MAX_PATH + 2]; v[0] = 0;
WCHAR f[MAX_PATH + 2]; f[0] = 0;
res = GetVolumeInformationW(fs2us(rootPath),
v, MAX_PATH,
volumeSerialNumber, maximumComponentLength, fileSystemFlags,
f, MAX_PATH);
volumeName = v;
fileSystemName = f;
}
return BOOLToBool(res);
}
UINT MyGetDriveType(CFSTR pathName)
{
#ifndef _UNICODE
if (!g_IsNT)
{
return GetDriveType(fs2fas(pathName));
}
else
#endif
{
return GetDriveTypeW(fs2us(pathName));
}
}
typedef BOOL (WINAPI * GetDiskFreeSpaceExA_Pointer)(
LPCSTR lpDirectoryName, // directory name
PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
);
typedef BOOL (WINAPI * GetDiskFreeSpaceExW_Pointer)(
LPCWSTR lpDirectoryName, // directory name
PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
);
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize)
{
DWORD numSectorsPerCluster, bytesPerSector, numFreeClusters, numClusters;
bool sizeIsDetected = false;
#ifndef _UNICODE
if (!g_IsNT)
{
GetDiskFreeSpaceExA_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExA_Pointer)GetProcAddress(
GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExA");
if (pGetDiskFreeSpaceEx)
{
ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2fas(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
totalSize = totalSize2.QuadPart;
freeSize = freeSize2.QuadPart;
}
if (!::GetDiskFreeSpace(fs2fas(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
return false;
}
else
#endif
{
GetDiskFreeSpaceExW_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExW_Pointer)GetProcAddress(
GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExW");
if (pGetDiskFreeSpaceEx)
{
ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2us(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
totalSize = totalSize2.QuadPart;
freeSize = freeSize2.QuadPart;
}
if (!::GetDiskFreeSpaceW(fs2us(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
return false;
}
clusterSize = (UInt64)bytesPerSector * (UInt64)numSectorsPerCluster;
if (!sizeIsDetected)
{
totalSize = clusterSize * (UInt64)numClusters;
freeSize = clusterSize * (UInt64)numFreeClusters;
}
return true;
}
}}}
#endif
// Windows/FileSystem.cpp
#include "StdAfx.h"
#ifndef UNDER_CE
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "FileSystem.h"
#include "Defs.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NFile {
namespace NSystem {
bool MyGetVolumeInformation(
CFSTR rootPath,
UString &volumeName,
LPDWORD volumeSerialNumber,
LPDWORD maximumComponentLength,
LPDWORD fileSystemFlags,
UString &fileSystemName)
{
BOOL res;
#ifndef _UNICODE
if (!g_IsNT)
{
TCHAR v[MAX_PATH + 2]; v[0] = 0;
TCHAR f[MAX_PATH + 2]; f[0] = 0;
res = GetVolumeInformation(fs2fas(rootPath),
v, MAX_PATH,
volumeSerialNumber, maximumComponentLength, fileSystemFlags,
f, MAX_PATH);
volumeName = MultiByteToUnicodeString(v);
fileSystemName = MultiByteToUnicodeString(f);
}
else
#endif
{
WCHAR v[MAX_PATH + 2]; v[0] = 0;
WCHAR f[MAX_PATH + 2]; f[0] = 0;
res = GetVolumeInformationW(fs2us(rootPath),
v, MAX_PATH,
volumeSerialNumber, maximumComponentLength, fileSystemFlags,
f, MAX_PATH);
volumeName = v;
fileSystemName = f;
}
return BOOLToBool(res);
}
UINT MyGetDriveType(CFSTR pathName)
{
#ifndef _UNICODE
if (!g_IsNT)
{
return GetDriveType(fs2fas(pathName));
}
else
#endif
{
return GetDriveTypeW(fs2us(pathName));
}
}
typedef BOOL (WINAPI * GetDiskFreeSpaceExA_Pointer)(
LPCSTR lpDirectoryName, // directory name
PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
);
typedef BOOL (WINAPI * GetDiskFreeSpaceExW_Pointer)(
LPCWSTR lpDirectoryName, // directory name
PULARGE_INTEGER lpFreeBytesAvailable, // bytes available to caller
PULARGE_INTEGER lpTotalNumberOfBytes, // bytes on disk
PULARGE_INTEGER lpTotalNumberOfFreeBytes // free bytes on disk
);
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize)
{
DWORD numSectorsPerCluster, bytesPerSector, numFreeClusters, numClusters;
bool sizeIsDetected = false;
#ifndef _UNICODE
if (!g_IsNT)
{
GetDiskFreeSpaceExA_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExA_Pointer)GetProcAddress(
GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExA");
if (pGetDiskFreeSpaceEx)
{
ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2fas(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
totalSize = totalSize2.QuadPart;
freeSize = freeSize2.QuadPart;
}
if (!::GetDiskFreeSpace(fs2fas(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
return false;
}
else
#endif
{
GetDiskFreeSpaceExW_Pointer pGetDiskFreeSpaceEx = (GetDiskFreeSpaceExW_Pointer)GetProcAddress(
GetModuleHandle(TEXT("kernel32.dll")), "GetDiskFreeSpaceExW");
if (pGetDiskFreeSpaceEx)
{
ULARGE_INTEGER freeBytesToCaller2, totalSize2, freeSize2;
sizeIsDetected = BOOLToBool(pGetDiskFreeSpaceEx(fs2us(rootPath), &freeBytesToCaller2, &totalSize2, &freeSize2));
totalSize = totalSize2.QuadPart;
freeSize = freeSize2.QuadPart;
}
if (!::GetDiskFreeSpaceW(fs2us(rootPath), &numSectorsPerCluster, &bytesPerSector, &numFreeClusters, &numClusters))
return false;
}
clusterSize = (UInt64)bytesPerSector * (UInt64)numSectorsPerCluster;
if (!sizeIsDetected)
{
totalSize = clusterSize * (UInt64)numClusters;
freeSize = clusterSize * (UInt64)numFreeClusters;
}
return true;
}
}}}
#endif

54
CPP/Windows/FileSystem.h
View File

@@ -1,27 +1,27 @@
// Windows/FileSystem.h
#ifndef __WINDOWS_FILE_SYSTEM_H
#define __WINDOWS_FILE_SYSTEM_H
#include "../Common/MyString.h"
#include "../Common/MyTypes.h"
namespace NWindows {
namespace NFile {
namespace NSystem {
bool MyGetVolumeInformation(
CFSTR rootPath ,
UString &volumeName,
LPDWORD volumeSerialNumber,
LPDWORD maximumComponentLength,
LPDWORD fileSystemFlags,
UString &fileSystemName);
UINT MyGetDriveType(CFSTR pathName);
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}}}
#endif
// Windows/FileSystem.h
#ifndef __WINDOWS_FILE_SYSTEM_H
#define __WINDOWS_FILE_SYSTEM_H
#include "../Common/MyString.h"
#include "../Common/MyTypes.h"
namespace NWindows {
namespace NFile {
namespace NSystem {
bool MyGetVolumeInformation(
CFSTR rootPath ,
UString &volumeName,
LPDWORD volumeSerialNumber,
LPDWORD maximumComponentLength,
LPDWORD fileSystemFlags,
UString &fileSystemName);
UINT MyGetDriveType(CFSTR pathName);
bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
}}}
#endif

74
CPP/Windows/Handle.h
View File

@@ -1,37 +1,37 @@
// Windows/Handle.h
#ifndef __WINDOWS_HANDLE_H
#define __WINDOWS_HANDLE_H
namespace NWindows {
class CHandle
{
protected:
HANDLE _handle;
public:
operator HANDLE() { return _handle; }
CHandle(): _handle(NULL) {}
~CHandle() { Close(); }
bool IsCreated() const { return (_handle != NULL); }
bool Close()
{
if (_handle == NULL)
return true;
if (!::CloseHandle(_handle))
return false;
_handle = NULL;
return true;
}
void Attach(HANDLE handle) { _handle = handle; }
HANDLE Detach()
{
HANDLE handle = _handle;
_handle = NULL;
return handle;
}
};
}
#endif
// Windows/Handle.h
#ifndef __WINDOWS_HANDLE_H
#define __WINDOWS_HANDLE_H
namespace NWindows {
class CHandle
{
protected:
HANDLE _handle;
public:
operator HANDLE() { return _handle; }
CHandle(): _handle(NULL) {}
~CHandle() { Close(); }
bool IsCreated() const { return (_handle != NULL); }
bool Close()
{
if (_handle == NULL)
return true;
if (!::CloseHandle(_handle))
return false;
_handle = NULL;
return true;
}
void Attach(HANDLE handle) { _handle = handle; }
HANDLE Detach()
{
HANDLE handle = _handle;
_handle = NULL;
return handle;
}
};
}
#endif

72
CPP/Windows/MemoryGlobal.cpp
View File

@@ -1,36 +1,36 @@
// Windows/MemoryGlobal.cpp
#include "StdAfx.h"
#include "MemoryGlobal.h"
namespace NWindows {
namespace NMemory {
bool CGlobal::Alloc(UINT flags, SIZE_T size) throw()
{
HGLOBAL newBlock = ::GlobalAlloc(flags, size);
if (newBlock == NULL)
return false;
_global = newBlock;
return true;
}
bool CGlobal::Free() throw()
{
if (_global == NULL)
return true;
_global = ::GlobalFree(_global);
return (_global == NULL);
}
bool CGlobal::ReAlloc(SIZE_T size) throw()
{
HGLOBAL newBlock = ::GlobalReAlloc(_global, size, GMEM_MOVEABLE);
if (newBlock == NULL)
return false;
_global = newBlock;
return true;
}
}}
// Windows/MemoryGlobal.cpp
#include "StdAfx.h"
#include "MemoryGlobal.h"
namespace NWindows {
namespace NMemory {
bool CGlobal::Alloc(UINT flags, SIZE_T size) throw()
{
HGLOBAL newBlock = ::GlobalAlloc(flags, size);
if (newBlock == NULL)
return false;
_global = newBlock;
return true;
}
bool CGlobal::Free() throw()
{
if (_global == NULL)
return true;
_global = ::GlobalFree(_global);
return (_global == NULL);
}
bool CGlobal::ReAlloc(SIZE_T size) throw()
{
HGLOBAL newBlock = ::GlobalReAlloc(_global, size, GMEM_MOVEABLE);
if (newBlock == NULL)
return false;
_global = newBlock;
return true;
}
}}

110
CPP/Windows/MemoryGlobal.h
View File

@@ -1,55 +1,55 @@
// Windows/MemoryGlobal.h
#ifndef __WINDOWS_MEMORY_GLOBAL_H
#define __WINDOWS_MEMORY_GLOBAL_H
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NMemory {
class CGlobal
{
HGLOBAL _global;
public:
CGlobal(): _global(NULL){};
~CGlobal() { Free(); }
operator HGLOBAL() const { return _global; }
void Attach(HGLOBAL hGlobal)
{
Free();
_global = hGlobal;
}
HGLOBAL Detach()
{
HGLOBAL h = _global;
_global = NULL;
return h;
}
bool Alloc(UINT flags, SIZE_T size) throw();
bool Free() throw();
LPVOID Lock() const { return GlobalLock(_global); }
void Unlock() const { GlobalUnlock(_global); }
bool ReAlloc(SIZE_T size) throw();
};
class CGlobalLock
{
HGLOBAL _global;
LPVOID _ptr;
public:
LPVOID GetPointer() const { return _ptr; }
CGlobalLock(HGLOBAL hGlobal): _global(hGlobal)
{
_ptr = GlobalLock(hGlobal);
};
~CGlobalLock()
{
if (_ptr != NULL)
GlobalUnlock(_global);
}
};
}}
#endif
// Windows/MemoryGlobal.h
#ifndef __WINDOWS_MEMORY_GLOBAL_H
#define __WINDOWS_MEMORY_GLOBAL_H
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NMemory {
class CGlobal
{
HGLOBAL _global;
public:
CGlobal(): _global(NULL){};
~CGlobal() { Free(); }
operator HGLOBAL() const { return _global; }
void Attach(HGLOBAL hGlobal)
{
Free();
_global = hGlobal;
}
HGLOBAL Detach()
{
HGLOBAL h = _global;
_global = NULL;
return h;
}
bool Alloc(UINT flags, SIZE_T size) throw();
bool Free() throw();
LPVOID Lock() const { return GlobalLock(_global); }
void Unlock() const { GlobalUnlock(_global); }
bool ReAlloc(SIZE_T size) throw();
};
class CGlobalLock
{
HGLOBAL _global;
LPVOID _ptr;
public:
LPVOID GetPointer() const { return _ptr; }
CGlobalLock(HGLOBAL hGlobal): _global(hGlobal)
{
_ptr = GlobalLock(hGlobal);
};
~CGlobalLock()
{
if (_ptr != NULL)
GlobalUnlock(_global);
}
};
}}
#endif

224
CPP/Windows/MemoryLock.cpp
View File

@@ -1,112 +1,112 @@
// Windows/MemoryLock.cpp
#include "StdAfx.h"
#include "../../C/CpuArch.h"
#include "MemoryLock.h"
namespace NWindows {
namespace NSecurity {
#ifndef UNDER_CE
#ifdef _UNICODE
#define MY_FUNC_SELECT(f) :: f
#else
#define MY_FUNC_SELECT(f) my_ ## f
extern "C" {
typedef BOOL (WINAPI * Func_OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
typedef BOOL (WINAPI * Func_LookupPrivilegeValue)(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid);
typedef BOOL (WINAPI * Func_AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges,
PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
}
#define GET_PROC_ADDR(fff, name) Func_ ## fff my_ ## fff = (Func_ ## fff)GetProcAddress(hModule, name)
#endif
bool EnablePrivilege(LPCTSTR privilegeName, bool enable)
{
bool res = false;
#ifndef _UNICODE
HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
if (hModule == NULL)
return false;
GET_PROC_ADDR(OpenProcessToken, "OpenProcessToken");
GET_PROC_ADDR(LookupPrivilegeValue, "LookupPrivilegeValueA");
GET_PROC_ADDR(AdjustTokenPrivileges, "AdjustTokenPrivileges");
if (my_OpenProcessToken &&
my_AdjustTokenPrivileges &&
my_LookupPrivilegeValue)
#endif
{
HANDLE token;
if (MY_FUNC_SELECT(OpenProcessToken)(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
{
TOKEN_PRIVILEGES tp;
if (MY_FUNC_SELECT(LookupPrivilegeValue)(NULL, privilegeName, &(tp.Privileges[0].Luid)))
{
tp.PrivilegeCount = 1;
tp.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
if (MY_FUNC_SELECT(AdjustTokenPrivileges)(token, FALSE, &tp, 0, NULL, NULL))
res = (GetLastError() == ERROR_SUCCESS);
}
::CloseHandle(token);
}
}
#ifndef _UNICODE
::FreeLibrary(hModule);
#endif
return res;
}
typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
/*
We suppose that Window 10 works incorrectly with "Large Pages" at:
- Windows 10 1703 (15063)
- Windows 10 1709 (16299)
- Windows 10 1809 (17763) on some CPUs that have no 1 GB page support.
We need more information about that new BUG in Windows.
*/
unsigned Get_LargePages_RiskLevel()
{
OSVERSIONINFOEXW vi;
HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
if (!ntdll)
return 0;
Func_RtlGetVersion func = (Func_RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion");
if (!func)
return 0;
func(&vi);
if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
return 0;
if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
return 0;
if (vi.dwBuildNumber <= 16299)
return 1;
#ifdef MY_CPU_X86_OR_AMD64
if (!CPU_IsSupported_PageGB())
return 1;
#endif
return 0;
}
#endif
}}
// Windows/MemoryLock.cpp
#include "StdAfx.h"
#include "../../C/CpuArch.h"
#include "MemoryLock.h"
namespace NWindows {
namespace NSecurity {
#ifndef UNDER_CE
#ifdef _UNICODE
#define MY_FUNC_SELECT(f) :: f
#else
#define MY_FUNC_SELECT(f) my_ ## f
extern "C" {
typedef BOOL (WINAPI * Func_OpenProcessToken)(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle);
typedef BOOL (WINAPI * Func_LookupPrivilegeValue)(LPCTSTR lpSystemName, LPCTSTR lpName, PLUID lpLuid);
typedef BOOL (WINAPI * Func_AdjustTokenPrivileges)(HANDLE TokenHandle, BOOL DisableAllPrivileges,
PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength);
}
#define GET_PROC_ADDR(fff, name) Func_ ## fff my_ ## fff = (Func_ ## fff)GetProcAddress(hModule, name)
#endif
bool EnablePrivilege(LPCTSTR privilegeName, bool enable)
{
bool res = false;
#ifndef _UNICODE
HMODULE hModule = ::LoadLibrary(TEXT("Advapi32.dll"));
if (hModule == NULL)
return false;
GET_PROC_ADDR(OpenProcessToken, "OpenProcessToken");
GET_PROC_ADDR(LookupPrivilegeValue, "LookupPrivilegeValueA");
GET_PROC_ADDR(AdjustTokenPrivileges, "AdjustTokenPrivileges");
if (my_OpenProcessToken &&
my_AdjustTokenPrivileges &&
my_LookupPrivilegeValue)
#endif
{
HANDLE token;
if (MY_FUNC_SELECT(OpenProcessToken)(::GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &token))
{
TOKEN_PRIVILEGES tp;
if (MY_FUNC_SELECT(LookupPrivilegeValue)(NULL, privilegeName, &(tp.Privileges[0].Luid)))
{
tp.PrivilegeCount = 1;
tp.Privileges[0].Attributes = (enable ? SE_PRIVILEGE_ENABLED : 0);
if (MY_FUNC_SELECT(AdjustTokenPrivileges)(token, FALSE, &tp, 0, NULL, NULL))
res = (GetLastError() == ERROR_SUCCESS);
}
::CloseHandle(token);
}
}
#ifndef _UNICODE
::FreeLibrary(hModule);
#endif
return res;
}
typedef void (WINAPI * Func_RtlGetVersion) (OSVERSIONINFOEXW *);
/*
We suppose that Window 10 works incorrectly with "Large Pages" at:
- Windows 10 1703 (15063)
- Windows 10 1709 (16299)
- Windows 10 1809 (17763) on some CPUs that have no 1 GB page support.
We need more information about that new BUG in Windows.
*/
unsigned Get_LargePages_RiskLevel()
{
OSVERSIONINFOEXW vi;
HMODULE ntdll = ::GetModuleHandleW(L"ntdll.dll");
if (!ntdll)
return 0;
Func_RtlGetVersion func = (Func_RtlGetVersion)GetProcAddress(ntdll, "RtlGetVersion");
if (!func)
return 0;
func(&vi);
if (vi.dwPlatformId != VER_PLATFORM_WIN32_NT)
return 0;
if (vi.dwMajorVersion + vi.dwMinorVersion != 10)
return 0;
if (vi.dwBuildNumber <= 16299)
return 1;
#ifdef MY_CPU_X86_OR_AMD64
if (!CPU_IsSupported_PageGB())
return 1;
#endif
return 0;
}
#endif
}}

80
CPP/Windows/MemoryLock.h
View File

@@ -1,40 +1,40 @@
// Windows/MemoryLock.h
#ifndef __WINDOWS_MEMORY_LOCK_H
#define __WINDOWS_MEMORY_LOCK_H
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NSecurity {
#ifndef UNDER_CE
bool EnablePrivilege(LPCTSTR privilegeName, bool enable = true);
inline bool EnablePrivilege_LockMemory(bool enable = true)
{
return EnablePrivilege(SE_LOCK_MEMORY_NAME, enable);
}
inline void EnablePrivilege_SymLink()
{
/* Probably we do not to set any Privilege for junction points.
But we need them for Symbolic links */
NSecurity::EnablePrivilege(SE_RESTORE_NAME);
/* Probably we need only SE_RESTORE_NAME, but there is also
SE_CREATE_SYMBOLIC_LINK_NAME. So we set it also. Do we need it? */
NSecurity::EnablePrivilege(TEXT("SeCreateSymbolicLinkPrivilege")); // SE_CREATE_SYMBOLIC_LINK_NAME
// Do we need to set SE_BACKUP_NAME ?
}
unsigned Get_LargePages_RiskLevel();
#endif
}}
#endif
// Windows/MemoryLock.h
#ifndef __WINDOWS_MEMORY_LOCK_H
#define __WINDOWS_MEMORY_LOCK_H
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NSecurity {
#ifndef UNDER_CE
bool EnablePrivilege(LPCTSTR privilegeName, bool enable = true);
inline bool EnablePrivilege_LockMemory(bool enable = true)
{
return EnablePrivilege(SE_LOCK_MEMORY_NAME, enable);
}
inline void EnablePrivilege_SymLink()
{
/* Probably we do not to set any Privilege for junction points.
But we need them for Symbolic links */
NSecurity::EnablePrivilege(SE_RESTORE_NAME);
/* Probably we need only SE_RESTORE_NAME, but there is also
SE_CREATE_SYMBOLIC_LINK_NAME. So we set it also. Do we need it? */
NSecurity::EnablePrivilege(TEXT("SeCreateSymbolicLinkPrivilege")); // SE_CREATE_SYMBOLIC_LINK_NAME
// Do we need to set SE_BACKUP_NAME ?
}
unsigned Get_LargePages_RiskLevel();
#endif
}}
#endif

424
CPP/Windows/Menu.cpp
View File

@@ -1,212 +1,212 @@
// Windows/Menu.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Menu.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
/*
structures
MENUITEMINFOA
MENUITEMINFOW
contain additional member:
#if (WINVER >= 0x0500)
HBITMAP hbmpItem;
#endif
If we compile the source code with (WINVER >= 0x0500), some functions
will not work at NT 4.0, if cbSize is set as sizeof(MENUITEMINFO*).
So we use size of old version of structure. */
#if defined(UNDER_CE) || defined(_WIN64) || (WINVER < 0x0500)
#define my_compatib_MENUITEMINFOA_size sizeof(MENUITEMINFOA)
#define my_compatib_MENUITEMINFOW_size sizeof(MENUITEMINFOW)
#else
#define MY_STRUCT_SIZE_BEFORE(structname, member) ((UINT)(UINT_PTR)((LPBYTE)(&((structname*)0)->member) - (LPBYTE)(structname*)0))
#define my_compatib_MENUITEMINFOA_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOA, hbmpItem)
#define my_compatib_MENUITEMINFOW_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOW, hbmpItem)
#endif
static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOW &si)
{
ZeroMemory(&si, sizeof(si));
si.cbSize = my_compatib_MENUITEMINFOW_size; // sizeof(si);
si.fMask = item.fMask;
si.fType = item.fType;
si.fState = item.fState;
si.wID = item.wID;
si.hSubMenu = item.hSubMenu;
si.hbmpChecked = item.hbmpChecked;
si.hbmpUnchecked = item.hbmpUnchecked;
si.dwItemData = item.dwItemData;
}
#ifndef _UNICODE
static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOA &si)
{
ZeroMemory(&si, sizeof(si));
si.cbSize = my_compatib_MENUITEMINFOA_size; // sizeof(si);
si.fMask = item.fMask;
si.fType = item.fType;
si.fState = item.fState;
si.wID = item.wID;
si.hSubMenu = item.hSubMenu;
si.hbmpChecked = item.hbmpChecked;
si.hbmpUnchecked = item.hbmpUnchecked;
si.dwItemData = item.dwItemData;
}
#endif
static void ConvertItemToMyForm(const MENUITEMINFOW &si, CMenuItem &item)
{
item.fMask = si.fMask;
item.fType = si.fType;
item.fState = si.fState;
item.wID = si.wID;
item.hSubMenu = si.hSubMenu;
item.hbmpChecked = si.hbmpChecked;
item.hbmpUnchecked = si.hbmpUnchecked;
item.dwItemData = si.dwItemData;
}
#ifndef _UNICODE
static void ConvertItemToMyForm(const MENUITEMINFOA &si, CMenuItem &item)
{
item.fMask = si.fMask;
item.fType = si.fType;
item.fState = si.fState;
item.wID = si.wID;
item.hSubMenu = si.hSubMenu;
item.hbmpChecked = si.hbmpChecked;
item.hbmpUnchecked = si.hbmpUnchecked;
item.dwItemData = si.dwItemData;
}
#endif
bool CMenu::GetItem(UINT itemIndex, bool byPosition, CMenuItem &item)
{
const UINT kMaxSize = 512;
#ifndef _UNICODE
if (!g_IsNT)
{
CHAR s[kMaxSize + 1];
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
if (item.IsString())
{
si.cch = kMaxSize;
si.dwTypeData = s;
}
if (GetItemInfo(itemIndex, byPosition, &si))
{
ConvertItemToMyForm(si, item);
if (item.IsString())
item.StringValue = GetUnicodeString(s);
return true;
}
}
else
#endif
{
wchar_t s[kMaxSize + 1];
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
{
si.cch = kMaxSize;
si.dwTypeData = s;
}
if (GetItemInfo(itemIndex, byPosition, &si))
{
ConvertItemToMyForm(si, item);
if (item.IsString())
item.StringValue = s;
return true;
}
}
return false;
}
bool CMenu::SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
{
#ifndef _UNICODE
if (!g_IsNT)
{
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
AString s;
if (item.IsString())
{
s = GetSystemString(item.StringValue);
si.dwTypeData = (LPTSTR)(LPCTSTR)s;
}
return SetItemInfo(itemIndex, byPosition, &si);
}
else
#endif
{
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
si.dwTypeData = (LPWSTR)(LPCWSTR)item.StringValue;
return SetItemInfo(itemIndex, byPosition, &si);
}
}
bool CMenu::InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
{
#ifndef _UNICODE
if (!g_IsNT)
{
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
AString s;
if (item.IsString())
{
s = GetSystemString(item.StringValue);
si.dwTypeData = (LPTSTR)(LPCTSTR)s;
}
return InsertItem(itemIndex, byPosition, &si);
}
else
#endif
{
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
si.dwTypeData = (LPWSTR)(LPCWSTR)item.StringValue;
#ifdef UNDER_CE
UINT flags = (item.fType & MFT_SEPARATOR) ? MF_SEPARATOR : MF_STRING;
UINT id = item.wID;
if ((item.fMask & MIIM_SUBMENU) != 0)
{
flags |= MF_POPUP;
id = (UINT)item.hSubMenu;
}
if (!Insert(itemIndex, flags | (byPosition ? MF_BYPOSITION : MF_BYCOMMAND), id, item.StringValue))
return false;
return SetItemInfo(itemIndex, byPosition, &si);
#else
return InsertItem(itemIndex, byPosition, &si);
#endif
}
}
#ifndef _UNICODE
bool CMenu::AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem)
{
if (g_IsNT)
return BOOLToBool(::AppendMenuW(_menu, flags, newItemID, newItem));
else
return AppendItem(flags, newItemID, GetSystemString(newItem));
}
#endif
}
// Windows/Menu.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Menu.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
/*
structures
MENUITEMINFOA
MENUITEMINFOW
contain additional member:
#if (WINVER >= 0x0500)
HBITMAP hbmpItem;
#endif
If we compile the source code with (WINVER >= 0x0500), some functions
will not work at NT 4.0, if cbSize is set as sizeof(MENUITEMINFO*).
So we use size of old version of structure. */
#if defined(UNDER_CE) || defined(_WIN64) || (WINVER < 0x0500)
#define my_compatib_MENUITEMINFOA_size sizeof(MENUITEMINFOA)
#define my_compatib_MENUITEMINFOW_size sizeof(MENUITEMINFOW)
#else
#define MY_STRUCT_SIZE_BEFORE(structname, member) ((UINT)(UINT_PTR)((LPBYTE)(&((structname*)0)->member) - (LPBYTE)(structname*)0))
#define my_compatib_MENUITEMINFOA_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOA, hbmpItem)
#define my_compatib_MENUITEMINFOW_size MY_STRUCT_SIZE_BEFORE(MENUITEMINFOW, hbmpItem)
#endif
static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOW &si)
{
ZeroMemory(&si, sizeof(si));
si.cbSize = my_compatib_MENUITEMINFOW_size; // sizeof(si);
si.fMask = item.fMask;
si.fType = item.fType;
si.fState = item.fState;
si.wID = item.wID;
si.hSubMenu = item.hSubMenu;
si.hbmpChecked = item.hbmpChecked;
si.hbmpUnchecked = item.hbmpUnchecked;
si.dwItemData = item.dwItemData;
}
#ifndef _UNICODE
static void ConvertItemToSysForm(const CMenuItem &item, MENUITEMINFOA &si)
{
ZeroMemory(&si, sizeof(si));
si.cbSize = my_compatib_MENUITEMINFOA_size; // sizeof(si);
si.fMask = item.fMask;
si.fType = item.fType;
si.fState = item.fState;
si.wID = item.wID;
si.hSubMenu = item.hSubMenu;
si.hbmpChecked = item.hbmpChecked;
si.hbmpUnchecked = item.hbmpUnchecked;
si.dwItemData = item.dwItemData;
}
#endif
static void ConvertItemToMyForm(const MENUITEMINFOW &si, CMenuItem &item)
{
item.fMask = si.fMask;
item.fType = si.fType;
item.fState = si.fState;
item.wID = si.wID;
item.hSubMenu = si.hSubMenu;
item.hbmpChecked = si.hbmpChecked;
item.hbmpUnchecked = si.hbmpUnchecked;
item.dwItemData = si.dwItemData;
}
#ifndef _UNICODE
static void ConvertItemToMyForm(const MENUITEMINFOA &si, CMenuItem &item)
{
item.fMask = si.fMask;
item.fType = si.fType;
item.fState = si.fState;
item.wID = si.wID;
item.hSubMenu = si.hSubMenu;
item.hbmpChecked = si.hbmpChecked;
item.hbmpUnchecked = si.hbmpUnchecked;
item.dwItemData = si.dwItemData;
}
#endif
bool CMenu::GetItem(UINT itemIndex, bool byPosition, CMenuItem &item)
{
const UINT kMaxSize = 512;
#ifndef _UNICODE
if (!g_IsNT)
{
CHAR s[kMaxSize + 1];
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
if (item.IsString())
{
si.cch = kMaxSize;
si.dwTypeData = s;
}
if (GetItemInfo(itemIndex, byPosition, &si))
{
ConvertItemToMyForm(si, item);
if (item.IsString())
item.StringValue = GetUnicodeString(s);
return true;
}
}
else
#endif
{
wchar_t s[kMaxSize + 1];
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
{
si.cch = kMaxSize;
si.dwTypeData = s;
}
if (GetItemInfo(itemIndex, byPosition, &si))
{
ConvertItemToMyForm(si, item);
if (item.IsString())
item.StringValue = s;
return true;
}
}
return false;
}
bool CMenu::SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
{
#ifndef _UNICODE
if (!g_IsNT)
{
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
AString s;
if (item.IsString())
{
s = GetSystemString(item.StringValue);
si.dwTypeData = (LPTSTR)(LPCTSTR)s;
}
return SetItemInfo(itemIndex, byPosition, &si);
}
else
#endif
{
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
si.dwTypeData = (LPWSTR)(LPCWSTR)item.StringValue;
return SetItemInfo(itemIndex, byPosition, &si);
}
}
bool CMenu::InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item)
{
#ifndef _UNICODE
if (!g_IsNT)
{
MENUITEMINFOA si;
ConvertItemToSysForm(item, si);
AString s;
if (item.IsString())
{
s = GetSystemString(item.StringValue);
si.dwTypeData = (LPTSTR)(LPCTSTR)s;
}
return InsertItem(itemIndex, byPosition, &si);
}
else
#endif
{
MENUITEMINFOW si;
ConvertItemToSysForm(item, si);
if (item.IsString())
si.dwTypeData = (LPWSTR)(LPCWSTR)item.StringValue;
#ifdef UNDER_CE
UINT flags = (item.fType & MFT_SEPARATOR) ? MF_SEPARATOR : MF_STRING;
UINT id = item.wID;
if ((item.fMask & MIIM_SUBMENU) != 0)
{
flags |= MF_POPUP;
id = (UINT)item.hSubMenu;
}
if (!Insert(itemIndex, flags | (byPosition ? MF_BYPOSITION : MF_BYCOMMAND), id, item.StringValue))
return false;
return SetItemInfo(itemIndex, byPosition, &si);
#else
return InsertItem(itemIndex, byPosition, &si);
#endif
}
}
#ifndef _UNICODE
bool CMenu::AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem)
{
if (g_IsNT)
return BOOLToBool(::AppendMenuW(_menu, flags, newItemID, newItem));
else
return AppendItem(flags, newItemID, GetSystemString(newItem));
}
#endif
}

316
CPP/Windows/Menu.h
View File

@@ -1,158 +1,158 @@
// Windows/Menu.h
#ifndef __WINDOWS_MENU_H
#define __WINDOWS_MENU_H
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows {
struct CMenuItem
{
UString StringValue;
UINT fMask;
UINT fType;
UINT fState;
UINT wID;
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
ULONG_PTR dwItemData;
// LPTSTR dwTypeData;
// UINT cch;
// HBITMAP hbmpItem;
bool IsString() const // change it MIIM_STRING
{ return ((fMask & MIIM_TYPE) != 0 && (fType == MFT_STRING)); }
bool IsSeparator() const { return (fType == MFT_SEPARATOR); }
CMenuItem(): fMask(0), fType(0), fState(0), wID(0), hSubMenu(0), hbmpChecked(0),
hbmpUnchecked(0), dwItemData(0) {}
};
class CMenu
{
HMENU _menu;
public:
CMenu(): _menu(NULL) {};
operator HMENU() const { return _menu; }
void Attach(HMENU menu) { _menu = menu; }
HMENU Detach()
{
HMENU menu = _menu;
_menu = NULL;
return menu;
}
bool Create()
{
_menu = ::CreateMenu();
return (_menu != NULL);
}
bool CreatePopup()
{
_menu = ::CreatePopupMenu();
return (_menu != NULL);
}
bool Destroy()
{
if (_menu == NULL)
return false;
return BOOLToBool(::DestroyMenu(Detach()));
}
int GetItemCount()
{
#ifdef UNDER_CE
for (int i = 0;; i++)
{
CMenuItem item;
item.fMask = MIIM_STATE;
if (!GetItem(i, true, item))
return i;
}
#else
return GetMenuItemCount(_menu);
#endif
}
HMENU GetSubMenu(int pos) { return ::GetSubMenu(_menu, pos); }
#ifndef UNDER_CE
/*
bool GetItemString(UINT idItem, UINT flag, CSysString &result)
{
result.Empty();
int len = ::GetMenuString(_menu, idItem, 0, 0, flag);
int len2 = ::GetMenuString(_menu, idItem, result.GetBuf(len + 2), len + 1, flag);
if (len > len2)
len = len2;
result.ReleaseBuf_CalcLen(len + 2);
return (len != 0);
}
*/
UINT GetItemID(int pos) { return ::GetMenuItemID(_menu, pos); }
UINT GetItemState(UINT id, UINT flags) { return ::GetMenuState(_menu, id, flags); }
#endif
bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo)
{ return BOOLToBool(::GetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo)
{ return BOOLToBool(::SetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool AppendItem(UINT flags, UINT_PTR newItemID, LPCTSTR newItem)
{ return BOOLToBool(::AppendMenu(_menu, flags, newItemID, newItem)); }
bool Insert(UINT position, UINT flags, UINT_PTR idNewItem, LPCTSTR newItem)
{ return BOOLToBool(::InsertMenu(_menu, position, flags, idNewItem, newItem)); }
#ifndef UNDER_CE
bool InsertItem(UINT itemIndex, bool byPosition, LPCMENUITEMINFO itemInfo)
{ return BOOLToBool(::InsertMenuItem(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
#endif
bool RemoveItem(UINT item, UINT flags) { return BOOLToBool(::RemoveMenu(_menu, item, flags)); }
void RemoveAllItemsFrom(UINT index) { while (RemoveItem(index, MF_BYPOSITION)); }
void RemoveAllItems() { RemoveAllItemsFrom(0); }
#ifndef _UNICODE
bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::GetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool InsertItem(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::InsertMenuItemW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::SetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem);
#endif
bool GetItem(UINT itemIndex, bool byPosition, CMenuItem &item);
bool SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
bool InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
int Track(UINT flags, int x, int y, HWND hWnd) { return ::TrackPopupMenuEx(_menu, flags, x, y, hWnd, NULL); }
bool CheckRadioItem(UINT idFirst, UINT idLast, UINT idCheck, UINT flags)
{ return BOOLToBool(::CheckMenuRadioItem(_menu, idFirst, idLast, idCheck, flags)); }
DWORD CheckItem(UINT id, UINT uCheck) { return ::CheckMenuItem(_menu, id, uCheck); }
DWORD CheckItemByID(UINT id, bool check) { return CheckItem(id, MF_BYCOMMAND | (check ? MF_CHECKED : MF_UNCHECKED)); }
BOOL EnableItem(UINT uIDEnableItem, UINT uEnable) { return EnableMenuItem(_menu, uIDEnableItem, uEnable); }
};
class CMenuDestroyer
{
CMenu *_menu;
public:
CMenuDestroyer(CMenu &menu): _menu(&menu) {}
CMenuDestroyer(): _menu(0) {}
~CMenuDestroyer() { if (_menu) _menu->Destroy(); }
void Attach(CMenu &menu) { _menu = &menu; }
void Disable() { _menu = 0; }
};
}
#endif
// Windows/Menu.h
#ifndef __WINDOWS_MENU_H
#define __WINDOWS_MENU_H
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows {
struct CMenuItem
{
UString StringValue;
UINT fMask;
UINT fType;
UINT fState;
UINT wID;
HMENU hSubMenu;
HBITMAP hbmpChecked;
HBITMAP hbmpUnchecked;
ULONG_PTR dwItemData;
// LPTSTR dwTypeData;
// UINT cch;
// HBITMAP hbmpItem;
bool IsString() const // change it MIIM_STRING
{ return ((fMask & MIIM_TYPE) != 0 && (fType == MFT_STRING)); }
bool IsSeparator() const { return (fType == MFT_SEPARATOR); }
CMenuItem(): fMask(0), fType(0), fState(0), wID(0), hSubMenu(0), hbmpChecked(0),
hbmpUnchecked(0), dwItemData(0) {}
};
class CMenu
{
HMENU _menu;
public:
CMenu(): _menu(NULL) {};
operator HMENU() const { return _menu; }
void Attach(HMENU menu) { _menu = menu; }
HMENU Detach()
{
HMENU menu = _menu;
_menu = NULL;
return menu;
}
bool Create()
{
_menu = ::CreateMenu();
return (_menu != NULL);
}
bool CreatePopup()
{
_menu = ::CreatePopupMenu();
return (_menu != NULL);
}
bool Destroy()
{
if (_menu == NULL)
return false;
return BOOLToBool(::DestroyMenu(Detach()));
}
int GetItemCount()
{
#ifdef UNDER_CE
for (int i = 0;; i++)
{
CMenuItem item;
item.fMask = MIIM_STATE;
if (!GetItem(i, true, item))
return i;
}
#else
return GetMenuItemCount(_menu);
#endif
}
HMENU GetSubMenu(int pos) { return ::GetSubMenu(_menu, pos); }
#ifndef UNDER_CE
/*
bool GetItemString(UINT idItem, UINT flag, CSysString &result)
{
result.Empty();
int len = ::GetMenuString(_menu, idItem, 0, 0, flag);
int len2 = ::GetMenuString(_menu, idItem, result.GetBuf(len + 2), len + 1, flag);
if (len > len2)
len = len2;
result.ReleaseBuf_CalcLen(len + 2);
return (len != 0);
}
*/
UINT GetItemID(int pos) { return ::GetMenuItemID(_menu, pos); }
UINT GetItemState(UINT id, UINT flags) { return ::GetMenuState(_menu, id, flags); }
#endif
bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo)
{ return BOOLToBool(::GetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFO itemInfo)
{ return BOOLToBool(::SetMenuItemInfo(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool AppendItem(UINT flags, UINT_PTR newItemID, LPCTSTR newItem)
{ return BOOLToBool(::AppendMenu(_menu, flags, newItemID, newItem)); }
bool Insert(UINT position, UINT flags, UINT_PTR idNewItem, LPCTSTR newItem)
{ return BOOLToBool(::InsertMenu(_menu, position, flags, idNewItem, newItem)); }
#ifndef UNDER_CE
bool InsertItem(UINT itemIndex, bool byPosition, LPCMENUITEMINFO itemInfo)
{ return BOOLToBool(::InsertMenuItem(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
#endif
bool RemoveItem(UINT item, UINT flags) { return BOOLToBool(::RemoveMenu(_menu, item, flags)); }
void RemoveAllItemsFrom(UINT index) { while (RemoveItem(index, MF_BYPOSITION)); }
void RemoveAllItems() { RemoveAllItemsFrom(0); }
#ifndef _UNICODE
bool GetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::GetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool InsertItem(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::InsertMenuItemW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool SetItemInfo(UINT itemIndex, bool byPosition, LPMENUITEMINFOW itemInfo)
{ return BOOLToBool(::SetMenuItemInfoW(_menu, itemIndex, BoolToBOOL(byPosition), itemInfo)); }
bool AppendItem(UINT flags, UINT_PTR newItemID, LPCWSTR newItem);
#endif
bool GetItem(UINT itemIndex, bool byPosition, CMenuItem &item);
bool SetItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
bool InsertItem(UINT itemIndex, bool byPosition, const CMenuItem &item);
int Track(UINT flags, int x, int y, HWND hWnd) { return ::TrackPopupMenuEx(_menu, flags, x, y, hWnd, NULL); }
bool CheckRadioItem(UINT idFirst, UINT idLast, UINT idCheck, UINT flags)
{ return BOOLToBool(::CheckMenuRadioItem(_menu, idFirst, idLast, idCheck, flags)); }
DWORD CheckItem(UINT id, UINT uCheck) { return ::CheckMenuItem(_menu, id, uCheck); }
DWORD CheckItemByID(UINT id, bool check) { return CheckItem(id, MF_BYCOMMAND | (check ? MF_CHECKED : MF_UNCHECKED)); }
BOOL EnableItem(UINT uIDEnableItem, UINT uEnable) { return EnableMenuItem(_menu, uIDEnableItem, uEnable); }
};
class CMenuDestroyer
{
CMenu *_menu;
public:
CMenuDestroyer(CMenu &menu): _menu(&menu) {}
CMenuDestroyer(): _menu(0) {}
~CMenuDestroyer() { if (_menu) _menu->Destroy(); }
void Attach(CMenu &menu) { _menu = &menu; }
void Disable() { _menu = 0; }
};
}
#endif

74
CPP/Windows/NationalTime.cpp
View File

@@ -1,37 +1,37 @@
// Windows/NationalTime.cpp
#include "StdAfx.h"
#include "NationalTime.h"
namespace NWindows {
namespace NNational {
namespace NTime {
bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString)
{
resultString.Empty();
int numChars = ::GetTimeFormat(locale, flags, time, format, NULL, 0);
if (numChars == 0)
return false;
numChars = ::GetTimeFormat(locale, flags, time, format,
resultString.GetBuf(numChars), numChars + 1);
resultString.ReleaseBuf_CalcLen(numChars);
return (numChars != 0);
}
bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString)
{
resultString.Empty();
int numChars = ::GetDateFormat(locale, flags, time, format, NULL, 0);
if (numChars == 0)
return false;
numChars = ::GetDateFormat(locale, flags, time, format,
resultString.GetBuf(numChars), numChars + 1);
resultString.ReleaseBuf_CalcLen(numChars);
return (numChars != 0);
}
}}}
// Windows/NationalTime.cpp
#include "StdAfx.h"
#include "NationalTime.h"
namespace NWindows {
namespace NNational {
namespace NTime {
bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString)
{
resultString.Empty();
int numChars = ::GetTimeFormat(locale, flags, time, format, NULL, 0);
if (numChars == 0)
return false;
numChars = ::GetTimeFormat(locale, flags, time, format,
resultString.GetBuf(numChars), numChars + 1);
resultString.ReleaseBuf_CalcLen(numChars);
return (numChars != 0);
}
bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString)
{
resultString.Empty();
int numChars = ::GetDateFormat(locale, flags, time, format, NULL, 0);
if (numChars == 0)
return false;
numChars = ::GetDateFormat(locale, flags, time, format,
resultString.GetBuf(numChars), numChars + 1);
resultString.ReleaseBuf_CalcLen(numChars);
return (numChars != 0);
}
}}}

40
CPP/Windows/NationalTime.h
View File

@@ -1,20 +1,20 @@
// Windows/NationalTime.h
#ifndef __WINDOWS_NATIONAL_TIME_H
#define __WINDOWS_NATIONAL_TIME_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NNational {
namespace NTime {
bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString);
bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString);
}}}
#endif
// Windows/NationalTime.h
#ifndef __WINDOWS_NATIONAL_TIME_H
#define __WINDOWS_NATIONAL_TIME_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NNational {
namespace NTime {
bool MyGetTimeFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString);
bool MyGetDateFormat(LCID locale, DWORD flags, CONST SYSTEMTIME *time,
LPCTSTR format, CSysString &resultString);
}}}
#endif

752
CPP/Windows/Net.cpp
View File

@@ -1,376 +1,376 @@
// Windows/Net.cpp
#include "StdAfx.h"
#include "../Common/MyBuffer.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Net.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NNet {
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource)
{
Close();
DWORD result = ::WNetOpenEnum(scope, type, usage, netResource, &_handle);
_handleAllocated = (result == NO_ERROR);
return result;
}
#ifndef _UNICODE
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource)
{
Close();
DWORD result = ::WNetOpenEnumW(scope, type, usage, netResource, &_handle);
_handleAllocated = (result == NO_ERROR);
return result;
}
#endif
static void SetComplexString(bool &defined, CSysString &destString, LPCTSTR srsString)
{
defined = (srsString != 0);
if (defined)
destString = srsString;
else
destString.Empty();
}
static void ConvertNETRESOURCEToCResource(const NETRESOURCE &netResource, CResource &resource)
{
resource.Scope = netResource.dwScope;
resource.Type = netResource.dwType;
resource.DisplayType = netResource.dwDisplayType;
resource.Usage = netResource.dwUsage;
SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
}
static void SetComplexString2(LPTSTR *destString, bool defined, const CSysString &srcString)
{
if (defined)
*destString = (TCHAR *)(const TCHAR *)srcString;
else
*destString = 0;
}
static void ConvertCResourceToNETRESOURCE(const CResource &resource, NETRESOURCE &netResource)
{
netResource.dwScope = resource.Scope;
netResource.dwType = resource.Type;
netResource.dwDisplayType = resource.DisplayType;
netResource.dwUsage = resource.Usage;
SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
}
#ifndef _UNICODE
static void SetComplexString(bool &defined, UString &destString, LPCWSTR srsString)
{
defined = (srsString != 0);
if (defined)
destString = srsString;
else
destString.Empty();
}
static void ConvertNETRESOURCEToCResource(const NETRESOURCEW &netResource, CResourceW &resource)
{
resource.Scope = netResource.dwScope;
resource.Type = netResource.dwType;
resource.DisplayType = netResource.dwDisplayType;
resource.Usage = netResource.dwUsage;
SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
}
static void SetComplexString2(LPWSTR *destString, bool defined, const UString &srcString)
{
if (defined)
*destString = (WCHAR *)(const WCHAR *)srcString;
else
*destString = 0;
}
static void ConvertCResourceToNETRESOURCE(const CResourceW &resource, NETRESOURCEW &netResource)
{
netResource.dwScope = resource.Scope;
netResource.dwType = resource.Type;
netResource.dwDisplayType = resource.DisplayType;
netResource.dwUsage = resource.Usage;
SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
}
static void ConvertResourceWToResource(const CResourceW &resourceW, CResource &resource)
{
*(CResourceBase *)&resource = *(CResourceBase *)&resourceW;
resource.LocalName = GetSystemString(resourceW.LocalName);
resource.RemoteName = GetSystemString(resourceW.RemoteName);
resource.Comment = GetSystemString(resourceW.Comment);
resource.Provider = GetSystemString(resourceW.Provider);
}
static void ConvertResourceToResourceW(const CResource &resource, CResourceW &resourceW)
{
*(CResourceBase *)&resourceW = *(CResourceBase *)&resource;
resourceW.LocalName = GetUnicodeString(resource.LocalName);
resourceW.RemoteName = GetUnicodeString(resource.RemoteName);
resourceW.Comment = GetUnicodeString(resource.Comment);
resourceW.Provider = GetUnicodeString(resource.Provider);
}
#endif
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource)
{
NETRESOURCE netResource;
LPNETRESOURCE pointer;
if (resource == 0)
pointer = 0;
else
{
ConvertCResourceToNETRESOURCE(*resource, netResource);
pointer = &netResource;
}
return Open(scope, type, usage, pointer);
}
#ifndef _UNICODE
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource)
{
if (g_IsNT)
{
NETRESOURCEW netResource;
LPNETRESOURCEW pointer;
if (resource == 0)
pointer = 0;
else
{
ConvertCResourceToNETRESOURCE(*resource, netResource);
pointer = &netResource;
}
return Open(scope, type, usage, pointer);
}
CResource *pointer;
CResource resourceA;
if (resource == 0)
pointer = 0;
else
{
ConvertResourceWToResource(*resource, resourceA);
pointer = &resourceA;
}
return Open(scope, type, usage, pointer);
}
#endif
DWORD CEnum::Close()
{
if (!_handleAllocated)
return NO_ERROR;
DWORD result = ::WNetCloseEnum(_handle);
_handleAllocated = (result != NO_ERROR);
return result;
}
DWORD CEnum::Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
{
return ::WNetEnumResource(_handle, lpcCount, lpBuffer, lpBufferSize);
}
#ifndef _UNICODE
DWORD CEnum::NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
{
return ::WNetEnumResourceW(_handle, lpcCount, lpBuffer, lpBufferSize);
}
#endif
DWORD CEnum::Next(CResource &resource)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
DWORD numEntries = 1;
DWORD result = Next(&numEntries, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
if (numEntries != 1)
return (DWORD)E_FAIL;
ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
return result;
}
#ifndef _UNICODE
DWORD CEnum::Next(CResourceW &resource)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
DWORD numEntries = 1;
DWORD result = NextW(&numEntries, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
if (numEntries != 1)
return (DWORD)E_FAIL;
ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
return result;
}
CResource resourceA;
DWORD result = Next(resourceA);
ConvertResourceToResourceW(resourceA, resource);
return result;
}
#endif
DWORD GetResourceParent(const CResource &resource, CResource &parentResource)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
DWORD result = ::WNetGetResourceParent(&netResource, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
return result;
}
#ifndef _UNICODE
DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
DWORD result = ::WNetGetResourceParentW(&netResource, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
return result;
}
CResource resourceA, parentResourceA;
ConvertResourceWToResource(resource, resourceA);
DWORD result = GetResourceParent(resourceA, parentResourceA);
ConvertResourceToResourceW(parentResourceA, parentResource);
return result;
}
#endif
DWORD GetResourceInformation(const CResource &resource,
CResource &destResource, CSysString &systemPathPart)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
LPTSTR lplpSystem;
DWORD result = ::WNetGetResourceInformation(&netResource,
lpnrLocal, &bufferSize, &lplpSystem);
if (result != NO_ERROR)
return result;
if (lplpSystem != 0)
systemPathPart = lplpSystem;
ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
return result;
}
#ifndef _UNICODE
DWORD GetResourceInformation(const CResourceW &resource,
CResourceW &destResource, UString &systemPathPart)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
LPWSTR lplpSystem;
DWORD result = ::WNetGetResourceInformationW(&netResource,
lpnrLocal, &bufferSize, &lplpSystem);
if (result != NO_ERROR)
return result;
if (lplpSystem != 0)
systemPathPart = lplpSystem;
ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
return result;
}
CResource resourceA, destResourceA;
ConvertResourceWToResource(resource, resourceA);
AString systemPathPartA;
DWORD result = GetResourceInformation(resourceA, destResourceA, systemPathPartA);
ConvertResourceToResourceW(destResourceA, destResource);
systemPathPart = GetUnicodeString(systemPathPartA);
return result;
}
#endif
DWORD AddConnection2(const CResource &resource,
LPCTSTR password, LPCTSTR userName, DWORD flags)
{
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
return ::WNetAddConnection2(&netResource,
password, userName, flags);
}
DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
#ifndef _UNICODE
DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags)
{
if (g_IsNT)
{
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
return ::WNetAddConnection2W(&netResource,password, userName, flags);
}
CResource resourceA;
ConvertResourceWToResource(resource, resourceA);
const CSysString passwordA (GetSystemString(password));
const CSysString userNameA (GetSystemString(userName));
return AddConnection2(resourceA,
password ? (LPCTSTR)passwordA: 0,
userName ? (LPCTSTR)userNameA: 0,
flags);
}
#endif
}}
// Windows/Net.cpp
#include "StdAfx.h"
#include "../Common/MyBuffer.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Net.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NNet {
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource)
{
Close();
DWORD result = ::WNetOpenEnum(scope, type, usage, netResource, &_handle);
_handleAllocated = (result == NO_ERROR);
return result;
}
#ifndef _UNICODE
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource)
{
Close();
DWORD result = ::WNetOpenEnumW(scope, type, usage, netResource, &_handle);
_handleAllocated = (result == NO_ERROR);
return result;
}
#endif
static void SetComplexString(bool &defined, CSysString &destString, LPCTSTR srsString)
{
defined = (srsString != 0);
if (defined)
destString = srsString;
else
destString.Empty();
}
static void ConvertNETRESOURCEToCResource(const NETRESOURCE &netResource, CResource &resource)
{
resource.Scope = netResource.dwScope;
resource.Type = netResource.dwType;
resource.DisplayType = netResource.dwDisplayType;
resource.Usage = netResource.dwUsage;
SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
}
static void SetComplexString2(LPTSTR *destString, bool defined, const CSysString &srcString)
{
if (defined)
*destString = (TCHAR *)(const TCHAR *)srcString;
else
*destString = 0;
}
static void ConvertCResourceToNETRESOURCE(const CResource &resource, NETRESOURCE &netResource)
{
netResource.dwScope = resource.Scope;
netResource.dwType = resource.Type;
netResource.dwDisplayType = resource.DisplayType;
netResource.dwUsage = resource.Usage;
SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
}
#ifndef _UNICODE
static void SetComplexString(bool &defined, UString &destString, LPCWSTR srsString)
{
defined = (srsString != 0);
if (defined)
destString = srsString;
else
destString.Empty();
}
static void ConvertNETRESOURCEToCResource(const NETRESOURCEW &netResource, CResourceW &resource)
{
resource.Scope = netResource.dwScope;
resource.Type = netResource.dwType;
resource.DisplayType = netResource.dwDisplayType;
resource.Usage = netResource.dwUsage;
SetComplexString(resource.LocalNameIsDefined, resource.LocalName, netResource.lpLocalName);
SetComplexString(resource.RemoteNameIsDefined, resource.RemoteName, netResource.lpRemoteName);
SetComplexString(resource.CommentIsDefined, resource.Comment, netResource.lpComment);
SetComplexString(resource.ProviderIsDefined, resource.Provider, netResource.lpProvider);
}
static void SetComplexString2(LPWSTR *destString, bool defined, const UString &srcString)
{
if (defined)
*destString = (WCHAR *)(const WCHAR *)srcString;
else
*destString = 0;
}
static void ConvertCResourceToNETRESOURCE(const CResourceW &resource, NETRESOURCEW &netResource)
{
netResource.dwScope = resource.Scope;
netResource.dwType = resource.Type;
netResource.dwDisplayType = resource.DisplayType;
netResource.dwUsage = resource.Usage;
SetComplexString2(&netResource.lpLocalName, resource.LocalNameIsDefined, resource.LocalName);
SetComplexString2(&netResource.lpRemoteName, resource.RemoteNameIsDefined, resource.RemoteName);
SetComplexString2(&netResource.lpComment, resource.CommentIsDefined, resource.Comment);
SetComplexString2(&netResource.lpProvider, resource.ProviderIsDefined, resource.Provider);
}
static void ConvertResourceWToResource(const CResourceW &resourceW, CResource &resource)
{
*(CResourceBase *)&resource = *(CResourceBase *)&resourceW;
resource.LocalName = GetSystemString(resourceW.LocalName);
resource.RemoteName = GetSystemString(resourceW.RemoteName);
resource.Comment = GetSystemString(resourceW.Comment);
resource.Provider = GetSystemString(resourceW.Provider);
}
static void ConvertResourceToResourceW(const CResource &resource, CResourceW &resourceW)
{
*(CResourceBase *)&resourceW = *(CResourceBase *)&resource;
resourceW.LocalName = GetUnicodeString(resource.LocalName);
resourceW.RemoteName = GetUnicodeString(resource.RemoteName);
resourceW.Comment = GetUnicodeString(resource.Comment);
resourceW.Provider = GetUnicodeString(resource.Provider);
}
#endif
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource)
{
NETRESOURCE netResource;
LPNETRESOURCE pointer;
if (resource == 0)
pointer = 0;
else
{
ConvertCResourceToNETRESOURCE(*resource, netResource);
pointer = &netResource;
}
return Open(scope, type, usage, pointer);
}
#ifndef _UNICODE
DWORD CEnum::Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource)
{
if (g_IsNT)
{
NETRESOURCEW netResource;
LPNETRESOURCEW pointer;
if (resource == 0)
pointer = 0;
else
{
ConvertCResourceToNETRESOURCE(*resource, netResource);
pointer = &netResource;
}
return Open(scope, type, usage, pointer);
}
CResource *pointer;
CResource resourceA;
if (resource == 0)
pointer = 0;
else
{
ConvertResourceWToResource(*resource, resourceA);
pointer = &resourceA;
}
return Open(scope, type, usage, pointer);
}
#endif
DWORD CEnum::Close()
{
if (!_handleAllocated)
return NO_ERROR;
DWORD result = ::WNetCloseEnum(_handle);
_handleAllocated = (result != NO_ERROR);
return result;
}
DWORD CEnum::Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
{
return ::WNetEnumResource(_handle, lpcCount, lpBuffer, lpBufferSize);
}
#ifndef _UNICODE
DWORD CEnum::NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize)
{
return ::WNetEnumResourceW(_handle, lpcCount, lpBuffer, lpBufferSize);
}
#endif
DWORD CEnum::Next(CResource &resource)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
DWORD numEntries = 1;
DWORD result = Next(&numEntries, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
if (numEntries != 1)
return (DWORD)E_FAIL;
ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
return result;
}
#ifndef _UNICODE
DWORD CEnum::Next(CResourceW &resource)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
DWORD numEntries = 1;
DWORD result = NextW(&numEntries, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
if (numEntries != 1)
return (DWORD)E_FAIL;
ConvertNETRESOURCEToCResource(lpnrLocal[0], resource);
return result;
}
CResource resourceA;
DWORD result = Next(resourceA);
ConvertResourceToResourceW(resourceA, resource);
return result;
}
#endif
DWORD GetResourceParent(const CResource &resource, CResource &parentResource)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
DWORD result = ::WNetGetResourceParent(&netResource, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
return result;
}
#ifndef _UNICODE
DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
DWORD result = ::WNetGetResourceParentW(&netResource, lpnrLocal, &bufferSize);
if (result != NO_ERROR)
return result;
ConvertNETRESOURCEToCResource(lpnrLocal[0], parentResource);
return result;
}
CResource resourceA, parentResourceA;
ConvertResourceWToResource(resource, resourceA);
DWORD result = GetResourceParent(resourceA, parentResourceA);
ConvertResourceToResourceW(parentResourceA, parentResource);
return result;
}
#endif
DWORD GetResourceInformation(const CResource &resource,
CResource &destResource, CSysString &systemPathPart)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCE lpnrLocal = (LPNETRESOURCE) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
LPTSTR lplpSystem;
DWORD result = ::WNetGetResourceInformation(&netResource,
lpnrLocal, &bufferSize, &lplpSystem);
if (result != NO_ERROR)
return result;
if (lplpSystem != 0)
systemPathPart = lplpSystem;
ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
return result;
}
#ifndef _UNICODE
DWORD GetResourceInformation(const CResourceW &resource,
CResourceW &destResource, UString &systemPathPart)
{
if (g_IsNT)
{
const DWORD kBufferSize = 16384;
CByteArr byteBuffer(kBufferSize);
LPNETRESOURCEW lpnrLocal = (LPNETRESOURCEW) (BYTE *)(byteBuffer);
ZeroMemory(lpnrLocal, kBufferSize);
DWORD bufferSize = kBufferSize;
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
LPWSTR lplpSystem;
DWORD result = ::WNetGetResourceInformationW(&netResource,
lpnrLocal, &bufferSize, &lplpSystem);
if (result != NO_ERROR)
return result;
if (lplpSystem != 0)
systemPathPart = lplpSystem;
ConvertNETRESOURCEToCResource(lpnrLocal[0], destResource);
return result;
}
CResource resourceA, destResourceA;
ConvertResourceWToResource(resource, resourceA);
AString systemPathPartA;
DWORD result = GetResourceInformation(resourceA, destResourceA, systemPathPartA);
ConvertResourceToResourceW(destResourceA, destResource);
systemPathPart = GetUnicodeString(systemPathPartA);
return result;
}
#endif
DWORD AddConnection2(const CResource &resource,
LPCTSTR password, LPCTSTR userName, DWORD flags)
{
NETRESOURCE netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
return ::WNetAddConnection2(&netResource,
password, userName, flags);
}
DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
#ifndef _UNICODE
DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags)
{
if (g_IsNT)
{
NETRESOURCEW netResource;
ConvertCResourceToNETRESOURCE(resource, netResource);
return ::WNetAddConnection2W(&netResource,password, userName, flags);
}
CResource resourceA;
ConvertResourceWToResource(resource, resourceA);
const CSysString passwordA (GetSystemString(password));
const CSysString userNameA (GetSystemString(userName));
return AddConnection2(resourceA,
password ? (LPCTSTR)passwordA: 0,
userName ? (LPCTSTR)userNameA: 0,
flags);
}
#endif
}}

172
CPP/Windows/Net.h
View File

@@ -1,86 +1,86 @@
// Windows/Net.h
#ifndef __WINDOWS_NET_H
#define __WINDOWS_NET_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NNet {
struct CResourceBase
{
DWORD Scope;
DWORD Type;
DWORD DisplayType;
DWORD Usage;
bool LocalNameIsDefined;
bool RemoteNameIsDefined;
bool CommentIsDefined;
bool ProviderIsDefined;
};
struct CResource: public CResourceBase
{
CSysString LocalName;
CSysString RemoteName;
CSysString Comment;
CSysString Provider;
};
#ifdef _UNICODE
typedef CResource CResourceW;
#else
struct CResourceW: public CResourceBase
{
UString LocalName;
UString RemoteName;
UString Comment;
UString Provider;
};
#endif
class CEnum
{
HANDLE _handle;
bool _handleAllocated;
DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource);
DWORD Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
#ifndef _UNICODE
DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource);
DWORD NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
#endif
protected:
bool IsHandleAllocated() const { return _handleAllocated; }
public:
CEnum(): _handleAllocated(false) {}
~CEnum() { Close(); }
DWORD Close();
DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource);
DWORD Next(CResource &resource);
#ifndef _UNICODE
DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource);
DWORD Next(CResourceW &resource);
#endif
};
DWORD GetResourceParent(const CResource &resource, CResource &parentResource);
#ifndef _UNICODE
DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource);
#endif
DWORD GetResourceInformation(const CResource &resource,
CResource &destResource, CSysString &systemPathPart);
#ifndef _UNICODE
DWORD GetResourceInformation(const CResourceW &resource,
CResourceW &destResource, UString &systemPathPart);
#endif
DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
#ifndef _UNICODE
DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags);
#endif
}}
#endif
// Windows/Net.h
#ifndef __WINDOWS_NET_H
#define __WINDOWS_NET_H
#include "../Common/MyString.h"
namespace NWindows {
namespace NNet {
struct CResourceBase
{
DWORD Scope;
DWORD Type;
DWORD DisplayType;
DWORD Usage;
bool LocalNameIsDefined;
bool RemoteNameIsDefined;
bool CommentIsDefined;
bool ProviderIsDefined;
};
struct CResource: public CResourceBase
{
CSysString LocalName;
CSysString RemoteName;
CSysString Comment;
CSysString Provider;
};
#ifdef _UNICODE
typedef CResource CResourceW;
#else
struct CResourceW: public CResourceBase
{
UString LocalName;
UString RemoteName;
UString Comment;
UString Provider;
};
#endif
class CEnum
{
HANDLE _handle;
bool _handleAllocated;
DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCE netResource);
DWORD Next(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
#ifndef _UNICODE
DWORD Open(DWORD scope, DWORD type, DWORD usage, LPNETRESOURCEW netResource);
DWORD NextW(LPDWORD lpcCount, LPVOID lpBuffer, LPDWORD lpBufferSize);
#endif
protected:
bool IsHandleAllocated() const { return _handleAllocated; }
public:
CEnum(): _handleAllocated(false) {}
~CEnum() { Close(); }
DWORD Close();
DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResource *resource);
DWORD Next(CResource &resource);
#ifndef _UNICODE
DWORD Open(DWORD scope, DWORD type, DWORD usage, const CResourceW *resource);
DWORD Next(CResourceW &resource);
#endif
};
DWORD GetResourceParent(const CResource &resource, CResource &parentResource);
#ifndef _UNICODE
DWORD GetResourceParent(const CResourceW &resource, CResourceW &parentResource);
#endif
DWORD GetResourceInformation(const CResource &resource,
CResource &destResource, CSysString &systemPathPart);
#ifndef _UNICODE
DWORD GetResourceInformation(const CResourceW &resource,
CResourceW &destResource, UString &systemPathPart);
#endif
DWORD AddConnection2(const CResource &resource, LPCTSTR password, LPCTSTR userName, DWORD flags);
#ifndef _UNICODE
DWORD AddConnection2(const CResourceW &resource, LPCWSTR password, LPCWSTR userName, DWORD flags);
#endif
}}
#endif

92
CPP/Windows/NtCheck.h
View File

@@ -1,46 +1,46 @@
// Windows/NtCheck.h
#ifndef __WINDOWS_NT_CHECK_H
#define __WINDOWS_NT_CHECK_H
#ifdef _WIN32
#include "../Common/MyWindows.h"
#if !defined(_WIN64) && !defined(UNDER_CE)
static inline bool IsItWindowsNT()
{
OSVERSIONINFO vi;
vi.dwOSVersionInfoSize = sizeof(vi);
return (::GetVersionEx(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
}
#endif
#ifndef _UNICODE
#if defined(_WIN64) || defined(UNDER_CE)
bool g_IsNT = true;
#define SET_IS_NT
#else
bool g_IsNT = false;
#define SET_IS_NT g_IsNT = IsItWindowsNT();
#endif
#define NT_CHECK_ACTION
// #define NT_CHECK_ACTION { NT_CHECK_FAIL_ACTION }
#else
#if !defined(_WIN64) && !defined(UNDER_CE)
#define NT_CHECK_ACTION if (!IsItWindowsNT()) { NT_CHECK_FAIL_ACTION }
#else
#define NT_CHECK_ACTION
#endif
#define SET_IS_NT
#endif
#define NT_CHECK NT_CHECK_ACTION SET_IS_NT
#else
#define NT_CHECK
#endif
#endif
// Windows/NtCheck.h
#ifndef __WINDOWS_NT_CHECK_H
#define __WINDOWS_NT_CHECK_H
#ifdef _WIN32
#include "../Common/MyWindows.h"
#if !defined(_WIN64) && !defined(UNDER_CE)
static inline bool IsItWindowsNT()
{
OSVERSIONINFO vi;
vi.dwOSVersionInfoSize = sizeof(vi);
return (::GetVersionEx(&vi) && vi.dwPlatformId == VER_PLATFORM_WIN32_NT);
}
#endif
#ifndef _UNICODE
#if defined(_WIN64) || defined(UNDER_CE)
bool g_IsNT = true;
#define SET_IS_NT
#else
bool g_IsNT = false;
#define SET_IS_NT g_IsNT = IsItWindowsNT();
#endif
#define NT_CHECK_ACTION
// #define NT_CHECK_ACTION { NT_CHECK_FAIL_ACTION }
#else
#if !defined(_WIN64) && !defined(UNDER_CE)
#define NT_CHECK_ACTION if (!IsItWindowsNT()) { NT_CHECK_FAIL_ACTION }
#else
#define NT_CHECK_ACTION
#endif
#define SET_IS_NT
#endif
#define NT_CHECK NT_CHECK_ACTION SET_IS_NT
#else
#define NT_CHECK
#endif
#endif

44
CPP/Windows/ProcessMessages.cpp
View File

@@ -1,22 +1,22 @@
// Windows/ProcessMessages.cpp
#include "StdAfx.h"
#include "ProcessMessages.h"
namespace NWindows {
void ProcessMessages(HWND window)
{
MSG msg;
while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
{
if (window == (HWND) NULL || !IsDialogMessage(window, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
}
// Windows/ProcessMessages.cpp
#include "StdAfx.h"
#include "ProcessMessages.h"
namespace NWindows {
void ProcessMessages(HWND window)
{
MSG msg;
while (::PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) )
{
if (window == (HWND) NULL || !IsDialogMessage(window, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
}

24
CPP/Windows/ProcessMessages.h
View File

@@ -1,12 +1,12 @@
// Windows/ProcessMessages.h
#ifndef __WINDOWS_PROCESSMESSAGES_H
#define __WINDOWS_PROCESSMESSAGES_H
namespace NWindows {
void ProcessMessages(HWND window);
}
#endif
// Windows/ProcessMessages.h
#ifndef __WINDOWS_PROCESSMESSAGES_H
#define __WINDOWS_PROCESSMESSAGES_H
namespace NWindows {
void ProcessMessages(HWND window);
}
#endif

172
CPP/Windows/ProcessUtils.cpp
View File

@@ -1,86 +1,86 @@
// ProcessUtils.cpp
#include "StdAfx.h"
#include "../Common/StringConvert.h"
#include "ProcessUtils.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef UNDER_CE
static UString GetQuotedString(const UString &s)
{
UString s2 ('\"');
s2 += s;
s2 += '\"';
return s2;
}
#endif
WRes CProcess::Create(LPCWSTR imageName, const UString &params, LPCWSTR curDir)
{
Close();
const UString params2 =
#ifndef UNDER_CE
GetQuotedString(imageName) + L' ' +
#endif
params;
#ifdef UNDER_CE
curDir = 0;
#else
imageName = 0;
#endif
PROCESS_INFORMATION pi;
BOOL result;
#ifndef _UNICODE
if (!g_IsNT)
{
STARTUPINFOA si;
si.cb = sizeof(si);
si.lpReserved = 0;
si.lpDesktop = 0;
si.lpTitle = 0;
si.dwFlags = 0;
si.cbReserved2 = 0;
si.lpReserved2 = 0;
CSysString curDirA;
if (curDir != 0)
curDirA = GetSystemString(curDir);
result = ::CreateProcessA(NULL, (LPSTR)(LPCSTR)GetSystemString(params2),
NULL, NULL, FALSE, 0, NULL, ((curDir != 0) ? (LPCSTR)curDirA: 0), &si, &pi);
}
else
#endif
{
STARTUPINFOW si;
si.cb = sizeof(si);
si.lpReserved = 0;
si.lpDesktop = 0;
si.lpTitle = 0;
si.dwFlags = 0;
si.cbReserved2 = 0;
si.lpReserved2 = 0;
result = CreateProcessW(imageName, (LPWSTR)(LPCWSTR)params2,
NULL, NULL, FALSE, 0, NULL, (LPWSTR)curDir, &si, &pi);
}
if (result == 0)
return ::GetLastError();
::CloseHandle(pi.hThread);
_handle = pi.hProcess;
return 0;
}
WRes MyCreateProcess(LPCWSTR imageName, const UString &params)
{
CProcess process;
return process.Create(imageName, params, 0);
}
}
// ProcessUtils.cpp
#include "StdAfx.h"
#include "../Common/StringConvert.h"
#include "ProcessUtils.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef UNDER_CE
static UString GetQuotedString(const UString &s)
{
UString s2 ('\"');
s2 += s;
s2 += '\"';
return s2;
}
#endif
WRes CProcess::Create(LPCWSTR imageName, const UString &params, LPCWSTR curDir)
{
Close();
const UString params2 =
#ifndef UNDER_CE
GetQuotedString(imageName) + L' ' +
#endif
params;
#ifdef UNDER_CE
curDir = 0;
#else
imageName = 0;
#endif
PROCESS_INFORMATION pi;
BOOL result;
#ifndef _UNICODE
if (!g_IsNT)
{
STARTUPINFOA si;
si.cb = sizeof(si);
si.lpReserved = 0;
si.lpDesktop = 0;
si.lpTitle = 0;
si.dwFlags = 0;
si.cbReserved2 = 0;
si.lpReserved2 = 0;
CSysString curDirA;
if (curDir != 0)
curDirA = GetSystemString(curDir);
result = ::CreateProcessA(NULL, (LPSTR)(LPCSTR)GetSystemString(params2),
NULL, NULL, FALSE, 0, NULL, ((curDir != 0) ? (LPCSTR)curDirA: 0), &si, &pi);
}
else
#endif
{
STARTUPINFOW si;
si.cb = sizeof(si);
si.lpReserved = 0;
si.lpDesktop = 0;
si.lpTitle = 0;
si.dwFlags = 0;
si.cbReserved2 = 0;
si.lpReserved2 = 0;
result = CreateProcessW(imageName, (LPWSTR)(LPCWSTR)params2,
NULL, NULL, FALSE, 0, NULL, (LPWSTR)curDir, &si, &pi);
}
if (result == 0)
return ::GetLastError();
::CloseHandle(pi.hThread);
_handle = pi.hProcess;
return 0;
}
WRes MyCreateProcess(LPCWSTR imageName, const UString &params)
{
CProcess process;
return process.Create(imageName, params, 0);
}
}

200
CPP/Windows/ProcessUtils.h
View File

@@ -1,100 +1,100 @@
// Windows/ProcessUtils.h
#ifndef __WINDOWS_PROCESS_UTILS_H
#define __WINDOWS_PROCESS_UTILS_H
#include <psapi.h>
#include "../Common/MyString.h"
#include "Defs.h"
#include "Handle.h"
namespace NWindows {
class CProcess: public CHandle
{
public:
bool Open(DWORD desiredAccess, bool inheritHandle, DWORD processId)
{
_handle = ::OpenProcess(desiredAccess, inheritHandle, processId);
return (_handle != 0);
}
#ifndef UNDER_CE
bool GetExitCodeProcess(LPDWORD lpExitCode) { return BOOLToBool(::GetExitCodeProcess(_handle, lpExitCode)); }
bool Terminate(UINT exitCode) { return BOOLToBool(::TerminateProcess(_handle, exitCode)); }
#if (WINVER >= 0x0500)
DWORD GetGuiResources (DWORD uiFlags) { return ::GetGuiResources(_handle, uiFlags); }
#endif
bool SetPriorityClass(DWORD dwPriorityClass) { return BOOLToBool(::SetPriorityClass(_handle, dwPriorityClass)); }
DWORD GetPriorityClass() { return ::GetPriorityClass(_handle); }
// bool GetIoCounters(PIO_COUNTERS lpIoCounters ) { return BOOLToBool(::GetProcessIoCounters(_handle, lpIoCounters )); }
bool GetTimes(LPFILETIME creationTime, LPFILETIME exitTime, LPFILETIME kernelTime, LPFILETIME userTime)
{ return BOOLToBool(::GetProcessTimes(_handle, creationTime, exitTime, kernelTime, userTime)); }
DWORD WaitForInputIdle(DWORD milliseconds) { return ::WaitForInputIdle(_handle, milliseconds); }
// Debug
bool ReadMemory(LPCVOID baseAddress, LPVOID buffer, SIZE_T size, SIZE_T* numberOfBytesRead)
{ return BOOLToBool(::ReadProcessMemory(_handle, baseAddress, buffer, size, numberOfBytesRead)); }
bool WriteMemory(LPVOID baseAddress, LPCVOID buffer, SIZE_T size, SIZE_T* numberOfBytesWritten)
{ return BOOLToBool(::WriteProcessMemory(_handle, baseAddress, buffer, size, numberOfBytesWritten)); }
bool FlushInstructionCache(LPCVOID baseAddress = 0, SIZE_T size = 0)
{ return BOOLToBool(::FlushInstructionCache(_handle, baseAddress, size)); }
LPVOID VirtualAlloc(LPVOID address, SIZE_T size, DWORD allocationType, DWORD protect)
{ return VirtualAllocEx(_handle, address, size, allocationType, protect); }
bool VirtualFree(LPVOID address, SIZE_T size, DWORD freeType)
{ return BOOLToBool(::VirtualFreeEx(_handle, address, size, freeType)); }
// Process Status API (PSAPI)
bool EmptyWorkingSet()
{ return BOOLToBool(::EmptyWorkingSet(_handle)); }
bool EnumModules(HMODULE *hModules, DWORD arraySizeInBytes, LPDWORD receivedBytes)
{ return BOOLToBool(::EnumProcessModules(_handle, hModules, arraySizeInBytes, receivedBytes)); }
DWORD MyGetModuleBaseName(HMODULE hModule, LPTSTR baseName, DWORD size)
{ return ::GetModuleBaseName(_handle, hModule, baseName, size); }
bool MyGetModuleBaseName(HMODULE hModule, CSysString &name)
{
const unsigned len = MAX_PATH + 100;
DWORD resultLen = MyGetModuleBaseName(hModule, name.GetBuf(len), len);
name.ReleaseBuf_CalcLen(len);
return (resultLen != 0);
}
DWORD MyGetModuleFileNameEx(HMODULE hModule, LPTSTR baseName, DWORD size)
{ return ::GetModuleFileNameEx(_handle, hModule, baseName, size); }
bool MyGetModuleFileNameEx(HMODULE hModule, CSysString &name)
{
const unsigned len = MAX_PATH + 100;
DWORD resultLen = MyGetModuleFileNameEx(hModule, name.GetBuf(len), len);
name.ReleaseBuf_CalcLen(len);
return (resultLen != 0);
}
bool GetModuleInformation(HMODULE hModule, LPMODULEINFO moduleInfo)
{ return BOOLToBool(::GetModuleInformation(_handle, hModule, moduleInfo, sizeof(MODULEINFO))); }
bool GetMemoryInfo(PPROCESS_MEMORY_COUNTERS memCounters)
{ return BOOLToBool(::GetProcessMemoryInfo(_handle, memCounters, sizeof(PROCESS_MEMORY_COUNTERS))); }
#endif
WRes Create(LPCWSTR imageName, const UString &params, LPCWSTR curDir);
DWORD Wait() { return ::WaitForSingleObject(_handle, INFINITE); }
};
WRes MyCreateProcess(LPCWSTR imageName, const UString &params);
}
#endif
// Windows/ProcessUtils.h
#ifndef __WINDOWS_PROCESS_UTILS_H
#define __WINDOWS_PROCESS_UTILS_H
#include <psapi.h>
#include "../Common/MyString.h"
#include "Defs.h"
#include "Handle.h"
namespace NWindows {
class CProcess: public CHandle
{
public:
bool Open(DWORD desiredAccess, bool inheritHandle, DWORD processId)
{
_handle = ::OpenProcess(desiredAccess, inheritHandle, processId);
return (_handle != 0);
}
#ifndef UNDER_CE
bool GetExitCodeProcess(LPDWORD lpExitCode) { return BOOLToBool(::GetExitCodeProcess(_handle, lpExitCode)); }
bool Terminate(UINT exitCode) { return BOOLToBool(::TerminateProcess(_handle, exitCode)); }
#if (WINVER >= 0x0500)
DWORD GetGuiResources (DWORD uiFlags) { return ::GetGuiResources(_handle, uiFlags); }
#endif
bool SetPriorityClass(DWORD dwPriorityClass) { return BOOLToBool(::SetPriorityClass(_handle, dwPriorityClass)); }
DWORD GetPriorityClass() { return ::GetPriorityClass(_handle); }
// bool GetIoCounters(PIO_COUNTERS lpIoCounters ) { return BOOLToBool(::GetProcessIoCounters(_handle, lpIoCounters )); }
bool GetTimes(LPFILETIME creationTime, LPFILETIME exitTime, LPFILETIME kernelTime, LPFILETIME userTime)
{ return BOOLToBool(::GetProcessTimes(_handle, creationTime, exitTime, kernelTime, userTime)); }
DWORD WaitForInputIdle(DWORD milliseconds) { return ::WaitForInputIdle(_handle, milliseconds); }
// Debug
bool ReadMemory(LPCVOID baseAddress, LPVOID buffer, SIZE_T size, SIZE_T* numberOfBytesRead)
{ return BOOLToBool(::ReadProcessMemory(_handle, baseAddress, buffer, size, numberOfBytesRead)); }
bool WriteMemory(LPVOID baseAddress, LPCVOID buffer, SIZE_T size, SIZE_T* numberOfBytesWritten)
{ return BOOLToBool(::WriteProcessMemory(_handle, baseAddress, buffer, size, numberOfBytesWritten)); }
bool FlushInstructionCache(LPCVOID baseAddress = 0, SIZE_T size = 0)
{ return BOOLToBool(::FlushInstructionCache(_handle, baseAddress, size)); }
LPVOID VirtualAlloc(LPVOID address, SIZE_T size, DWORD allocationType, DWORD protect)
{ return VirtualAllocEx(_handle, address, size, allocationType, protect); }
bool VirtualFree(LPVOID address, SIZE_T size, DWORD freeType)
{ return BOOLToBool(::VirtualFreeEx(_handle, address, size, freeType)); }
// Process Status API (PSAPI)
bool EmptyWorkingSet()
{ return BOOLToBool(::EmptyWorkingSet(_handle)); }
bool EnumModules(HMODULE *hModules, DWORD arraySizeInBytes, LPDWORD receivedBytes)
{ return BOOLToBool(::EnumProcessModules(_handle, hModules, arraySizeInBytes, receivedBytes)); }
DWORD MyGetModuleBaseName(HMODULE hModule, LPTSTR baseName, DWORD size)
{ return ::GetModuleBaseName(_handle, hModule, baseName, size); }
bool MyGetModuleBaseName(HMODULE hModule, CSysString &name)
{
const unsigned len = MAX_PATH + 100;
DWORD resultLen = MyGetModuleBaseName(hModule, name.GetBuf(len), len);
name.ReleaseBuf_CalcLen(len);
return (resultLen != 0);
}
DWORD MyGetModuleFileNameEx(HMODULE hModule, LPTSTR baseName, DWORD size)
{ return ::GetModuleFileNameEx(_handle, hModule, baseName, size); }
bool MyGetModuleFileNameEx(HMODULE hModule, CSysString &name)
{
const unsigned len = MAX_PATH + 100;
DWORD resultLen = MyGetModuleFileNameEx(hModule, name.GetBuf(len), len);
name.ReleaseBuf_CalcLen(len);
return (resultLen != 0);
}
bool GetModuleInformation(HMODULE hModule, LPMODULEINFO moduleInfo)
{ return BOOLToBool(::GetModuleInformation(_handle, hModule, moduleInfo, sizeof(MODULEINFO))); }
bool GetMemoryInfo(PPROCESS_MEMORY_COUNTERS memCounters)
{ return BOOLToBool(::GetProcessMemoryInfo(_handle, memCounters, sizeof(PROCESS_MEMORY_COUNTERS))); }
#endif
WRes Create(LPCWSTR imageName, const UString &params, LPCWSTR curDir);
DWORD Wait() { return ::WaitForSingleObject(_handle, INFINITE); }
};
WRes MyCreateProcess(LPCWSTR imageName, const UString &params);
}
#endif

694
CPP/Windows/PropVariant.cpp
View File

@@ -1,347 +1,347 @@
// Windows/PropVariant.cpp
#include "StdAfx.h"
#include "../Common/Defs.h"
#include "PropVariant.h"
namespace NWindows {
namespace NCOM {
BSTR AllocBstrFromAscii(const char *s) throw()
{
if (!s)
return NULL;
UINT len = (UINT)strlen(s);
BSTR p = ::SysAllocStringLen(NULL, len);
if (p)
{
for (UINT i = 0; i <= len; i++)
p[i] = (Byte)s[i];
}
return p;
}
HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
{
p->bstrVal = ::SysAllocStringLen(NULL, numChars);
if (!p->bstrVal)
{
p->vt = VT_ERROR;
p->scode = E_OUTOFMEMORY;
return E_OUTOFMEMORY;
}
p->vt = VT_BSTR;
return S_OK;
}
HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
{
p->bstrVal = AllocBstrFromAscii(s);
if (p->bstrVal)
{
p->vt = VT_BSTR;
return S_OK;
}
p->vt = VT_ERROR;
p->scode = E_OUTOFMEMORY;
return E_OUTOFMEMORY;
}
CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CPropVariant::CPropVariant(const CPropVariant &varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CPropVariant::CPropVariant(BSTR bstrSrc)
{
vt = VT_EMPTY;
*this = bstrSrc;
}
CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
{
vt = VT_EMPTY;
*this = lpszSrc;
}
CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
{
*this = (LPCOLESTR)bstrSrc;
return *this;
}
static const char * const kMemException = "out of memory";
CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocString(lpszSrc);
if (!bstrVal && lpszSrc)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return *this;
}
CPropVariant& CPropVariant::operator=(const UString &s)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(s, s.Len());
if (!bstrVal)
throw kMemException;
return *this;
}
CPropVariant& CPropVariant::operator=(const UString2 &s)
{
/*
if (s.IsEmpty())
*this = L"";
else
*/
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
if (!bstrVal)
throw kMemException;
/* SysAllocStringLen probably appends a null-terminating character for NULL string.
But it doesn't specified in MSDN.
But we suppose that it works
if (!s.GetRawPtr())
{
*bstrVal = 0;
}
*/
/* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
pointers to this function causes an unexpected termination of the application.
Is it safe? Maybe we must chamnge the code for that case ? */
}
return *this;
}
CPropVariant& CPropVariant::operator=(const char *s)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = AllocBstrFromAscii(s);
if (!bstrVal)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return *this;
}
CPropVariant& CPropVariant::operator=(bool bSrc) throw()
{
if (vt != VT_BOOL)
{
InternalClear();
vt = VT_BOOL;
}
boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
return *this;
}
BSTR CPropVariant::AllocBstr(unsigned numChars)
{
if (vt != VT_EMPTY)
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(NULL, numChars);
if (!bstrVal)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return bstrVal;
}
#define SET_PROP_FUNC(type, id, dest) \
CPropVariant& CPropVariant::operator=(type value) throw() \
{ if (vt != id) { InternalClear(); vt = id; } \
dest = value; return *this; }
SET_PROP_FUNC(Byte, VT_UI1, bVal)
// SET_PROP_FUNC(Int16, VT_I2, iVal)
SET_PROP_FUNC(Int32, VT_I4, lVal)
SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
{
switch (prop->vt)
{
case VT_EMPTY:
case VT_UI1:
case VT_I1:
case VT_I2:
case VT_UI2:
case VT_BOOL:
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
prop->vt = VT_EMPTY;
prop->wReserved1 = 0;
prop->wReserved2 = 0;
prop->wReserved3 = 0;
prop->uhVal.QuadPart = 0;
return S_OK;
}
return ::VariantClear((VARIANTARG *)prop);
// return ::PropVariantClear(prop);
// PropVariantClear can clear VT_BLOB.
}
HRESULT CPropVariant::Clear() throw()
{
if (vt == VT_EMPTY)
return S_OK;
return PropVariant_Clear(this);
}
HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
{
::VariantClear((tagVARIANT *)this);
switch (pSrc->vt)
{
case VT_UI1:
case VT_I1:
case VT_I2:
case VT_UI2:
case VT_BOOL:
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
return S_OK;
}
return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc));
}
HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
{
HRESULT hr = Clear();
if (FAILED(hr))
return hr;
memcpy(this, pSrc, sizeof(PROPVARIANT));
pSrc->vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
{
if (pDest->vt != VT_EMPTY)
{
HRESULT hr = PropVariant_Clear(pDest);
if (FAILED(hr))
return hr;
}
memcpy(pDest, this, sizeof(PROPVARIANT));
vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::InternalClear() throw()
{
if (vt == VT_EMPTY)
return S_OK;
HRESULT hr = Clear();
if (FAILED(hr))
{
vt = VT_ERROR;
scode = hr;
}
return hr;
}
void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
{
HRESULT hr = Copy(pSrc);
if (FAILED(hr))
{
if (hr == E_OUTOFMEMORY)
throw kMemException;
vt = VT_ERROR;
scode = hr;
}
}
int CPropVariant::Compare(const CPropVariant &a) throw()
{
if (vt != a.vt)
return MyCompare(vt, a.vt);
switch (vt)
{
case VT_EMPTY: return 0;
// case VT_I1: return MyCompare(cVal, a.cVal);
case VT_UI1: return MyCompare(bVal, a.bVal);
case VT_I2: return MyCompare(iVal, a.iVal);
case VT_UI2: return MyCompare(uiVal, a.uiVal);
case VT_I4: return MyCompare(lVal, a.lVal);
case VT_UI4: return MyCompare(ulVal, a.ulVal);
// case VT_UINT: return MyCompare(uintVal, a.uintVal);
case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime);
case VT_BSTR: return 0; // Not implemented
default: return 0;
}
}
}}
// Windows/PropVariant.cpp
#include "StdAfx.h"
#include "../Common/Defs.h"
#include "PropVariant.h"
namespace NWindows {
namespace NCOM {
BSTR AllocBstrFromAscii(const char *s) throw()
{
if (!s)
return NULL;
UINT len = (UINT)strlen(s);
BSTR p = ::SysAllocStringLen(NULL, len);
if (p)
{
for (UINT i = 0; i <= len; i++)
p[i] = (Byte)s[i];
}
return p;
}
HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw()
{
p->bstrVal = ::SysAllocStringLen(NULL, numChars);
if (!p->bstrVal)
{
p->vt = VT_ERROR;
p->scode = E_OUTOFMEMORY;
return E_OUTOFMEMORY;
}
p->vt = VT_BSTR;
return S_OK;
}
HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw()
{
p->bstrVal = AllocBstrFromAscii(s);
if (p->bstrVal)
{
p->vt = VT_BSTR;
return S_OK;
}
p->vt = VT_ERROR;
p->scode = E_OUTOFMEMORY;
return E_OUTOFMEMORY;
}
CPropVariant::CPropVariant(const PROPVARIANT &varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CPropVariant::CPropVariant(const CPropVariant &varSrc)
{
vt = VT_EMPTY;
InternalCopy(&varSrc);
}
CPropVariant::CPropVariant(BSTR bstrSrc)
{
vt = VT_EMPTY;
*this = bstrSrc;
}
CPropVariant::CPropVariant(LPCOLESTR lpszSrc)
{
vt = VT_EMPTY;
*this = lpszSrc;
}
CPropVariant& CPropVariant::operator=(const CPropVariant &varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CPropVariant& CPropVariant::operator=(const PROPVARIANT &varSrc)
{
InternalCopy(&varSrc);
return *this;
}
CPropVariant& CPropVariant::operator=(BSTR bstrSrc)
{
*this = (LPCOLESTR)bstrSrc;
return *this;
}
static const char * const kMemException = "out of memory";
CPropVariant& CPropVariant::operator=(LPCOLESTR lpszSrc)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocString(lpszSrc);
if (!bstrVal && lpszSrc)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return *this;
}
CPropVariant& CPropVariant::operator=(const UString &s)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(s, s.Len());
if (!bstrVal)
throw kMemException;
return *this;
}
CPropVariant& CPropVariant::operator=(const UString2 &s)
{
/*
if (s.IsEmpty())
*this = L"";
else
*/
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(s.GetRawPtr(), s.Len());
if (!bstrVal)
throw kMemException;
/* SysAllocStringLen probably appends a null-terminating character for NULL string.
But it doesn't specified in MSDN.
But we suppose that it works
if (!s.GetRawPtr())
{
*bstrVal = 0;
}
*/
/* MSDN: Windows CE: SysAllocStringLen() : Passing invalid (and under some circumstances NULL)
pointers to this function causes an unexpected termination of the application.
Is it safe? Maybe we must chamnge the code for that case ? */
}
return *this;
}
CPropVariant& CPropVariant::operator=(const char *s)
{
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = AllocBstrFromAscii(s);
if (!bstrVal)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return *this;
}
CPropVariant& CPropVariant::operator=(bool bSrc) throw()
{
if (vt != VT_BOOL)
{
InternalClear();
vt = VT_BOOL;
}
boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
return *this;
}
BSTR CPropVariant::AllocBstr(unsigned numChars)
{
if (vt != VT_EMPTY)
InternalClear();
vt = VT_BSTR;
wReserved1 = 0;
bstrVal = ::SysAllocStringLen(NULL, numChars);
if (!bstrVal)
{
throw kMemException;
// vt = VT_ERROR;
// scode = E_OUTOFMEMORY;
}
return bstrVal;
}
#define SET_PROP_FUNC(type, id, dest) \
CPropVariant& CPropVariant::operator=(type value) throw() \
{ if (vt != id) { InternalClear(); vt = id; } \
dest = value; return *this; }
SET_PROP_FUNC(Byte, VT_UI1, bVal)
// SET_PROP_FUNC(Int16, VT_I2, iVal)
SET_PROP_FUNC(Int32, VT_I4, lVal)
SET_PROP_FUNC(UInt32, VT_UI4, ulVal)
SET_PROP_FUNC(UInt64, VT_UI8, uhVal.QuadPart)
SET_PROP_FUNC(Int64, VT_I8, hVal.QuadPart)
SET_PROP_FUNC(const FILETIME &, VT_FILETIME, filetime)
HRESULT PropVariant_Clear(PROPVARIANT *prop) throw()
{
switch (prop->vt)
{
case VT_EMPTY:
case VT_UI1:
case VT_I1:
case VT_I2:
case VT_UI2:
case VT_BOOL:
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
prop->vt = VT_EMPTY;
prop->wReserved1 = 0;
prop->wReserved2 = 0;
prop->wReserved3 = 0;
prop->uhVal.QuadPart = 0;
return S_OK;
}
return ::VariantClear((VARIANTARG *)prop);
// return ::PropVariantClear(prop);
// PropVariantClear can clear VT_BLOB.
}
HRESULT CPropVariant::Clear() throw()
{
if (vt == VT_EMPTY)
return S_OK;
return PropVariant_Clear(this);
}
HRESULT CPropVariant::Copy(const PROPVARIANT* pSrc) throw()
{
::VariantClear((tagVARIANT *)this);
switch (pSrc->vt)
{
case VT_UI1:
case VT_I1:
case VT_I2:
case VT_UI2:
case VT_BOOL:
case VT_I4:
case VT_UI4:
case VT_R4:
case VT_INT:
case VT_UINT:
case VT_ERROR:
case VT_FILETIME:
case VT_UI8:
case VT_R8:
case VT_CY:
case VT_DATE:
memmove((PROPVARIANT*)this, pSrc, sizeof(PROPVARIANT));
return S_OK;
}
return ::VariantCopy((tagVARIANT *)this, (tagVARIANT *)const_cast<PROPVARIANT *>(pSrc));
}
HRESULT CPropVariant::Attach(PROPVARIANT *pSrc) throw()
{
HRESULT hr = Clear();
if (FAILED(hr))
return hr;
memcpy(this, pSrc, sizeof(PROPVARIANT));
pSrc->vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::Detach(PROPVARIANT *pDest) throw()
{
if (pDest->vt != VT_EMPTY)
{
HRESULT hr = PropVariant_Clear(pDest);
if (FAILED(hr))
return hr;
}
memcpy(pDest, this, sizeof(PROPVARIANT));
vt = VT_EMPTY;
return S_OK;
}
HRESULT CPropVariant::InternalClear() throw()
{
if (vt == VT_EMPTY)
return S_OK;
HRESULT hr = Clear();
if (FAILED(hr))
{
vt = VT_ERROR;
scode = hr;
}
return hr;
}
void CPropVariant::InternalCopy(const PROPVARIANT *pSrc)
{
HRESULT hr = Copy(pSrc);
if (FAILED(hr))
{
if (hr == E_OUTOFMEMORY)
throw kMemException;
vt = VT_ERROR;
scode = hr;
}
}
int CPropVariant::Compare(const CPropVariant &a) throw()
{
if (vt != a.vt)
return MyCompare(vt, a.vt);
switch (vt)
{
case VT_EMPTY: return 0;
// case VT_I1: return MyCompare(cVal, a.cVal);
case VT_UI1: return MyCompare(bVal, a.bVal);
case VT_I2: return MyCompare(iVal, a.iVal);
case VT_UI2: return MyCompare(uiVal, a.uiVal);
case VT_I4: return MyCompare(lVal, a.lVal);
case VT_UI4: return MyCompare(ulVal, a.ulVal);
// case VT_UINT: return MyCompare(uintVal, a.uintVal);
case VT_I8: return MyCompare(hVal.QuadPart, a.hVal.QuadPart);
case VT_UI8: return MyCompare(uhVal.QuadPart, a.uhVal.QuadPart);
case VT_BOOL: return -MyCompare(boolVal, a.boolVal);
case VT_FILETIME: return ::CompareFileTime(&filetime, &a.filetime);
case VT_BSTR: return 0; // Not implemented
default: return 0;
}
}
}}

228
CPP/Windows/PropVariant.h
View File

@@ -1,114 +1,114 @@
// Windows/PropVariant.h
#ifndef __WINDOWS_PROP_VARIANT_H
#define __WINDOWS_PROP_VARIANT_H
#include "../Common/MyTypes.h"
#include "../Common/MyWindows.h"
#include "../Common/MyString.h"
namespace NWindows {
namespace NCOM {
BSTR AllocBstrFromAscii(const char *s) throw();
HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
{
p->vt = VT_UI4;
p->ulVal = v;
}
inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
{
p->vt = VT_UI8;
p->uhVal.QuadPart = v;
}
inline void PropVarEm_Set_FileTime64(PROPVARIANT *p, UInt64 v) throw()
{
p->vt = VT_FILETIME;
p->filetime.dwLowDateTime = (DWORD)v;
p->filetime.dwHighDateTime = (DWORD)(v >> 32);
}
inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
{
p->vt = VT_BOOL;
p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
}
class CPropVariant : public tagPROPVARIANT
{
public:
CPropVariant()
{
vt = VT_EMPTY;
wReserved1 = 0;
// wReserved2 = 0;
// wReserved3 = 0;
// uhVal.QuadPart = 0;
bstrVal = 0;
}
~CPropVariant() throw() { Clear(); }
CPropVariant(const PROPVARIANT &varSrc);
CPropVariant(const CPropVariant &varSrc);
CPropVariant(BSTR bstrSrc);
CPropVariant(LPCOLESTR lpszSrc);
CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); }
CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
private:
CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
public:
CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
CPropVariant(Int64 value) { vt = VT_I8; wReserved1 = 0; hVal.QuadPart = value; }
CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
CPropVariant& operator=(const CPropVariant &varSrc);
CPropVariant& operator=(const PROPVARIANT &varSrc);
CPropVariant& operator=(BSTR bstrSrc);
CPropVariant& operator=(LPCOLESTR lpszSrc);
CPropVariant& operator=(const UString &s);
CPropVariant& operator=(const UString2 &s);
CPropVariant& operator=(const char *s);
CPropVariant& operator=(const AString &s)
{ return (*this)=(const char *)s; }
CPropVariant& operator=(bool bSrc) throw();
CPropVariant& operator=(Byte value) throw();
private:
CPropVariant& operator=(Int16 value) throw();
public:
CPropVariant& operator=(Int32 value) throw();
CPropVariant& operator=(UInt32 value) throw();
CPropVariant& operator=(UInt64 value) throw();
CPropVariant& operator=(Int64 value) throw();
CPropVariant& operator=(const FILETIME &value) throw();
BSTR AllocBstr(unsigned numChars);
HRESULT Clear() throw();
HRESULT Copy(const PROPVARIANT *pSrc) throw();
HRESULT Attach(PROPVARIANT *pSrc) throw();
HRESULT Detach(PROPVARIANT *pDest) throw();
HRESULT InternalClear() throw();
void InternalCopy(const PROPVARIANT *pSrc);
int Compare(const CPropVariant &a) throw();
};
}}
#endif
// Windows/PropVariant.h
#ifndef __WINDOWS_PROP_VARIANT_H
#define __WINDOWS_PROP_VARIANT_H
#include "../Common/MyTypes.h"
#include "../Common/MyWindows.h"
#include "../Common/MyString.h"
namespace NWindows {
namespace NCOM {
BSTR AllocBstrFromAscii(const char *s) throw();
HRESULT PropVariant_Clear(PROPVARIANT *p) throw();
HRESULT PropVarEm_Alloc_Bstr(PROPVARIANT *p, unsigned numChars) throw();
HRESULT PropVarEm_Set_Str(PROPVARIANT *p, const char *s) throw();
inline void PropVarEm_Set_UInt32(PROPVARIANT *p, UInt32 v) throw()
{
p->vt = VT_UI4;
p->ulVal = v;
}
inline void PropVarEm_Set_UInt64(PROPVARIANT *p, UInt64 v) throw()
{
p->vt = VT_UI8;
p->uhVal.QuadPart = v;
}
inline void PropVarEm_Set_FileTime64(PROPVARIANT *p, UInt64 v) throw()
{
p->vt = VT_FILETIME;
p->filetime.dwLowDateTime = (DWORD)v;
p->filetime.dwHighDateTime = (DWORD)(v >> 32);
}
inline void PropVarEm_Set_Bool(PROPVARIANT *p, bool b) throw()
{
p->vt = VT_BOOL;
p->boolVal = (b ? VARIANT_TRUE : VARIANT_FALSE);
}
class CPropVariant : public tagPROPVARIANT
{
public:
CPropVariant()
{
vt = VT_EMPTY;
wReserved1 = 0;
// wReserved2 = 0;
// wReserved3 = 0;
// uhVal.QuadPart = 0;
bstrVal = 0;
}
~CPropVariant() throw() { Clear(); }
CPropVariant(const PROPVARIANT &varSrc);
CPropVariant(const CPropVariant &varSrc);
CPropVariant(BSTR bstrSrc);
CPropVariant(LPCOLESTR lpszSrc);
CPropVariant(bool bSrc) { vt = VT_BOOL; wReserved1 = 0; boolVal = (bSrc ? VARIANT_TRUE : VARIANT_FALSE); }
CPropVariant(Byte value) { vt = VT_UI1; wReserved1 = 0; bVal = value; }
private:
CPropVariant(Int16 value); // { vt = VT_I2; wReserved1 = 0; iVal = value; }
CPropVariant(Int32 value); // { vt = VT_I4; wReserved1 = 0; lVal = value; }
public:
CPropVariant(UInt32 value) { vt = VT_UI4; wReserved1 = 0; ulVal = value; }
CPropVariant(UInt64 value) { vt = VT_UI8; wReserved1 = 0; uhVal.QuadPart = value; }
CPropVariant(Int64 value) { vt = VT_I8; wReserved1 = 0; hVal.QuadPart = value; }
CPropVariant(const FILETIME &value) { vt = VT_FILETIME; wReserved1 = 0; filetime = value; }
CPropVariant& operator=(const CPropVariant &varSrc);
CPropVariant& operator=(const PROPVARIANT &varSrc);
CPropVariant& operator=(BSTR bstrSrc);
CPropVariant& operator=(LPCOLESTR lpszSrc);
CPropVariant& operator=(const UString &s);
CPropVariant& operator=(const UString2 &s);
CPropVariant& operator=(const char *s);
CPropVariant& operator=(const AString &s)
{ return (*this)=(const char *)s; }
CPropVariant& operator=(bool bSrc) throw();
CPropVariant& operator=(Byte value) throw();
private:
CPropVariant& operator=(Int16 value) throw();
public:
CPropVariant& operator=(Int32 value) throw();
CPropVariant& operator=(UInt32 value) throw();
CPropVariant& operator=(UInt64 value) throw();
CPropVariant& operator=(Int64 value) throw();
CPropVariant& operator=(const FILETIME &value) throw();
BSTR AllocBstr(unsigned numChars);
HRESULT Clear() throw();
HRESULT Copy(const PROPVARIANT *pSrc) throw();
HRESULT Attach(PROPVARIANT *pSrc) throw();
HRESULT Detach(PROPVARIANT *pDest) throw();
HRESULT InternalClear() throw();
void InternalCopy(const PROPVARIANT *pSrc);
int Compare(const CPropVariant &a) throw();
};
}}
#endif

276
CPP/Windows/PropVariantConv.cpp
View File

@@ -1,138 +1,138 @@
// PropVariantConvert.cpp
#include "StdAfx.h"
#include "../Common/IntToString.h"
#include "Defs.h"
#include "PropVariantConv.h"
#define UINT_TO_STR_2(c, val) { s[0] = (c); s[1] = (char)('0' + (val) / 10); s[2] = (char)('0' + (val) % 10); s += 3; }
bool ConvertUtcFileTimeToString(const FILETIME &utc, char *s, int level) throw()
{
*s = 0;
FILETIME ft;
if (!FileTimeToLocalFileTime(&utc, &ft))
return false;
SYSTEMTIME st;
if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
return false;
{
unsigned val = st.wYear;
if (val >= 10000)
{
*s++ = (char)('0' + val / 10000);
val %= 10000;
}
s[3] = (char)('0' + val % 10); val /= 10;
s[2] = (char)('0' + val % 10); val /= 10;
s[1] = (char)('0' + val % 10);
s[0] = (char)('0' + val / 10);
s += 4;
}
UINT_TO_STR_2('-', st.wMonth);
UINT_TO_STR_2('-', st.wDay);
if (level > kTimestampPrintLevel_DAY)
{
UINT_TO_STR_2(' ', st.wHour);
UINT_TO_STR_2(':', st.wMinute);
if (level >= kTimestampPrintLevel_SEC)
{
UINT_TO_STR_2(':', st.wSecond);
if (level > kTimestampPrintLevel_SEC)
{
*s++ = '.';
/*
{
unsigned val = st.wMilliseconds;
s[2] = (char)('0' + val % 10); val /= 10;
s[1] = (char)('0' + val % 10);
s[0] = (char)('0' + val / 10);
s += 3;
}
*s++ = ' ';
*/
{
unsigned numDigits = 7;
UInt32 val = (UInt32)((((UInt64)ft.dwHighDateTime << 32) + ft.dwLowDateTime) % 10000000);
for (unsigned i = numDigits; i != 0;)
{
i--;
s[i] = (char)('0' + val % 10); val /= 10;
}
if (numDigits > (unsigned)level)
numDigits = (unsigned)level;
s += numDigits;
}
}
}
}
*s = 0;
return true;
}
bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *dest, int level) throw()
{
char s[32];
bool res = ConvertUtcFileTimeToString(ft, s, level);
for (unsigned i = 0;; i++)
{
unsigned char c = s[i];
dest[i] = c;
if (c == 0)
break;
}
return res;
}
void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw()
{
*dest = 0;
switch (prop.vt)
{
case VT_EMPTY: return;
case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
// case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? '+' : '-'; dest[1] = 0; return;
default: dest[0] = '?'; dest[1] = ':'; ConvertUInt64ToString(prop.vt, dest + 2);
}
}
void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw()
{
*dest = 0;
switch (prop.vt)
{
case VT_EMPTY: return;
case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
// case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? (wchar_t)'+' : (wchar_t)'-'; dest[1] = 0; return;
default: dest[0] = '?'; dest[1] = ':'; ConvertUInt32ToString(prop.vt, dest + 2);
}
}
// PropVariantConvert.cpp
#include "StdAfx.h"
#include "../Common/IntToString.h"
#include "Defs.h"
#include "PropVariantConv.h"
#define UINT_TO_STR_2(c, val) { s[0] = (c); s[1] = (char)('0' + (val) / 10); s[2] = (char)('0' + (val) % 10); s += 3; }
bool ConvertUtcFileTimeToString(const FILETIME &utc, char *s, int level) throw()
{
*s = 0;
FILETIME ft;
if (!FileTimeToLocalFileTime(&utc, &ft))
return false;
SYSTEMTIME st;
if (!BOOLToBool(FileTimeToSystemTime(&ft, &st)))
return false;
{
unsigned val = st.wYear;
if (val >= 10000)
{
*s++ = (char)('0' + val / 10000);
val %= 10000;
}
s[3] = (char)('0' + val % 10); val /= 10;
s[2] = (char)('0' + val % 10); val /= 10;
s[1] = (char)('0' + val % 10);
s[0] = (char)('0' + val / 10);
s += 4;
}
UINT_TO_STR_2('-', st.wMonth);
UINT_TO_STR_2('-', st.wDay);
if (level > kTimestampPrintLevel_DAY)
{
UINT_TO_STR_2(' ', st.wHour);
UINT_TO_STR_2(':', st.wMinute);
if (level >= kTimestampPrintLevel_SEC)
{
UINT_TO_STR_2(':', st.wSecond);
if (level > kTimestampPrintLevel_SEC)
{
*s++ = '.';
/*
{
unsigned val = st.wMilliseconds;
s[2] = (char)('0' + val % 10); val /= 10;
s[1] = (char)('0' + val % 10);
s[0] = (char)('0' + val / 10);
s += 3;
}
*s++ = ' ';
*/
{
unsigned numDigits = 7;
UInt32 val = (UInt32)((((UInt64)ft.dwHighDateTime << 32) + ft.dwLowDateTime) % 10000000);
for (unsigned i = numDigits; i != 0;)
{
i--;
s[i] = (char)('0' + val % 10); val /= 10;
}
if (numDigits > (unsigned)level)
numDigits = (unsigned)level;
s += numDigits;
}
}
}
}
*s = 0;
return true;
}
bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *dest, int level) throw()
{
char s[32];
bool res = ConvertUtcFileTimeToString(ft, s, level);
for (unsigned i = 0;; i++)
{
unsigned char c = s[i];
dest[i] = c;
if (c == 0)
break;
}
return res;
}
void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw()
{
*dest = 0;
switch (prop.vt)
{
case VT_EMPTY: return;
case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
// case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? '+' : '-'; dest[1] = 0; return;
default: dest[0] = '?'; dest[1] = ':'; ConvertUInt64ToString(prop.vt, dest + 2);
}
}
void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw()
{
*dest = 0;
switch (prop.vt)
{
case VT_EMPTY: return;
case VT_BSTR: dest[0] = '?'; dest[1] = 0; return;
case VT_UI1: ConvertUInt32ToString(prop.bVal, dest); return;
case VT_UI2: ConvertUInt32ToString(prop.uiVal, dest); return;
case VT_UI4: ConvertUInt32ToString(prop.ulVal, dest); return;
case VT_UI8: ConvertUInt64ToString(prop.uhVal.QuadPart, dest); return;
case VT_FILETIME: ConvertUtcFileTimeToString(prop.filetime, dest); return;
// case VT_I1: return ConvertInt64ToString(prop.cVal, dest); return;
case VT_I2: ConvertInt64ToString(prop.iVal, dest); return;
case VT_I4: ConvertInt64ToString(prop.lVal, dest); return;
case VT_I8: ConvertInt64ToString(prop.hVal.QuadPart, dest); return;
case VT_BOOL: dest[0] = VARIANT_BOOLToBool(prop.boolVal) ? (wchar_t)'+' : (wchar_t)'-'; dest[1] = 0; return;
default: dest[0] = '?'; dest[1] = ':'; ConvertUInt32ToString(prop.vt, dest + 2);
}
}

74
CPP/Windows/PropVariantConv.h
View File

@@ -1,37 +1,37 @@
// Windows/PropVariantConv.h
#ifndef __PROP_VARIANT_CONV_H
#define __PROP_VARIANT_CONV_H
#include "../Common/MyTypes.h"
// provide at least 32 bytes for buffer including zero-end
#define kTimestampPrintLevel_DAY -3
// #define kTimestampPrintLevel_HOUR -2
#define kTimestampPrintLevel_MIN -1
#define kTimestampPrintLevel_SEC 0
#define kTimestampPrintLevel_NTFS 7
bool ConvertUtcFileTimeToString(const FILETIME &ft, char *s, int level = kTimestampPrintLevel_SEC) throw();
bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
// provide at least 32 bytes for buffer including zero-end
// don't send VT_BSTR to these functions
void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw();
void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw();
inline bool ConvertPropVariantToUInt64(const PROPVARIANT &prop, UInt64 &value)
{
switch (prop.vt)
{
case VT_UI8: value = (UInt64)prop.uhVal.QuadPart; return true;
case VT_UI4: value = prop.ulVal; return true;
case VT_UI2: value = prop.uiVal; return true;
case VT_UI1: value = prop.bVal; return true;
case VT_EMPTY: return false;
default: throw 151199;
}
}
#endif
// Windows/PropVariantConv.h
#ifndef __PROP_VARIANT_CONV_H
#define __PROP_VARIANT_CONV_H
#include "../Common/MyTypes.h"
// provide at least 32 bytes for buffer including zero-end
#define kTimestampPrintLevel_DAY -3
// #define kTimestampPrintLevel_HOUR -2
#define kTimestampPrintLevel_MIN -1
#define kTimestampPrintLevel_SEC 0
#define kTimestampPrintLevel_NTFS 7
bool ConvertUtcFileTimeToString(const FILETIME &ft, char *s, int level = kTimestampPrintLevel_SEC) throw();
bool ConvertUtcFileTimeToString(const FILETIME &ft, wchar_t *s, int level = kTimestampPrintLevel_SEC) throw();
// provide at least 32 bytes for buffer including zero-end
// don't send VT_BSTR to these functions
void ConvertPropVariantToShortString(const PROPVARIANT &prop, char *dest) throw();
void ConvertPropVariantToShortString(const PROPVARIANT &prop, wchar_t *dest) throw();
inline bool ConvertPropVariantToUInt64(const PROPVARIANT &prop, UInt64 &value)
{
switch (prop.vt)
{
case VT_UI8: value = (UInt64)prop.uhVal.QuadPart; return true;
case VT_UI4: value = prop.ulVal; return true;
case VT_UI2: value = prop.uiVal; return true;
case VT_UI1: value = prop.bVal; return true;
case VT_EMPTY: return false;
default: throw 151199;
}
}
#endif

322
CPP/Windows/PropVariantUtils.cpp
View File

@@ -1,161 +1,161 @@
// PropVariantUtils.cpp
#include "StdAfx.h"
#include "../Common/IntToString.h"
#include "PropVariantUtils.h"
using namespace NWindows;
static void AddHex(AString &s, UInt32 v)
{
char sz[16];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt32ToHex(v, sz + 2);
s += sz;
}
AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
{
char sz[16];
const char *p = NULL;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &pair = pairs[i];
if (pair.Value == value)
p = pair.Name;
}
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
return (AString)p;
}
void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
{
prop = TypePairToString(pairs, num, value);
}
AString TypeToString(const char * const table[], unsigned num, UInt32 value)
{
char sz[16];
const char *p = NULL;
if (value < num)
p = table[value];
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
return (AString)p;
}
void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop)
{
char sz[16];
const char *p = NULL;
if (value < num)
p = table[value];
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
prop = p;
}
AString FlagsToString(const char * const *names, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
UInt32 flag = (UInt32)1 << i;
if ((flags & flag) != 0)
{
const char *name = names[i];
if (name && name[0] != 0)
{
s.Add_OptSpaced(name);
flags &= ~flag;
}
}
}
if (flags != 0)
{
s.Add_Space_if_NotEmpty();
AddHex(s, flags);
}
return s;
}
AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt32 flag = (UInt32)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
s.Add_OptSpaced(p.Name);
}
flags &= ~flag;
}
if (flags != 0)
{
s.Add_Space_if_NotEmpty();
AddHex(s, flags);
}
return s;
}
void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
{
prop = FlagsToString(names, num, flags);
}
void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
{
prop = FlagsToString(pairs, num, flags);
}
AString Flags64ToString(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt64 flag = (UInt64)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
s.Add_OptSpaced(p.Name);
}
flags &= ~flag;
}
if (flags != 0)
{
{
char sz[32];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt64ToHex(flags, sz + 2);
s.Add_OptSpaced(sz);
}
}
return s;
}
void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NCOM::CPropVariant &prop)
{
prop = Flags64ToString(pairs, num, flags);
}
// PropVariantUtils.cpp
#include "StdAfx.h"
#include "../Common/IntToString.h"
#include "PropVariantUtils.h"
using namespace NWindows;
static void AddHex(AString &s, UInt32 v)
{
char sz[16];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt32ToHex(v, sz + 2);
s += sz;
}
AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value)
{
char sz[16];
const char *p = NULL;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &pair = pairs[i];
if (pair.Value == value)
p = pair.Name;
}
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
return (AString)p;
}
void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NCOM::CPropVariant &prop)
{
prop = TypePairToString(pairs, num, value);
}
AString TypeToString(const char * const table[], unsigned num, UInt32 value)
{
char sz[16];
const char *p = NULL;
if (value < num)
p = table[value];
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
return (AString)p;
}
void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop)
{
char sz[16];
const char *p = NULL;
if (value < num)
p = table[value];
if (!p)
{
ConvertUInt32ToString(value, sz);
p = sz;
}
prop = p;
}
AString FlagsToString(const char * const *names, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
UInt32 flag = (UInt32)1 << i;
if ((flags & flag) != 0)
{
const char *name = names[i];
if (name && name[0] != 0)
{
s.Add_OptSpaced(name);
flags &= ~flag;
}
}
}
if (flags != 0)
{
s.Add_Space_if_NotEmpty();
AddHex(s, flags);
}
return s;
}
AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt32 flag = (UInt32)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
s.Add_OptSpaced(p.Name);
}
flags &= ~flag;
}
if (flags != 0)
{
s.Add_Space_if_NotEmpty();
AddHex(s, flags);
}
return s;
}
void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
{
prop = FlagsToString(names, num, flags);
}
void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NCOM::CPropVariant &prop)
{
prop = FlagsToString(pairs, num, flags);
}
AString Flags64ToString(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags)
{
AString s;
for (unsigned i = 0; i < num; i++)
{
const CUInt32PCharPair &p = pairs[i];
UInt64 flag = (UInt64)1 << (unsigned)p.Value;
if ((flags & flag) != 0)
{
if (p.Name[0] != 0)
s.Add_OptSpaced(p.Name);
}
flags &= ~flag;
}
if (flags != 0)
{
{
char sz[32];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt64ToHex(flags, sz + 2);
s.Add_OptSpaced(sz);
}
}
return s;
}
void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NCOM::CPropVariant &prop)
{
prop = Flags64ToString(pairs, num, flags);
}

68
CPP/Windows/PropVariantUtils.h
View File

@@ -1,34 +1,34 @@
// Windows/PropVariantUtils.h
#ifndef __PROP_VARIANT_UTILS_H
#define __PROP_VARIANT_UTILS_H
#include "../Common/MyString.h"
#include "PropVariant.h"
struct CUInt32PCharPair
{
UInt32 Value;
const char *Name;
};
AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value);
void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
AString FlagsToString(const char * const *names, unsigned num, UInt32 flags);
AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags);
void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
AString TypeToString(const char * const table[], unsigned num, UInt32 value);
void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, ARRAY_SIZE(table), value, prop)
void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NWindows::NCOM::CPropVariant &prop);
#define FLAGS64_TO_PROP(pairs, value, prop) Flags64ToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#endif
// Windows/PropVariantUtils.h
#ifndef __PROP_VARIANT_UTILS_H
#define __PROP_VARIANT_UTILS_H
#include "../Common/MyString.h"
#include "PropVariant.h"
struct CUInt32PCharPair
{
UInt32 Value;
const char *Name;
};
AString TypePairToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 value);
void PairToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
AString FlagsToString(const char * const *names, unsigned num, UInt32 flags);
AString FlagsToString(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags);
void FlagsToProp(const char * const *names, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
void FlagsToProp(const CUInt32PCharPair *pairs, unsigned num, UInt32 flags, NWindows::NCOM::CPropVariant &prop);
AString TypeToString(const char * const table[], unsigned num, UInt32 value);
void TypeToProp(const char * const table[], unsigned num, UInt32 value, NWindows::NCOM::CPropVariant &prop);
#define PAIR_TO_PROP(pairs, value, prop) PairToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#define FLAGS_TO_PROP(pairs, value, prop) FlagsToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#define TYPE_TO_PROP(table, value, prop) TypeToProp(table, ARRAY_SIZE(table), value, prop)
void Flags64ToProp(const CUInt32PCharPair *pairs, unsigned num, UInt64 flags, NWindows::NCOM::CPropVariant &prop);
#define FLAGS64_TO_PROP(pairs, value, prop) Flags64ToProp(pairs, ARRAY_SIZE(pairs), value, prop)
#endif

780
CPP/Windows/Registry.cpp
View File

@@ -1,390 +1,390 @@
// Windows/Registry.cpp
#include "StdAfx.h"
#include <wchar.h>
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Registry.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NRegistry {
#define MYASSERT(expr) // _ASSERTE(expr)
LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
LPTSTR keyClass, DWORD options, REGSAM accessMask,
LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
{
MYASSERT(parentKey != NULL);
DWORD dispositionReal;
HKEY key = NULL;
LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
options, accessMask, securityAttributes, &key, &dispositionReal);
if (disposition != NULL)
*disposition = dispositionReal;
if (res == ERROR_SUCCESS)
{
res = Close();
_object = key;
}
return res;
}
LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
{
MYASSERT(parentKey != NULL);
HKEY key = NULL;
LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
if (res == ERROR_SUCCESS)
{
res = Close();
MYASSERT(res == ERROR_SUCCESS);
_object = key;
}
return res;
}
LONG CKey::Close() throw()
{
LONG res = ERROR_SUCCESS;
if (_object != NULL)
{
res = RegCloseKey(_object);
_object = NULL;
}
return res;
}
// win95, win98: deletes sunkey and all its subkeys
// winNT to be deleted must not have subkeys
LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
{
MYASSERT(_object != NULL);
return RegDeleteKey(_object, subKeyName);
}
LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
{
CKey key;
LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
if (res != ERROR_SUCCESS)
return res;
FILETIME fileTime;
const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
DWORD size = kBufSize;
TCHAR buffer[kBufSize];
while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
{
res = key.RecurseDeleteKey(buffer);
if (res != ERROR_SUCCESS)
return res;
size = kBufSize;
}
key.Close();
return DeleteSubKey(subKeyName);
}
/////////////////////////
// Value Functions
static inline UInt32 BoolToUINT32(bool value) { return (value ? 1: 0); }
static inline bool UINT32ToBool(UInt32 value) { return (value != 0); }
LONG CKey::DeleteValue(LPCTSTR name) throw()
{
MYASSERT(_object != NULL);
return ::RegDeleteValue(_object, name);
}
#ifndef _UNICODE
LONG CKey::DeleteValue(LPCWSTR name)
{
MYASSERT(_object != NULL);
if (g_IsNT)
return ::RegDeleteValueW(_object, name);
return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
}
#endif
LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
{
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_DWORD,
(BYTE * const)&value, sizeof(UInt32));
}
LONG CKey::SetValue(LPCTSTR name, bool value) throw()
{
return SetValue(name, BoolToUINT32(value));
}
LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_SZ,
(const BYTE * )value, (lstrlen(value) + 1) * sizeof(TCHAR));
}
/*
LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, NULL, REG_SZ,
(const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
}
*/
#ifndef _UNICODE
LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
if (g_IsNT)
return RegSetValueExW(_object, name, 0, REG_SZ,
(const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
value == 0 ? 0 : (LPCSTR)GetSystemString(value));
}
#endif
LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_BINARY,
(const BYTE *)value, size);
}
LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
{
MYASSERT(value != NULL);
CKey key;
LONG res = key.Create(parentKey, keyName);
if (res == ERROR_SUCCESS)
res = key.SetValue(valueName, value);
return res;
}
LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw()
{
MYASSERT(value != NULL);
CKey key;
LONG res = key.Create(_object, keyName);
if (res == ERROR_SUCCESS)
res = key.SetValue(valueName, value);
return res;
}
LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
{
DWORD type = 0;
DWORD count = sizeof(DWORD);
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type,
(LPBYTE)&value, &count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
{
UInt32 uintValue = BoolToUINT32(value);
LONG res = QueryValue(name, uintValue);
value = UINT32ToBool(uintValue);
return res;
}
LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
{
UInt32 newVal;
LONG res = QueryValue(name, newVal);
if (res == ERROR_SUCCESS)
value = newVal;
return res;
}
LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
{
bool newVal;
LONG res = QueryValue(name, newVal);
if (res == ERROR_SUCCESS)
value = newVal;
return res;
}
LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
{
DWORD type = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
{
value.Empty();
DWORD type = 0;
UInt32 curSize = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&curSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
UInt32 curSize2 = curSize;
res = QueryValue(name, value.GetBuf(curSize), curSize2);
if (curSize > curSize2)
curSize = curSize2;
value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
return res;
}
#ifndef _UNICODE
LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
{
DWORD type = 0;
LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
return res;
}
LONG CKey::QueryValue(LPCWSTR name, UString &value)
{
value.Empty();
DWORD type = 0;
UInt32 curSize = 0;
LONG res;
if (g_IsNT)
{
res = RegQueryValueExW(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
UInt32 curSize2 = curSize;
res = QueryValue(name, value.GetBuf(curSize), curSize2);
if (curSize > curSize2)
curSize = curSize2;
value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
}
else
{
AString vTemp;
res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
value = GetUnicodeString(vTemp);
}
return res;
}
#endif
LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
{
DWORD type = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
{
DWORD type = 0;
dataSize = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&dataSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
value.Alloc(dataSize);
return QueryValue(name, (BYTE *)value, dataSize);
}
LONG CKey::EnumKeys(CSysStringVector &keyNames)
{
keyNames.Clear();
CSysString keyName;
for (DWORD index = 0; ; index++)
{
const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
FILETIME lastWriteTime;
UInt32 nameSize = kBufSize;
LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
(DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
keyName.ReleaseBuf_CalcLen(kBufSize);
if (result == ERROR_NO_MORE_ITEMS)
break;
if (result != ERROR_SUCCESS)
return result;
keyNames.Add(keyName);
}
return ERROR_SUCCESS;
}
LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
{
size_t numChars = 0;
unsigned i;
for (i = 0; i < strings.Size(); i++)
numChars += strings[i].Len() + 1;
CObjArray<wchar_t> buffer(numChars);
size_t pos = 0;
for (i = 0; i < strings.Size(); i++)
{
const UString &s = strings[i];
size_t size = s.Len() + 1;
wmemcpy(buffer + pos, s, size);
pos += size;
}
return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
}
LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
{
strings.Clear();
CByteBuffer buffer;
UInt32 dataSize = 0;
LONG res = QueryValue(valueName, buffer, dataSize);
if (res != ERROR_SUCCESS)
return res;
if (dataSize > buffer.Size())
return E_FAIL;
if (dataSize % sizeof(wchar_t) != 0)
return E_FAIL;
const wchar_t *data = (const wchar_t *)(const Byte *)buffer;
size_t numChars = dataSize / sizeof(wchar_t);
size_t prev = 0;
UString s;
for (size_t i = 0; i < numChars; i++)
{
if (data[i] == 0)
{
s = data + prev;
strings.Add(s);
prev = i + 1;
}
}
return res;
}
}}
// Windows/Registry.cpp
#include "StdAfx.h"
#include <wchar.h>
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Registry.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NRegistry {
#define MYASSERT(expr) // _ASSERTE(expr)
LONG CKey::Create(HKEY parentKey, LPCTSTR keyName,
LPTSTR keyClass, DWORD options, REGSAM accessMask,
LPSECURITY_ATTRIBUTES securityAttributes, LPDWORD disposition) throw()
{
MYASSERT(parentKey != NULL);
DWORD dispositionReal;
HKEY key = NULL;
LONG res = RegCreateKeyEx(parentKey, keyName, 0, keyClass,
options, accessMask, securityAttributes, &key, &dispositionReal);
if (disposition != NULL)
*disposition = dispositionReal;
if (res == ERROR_SUCCESS)
{
res = Close();
_object = key;
}
return res;
}
LONG CKey::Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask) throw()
{
MYASSERT(parentKey != NULL);
HKEY key = NULL;
LONG res = RegOpenKeyEx(parentKey, keyName, 0, accessMask, &key);
if (res == ERROR_SUCCESS)
{
res = Close();
MYASSERT(res == ERROR_SUCCESS);
_object = key;
}
return res;
}
LONG CKey::Close() throw()
{
LONG res = ERROR_SUCCESS;
if (_object != NULL)
{
res = RegCloseKey(_object);
_object = NULL;
}
return res;
}
// win95, win98: deletes sunkey and all its subkeys
// winNT to be deleted must not have subkeys
LONG CKey::DeleteSubKey(LPCTSTR subKeyName) throw()
{
MYASSERT(_object != NULL);
return RegDeleteKey(_object, subKeyName);
}
LONG CKey::RecurseDeleteKey(LPCTSTR subKeyName) throw()
{
CKey key;
LONG res = key.Open(_object, subKeyName, KEY_READ | KEY_WRITE);
if (res != ERROR_SUCCESS)
return res;
FILETIME fileTime;
const UInt32 kBufSize = MAX_PATH + 1; // 256 in ATL
DWORD size = kBufSize;
TCHAR buffer[kBufSize];
while (RegEnumKeyEx(key._object, 0, buffer, &size, NULL, NULL, NULL, &fileTime) == ERROR_SUCCESS)
{
res = key.RecurseDeleteKey(buffer);
if (res != ERROR_SUCCESS)
return res;
size = kBufSize;
}
key.Close();
return DeleteSubKey(subKeyName);
}
/////////////////////////
// Value Functions
static inline UInt32 BoolToUINT32(bool value) { return (value ? 1: 0); }
static inline bool UINT32ToBool(UInt32 value) { return (value != 0); }
LONG CKey::DeleteValue(LPCTSTR name) throw()
{
MYASSERT(_object != NULL);
return ::RegDeleteValue(_object, name);
}
#ifndef _UNICODE
LONG CKey::DeleteValue(LPCWSTR name)
{
MYASSERT(_object != NULL);
if (g_IsNT)
return ::RegDeleteValueW(_object, name);
return DeleteValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name));
}
#endif
LONG CKey::SetValue(LPCTSTR name, UInt32 value) throw()
{
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_DWORD,
(BYTE * const)&value, sizeof(UInt32));
}
LONG CKey::SetValue(LPCTSTR name, bool value) throw()
{
return SetValue(name, BoolToUINT32(value));
}
LONG CKey::SetValue(LPCTSTR name, LPCTSTR value) throw()
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_SZ,
(const BYTE * )value, (lstrlen(value) + 1) * sizeof(TCHAR));
}
/*
LONG CKey::SetValue(LPCTSTR name, const CSysString &value)
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, NULL, REG_SZ,
(const BYTE *)(const TCHAR *)value, (value.Len() + 1) * sizeof(TCHAR));
}
*/
#ifndef _UNICODE
LONG CKey::SetValue(LPCWSTR name, LPCWSTR value)
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
if (g_IsNT)
return RegSetValueExW(_object, name, 0, REG_SZ,
(const BYTE * )value, (DWORD)((wcslen(value) + 1) * sizeof(wchar_t)));
return SetValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name),
value == 0 ? 0 : (LPCSTR)GetSystemString(value));
}
#endif
LONG CKey::SetValue(LPCTSTR name, const void *value, UInt32 size) throw()
{
MYASSERT(value != NULL);
MYASSERT(_object != NULL);
return RegSetValueEx(_object, name, 0, REG_BINARY,
(const BYTE *)value, size);
}
LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value)
{
MYASSERT(value != NULL);
CKey key;
LONG res = key.Create(parentKey, keyName);
if (res == ERROR_SUCCESS)
res = key.SetValue(valueName, value);
return res;
}
LONG CKey::SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw()
{
MYASSERT(value != NULL);
CKey key;
LONG res = key.Create(_object, keyName);
if (res == ERROR_SUCCESS)
res = key.SetValue(valueName, value);
return res;
}
LONG CKey::QueryValue(LPCTSTR name, UInt32 &value) throw()
{
DWORD type = 0;
DWORD count = sizeof(DWORD);
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type,
(LPBYTE)&value, &count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_DWORD));
MYASSERT((res != ERROR_SUCCESS) || (count == sizeof(UInt32)));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, bool &value) throw()
{
UInt32 uintValue = BoolToUINT32(value);
LONG res = QueryValue(name, uintValue);
value = UINT32ToBool(uintValue);
return res;
}
LONG CKey::GetValue_IfOk(LPCTSTR name, UInt32 &value) throw()
{
UInt32 newVal;
LONG res = QueryValue(name, newVal);
if (res == ERROR_SUCCESS)
value = newVal;
return res;
}
LONG CKey::GetValue_IfOk(LPCTSTR name, bool &value) throw()
{
bool newVal;
LONG res = QueryValue(name, newVal);
if (res == ERROR_SUCCESS)
value = newVal;
return res;
}
LONG CKey::QueryValue(LPCTSTR name, LPTSTR value, UInt32 &count) throw()
{
DWORD type = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, CSysString &value)
{
value.Empty();
DWORD type = 0;
UInt32 curSize = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&curSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
UInt32 curSize2 = curSize;
res = QueryValue(name, value.GetBuf(curSize), curSize2);
if (curSize > curSize2)
curSize = curSize2;
value.ReleaseBuf_CalcLen(curSize / sizeof(TCHAR));
return res;
}
#ifndef _UNICODE
LONG CKey::QueryValue(LPCWSTR name, LPWSTR value, UInt32 &count)
{
DWORD type = 0;
LONG res = RegQueryValueExW(_object, name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_SZ) || (type == REG_MULTI_SZ) || (type == REG_EXPAND_SZ));
return res;
}
LONG CKey::QueryValue(LPCWSTR name, UString &value)
{
value.Empty();
DWORD type = 0;
UInt32 curSize = 0;
LONG res;
if (g_IsNT)
{
res = RegQueryValueExW(_object, name, NULL, &type, NULL, (DWORD *)&curSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
UInt32 curSize2 = curSize;
res = QueryValue(name, value.GetBuf(curSize), curSize2);
if (curSize > curSize2)
curSize = curSize2;
value.ReleaseBuf_CalcLen(curSize / sizeof(wchar_t));
}
else
{
AString vTemp;
res = QueryValue(name == 0 ? 0 : (LPCSTR)GetSystemString(name), vTemp);
value = GetUnicodeString(vTemp);
}
return res;
}
#endif
LONG CKey::QueryValue(LPCTSTR name, void *value, UInt32 &count) throw()
{
DWORD type = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, (LPBYTE)value, (DWORD *)&count);
MYASSERT((res != ERROR_SUCCESS) || (type == REG_BINARY));
return res;
}
LONG CKey::QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize)
{
DWORD type = 0;
dataSize = 0;
LONG res = RegQueryValueEx(_object, (LPTSTR)name, NULL, &type, NULL, (DWORD *)&dataSize);
if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA)
return res;
value.Alloc(dataSize);
return QueryValue(name, (BYTE *)value, dataSize);
}
LONG CKey::EnumKeys(CSysStringVector &keyNames)
{
keyNames.Clear();
CSysString keyName;
for (DWORD index = 0; ; index++)
{
const unsigned kBufSize = MAX_PATH + 1; // 256 in ATL
FILETIME lastWriteTime;
UInt32 nameSize = kBufSize;
LONG result = ::RegEnumKeyEx(_object, index, keyName.GetBuf(kBufSize),
(DWORD *)&nameSize, NULL, NULL, NULL, &lastWriteTime);
keyName.ReleaseBuf_CalcLen(kBufSize);
if (result == ERROR_NO_MORE_ITEMS)
break;
if (result != ERROR_SUCCESS)
return result;
keyNames.Add(keyName);
}
return ERROR_SUCCESS;
}
LONG CKey::SetValue_Strings(LPCTSTR valueName, const UStringVector &strings)
{
size_t numChars = 0;
unsigned i;
for (i = 0; i < strings.Size(); i++)
numChars += strings[i].Len() + 1;
CObjArray<wchar_t> buffer(numChars);
size_t pos = 0;
for (i = 0; i < strings.Size(); i++)
{
const UString &s = strings[i];
size_t size = s.Len() + 1;
wmemcpy(buffer + pos, s, size);
pos += size;
}
return SetValue(valueName, buffer, (UInt32)numChars * sizeof(wchar_t));
}
LONG CKey::GetValue_Strings(LPCTSTR valueName, UStringVector &strings)
{
strings.Clear();
CByteBuffer buffer;
UInt32 dataSize = 0;
LONG res = QueryValue(valueName, buffer, dataSize);
if (res != ERROR_SUCCESS)
return res;
if (dataSize > buffer.Size())
return E_FAIL;
if (dataSize % sizeof(wchar_t) != 0)
return E_FAIL;
const wchar_t *data = (const wchar_t *)(const Byte *)buffer;
size_t numChars = dataSize / sizeof(wchar_t);
size_t prev = 0;
UString s;
for (size_t i = 0; i < numChars; i++)
{
if (data[i] == 0)
{
s = data + prev;
strings.Add(s);
prev = i + 1;
}
}
return res;
}
}}

168
CPP/Windows/Registry.h
View File

@@ -1,84 +1,84 @@
// Windows/Registry.h
#ifndef __WINDOWS_REGISTRY_H
#define __WINDOWS_REGISTRY_H
#include "../Common/MyBuffer.h"
#include "../Common/MyString.h"
namespace NWindows {
namespace NRegistry {
LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value);
class CKey
{
HKEY _object;
public:
CKey(): _object(NULL) {}
~CKey() { Close(); }
operator HKEY() const { return _object; }
void Attach(HKEY key) { _object = key; }
HKEY Detach()
{
HKEY key = _object;
_object = NULL;
return key;
}
LONG Create(HKEY parentKey, LPCTSTR keyName,
LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
REGSAM accessMask = KEY_ALL_ACCESS,
LPSECURITY_ATTRIBUTES securityAttributes = NULL,
LPDWORD disposition = NULL) throw();
LONG Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask = KEY_ALL_ACCESS) throw();
LONG Close() throw();
LONG DeleteSubKey(LPCTSTR subKeyName) throw();
LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
LONG DeleteValue(LPCTSTR name) throw();
#ifndef _UNICODE
LONG DeleteValue(LPCWSTR name);
#endif
LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
LONG SetValue(LPCTSTR valueName, bool value) throw();
LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
// LONG SetValue(LPCTSTR valueName, const CSysString &value);
#ifndef _UNICODE
LONG SetValue(LPCWSTR name, LPCWSTR value);
// LONG SetValue(LPCWSTR name, const UString &value);
#endif
LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
LONG SetValue_Strings(LPCTSTR valueName, const UStringVector &strings);
LONG GetValue_Strings(LPCTSTR valueName, UStringVector &strings);
LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
LONG QueryValue(LPCTSTR name, bool &value) throw();
LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
LONG QueryValue(LPCTSTR name, CSysString &value);
LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
#ifndef _UNICODE
LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
LONG QueryValue(LPCWSTR name, UString &value);
#endif
LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
LONG EnumKeys(CSysStringVector &keyNames);
};
}}
#endif
// Windows/Registry.h
#ifndef __WINDOWS_REGISTRY_H
#define __WINDOWS_REGISTRY_H
#include "../Common/MyBuffer.h"
#include "../Common/MyString.h"
namespace NWindows {
namespace NRegistry {
LONG SetValue(HKEY parentKey, LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value);
class CKey
{
HKEY _object;
public:
CKey(): _object(NULL) {}
~CKey() { Close(); }
operator HKEY() const { return _object; }
void Attach(HKEY key) { _object = key; }
HKEY Detach()
{
HKEY key = _object;
_object = NULL;
return key;
}
LONG Create(HKEY parentKey, LPCTSTR keyName,
LPTSTR keyClass = REG_NONE, DWORD options = REG_OPTION_NON_VOLATILE,
REGSAM accessMask = KEY_ALL_ACCESS,
LPSECURITY_ATTRIBUTES securityAttributes = NULL,
LPDWORD disposition = NULL) throw();
LONG Open(HKEY parentKey, LPCTSTR keyName, REGSAM accessMask = KEY_ALL_ACCESS) throw();
LONG Close() throw();
LONG DeleteSubKey(LPCTSTR subKeyName) throw();
LONG RecurseDeleteKey(LPCTSTR subKeyName) throw();
LONG DeleteValue(LPCTSTR name) throw();
#ifndef _UNICODE
LONG DeleteValue(LPCWSTR name);
#endif
LONG SetValue(LPCTSTR valueName, UInt32 value) throw();
LONG SetValue(LPCTSTR valueName, bool value) throw();
LONG SetValue(LPCTSTR valueName, LPCTSTR value) throw();
// LONG SetValue(LPCTSTR valueName, const CSysString &value);
#ifndef _UNICODE
LONG SetValue(LPCWSTR name, LPCWSTR value);
// LONG SetValue(LPCWSTR name, const UString &value);
#endif
LONG SetValue(LPCTSTR name, const void *value, UInt32 size) throw();
LONG SetValue_Strings(LPCTSTR valueName, const UStringVector &strings);
LONG GetValue_Strings(LPCTSTR valueName, UStringVector &strings);
LONG SetKeyValue(LPCTSTR keyName, LPCTSTR valueName, LPCTSTR value) throw();
LONG QueryValue(LPCTSTR name, UInt32 &value) throw();
LONG QueryValue(LPCTSTR name, bool &value) throw();
LONG QueryValue(LPCTSTR name, LPTSTR value, UInt32 &dataSize) throw();
LONG QueryValue(LPCTSTR name, CSysString &value);
LONG GetValue_IfOk(LPCTSTR name, UInt32 &value) throw();
LONG GetValue_IfOk(LPCTSTR name, bool &value) throw();
#ifndef _UNICODE
LONG QueryValue(LPCWSTR name, LPWSTR value, UInt32 &dataSize);
LONG QueryValue(LPCWSTR name, UString &value);
#endif
LONG QueryValue(LPCTSTR name, void *value, UInt32 &dataSize) throw();
LONG QueryValue(LPCTSTR name, CByteBuffer &value, UInt32 &dataSize);
LONG EnumKeys(CSysStringVector &keyNames);
};
}}
#endif

206
CPP/Windows/ResourceString.cpp
View File

@@ -1,103 +1,103 @@
// Windows/ResourceString.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "ResourceString.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
{
CSysString s;
int size = 128;
int len;
do
{
size <<= 1;
len = ::LoadString(hInstance, resourceID, s.GetBuf(size - 1), size);
}
while (size - len <= 1);
s.ReleaseBuf_CalcLen(len);
return s;
}
#endif
static const int kStartSize = 256;
static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
{
int size = kStartSize;
int len;
do
{
size <<= 1;
len = ::LoadStringW(hInstance, resourceID, s.GetBuf(size - 1), size);
}
while (size - len <= 1);
s.ReleaseBuf_CalcLen(len);
}
// NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.
UString MyLoadString(UINT resourceID)
{
#ifndef _UNICODE
if (!g_IsNT)
return GetUnicodeString(MyLoadStringA(g_hInstance, resourceID));
else
#endif
{
{
wchar_t s[kStartSize];
s[0] = 0;
int len = ::LoadStringW(g_hInstance, resourceID, s, kStartSize);
if (kStartSize - len > 1)
return s;
}
UString dest;
MyLoadString2(g_hInstance, resourceID, dest);
return dest;
}
}
void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest)
{
dest.Empty();
#ifndef _UNICODE
if (!g_IsNT)
MultiByteToUnicodeString2(dest, MyLoadStringA(hInstance, resourceID));
else
#endif
{
{
wchar_t s[kStartSize];
s[0] = 0;
int len = ::LoadStringW(hInstance, resourceID, s, kStartSize);
if (kStartSize - len > 1)
{
dest = s;
return;
}
}
MyLoadString2(hInstance, resourceID, dest);
}
}
void MyLoadString(UINT resourceID, UString &dest)
{
MyLoadString(g_hInstance, resourceID, dest);
}
}
// Windows/ResourceString.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "ResourceString.h"
extern HINSTANCE g_hInstance;
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
static CSysString MyLoadStringA(HINSTANCE hInstance, UINT resourceID)
{
CSysString s;
int size = 128;
int len;
do
{
size <<= 1;
len = ::LoadString(hInstance, resourceID, s.GetBuf(size - 1), size);
}
while (size - len <= 1);
s.ReleaseBuf_CalcLen(len);
return s;
}
#endif
static const int kStartSize = 256;
static void MyLoadString2(HINSTANCE hInstance, UINT resourceID, UString &s)
{
int size = kStartSize;
int len;
do
{
size <<= 1;
len = ::LoadStringW(hInstance, resourceID, s.GetBuf(size - 1), size);
}
while (size - len <= 1);
s.ReleaseBuf_CalcLen(len);
}
// NT4 doesn't support LoadStringW(,,, 0) to get pointer to resource string. So we don't use it.
UString MyLoadString(UINT resourceID)
{
#ifndef _UNICODE
if (!g_IsNT)
return GetUnicodeString(MyLoadStringA(g_hInstance, resourceID));
else
#endif
{
{
wchar_t s[kStartSize];
s[0] = 0;
int len = ::LoadStringW(g_hInstance, resourceID, s, kStartSize);
if (kStartSize - len > 1)
return s;
}
UString dest;
MyLoadString2(g_hInstance, resourceID, dest);
return dest;
}
}
void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest)
{
dest.Empty();
#ifndef _UNICODE
if (!g_IsNT)
MultiByteToUnicodeString2(dest, MyLoadStringA(hInstance, resourceID));
else
#endif
{
{
wchar_t s[kStartSize];
s[0] = 0;
int len = ::LoadStringW(hInstance, resourceID, s, kStartSize);
if (kStartSize - len > 1)
{
dest = s;
return;
}
}
MyLoadString2(hInstance, resourceID, dest);
}
}
void MyLoadString(UINT resourceID, UString &dest)
{
MyLoadString(g_hInstance, resourceID, dest);
}
}

32
CPP/Windows/ResourceString.h
View File

@@ -1,16 +1,16 @@
// Windows/ResourceString.h
#ifndef __WINDOWS_RESOURCE_STRING_H
#define __WINDOWS_RESOURCE_STRING_H
#include "../Common/MyString.h"
namespace NWindows {
UString MyLoadString(UINT resourceID);
void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest);
void MyLoadString(UINT resourceID, UString &dest);
}
#endif
// Windows/ResourceString.h
#ifndef __WINDOWS_RESOURCE_STRING_H
#define __WINDOWS_RESOURCE_STRING_H
#include "../Common/MyString.h"
namespace NWindows {
UString MyLoadString(UINT resourceID);
void MyLoadString(HINSTANCE hInstance, UINT resourceID, UString &dest);
void MyLoadString(UINT resourceID, UString &dest);
}
#endif

362
CPP/Windows/SecurityUtils.cpp
View File

@@ -1,181 +1,181 @@
// Windows/SecurityUtils.cpp
#include "StdAfx.h"
#include "../Common/MyString.h"
#include "SecurityUtils.h"
namespace NWindows {
namespace NSecurity {
/*
bool MyLookupAccountSid(LPCTSTR systemName, PSID sid,
CSysString &accountName, CSysString &domainName, PSID_NAME_USE sidNameUse)
{
DWORD accountNameSize = 0, domainNameSize = 0;
if (!::LookupAccountSid(systemName, sid,
accountName.GetBuf(0), &accountNameSize,
domainName.GetBuf(0), &domainNameSize, sidNameUse))
{
if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return false;
}
DWORD accountNameSize2 = accountNameSize, domainNameSize2 = domainNameSize;
bool result = BOOLToBool(::LookupAccountSid(systemName, sid,
accountName.GetBuf(accountNameSize), &accountNameSize2,
domainName.GetBuf(domainNameSize), &domainNameSize2, sidNameUse));
accountName.ReleaseBuf_CalcLen(accountNameSize);
domainName.ReleaseBuf_CalcLen(domainNameSize);
return result;
}
*/
static void SetLsaString(LPWSTR src, PLSA_UNICODE_STRING dest)
{
int len = (int)wcslen(src);
dest->Length = (USHORT)(len * sizeof(WCHAR));
dest->MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
dest->Buffer = src;
}
/*
static void MyLookupSids(CPolicy &policy, PSID ps)
{
LSA_REFERENCED_DOMAIN_LIST *referencedDomains = NULL;
LSA_TRANSLATED_NAME *names = NULL;
NTSTATUS nts = policy.LookupSids(1, &ps, &referencedDomains, &names);
int res = LsaNtStatusToWinError(nts);
LsaFreeMemory(referencedDomains);
LsaFreeMemory(names);
}
*/
#ifndef _UNICODE
typedef BOOL (WINAPI * LookupAccountNameWP)(
LPCWSTR lpSystemName,
LPCWSTR lpAccountName,
PSID Sid,
LPDWORD cbSid,
LPWSTR ReferencedDomainName,
LPDWORD cchReferencedDomainName,
PSID_NAME_USE peUse
);
#endif
static PSID GetSid(LPWSTR accountName)
{
#ifndef _UNICODE
HMODULE hModule = GetModuleHandle(TEXT("Advapi32.dll"));
if (hModule == NULL)
return NULL;
LookupAccountNameWP lookupAccountNameW = (LookupAccountNameWP)GetProcAddress(hModule, "LookupAccountNameW");
if (lookupAccountNameW == NULL)
return NULL;
#endif
DWORD sidLen = 0, domainLen = 0;
SID_NAME_USE sidNameUse;
if (!
#ifdef _UNICODE
::LookupAccountNameW
#else
lookupAccountNameW
#endif
(NULL, accountName, NULL, &sidLen, NULL, &domainLen, &sidNameUse))
{
if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
PSID pSid = ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidLen);
LPWSTR domainName = (LPWSTR)::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (domainLen + 1) * sizeof(WCHAR));
BOOL res =
#ifdef _UNICODE
::LookupAccountNameW
#else
lookupAccountNameW
#endif
(NULL, accountName, pSid, &sidLen, domainName, &domainLen, &sidNameUse);
::HeapFree(GetProcessHeap(), 0, domainName);
if (res)
return pSid;
}
}
return NULL;
}
#define MY__SE_LOCK_MEMORY_NAME L"SeLockMemoryPrivilege"
bool AddLockMemoryPrivilege()
{
CPolicy policy;
LSA_OBJECT_ATTRIBUTES attr;
attr.Length = sizeof(attr);
attr.RootDirectory = NULL;
attr.ObjectName = NULL;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
if (policy.Open(NULL, &attr,
// GENERIC_WRITE)
POLICY_ALL_ACCESS)
// STANDARD_RIGHTS_REQUIRED,
// GENERIC_READ | GENERIC_EXECUTE | POLICY_VIEW_LOCAL_INFORMATION | POLICY_LOOKUP_NAMES)
!= 0)
return false;
LSA_UNICODE_STRING userRights;
wchar_t s[128] = MY__SE_LOCK_MEMORY_NAME;
SetLsaString(s, &userRights);
WCHAR userName[256 + 2];
DWORD size = 256;
if (!GetUserNameW(userName, &size))
return false;
PSID psid = GetSid(userName);
if (psid == NULL)
return false;
bool res = false;
/*
PLSA_UNICODE_STRING userRightsArray;
ULONG countOfRights;
NTSTATUS status = policy.EnumerateAccountRights(psid, &userRightsArray, &countOfRights);
if (status != 0)
return false;
bool finded = false;
for (ULONG i = 0; i < countOfRights; i++)
{
LSA_UNICODE_STRING &ur = userRightsArray[i];
if (ur.Length != s.Length() * sizeof(WCHAR))
continue;
if (wcsncmp(ur.Buffer, s, s.Length()) != 0)
continue;
finded = true;
res = true;
break;
}
if (!finded)
*/
{
/*
LSA_ENUMERATION_INFORMATION *enums;
ULONG countReturned;
NTSTATUS status = policy.EnumerateAccountsWithUserRight(&userRights, &enums, &countReturned);
if (status == 0)
{
for (ULONG i = 0; i < countReturned; i++)
MyLookupSids(policy, enums[i].Sid);
if (enums)
::LsaFreeMemory(enums);
res = true;
}
*/
NTSTATUS status = policy.AddAccountRights(psid, &userRights);
if (status == 0)
res = true;
// ULONG res = LsaNtStatusToWinError(status);
}
HeapFree(GetProcessHeap(), 0, psid);
return res;
}
}}
// Windows/SecurityUtils.cpp
#include "StdAfx.h"
#include "../Common/MyString.h"
#include "SecurityUtils.h"
namespace NWindows {
namespace NSecurity {
/*
bool MyLookupAccountSid(LPCTSTR systemName, PSID sid,
CSysString &accountName, CSysString &domainName, PSID_NAME_USE sidNameUse)
{
DWORD accountNameSize = 0, domainNameSize = 0;
if (!::LookupAccountSid(systemName, sid,
accountName.GetBuf(0), &accountNameSize,
domainName.GetBuf(0), &domainNameSize, sidNameUse))
{
if (::GetLastError() != ERROR_INSUFFICIENT_BUFFER)
return false;
}
DWORD accountNameSize2 = accountNameSize, domainNameSize2 = domainNameSize;
bool result = BOOLToBool(::LookupAccountSid(systemName, sid,
accountName.GetBuf(accountNameSize), &accountNameSize2,
domainName.GetBuf(domainNameSize), &domainNameSize2, sidNameUse));
accountName.ReleaseBuf_CalcLen(accountNameSize);
domainName.ReleaseBuf_CalcLen(domainNameSize);
return result;
}
*/
static void SetLsaString(LPWSTR src, PLSA_UNICODE_STRING dest)
{
int len = (int)wcslen(src);
dest->Length = (USHORT)(len * sizeof(WCHAR));
dest->MaximumLength = (USHORT)((len + 1) * sizeof(WCHAR));
dest->Buffer = src;
}
/*
static void MyLookupSids(CPolicy &policy, PSID ps)
{
LSA_REFERENCED_DOMAIN_LIST *referencedDomains = NULL;
LSA_TRANSLATED_NAME *names = NULL;
NTSTATUS nts = policy.LookupSids(1, &ps, &referencedDomains, &names);
int res = LsaNtStatusToWinError(nts);
LsaFreeMemory(referencedDomains);
LsaFreeMemory(names);
}
*/
#ifndef _UNICODE
typedef BOOL (WINAPI * LookupAccountNameWP)(
LPCWSTR lpSystemName,
LPCWSTR lpAccountName,
PSID Sid,
LPDWORD cbSid,
LPWSTR ReferencedDomainName,
LPDWORD cchReferencedDomainName,
PSID_NAME_USE peUse
);
#endif
static PSID GetSid(LPWSTR accountName)
{
#ifndef _UNICODE
HMODULE hModule = GetModuleHandle(TEXT("Advapi32.dll"));
if (hModule == NULL)
return NULL;
LookupAccountNameWP lookupAccountNameW = (LookupAccountNameWP)GetProcAddress(hModule, "LookupAccountNameW");
if (lookupAccountNameW == NULL)
return NULL;
#endif
DWORD sidLen = 0, domainLen = 0;
SID_NAME_USE sidNameUse;
if (!
#ifdef _UNICODE
::LookupAccountNameW
#else
lookupAccountNameW
#endif
(NULL, accountName, NULL, &sidLen, NULL, &domainLen, &sidNameUse))
{
if (::GetLastError() == ERROR_INSUFFICIENT_BUFFER)
{
PSID pSid = ::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sidLen);
LPWSTR domainName = (LPWSTR)::HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (domainLen + 1) * sizeof(WCHAR));
BOOL res =
#ifdef _UNICODE
::LookupAccountNameW
#else
lookupAccountNameW
#endif
(NULL, accountName, pSid, &sidLen, domainName, &domainLen, &sidNameUse);
::HeapFree(GetProcessHeap(), 0, domainName);
if (res)
return pSid;
}
}
return NULL;
}
#define MY__SE_LOCK_MEMORY_NAME L"SeLockMemoryPrivilege"
bool AddLockMemoryPrivilege()
{
CPolicy policy;
LSA_OBJECT_ATTRIBUTES attr;
attr.Length = sizeof(attr);
attr.RootDirectory = NULL;
attr.ObjectName = NULL;
attr.Attributes = 0;
attr.SecurityDescriptor = NULL;
attr.SecurityQualityOfService = NULL;
if (policy.Open(NULL, &attr,
// GENERIC_WRITE)
POLICY_ALL_ACCESS)
// STANDARD_RIGHTS_REQUIRED,
// GENERIC_READ | GENERIC_EXECUTE | POLICY_VIEW_LOCAL_INFORMATION | POLICY_LOOKUP_NAMES)
!= 0)
return false;
LSA_UNICODE_STRING userRights;
wchar_t s[128] = MY__SE_LOCK_MEMORY_NAME;
SetLsaString(s, &userRights);
WCHAR userName[256 + 2];
DWORD size = 256;
if (!GetUserNameW(userName, &size))
return false;
PSID psid = GetSid(userName);
if (psid == NULL)
return false;
bool res = false;
/*
PLSA_UNICODE_STRING userRightsArray;
ULONG countOfRights;
NTSTATUS status = policy.EnumerateAccountRights(psid, &userRightsArray, &countOfRights);
if (status != 0)
return false;
bool finded = false;
for (ULONG i = 0; i < countOfRights; i++)
{
LSA_UNICODE_STRING &ur = userRightsArray[i];
if (ur.Length != s.Length() * sizeof(WCHAR))
continue;
if (wcsncmp(ur.Buffer, s, s.Length()) != 0)
continue;
finded = true;
res = true;
break;
}
if (!finded)
*/
{
/*
LSA_ENUMERATION_INFORMATION *enums;
ULONG countReturned;
NTSTATUS status = policy.EnumerateAccountsWithUserRight(&userRights, &enums, &countReturned);
if (status == 0)
{
for (ULONG i = 0; i < countReturned; i++)
MyLookupSids(policy, enums[i].Sid);
if (enums)
::LsaFreeMemory(enums);
res = true;
}
*/
NTSTATUS status = policy.AddAccountRights(psid, &userRights);
if (status == 0)
res = true;
// ULONG res = LsaNtStatusToWinError(status);
}
HeapFree(GetProcessHeap(), 0, psid);
return res;
}
}}

334
CPP/Windows/SecurityUtils.h
View File

@@ -1,167 +1,167 @@
// Windows/SecurityUtils.h
#ifndef __WINDOWS_SECURITY_UTILS_H
#define __WINDOWS_SECURITY_UTILS_H
#include <NTSecAPI.h>
#include "Defs.h"
namespace NWindows {
namespace NSecurity {
class CAccessToken
{
HANDLE _handle;
public:
CAccessToken(): _handle(NULL) {};
~CAccessToken() { Close(); }
bool Close()
{
if (_handle == NULL)
return true;
bool res = BOOLToBool(::CloseHandle(_handle));
if (res)
_handle = NULL;
return res;
}
bool OpenProcessToken(HANDLE processHandle, DWORD desiredAccess)
{
Close();
return BOOLToBool(::OpenProcessToken(processHandle, desiredAccess, &_handle));
}
/*
bool OpenThreadToken(HANDLE threadHandle, DWORD desiredAccess, bool openAsSelf)
{
Close();
return BOOLToBool(::OpenTreadToken(threadHandle, desiredAccess, BoolToBOOL(anOpenAsSelf), &_handle));
}
*/
bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState,
DWORD bufferLength, PTOKEN_PRIVILEGES previousState, PDWORD returnLength)
{ return BOOLToBool(::AdjustTokenPrivileges(_handle, BoolToBOOL(disableAllPrivileges),
newState, bufferLength, previousState, returnLength)); }
bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState)
{ return AdjustPrivileges(disableAllPrivileges, newState, 0, NULL, NULL); }
bool AdjustPrivileges(PTOKEN_PRIVILEGES newState)
{ return AdjustPrivileges(false, newState); }
};
#ifndef _UNICODE
typedef NTSTATUS (NTAPI *LsaOpenPolicyP)(PLSA_UNICODE_STRING SystemName,
PLSA_OBJECT_ATTRIBUTES ObjectAttributes, ACCESS_MASK DesiredAccess, PLSA_HANDLE PolicyHandle);
typedef NTSTATUS (NTAPI *LsaCloseP)(LSA_HANDLE ObjectHandle);
typedef NTSTATUS (NTAPI *LsaAddAccountRightsP)(LSA_HANDLE PolicyHandle,
PSID AccountSid, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights );
#define MY_STATUS_NOT_IMPLEMENTED ((NTSTATUS)0xC0000002L)
#endif
struct CPolicy
{
protected:
LSA_HANDLE _handle;
#ifndef _UNICODE
HMODULE hModule;
#endif
public:
operator LSA_HANDLE() const { return _handle; }
CPolicy(): _handle(NULL)
{
#ifndef _UNICODE
hModule = GetModuleHandle(TEXT("Advapi32.dll"));
#endif
};
~CPolicy() { Close(); }
NTSTATUS Open(PLSA_UNICODE_STRING systemName, PLSA_OBJECT_ATTRIBUTES objectAttributes,
ACCESS_MASK desiredAccess)
{
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaOpenPolicyP lsaOpenPolicy = (LsaOpenPolicyP)GetProcAddress(hModule, "LsaOpenPolicy");
if (lsaOpenPolicy == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
Close();
return
#ifdef _UNICODE
::LsaOpenPolicy
#else
lsaOpenPolicy
#endif
(systemName, objectAttributes, desiredAccess, &_handle);
}
NTSTATUS Close()
{
if (_handle == NULL)
return 0;
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaCloseP lsaClose = (LsaCloseP)GetProcAddress(hModule, "LsaClose");
if (lsaClose == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
NTSTATUS res =
#ifdef _UNICODE
::LsaClose
#else
lsaClose
#endif
(_handle);
_handle = NULL;
return res;
}
NTSTATUS EnumerateAccountsWithUserRight(PLSA_UNICODE_STRING userRights,
PLSA_ENUMERATION_INFORMATION *enumerationBuffer, PULONG countReturned)
{ return LsaEnumerateAccountsWithUserRight(_handle, userRights, (void **)enumerationBuffer, countReturned); }
NTSTATUS EnumerateAccountRights(PSID sid, PLSA_UNICODE_STRING* userRights, PULONG countOfRights)
{ return ::LsaEnumerateAccountRights(_handle, sid, userRights, countOfRights); }
NTSTATUS LookupSids(ULONG count, PSID* sids,
PLSA_REFERENCED_DOMAIN_LIST* referencedDomains, PLSA_TRANSLATED_NAME* names)
{ return LsaLookupSids(_handle, count, sids, referencedDomains, names); }
NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
{
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaAddAccountRightsP lsaAddAccountRights = (LsaAddAccountRightsP)GetProcAddress(hModule, "LsaAddAccountRights");
if (lsaAddAccountRights == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
return
#ifdef _UNICODE
::LsaAddAccountRights
#else
lsaAddAccountRights
#endif
(_handle, accountSid, userRights, countOfRights);
}
NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights)
{ return AddAccountRights(accountSid, userRights, 1); }
NTSTATUS RemoveAccountRights(PSID accountSid, bool allRights, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
{ return LsaRemoveAccountRights(_handle, accountSid, (BOOLEAN)(allRights ? TRUE : FALSE), userRights, countOfRights); }
};
bool AddLockMemoryPrivilege();
}}
#endif
// Windows/SecurityUtils.h
#ifndef __WINDOWS_SECURITY_UTILS_H
#define __WINDOWS_SECURITY_UTILS_H
#include <NTSecAPI.h>
#include "Defs.h"
namespace NWindows {
namespace NSecurity {
class CAccessToken
{
HANDLE _handle;
public:
CAccessToken(): _handle(NULL) {};
~CAccessToken() { Close(); }
bool Close()
{
if (_handle == NULL)
return true;
bool res = BOOLToBool(::CloseHandle(_handle));
if (res)
_handle = NULL;
return res;
}
bool OpenProcessToken(HANDLE processHandle, DWORD desiredAccess)
{
Close();
return BOOLToBool(::OpenProcessToken(processHandle, desiredAccess, &_handle));
}
/*
bool OpenThreadToken(HANDLE threadHandle, DWORD desiredAccess, bool openAsSelf)
{
Close();
return BOOLToBool(::OpenTreadToken(threadHandle, desiredAccess, BoolToBOOL(anOpenAsSelf), &_handle));
}
*/
bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState,
DWORD bufferLength, PTOKEN_PRIVILEGES previousState, PDWORD returnLength)
{ return BOOLToBool(::AdjustTokenPrivileges(_handle, BoolToBOOL(disableAllPrivileges),
newState, bufferLength, previousState, returnLength)); }
bool AdjustPrivileges(bool disableAllPrivileges, PTOKEN_PRIVILEGES newState)
{ return AdjustPrivileges(disableAllPrivileges, newState, 0, NULL, NULL); }
bool AdjustPrivileges(PTOKEN_PRIVILEGES newState)
{ return AdjustPrivileges(false, newState); }
};
#ifndef _UNICODE
typedef NTSTATUS (NTAPI *LsaOpenPolicyP)(PLSA_UNICODE_STRING SystemName,
PLSA_OBJECT_ATTRIBUTES ObjectAttributes, ACCESS_MASK DesiredAccess, PLSA_HANDLE PolicyHandle);
typedef NTSTATUS (NTAPI *LsaCloseP)(LSA_HANDLE ObjectHandle);
typedef NTSTATUS (NTAPI *LsaAddAccountRightsP)(LSA_HANDLE PolicyHandle,
PSID AccountSid, PLSA_UNICODE_STRING UserRights, ULONG CountOfRights );
#define MY_STATUS_NOT_IMPLEMENTED ((NTSTATUS)0xC0000002L)
#endif
struct CPolicy
{
protected:
LSA_HANDLE _handle;
#ifndef _UNICODE
HMODULE hModule;
#endif
public:
operator LSA_HANDLE() const { return _handle; }
CPolicy(): _handle(NULL)
{
#ifndef _UNICODE
hModule = GetModuleHandle(TEXT("Advapi32.dll"));
#endif
};
~CPolicy() { Close(); }
NTSTATUS Open(PLSA_UNICODE_STRING systemName, PLSA_OBJECT_ATTRIBUTES objectAttributes,
ACCESS_MASK desiredAccess)
{
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaOpenPolicyP lsaOpenPolicy = (LsaOpenPolicyP)GetProcAddress(hModule, "LsaOpenPolicy");
if (lsaOpenPolicy == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
Close();
return
#ifdef _UNICODE
::LsaOpenPolicy
#else
lsaOpenPolicy
#endif
(systemName, objectAttributes, desiredAccess, &_handle);
}
NTSTATUS Close()
{
if (_handle == NULL)
return 0;
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaCloseP lsaClose = (LsaCloseP)GetProcAddress(hModule, "LsaClose");
if (lsaClose == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
NTSTATUS res =
#ifdef _UNICODE
::LsaClose
#else
lsaClose
#endif
(_handle);
_handle = NULL;
return res;
}
NTSTATUS EnumerateAccountsWithUserRight(PLSA_UNICODE_STRING userRights,
PLSA_ENUMERATION_INFORMATION *enumerationBuffer, PULONG countReturned)
{ return LsaEnumerateAccountsWithUserRight(_handle, userRights, (void **)enumerationBuffer, countReturned); }
NTSTATUS EnumerateAccountRights(PSID sid, PLSA_UNICODE_STRING* userRights, PULONG countOfRights)
{ return ::LsaEnumerateAccountRights(_handle, sid, userRights, countOfRights); }
NTSTATUS LookupSids(ULONG count, PSID* sids,
PLSA_REFERENCED_DOMAIN_LIST* referencedDomains, PLSA_TRANSLATED_NAME* names)
{ return LsaLookupSids(_handle, count, sids, referencedDomains, names); }
NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
{
#ifndef _UNICODE
if (hModule == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
LsaAddAccountRightsP lsaAddAccountRights = (LsaAddAccountRightsP)GetProcAddress(hModule, "LsaAddAccountRights");
if (lsaAddAccountRights == NULL)
return MY_STATUS_NOT_IMPLEMENTED;
#endif
return
#ifdef _UNICODE
::LsaAddAccountRights
#else
lsaAddAccountRights
#endif
(_handle, accountSid, userRights, countOfRights);
}
NTSTATUS AddAccountRights(PSID accountSid, PLSA_UNICODE_STRING userRights)
{ return AddAccountRights(accountSid, userRights, 1); }
NTSTATUS RemoveAccountRights(PSID accountSid, bool allRights, PLSA_UNICODE_STRING userRights, ULONG countOfRights)
{ return LsaRemoveAccountRights(_handle, accountSid, (BOOLEAN)(allRights ? TRUE : FALSE), userRights, countOfRights); }
};
bool AddLockMemoryPrivilege();
}}
#endif

716
CPP/Windows/Shell.cpp
View File

@@ -1,358 +1,358 @@
// Windows/Shell.cpp
#include "StdAfx.h"
/*
#include <stdio.h>
#include <string.h>
*/
#include "../Common/MyCom.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "COM.h"
#include "Shell.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NShell {
#ifndef UNDER_CE
// SHGetMalloc is unsupported in Windows Mobile?
void CItemIDList::Free()
{
if (m_Object == NULL)
return;
CMyComPtr<IMalloc> shellMalloc;
if (::SHGetMalloc(&shellMalloc) != NOERROR)
throw 41099;
shellMalloc->Free(m_Object);
m_Object = NULL;
}
/*
CItemIDList::(LPCITEMIDLIST itemIDList): m_Object(NULL)
{ *this = itemIDList; }
CItemIDList::(const CItemIDList& itemIDList): m_Object(NULL)
{ *this = itemIDList; }
CItemIDList& CItemIDList::operator=(LPCITEMIDLIST object)
{
Free();
if (object != 0)
{
UINT32 size = GetSize(object);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
if (m_Object != NULL)
MoveMemory(m_Object, object, size);
}
return *this;
}
CItemIDList& CItemIDList::operator=(const CItemIDList &object)
{
Free();
if (object.m_Object != NULL)
{
UINT32 size = GetSize(object.m_Object);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
if (m_Object != NULL)
MoveMemory(m_Object, object.m_Object, size);
}
return *this;
}
*/
/////////////////////////////
// CDrop
void CDrop::Attach(HDROP object)
{
Free();
m_Object = object;
m_Assigned = true;
}
void CDrop::Free()
{
if (m_MustBeFinished && m_Assigned)
Finish();
m_Assigned = false;
}
UINT CDrop::QueryCountOfFiles()
{
return QueryFile(0xFFFFFFFF, (LPTSTR)NULL, 0);
}
UString CDrop::QueryFileName(UINT fileIndex)
{
UString fileName;
#ifndef _UNICODE
if (!g_IsNT)
{
AString fileNameA;
UINT bufferSize = QueryFile(fileIndex, (LPTSTR)NULL, 0);
const unsigned len = bufferSize + 2;
QueryFile(fileIndex, fileNameA.GetBuf(len), bufferSize + 1);
fileNameA.ReleaseBuf_CalcLen(len);
fileName = GetUnicodeString(fileNameA);
}
else
#endif
{
UINT bufferSize = QueryFile(fileIndex, (LPWSTR)NULL, 0);
const unsigned len = bufferSize + 2;
QueryFile(fileIndex, fileName.GetBuf(len), bufferSize + 1);
fileName.ReleaseBuf_CalcLen(len);
}
return fileName;
}
void CDrop::QueryFileNames(UStringVector &fileNames)
{
UINT numFiles = QueryCountOfFiles();
/*
char s[100];
sprintf(s, "QueryFileNames: %d files", numFiles);
OutputDebugStringA(s);
*/
fileNames.ClearAndReserve(numFiles);
for (UINT i = 0; i < numFiles; i++)
{
const UString s2 = QueryFileName(i);
if (!s2.IsEmpty())
fileNames.AddInReserved(s2);
/*
OutputDebugStringW(L"file ---");
OutputDebugStringW(s2);
*/
}
}
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path)
{
const unsigned len = MAX_PATH * 2;
bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
path.ReleaseBuf_CalcLen(len);
return result;
}
#endif
#ifdef UNDER_CE
bool BrowseForFolder(LPBROWSEINFO, CSysString)
{
return false;
}
bool BrowseForFolder(HWND, LPCTSTR, UINT, LPCTSTR, CSysString &)
{
return false;
}
bool BrowseForFolder(HWND /* owner */, LPCTSTR /* title */,
LPCTSTR /* initialFolder */, CSysString & /* resultPath */)
{
/*
// SHBrowseForFolder doesn't work before CE 6.0 ?
if (GetProcAddress(LoadLibrary(L"ceshell.dll", L"SHBrowseForFolder") == 0)
MessageBoxW(0, L"no", L"", 0);
else
MessageBoxW(0, L"yes", L"", 0);
*/
/*
UString s = "all files";
s += " (*.*)";
return MyGetOpenFileName(owner, title, initialFolder, s, resultPath, true);
*/
return false;
}
#else
bool BrowseForFolder(LPBROWSEINFO browseInfo, CSysString &resultPath)
{
NWindows::NCOM::CComInitializer comInitializer;
LPITEMIDLIST itemIDList = ::SHBrowseForFolder(browseInfo);
if (itemIDList == NULL)
return false;
CItemIDList itemIDListHolder;
itemIDListHolder.Attach(itemIDList);
return GetPathFromIDList(itemIDList, resultPath);
}
int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
{
#ifndef UNDER_CE
switch (uMsg)
{
case BFFM_INITIALIZED:
{
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, data);
break;
}
/*
case BFFM_SELCHANGED:
{
TCHAR dir[MAX_PATH];
if (::SHGetPathFromIDList((LPITEMIDLIST) lp , dir))
SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)dir);
else
SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)TEXT(""));
break;
}
*/
default:
break;
}
#endif
return 0;
}
bool BrowseForFolder(HWND owner, LPCTSTR title, UINT ulFlags,
LPCTSTR initialFolder, CSysString &resultPath)
{
CSysString displayName;
BROWSEINFO browseInfo;
browseInfo.hwndOwner = owner;
browseInfo.pidlRoot = NULL;
// there are Unicode/Astring problems in some WinCE SDK ?
/*
#ifdef UNDER_CE
browseInfo.pszDisplayName = (LPSTR)displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = (LPCSTR)title;
#else
*/
browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = title;
// #endif
browseInfo.ulFlags = ulFlags;
browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc : NULL;
browseInfo.lParam = (LPARAM)initialFolder;
return BrowseForFolder(&browseInfo, resultPath);
}
bool BrowseForFolder(HWND owner, LPCTSTR title,
LPCTSTR initialFolder, CSysString &resultPath)
{
return BrowseForFolder(owner, title,
#ifndef UNDER_CE
BIF_NEWDIALOGSTYLE |
#endif
BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT, initialFolder, resultPath);
// BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
}
#ifndef _UNICODE
typedef BOOL (WINAPI * SHGetPathFromIDListWP)(LPCITEMIDLIST pidl, LPWSTR pszPath);
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path)
{
path.Empty();
SHGetPathFromIDListWP shGetPathFromIDListW = (SHGetPathFromIDListWP)
::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHGetPathFromIDListW");
if (shGetPathFromIDListW == 0)
return false;
const unsigned len = MAX_PATH * 2;
bool result = BOOLToBool(shGetPathFromIDListW(itemIDList, path.GetBuf(len)));
path.ReleaseBuf_CalcLen(len);
return result;
}
typedef LPITEMIDLIST (WINAPI * SHBrowseForFolderWP)(LPBROWSEINFOW lpbi);
bool BrowseForFolder(LPBROWSEINFOW browseInfo, UString &resultPath)
{
NWindows::NCOM::CComInitializer comInitializer;
SHBrowseForFolderWP shBrowseForFolderW = (SHBrowseForFolderWP)
::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHBrowseForFolderW");
if (shBrowseForFolderW == 0)
return false;
LPITEMIDLIST itemIDList = shBrowseForFolderW(browseInfo);
if (itemIDList == NULL)
return false;
CItemIDList itemIDListHolder;
itemIDListHolder.Attach(itemIDList);
return GetPathFromIDList(itemIDList, resultPath);
}
int CALLBACK BrowseCallbackProc2(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
{
switch (uMsg)
{
case BFFM_INITIALIZED:
{
SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, data);
break;
}
/*
case BFFM_SELCHANGED:
{
wchar_t dir[MAX_PATH * 2];
if (shGetPathFromIDListW((LPITEMIDLIST)lp , dir))
SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
else
SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)L"");
break;
}
*/
default:
break;
}
return 0;
}
static bool BrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
LPCWSTR initialFolder, UString &resultPath)
{
UString displayName;
BROWSEINFOW browseInfo;
browseInfo.hwndOwner = owner;
browseInfo.pidlRoot = NULL;
browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = title;
browseInfo.ulFlags = ulFlags;
browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc2 : NULL;
browseInfo.lParam = (LPARAM)initialFolder;
return BrowseForFolder(&browseInfo, resultPath);
}
bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath)
{
if (g_IsNT)
return BrowseForFolder(owner, title,
BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
// | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
, initialFolder, resultPath);
// BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
CSysString s;
bool res = BrowseForFolder(owner, GetSystemString(title),
BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
// | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
, GetSystemString(initialFolder), s);
resultPath = GetUnicodeString(s);
return res;
}
#endif
#endif
}}
// Windows/Shell.cpp
#include "StdAfx.h"
/*
#include <stdio.h>
#include <string.h>
*/
#include "../Common/MyCom.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "COM.h"
#include "Shell.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
namespace NShell {
#ifndef UNDER_CE
// SHGetMalloc is unsupported in Windows Mobile?
void CItemIDList::Free()
{
if (m_Object == NULL)
return;
CMyComPtr<IMalloc> shellMalloc;
if (::SHGetMalloc(&shellMalloc) != NOERROR)
throw 41099;
shellMalloc->Free(m_Object);
m_Object = NULL;
}
/*
CItemIDList::(LPCITEMIDLIST itemIDList): m_Object(NULL)
{ *this = itemIDList; }
CItemIDList::(const CItemIDList& itemIDList): m_Object(NULL)
{ *this = itemIDList; }
CItemIDList& CItemIDList::operator=(LPCITEMIDLIST object)
{
Free();
if (object != 0)
{
UINT32 size = GetSize(object);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
if (m_Object != NULL)
MoveMemory(m_Object, object, size);
}
return *this;
}
CItemIDList& CItemIDList::operator=(const CItemIDList &object)
{
Free();
if (object.m_Object != NULL)
{
UINT32 size = GetSize(object.m_Object);
m_Object = (LPITEMIDLIST)CoTaskMemAlloc(size);
if (m_Object != NULL)
MoveMemory(m_Object, object.m_Object, size);
}
return *this;
}
*/
/////////////////////////////
// CDrop
void CDrop::Attach(HDROP object)
{
Free();
m_Object = object;
m_Assigned = true;
}
void CDrop::Free()
{
if (m_MustBeFinished && m_Assigned)
Finish();
m_Assigned = false;
}
UINT CDrop::QueryCountOfFiles()
{
return QueryFile(0xFFFFFFFF, (LPTSTR)NULL, 0);
}
UString CDrop::QueryFileName(UINT fileIndex)
{
UString fileName;
#ifndef _UNICODE
if (!g_IsNT)
{
AString fileNameA;
UINT bufferSize = QueryFile(fileIndex, (LPTSTR)NULL, 0);
const unsigned len = bufferSize + 2;
QueryFile(fileIndex, fileNameA.GetBuf(len), bufferSize + 1);
fileNameA.ReleaseBuf_CalcLen(len);
fileName = GetUnicodeString(fileNameA);
}
else
#endif
{
UINT bufferSize = QueryFile(fileIndex, (LPWSTR)NULL, 0);
const unsigned len = bufferSize + 2;
QueryFile(fileIndex, fileName.GetBuf(len), bufferSize + 1);
fileName.ReleaseBuf_CalcLen(len);
}
return fileName;
}
void CDrop::QueryFileNames(UStringVector &fileNames)
{
UINT numFiles = QueryCountOfFiles();
/*
char s[100];
sprintf(s, "QueryFileNames: %d files", numFiles);
OutputDebugStringA(s);
*/
fileNames.ClearAndReserve(numFiles);
for (UINT i = 0; i < numFiles; i++)
{
const UString s2 = QueryFileName(i);
if (!s2.IsEmpty())
fileNames.AddInReserved(s2);
/*
OutputDebugStringW(L"file ---");
OutputDebugStringW(s2);
*/
}
}
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path)
{
const unsigned len = MAX_PATH * 2;
bool result = BOOLToBool(::SHGetPathFromIDList(itemIDList, path.GetBuf(len)));
path.ReleaseBuf_CalcLen(len);
return result;
}
#endif
#ifdef UNDER_CE
bool BrowseForFolder(LPBROWSEINFO, CSysString)
{
return false;
}
bool BrowseForFolder(HWND, LPCTSTR, UINT, LPCTSTR, CSysString &)
{
return false;
}
bool BrowseForFolder(HWND /* owner */, LPCTSTR /* title */,
LPCTSTR /* initialFolder */, CSysString & /* resultPath */)
{
/*
// SHBrowseForFolder doesn't work before CE 6.0 ?
if (GetProcAddress(LoadLibrary(L"ceshell.dll", L"SHBrowseForFolder") == 0)
MessageBoxW(0, L"no", L"", 0);
else
MessageBoxW(0, L"yes", L"", 0);
*/
/*
UString s = "all files";
s += " (*.*)";
return MyGetOpenFileName(owner, title, initialFolder, s, resultPath, true);
*/
return false;
}
#else
bool BrowseForFolder(LPBROWSEINFO browseInfo, CSysString &resultPath)
{
NWindows::NCOM::CComInitializer comInitializer;
LPITEMIDLIST itemIDList = ::SHBrowseForFolder(browseInfo);
if (itemIDList == NULL)
return false;
CItemIDList itemIDListHolder;
itemIDListHolder.Attach(itemIDList);
return GetPathFromIDList(itemIDList, resultPath);
}
int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
{
#ifndef UNDER_CE
switch (uMsg)
{
case BFFM_INITIALIZED:
{
SendMessage(hwnd, BFFM_SETSELECTION, TRUE, data);
break;
}
/*
case BFFM_SELCHANGED:
{
TCHAR dir[MAX_PATH];
if (::SHGetPathFromIDList((LPITEMIDLIST) lp , dir))
SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)dir);
else
SendMessage(hwnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)TEXT(""));
break;
}
*/
default:
break;
}
#endif
return 0;
}
bool BrowseForFolder(HWND owner, LPCTSTR title, UINT ulFlags,
LPCTSTR initialFolder, CSysString &resultPath)
{
CSysString displayName;
BROWSEINFO browseInfo;
browseInfo.hwndOwner = owner;
browseInfo.pidlRoot = NULL;
// there are Unicode/Astring problems in some WinCE SDK ?
/*
#ifdef UNDER_CE
browseInfo.pszDisplayName = (LPSTR)displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = (LPCSTR)title;
#else
*/
browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = title;
// #endif
browseInfo.ulFlags = ulFlags;
browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc : NULL;
browseInfo.lParam = (LPARAM)initialFolder;
return BrowseForFolder(&browseInfo, resultPath);
}
bool BrowseForFolder(HWND owner, LPCTSTR title,
LPCTSTR initialFolder, CSysString &resultPath)
{
return BrowseForFolder(owner, title,
#ifndef UNDER_CE
BIF_NEWDIALOGSTYLE |
#endif
BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT, initialFolder, resultPath);
// BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
}
#ifndef _UNICODE
typedef BOOL (WINAPI * SHGetPathFromIDListWP)(LPCITEMIDLIST pidl, LPWSTR pszPath);
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path)
{
path.Empty();
SHGetPathFromIDListWP shGetPathFromIDListW = (SHGetPathFromIDListWP)
::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHGetPathFromIDListW");
if (shGetPathFromIDListW == 0)
return false;
const unsigned len = MAX_PATH * 2;
bool result = BOOLToBool(shGetPathFromIDListW(itemIDList, path.GetBuf(len)));
path.ReleaseBuf_CalcLen(len);
return result;
}
typedef LPITEMIDLIST (WINAPI * SHBrowseForFolderWP)(LPBROWSEINFOW lpbi);
bool BrowseForFolder(LPBROWSEINFOW browseInfo, UString &resultPath)
{
NWindows::NCOM::CComInitializer comInitializer;
SHBrowseForFolderWP shBrowseForFolderW = (SHBrowseForFolderWP)
::GetProcAddress(::GetModuleHandleW(L"shell32.dll"), "SHBrowseForFolderW");
if (shBrowseForFolderW == 0)
return false;
LPITEMIDLIST itemIDList = shBrowseForFolderW(browseInfo);
if (itemIDList == NULL)
return false;
CItemIDList itemIDListHolder;
itemIDListHolder.Attach(itemIDList);
return GetPathFromIDList(itemIDList, resultPath);
}
int CALLBACK BrowseCallbackProc2(HWND hwnd, UINT uMsg, LPARAM /* lp */, LPARAM data)
{
switch (uMsg)
{
case BFFM_INITIALIZED:
{
SendMessageW(hwnd, BFFM_SETSELECTIONW, TRUE, data);
break;
}
/*
case BFFM_SELCHANGED:
{
wchar_t dir[MAX_PATH * 2];
if (shGetPathFromIDListW((LPITEMIDLIST)lp , dir))
SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)dir);
else
SendMessageW(hwnd, BFFM_SETSTATUSTEXTW, 0, (LPARAM)L"");
break;
}
*/
default:
break;
}
return 0;
}
static bool BrowseForFolder(HWND owner, LPCWSTR title, UINT ulFlags,
LPCWSTR initialFolder, UString &resultPath)
{
UString displayName;
BROWSEINFOW browseInfo;
browseInfo.hwndOwner = owner;
browseInfo.pidlRoot = NULL;
browseInfo.pszDisplayName = displayName.GetBuf(MAX_PATH);
browseInfo.lpszTitle = title;
browseInfo.ulFlags = ulFlags;
browseInfo.lpfn = (initialFolder != NULL) ? BrowseCallbackProc2 : NULL;
browseInfo.lParam = (LPARAM)initialFolder;
return BrowseForFolder(&browseInfo, resultPath);
}
bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath)
{
if (g_IsNT)
return BrowseForFolder(owner, title,
BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
// | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
, initialFolder, resultPath);
// BIF_STATUSTEXT; BIF_USENEWUI (Version 5.0)
CSysString s;
bool res = BrowseForFolder(owner, GetSystemString(title),
BIF_NEWDIALOGSTYLE | BIF_RETURNONLYFSDIRS
// | BIF_STATUSTEXT // This flag is not supported when BIF_NEWDIALOGSTYLE is specified.
, GetSystemString(initialFolder), s);
resultPath = GetUnicodeString(s);
return res;
}
#endif
#endif
}}

188
CPP/Windows/Shell.h
View File

@@ -1,94 +1,94 @@
// Windows/Shell.h
#ifndef __WINDOWS_SHELL_H
#define __WINDOWS_SHELL_H
#include <windows.h>
#include <shlobj.h>
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows{
namespace NShell{
/////////////////////////
// CItemIDList
#ifndef UNDER_CE
class CItemIDList
{
LPITEMIDLIST m_Object;
public:
CItemIDList(): m_Object(NULL) {}
// CItemIDList(LPCITEMIDLIST itemIDList);
// CItemIDList(const CItemIDList& itemIDList);
~CItemIDList() { Free(); }
void Free();
void Attach(LPITEMIDLIST object)
{
Free();
m_Object = object;
}
LPITEMIDLIST Detach()
{
LPITEMIDLIST object = m_Object;
m_Object = NULL;
return object;
}
operator LPITEMIDLIST() { return m_Object;}
operator LPCITEMIDLIST() const { return m_Object;}
LPITEMIDLIST* operator&() { return &m_Object; }
LPITEMIDLIST operator->() { return m_Object; }
// CItemIDList& operator=(LPCITEMIDLIST object);
// CItemIDList& operator=(const CItemIDList &object);
};
/////////////////////////////
// CDrop
class CDrop
{
HDROP m_Object;
bool m_MustBeFinished;
bool m_Assigned;
void Free();
public:
CDrop(bool mustBeFinished) : m_MustBeFinished(mustBeFinished), m_Assigned(false) {}
~CDrop() { Free(); }
void Attach(HDROP object);
operator HDROP() { return m_Object;}
bool QueryPoint(LPPOINT point)
{ return BOOLToBool(::DragQueryPoint(m_Object, point)); }
void Finish() { ::DragFinish(m_Object); }
UINT QueryFile(UINT fileIndex, LPTSTR fileName, UINT fileNameSize)
{ return ::DragQueryFile(m_Object, fileIndex, fileName, fileNameSize); }
#ifndef _UNICODE
UINT QueryFile(UINT fileIndex, LPWSTR fileName, UINT fileNameSize)
{ return ::DragQueryFileW(m_Object, fileIndex, fileName, fileNameSize); }
#endif
UINT QueryCountOfFiles();
UString QueryFileName(UINT fileIndex);
void QueryFileNames(UStringVector &fileNames);
};
#endif
/////////////////////////////
// Functions
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path);
bool BrowseForFolder(LPBROWSEINFO lpbi, CSysString &resultPath);
bool BrowseForFolder(HWND owner, LPCTSTR title, LPCTSTR initialFolder, CSysString &resultPath);
#ifndef _UNICODE
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path);
bool BrowseForFolder(LPBROWSEINFO lpbi, UString &resultPath);
bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath);
#endif
}}
#endif
// Windows/Shell.h
#ifndef __WINDOWS_SHELL_H
#define __WINDOWS_SHELL_H
#include <windows.h>
#include <shlobj.h>
#include "../Common/MyString.h"
#include "Defs.h"
namespace NWindows{
namespace NShell{
/////////////////////////
// CItemIDList
#ifndef UNDER_CE
class CItemIDList
{
LPITEMIDLIST m_Object;
public:
CItemIDList(): m_Object(NULL) {}
// CItemIDList(LPCITEMIDLIST itemIDList);
// CItemIDList(const CItemIDList& itemIDList);
~CItemIDList() { Free(); }
void Free();
void Attach(LPITEMIDLIST object)
{
Free();
m_Object = object;
}
LPITEMIDLIST Detach()
{
LPITEMIDLIST object = m_Object;
m_Object = NULL;
return object;
}
operator LPITEMIDLIST() { return m_Object;}
operator LPCITEMIDLIST() const { return m_Object;}
LPITEMIDLIST* operator&() { return &m_Object; }
LPITEMIDLIST operator->() { return m_Object; }
// CItemIDList& operator=(LPCITEMIDLIST object);
// CItemIDList& operator=(const CItemIDList &object);
};
/////////////////////////////
// CDrop
class CDrop
{
HDROP m_Object;
bool m_MustBeFinished;
bool m_Assigned;
void Free();
public:
CDrop(bool mustBeFinished) : m_MustBeFinished(mustBeFinished), m_Assigned(false) {}
~CDrop() { Free(); }
void Attach(HDROP object);
operator HDROP() { return m_Object;}
bool QueryPoint(LPPOINT point)
{ return BOOLToBool(::DragQueryPoint(m_Object, point)); }
void Finish() { ::DragFinish(m_Object); }
UINT QueryFile(UINT fileIndex, LPTSTR fileName, UINT fileNameSize)
{ return ::DragQueryFile(m_Object, fileIndex, fileName, fileNameSize); }
#ifndef _UNICODE
UINT QueryFile(UINT fileIndex, LPWSTR fileName, UINT fileNameSize)
{ return ::DragQueryFileW(m_Object, fileIndex, fileName, fileNameSize); }
#endif
UINT QueryCountOfFiles();
UString QueryFileName(UINT fileIndex);
void QueryFileNames(UStringVector &fileNames);
};
#endif
/////////////////////////////
// Functions
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, CSysString &path);
bool BrowseForFolder(LPBROWSEINFO lpbi, CSysString &resultPath);
bool BrowseForFolder(HWND owner, LPCTSTR title, LPCTSTR initialFolder, CSysString &resultPath);
#ifndef _UNICODE
bool GetPathFromIDList(LPCITEMIDLIST itemIDList, UString &path);
bool BrowseForFolder(LPBROWSEINFO lpbi, UString &resultPath);
bool BrowseForFolder(HWND owner, LPCWSTR title, LPCWSTR initialFolder, UString &resultPath);
#endif
}}
#endif

16
CPP/Windows/StdAfx.h
View File

@@ -1,8 +1,8 @@
// StdAfx.h
#ifndef __STDAFX_H
#define __STDAFX_H
#include "../Common/Common.h"
#endif
// StdAfx.h
#ifndef __STDAFX_H
#define __STDAFX_H
#include "../Common/Common.h"
#endif

20
CPP/Windows/Synchronization.cpp
View File

@@ -1,10 +1,10 @@
// Windows/Synchronization.cpp
#include "StdAfx.h"
#include "Synchronization.h"
namespace NWindows {
namespace NSynchronization {
}}
// Windows/Synchronization.cpp
#include "StdAfx.h"
#include "Synchronization.h"
namespace NWindows {
namespace NSynchronization {
}}

328
CPP/Windows/Synchronization.h
View File

@@ -1,164 +1,164 @@
// Windows/Synchronization.h
#ifndef __WINDOWS_SYNCHRONIZATION_H
#define __WINDOWS_SYNCHRONIZATION_H
#include "../../C/Threads.h"
#include "Defs.h"
#ifdef _WIN32
#include "Handle.h"
#endif
namespace NWindows {
namespace NSynchronization {
class CBaseEvent
{
protected:
::CEvent _object;
public:
bool IsCreated() { return Event_IsCreated(&_object) != 0; }
operator HANDLE() { return _object; }
CBaseEvent() { Event_Construct(&_object); }
~CBaseEvent() { Close(); }
WRes Close() { return Event_Close(&_object); }
#ifdef _WIN32
WRes Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
{
_object = ::CreateEvent(sa, BoolToBOOL(manualReset), BoolToBOOL(initiallyOwn), name);
if (name == NULL && _object != 0)
return 0;
return ::GetLastError();
}
WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
{
_object = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
if (_object != 0)
return 0;
return ::GetLastError();
}
#endif
WRes Set() { return Event_Set(&_object); }
// bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
WRes Reset() { return Event_Reset(&_object); }
WRes Lock() { return Event_Wait(&_object); }
};
class CManualResetEvent: public CBaseEvent
{
public:
WRes Create(bool initiallyOwn = false)
{
return ManualResetEvent_Create(&_object, initiallyOwn ? 1: 0);
}
WRes CreateIfNotCreated()
{
if (IsCreated())
return 0;
return ManualResetEvent_CreateNotSignaled(&_object);
}
#ifdef _WIN32
WRes CreateWithName(bool initiallyOwn, LPCTSTR name)
{
return CBaseEvent::Create(true, initiallyOwn, name);
}
#endif
};
class CAutoResetEvent: public CBaseEvent
{
public:
WRes Create()
{
return AutoResetEvent_CreateNotSignaled(&_object);
}
WRes CreateIfNotCreated()
{
if (IsCreated())
return 0;
return AutoResetEvent_CreateNotSignaled(&_object);
}
};
#ifdef _WIN32
class CObject: public CHandle
{
public:
WRes Lock(DWORD timeoutInterval = INFINITE)
{ return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0 ? 0 : ::GetLastError()); }
};
class CMutex: public CObject
{
public:
WRes Create(bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
{
_handle = ::CreateMutex(sa, BoolToBOOL(initiallyOwn), name);
if (name == NULL && _handle != 0)
return 0;
return ::GetLastError();
}
#ifndef UNDER_CE
WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
{
_handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);
if (_handle != 0)
return 0;
return ::GetLastError();
}
#endif
WRes Release()
{
return ::ReleaseMutex(_handle) ? 0 : ::GetLastError();
}
};
class CMutexLock
{
CMutex *_object;
public:
CMutexLock(CMutex &object): _object(&object) { _object->Lock(); }
~CMutexLock() { _object->Release(); }
};
#endif
class CSemaphore
{
::CSemaphore _object;
public:
CSemaphore() { Semaphore_Construct(&_object); }
~CSemaphore() { Close(); }
WRes Close() { return Semaphore_Close(&_object); }
operator HANDLE() { return _object; }
WRes Create(UInt32 initiallyCount, UInt32 maxCount)
{
return Semaphore_Create(&_object, initiallyCount, maxCount);
}
WRes Release() { return Semaphore_Release1(&_object); }
WRes Release(UInt32 releaseCount) { return Semaphore_ReleaseN(&_object, releaseCount); }
WRes Lock() { return Semaphore_Wait(&_object); }
};
class CCriticalSection
{
::CCriticalSection _object;
public:
CCriticalSection() { CriticalSection_Init(&_object); }
~CCriticalSection() { CriticalSection_Delete(&_object); }
void Enter() { CriticalSection_Enter(&_object); }
void Leave() { CriticalSection_Leave(&_object); }
};
class CCriticalSectionLock
{
CCriticalSection *_object;
void Unlock() { _object->Leave(); }
public:
CCriticalSectionLock(CCriticalSection &object): _object(&object) {_object->Enter(); }
~CCriticalSectionLock() { Unlock(); }
};
}}
#endif
// Windows/Synchronization.h
#ifndef __WINDOWS_SYNCHRONIZATION_H
#define __WINDOWS_SYNCHRONIZATION_H
#include "../../C/Threads.h"
#include "Defs.h"
#ifdef _WIN32
#include "Handle.h"
#endif
namespace NWindows {
namespace NSynchronization {
class CBaseEvent
{
protected:
::CEvent _object;
public:
bool IsCreated() { return Event_IsCreated(&_object) != 0; }
operator HANDLE() { return _object; }
CBaseEvent() { Event_Construct(&_object); }
~CBaseEvent() { Close(); }
WRes Close() { return Event_Close(&_object); }
#ifdef _WIN32
WRes Create(bool manualReset, bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
{
_object = ::CreateEvent(sa, BoolToBOOL(manualReset), BoolToBOOL(initiallyOwn), name);
if (name == NULL && _object != 0)
return 0;
return ::GetLastError();
}
WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
{
_object = ::OpenEvent(desiredAccess, BoolToBOOL(inheritHandle), name);
if (_object != 0)
return 0;
return ::GetLastError();
}
#endif
WRes Set() { return Event_Set(&_object); }
// bool Pulse() { return BOOLToBool(::PulseEvent(_handle)); }
WRes Reset() { return Event_Reset(&_object); }
WRes Lock() { return Event_Wait(&_object); }
};
class CManualResetEvent: public CBaseEvent
{
public:
WRes Create(bool initiallyOwn = false)
{
return ManualResetEvent_Create(&_object, initiallyOwn ? 1: 0);
}
WRes CreateIfNotCreated()
{
if (IsCreated())
return 0;
return ManualResetEvent_CreateNotSignaled(&_object);
}
#ifdef _WIN32
WRes CreateWithName(bool initiallyOwn, LPCTSTR name)
{
return CBaseEvent::Create(true, initiallyOwn, name);
}
#endif
};
class CAutoResetEvent: public CBaseEvent
{
public:
WRes Create()
{
return AutoResetEvent_CreateNotSignaled(&_object);
}
WRes CreateIfNotCreated()
{
if (IsCreated())
return 0;
return AutoResetEvent_CreateNotSignaled(&_object);
}
};
#ifdef _WIN32
class CObject: public CHandle
{
public:
WRes Lock(DWORD timeoutInterval = INFINITE)
{ return (::WaitForSingleObject(_handle, timeoutInterval) == WAIT_OBJECT_0 ? 0 : ::GetLastError()); }
};
class CMutex: public CObject
{
public:
WRes Create(bool initiallyOwn, LPCTSTR name = NULL, LPSECURITY_ATTRIBUTES sa = NULL)
{
_handle = ::CreateMutex(sa, BoolToBOOL(initiallyOwn), name);
if (name == NULL && _handle != 0)
return 0;
return ::GetLastError();
}
#ifndef UNDER_CE
WRes Open(DWORD desiredAccess, bool inheritHandle, LPCTSTR name)
{
_handle = ::OpenMutex(desiredAccess, BoolToBOOL(inheritHandle), name);
if (_handle != 0)
return 0;
return ::GetLastError();
}
#endif
WRes Release()
{
return ::ReleaseMutex(_handle) ? 0 : ::GetLastError();
}
};
class CMutexLock
{
CMutex *_object;
public:
CMutexLock(CMutex &object): _object(&object) { _object->Lock(); }
~CMutexLock() { _object->Release(); }
};
#endif
class CSemaphore
{
::CSemaphore _object;
public:
CSemaphore() { Semaphore_Construct(&_object); }
~CSemaphore() { Close(); }
WRes Close() { return Semaphore_Close(&_object); }
operator HANDLE() { return _object; }
WRes Create(UInt32 initiallyCount, UInt32 maxCount)
{
return Semaphore_Create(&_object, initiallyCount, maxCount);
}
WRes Release() { return Semaphore_Release1(&_object); }
WRes Release(UInt32 releaseCount) { return Semaphore_ReleaseN(&_object, releaseCount); }
WRes Lock() { return Semaphore_Wait(&_object); }
};
class CCriticalSection
{
::CCriticalSection _object;
public:
CCriticalSection() { CriticalSection_Init(&_object); }
~CCriticalSection() { CriticalSection_Delete(&_object); }
void Enter() { CriticalSection_Enter(&_object); }
void Leave() { CriticalSection_Leave(&_object); }
};
class CCriticalSectionLock
{
CCriticalSection *_object;
void Unlock() { _object->Leave(); }
public:
CCriticalSectionLock(CCriticalSection &object): _object(&object) {_object->Enter(); }
~CCriticalSectionLock() { Unlock(); }
};
}}
#endif

284
CPP/Windows/System.cpp
View File

@@ -1,142 +1,142 @@
// Windows/System.cpp
#include "StdAfx.h"
#include "../Common/MyWindows.h"
#include "../Common/Defs.h"
#include "System.h"
namespace NWindows {
namespace NSystem {
UInt32 CountAffinity(DWORD_PTR mask)
{
UInt32 num = 0;
for (unsigned i = 0; i < sizeof(mask) * 8; i++)
num += (UInt32)((mask >> i) & 1);
return num;
}
#ifdef _WIN32
BOOL CProcessAffinity::Get()
{
#ifndef UNDER_CE
return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
#else
return FALSE;
#endif
}
UInt32 GetNumberOfProcessors()
{
// We need to know how many threads we can use.
// By default the process is assigned to one group.
// So we get the number of logical processors (threads)
// assigned to current process in the current group.
// Group size can be smaller than total number logical processors, for exammple, 2x36
CProcessAffinity pa;
if (pa.Get() && pa.processAffinityMask != 0)
return pa.GetNumProcessThreads();
SYSTEM_INFO systemInfo;
GetSystemInfo(&systemInfo);
// the number of logical processors in the current group
return (UInt32)systemInfo.dwNumberOfProcessors;
}
#else
UInt32 GetNumberOfProcessors()
{
return 1;
}
#endif
#ifdef _WIN32
#ifndef UNDER_CE
#if !defined(_WIN64) && defined(__GNUC__)
typedef struct _MY_MEMORYSTATUSEX {
DWORD dwLength;
DWORD dwMemoryLoad;
DWORDLONG ullTotalPhys;
DWORDLONG ullAvailPhys;
DWORDLONG ullTotalPageFile;
DWORDLONG ullAvailPageFile;
DWORDLONG ullTotalVirtual;
DWORDLONG ullAvailVirtual;
DWORDLONG ullAvailExtendedVirtual;
} MY_MEMORYSTATUSEX, *MY_LPMEMORYSTATUSEX;
#else
#define MY_MEMORYSTATUSEX MEMORYSTATUSEX
#define MY_LPMEMORYSTATUSEX LPMEMORYSTATUSEX
#endif
typedef BOOL (WINAPI *GlobalMemoryStatusExP)(MY_LPMEMORYSTATUSEX lpBuffer);
#endif
#endif
bool GetRamSize(UInt64 &size)
{
size = (UInt64)(sizeof(size_t)) << 29;
#ifdef _WIN32
#ifndef UNDER_CE
MY_MEMORYSTATUSEX stat;
stat.dwLength = sizeof(stat);
#endif
#ifdef _WIN64
if (!::GlobalMemoryStatusEx(&stat))
return false;
size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
return true;
#else
#ifndef UNDER_CE
GlobalMemoryStatusExP globalMemoryStatusEx = (GlobalMemoryStatusExP)
::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GlobalMemoryStatusEx");
if (globalMemoryStatusEx && globalMemoryStatusEx(&stat))
{
size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
return true;
}
#endif
{
MEMORYSTATUS stat2;
stat2.dwLength = sizeof(stat2);
::GlobalMemoryStatus(&stat2);
size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
return true;
}
#endif
#else
return false;
#endif
}
}}
// Windows/System.cpp
#include "StdAfx.h"
#include "../Common/MyWindows.h"
#include "../Common/Defs.h"
#include "System.h"
namespace NWindows {
namespace NSystem {
UInt32 CountAffinity(DWORD_PTR mask)
{
UInt32 num = 0;
for (unsigned i = 0; i < sizeof(mask) * 8; i++)
num += (UInt32)((mask >> i) & 1);
return num;
}
#ifdef _WIN32
BOOL CProcessAffinity::Get()
{
#ifndef UNDER_CE
return GetProcessAffinityMask(GetCurrentProcess(), &processAffinityMask, &systemAffinityMask);
#else
return FALSE;
#endif
}
UInt32 GetNumberOfProcessors()
{
// We need to know how many threads we can use.
// By default the process is assigned to one group.
// So we get the number of logical processors (threads)
// assigned to current process in the current group.
// Group size can be smaller than total number logical processors, for exammple, 2x36
CProcessAffinity pa;
if (pa.Get() && pa.processAffinityMask != 0)
return pa.GetNumProcessThreads();
SYSTEM_INFO systemInfo;
GetSystemInfo(&systemInfo);
// the number of logical processors in the current group
return (UInt32)systemInfo.dwNumberOfProcessors;
}
#else
UInt32 GetNumberOfProcessors()
{
return 1;
}
#endif
#ifdef _WIN32
#ifndef UNDER_CE
#if !defined(_WIN64) && defined(__GNUC__)
typedef struct _MY_MEMORYSTATUSEX {
DWORD dwLength;
DWORD dwMemoryLoad;
DWORDLONG ullTotalPhys;
DWORDLONG ullAvailPhys;
DWORDLONG ullTotalPageFile;
DWORDLONG ullAvailPageFile;
DWORDLONG ullTotalVirtual;
DWORDLONG ullAvailVirtual;
DWORDLONG ullAvailExtendedVirtual;
} MY_MEMORYSTATUSEX, *MY_LPMEMORYSTATUSEX;
#else
#define MY_MEMORYSTATUSEX MEMORYSTATUSEX
#define MY_LPMEMORYSTATUSEX LPMEMORYSTATUSEX
#endif
typedef BOOL (WINAPI *GlobalMemoryStatusExP)(MY_LPMEMORYSTATUSEX lpBuffer);
#endif
#endif
bool GetRamSize(UInt64 &size)
{
size = (UInt64)(sizeof(size_t)) << 29;
#ifdef _WIN32
#ifndef UNDER_CE
MY_MEMORYSTATUSEX stat;
stat.dwLength = sizeof(stat);
#endif
#ifdef _WIN64
if (!::GlobalMemoryStatusEx(&stat))
return false;
size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
return true;
#else
#ifndef UNDER_CE
GlobalMemoryStatusExP globalMemoryStatusEx = (GlobalMemoryStatusExP)
::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GlobalMemoryStatusEx");
if (globalMemoryStatusEx && globalMemoryStatusEx(&stat))
{
size = MyMin(stat.ullTotalVirtual, stat.ullTotalPhys);
return true;
}
#endif
{
MEMORYSTATUS stat2;
stat2.dwLength = sizeof(stat2);
::GlobalMemoryStatus(&stat2);
size = MyMin(stat2.dwTotalVirtual, stat2.dwTotalPhys);
return true;
}
#endif
#else
return false;
#endif
}
}}

80
CPP/Windows/System.h
View File

@@ -1,40 +1,40 @@
// Windows/System.h
#ifndef __WINDOWS_SYSTEM_H
#define __WINDOWS_SYSTEM_H
#include "../Common/MyTypes.h"
namespace NWindows {
namespace NSystem {
UInt32 CountAffinity(DWORD_PTR mask);
struct CProcessAffinity
{
// UInt32 numProcessThreads;
// UInt32 numSysThreads;
DWORD_PTR processAffinityMask;
DWORD_PTR systemAffinityMask;
void InitST()
{
// numProcessThreads = 1;
// numSysThreads = 1;
processAffinityMask = 1;
systemAffinityMask = 1;
}
UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
BOOL Get();
};
UInt32 GetNumberOfProcessors();
bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
}}
#endif
// Windows/System.h
#ifndef __WINDOWS_SYSTEM_H
#define __WINDOWS_SYSTEM_H
#include "../Common/MyTypes.h"
namespace NWindows {
namespace NSystem {
UInt32 CountAffinity(DWORD_PTR mask);
struct CProcessAffinity
{
// UInt32 numProcessThreads;
// UInt32 numSysThreads;
DWORD_PTR processAffinityMask;
DWORD_PTR systemAffinityMask;
void InitST()
{
// numProcessThreads = 1;
// numSysThreads = 1;
processAffinityMask = 1;
systemAffinityMask = 1;
}
UInt32 GetNumProcessThreads() const { return CountAffinity(processAffinityMask); }
UInt32 GetNumSystemThreads() const { return CountAffinity(systemAffinityMask); }
BOOL Get();
};
UInt32 GetNumberOfProcessors();
bool GetRamSize(UInt64 &size); // returns false, if unknown ram size
}}
#endif

76
CPP/Windows/Thread.h
View File

@@ -1,38 +1,38 @@
// Windows/Thread.h
#ifndef __WINDOWS_THREAD_H
#define __WINDOWS_THREAD_H
#include "../../C/Threads.h"
#include "Defs.h"
namespace NWindows {
class CThread
{
::CThread thread;
public:
CThread() { Thread_Construct(&thread); }
~CThread() { Close(); }
bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
WRes Close() { return Thread_Close(&thread); }
WRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
{ return Thread_Create(&thread, startAddress, parameter); }
WRes Wait() { return Thread_Wait(&thread); }
#ifdef _WIN32
operator HANDLE() { return thread; }
void Attach(HANDLE handle) { thread = handle; }
HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
DWORD Resume() { return ::ResumeThread(thread); }
DWORD Suspend() { return ::SuspendThread(thread); }
bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
int GetPriority() { return ::GetThreadPriority(thread); }
bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
#endif
};
}
#endif
// Windows/Thread.h
#ifndef __WINDOWS_THREAD_H
#define __WINDOWS_THREAD_H
#include "../../C/Threads.h"
#include "Defs.h"
namespace NWindows {
class CThread
{
::CThread thread;
public:
CThread() { Thread_Construct(&thread); }
~CThread() { Close(); }
bool IsCreated() { return Thread_WasCreated(&thread) != 0; }
WRes Close() { return Thread_Close(&thread); }
WRes Create(THREAD_FUNC_RET_TYPE (THREAD_FUNC_CALL_TYPE *startAddress)(void *), LPVOID parameter)
{ return Thread_Create(&thread, startAddress, parameter); }
WRes Wait() { return Thread_Wait(&thread); }
#ifdef _WIN32
operator HANDLE() { return thread; }
void Attach(HANDLE handle) { thread = handle; }
HANDLE Detach() { HANDLE h = thread; thread = NULL; return h; }
DWORD Resume() { return ::ResumeThread(thread); }
DWORD Suspend() { return ::SuspendThread(thread); }
bool Terminate(DWORD exitCode) { return BOOLToBool(::TerminateThread(thread, exitCode)); }
int GetPriority() { return ::GetThreadPriority(thread); }
bool SetPriority(int priority) { return BOOLToBool(::SetThreadPriority(thread, priority)); }
#endif
};
}
#endif

426
CPP/Windows/TimeUtils.cpp
View File

@@ -1,213 +1,213 @@
// Windows/TimeUtils.cpp
#include "StdAfx.h"
#include "Defs.h"
#include "TimeUtils.h"
namespace NWindows {
namespace NTime {
static const UInt32 kNumTimeQuantumsInSecond = 10000000;
static const UInt32 kFileTimeStartYear = 1601;
static const UInt32 kDosTimeStartYear = 1980;
static const UInt32 kUnixTimeStartYear = 1970;
static const UInt64 kUnixTimeOffset =
(UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
static const UInt64 kNumSecondsInFileTime = (UInt64)(Int64)-1 / kNumTimeQuantumsInSecond;
bool DosTimeToFileTime(UInt32 dosTime, FILETIME &ft) throw()
{
#if defined(_WIN32) && !defined(UNDER_CE)
return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &ft));
#else
ft.dwLowDateTime = 0;
ft.dwHighDateTime = 0;
UInt64 res;
if (!GetSecondsSince1601(kDosTimeStartYear + (dosTime >> 25), (dosTime >> 21) & 0xF, (dosTime >> 16) & 0x1F,
(dosTime >> 11) & 0x1F, (dosTime >> 5) & 0x3F, (dosTime & 0x1F) * 2, res))
return false;
res *= kNumTimeQuantumsInSecond;
ft.dwLowDateTime = (UInt32)res;
ft.dwHighDateTime = (UInt32)(res >> 32);
return true;
#endif
}
static const UInt32 kHighDosTime = 0xFF9FBF7D;
static const UInt32 kLowDosTime = 0x210000;
#define PERIOD_4 (4 * 365 + 1)
#define PERIOD_100 (PERIOD_4 * 25 - 1)
#define PERIOD_400 (PERIOD_100 * 4 + 1)
bool FileTimeToDosTime(const FILETIME &ft, UInt32 &dosTime) throw()
{
#if defined(_WIN32) && !defined(UNDER_CE)
WORD datePart, timePart;
if (!::FileTimeToDosDateTime(&ft, &datePart, &timePart))
{
dosTime = (ft.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
return false;
}
dosTime = (((UInt32)datePart) << 16) + timePart;
#else
unsigned year, mon, day, hour, min, sec;
UInt64 v64 = ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
unsigned temp;
UInt32 v;
v64 += (kNumTimeQuantumsInSecond * 2 - 1);
v64 /= kNumTimeQuantumsInSecond;
sec = (unsigned)(v64 % 60);
v64 /= 60;
min = (unsigned)(v64 % 60);
v64 /= 60;
hour = (unsigned)(v64 % 24);
v64 /= 24;
v = (UInt32)v64;
year = (unsigned)(kFileTimeStartYear + v / PERIOD_400 * 400);
v %= PERIOD_400;
temp = (unsigned)(v / PERIOD_100);
if (temp == 4)
temp = 3;
year += temp * 100;
v -= temp * PERIOD_100;
temp = v / PERIOD_4;
if (temp == 25)
temp = 24;
year += temp * 4;
v -= temp * PERIOD_4;
temp = v / 365;
if (temp == 4)
temp = 3;
year += temp;
v -= temp * 365;
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
ms[1] = 29;
for (mon = 1; mon <= 12; mon++)
{
unsigned s = ms[mon - 1];
if (v < s)
break;
v -= s;
}
day = (unsigned)v + 1;
dosTime = kLowDosTime;
if (year < kDosTimeStartYear)
return false;
year -= kDosTimeStartYear;
dosTime = kHighDosTime;
if (year >= 128)
return false;
dosTime = (year << 25) | (mon << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec >> 1);
#endif
return true;
}
UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw()
{
return (kUnixTimeOffset + (UInt64)unixTime) * kNumTimeQuantumsInSecond;
}
void UnixTimeToFileTime(UInt32 unixTime, FILETIME &ft) throw()
{
UInt64 v = UnixTimeToFileTime64(unixTime);
ft.dwLowDateTime = (DWORD)v;
ft.dwHighDateTime = (DWORD)(v >> 32);
}
UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw()
{
return (UInt64)(kUnixTimeOffset + unixTime) * kNumTimeQuantumsInSecond;
}
bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &ft) throw()
{
if (unixTime > (Int64)(kNumSecondsInFileTime - kUnixTimeOffset))
{
ft.dwLowDateTime = ft.dwHighDateTime = (UInt32)(Int32)-1;
return false;
}
Int64 v = (Int64)kUnixTimeOffset + unixTime;
if (v < 0)
{
ft.dwLowDateTime = ft.dwHighDateTime = 0;
return false;
}
UInt64 v2 = (UInt64)v * kNumTimeQuantumsInSecond;
ft.dwLowDateTime = (DWORD)v2;
ft.dwHighDateTime = (DWORD)(v2 >> 32);
return true;
}
Int64 FileTimeToUnixTime64(const FILETIME &ft) throw()
{
UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
}
bool FileTimeToUnixTime(const FILETIME &ft, UInt32 &unixTime) throw()
{
UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
winTime /= kNumTimeQuantumsInSecond;
if (winTime < kUnixTimeOffset)
{
unixTime = 0;
return false;
}
winTime -= kUnixTimeOffset;
if (winTime > 0xFFFFFFFF)
{
unixTime = 0xFFFFFFFF;
return false;
}
unixTime = (UInt32)winTime;
return true;
}
bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw()
{
resSeconds = 0;
if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
return false;
UInt32 numYears = year - kFileTimeStartYear;
UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
ms[1] = 29;
month--;
for (unsigned i = 0; i < month; i++)
numDays += ms[i];
numDays += day - 1;
resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
return true;
}
void GetCurUtcFileTime(FILETIME &ft) throw()
{
// Both variants provide same low resolution on WinXP: about 15 ms.
// But GetSystemTimeAsFileTime is much faster.
#ifdef UNDER_CE
SYSTEMTIME st;
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
#else
GetSystemTimeAsFileTime(&ft);
#endif
}
}}
// Windows/TimeUtils.cpp
#include "StdAfx.h"
#include "Defs.h"
#include "TimeUtils.h"
namespace NWindows {
namespace NTime {
static const UInt32 kNumTimeQuantumsInSecond = 10000000;
static const UInt32 kFileTimeStartYear = 1601;
static const UInt32 kDosTimeStartYear = 1980;
static const UInt32 kUnixTimeStartYear = 1970;
static const UInt64 kUnixTimeOffset =
(UInt64)60 * 60 * 24 * (89 + 365 * (kUnixTimeStartYear - kFileTimeStartYear));
static const UInt64 kNumSecondsInFileTime = (UInt64)(Int64)-1 / kNumTimeQuantumsInSecond;
bool DosTimeToFileTime(UInt32 dosTime, FILETIME &ft) throw()
{
#if defined(_WIN32) && !defined(UNDER_CE)
return BOOLToBool(::DosDateTimeToFileTime((UInt16)(dosTime >> 16), (UInt16)(dosTime & 0xFFFF), &ft));
#else
ft.dwLowDateTime = 0;
ft.dwHighDateTime = 0;
UInt64 res;
if (!GetSecondsSince1601(kDosTimeStartYear + (dosTime >> 25), (dosTime >> 21) & 0xF, (dosTime >> 16) & 0x1F,
(dosTime >> 11) & 0x1F, (dosTime >> 5) & 0x3F, (dosTime & 0x1F) * 2, res))
return false;
res *= kNumTimeQuantumsInSecond;
ft.dwLowDateTime = (UInt32)res;
ft.dwHighDateTime = (UInt32)(res >> 32);
return true;
#endif
}
static const UInt32 kHighDosTime = 0xFF9FBF7D;
static const UInt32 kLowDosTime = 0x210000;
#define PERIOD_4 (4 * 365 + 1)
#define PERIOD_100 (PERIOD_4 * 25 - 1)
#define PERIOD_400 (PERIOD_100 * 4 + 1)
bool FileTimeToDosTime(const FILETIME &ft, UInt32 &dosTime) throw()
{
#if defined(_WIN32) && !defined(UNDER_CE)
WORD datePart, timePart;
if (!::FileTimeToDosDateTime(&ft, &datePart, &timePart))
{
dosTime = (ft.dwHighDateTime >= 0x01C00000) ? kHighDosTime : kLowDosTime;
return false;
}
dosTime = (((UInt32)datePart) << 16) + timePart;
#else
unsigned year, mon, day, hour, min, sec;
UInt64 v64 = ft.dwLowDateTime | ((UInt64)ft.dwHighDateTime << 32);
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
unsigned temp;
UInt32 v;
v64 += (kNumTimeQuantumsInSecond * 2 - 1);
v64 /= kNumTimeQuantumsInSecond;
sec = (unsigned)(v64 % 60);
v64 /= 60;
min = (unsigned)(v64 % 60);
v64 /= 60;
hour = (unsigned)(v64 % 24);
v64 /= 24;
v = (UInt32)v64;
year = (unsigned)(kFileTimeStartYear + v / PERIOD_400 * 400);
v %= PERIOD_400;
temp = (unsigned)(v / PERIOD_100);
if (temp == 4)
temp = 3;
year += temp * 100;
v -= temp * PERIOD_100;
temp = v / PERIOD_4;
if (temp == 25)
temp = 24;
year += temp * 4;
v -= temp * PERIOD_4;
temp = v / 365;
if (temp == 4)
temp = 3;
year += temp;
v -= temp * 365;
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
ms[1] = 29;
for (mon = 1; mon <= 12; mon++)
{
unsigned s = ms[mon - 1];
if (v < s)
break;
v -= s;
}
day = (unsigned)v + 1;
dosTime = kLowDosTime;
if (year < kDosTimeStartYear)
return false;
year -= kDosTimeStartYear;
dosTime = kHighDosTime;
if (year >= 128)
return false;
dosTime = (year << 25) | (mon << 21) | (day << 16) | (hour << 11) | (min << 5) | (sec >> 1);
#endif
return true;
}
UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw()
{
return (kUnixTimeOffset + (UInt64)unixTime) * kNumTimeQuantumsInSecond;
}
void UnixTimeToFileTime(UInt32 unixTime, FILETIME &ft) throw()
{
UInt64 v = UnixTimeToFileTime64(unixTime);
ft.dwLowDateTime = (DWORD)v;
ft.dwHighDateTime = (DWORD)(v >> 32);
}
UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw()
{
return (UInt64)(kUnixTimeOffset + unixTime) * kNumTimeQuantumsInSecond;
}
bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &ft) throw()
{
if (unixTime > (Int64)(kNumSecondsInFileTime - kUnixTimeOffset))
{
ft.dwLowDateTime = ft.dwHighDateTime = (UInt32)(Int32)-1;
return false;
}
Int64 v = (Int64)kUnixTimeOffset + unixTime;
if (v < 0)
{
ft.dwLowDateTime = ft.dwHighDateTime = 0;
return false;
}
UInt64 v2 = (UInt64)v * kNumTimeQuantumsInSecond;
ft.dwLowDateTime = (DWORD)v2;
ft.dwHighDateTime = (DWORD)(v2 >> 32);
return true;
}
Int64 FileTimeToUnixTime64(const FILETIME &ft) throw()
{
UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
return (Int64)(winTime / kNumTimeQuantumsInSecond) - (Int64)kUnixTimeOffset;
}
bool FileTimeToUnixTime(const FILETIME &ft, UInt32 &unixTime) throw()
{
UInt64 winTime = (((UInt64)ft.dwHighDateTime) << 32) + ft.dwLowDateTime;
winTime /= kNumTimeQuantumsInSecond;
if (winTime < kUnixTimeOffset)
{
unixTime = 0;
return false;
}
winTime -= kUnixTimeOffset;
if (winTime > 0xFFFFFFFF)
{
unixTime = 0xFFFFFFFF;
return false;
}
unixTime = (UInt32)winTime;
return true;
}
bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw()
{
resSeconds = 0;
if (year < kFileTimeStartYear || year >= 10000 || month < 1 || month > 12 ||
day < 1 || day > 31 || hour > 23 || min > 59 || sec > 59)
return false;
UInt32 numYears = year - kFileTimeStartYear;
UInt32 numDays = numYears * 365 + numYears / 4 - numYears / 100 + numYears / 400;
Byte ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
ms[1] = 29;
month--;
for (unsigned i = 0; i < month; i++)
numDays += ms[i];
numDays += day - 1;
resSeconds = ((UInt64)(numDays * 24 + hour) * 60 + min) * 60 + sec;
return true;
}
void GetCurUtcFileTime(FILETIME &ft) throw()
{
// Both variants provide same low resolution on WinXP: about 15 ms.
// But GetSystemTimeAsFileTime is much faster.
#ifdef UNDER_CE
SYSTEMTIME st;
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
#else
GetSystemTimeAsFileTime(&ft);
#endif
}
}}

64
CPP/Windows/TimeUtils.h
View File

@@ -1,32 +1,32 @@
// Windows/TimeUtils.h
#ifndef __WINDOWS_TIME_UTILS_H
#define __WINDOWS_TIME_UTILS_H
#include "../Common/MyTypes.h"
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NTime {
bool DosTimeToFileTime(UInt32 dosTime, FILETIME &fileTime) throw();
bool FileTimeToDosTime(const FILETIME &fileTime, UInt32 &dosTime) throw();
// UInt32 Unix Time : for dates 1970-2106
UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw();
void UnixTimeToFileTime(UInt32 unixTime, FILETIME &fileTime) throw();
// Int64 Unix Time : negative values for dates before 1970
UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw();
bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &fileTime) throw();
bool FileTimeToUnixTime(const FILETIME &fileTime, UInt32 &unixTime) throw();
Int64 FileTimeToUnixTime64(const FILETIME &ft) throw();
bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw();
void GetCurUtcFileTime(FILETIME &ft) throw();
}}
#endif
// Windows/TimeUtils.h
#ifndef __WINDOWS_TIME_UTILS_H
#define __WINDOWS_TIME_UTILS_H
#include "../Common/MyTypes.h"
#include "../Common/MyWindows.h"
namespace NWindows {
namespace NTime {
bool DosTimeToFileTime(UInt32 dosTime, FILETIME &fileTime) throw();
bool FileTimeToDosTime(const FILETIME &fileTime, UInt32 &dosTime) throw();
// UInt32 Unix Time : for dates 1970-2106
UInt64 UnixTimeToFileTime64(UInt32 unixTime) throw();
void UnixTimeToFileTime(UInt32 unixTime, FILETIME &fileTime) throw();
// Int64 Unix Time : negative values for dates before 1970
UInt64 UnixTime64ToFileTime64(Int64 unixTime) throw();
bool UnixTime64ToFileTime(Int64 unixTime, FILETIME &fileTime) throw();
bool FileTimeToUnixTime(const FILETIME &fileTime, UInt32 &unixTime) throw();
Int64 FileTimeToUnixTime64(const FILETIME &ft) throw();
bool GetSecondsSince1601(unsigned year, unsigned month, unsigned day,
unsigned hour, unsigned min, unsigned sec, UInt64 &resSeconds) throw();
void GetCurUtcFileTime(FILETIME &ft) throw();
}}
#endif

358
CPP/Windows/Window.cpp
View File

@@ -1,179 +1,179 @@
// Windows/Window.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Window.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass)
{
if (g_IsNT)
return RegisterClassW(wndClass);
WNDCLASSA wndClassA;
wndClassA.style = wndClass->style;
wndClassA.lpfnWndProc = wndClass->lpfnWndProc;
wndClassA.cbClsExtra = wndClass->cbClsExtra;
wndClassA.cbWndExtra = wndClass->cbWndExtra;
wndClassA.hInstance = wndClass->hInstance;
wndClassA.hIcon = wndClass->hIcon;
wndClassA.hCursor = wndClass->hCursor;
wndClassA.hbrBackground = wndClass->hbrBackground;
AString menuName;
AString className;
if (IS_INTRESOURCE(wndClass->lpszMenuName))
wndClassA.lpszMenuName = (LPCSTR)wndClass->lpszMenuName;
else
{
menuName = GetSystemString(wndClass->lpszMenuName);
wndClassA.lpszMenuName = menuName;
}
if (IS_INTRESOURCE(wndClass->lpszClassName))
wndClassA.lpszClassName = (LPCSTR)wndClass->lpszClassName;
else
{
className = GetSystemString(wndClass->lpszClassName);
wndClassA.lpszClassName = className;
}
return RegisterClassA(&wndClassA);
}
bool CWindow::Create(LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
if (g_IsNT)
{
_window = ::CreateWindowW(className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
return Create(GetSystemString(className), GetSystemString(windowName),
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
}
bool CWindow::CreateEx(DWORD exStyle, LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
if (g_IsNT)
{
_window = ::CreateWindowExW(exStyle, className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
AString classNameA;
LPCSTR classNameP;
if (IS_INTRESOURCE(className))
classNameP = (LPCSTR)className;
else
{
classNameA = GetSystemString(className);
classNameP = classNameA;
}
AString windowNameA;
LPCSTR windowNameP;
if (IS_INTRESOURCE(windowName))
windowNameP = (LPCSTR)windowName;
else
{
windowNameA = GetSystemString(windowName);
windowNameP = windowNameA;
}
return CreateEx(exStyle, classNameP, windowNameP,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
}
#endif
#ifndef _UNICODE
bool MySetWindowText(HWND wnd, LPCWSTR s)
{
if (g_IsNT)
return BOOLToBool(::SetWindowTextW(wnd, s));
return BOOLToBool(::SetWindowTextA(wnd, UnicodeStringToMultiByte(s)));
}
#endif
bool CWindow::GetText(CSysString &s)
{
s.Empty();
int len = GetTextLength();
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
TCHAR *p = s.GetBuf(len);
{
int len2 = GetText(p, len + 1);
if (len > len2)
len = len2;
}
s.ReleaseBuf_CalcLen(len);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
return true;
}
#ifndef _UNICODE
bool CWindow::GetText(UString &s)
{
if (g_IsNT)
{
s.Empty();
int len = GetWindowTextLengthW(_window);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
wchar_t *p = s.GetBuf(len);
{
int len2 = GetWindowTextW(_window, p, len + 1);
if (len > len2)
len = len2;
}
s.ReleaseBuf_CalcLen(len);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
return true;
}
CSysString sysString;
bool result = GetText(sysString);
MultiByteToUnicodeString2(s, sysString);
return result;
}
#endif
/*
bool CWindow::ModifyStyleBase(int styleOffset,
DWORD remove, DWORD add, UINT flags)
{
DWORD style = GetWindowLong(styleOffset);
DWORD newStyle = (style & ~remove) | add;
if (style == newStyle)
return false; // it is not good
SetWindowLong(styleOffset, newStyle);
if (flags != 0)
{
::SetWindowPos(_window, NULL, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | flags);
}
return TRUE;
}
*/
}
// Windows/Window.cpp
#include "StdAfx.h"
#ifndef _UNICODE
#include "../Common/StringConvert.h"
#endif
#include "Window.h"
#ifndef _UNICODE
extern bool g_IsNT;
#endif
namespace NWindows {
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass)
{
if (g_IsNT)
return RegisterClassW(wndClass);
WNDCLASSA wndClassA;
wndClassA.style = wndClass->style;
wndClassA.lpfnWndProc = wndClass->lpfnWndProc;
wndClassA.cbClsExtra = wndClass->cbClsExtra;
wndClassA.cbWndExtra = wndClass->cbWndExtra;
wndClassA.hInstance = wndClass->hInstance;
wndClassA.hIcon = wndClass->hIcon;
wndClassA.hCursor = wndClass->hCursor;
wndClassA.hbrBackground = wndClass->hbrBackground;
AString menuName;
AString className;
if (IS_INTRESOURCE(wndClass->lpszMenuName))
wndClassA.lpszMenuName = (LPCSTR)wndClass->lpszMenuName;
else
{
menuName = GetSystemString(wndClass->lpszMenuName);
wndClassA.lpszMenuName = menuName;
}
if (IS_INTRESOURCE(wndClass->lpszClassName))
wndClassA.lpszClassName = (LPCSTR)wndClass->lpszClassName;
else
{
className = GetSystemString(wndClass->lpszClassName);
wndClassA.lpszClassName = className;
}
return RegisterClassA(&wndClassA);
}
bool CWindow::Create(LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
if (g_IsNT)
{
_window = ::CreateWindowW(className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
return Create(GetSystemString(className), GetSystemString(windowName),
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
}
bool CWindow::CreateEx(DWORD exStyle, LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
if (g_IsNT)
{
_window = ::CreateWindowExW(exStyle, className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
AString classNameA;
LPCSTR classNameP;
if (IS_INTRESOURCE(className))
classNameP = (LPCSTR)className;
else
{
classNameA = GetSystemString(className);
classNameP = classNameA;
}
AString windowNameA;
LPCSTR windowNameP;
if (IS_INTRESOURCE(windowName))
windowNameP = (LPCSTR)windowName;
else
{
windowNameA = GetSystemString(windowName);
windowNameP = windowNameA;
}
return CreateEx(exStyle, classNameP, windowNameP,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
}
#endif
#ifndef _UNICODE
bool MySetWindowText(HWND wnd, LPCWSTR s)
{
if (g_IsNT)
return BOOLToBool(::SetWindowTextW(wnd, s));
return BOOLToBool(::SetWindowTextA(wnd, UnicodeStringToMultiByte(s)));
}
#endif
bool CWindow::GetText(CSysString &s)
{
s.Empty();
int len = GetTextLength();
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
TCHAR *p = s.GetBuf(len);
{
int len2 = GetText(p, len + 1);
if (len > len2)
len = len2;
}
s.ReleaseBuf_CalcLen(len);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
return true;
}
#ifndef _UNICODE
bool CWindow::GetText(UString &s)
{
if (g_IsNT)
{
s.Empty();
int len = GetWindowTextLengthW(_window);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
wchar_t *p = s.GetBuf(len);
{
int len2 = GetWindowTextW(_window, p, len + 1);
if (len > len2)
len = len2;
}
s.ReleaseBuf_CalcLen(len);
if (len == 0)
return (::GetLastError() == ERROR_SUCCESS);
return true;
}
CSysString sysString;
bool result = GetText(sysString);
MultiByteToUnicodeString2(s, sysString);
return result;
}
#endif
/*
bool CWindow::ModifyStyleBase(int styleOffset,
DWORD remove, DWORD add, UINT flags)
{
DWORD style = GetWindowLong(styleOffset);
DWORD newStyle = (style & ~remove) | add;
if (style == newStyle)
return false; // it is not good
SetWindowLong(styleOffset, newStyle);
if (flags != 0)
{
::SetWindowPos(_window, NULL, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | flags);
}
return TRUE;
}
*/
}

568
CPP/Windows/Window.h
View File

@@ -1,284 +1,284 @@
// Windows/Window.h
#ifndef __WINDOWS_WINDOW_H
#define __WINDOWS_WINDOW_H
#include "../Common/MyWindows.h"
#include "../Common/MyString.h"
#include "Defs.h"
#ifndef UNDER_CE
#define MY__WM_CHANGEUISTATE 0x0127
#define MY__WM_UPDATEUISTATE 0x0128
#define MY__WM_QUERYUISTATE 0x0129
// LOWORD(wParam) values in WM_*UISTATE
#define MY__UIS_SET 1
#define MY__UIS_CLEAR 2
#define MY__UIS_INITIALIZE 3
// HIWORD(wParam) values in WM_*UISTATE
#define MY__UISF_HIDEFOCUS 0x1
#define MY__UISF_HIDEACCEL 0x2
#define MY__UISF_ACTIVE 0x4
#endif
namespace NWindows {
inline ATOM MyRegisterClass(CONST WNDCLASS *wndClass)
{ return ::RegisterClass(wndClass); }
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
#endif
#ifdef _UNICODE
inline bool MySetWindowText(HWND wnd, LPCWSTR s) { return BOOLToBool(::SetWindowText(wnd, s)); }
#else
bool MySetWindowText(HWND wnd, LPCWSTR s);
#endif
#ifdef UNDER_CE
#define GWLP_USERDATA GWL_USERDATA
#define GWLP_WNDPROC GWL_WNDPROC
#define BTNS_BUTTON TBSTYLE_BUTTON
#define WC_COMBOBOXW L"ComboBox"
#define DWLP_MSGRESULT DWL_MSGRESULT
#endif
class CWindow
{
private:
// bool ModifyStyleBase(int styleOffset, DWORD remove, DWORD add, UINT flags);
protected:
HWND _window;
public:
CWindow(HWND newWindow = NULL): _window(newWindow){};
CWindow& operator=(HWND newWindow)
{
_window = newWindow;
return *this;
}
operator HWND() const { return _window; }
void Attach(HWND newWindow) { _window = newWindow; }
HWND Detach()
{
HWND window = _window;
_window = NULL;
return window;
}
bool Foreground() { return BOOLToBool(::SetForegroundWindow(_window)); }
HWND GetParent() const { return ::GetParent(_window); }
bool GetWindowRect(LPRECT rect) const { return BOOLToBool(::GetWindowRect(_window,rect)); }
#ifndef UNDER_CE
bool IsZoomed() const { return BOOLToBool(::IsZoomed(_window)); }
#endif
bool ClientToScreen(LPPOINT point) const { return BOOLToBool(::ClientToScreen(_window, point)); }
bool ScreenToClient(LPPOINT point) const { return BOOLToBool(::ScreenToClient(_window, point)); }
bool CreateEx(DWORD exStyle, LPCTSTR className,
LPCTSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
_window = ::CreateWindowEx(exStyle, className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
bool Create(LPCTSTR className,
LPCTSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
_window = ::CreateWindow(className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
#ifndef _UNICODE
bool Create(LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
bool CreateEx(DWORD exStyle, LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
#endif
bool Destroy()
{
if (_window == NULL)
return true;
bool result = BOOLToBool(::DestroyWindow(_window));
if (result)
_window = NULL;
return result;
}
bool IsWindow() { return BOOLToBool(::IsWindow(_window)); }
bool Move(int x, int y, int width, int height, bool repaint = true)
{ return BOOLToBool(::MoveWindow(_window, x, y, width, height, BoolToBOOL(repaint))); }
bool ChangeSubWindowSizeX(HWND hwnd, int xSize)
{
RECT rect;
::GetWindowRect(hwnd, &rect);
POINT p1;
p1.x = rect.left;
p1.y = rect.top;
ScreenToClient(&p1);
return BOOLToBool(::MoveWindow(hwnd, p1.x, p1.y, xSize, rect.bottom - rect.top, TRUE));
}
void ScreenToClient(RECT *rect)
{
POINT p1, p2;
p1.x = rect->left;
p1.y = rect->top;
p2.x = rect->right;
p2.y = rect->bottom;
ScreenToClient(&p1);
ScreenToClient(&p2);
rect->left = p1.x;
rect->top = p1.y;
rect->right = p2.x;
rect->bottom = p2.y;
}
bool GetClientRect(LPRECT rect) { return BOOLToBool(::GetClientRect(_window, rect)); }
bool Show(int cmdShow) { return BOOLToBool(::ShowWindow(_window, cmdShow)); }
bool Show_Bool(bool show) { return Show(show ? SW_SHOW: SW_HIDE); }
#ifndef UNDER_CE
bool SetPlacement(CONST WINDOWPLACEMENT *placement) { return BOOLToBool(::SetWindowPlacement(_window, placement)); }
bool GetPlacement(WINDOWPLACEMENT *placement) { return BOOLToBool(::GetWindowPlacement(_window, placement)); }
#endif
bool Update() { return BOOLToBool(::UpdateWindow(_window)); }
bool InvalidateRect(LPCRECT rect, bool backgroundErase = true)
{ return BOOLToBool(::InvalidateRect(_window, rect, BoolToBOOL(backgroundErase))); }
void SetRedraw(bool redraw = true) { SendMsg(WM_SETREDRAW, BoolToBOOL(redraw), 0); }
LONG_PTR SetStyle(LONG_PTR style) { return SetLongPtr(GWL_STYLE, style); }
LONG_PTR GetStyle() const { return GetLongPtr(GWL_STYLE); }
// bool MyIsMaximized() const { return ((GetStyle() & WS_MAXIMIZE) != 0); }
LONG_PTR SetLong(int index, LONG newLongPtr) { return ::SetWindowLong(_window, index, newLongPtr); }
LONG_PTR GetLong(int index) const { return ::GetWindowLong(_window, index); }
LONG_PTR SetUserDataLong(LONG newLongPtr) { return SetLong(GWLP_USERDATA, newLongPtr); }
LONG_PTR GetUserDataLong() const { return GetLong(GWLP_USERDATA); }
#ifdef UNDER_CE
LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr) { return SetLong(index, newLongPtr); }
LONG_PTR GetLongPtr(int index) const { return GetLong(index); }
LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetUserDataLong(newLongPtr); }
LONG_PTR GetUserDataLongPtr() const { return GetUserDataLong(); }
#else
LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr)
{ return ::SetWindowLongPtr(_window, index,
#ifndef _WIN64
(LONG)
#endif
newLongPtr); }
#ifndef _UNICODE
LONG_PTR SetLongPtrW(int index, LONG_PTR newLongPtr)
{ return ::SetWindowLongPtrW(_window, index,
#ifndef _WIN64
(LONG)
#endif
newLongPtr); }
#endif
LONG_PTR GetLongPtr(int index) const { return ::GetWindowLongPtr(_window, index); }
LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetLongPtr(GWLP_USERDATA, newLongPtr); }
LONG_PTR GetUserDataLongPtr() const { return GetLongPtr(GWLP_USERDATA); }
#endif
/*
bool ModifyStyle(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
{ return ModifyStyleBase(GWL_STYLE, remove, add, flags); }
bool ModifyStyleEx(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
{ return ModifyStyleBase(GWL_EXSTYLE, remove, add, flags); }
*/
HWND SetFocus() { return ::SetFocus(_window); }
LRESULT SendMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return ::SendMessage(_window, message, wParam, lParam); }
#ifndef _UNICODE
LRESULT SendMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return ::SendMessageW(_window, message, wParam, lParam); }
#endif
bool PostMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return BOOLToBool(::PostMessage(_window, message, wParam, lParam)); }
#ifndef _UNICODE
bool PostMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return BOOLToBool(::PostMessageW(_window, message, wParam, lParam)); }
#endif
bool SetText(LPCTSTR s) { return BOOLToBool(::SetWindowText(_window, s)); }
#ifndef _UNICODE
bool SetText(LPCWSTR s) { return MySetWindowText(_window, s); }
#endif
int GetTextLength() const
{ return GetWindowTextLength(_window); }
UINT GetText(LPTSTR string, int maxCount) const
{ return GetWindowText(_window, string, maxCount); }
bool GetText(CSysString &s);
#ifndef _UNICODE
/*
UINT GetText(LPWSTR string, int maxCount) const
{ return GetWindowTextW(_window, string, maxCount); }
*/
bool GetText(UString &s);
#endif
bool Enable(bool enable)
{ return BOOLToBool(::EnableWindow(_window, BoolToBOOL(enable))); }
bool IsEnabled()
{ return BOOLToBool(::IsWindowEnabled(_window)); }
#ifndef UNDER_CE
HMENU GetSystemMenu(bool revert)
{ return ::GetSystemMenu(_window, BoolToBOOL(revert)); }
#endif
UINT_PTR SetTimer(UINT_PTR idEvent, UINT elapse, TIMERPROC timerFunc = 0)
{ return ::SetTimer(_window, idEvent, elapse, timerFunc); }
bool KillTimer(UINT_PTR idEvent)
{return BOOLToBool(::KillTimer(_window, idEvent)); }
HICON SetIcon(WPARAM sizeType, HICON icon) { return (HICON)SendMsg(WM_SETICON, sizeType, (LPARAM)icon); }
};
#define RECT_SIZE_X(r) ((r).right - (r).left)
#define RECT_SIZE_Y(r) ((r).bottom - (r).top)
inline bool IsKeyDown(int virtKey) { return (::GetKeyState(virtKey) & 0x8000) != 0; }
}
#endif
// Windows/Window.h
#ifndef __WINDOWS_WINDOW_H
#define __WINDOWS_WINDOW_H
#include "../Common/MyWindows.h"
#include "../Common/MyString.h"
#include "Defs.h"
#ifndef UNDER_CE
#define MY__WM_CHANGEUISTATE 0x0127
#define MY__WM_UPDATEUISTATE 0x0128
#define MY__WM_QUERYUISTATE 0x0129
// LOWORD(wParam) values in WM_*UISTATE
#define MY__UIS_SET 1
#define MY__UIS_CLEAR 2
#define MY__UIS_INITIALIZE 3
// HIWORD(wParam) values in WM_*UISTATE
#define MY__UISF_HIDEFOCUS 0x1
#define MY__UISF_HIDEACCEL 0x2
#define MY__UISF_ACTIVE 0x4
#endif
namespace NWindows {
inline ATOM MyRegisterClass(CONST WNDCLASS *wndClass)
{ return ::RegisterClass(wndClass); }
#ifndef _UNICODE
ATOM MyRegisterClass(CONST WNDCLASSW *wndClass);
#endif
#ifdef _UNICODE
inline bool MySetWindowText(HWND wnd, LPCWSTR s) { return BOOLToBool(::SetWindowText(wnd, s)); }
#else
bool MySetWindowText(HWND wnd, LPCWSTR s);
#endif
#ifdef UNDER_CE
#define GWLP_USERDATA GWL_USERDATA
#define GWLP_WNDPROC GWL_WNDPROC
#define BTNS_BUTTON TBSTYLE_BUTTON
#define WC_COMBOBOXW L"ComboBox"
#define DWLP_MSGRESULT DWL_MSGRESULT
#endif
class CWindow
{
private:
// bool ModifyStyleBase(int styleOffset, DWORD remove, DWORD add, UINT flags);
protected:
HWND _window;
public:
CWindow(HWND newWindow = NULL): _window(newWindow){};
CWindow& operator=(HWND newWindow)
{
_window = newWindow;
return *this;
}
operator HWND() const { return _window; }
void Attach(HWND newWindow) { _window = newWindow; }
HWND Detach()
{
HWND window = _window;
_window = NULL;
return window;
}
bool Foreground() { return BOOLToBool(::SetForegroundWindow(_window)); }
HWND GetParent() const { return ::GetParent(_window); }
bool GetWindowRect(LPRECT rect) const { return BOOLToBool(::GetWindowRect(_window,rect)); }
#ifndef UNDER_CE
bool IsZoomed() const { return BOOLToBool(::IsZoomed(_window)); }
#endif
bool ClientToScreen(LPPOINT point) const { return BOOLToBool(::ClientToScreen(_window, point)); }
bool ScreenToClient(LPPOINT point) const { return BOOLToBool(::ScreenToClient(_window, point)); }
bool CreateEx(DWORD exStyle, LPCTSTR className,
LPCTSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
_window = ::CreateWindowEx(exStyle, className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
bool Create(LPCTSTR className,
LPCTSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam)
{
_window = ::CreateWindow(className, windowName,
style, x, y, width, height, parentWindow,
idOrHMenu, instance, createParam);
return (_window != NULL);
}
#ifndef _UNICODE
bool Create(LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
bool CreateEx(DWORD exStyle, LPCWSTR className,
LPCWSTR windowName, DWORD style,
int x, int y, int width, int height,
HWND parentWindow, HMENU idOrHMenu,
HINSTANCE instance, LPVOID createParam);
#endif
bool Destroy()
{
if (_window == NULL)
return true;
bool result = BOOLToBool(::DestroyWindow(_window));
if (result)
_window = NULL;
return result;
}
bool IsWindow() { return BOOLToBool(::IsWindow(_window)); }
bool Move(int x, int y, int width, int height, bool repaint = true)
{ return BOOLToBool(::MoveWindow(_window, x, y, width, height, BoolToBOOL(repaint))); }
bool ChangeSubWindowSizeX(HWND hwnd, int xSize)
{
RECT rect;
::GetWindowRect(hwnd, &rect);
POINT p1;
p1.x = rect.left;
p1.y = rect.top;
ScreenToClient(&p1);
return BOOLToBool(::MoveWindow(hwnd, p1.x, p1.y, xSize, rect.bottom - rect.top, TRUE));
}
void ScreenToClient(RECT *rect)
{
POINT p1, p2;
p1.x = rect->left;
p1.y = rect->top;
p2.x = rect->right;
p2.y = rect->bottom;
ScreenToClient(&p1);
ScreenToClient(&p2);
rect->left = p1.x;
rect->top = p1.y;
rect->right = p2.x;
rect->bottom = p2.y;
}
bool GetClientRect(LPRECT rect) { return BOOLToBool(::GetClientRect(_window, rect)); }
bool Show(int cmdShow) { return BOOLToBool(::ShowWindow(_window, cmdShow)); }
bool Show_Bool(bool show) { return Show(show ? SW_SHOW: SW_HIDE); }
#ifndef UNDER_CE
bool SetPlacement(CONST WINDOWPLACEMENT *placement) { return BOOLToBool(::SetWindowPlacement(_window, placement)); }
bool GetPlacement(WINDOWPLACEMENT *placement) { return BOOLToBool(::GetWindowPlacement(_window, placement)); }
#endif
bool Update() { return BOOLToBool(::UpdateWindow(_window)); }
bool InvalidateRect(LPCRECT rect, bool backgroundErase = true)
{ return BOOLToBool(::InvalidateRect(_window, rect, BoolToBOOL(backgroundErase))); }
void SetRedraw(bool redraw = true) { SendMsg(WM_SETREDRAW, BoolToBOOL(redraw), 0); }
LONG_PTR SetStyle(LONG_PTR style) { return SetLongPtr(GWL_STYLE, style); }
LONG_PTR GetStyle() const { return GetLongPtr(GWL_STYLE); }
// bool MyIsMaximized() const { return ((GetStyle() & WS_MAXIMIZE) != 0); }
LONG_PTR SetLong(int index, LONG newLongPtr) { return ::SetWindowLong(_window, index, newLongPtr); }
LONG_PTR GetLong(int index) const { return ::GetWindowLong(_window, index); }
LONG_PTR SetUserDataLong(LONG newLongPtr) { return SetLong(GWLP_USERDATA, newLongPtr); }
LONG_PTR GetUserDataLong() const { return GetLong(GWLP_USERDATA); }
#ifdef UNDER_CE
LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr) { return SetLong(index, newLongPtr); }
LONG_PTR GetLongPtr(int index) const { return GetLong(index); }
LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetUserDataLong(newLongPtr); }
LONG_PTR GetUserDataLongPtr() const { return GetUserDataLong(); }
#else
LONG_PTR SetLongPtr(int index, LONG_PTR newLongPtr)
{ return ::SetWindowLongPtr(_window, index,
#ifndef _WIN64
(LONG)
#endif
newLongPtr); }
#ifndef _UNICODE
LONG_PTR SetLongPtrW(int index, LONG_PTR newLongPtr)
{ return ::SetWindowLongPtrW(_window, index,
#ifndef _WIN64
(LONG)
#endif
newLongPtr); }
#endif
LONG_PTR GetLongPtr(int index) const { return ::GetWindowLongPtr(_window, index); }
LONG_PTR SetUserDataLongPtr(LONG_PTR newLongPtr) { return SetLongPtr(GWLP_USERDATA, newLongPtr); }
LONG_PTR GetUserDataLongPtr() const { return GetLongPtr(GWLP_USERDATA); }
#endif
/*
bool ModifyStyle(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
{ return ModifyStyleBase(GWL_STYLE, remove, add, flags); }
bool ModifyStyleEx(HWND hWnd, DWORD remove, DWORD add, UINT flags = 0)
{ return ModifyStyleBase(GWL_EXSTYLE, remove, add, flags); }
*/
HWND SetFocus() { return ::SetFocus(_window); }
LRESULT SendMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return ::SendMessage(_window, message, wParam, lParam); }
#ifndef _UNICODE
LRESULT SendMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return ::SendMessageW(_window, message, wParam, lParam); }
#endif
bool PostMsg(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return BOOLToBool(::PostMessage(_window, message, wParam, lParam)); }
#ifndef _UNICODE
bool PostMsgW(UINT message, WPARAM wParam = 0, LPARAM lParam = 0)
{ return BOOLToBool(::PostMessageW(_window, message, wParam, lParam)); }
#endif
bool SetText(LPCTSTR s) { return BOOLToBool(::SetWindowText(_window, s)); }
#ifndef _UNICODE
bool SetText(LPCWSTR s) { return MySetWindowText(_window, s); }
#endif
int GetTextLength() const
{ return GetWindowTextLength(_window); }
UINT GetText(LPTSTR string, int maxCount) const
{ return GetWindowText(_window, string, maxCount); }
bool GetText(CSysString &s);
#ifndef _UNICODE
/*
UINT GetText(LPWSTR string, int maxCount) const
{ return GetWindowTextW(_window, string, maxCount); }
*/
bool GetText(UString &s);
#endif
bool Enable(bool enable)
{ return BOOLToBool(::EnableWindow(_window, BoolToBOOL(enable))); }
bool IsEnabled()
{ return BOOLToBool(::IsWindowEnabled(_window)); }
#ifndef UNDER_CE
HMENU GetSystemMenu(bool revert)
{ return ::GetSystemMenu(_window, BoolToBOOL(revert)); }
#endif
UINT_PTR SetTimer(UINT_PTR idEvent, UINT elapse, TIMERPROC timerFunc = 0)
{ return ::SetTimer(_window, idEvent, elapse, timerFunc); }
bool KillTimer(UINT_PTR idEvent)
{return BOOLToBool(::KillTimer(_window, idEvent)); }
HICON SetIcon(WPARAM sizeType, HICON icon) { return (HICON)SendMsg(WM_SETICON, sizeType, (LPARAM)icon); }
};
#define RECT_SIZE_X(r) ((r).right - (r).left)
#define RECT_SIZE_Y(r) ((r).bottom - (r).top)
inline bool IsKeyDown(int virtKey) { return (::GetKeyState(virtKey) & 0x8000) != 0; }
}
#endif