Merge branch 'master' into Sync-weave

21 files changed, 1682 insertions, 0 deletions

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ComboBox.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/ComboBox.cpp
new file mode 100644
index 000000000..6ab471712
--- /dev/null
+++ b/other-licenses/7zstub/src/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

+

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ComboBox.h b/other-licenses/7zstub/src/CPP/Windows/Control/ComboBox.h
new file mode 100644
index 000000000..3439655fe
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/CommandBar.h b/other-licenses/7zstub/src/CPP/Windows/Control/CommandBar.h
new file mode 100644
index 000000000..c4355680a
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.cpp
new file mode 100644
index 000000000..8e61a2b2c
--- /dev/null
+++ b/other-licenses/7zstub/src/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

+

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.h b/other-licenses/7zstub/src/CPP/Windows/Control/Dialog.h
new file mode 100644
index 000000000..f9c3442fd
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Edit.h b/other-licenses/7zstub/src/CPP/Windows/Control/Edit.h
new file mode 100644
index 000000000..4f503aa7a
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ImageList.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/ImageList.cpp
new file mode 100644
index 000000000..d201c8fd7
--- /dev/null
+++ b/other-licenses/7zstub/src/CPP/Windows/Control/ImageList.cpp
@@ -0,0 +1,10 @@
+// Windows/Control/ImageList.cpp

+

+#include "StdAfx.h"

+

+#include "ImageList.h"

+

+namespace NWindows {

+namespace NControl {

+

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ImageList.h b/other-licenses/7zstub/src/CPP/Windows/Control/ImageList.h
new file mode 100644
index 000000000..f72ea0d19
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ListView.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/ListView.cpp
new file mode 100644
index 000000000..fb22f95c1
--- /dev/null
+++ b/other-licenses/7zstub/src/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;

+}

+*/

+  

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ListView.h b/other-licenses/7zstub/src/CPP/Windows/Control/ListView.h
new file mode 100644
index 000000000..1ed496d7e
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ProgressBar.h b/other-licenses/7zstub/src/CPP/Windows/Control/ProgressBar.h
new file mode 100644
index 000000000..f18d89c14
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/PropertyPage.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/PropertyPage.cpp
new file mode 100644
index 000000000..48947c018
--- /dev/null
+++ b/other-licenses/7zstub/src/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);

+  }

+}

+

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/PropertyPage.h b/other-licenses/7zstub/src/CPP/Windows/Control/PropertyPage.h
new file mode 100644
index 000000000..551c95994
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ReBar.h b/other-licenses/7zstub/src/CPP/Windows/Control/ReBar.h
new file mode 100644
index 000000000..26fa31105
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Static.h b/other-licenses/7zstub/src/CPP/Windows/Control/Static.h
new file mode 100644
index 000000000..936dd3c88
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/StatusBar.h b/other-licenses/7zstub/src/CPP/Windows/Control/StatusBar.h
new file mode 100644
index 000000000..7f7d66b0b
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/StdAfx.h b/other-licenses/7zstub/src/CPP/Windows/Control/StdAfx.h
new file mode 100644
index 000000000..42a088f12
--- /dev/null
+++ b/other-licenses/7zstub/src/CPP/Windows/Control/StdAfx.h
@@ -0,0 +1,8 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+#include "../../Common/Common.h"

+

+#endif

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/ToolBar.h b/other-licenses/7zstub/src/CPP/Windows/Control/ToolBar.h
new file mode 100644
index 000000000..02ed9a142
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Trackbar.h b/other-licenses/7zstub/src/CPP/Windows/Control/Trackbar.h
new file mode 100644
index 000000000..afc9bf25c
--- /dev/null
+++ b/other-licenses/7zstub/src/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

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Window2.cpp b/other-licenses/7zstub/src/CPP/Windows/Control/Window2.cpp
new file mode 100644
index 000000000..b6e6d67da
--- /dev/null
+++ b/other-licenses/7zstub/src/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;

+}

+

+*/

+

+}}

diff --git a/other-licenses/7zstub/src/CPP/Windows/Control/Window2.h b/other-licenses/7zstub/src/CPP/Windows/Control/Window2.h
new file mode 100644
index 000000000..d632b86fe
--- /dev/null
+++ b/other-licenses/7zstub/src/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