react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/Control/Dialog.cpp

@@ -0,0 +1,446 @@
+// Windows/Control/Dialog.cpp
+
+#include "StdAfx.h"
+
+// #include "../../Windows/DLL.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
+#ifdef Z7_OLD_WIN_SDK
+  BOOL
+#else
+  INT_PTR
+#endif
+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);
+
+  /* MSDN: The dialog box procedure should return
+       TRUE  - if it processed the message
+       FALSE - if it did not process the message
+     If the dialog box procedure returns FALSE,
+     the dialog manager performs the default dialog operation in response to the message.
+  */
+
+  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(HIWORD(wParam), LOWORD(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_DESTROY: return OnDestroy();
+    case WM_HELP: OnHelp(); return true;
+    /*
+        OnHelp(
+          #ifdef UNDER_CE
+          (void *)
+          #else
+          (LPHELPINFO)
+          #endif
+          lParam);
+        return true;
+    */
+    default: return false;
+  }
+}
+
+/*
+bool CDialog::OnCommand2(WPARAM wParam, LPARAM lParam)
+{
+  return OnCommand(HIWORD(wParam), LOWORD(wParam), lParam);
+}
+*/
+
+bool CDialog::OnCommand(unsigned code, unsigned itemID, LPARAM lParam)
+{
+  if (code == BN_CLICKED)
+    return OnButtonClicked(itemID, (HWND)lParam);
+  return false;
+}
+
+bool CDialog::OnButtonClicked(unsigned buttonID, HWND /* buttonHWND */)
+{
+  switch (buttonID)
+  {
+    case IDOK: OnOK(); break;
+    case IDCANCEL: OnCancel(); break;
+    case IDCLOSE: OnClose(); break;
+    case IDCONTINUE: OnContinue(); break;
+    case IDHELP: OnHelp(); break;
+    default: return false;
+  }
+  return true;
+}
+
+#ifndef UNDER_CE
+/* in win2000/win98 : monitor functions are supported.
+   We need dynamic linking, if we want nt4/win95 support in program.
+   Even if we compile the code with low (WINVER) value, we still
+   want to use monitor functions. So we declare missing functions here */
+// #if (WINVER < 0x0500)
+#ifndef MONITOR_DEFAULTTOPRIMARY
+extern "C" {
+DECLARE_HANDLE(HMONITOR);
+#define MONITOR_DEFAULTTOPRIMARY    0x00000001
+typedef struct tagMONITORINFO
+{
+    DWORD   cbSize;
+    RECT    rcMonitor;
+    RECT    rcWork;
+    DWORD   dwFlags;
+} MONITORINFO, *LPMONITORINFO;
+WINUSERAPI HMONITOR WINAPI MonitorFromWindow(HWND hwnd, DWORD dwFlags);
+WINUSERAPI BOOL WINAPI GetMonitorInfoA(HMONITOR hMonitor, LPMONITORINFO lpmi);
+}
+#endif
+#endif
+
+static bool GetWorkAreaRect(RECT *rect, HWND hwnd)
+{
+  if (hwnd)
+  {
+    #ifndef UNDER_CE
+    /* MonitorFromWindow() is supported in Win2000+
+       MonitorFromWindow() : retrieves a handle to the display monitor that has the
+         largest area of intersection with the bounding rectangle of a specified window.
+       dwFlags: Determines the function's return value if the window does not intersect any display monitor.
+         MONITOR_DEFAULTTONEAREST : Returns display that is nearest to the window.
+         MONITOR_DEFAULTTONULL    : Returns NULL.
+         MONITOR_DEFAULTTOPRIMARY : Returns the primary display monitor.
+    */
+    const HMONITOR hmon = MonitorFromWindow(hwnd, MONITOR_DEFAULTTOPRIMARY);
+    if (hmon)
+    {
+      MONITORINFO mi;
+      memset(&mi, 0, sizeof(mi));
+      mi.cbSize = sizeof(mi);
+      if (GetMonitorInfoA(hmon, &mi))
+      {
+        *rect = mi.rcWork;
+        return true;
+      }
+    }
+    #endif
+  }
+
+  /* Retrieves the size of the work area on the primary display monitor.
+     The work area is the portion of the screen not obscured
+     by the system taskbar or by application desktop toolbars.
+     Any DPI virtualization mode of the caller has no effect on this output. */
+
+  return BOOLToBool(::SystemParametersInfo(SPI_GETWORKAREA, 0, rect, 0));
+}
+
+
+bool IsDialogSizeOK(int xSize, int ySize, HWND hwnd)
+{
+  // it returns for system font. Real font uses another values
+  const LONG v = GetDialogBaseUnits();
+  const int x = LOWORD(v);
+  const int y = HIWORD(v);
+
+  RECT rect;
+  GetWorkAreaRect(&rect, hwnd);
+  const int wx = RECT_SIZE_X(rect);
+  const 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(unsigned 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(unsigned id, RECT &rect)
+{
+  ::GetWindowRect(GetItem(id), &rect);
+  ScreenToClient(&rect);
+}
+
+bool CDialog::MoveItem(unsigned id, int x, int y, int width, int height, bool repaint)
+{
+  return BOOLToBool(::MoveWindow(GetItem(id), x, y, width, height, BoolToBOOL(repaint)));
+}
+
+
+/*
+typedef BOOL (WINAPI * Func_DwmGetWindowAttribute)(
+    HWND hwnd, DWORD dwAttribute, PVOID pvAttribute, DWORD cbAttribute);
+
+static bool GetWindowsRect_DWM(HWND hwnd, RECT *rect)
+{
+  // dll load and free is too slow : 300 calls in second.
+  NDLL::CLibrary dll;
+  if (!dll.Load(FTEXT("dwmapi.dll")))
+    return false;
+  Func_DwmGetWindowAttribute f = (Func_DwmGetWindowAttribute)dll.GetProc("DwmGetWindowAttribute" );
+  if (f)
+  {
+    #define MY__DWMWA_EXTENDED_FRAME_BOUNDS 9
+    // 30000 per second
+    RECT r;
+    if (f(hwnd, MY__DWMWA_EXTENDED_FRAME_BOUNDS, &r, sizeof(RECT)) == S_OK)
+    {
+      *rect = r;
+      return true;
+    }
+  }
+  return false;
+}
+*/
+
+
+static bool IsRect_Small_Inside_Big(const RECT &sm, const RECT &big)
+{
+  return sm.left   >= big.left
+      && sm.right  <= big.right
+      && sm.top    >= big.top
+      && sm.bottom <= big.bottom;
+}
+
+
+static bool AreRectsOverlapped(const RECT &r1, const RECT &r2)
+{
+  return r1.left   < r2.right
+      && r1.right  > r2.left
+      && r1.top    < r2.bottom
+      && r1.bottom > r2.top;
+}
+
+
+static bool AreRectsEqual(const RECT &r1, const RECT &r2)
+{
+  return r1.left   == r2.left
+      && r1.right  == r2.right
+      && r1.top    == r2.top
+      && r1.bottom == r2.bottom;
+}
+
+
+void CDialog::NormalizeSize(bool fullNormalize)
+{
+  RECT workRect;
+  if (!GetWorkAreaRect(&workRect, *this))
+    return;
+  RECT rect;
+  if (!GetWindowRect(&rect))
+    return;
+  int xs = RECT_SIZE_X(rect);
+  int ys = RECT_SIZE_Y(rect);
+
+  // we don't want to change size using workRect, if window is outside of WorkArea
+  if (!AreRectsOverlapped(rect, workRect))
+    return;
+
+  /* here rect and workRect are overlapped, but it can be false
+     overlapping of small shadow when window in another display. */
+
+  const int xsW = RECT_SIZE_X(workRect);
+  const int ysW = RECT_SIZE_Y(workRect);
+  if (xs <= xsW && ys <= ysW)
+    return; // size of window is OK
+  if (fullNormalize)
+  {
+    Show(SW_SHOWMAXIMIZED);
+    return;
+  }
+  int x = workRect.left;
+  int y = workRect.top;
+  if (xs < xsW)  x += (xsW - xs) / 2;  else xs = xsW;
+  if (ys < ysW)  y += (ysW - ys) / 2;  else ys = ysW;
+  Move(x, y, xs, ys, true);
+}
+
+
+void CDialog::NormalizePosition()
+{
+  RECT workRect;
+  if (!GetWorkAreaRect(&workRect, *this))
+    return;
+
+  RECT rect2 = workRect;
+  bool useWorkArea = true;
+  const HWND parentHWND = GetParent();
+
+  if (parentHWND)
+  {
+    RECT workRectParent;
+    if (!GetWorkAreaRect(&workRectParent, parentHWND))
+      return;
+
+    // if windows are in different monitors, we use only workArea of current window
+
+    if (AreRectsEqual(workRectParent, workRect))
+    {
+      // RECT rect3; if (GetWindowsRect_DWM(parentHWND, &rect3)) {}
+      CWindow wnd(parentHWND);
+      if (wnd.GetWindowRect(&rect2))
+      {
+        // it's same monitor. So we try to use parentHWND rect.
+        /* we don't want to change position, if parent window is not inside work area.
+           In Win10 : parent window rect is 8 pixels larger for each corner than window size for shadow.
+           In maximize mode : window is outside of workRect.
+           if parent window is inside workRect, we will use parent window instead of workRect */
+        if (IsRect_Small_Inside_Big(rect2, workRect))
+          useWorkArea = false;
+      }
+    }
+  }
+
+  RECT rect;
+  if (!GetWindowRect(&rect))
+    return;
+
+  if (useWorkArea)
+  {
+    // we don't want to move window, if it's already inside.
+    if (IsRect_Small_Inside_Big(rect, workRect))
+      return;
+    // we don't want to move window, if it's outside of workArea
+    if (!AreRectsOverlapped(rect, workRect))
+      return;
+    rect2 = workRect;
+  }
+
+  {
+    const int xs = RECT_SIZE_X(rect);
+    const int ys = RECT_SIZE_Y(rect);
+    const int xs2 = RECT_SIZE_X(rect2);
+    const int ys2 = RECT_SIZE_Y(rect2);
+    // we don't want to change position if parent is smaller.
+    if (xs <= xs2 && ys <= ys2)
+    {
+      const int x = rect2.left + (xs2 - xs) / 2;
+      const int y = rect2.top  + (ys2 - ys) / 2;
+
+      if (x != rect.left || y != rect.top)
+        Move(x, y, xs, ys, true);
+      // SetWindowPos(*this, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);
+      return;
+    }
+  }
+}
+
+
+
+bool CModelessDialog::Create(LPCTSTR templateName, HWND parentWindow)
+{
+  const HWND aHWND = CreateDialogParam(g_hInstance, templateName, parentWindow, DialogProcedure, (LPARAM)this);
+  if (!aHWND)
+    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
+
+}}

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/Control/Dialog.h

@@ -0,0 +1,213 @@
+// Windows/Control/Dialog.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_DIALOG_H
+#define ZIP7_INC_WINDOWS_CONTROL_DIALOG_H
+
+#include "../Window.h"
+
+namespace NWindows {
+namespace NControl {
+
+#ifndef IDCONTINUE
+#define IDCONTINUE 11
+#endif
+
+class CDialog: public CWindow
+{
+  // Z7_CLASS_NO_COPY(CDialog)
+public:
+  CDialog(HWND wnd = NULL): CWindow(wnd) {}
+  virtual ~CDialog() {}
+
+  HWND GetItem(unsigned itemID) const
+    { return GetDlgItem(_window, (int)itemID); }
+
+  bool EnableItem(unsigned itemID, bool enable) const
+    { return BOOLToBool(::EnableWindow(GetItem(itemID), BoolToBOOL(enable))); }
+
+  bool ShowItem(unsigned itemID, int cmdShow) const
+    { return BOOLToBool(::ShowWindow(GetItem(itemID), cmdShow)); }
+
+  bool ShowItem_Bool(unsigned itemID, bool show) const
+    { return ShowItem(itemID, show ? SW_SHOW: SW_HIDE); }
+
+  bool HideItem(unsigned itemID) const { return ShowItem(itemID, SW_HIDE); }
+
+  bool SetItemText(unsigned itemID, LPCTSTR s)
+    { return BOOLToBool(SetDlgItemText(_window, (int)itemID, s)); }
+
+  bool SetItemTextA(unsigned itemID, LPCSTR s)
+    { return BOOLToBool(SetDlgItemTextA(_window, (int)itemID, s)); }
+
+  bool SetItemText_Empty(unsigned itemID)
+    { return SetItemText(itemID, TEXT("")); }
+
+  #ifndef _UNICODE
+  bool SetItemText(unsigned itemID, LPCWSTR s)
+  {
+    CWindow window(GetItem(itemID));
+    return window.SetText(s);
+  }
+  #endif
+
+  UINT GetItemText(unsigned itemID, LPTSTR string, unsigned maxCount)
+    { return GetDlgItemText(_window, (int)itemID, string, (int)maxCount); }
+  #ifndef _UNICODE
+  /*
+  bool GetItemText(unsigned itemID, LPWSTR string, int maxCount)
+  {
+    CWindow window(GetItem(unsigned));
+    return window.GetText(string, maxCount);
+  }
+  */
+  #endif
+
+  bool GetItemText(unsigned itemID, UString &s)
+  {
+    CWindow window(GetItem(itemID));
+    return window.GetText(s);
+  }
+
+/*
+  bool SetItemInt(unsigned itemID, UINT value, bool isSigned)
+    { return BOOLToBool(SetDlgItemInt(_window, (int)itemID, value, BoolToBOOL(isSigned))); }
+*/
+  bool SetItemUInt(unsigned itemID, UINT value)
+    { return BOOLToBool(SetDlgItemInt(_window, (int)itemID, value, FALSE)); }
+/*
+  bool GetItemInt(unsigned itemID, bool isSigned, UINT &value)
+  {
+    BOOL result;
+    value = GetDlgItemInt(_window, (int)itemID, &result, BoolToBOOL(isSigned));
+    return BOOLToBool(result);
+  }
+*/
+  bool GetItemUInt(unsigned itemID, UINT &value)
+  {
+    BOOL result;
+    value = GetDlgItemInt(_window, (int)itemID, &result, FALSE);
+    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)); }
+
+  LRESULT SendMsg_NextDlgCtl(WPARAM wParam, LPARAM lParam)
+    { return SendMsg(WM_NEXTDLGCTL, wParam, lParam); }
+  LRESULT SendMsg_NextDlgCtl_HWND(HWND hwnd) { return SendMsg_NextDlgCtl((WPARAM)hwnd, TRUE); }
+  LRESULT SendMsg_NextDlgCtl_CtlId(unsigned id)   { return SendMsg_NextDlgCtl_HWND(GetItem(id)); }
+  LRESULT SendMsg_NextDlgCtl_Next()          { return SendMsg_NextDlgCtl(0, FALSE); }
+  LRESULT SendMsg_NextDlgCtl_Prev()          { return SendMsg_NextDlgCtl(1, FALSE); }
+
+  bool MapRect(LPRECT rect)
+    { return BOOLToBool(MapDialogRect(_window, rect)); }
+
+  bool IsMessage(LPMSG message)
+    { return BOOLToBool(IsDialogMessage(_window, message)); }
+
+  LRESULT SendItemMessage(unsigned itemID, UINT message, WPARAM wParam, LPARAM lParam)
+    { return SendDlgItemMessage(_window, (int)itemID, message, wParam, lParam); }
+
+  bool CheckButton(unsigned buttonID, UINT checkState)
+    { return BOOLToBool(CheckDlgButton(_window, (int)buttonID, checkState)); }
+  bool CheckButton(unsigned buttonID, bool checkState)
+    { return CheckButton(buttonID, UINT(checkState ? BST_CHECKED : BST_UNCHECKED)); }
+
+  UINT IsButtonChecked_BST(unsigned buttonID) const
+    { return IsDlgButtonChecked(_window, (int)buttonID); }
+  bool IsButtonCheckedBool(unsigned buttonID) const
+    { return (IsButtonChecked_BST(buttonID) == BST_CHECKED); }
+
+  bool CheckRadioButton(unsigned firstButtonID, unsigned lastButtonID, unsigned checkButtonID)
+    { return BOOLToBool(::CheckRadioButton(_window,
+        (int)firstButtonID, (int)lastButtonID, (int)checkButtonID)); }
+
+  virtual bool OnMessage(UINT message, WPARAM wParam, LPARAM lParam);
+  virtual bool OnInit() { return true; }
+  // virtual bool OnCommand2(WPARAM wParam, LPARAM lParam);
+  virtual bool OnCommand(unsigned code, unsigned itemID, LPARAM lParam);
+  virtual bool OnSize(WPARAM /* wParam */, int /* xSize */, int /* ySize */) { return false; }
+  virtual bool OnDestroy() { return false; }
+
+  /*
+  #ifdef UNDER_CE
+  virtual void OnHelp(void *) { OnHelp(); }
+  #else
+  virtual void OnHelp(LPHELPINFO) { OnHelp(); }
+  #endif
+  */
+  virtual void OnHelp() {}
+
+  virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND);
+  virtual void OnOK() {}
+  virtual void OnContinue() {}
+  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(unsigned id, int &x, int &y);
+  void GetClientRectOfItem(unsigned id, RECT &rect);
+  bool MoveItem(unsigned id, int x, int y, int width, int height, bool repaint = true);
+  bool MoveItem_RECT(unsigned id, const RECT &r, bool repaint = true)
+    { return MoveItem(id, r.left, r.top, RECT_SIZE_X(r), RECT_SIZE_Y(r), repaint); }
+
+  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() Z7_override { Destroy(); }
+  virtual void OnContinue() Z7_override { Destroy(); }
+  virtual void OnCancel() Z7_override { Destroy(); }
+  virtual void OnClose() Z7_override { 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() Z7_override { End(IDOK); }
+  virtual void OnContinue() Z7_override { End(IDCONTINUE); }
+  virtual void OnCancel() Z7_override { End(IDCANCEL); }
+  virtual void OnClose() Z7_override { End(IDCLOSE); }
+};
+
+class CDialogChildControl: public NWindows::CWindow
+{
+  // unsigned m_ID;
+public:
+  void Init(const NWindows::NControl::CDialog &parentDialog, unsigned id)
+  {
+    // m_ID = id;
+    Attach(parentDialog.GetItem(id));
+  }
+};
+
+bool IsDialogSizeOK(int xSize, int ySize, HWND hwnd = NULL);
+
+}}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/Control/Edit.h

@@ -0,0 +1,19 @@
+// Windows/Control/Edit.h
+
+#ifndef ZIP7_INC_WINDOWS_CONTROL_EDIT_H
+#define ZIP7_INC_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

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/Control/ImageList.cpp

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