react-native-update 7.4.2 → 8.0.1

package/android/jni/lzma/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
+
+}}

package/android/jni/lzma/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

package/android/jni/lzma/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

package/android/jni/lzma/CPP/Windows/Control/ImageList.cpp

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

package/android/jni/lzma/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

package/android/jni/lzma/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;
+}
+*/
+  
+}}