7zip-native 0.0.0-stage → 0.0.5

package/vendor/7zip/CPP/Windows/Control/ImageList.h

@@ -0,0 +1,87 @@
+// Windows/Control/ImageList.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_IMAGE_LIST_H
+#define ZIP7_INC_WINDOWS_CONTROL_IMAGE_LIST_H
+
+#include <CommCtrl.h>
+
+#include "../WinDefs.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 = NULL)
+    { 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

package/vendor/7zip/CPP/Windows/Control/ListView.cpp

@@ -0,0 +1,162 @@
+// 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);
+}
+
+/* note: LVITEM and LVCOLUMN structures contain optional fields
+   depending from preprocessor macros:
+      #if (_WIN32_IE >= 0x0300)
+      #if (_WIN32_WINNT >= 0x0501)
+      #if (_WIN32_WINNT >= 0x0600)
+*/
+
+bool CListView::GetItemParam(unsigned index, LPARAM &param) const
+{
+  LVITEM item;
+  item.iItem = (int)index;
+  item.iSubItem = 0;
+  item.mask = LVIF_PARAM;
+  const bool res = GetItem(&item);
+  param = item.lParam;
+  return res;
+}
+
+int CListView::InsertColumn(unsigned columnIndex, LPCTSTR text, int width)
+{
+  LVCOLUMN ci;
+  ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
+  ci.pszText = (LPTSTR)(void *)text;
+  ci.iSubItem = (int)columnIndex;
+  ci.cx = width;
+  return InsertColumn(columnIndex, &ci);
+}
+
+int CListView::InsertItem(unsigned index, LPCTSTR text)
+{
+  LVITEM item;
+  item.mask = LVIF_TEXT | LVIF_PARAM;
+  item.iItem = (int)index;
+  item.lParam = (LPARAM)index;
+  item.pszText = (LPTSTR)(void *)text;
+  item.iSubItem = 0;
+  return InsertItem(&item);
+}
+
+int CListView::SetSubItem(unsigned index, unsigned subIndex, LPCTSTR text)
+{
+  LVITEM item;
+  item.mask = LVIF_TEXT;
+  item.iItem = (int)index;
+  item.pszText = (LPTSTR)(void *)text;
+  item.iSubItem = (int)subIndex;
+  return SetItem(&item);
+}
+
+#ifndef _UNICODE
+
+int CListView::InsertColumn(unsigned columnIndex, LPCWSTR text, int width)
+{
+  LVCOLUMNW ci;
+  ci.mask = LVCF_TEXT | LVCF_WIDTH | LVCF_SUBITEM;
+  ci.pszText = (LPWSTR)(void *)text;
+  ci.iSubItem = (int)columnIndex;
+  ci.cx = width;
+  return InsertColumn(columnIndex, &ci);
+}
+
+int CListView::InsertItem(unsigned index, LPCWSTR text)
+{
+  LVITEMW item;
+  item.mask = LVIF_TEXT | LVIF_PARAM;
+  item.iItem = (int)index;
+  item.lParam = (LPARAM)index;
+  item.pszText = (LPWSTR)(void *)text;
+  item.iSubItem = 0;
+  return InsertItem(&item);
+}
+
+int CListView::SetSubItem(unsigned index, unsigned subIndex, LPCWSTR text)
+{
+  LVITEMW item;
+  item.mask = LVIF_TEXT;
+  item.iItem = (int)index;
+  item.pszText = (LPWSTR)(void *)text;
+  item.iSubItem = (int)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;
+}
+*/
+  
+}}

package/vendor/7zip/CPP/Windows/Control/ListView.h

@@ -0,0 +1,156 @@
+// Windows/Control/ListView.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_LISTVIEW_H
+#define ZIP7_INC_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(unsigned columnIndex) { return BOOLToBool(ListView_DeleteColumn(_window, columnIndex)); }
+
+  int InsertColumn(unsigned columnIndex, const LVCOLUMN *columnInfo) { return ListView_InsertColumn(_window, columnIndex, columnInfo); }
+  int InsertColumn(unsigned columnIndex, LPCTSTR text, int width);
+  bool SetColumnOrderArray(unsigned count, const int *columns)
+    { return BOOLToBool(ListView_SetColumnOrderArray(_window, count, (int *)(void *)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(unsigned index, LPCTSTR text);
+  bool SetItem(const LVITEM* item) { return BOOLToBool(ListView_SetItem(_window, item)); }
+  int SetSubItem(unsigned index, unsigned subIndex, LPCTSTR text);
+
+  #ifndef _UNICODE
+
+  int InsertColumn(unsigned columnIndex, const LVCOLUMNW *columnInfo) { return (int)SendMsg(LVM_INSERTCOLUMNW, (WPARAM)columnIndex, (LPARAM)columnInfo); }
+  int InsertColumn(unsigned columnIndex, LPCWSTR text, int width);
+  int InsertItem(const LV_ITEMW* item) { return (int)SendMsg(LVM_INSERTITEMW, 0, (LPARAM)item); }
+  int InsertItem(unsigned index, LPCWSTR text);
+  bool SetItem(const LV_ITEMW* item) { return BOOLToBool((BOOL)SendMsg(LVM_SETITEMW, 0, (LPARAM)item)); }
+  int SetSubItem(unsigned index, unsigned subIndex, LPCWSTR text);
+
+  #endif
+
+  bool DeleteItem(unsigned 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(unsigned numItems) { ListView_SetItemCount(_window, numItems); }
+  void SetItemCountEx(unsigned numItems, DWORD flags) {  ListView_SetItemCountEx(_window, numItems, flags); }
+
+  /* startIndex : The index of the item with which to begin the search,
+     or -1 to find the first item that matches the specified flags.
+     The specified item itself is excluded from the search. */
+  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(unsigned itemIndex, LPARAM &param) const;
+  /*
+  void GetItemText(unsigned itemIndex, unsigned subItemIndex, LPTSTR text, unsigned textSizeMax) const
+    { ListView_GetItemText(_window, itemIndex, subItemIndex, text, textSizeMax) }
+  */
+  bool SortItems(PFNLVCOMPARE compareFunction, LPARAM dataParam)
+    { return BOOLToBool(ListView_SortItems(_window, compareFunction, dataParam)); }
+
+  // If (index == -1), then the state change is applied to all items.
+  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(unsigned 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;
+  // ~CListView2() ZIP7_eq_delete;
+public:
+  virtual ~CListView2() {}
+  CListView2() {}
+  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

package/vendor/7zip/CPP/Windows/Control/ProgressBar.h

@@ -0,0 +1,35 @@
+// Windows/Control/ProgressBar.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_PROGRESSBAR_H
+#define ZIP7_INC_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, (unsigned)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, (unsigned)minValue, (LPARAM)(unsigned)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, (LPARAM)color); }
+  COLORREF SetBackgroundColor(COLORREF color) { return (COLORREF)SendMsg(PBM_SETBKCOLOR, 0, (LPARAM)color); }
+  #endif
+};
+
+}}
+
+#endif

package/vendor/7zip/CPP/Windows/Control/PropertyPage.cpp

@@ -0,0 +1,165 @@
+// 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
+#ifdef Z7_OLD_WIN_SDK
+  BOOL
+#else
+  INT_PTR
+#endif
+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(OnApply2(LPPSHNOTIFY(lParam))); break;
+    case PSN_KILLACTIVE: SetMsgResult(BoolToBOOL(OnKillActive2(LPPSHNOTIFY(lParam)))); break;
+    case PSN_SETACTIVE: SetMsgResult(OnSetActive2(LPPSHNOTIFY(lParam))); break;
+    case PSN_RESET: OnReset2(LPPSHNOTIFY(lParam)); break;
+    case PSN_HELP: OnNotifyHelp2(LPPSHNOTIFY(lParam)); break;
+    default: return false;
+  }
+  return true;
+}
+
+/*
+PROPSHEETPAGE fields depend from
+#if   (_WIN32_WINNT >= 0x0600)
+#elif (_WIN32_WINNT >= 0x0501)
+#elif (_WIN32_IE >= 0x0400)
+PROPSHEETHEADER fields depend from
+#if (_WIN32_IE >= 0x0400)
+*/
+#if defined(PROPSHEETPAGEA_V1_SIZE) && !defined(Z7_OLD_WIN_SDK)
+#ifndef _UNICODE
+#define my_compatib_PROPSHEETPAGEA PROPSHEETPAGEA_V1
+#endif
+#define my_compatib_PROPSHEETPAGEW PROPSHEETPAGEW_V1
+#else
+// for old mingw:
+#ifndef _UNICODE
+#define my_compatib_PROPSHEETPAGEA PROPSHEETPAGEA
+#endif
+#define my_compatib_PROPSHEETPAGEW PROPSHEETPAGEW
+#endif
+
+INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title)
+{
+  unsigned i;
+  #ifndef _UNICODE
+  AStringVector titles;
+  for (i = 0; i < pagesInfo.Size(); i++)
+    titles.Add(GetSystemString(pagesInfo[i].Title));
+  CRecordVector<my_compatib_PROPSHEETPAGEA> pagesA;
+  #endif
+  CRecordVector<my_compatib_PROPSHEETPAGEW> pagesW;
+
+  for (i = 0; i < pagesInfo.Size(); i++)
+  {
+    const CPageInfo &pageInfo = pagesInfo[i];
+    #ifndef _UNICODE
+    {
+      my_compatib_PROPSHEETPAGEA page;
+      memset(&page, 0, sizeof(page));
+      page.dwSize = sizeof(page);
+      page.dwFlags = PSP_HASHELP;
+      page.hInstance = g_hInstance;
+      page.pszTemplate = MAKEINTRESOURCEA(pageInfo.ID);
+      // page.pszIcon = NULL;
+      page.pfnDlgProc = NWindows::NControl::MyProperyPageProcedure;
+      
+      if (!titles[i].IsEmpty())
+      {
+        page.pszTitle = titles[i];
+        page.dwFlags |= PSP_USETITLE;
+      }
+      // else page.pszTitle = NULL;
+      page.lParam = (LPARAM)pageInfo.Page;
+      // page.pfnCallback = NULL;
+      pagesA.Add(page);
+    }
+    #endif
+    {
+      my_compatib_PROPSHEETPAGEW page;
+      memset(&page, 0, sizeof(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 = pageInfo.Title;
+        page.dwFlags |= PSP_USETITLE;
+      }
+      // else page.pszTitle = NULL;
+      page.lParam = (LPARAM)pageInfo.Page;
+      // page.pfnCallback = NULL;
+      pagesW.Add(page);
+    }
+  }
+
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    PROPSHEETHEADERA 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 = pagesA.Size();
+    sheet.nStartPage = 0;
+    sheet.ppsp = (LPCPROPSHEETPAGEA)(const void *)pagesA.ConstData();
+    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 = pagesW.Size();
+    sheet.nStartPage = 0;
+    sheet.ppsp = (LPCPROPSHEETPAGEW)(const void *)pagesW.ConstData();
+    sheet.pfnCallback = NULL;
+    return ::PropertySheetW(&sheet);
+  }
+}
+
+}}

package/vendor/7zip/CPP/Windows/Control/PropertyPage.h

@@ -0,0 +1,50 @@
+// Windows/Control/PropertyPage.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_PROPERTYPAGE_H
+#define ZIP7_INC_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) Z7_override;
+
+  virtual bool OnKillActive() { return false; } // false = OK
+  virtual bool OnKillActive2(const PSHNOTIFY *) { return OnKillActive(); }
+  virtual LONG OnSetActive() { return false; } // false = OK
+  virtual LONG OnSetActive2(const PSHNOTIFY *) { return OnSetActive(); }
+  virtual LONG OnApply() { return PSNRET_NOERROR; }
+  virtual LONG OnApply2(const PSHNOTIFY *) { return OnApply(); }
+  virtual void OnNotifyHelp() {}
+  virtual void OnNotifyHelp2(const PSHNOTIFY *) { OnNotifyHelp(); }
+  virtual void OnReset() {}
+  virtual void OnReset2(const PSHNOTIFY *) { OnReset(); }
+};
+
+struct CPageInfo
+{
+  CPropertyPage *Page;
+  UString Title;
+  UINT ID;
+};
+
+INT_PTR MyPropertySheet(const CObjectVector<CPageInfo> &pagesInfo, HWND hwndParent, const UString &title);
+
+}}
+
+#endif

package/vendor/7zip/CPP/Windows/Control/ReBar.h

@@ -0,0 +1,34 @@
+// Windows/Control/ReBar.h
+  
+#ifndef ZIP7_INC_WINDOWS_CONTROL_REBAR_H
+#define ZIP7_INC_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, MY_int_TO_WPARAM(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