chore: initial commit (extracted from Launchers monorepo)

Plugin: ns7zip v2.0.0
Architectures: x86-ansi, x86-unicode, amd64-unicode
License: LGPL-2.1-or-later

versions/19.00/CPP/Windows/COM.cpp

@@ -0,0 +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);
+}
+
+}}
+
+*/

versions/19.00/CPP/Windows/COM.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Clipboard.cpp

@@ -0,0 +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;
+}
+ 
+}

versions/19.00/CPP/Windows/Clipboard.h

@@ -0,0 +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

versions/19.00/CPP/Windows/CommonDialog.cpp

@@ -0,0 +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;
+  }
+}
+
+}

versions/19.00/CPP/Windows/CommonDialog.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Console.cpp

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

versions/19.00/CPP/Windows/Console.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/ComboBox.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/Control/ComboBox.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/CommandBar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/Dialog.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/Control/Dialog.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/Edit.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/ImageList.cpp

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

versions/19.00/CPP/Windows/Control/ImageList.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/ListView.cpp

@@ -0,0 +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;
+}
+*/
+  
+}}

versions/19.00/CPP/Windows/Control/ListView.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/ProgressBar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/PropertyPage.cpp

@@ -0,0 +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);
+  }
+}
+
+}}

versions/19.00/CPP/Windows/Control/PropertyPage.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/ReBar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/Static.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/StatusBar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/StdAfx.h

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

versions/19.00/CPP/Windows/Control/ToolBar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/Trackbar.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Control/Window2.cpp

@@ -0,0 +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;
+}
+
+*/
+
+}}

versions/19.00/CPP/Windows/Control/Window2.h

@@ -0,0 +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

versions/19.00/CPP/Windows/DLL.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/DLL.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Defs.h

@@ -0,0 +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

versions/19.00/CPP/Windows/ErrorMsg.cpp

@@ -0,0 +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;
+}
+
+}}

versions/19.00/CPP/Windows/ErrorMsg.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileDir.cpp

@@ -0,0 +1,714 @@
+// Windows/FileDir.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "FileDir.h"
+#include "FileFind.h"
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+namespace NWindows {
+namespace NFile {
+namespace NDir {
+
+#ifndef UNDER_CE
+
+bool GetWindowsDir(FString &path)
+{
+  UINT needLength;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetWindowsDirectory(s, MAX_PATH + 1);
+    path = fas2fs(s);
+  }
+  else
+  #endif
+  {
+    WCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetWindowsDirectoryW(s, MAX_PATH + 1);
+    path = us2fs(s);
+  }
+  return (needLength > 0 && needLength <= MAX_PATH);
+}
+
+bool GetSystemDir(FString &path)
+{
+  UINT needLength;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetSystemDirectory(s, MAX_PATH + 1);
+    path = fas2fs(s);
+  }
+  else
+  #endif
+  {
+    WCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetSystemDirectoryW(s, MAX_PATH + 1);
+    path = us2fs(s);
+  }
+  return (needLength > 0 && needLength <= MAX_PATH);
+}
+#endif
+
+bool SetDirTime(CFSTR path, const FILETIME *cTime, const FILETIME *aTime, const FILETIME *mTime)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return false;
+  }
+  #endif
+  
+  HANDLE hDir = INVALID_HANDLE_VALUE;
+  IF_USE_MAIN_PATH
+    hDir = ::CreateFileW(fs2us(path), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+        NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+  #ifdef WIN_LONG_PATH
+  if (hDir == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
+  {
+    UString superPath;
+    if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+      hDir = ::CreateFileW(superPath, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE,
+          NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+  }
+  #endif
+
+  bool res = false;
+  if (hDir != INVALID_HANDLE_VALUE)
+  {
+    res = BOOLToBool(::SetFileTime(hDir, cTime, aTime, mTime));
+    ::CloseHandle(hDir);
+  }
+  return res;
+}
+
+bool SetFileAttrib(CFSTR path, DWORD attrib)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::SetFileAttributes(fs2fas(path), attrib))
+      return true;
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+      if (::SetFileAttributesW(fs2us(path), attrib))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        return BOOLToBool(::SetFileAttributesW(superPath, attrib));
+    }
+    #endif
+  }
+  return false;
+}
+
+
+bool SetFileAttrib_PosixHighDetect(CFSTR path, DWORD attrib)
+{
+  if ((attrib & 0xF0000000) != 0)
+    attrib &= 0x3FFF;
+  return SetFileAttrib(path, attrib);
+}
+
+
+bool RemoveDir(CFSTR path)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::RemoveDirectory(fs2fas(path)))
+      return true;
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+      if (::RemoveDirectoryW(fs2us(path)))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        return BOOLToBool(::RemoveDirectoryW(superPath));
+    }
+    #endif
+  }
+  return false;
+}
+
+bool MyMoveFile(CFSTR oldFile, CFSTR newFile)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::MoveFile(fs2fas(oldFile), fs2fas(newFile)))
+      return true;
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH_2(oldFile, newFile)
+      if (::MoveFileW(fs2us(oldFile), fs2us(newFile)))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH_2)
+    {
+      UString d1, d2;
+      if (GetSuperPaths(oldFile, newFile, d1, d2, USE_MAIN_PATH_2))
+        return BOOLToBool(::MoveFileW(d1, d2));
+    }
+    #endif
+  }
+  return false;
+}
+
+#ifndef UNDER_CE
+
+EXTERN_C_BEGIN
+typedef BOOL (WINAPI *Func_CreateHardLinkW)(
+    LPCWSTR lpFileName,
+    LPCWSTR lpExistingFileName,
+    LPSECURITY_ATTRIBUTES lpSecurityAttributes
+    );
+EXTERN_C_END
+
+bool MyCreateHardLink(CFSTR newFileName, CFSTR existFileName)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return false;
+    /*
+    if (::CreateHardLink(fs2fas(newFileName), fs2fas(existFileName), NULL))
+      return true;
+    */
+  }
+  else
+  #endif
+  {
+    Func_CreateHardLinkW my_CreateHardLinkW = (Func_CreateHardLinkW)
+        ::GetProcAddress(::GetModuleHandleW(L"kernel32.dll"), "CreateHardLinkW");
+    if (!my_CreateHardLinkW)
+      return false;
+    IF_USE_MAIN_PATH_2(newFileName, existFileName)
+      if (my_CreateHardLinkW(fs2us(newFileName), fs2us(existFileName), NULL))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH_2)
+    {
+      UString d1, d2;
+      if (GetSuperPaths(newFileName, existFileName, d1, d2, USE_MAIN_PATH_2))
+        return BOOLToBool(my_CreateHardLinkW(d1, d2, NULL));
+    }
+    #endif
+  }
+  return false;
+}
+
+#endif
+
+/*
+WinXP-64 CreateDir():
+  ""                  - ERROR_PATH_NOT_FOUND
+  \                   - ERROR_ACCESS_DENIED
+  C:\                 - ERROR_ACCESS_DENIED, if there is such drive,
+  
+  D:\folder             - ERROR_PATH_NOT_FOUND, if there is no such drive,
+  C:\nonExistent\folder - ERROR_PATH_NOT_FOUND
+  
+  C:\existFolder      - ERROR_ALREADY_EXISTS
+  C:\existFolder\     - ERROR_ALREADY_EXISTS
+
+  C:\folder   - OK
+  C:\folder\  - OK
+
+  \\Server\nonExistent    - ERROR_BAD_NETPATH
+  \\Server\Share_Readonly - ERROR_ACCESS_DENIED
+  \\Server\Share          - ERROR_ALREADY_EXISTS
+
+  \\Server\Share_NTFS_drive - ERROR_ACCESS_DENIED
+  \\Server\Share_FAT_drive  - ERROR_ALREADY_EXISTS
+*/
+
+bool CreateDir(CFSTR path)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::CreateDirectory(fs2fas(path), NULL))
+      return true;
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+      if (::CreateDirectoryW(fs2us(path), NULL))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        return BOOLToBool(::CreateDirectoryW(superPath, NULL));
+    }
+    #endif
+  }
+  return false;
+}
+
+/*
+  CreateDir2 returns true, if directory can contain files after the call (two cases):
+    1) the directory already exists
+    2) the directory was created
+  path must be WITHOUT trailing path separator.
+
+  We need CreateDir2, since fileInfo.Find() for reserved names like "com8"
+   returns FILE instead of DIRECTORY. And we need to use SuperPath */
+ 
+static bool CreateDir2(CFSTR path)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::CreateDirectory(fs2fas(path), NULL))
+      return true;
+  }
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+      if (::CreateDirectoryW(fs2us(path), NULL))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if ((!USE_MAIN_PATH || ::GetLastError() != ERROR_ALREADY_EXISTS) && USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+      {
+        if (::CreateDirectoryW(superPath, NULL))
+          return true;
+        if (::GetLastError() != ERROR_ALREADY_EXISTS)
+          return false;
+        NFind::CFileInfo fi;
+        if (!fi.Find(us2fs(superPath)))
+          return false;
+        return fi.IsDir();
+      }
+    }
+    #endif
+  }
+  if (::GetLastError() != ERROR_ALREADY_EXISTS)
+    return false;
+  NFind::CFileInfo fi;
+  if (!fi.Find(path))
+    return false;
+  return fi.IsDir();
+}
+
+bool CreateComplexDir(CFSTR _path)
+{
+  #ifdef _WIN32
+  
+  {
+    DWORD attrib = NFind::GetFileAttrib(_path);
+    if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+      return true;
+  }
+
+  #ifndef UNDER_CE
+  
+  if (IsDriveRootPath_SuperAllowed(_path))
+    return false;
+  
+  unsigned prefixSize = GetRootPrefixSize(_path);
+  
+  #endif
+  
+  #endif
+
+  FString path (_path);
+
+  int pos = path.ReverseFind_PathSepar();
+  if (pos >= 0 && (unsigned)pos == path.Len() - 1)
+  {
+    if (path.Len() == 1)
+      return true;
+    path.DeleteBack();
+  }
+
+  const FString path2 (path);
+  pos = path.Len();
+  
+  for (;;)
+  {
+    if (CreateDir2(path))
+      break;
+    if (::GetLastError() == ERROR_ALREADY_EXISTS)
+      return false;
+    pos = path.ReverseFind_PathSepar();
+    if (pos < 0 || pos == 0)
+      return false;
+    
+    #if defined(_WIN32) && !defined(UNDER_CE)
+    if (pos == 1 && IS_PATH_SEPAR(path[0]))
+      return false;
+    if (prefixSize >= (unsigned)pos + 1)
+      return false;
+    #endif
+    
+    path.DeleteFrom(pos);
+  }
+  
+  while (pos < (int)path2.Len())
+  {
+    int pos2 = NName::FindSepar(path2.Ptr(pos + 1));
+    if (pos2 < 0)
+      pos = path2.Len();
+    else
+      pos += 1 + pos2;
+    path.SetFrom(path2, pos);
+    if (!CreateDir(path))
+      return false;
+  }
+  
+  return true;
+}
+
+bool DeleteFileAlways(CFSTR path)
+{
+  /* If alt stream, we also need to clear READ-ONLY attribute of main file before delete.
+     SetFileAttrib("name:stream", ) changes attributes of main file. */
+  {
+    DWORD attrib = NFind::GetFileAttrib(path);
+    if (attrib != INVALID_FILE_ATTRIBUTES
+        && (attrib & FILE_ATTRIBUTE_DIRECTORY) == 0
+        && (attrib & FILE_ATTRIBUTE_READONLY) != 0)
+    {
+      if (!SetFileAttrib(path, attrib & ~FILE_ATTRIBUTE_READONLY))
+        return false;
+    }
+  }
+
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    if (::DeleteFile(fs2fas(path)))
+      return true;
+  }
+  else
+  #endif
+  {
+    /* DeleteFile("name::$DATA") deletes all alt streams (same as delete DeleteFile("name")).
+       Maybe it's better to open "name::$DATA" and clear data for unnamed stream? */
+    IF_USE_MAIN_PATH
+      if (::DeleteFileW(fs2us(path)))
+        return true;
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        return BOOLToBool(::DeleteFileW(superPath));
+    }
+    #endif
+  }
+  return false;
+}
+
+bool RemoveDirWithSubItems(const FString &path)
+{
+  bool needRemoveSubItems = true;
+  {
+    NFind::CFileInfo fi;
+    if (!fi.Find(path))
+      return false;
+    if (!fi.IsDir())
+    {
+      ::SetLastError(ERROR_DIRECTORY);
+      return false;
+    }
+    if (fi.HasReparsePoint())
+      needRemoveSubItems = false;
+  }
+
+  if (needRemoveSubItems)
+  {
+    FString s (path);
+    s.Add_PathSepar();
+    const unsigned prefixSize = s.Len();
+    NFind::CEnumerator enumerator;
+    enumerator.SetDirPrefix(s);
+    NFind::CFileInfo fi;
+    while (enumerator.Next(fi))
+    {
+      s.DeleteFrom(prefixSize);
+      s += fi.Name;
+      if (fi.IsDir())
+      {
+        if (!RemoveDirWithSubItems(s))
+          return false;
+      }
+      else if (!DeleteFileAlways(s))
+        return false;
+    }
+  }
+  
+  if (!SetFileAttrib(path, 0))
+    return false;
+  return RemoveDir(path);
+}
+
+#ifdef UNDER_CE
+
+bool MyGetFullPathName(CFSTR path, FString &resFullPath)
+{
+  resFullPath = path;
+  return true;
+}
+
+#else
+
+bool MyGetFullPathName(CFSTR path, FString &resFullPath)
+{
+  return GetFullPath(path, resFullPath);
+}
+
+bool SetCurrentDir(CFSTR path)
+{
+  // SetCurrentDirectory doesn't support \\?\ prefix
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    return BOOLToBool(::SetCurrentDirectory(fs2fas(path)));
+  }
+  else
+  #endif
+  {
+    return BOOLToBool(::SetCurrentDirectoryW(fs2us(path)));
+  }
+}
+
+bool GetCurrentDir(FString &path)
+{
+  path.Empty();
+  DWORD needLength;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetCurrentDirectory(MAX_PATH + 1, s);
+    path = fas2fs(s);
+  }
+  else
+  #endif
+  {
+    WCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, s);
+    path = us2fs(s);
+  }
+  return (needLength > 0 && needLength <= MAX_PATH);
+}
+
+#endif
+
+bool GetFullPathAndSplit(CFSTR path, FString &resDirPrefix, FString &resFileName)
+{
+  bool res = MyGetFullPathName(path, resDirPrefix);
+  if (!res)
+    resDirPrefix = path;
+  int pos = resDirPrefix.ReverseFind_PathSepar();
+  resFileName = resDirPrefix.Ptr(pos + 1);
+  resDirPrefix.DeleteFrom(pos + 1);
+  return res;
+}
+
+bool GetOnlyDirPrefix(CFSTR path, FString &resDirPrefix)
+{
+  FString resFileName;
+  return GetFullPathAndSplit(path, resDirPrefix, resFileName);
+}
+
+bool MyGetTempPath(FString &path)
+{
+  path.Empty();
+  DWORD needLength;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetTempPath(MAX_PATH + 1, s);
+    path = fas2fs(s);
+  }
+  else
+  #endif
+  {
+    WCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetTempPathW(MAX_PATH + 1, s);;
+    path = us2fs(s);
+  }
+  return (needLength > 0 && needLength <= MAX_PATH);
+}
+
+static bool CreateTempFile(CFSTR prefix, bool addRandom, FString &path, NIO::COutFile *outFile)
+{
+  UInt32 d = (GetTickCount() << 12) ^ (GetCurrentThreadId() << 14) ^ GetCurrentProcessId();
+  for (unsigned i = 0; i < 100; i++)
+  {
+    path = prefix;
+    if (addRandom)
+    {
+      char s[16];
+      UInt32 val = d;
+      unsigned k;
+      for (k = 0; k < 8; k++)
+      {
+        unsigned t = val & 0xF;
+        val >>= 4;
+        s[k] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+      }
+      s[k] = '\0';
+      if (outFile)
+        path += '.';
+      path += s;
+      UInt32 step = GetTickCount() + 2;
+      if (step == 0)
+        step = 1;
+      d += step;
+    }
+    addRandom = true;
+    if (outFile)
+      path += ".tmp";
+    if (NFind::DoesFileOrDirExist(path))
+    {
+      SetLastError(ERROR_ALREADY_EXISTS);
+      continue;
+    }
+    if (outFile)
+    {
+      if (outFile->Create(path, false))
+        return true;
+    }
+    else
+    {
+      if (CreateDir(path))
+        return true;
+    }
+    DWORD error = GetLastError();
+    if (error != ERROR_FILE_EXISTS &&
+        error != ERROR_ALREADY_EXISTS)
+      break;
+  }
+  path.Empty();
+  return false;
+}
+
+bool CTempFile::Create(CFSTR prefix, NIO::COutFile *outFile)
+{
+  if (!Remove())
+    return false;
+  if (!CreateTempFile(prefix, false, _path, outFile))
+    return false;
+  _mustBeDeleted = true;
+  return true;
+}
+
+bool CTempFile::CreateRandomInTempFolder(CFSTR namePrefix, NIO::COutFile *outFile)
+{
+  if (!Remove())
+    return false;
+  FString tempPath;
+  if (!MyGetTempPath(tempPath))
+    return false;
+  if (!CreateTempFile(tempPath + namePrefix, true, _path, outFile))
+    return false;
+  _mustBeDeleted = true;
+  return true;
+}
+
+bool CTempFile::Remove()
+{
+  if (!_mustBeDeleted)
+    return true;
+  _mustBeDeleted = !DeleteFileAlways(_path);
+  return !_mustBeDeleted;
+}
+
+bool CTempFile::MoveTo(CFSTR name, bool deleteDestBefore)
+{
+  // DWORD attrib = 0;
+  if (deleteDestBefore)
+  {
+    if (NFind::DoesFileExist(name))
+    {
+      // attrib = NFind::GetFileAttrib(name);
+      if (!DeleteFileAlways(name))
+        return false;
+    }
+  }
+  DisableDeleting();
+  return MyMoveFile(_path, name);
+  
+  /*
+  if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
+  {
+    DWORD attrib2 = NFind::GetFileAttrib(name);
+    if (attrib2 != INVALID_FILE_ATTRIBUTES)
+      SetFileAttrib(name, attrib2 | FILE_ATTRIBUTE_READONLY);
+  }
+  */
+}
+
+bool CTempDir::Create(CFSTR prefix)
+{
+  if (!Remove())
+    return false;
+  FString tempPath;
+  if (!MyGetTempPath(tempPath))
+    return false;
+  if (!CreateTempFile(tempPath + prefix, true, _path, NULL))
+    return false;
+  _mustBeDeleted = true;
+  return true;
+}
+
+bool CTempDir::Remove()
+{
+  if (!_mustBeDeleted)
+    return true;
+  _mustBeDeleted = !RemoveDirWithSubItems(_path);
+  return !_mustBeDeleted;
+}
+
+}}}

versions/19.00/CPP/Windows/FileDir.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileFind.cpp

@@ -0,0 +1,749 @@
+// Windows/FileFind.cpp
+
+#include "StdAfx.h"
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "FileFind.h"
+#include "FileIO.h"
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+using namespace NWindows;
+using namespace NFile;
+using namespace NName;
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+EXTERN_C_BEGIN
+
+typedef enum
+{
+  My_FindStreamInfoStandard,
+  My_FindStreamInfoMaxInfoLevel
+} MY_STREAM_INFO_LEVELS;
+
+typedef struct
+{
+  LARGE_INTEGER StreamSize;
+  WCHAR cStreamName[MAX_PATH + 36];
+} MY_WIN32_FIND_STREAM_DATA, *MY_PWIN32_FIND_STREAM_DATA;
+
+typedef WINBASEAPI HANDLE (WINAPI *FindFirstStreamW_Ptr)(LPCWSTR fileName, MY_STREAM_INFO_LEVELS infoLevel,
+    LPVOID findStreamData, DWORD flags);
+
+typedef WINBASEAPI BOOL (APIENTRY *FindNextStreamW_Ptr)(HANDLE findStream, LPVOID findStreamData);
+
+EXTERN_C_END
+
+#endif
+
+namespace NWindows {
+namespace NFile {
+
+#ifdef SUPPORT_DEVICE_FILE
+namespace NSystem
+{
+bool MyGetDiskFreeSpace(CFSTR rootPath, UInt64 &clusterSize, UInt64 &totalSize, UInt64 &freeSize);
+}
+#endif
+
+namespace NFind {
+
+bool CFileInfo::IsDots() const throw()
+{
+  if (!IsDir() || Name.IsEmpty())
+    return false;
+  if (Name[0] != '.')
+    return false;
+  return Name.Len() == 1 || (Name.Len() == 2 && Name[1] == '.');
+}
+
+#define WIN_FD_TO_MY_FI(fi, fd) \
+  fi.Attrib = fd.dwFileAttributes; \
+  fi.CTime = fd.ftCreationTime; \
+  fi.ATime = fd.ftLastAccessTime; \
+  fi.MTime = fd.ftLastWriteTime; \
+  fi.Size = (((UInt64)fd.nFileSizeHigh) << 32) + fd.nFileSizeLow; \
+  fi.IsAltStream = false; \
+  fi.IsDevice = false;
+
+  /*
+  #ifdef UNDER_CE
+  fi.ObjectID = fd.dwOID;
+  #else
+  fi.ReparseTag = fd.dwReserved0;
+  #endif
+  */
+
+static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATAW &fd, CFileInfo &fi)
+{
+  WIN_FD_TO_MY_FI(fi, fd);
+  fi.Name = us2fs(fd.cFileName);
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  // fi.ShortName = us2fs(fd.cAlternateFileName);
+  #endif
+}
+
+#ifndef _UNICODE
+
+static void Convert_WIN32_FIND_DATA_to_FileInfo(const WIN32_FIND_DATA &fd, CFileInfo &fi)
+{
+  WIN_FD_TO_MY_FI(fi, fd);
+  fi.Name = fas2fs(fd.cFileName);
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  // fi.ShortName = fas2fs(fd.cAlternateFileName);
+  #endif
+}
+#endif
+  
+////////////////////////////////
+// CFindFile
+
+bool CFindFileBase::Close() throw()
+{
+  if (_handle == INVALID_HANDLE_VALUE)
+    return true;
+  if (!::FindClose(_handle))
+    return false;
+  _handle = INVALID_HANDLE_VALUE;
+  return true;
+}
+
+/*
+WinXP-64 FindFirstFile():
+  ""      -  ERROR_PATH_NOT_FOUND
+  folder\ -  ERROR_FILE_NOT_FOUND
+  \       -  ERROR_FILE_NOT_FOUND
+  c:\     -  ERROR_FILE_NOT_FOUND
+  c:      -  ERROR_FILE_NOT_FOUND, if current dir is ROOT     ( c:\ )
+  c:      -  OK,                   if current dir is NOT ROOT ( c:\folder )
+  folder  -  OK
+
+  \\               - ERROR_INVALID_NAME
+  \\Server         - ERROR_INVALID_NAME
+  \\Server\        - ERROR_INVALID_NAME
+      
+  \\Server\Share            - ERROR_BAD_NETPATH
+  \\Server\Share            - ERROR_BAD_NET_NAME (Win7).
+             !!! There is problem : Win7 makes some requests for "\\Server\Shar" (look in Procmon),
+                 when we call it for "\\Server\Share"
+                      
+  \\Server\Share\           - ERROR_FILE_NOT_FOUND
+  
+  \\?\UNC\Server\Share      - ERROR_INVALID_NAME
+  \\?\UNC\Server\Share      - ERROR_BAD_PATHNAME (Win7)
+  \\?\UNC\Server\Share\     - ERROR_FILE_NOT_FOUND
+  
+  \\Server\Share_RootDrive  - ERROR_INVALID_NAME
+  \\Server\Share_RootDrive\ - ERROR_INVALID_NAME
+  
+  c:\* - ERROR_FILE_NOT_FOUND, if thare are no item in that folder
+*/
+
+bool CFindFile::FindFirst(CFSTR path, CFileInfo &fi)
+{
+  if (!Close())
+    return false;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    WIN32_FIND_DATAA fd;
+    _handle = ::FindFirstFileA(fs2fas(path), &fd);
+    if (_handle == INVALID_HANDLE_VALUE)
+      return false;
+    Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+  }
+  else
+  #endif
+  {
+    WIN32_FIND_DATAW fd;
+
+    IF_USE_MAIN_PATH
+      _handle = ::FindFirstFileW(fs2us(path), &fd);
+    #ifdef WIN_LONG_PATH
+    if (_handle == INVALID_HANDLE_VALUE && USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        _handle = ::FindFirstFileW(superPath, &fd);
+    }
+    #endif
+    if (_handle == INVALID_HANDLE_VALUE)
+      return false;
+    Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+  }
+  return true;
+}
+
+bool CFindFile::FindNext(CFileInfo &fi)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    WIN32_FIND_DATAA fd;
+    if (!::FindNextFileA(_handle, &fd))
+      return false;
+    Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+  }
+  else
+  #endif
+  {
+    WIN32_FIND_DATAW fd;
+    if (!::FindNextFileW(_handle, &fd))
+      return false;
+    Convert_WIN32_FIND_DATA_to_FileInfo(fd, fi);
+  }
+  return true;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+////////////////////////////////
+// AltStreams
+
+static FindFirstStreamW_Ptr g_FindFirstStreamW;
+static FindNextStreamW_Ptr g_FindNextStreamW;
+
+struct CFindStreamLoader
+{
+  CFindStreamLoader()
+  {
+    g_FindFirstStreamW = (FindFirstStreamW_Ptr)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "FindFirstStreamW");
+    g_FindNextStreamW = (FindNextStreamW_Ptr)::GetProcAddress(::GetModuleHandleA("kernel32.dll"), "FindNextStreamW");
+  }
+} g_FindStreamLoader;
+
+bool CStreamInfo::IsMainStream() const throw()
+{
+  return StringsAreEqualNoCase_Ascii(Name, "::$DATA");
+};
+
+UString CStreamInfo::GetReducedName() const
+{
+  // remove ":$DATA" postfix, but keep postfix, if Name is "::$DATA"
+  UString s (Name);
+  if (s.Len() > 6 + 1 && StringsAreEqualNoCase_Ascii(s.RightPtr(6), ":$DATA"))
+    s.DeleteFrom(s.Len() - 6);
+  return s;
+}
+
+/*
+UString CStreamInfo::GetReducedName2() const
+{
+  UString s = GetReducedName();
+  if (!s.IsEmpty() && s[0] == ':')
+    s.Delete(0);
+  return s;
+}
+*/
+
+static void Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(const MY_WIN32_FIND_STREAM_DATA &sd, CStreamInfo &si)
+{
+  si.Size = sd.StreamSize.QuadPart;
+  si.Name = sd.cStreamName;
+}
+
+/*
+  WinXP-64 FindFirstStream():
+  ""      -  ERROR_PATH_NOT_FOUND
+  folder\ -  OK
+  folder  -  OK
+  \       -  OK
+  c:\     -  OK
+  c:      -  OK, if current dir is ROOT     ( c:\ )
+  c:      -  OK, if current dir is NOT ROOT ( c:\folder )
+  \\Server\Share   - OK
+  \\Server\Share\  - OK
+
+  \\               - ERROR_INVALID_NAME
+  \\Server         - ERROR_INVALID_NAME
+  \\Server\        - ERROR_INVALID_NAME
+*/
+
+bool CFindStream::FindFirst(CFSTR path, CStreamInfo &si)
+{
+  if (!Close())
+    return false;
+  if (!g_FindFirstStreamW)
+  {
+    ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return false;
+  }
+  {
+    MY_WIN32_FIND_STREAM_DATA sd;
+    SetLastError(0);
+    IF_USE_MAIN_PATH
+      _handle = g_FindFirstStreamW(fs2us(path), My_FindStreamInfoStandard, &sd, 0);
+    if (_handle == INVALID_HANDLE_VALUE)
+    {
+      if (::GetLastError() == ERROR_HANDLE_EOF)
+        return false;
+      // long name can be tricky for path like ".\dirName".
+      #ifdef WIN_LONG_PATH
+      if (USE_SUPER_PATH)
+      {
+        UString superPath;
+        if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+          _handle = g_FindFirstStreamW(superPath, My_FindStreamInfoStandard, &sd, 0);
+      }
+      #endif
+    }
+    if (_handle == INVALID_HANDLE_VALUE)
+      return false;
+    Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
+  }
+  return true;
+}
+
+bool CFindStream::FindNext(CStreamInfo &si)
+{
+  if (!g_FindNextStreamW)
+  {
+    ::SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
+    return false;
+  }
+  {
+    MY_WIN32_FIND_STREAM_DATA sd;
+    if (!g_FindNextStreamW(_handle, &sd))
+      return false;
+    Convert_WIN32_FIND_STREAM_DATA_to_StreamInfo(sd, si);
+  }
+  return true;
+}
+
+bool CStreamEnumerator::Next(CStreamInfo &si, bool &found)
+{
+  bool res;
+  if (_find.IsHandleAllocated())
+    res = _find.FindNext(si);
+  else
+    res = _find.FindFirst(_filePath, si);
+  if (res)
+  {
+    found = true;
+    return true;
+  }
+  found = false;
+  return (::GetLastError() == ERROR_HANDLE_EOF);
+}
+
+#endif
+
+
+#define MY_CLEAR_FILETIME(ft) ft.dwLowDateTime = ft.dwHighDateTime = 0;
+
+void CFileInfoBase::ClearBase() throw()
+{
+  Size = 0;
+  MY_CLEAR_FILETIME(CTime);
+  MY_CLEAR_FILETIME(ATime);
+  MY_CLEAR_FILETIME(MTime);
+  Attrib = 0;
+  IsAltStream = false;
+  IsDevice = false;
+}
+
+/*
+WinXP-64 GetFileAttributes():
+  If the function fails, it returns INVALID_FILE_ATTRIBUTES and use GetLastError() to get error code
+
+  \    - OK
+  C:\  - OK, if there is such drive,
+  D:\  - ERROR_PATH_NOT_FOUND, if there is no such drive,
+
+  C:\folder     - OK
+  C:\folder\    - OK
+  C:\folderBad  - ERROR_FILE_NOT_FOUND
+
+  \\Server\BadShare  - ERROR_BAD_NETPATH
+  \\Server\Share     - WORKS OK, but MSDN says:
+                          GetFileAttributes for a network share, the function fails, and GetLastError
+                          returns ERROR_BAD_NETPATH. You must specify a path to a subfolder on that share.
+*/
+
+DWORD GetFileAttrib(CFSTR path)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+    return ::GetFileAttributes(fs2fas(path));
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+    {
+      DWORD dw = ::GetFileAttributesW(fs2us(path));
+      if (dw != INVALID_FILE_ATTRIBUTES)
+        return dw;
+    }
+    #ifdef WIN_LONG_PATH
+    if (USE_SUPER_PATH)
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        return ::GetFileAttributesW(superPath);
+    }
+    #endif
+    return INVALID_FILE_ATTRIBUTES;
+  }
+}
+
+/* if path is "c:" or "c::" then CFileInfo::Find() returns name of current folder for that disk
+   so instead of absolute path we have relative path in Name. That is not good in some calls */
+
+/* In CFileInfo::Find() we want to support same names for alt streams as in CreateFile(). */
+
+/* CFileInfo::Find()
+We alow the following paths (as FindFirstFile):
+  C:\folder
+  c:                      - if current dir is NOT ROOT ( c:\folder )
+
+also we support paths that are not supported by FindFirstFile:
+  \
+  \\.\c:
+  c:\                     - Name will be without tail slash ( c: )
+  \\?\c:\                 - Name will be without tail slash ( c: )
+  \\Server\Share
+  \\?\UNC\Server\Share
+
+  c:\folder:stream  - Name = folder:stream
+  c:\:stream        - Name = :stream
+  c::stream         - Name = c::stream
+*/
+
+bool CFileInfo::Find(CFSTR path)
+{
+  #ifdef SUPPORT_DEVICE_FILE
+  if (IsDevicePath(path))
+  {
+    ClearBase();
+    Name = path + 4;
+    IsDevice = true;
+    
+    if (NName::IsDrivePath2(path + 4) && path[6] == 0)
+    {
+      FChar drive[4] = { path[4], ':', '\\', 0 };
+      UInt64 clusterSize, totalSize, freeSize;
+      if (NSystem::MyGetDiskFreeSpace(drive, clusterSize, totalSize, freeSize))
+      {
+        Size = totalSize;
+        return true;
+      }
+    }
+
+    NIO::CInFile inFile;
+    // ::OutputDebugStringW(path);
+    if (!inFile.Open(path))
+      return false;
+    // ::OutputDebugStringW(L"---");
+    if (inFile.SizeDefined)
+      Size = inFile.Size;
+    return true;
+  }
+  #endif
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+
+  int colonPos = FindAltStreamColon(path);
+  if (colonPos >= 0 && path[(unsigned)colonPos + 1] != 0)
+  {
+    UString streamName = fs2us(path + (unsigned)colonPos);
+    FString filePath (path);
+    filePath.DeleteFrom(colonPos);
+    /* we allow both cases:
+      name:stream
+      name:stream:$DATA
+    */
+    const unsigned kPostfixSize = 6;
+    if (streamName.Len() <= kPostfixSize
+        || !StringsAreEqualNoCase_Ascii(streamName.RightPtr(kPostfixSize), ":$DATA"))
+      streamName += ":$DATA";
+
+    bool isOk = true;
+    
+    if (IsDrivePath2(filePath) &&
+        (colonPos == 2 || colonPos == 3 && filePath[2] == '\\'))
+    {
+      // FindFirstFile doesn't work for "c:\" and for "c:" (if current dir is ROOT)
+      ClearBase();
+      Name.Empty();
+      if (colonPos == 2)
+        Name = filePath;
+    }
+    else
+      isOk = Find(filePath);
+
+    if (isOk)
+    {
+      Attrib &= ~(FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT);
+      Size = 0;
+      CStreamEnumerator enumerator(filePath);
+      for (;;)
+      {
+        CStreamInfo si;
+        bool found;
+        if (!enumerator.Next(si, found))
+          return false;
+        if (!found)
+        {
+          ::SetLastError(ERROR_FILE_NOT_FOUND);
+          return false;
+        }
+        if (si.Name.IsEqualTo_NoCase(streamName))
+        {
+          // we delete postfix, if alt stream name is not "::$DATA"
+          if (si.Name.Len() > kPostfixSize + 1)
+            si.Name.DeleteFrom(si.Name.Len() - kPostfixSize);
+          Name += us2fs(si.Name);
+          Size = si.Size;
+          IsAltStream = true;
+          return true;
+        }
+      }
+    }
+  }
+  
+  #endif
+
+  CFindFile finder;
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  {
+    /*
+    DWORD lastError = GetLastError();
+    if (lastError == ERROR_FILE_NOT_FOUND
+        || lastError == ERROR_BAD_NETPATH  // XP64: "\\Server\Share"
+        || lastError == ERROR_BAD_NET_NAME // Win7: "\\Server\Share"
+        || lastError == ERROR_INVALID_NAME // XP64: "\\?\UNC\Server\Share"
+        || lastError == ERROR_BAD_PATHNAME // Win7: "\\?\UNC\Server\Share"
+        )
+    */
+    
+    unsigned rootSize = 0;
+    if (IsSuperPath(path))
+      rootSize = kSuperPathPrefixSize;
+    
+    if (NName::IsDrivePath(path + rootSize) && path[rootSize + 3] == 0)
+    {
+      DWORD attrib = GetFileAttrib(path);
+      if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+      {
+        ClearBase();
+        Attrib = attrib;
+        Name = path + rootSize;
+        Name.DeleteFrom(2); // we don't need backslash (C:)
+        return true;
+      }
+    }
+    else if (IS_PATH_SEPAR(path[0]))
+      if (path[1] == 0)
+      {
+        DWORD attrib = GetFileAttrib(path);
+        if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+        {
+          ClearBase();
+          Name.Empty();
+          Attrib = attrib;
+          return true;
+        }
+      }
+      else
+      {
+        const unsigned prefixSize = GetNetworkServerPrefixSize(path);
+        if (prefixSize > 0 && path[prefixSize] != 0)
+        {
+          if (NName::FindSepar(path + prefixSize) < 0)
+          {
+            FString s (path);
+            s.Add_PathSepar();
+            s += '*'; // CHAR_ANY_MASK
+            
+            bool isOK = false;
+            if (finder.FindFirst(s, *this))
+            {
+              if (Name == FTEXT("."))
+              {
+                Name = path + prefixSize;
+                return true;
+              }
+              isOK = true;
+              /* if "\\server\share" maps to root folder "d:\", there is no "." item.
+                 But it's possible that there are another items */
+            }
+            {
+              DWORD attrib = GetFileAttrib(path);
+              if (isOK || attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_DIRECTORY) != 0)
+              {
+                ClearBase();
+                if (attrib != INVALID_FILE_ATTRIBUTES)
+                  Attrib = attrib;
+                else
+                  SetAsDir();
+                Name = path + prefixSize;
+                return true;
+              }
+            }
+            // ::SetLastError(lastError);
+          }
+        }
+      }
+  }
+  #endif
+
+  return finder.FindFirst(path, *this);
+}
+
+
+bool DoesFileExist(CFSTR name)
+{
+  CFileInfo fi;
+  return fi.Find(name) && !fi.IsDir();
+}
+
+bool DoesDirExist(CFSTR name)
+{
+  CFileInfo fi;
+  return fi.Find(name) && fi.IsDir();
+}
+
+bool DoesFileOrDirExist(CFSTR name)
+{
+  CFileInfo fi;
+  return fi.Find(name);
+}
+
+
+void CEnumerator::SetDirPrefix(const FString &dirPrefix)
+{
+  _wildcard = dirPrefix;
+  _wildcard += '*';
+}
+
+bool CEnumerator::NextAny(CFileInfo &fi)
+{
+  if (_findFile.IsHandleAllocated())
+    return _findFile.FindNext(fi);
+  else
+    return _findFile.FindFirst(_wildcard, fi);
+}
+
+bool CEnumerator::Next(CFileInfo &fi)
+{
+  for (;;)
+  {
+    if (!NextAny(fi))
+      return false;
+    if (!fi.IsDots())
+      return true;
+  }
+}
+
+bool CEnumerator::Next(CFileInfo &fi, bool &found)
+{
+  if (Next(fi))
+  {
+    found = true;
+    return true;
+  }
+  found = false;
+  return (::GetLastError() == ERROR_NO_MORE_FILES);
+}
+
+////////////////////////////////
+// CFindChangeNotification
+// FindFirstChangeNotification can return 0. MSDN doesn't tell about it.
+
+bool CFindChangeNotification::Close() throw()
+{
+  if (!IsHandleAllocated())
+    return true;
+  if (!::FindCloseChangeNotification(_handle))
+    return false;
+  _handle = INVALID_HANDLE_VALUE;
+  return true;
+}
+           
+HANDLE CFindChangeNotification::FindFirst(CFSTR path, bool watchSubtree, DWORD notifyFilter)
+{
+  #ifndef _UNICODE
+  if (!g_IsNT)
+    _handle = ::FindFirstChangeNotification(fs2fas(path), BoolToBOOL(watchSubtree), notifyFilter);
+  else
+  #endif
+  {
+    IF_USE_MAIN_PATH
+    _handle = ::FindFirstChangeNotificationW(fs2us(path), BoolToBOOL(watchSubtree), notifyFilter);
+    #ifdef WIN_LONG_PATH
+    if (!IsHandleAllocated())
+    {
+      UString superPath;
+      if (GetSuperPath(path, superPath, USE_MAIN_PATH))
+        _handle = ::FindFirstChangeNotificationW(superPath, BoolToBOOL(watchSubtree), notifyFilter);
+    }
+    #endif
+  }
+  return _handle;
+}
+
+#ifndef UNDER_CE
+
+bool MyGetLogicalDriveStrings(CObjectVector<FString> &driveStrings)
+{
+  driveStrings.Clear();
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    driveStrings.Clear();
+    UINT32 size = GetLogicalDriveStrings(0, NULL);
+    if (size == 0)
+      return false;
+    CObjArray<char> buf(size);
+    UINT32 newSize = GetLogicalDriveStrings(size, buf);
+    if (newSize == 0 || newSize > size)
+      return false;
+    AString s;
+    UINT32 prev = 0;
+    for (UINT32 i = 0; i < newSize; i++)
+    {
+      if (buf[i] == 0)
+      {
+        s = buf + prev;
+        prev = i + 1;
+        driveStrings.Add(fas2fs(s));
+      }
+    }
+    return prev == newSize;
+  }
+  else
+  #endif
+  {
+    UINT32 size = GetLogicalDriveStringsW(0, NULL);
+    if (size == 0)
+      return false;
+    CObjArray<wchar_t> buf(size);
+    UINT32 newSize = GetLogicalDriveStringsW(size, buf);
+    if (newSize == 0 || newSize > size)
+      return false;
+    UString s;
+    UINT32 prev = 0;
+    for (UINT32 i = 0; i < newSize; i++)
+    {
+      if (buf[i] == 0)
+      {
+        s = buf + prev;
+        prev = i + 1;
+        driveStrings.Add(us2fs(s));
+      }
+    }
+    return prev == newSize;
+  }
+}
+
+#endif
+
+}}}

versions/19.00/CPP/Windows/FileFind.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileIO.cpp

@@ -0,0 +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();
+}
+
+}}}

versions/19.00/CPP/Windows/FileIO.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileLink.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/FileMapping.cpp

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

versions/19.00/CPP/Windows/FileMapping.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileName.cpp

@@ -0,0 +1,839 @@
+// Windows/FileName.cpp
+
+#include "StdAfx.h"
+
+#include "FileName.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+namespace NFile {
+namespace NName {
+
+#define IS_SEPAR(c) IS_PATH_SEPAR(c)
+
+int FindSepar(const wchar_t *s) throw()
+{
+  for (const wchar_t *p = s;; p++)
+  {
+    const wchar_t c = *p;
+    if (c == 0)
+      return -1;
+    if (IS_SEPAR(c))
+      return (int)(p - s);
+  }
+}
+
+#ifndef USE_UNICODE_FSTRING
+int FindSepar(const FChar *s) throw()
+{
+  for (const FChar *p = s;; p++)
+  {
+    const FChar c = *p;
+    if (c == 0)
+      return -1;
+    if (IS_SEPAR(c))
+      return (int)(p - s);
+  }
+}
+#endif
+
+#ifndef USE_UNICODE_FSTRING
+void NormalizeDirPathPrefix(FString &dirPath)
+{
+  if (dirPath.IsEmpty())
+    return;
+  if (!IsPathSepar(dirPath.Back()))
+    dirPath.Add_PathSepar();
+}
+#endif
+
+void NormalizeDirPathPrefix(UString &dirPath)
+{
+  if (dirPath.IsEmpty())
+    return;
+  if (!IsPathSepar(dirPath.Back()))
+    dirPath.Add_PathSepar();
+}
+
+#define IS_LETTER_CHAR(c) ((c) >= 'a' && (c) <= 'z' || (c) >= 'A' && (c) <= 'Z')
+
+bool IsDrivePath(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+
+bool IsAltPathPrefix(CFSTR s) throw()
+{
+  unsigned len = MyStringLen(s);
+  if (len == 0)
+    return false;
+  if (s[len - 1] != ':')
+    return false;
+
+  #if defined(_WIN32) && !defined(UNDER_CE)
+  if (IsDevicePath(s))
+    return false;
+  if (IsSuperPath(s))
+  {
+    s += kSuperPathPrefixSize;
+    len -= kSuperPathPrefixSize;
+  }
+  if (len == 2 && IsDrivePath2(s))
+    return false;
+  #endif
+
+  return true;
+}
+
+#if defined(_WIN32) && !defined(UNDER_CE)
+
+const char * const kSuperPathPrefix = "\\\\?\\";
+static const char * const kSuperUncPrefix = "\\\\?\\UNC\\";
+
+#define IS_DEVICE_PATH(s)          (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '.' && IS_SEPAR((s)[3]))
+#define IS_SUPER_PREFIX(s)         (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && (s)[2] == '?' && IS_SEPAR((s)[3]))
+#define IS_SUPER_OR_DEVICE_PATH(s) (IS_SEPAR((s)[0]) && IS_SEPAR((s)[1]) && ((s)[2] == '?' || (s)[2] == '.') && IS_SEPAR((s)[3]))
+
+#define IS_UNC_WITH_SLASH(s) ( \
+     ((s)[0] == 'U' || (s)[0] == 'u') \
+  && ((s)[1] == 'N' || (s)[1] == 'n') \
+  && ((s)[2] == 'C' || (s)[2] == 'c') \
+  && IS_SEPAR((s)[3]))
+
+bool IsDevicePath(CFSTR s) throw()
+{
+  #ifdef UNDER_CE
+
+  s = s;
+  return false;
+  /*
+  // actually we don't know the way to open device file in WinCE.
+  unsigned len = MyStringLen(s);
+  if (len < 5 || len > 5 || !IsString1PrefixedByString2(s, "DSK"))
+    return false;
+  if (s[4] != ':')
+    return false;
+  // for reading use SG_REQ sg; if (DeviceIoControl(dsk, IOCTL_DISK_READ));
+  */
+  
+  #else
+  
+  if (!IS_DEVICE_PATH(s))
+    return false;
+  unsigned len = MyStringLen(s);
+  if (len == 6 && s[5] == ':')
+    return true;
+  if (len < 18 || len > 22 || !IsString1PrefixedByString2(s + kDevicePathPrefixSize, "PhysicalDrive"))
+    return false;
+  for (unsigned i = 17; i < len; i++)
+    if (s[i] < '0' || s[i] > '9')
+      return false;
+  return true;
+  
+  #endif
+}
+
+bool IsSuperUncPath(CFSTR s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+bool IsNetworkPath(CFSTR s) throw()
+{
+  if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
+    return false;
+  if (IsSuperUncPath(s))
+    return true;
+  FChar c = s[2];
+  return (c != '.' && c != '?');
+}
+
+unsigned GetNetworkServerPrefixSize(CFSTR s) throw()
+{
+  if (!IS_SEPAR(s[0]) || !IS_SEPAR(s[1]))
+    return 0;
+  unsigned prefixSize = 2;
+  if (IsSuperUncPath(s))
+    prefixSize = kSuperUncPathPrefixSize;
+  else
+  {
+    FChar c = s[2];
+    if (c == '.' || c == '?')
+      return 0;
+  }
+  int pos = FindSepar(s + prefixSize);
+  if (pos < 0)
+    return 0;
+  return prefixSize + pos + 1;
+}
+
+bool IsNetworkShareRootPath(CFSTR s) throw()
+{
+  unsigned prefixSize = GetNetworkServerPrefixSize(s);
+  if (prefixSize == 0)
+    return false;
+  s += prefixSize;
+  int pos = FindSepar(s);
+  if (pos < 0)
+    return true;
+  return s[(unsigned)pos + 1] == 0;
+}
+
+static const unsigned kDrivePrefixSize = 3; /* c:\ */
+
+bool IsDrivePath2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+// bool IsDriveName2(const wchar_t *s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+bool IsSuperPath(const wchar_t *s) throw() { return IS_SUPER_PREFIX(s); }
+bool IsSuperOrDevicePath(const wchar_t *s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
+// bool IsSuperUncPath(const wchar_t *s) throw() { return (IS_SUPER_PREFIX(s) && IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize)); }
+
+#ifndef USE_UNICODE_FSTRING
+bool IsDrivePath2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':'; }
+// bool IsDriveName2(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && s[2] == 0; }
+bool IsDrivePath(CFSTR s) throw() { return IS_LETTER_CHAR(s[0]) && s[1] == ':' && IS_SEPAR(s[2]); }
+bool IsSuperPath(CFSTR s) throw() { return IS_SUPER_PREFIX(s); }
+bool IsSuperOrDevicePath(CFSTR s) throw() { return IS_SUPER_OR_DEVICE_PATH(s); }
+#endif // USE_UNICODE_FSTRING
+
+bool IsDrivePath_SuperAllowed(CFSTR s) throw()
+{
+  if (IsSuperPath(s))
+    s += kSuperPathPrefixSize;
+  return IsDrivePath(s);
+}
+
+bool IsDriveRootPath_SuperAllowed(CFSTR s) throw()
+{
+  if (IsSuperPath(s))
+    s += kSuperPathPrefixSize;
+  return IsDrivePath(s) && s[kDrivePrefixSize] == 0;
+}
+
+bool IsAbsolutePath(const wchar_t *s) throw()
+{
+  return IS_SEPAR(s[0]) || IsDrivePath2(s);
+}
+
+int FindAltStreamColon(CFSTR path) throw()
+{
+  unsigned i = 0;
+  if (IsDrivePath2(path))
+    i = 2;
+  int colonPos = -1;
+  for (;; i++)
+  {
+    FChar c = path[i];
+    if (c == 0)
+      return colonPos;
+    if (c == ':')
+    {
+      if (colonPos < 0)
+        colonPos = i;
+      continue;
+    }
+    if (IS_SEPAR(c))
+      colonPos = -1;
+  }
+}
+
+#ifndef USE_UNICODE_FSTRING
+
+static unsigned GetRootPrefixSize_Of_NetworkPath(CFSTR s)
+{
+  // Network path: we look "server\path\" as root prefix
+  int pos = FindSepar(s);
+  if (pos < 0)
+    return 0;
+  int pos2 = FindSepar(s + (unsigned)pos + 1);
+  if (pos2 < 0)
+    return 0;
+  return pos + pos2 + 2;
+}
+
+static unsigned GetRootPrefixSize_Of_SimplePath(CFSTR s)
+{
+  if (IsDrivePath(s))
+    return kDrivePrefixSize;
+  if (!IS_SEPAR(s[0]))
+    return 0;
+  if (s[1] == 0 || !IS_SEPAR(s[1]))
+    return 1;
+  unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+  return (size == 0) ? 0 : 2 + size;
+}
+
+static unsigned GetRootPrefixSize_Of_SuperPath(CFSTR s)
+{
+  if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
+  {
+    unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+    return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
+  }
+  // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
+  int pos = FindSepar(s + kSuperPathPrefixSize);
+  if (pos < 0)
+    return 0;
+  return kSuperPathPrefixSize + pos + 1;
+}
+
+unsigned GetRootPrefixSize(CFSTR s) throw()
+{
+  if (IS_DEVICE_PATH(s))
+    return kDevicePathPrefixSize;
+  if (IsSuperPath(s))
+    return GetRootPrefixSize_Of_SuperPath(s);
+  return GetRootPrefixSize_Of_SimplePath(s);
+}
+
+#endif // USE_UNICODE_FSTRING
+
+static unsigned GetRootPrefixSize_Of_NetworkPath(const wchar_t *s) throw()
+{
+  // Network path: we look "server\path\" as root prefix
+  int pos = FindSepar(s);
+  if (pos < 0)
+    return 0;
+  int pos2 = FindSepar(s + (unsigned)pos + 1);
+  if (pos2 < 0)
+    return 0;
+  return pos + pos2 + 2;
+}
+
+static unsigned GetRootPrefixSize_Of_SimplePath(const wchar_t *s) throw()
+{
+  if (IsDrivePath(s))
+    return kDrivePrefixSize;
+  if (!IS_SEPAR(s[0]))
+    return 0;
+  if (s[1] == 0 || !IS_SEPAR(s[1]))
+    return 1;
+  unsigned size = GetRootPrefixSize_Of_NetworkPath(s + 2);
+  return (size == 0) ? 0 : 2 + size;
+}
+
+static unsigned GetRootPrefixSize_Of_SuperPath(const wchar_t *s) throw()
+{
+  if (IS_UNC_WITH_SLASH(s + kSuperPathPrefixSize))
+  {
+    unsigned size = GetRootPrefixSize_Of_NetworkPath(s + kSuperUncPathPrefixSize);
+    return (size == 0) ? 0 : kSuperUncPathPrefixSize + size;
+  }
+  // we support \\?\c:\ paths and volume GUID paths \\?\Volume{GUID}\"
+  int pos = FindSepar(s + kSuperPathPrefixSize);
+  if (pos < 0)
+    return 0;
+  return kSuperPathPrefixSize + pos + 1;
+}
+
+unsigned GetRootPrefixSize(const wchar_t *s) throw()
+{
+  if (IS_DEVICE_PATH(s))
+    return kDevicePathPrefixSize;
+  if (IsSuperPath(s))
+    return GetRootPrefixSize_Of_SuperPath(s);
+  return GetRootPrefixSize_Of_SimplePath(s);
+}
+
+#else // _WIN32
+
+bool IsAbsolutePath(const wchar_t *s) { return IS_SEPAR(s[0]); }
+
+#ifndef USE_UNICODE_FSTRING
+unsigned GetRootPrefixSize(CFSTR s) { return IS_SEPAR(s[0]) ? 1 : 0; }
+#endif
+unsigned GetRootPrefixSize(const wchar_t *s) { return IS_SEPAR(s[0]) ? 1 : 0; }
+
+#endif // _WIN32
+
+
+#ifndef UNDER_CE
+
+static bool GetCurDir(UString &path)
+{
+  path.Empty();
+  DWORD needLength;
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    TCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetCurrentDirectory(MAX_PATH + 1, s);
+    path = fs2us(fas2fs(s));
+  }
+  else
+  #endif
+  {
+    WCHAR s[MAX_PATH + 2];
+    s[0] = 0;
+    needLength = ::GetCurrentDirectoryW(MAX_PATH + 1, s);
+    path = s;
+  }
+  return (needLength > 0 && needLength <= MAX_PATH);
+}
+
+static bool ResolveDotsFolders(UString &s)
+{
+  #ifdef _WIN32
+  // s.Replace(L'/', WCHAR_PATH_SEPARATOR);
+  #endif
+  
+  for (unsigned i = 0;;)
+  {
+    const wchar_t c = s[i];
+    if (c == 0)
+      return true;
+    if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
+    {
+      const wchar_t c1 = s[i + 1];
+      if (c1 == '.')
+      {
+        const wchar_t c2 = s[i + 2];
+        if (IS_SEPAR(c2) || c2 == 0)
+        {
+          if (i == 0)
+            return false;
+          int k = i - 2;
+          i += 2;
+          
+          for (;; k--)
+          {
+            if (k < 0)
+              return false;
+            if (!IS_SEPAR(s[(unsigned)k]))
+              break;
+          }
+
+          do
+            k--;
+          while (k >= 0 && !IS_SEPAR(s[(unsigned)k]));
+          
+          unsigned num;
+          
+          if (k >= 0)
+          {
+            num = i - k;
+            i = k;
+          }
+          else
+          {
+            num = (c2 == 0 ? i : (i + 1));
+            i = 0;
+          }
+          
+          s.Delete(i, num);
+          continue;
+        }
+      }
+      else if (IS_SEPAR(c1) || c1 == 0)
+      {
+        unsigned num = 2;
+        if (i != 0)
+          i--;
+        else if (c1 == 0)
+          num = 1;
+        s.Delete(i, num);
+        continue;
+      }
+    }
+
+    i++;
+  }
+}
+
+#endif // UNDER_CE
+
+#define LONG_PATH_DOTS_FOLDERS_PARSING
+
+
+/*
+Windows (at least 64-bit XP) can't resolve "." or ".." in paths that start with SuperPrefix \\?\
+To solve that problem we check such path:
+   - super path contains        "." or ".." - we use kSuperPathType_UseOnlySuper
+   - super path doesn't contain "." or ".." - we use kSuperPathType_UseOnlyMain
+*/
+#ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+#ifndef UNDER_CE
+static bool AreThereDotsFolders(CFSTR s)
+{
+  for (unsigned i = 0;; i++)
+  {
+    FChar c = s[i];
+    if (c == 0)
+      return false;
+    if (c == '.' && (i == 0 || IS_SEPAR(s[i - 1])))
+    {
+      FChar c1 = s[i + 1];
+      if (c1 == 0 || IS_SEPAR(c1) ||
+          (c1 == '.' && (s[i + 2] == 0 || IS_SEPAR(s[i + 2]))))
+        return true;
+    }
+  }
+}
+#endif
+#endif // LONG_PATH_DOTS_FOLDERS_PARSING
+
+#ifdef WIN_LONG_PATH
+
+/*
+Most of Windows versions have problems, if some file or dir name
+contains '.' or ' ' at the end of name (Bad Path).
+To solve that problem, we always use Super Path ("\\?\" prefix and full path)
+in such cases. Note that "." and ".." are not bad names.
+
+There are 3 cases:
+  1) If the path is already Super Path, we use that path
+  2) If the path is not Super Path :
+     2.1) Bad Path;  we use only Super Path.
+     2.2) Good Path; we use Main Path. If it fails, we use Super Path.
+
+ NeedToUseOriginalPath returns:
+    kSuperPathType_UseOnlyMain    : Super already
+    kSuperPathType_UseOnlySuper    : not Super, Bad Path
+    kSuperPathType_UseMainAndSuper : not Super, Good Path
+*/
+
+int GetUseSuperPathType(CFSTR s) throw()
+{
+  if (IsSuperOrDevicePath(s))
+  {
+    #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+    if ((s)[2] != '.')
+      if (AreThereDotsFolders(s + kSuperPathPrefixSize))
+        return kSuperPathType_UseOnlySuper;
+    #endif
+    return kSuperPathType_UseOnlyMain;
+  }
+
+  for (unsigned i = 0;; i++)
+  {
+    FChar c = s[i];
+    if (c == 0)
+      return kSuperPathType_UseMainAndSuper;
+    if (c == '.' || c == ' ')
+    {
+      FChar c2 = s[i + 1];
+      if (c2 == 0 || IS_SEPAR(c2))
+      {
+        // if it's "." or "..", it's not bad name.
+        if (c == '.')
+        {
+          if (i == 0 || IS_SEPAR(s[i - 1]))
+            continue;
+          if (s[i - 1] == '.')
+          {
+            if (i - 1 == 0 || IS_SEPAR(s[i - 2]))
+              continue;
+          }
+        }
+        return kSuperPathType_UseOnlySuper;
+      }
+    }
+  }
+}
+
+
+/*
+   returns false in two cases:
+     - if GetCurDir was used, and GetCurDir returned error.
+     - if we can't resolve ".." name.
+   if path is ".", "..", res is empty.
+   if it's Super Path already, res is empty.
+   for \**** , and if GetCurDir is not drive (c:\), res is empty
+   for absolute paths, returns true, res is Super path.
+*/
+
+
+static bool GetSuperPathBase(CFSTR s, UString &res)
+{
+  res.Empty();
+  
+  FChar c = s[0];
+  if (c == 0)
+    return true;
+  if (c == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
+    return true;
+  
+  if (IsSuperOrDevicePath(s))
+  {
+    #ifdef LONG_PATH_DOTS_FOLDERS_PARSING
+    
+    if ((s)[2] == '.')
+      return true;
+
+    // we will return true here, so we will try to use these problem paths.
+
+    if (!AreThereDotsFolders(s + kSuperPathPrefixSize))
+      return true;
+    
+    UString temp = fs2us(s);
+    unsigned fixedSize = GetRootPrefixSize_Of_SuperPath(temp);
+    if (fixedSize == 0)
+      return true;
+
+    UString rem = &temp[fixedSize];
+    if (!ResolveDotsFolders(rem))
+      return true;
+
+    temp.DeleteFrom(fixedSize);
+    res += temp;
+    res += rem;
+    
+    #endif
+
+    return true;
+  }
+
+  if (IS_SEPAR(c))
+  {
+    if (IS_SEPAR(s[1]))
+    {
+      UString temp = fs2us(s + 2);
+      unsigned fixedSize = GetRootPrefixSize_Of_NetworkPath(temp);
+      // we ignore that error to allow short network paths server\share?
+      /*
+      if (fixedSize == 0)
+        return false;
+      */
+      UString rem = &temp[fixedSize];
+      if (!ResolveDotsFolders(rem))
+        return false;
+      res += kSuperUncPrefix;
+      temp.DeleteFrom(fixedSize);
+      res += temp;
+      res += rem;
+      return true;
+    }
+  }
+  else
+  {
+    if (IsDrivePath2(s))
+    {
+      UString temp = fs2us(s);
+      unsigned prefixSize = 2;
+      if (IsDrivePath(s))
+        prefixSize = kDrivePrefixSize;
+      UString rem = temp.Ptr(prefixSize);
+      if (!ResolveDotsFolders(rem))
+        return true;
+      res += kSuperPathPrefix;
+      temp.DeleteFrom(prefixSize);
+      res += temp;
+      res += rem;
+      return true;
+    }
+  }
+
+  UString curDir;
+  if (!GetCurDir(curDir))
+    return false;
+  NormalizeDirPathPrefix(curDir);
+
+  unsigned fixedSizeStart = 0;
+  unsigned fixedSize = 0;
+  const char *superMarker = NULL;
+  if (IsSuperPath(curDir))
+  {
+    fixedSize = GetRootPrefixSize_Of_SuperPath(curDir);
+    if (fixedSize == 0)
+      return false;
+  }
+  else
+  {
+    if (IsDrivePath(curDir))
+    {
+      superMarker = kSuperPathPrefix;
+      fixedSize = kDrivePrefixSize;
+    }
+    else
+    {
+      if (!IsPathSepar(curDir[0]) || !IsPathSepar(curDir[1]))
+        return false;
+      fixedSizeStart = 2;
+      fixedSize = GetRootPrefixSize_Of_NetworkPath(curDir.Ptr(2));
+      if (fixedSize == 0)
+        return false;
+      superMarker = kSuperUncPrefix;
+    }
+  }
+  
+  UString temp;
+  if (IS_SEPAR(c))
+  {
+    temp = fs2us(s + 1);
+  }
+  else
+  {
+    temp += &curDir[fixedSizeStart + fixedSize];
+    temp += fs2us(s);
+  }
+  if (!ResolveDotsFolders(temp))
+    return false;
+  if (superMarker)
+    res += superMarker;
+  res += curDir.Mid(fixedSizeStart, fixedSize);
+  res += temp;
+  return true;
+}
+
+
+/*
+  In that case if GetSuperPathBase doesn't return new path, we don't need
+  to use same path that was used as main path
+                        
+  GetSuperPathBase  superPath.IsEmpty() onlyIfNew
+     false            *                *          GetCurDir Error
+     true            false             *          use Super path
+     true            true             true        don't use any path, we already used mainPath
+     true            true             false       use main path as Super Path, we don't try mainMath
+                                                  That case is possible now if GetCurDir returns unknow
+                                                  type of path (not drive and not network)
+
+  We can change that code if we want to try mainPath, if GetSuperPathBase returns error,
+  and we didn't try mainPath still.
+  If we want to work that way, we don't need to use GetSuperPathBase return code.
+*/
+
+bool GetSuperPath(CFSTR path, UString &superPath, bool onlyIfNew)
+{
+  if (GetSuperPathBase(path, superPath))
+  {
+    if (superPath.IsEmpty())
+    {
+      // actually the only possible when onlyIfNew == true and superPath is empty
+      // is case when
+
+      if (onlyIfNew)
+        return false;
+      superPath = fs2us(path);
+    }
+    return true;
+  }
+  return false;
+}
+
+bool GetSuperPaths(CFSTR s1, CFSTR s2, UString &d1, UString &d2, bool onlyIfNew)
+{
+  if (!GetSuperPathBase(s1, d1) ||
+      !GetSuperPathBase(s2, d2))
+    return false;
+  if (d1.IsEmpty() && d2.IsEmpty() && onlyIfNew)
+    return false;
+  if (d1.IsEmpty()) d1 = fs2us(s1);
+  if (d2.IsEmpty()) d2 = fs2us(s2);
+  return true;
+}
+
+
+/*
+// returns true, if we need additional use with New Super path.
+bool GetSuperPath(CFSTR path, UString &superPath)
+{
+  if (GetSuperPathBase(path, superPath))
+    return !superPath.IsEmpty();
+  return false;
+}
+*/
+#endif // WIN_LONG_PATH
+
+bool GetFullPath(CFSTR dirPrefix, CFSTR s, FString &res)
+{
+  res = s;
+
+  #ifdef UNDER_CE
+
+  if (!IS_SEPAR(s[0]))
+  {
+    if (!dirPrefix)
+      return false;
+    res = dirPrefix;
+    res += s;
+  }
+
+  #else
+
+  unsigned prefixSize = GetRootPrefixSize(s);
+  if (prefixSize != 0)
+  {
+    if (!AreThereDotsFolders(s + prefixSize))
+      return true;
+    
+    UString rem = fs2us(s + prefixSize);
+    if (!ResolveDotsFolders(rem))
+      return true; // maybe false;
+    res.DeleteFrom(prefixSize);
+    res += us2fs(rem);
+    return true;
+  }
+
+  /*
+  FChar c = s[0];
+  if (c == 0)
+    return true;
+  if (c == '.' && (s[1] == 0 || (s[1] == '.' && s[2] == 0)))
+    return true;
+  if (IS_SEPAR(c) && IS_SEPAR(s[1]))
+    return true;
+  if (IsDrivePath(s))
+    return true;
+  */
+
+  UString curDir;
+  if (dirPrefix)
+    curDir = fs2us(dirPrefix);
+  else
+  {
+    if (!GetCurDir(curDir))
+      return false;
+  }
+  NormalizeDirPathPrefix(curDir);
+
+  unsigned fixedSize = 0;
+
+  #ifdef _WIN32
+
+  if (IsSuperPath(curDir))
+  {
+    fixedSize = GetRootPrefixSize_Of_SuperPath(curDir);
+    if (fixedSize == 0)
+      return false;
+  }
+  else
+  {
+    if (IsDrivePath(curDir))
+      fixedSize = kDrivePrefixSize;
+    else
+    {
+      if (!IsPathSepar(curDir[0]) || !IsPathSepar(curDir[1]))
+        return false;
+      fixedSize = GetRootPrefixSize_Of_NetworkPath(curDir.Ptr(2));
+      if (fixedSize == 0)
+        return false;
+      fixedSize += 2;
+    }
+  }
+
+  #endif // _WIN32
+  
+  UString temp;
+  if (IS_SEPAR(s[0]))
+  {
+    temp = fs2us(s + 1);
+  }
+  else
+  {
+    temp += curDir.Ptr(fixedSize);
+    temp += fs2us(s);
+  }
+  if (!ResolveDotsFolders(temp))
+    return false;
+  curDir.DeleteFrom(fixedSize);
+  res = us2fs(curDir);
+  res += us2fs(temp);
+  
+  #endif // UNDER_CE
+
+  return true;
+}
+
+bool GetFullPath(CFSTR path, FString &fullPath)
+{
+  return GetFullPath(NULL, path, fullPath);
+}
+
+}}}

versions/19.00/CPP/Windows/FileName.h

@@ -0,0 +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

versions/19.00/CPP/Windows/FileSystem.cpp

@@ -0,0 +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

versions/19.00/CPP/Windows/FileSystem.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Handle.h

@@ -0,0 +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

versions/19.00/CPP/Windows/MemoryGlobal.cpp

@@ -0,0 +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;
+}
+
+}}

versions/19.00/CPP/Windows/MemoryGlobal.h

@@ -0,0 +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

versions/19.00/CPP/Windows/MemoryLock.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/MemoryLock.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Menu.cpp

@@ -0,0 +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
+
+}

versions/19.00/CPP/Windows/Menu.h

@@ -0,0 +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

versions/19.00/CPP/Windows/NationalTime.cpp

@@ -0,0 +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);
+}
+
+}}}

versions/19.00/CPP/Windows/NationalTime.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Net.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/Net.h

@@ -0,0 +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

versions/19.00/CPP/Windows/NtCheck.h

@@ -0,0 +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

versions/19.00/CPP/Windows/ProcessMessages.cpp

@@ -0,0 +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);
+    }
+  }
+}
+
+}

versions/19.00/CPP/Windows/ProcessMessages.h

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

versions/19.00/CPP/Windows/ProcessUtils.cpp

@@ -0,0 +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);
+}
+
+}

versions/19.00/CPP/Windows/ProcessUtils.h

@@ -0,0 +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

versions/19.00/CPP/Windows/PropVariant.cpp

@@ -0,0 +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;
+  }
+}
+
+}}

versions/19.00/CPP/Windows/PropVariant.h

@@ -0,0 +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

versions/19.00/CPP/Windows/PropVariantConv.cpp

@@ -0,0 +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);
+  }
+}

versions/19.00/CPP/Windows/PropVariantConv.h

@@ -0,0 +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

versions/19.00/CPP/Windows/PropVariantUtils.cpp

@@ -0,0 +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);
+}

versions/19.00/CPP/Windows/PropVariantUtils.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Registry.cpp

@@ -0,0 +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;
+}
+
+}}

versions/19.00/CPP/Windows/Registry.h

@@ -0,0 +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

versions/19.00/CPP/Windows/ResourceString.cpp

@@ -0,0 +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);
+}
+
+}

versions/19.00/CPP/Windows/ResourceString.h

@@ -0,0 +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

versions/19.00/CPP/Windows/SecurityUtils.cpp

@@ -0,0 +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;
+}
+
+}}

versions/19.00/CPP/Windows/SecurityUtils.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Shell.cpp

@@ -0,0 +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
+
+}}

versions/19.00/CPP/Windows/Shell.h

@@ -0,0 +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

versions/19.00/CPP/Windows/StdAfx.h

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

versions/19.00/CPP/Windows/Synchronization.cpp

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

versions/19.00/CPP/Windows/Synchronization.h

@@ -0,0 +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

versions/19.00/CPP/Windows/System.cpp

@@ -0,0 +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
+}
+
+}}

versions/19.00/CPP/Windows/System.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Thread.h

@@ -0,0 +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

versions/19.00/CPP/Windows/TimeUtils.cpp

@@ -0,0 +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
+}
+
+}}

versions/19.00/CPP/Windows/TimeUtils.h

@@ -0,0 +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

versions/19.00/CPP/Windows/Window.cpp

@@ -0,0 +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;
+}
+*/
+
+}

versions/19.00/CPP/Windows/Window.h

@@ -0,0 +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