react-native-update 10.34.2 → 10.34.3

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/ExtractCallback.h

@@ -0,0 +1,347 @@
+// ExtractCallback.h
+
+#ifndef ZIP7_INC_EXTRACT_CALLBACK_H
+#define ZIP7_INC_EXTRACT_CALLBACK_H
+
+#include "../../../../C/Alloc.h"
+
+#include "../../../Common/MyCom.h"
+#include "../../../Common/StringConvert.h"
+
+#ifndef Z7_SFX
+#include "../Agent/IFolderArchive.h"
+#endif
+
+#include "../Common/ArchiveExtractCallback.h"
+#include "../Common/ArchiveOpenCallback.h"
+
+#ifndef Z7_NO_CRYPTO
+#include "../../IPassword.h"
+#endif
+
+#ifndef Z7_SFX
+#include "IFolder.h"
+#endif
+
+#include "ProgressDialog2.h"
+
+#ifndef Z7_SFX
+
+class CGrowBuf
+{
+  Byte *_items;
+  size_t _size;
+
+  Z7_CLASS_NO_COPY(CGrowBuf)
+
+public:
+  void Free()
+  {
+    MyFree(_items);
+    _items = NULL;
+    _size = 0;
+  }
+
+  // newSize >= keepSize
+  bool ReAlloc_KeepData(size_t newSize, size_t keepSize)
+  {
+    void *buf = NULL;
+    if (newSize)
+    {
+      buf = MyAlloc(newSize);
+      if (!buf)
+        return false;
+    }
+    if (keepSize)
+      memcpy(buf, _items, keepSize);
+    MyFree(_items);
+    _items = (Byte *)buf;
+    _size = newSize;
+    return true;
+  }
+
+  CGrowBuf(): _items(NULL), _size(0) {}
+  ~CGrowBuf() { MyFree(_items); }
+
+  operator Byte *() { return _items; }
+  operator const Byte *() const { return _items; }
+  size_t Size() const { return _size; }
+};
+
+
+struct CVirtFile
+{
+  CGrowBuf Data;
+  
+  UInt64 ExpectedSize; // size from props request. 0 if unknown
+  size_t WrittenSize;  // size of written data in (Data) buffer
+                       //   use (WrittenSize) only if (CVirtFileSystem::_newVirtFileStream_IsReadyToWrite == false)
+  UString BaseName;    // original name of file inside archive,
+                       // It's not path. So any path separators
+                       // should be treated as part of name (or as incorrect chars)
+  UString AltStreamName;
+
+  bool CTime_Defined;
+  bool ATime_Defined;
+  bool MTime_Defined;
+  bool Attrib_Defined;
+  
+  // bool IsDir;
+  bool IsAltStream;
+  bool ColonWasUsed;
+  DWORD Attrib;
+
+  FILETIME CTime;
+  FILETIME ATime;
+  FILETIME MTime;
+
+  CVirtFile():
+    CTime_Defined(false),
+    ATime_Defined(false),
+    MTime_Defined(false),
+    Attrib_Defined(false),
+    // IsDir(false),
+    IsAltStream(false),
+    ColonWasUsed(false)
+    {}
+};
+
+
+/*
+  We use CVirtFileSystem only for single file extraction:
+  It supports the following cases and names:
+     - "fileName" : single file
+     - "fileName" item (main base file) and additional "fileName:altStream" items
+     - "altStream" : single item without "fileName:" prefix.
+  If file is flushed to disk, it uses Get_Correct_FsFile_Name(name).
+*/
+ 
+Z7_CLASS_IMP_NOQIB_1(
+  CVirtFileSystem,
+  ISequentialOutStream
+)
+  unsigned _numFlushed;
+public:
+  bool IsAltStreamFile; // in:
+      // = true,  if extracting file is alt stream without "fileName:" prefix.
+      // = false, if extracting file is normal file, but additional
+      //          alt streams "fileName:altStream" items are possible.
+private:
+  bool _newVirtFileStream_IsReadyToWrite;    // it can non real file (if can't open alt stream)
+  bool _needWriteToRealFile;  // we need real writing to open file.
+  bool _wasSwitchedToFsMode;
+  bool _altStream_NeedRestore_Attrib_bool;
+  DWORD _altStream_NeedRestore_AttribVal;
+
+  CMyComPtr2<ISequentialOutStream, COutFileStream> _outFileStream;
+public:
+  CObjectVector<CVirtFile> Files;
+  size_t MaxTotalAllocSize; // remain size, including Files.Back()
+  FString DirPrefix; // files will be flushed to this FS directory.
+  UString FileName; // name of file that will be extracted.
+                    // it can be name of alt stream without "fileName:" prefix, if (IsAltStreamFile == trye).
+                    // we use that name to detect altStream part in "FileName:altStream".
+  CByteBuffer ZoneBuf;
+  int Index_of_MainExtractedFile_in_Files; // out: index in Files. == -1, if expected file was not extracted
+  int Index_of_ZoneBuf_AltStream_in_Files; // out: index in Files. == -1, if no zonbuf alt stream
+  
+
+  CVirtFileSystem()
+  {
+    _numFlushed = 0;
+    IsAltStreamFile = false;
+    _newVirtFileStream_IsReadyToWrite = false;
+    _needWriteToRealFile = false;
+    _wasSwitchedToFsMode = false;
+    _altStream_NeedRestore_Attrib_bool = false;
+    MaxTotalAllocSize = (size_t)0 - 1;
+    Index_of_MainExtractedFile_in_Files = -1;
+    Index_of_ZoneBuf_AltStream_in_Files = -1;
+  }
+
+  bool WasStreamFlushedToFS() const { return _wasSwitchedToFsMode; }
+
+  HRESULT CloseMemFile()
+  {
+    if (_wasSwitchedToFsMode)
+      return FlushToDisk(true); // closeLast
+    CVirtFile &file = Files.Back();
+    if (file.Data.Size() != file.WrittenSize)
+      file.Data.ReAlloc_KeepData(file.WrittenSize, file.WrittenSize);
+    return S_OK;
+  }
+
+  HRESULT FlushToDisk(bool closeLast);
+};
+
+#endif
+  
+
+
+class CExtractCallbackImp Z7_final:
+  public IFolderArchiveExtractCallback,
+  /* IExtractCallbackUI:
+       before v23.00 : it         included IFolderArchiveExtractCallback
+       since  v23.00 : it doesn't include  IFolderArchiveExtractCallback
+  */
+  public IExtractCallbackUI, // NON-COM interface since 23.00
+  public IOpenCallbackUI,    // NON-COM interface
+  public IFolderArchiveExtractCallback2,
+ #ifndef Z7_SFX
+  public IFolderOperationsExtractCallback,
+  public IFolderExtractToStreamCallback,
+  public ICompressProgressInfo,
+  public IArchiveRequestMemoryUseCallback,
+ #endif
+ #ifndef Z7_NO_CRYPTO
+  public ICryptoGetTextPassword,
+ #endif
+  public CMyUnknownImp
+{
+  Z7_COM_QI_BEGIN2(IFolderArchiveExtractCallback)
+  Z7_COM_QI_ENTRY(IFolderArchiveExtractCallback2)
+ #ifndef Z7_SFX
+  Z7_COM_QI_ENTRY(IFolderOperationsExtractCallback)
+  Z7_COM_QI_ENTRY(IFolderExtractToStreamCallback)
+  Z7_COM_QI_ENTRY(ICompressProgressInfo)
+  Z7_COM_QI_ENTRY(IArchiveRequestMemoryUseCallback)
+ #endif
+ #ifndef Z7_NO_CRYPTO
+  Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
+ #endif
+  Z7_COM_QI_END
+  Z7_COM_ADDREF_RELEASE
+
+  Z7_IFACE_IMP(IExtractCallbackUI)
+  Z7_IFACE_IMP(IOpenCallbackUI)
+  Z7_IFACE_COM7_IMP(IProgress)
+  Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback)
+  Z7_IFACE_COM7_IMP(IFolderArchiveExtractCallback2)
+ #ifndef Z7_SFX
+  Z7_IFACE_COM7_IMP(IFolderOperationsExtractCallback)
+  Z7_IFACE_COM7_IMP(IFolderExtractToStreamCallback)
+  Z7_IFACE_COM7_IMP(ICompressProgressInfo)
+  Z7_IFACE_COM7_IMP(IArchiveRequestMemoryUseCallback)
+ #endif
+ #ifndef Z7_NO_CRYPTO
+  Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
+ #endif
+
+  bool _needWriteArchivePath;
+  bool _isFolder;
+  bool _totalFiles_Defined;
+  bool _totalBytes_Defined;
+public:
+  bool MultiArcMode;
+  bool ProcessAltStreams;
+  bool StreamMode; // set to true, if you want the callee to call GetStream7()
+  bool ThereAreMessageErrors;
+  bool Src_Is_IO_FS_Folder;
+
+#ifndef Z7_NO_CRYPTO
+  bool PasswordIsDefined;
+  bool PasswordWasAsked;
+#endif
+
+private:
+#ifndef Z7_SFX
+  bool _needUpdateStat;
+  bool _newVirtFileWasAdded;
+  bool _isAltStream;
+  // bool _extractMode;
+  // bool _testMode;
+  bool _hashStream_WasUsed;
+  bool _curSize_Defined;
+  bool NeedAddFile;
+
+  bool _remember;
+  bool _skipArc;
+#endif
+
+public:
+  bool YesToAll;
+  bool TestMode;
+
+  UInt32 NumArchiveErrors;
+  NExtract::NOverwriteMode::EEnum OverwriteMode;
+
+private:
+  UString _currentArchivePath;
+  UString _currentFilePath;
+  UString _filePath;  // virtual path than will be sent via IFolderExtractToStreamCallback
+
+#ifndef Z7_SFX
+  UInt64 _curSize;
+  CMyComPtr2<ISequentialOutStream, COutStreamWithHash> _hashStream;
+  IHashCalc *_hashCalc; // it's for stat in Test operation
+#endif
+
+public:
+  CProgressDialog *ProgressDialog;
+
+#ifndef Z7_SFX
+  CVirtFileSystem *VirtFileSystemSpec;
+  CMyComPtr<ISequentialOutStream> VirtFileSystem;
+  UInt64 NumFolders;
+  UInt64 NumFiles;
+#endif
+
+#ifndef Z7_NO_CRYPTO
+  UString Password;
+#endif
+
+  UString _lang_Extracting;
+  UString _lang_Testing;
+  UString _lang_Skipping;
+  UString _lang_Reading;
+  UString _lang_Empty;
+
+  CExtractCallbackImp():
+      _totalFiles_Defined(false)
+    , _totalBytes_Defined(false)
+    , MultiArcMode(false)
+    , ProcessAltStreams(true)
+    , StreamMode(false)
+    , ThereAreMessageErrors(false)
+    , Src_Is_IO_FS_Folder(false)
+#ifndef Z7_NO_CRYPTO
+    , PasswordIsDefined(false)
+    , PasswordWasAsked(false)
+#endif
+#ifndef Z7_SFX
+    , _remember(false)
+    , _skipArc(false)
+#endif
+    , YesToAll(false)
+    , TestMode(false)
+    , OverwriteMode(NExtract::NOverwriteMode::kAsk)
+#ifndef Z7_SFX
+    , _hashCalc(NULL)
+#endif
+    {}
+   
+  ~CExtractCallbackImp();
+  void Init();
+
+  HRESULT SetCurrentFilePath2(const wchar_t *filePath);
+  void AddError_Message(LPCWSTR message);
+  void AddError_Message_ShowArcPath(LPCWSTR message);
+  HRESULT MessageError(const char *message, const FString &path);
+  void Add_ArchiveName_Error();
+
+  #ifndef Z7_SFX
+  void SetHashCalc(IHashCalc *hashCalc) { _hashCalc = hashCalc; }
+
+  void SetHashMethods(IHashCalc *hash)
+  {
+    if (!hash)
+      return;
+    _hashStream.Create_if_Empty();
+    _hashStream->_hash = hash;
+  }
+  #endif
+
+  bool IsOK() const { return NumArchiveErrors == 0 && !ThereAreMessageErrors; }
+};
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/FormatUtils.cpp

@@ -0,0 +1,28 @@
+// FormatUtils.cpp
+
+#include "StdAfx.h"
+
+#include "../../../Common/IntToString.h"
+
+#include "FormatUtils.h"
+
+#include "LangUtils.h"
+
+UString NumberToString(UInt64 number)
+{
+  wchar_t numberString[32];
+  ConvertUInt64ToString(number, numberString);
+  return numberString;
+}
+
+UString MyFormatNew(const UString &format, const UString &argument)
+{
+  UString result = format;
+  result.Replace(L"{0}", argument);
+  return result;
+}
+
+UString MyFormatNew(UINT resourceID, const UString &argument)
+{
+  return MyFormatNew(LangString(resourceID), argument);
+}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/FormatUtils.h

@@ -0,0 +1,14 @@
+// FormatUtils.h
+
+#ifndef ZIP7_INC_FORMAT_UTILS_H
+#define ZIP7_INC_FORMAT_UTILS_H
+
+#include "../../../Common/MyTypes.h"
+#include "../../../Common/MyString.h"
+
+UString NumberToString(UInt64 number);
+
+UString MyFormatNew(const UString &format, const UString &argument);
+UString MyFormatNew(UINT resourceID, const UString &argument);
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/LangUtils.h

@@ -0,0 +1,48 @@
+// LangUtils.h
+
+#ifndef ZIP7_INC_LANG_UTILS_H
+#define ZIP7_INC_LANG_UTILS_H
+
+#include "../../../Common/Lang.h"
+
+#include "../../../Windows/ResourceString.h"
+
+extern UString g_LangID;
+extern CLang g_Lang;
+
+#ifdef Z7_LANG
+
+struct CIDLangPair
+{
+  UInt32 ControlID;
+  UInt32 LangID;
+};
+
+void ReloadLang();
+void LoadLangOneTime();
+
+void LangSetDlgItemText(HWND dialog, UInt32 controlID, UInt32 langID);
+void LangSetDlgItems(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetDlgItems_Colon(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetDlgItems_RemoveColon(HWND dialog, const UInt32 *ids, unsigned numItems);
+void LangSetWindowText(HWND window, UInt32 langID);
+
+UString LangString(UInt32 langID);
+void AddLangString(UString &s, UInt32 langID);
+void LangString(UInt32 langID, UString &dest);
+void LangString_OnlyFromLangFile(UInt32 langID, UString &dest);
+ 
+#else
+
+inline UString LangString(UInt32 langID) { return NWindows::MyLoadString(langID); }
+inline void LangString(UInt32 langID, UString &dest) { NWindows::MyLoadString(langID, dest); }
+inline void AddLangString(UString &s, UInt32 langID) { s += NWindows::MyLoadString(langID); }
+
+#endif
+
+FString GetLangDirPrefix();
+// bool LangOpen(CLang &lang, CFSTR fileName);
+
+void Lang_GetShortNames_for_DefaultLang(AStringVector &names, unsigned &subLang);
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/MemDialog.cpp

@@ -0,0 +1,218 @@
+// MemDialog.cpp
+
+#include "StdAfx.h"
+
+#include <CommCtrl.h>
+
+#include "MemDialog.h"
+
+#include "../../../Common/StringToInt.h"
+#include "../../../Windows/System.h"
+#include "../../../Windows/ErrorMsg.h"
+
+#include "../Explorer/MyMessages.h"
+#include "../GUI/ExtractRes.h"
+
+#include "resourceGui.h"
+
+#ifdef Z7_LANG
+#include "LangUtils.h"
+#endif
+
+#ifdef Z7_LANG
+static const UInt32 kLangIDs[] =
+{
+  IDX_MEM_SAVE_LIMIT,
+  IDX_MEM_REMEMBER,
+  IDG_MEM_ACTION,
+  IDR_MEM_ACTION_ALLOW,
+  IDR_MEM_ACTION_SKIP_ARC
+  // , IDR_MEM_SKIP_FILE
+};
+#endif
+
+static const unsigned k_Action_Buttons[] =
+{
+  IDR_MEM_ACTION_ALLOW,
+  IDR_MEM_ACTION_SKIP_ARC
+  // , IDR_MEM_SKIP_FILE
+};
+
+
+void CMemDialog::EnableSpin(bool enable)
+{
+  EnableItem(IDC_MEM_SPIN, enable);
+  EnableItem(IDE_MEM_SPIN_EDIT, enable);
+}
+
+
+static void AddSize_GB(UString &s, UInt32 size_GB, UInt32 id)
+{
+  s.Add_LF();
+  s += "    ";
+  s.Add_UInt32(size_GB);
+  s += " GB : ";
+  AddLangString(s, id);
+}
+
+void CMemDialog::AddInfoMessage_To_String(UString &s, const UInt32 *ramSize_GB)
+{
+  AddLangString(s, IDS_MEM_REQUIRES_BIG_MEM);
+  AddSize_GB(s, Required_GB, IDS_MEM_REQUIRED_MEM_SIZE);
+  AddSize_GB(s, Limit_GB, IDS_MEM_CURRENT_MEM_LIMIT);
+  if (ramSize_GB)
+    AddSize_GB(s, *ramSize_GB, IDS_MEM_RAM_SIZE);
+  if (!FilePath.IsEmpty())
+  {
+    s.Add_LF();
+    s += "File: ";
+    s += FilePath;
+  }
+}
+
+/*
+int CMemDialog::AddAction(UINT id)
+{
+  const int index = (int)m_Action.AddString(LangString(id));
+  m_Action.SetItemData(index, (LPARAM)id);
+  return index;
+}
+*/
+
+bool CMemDialog::OnInit()
+{
+  #ifdef Z7_LANG
+  LangSetWindowText(*this, IDD_MEM);
+  LangSetDlgItems(*this, kLangIDs, Z7_ARRAY_SIZE(kLangIDs));
+  #endif
+
+  // m_Action.Attach(GetItem(IDC_MEM_ACTION));
+
+  size_t ramSize = (size_t)sizeof(size_t) << 29;
+  const bool ramSize_defined = NWindows::NSystem::GetRamSize(ramSize);
+  // ramSize *= 10; // for debug
+
+  UInt32 ramSize_GB = (UInt32)(((UInt64)ramSize + (1u << 29)) >> 30);
+  if (ramSize_GB == 0)
+    ramSize_GB = 1;
+
+  const bool is_Allowed = (!ramSize_defined || ramSize > ((UInt64)Required_GB << 30));
+  {
+    UString s;
+    if (!is_Allowed)
+    {
+      AddLangString(s, IDS_MEM_ERROR);
+      s.Add_LF();
+    }
+    AddInfoMessage_To_String(s, is_Allowed ? NULL : &ramSize_GB);
+    if (!ArcPath.IsEmpty())
+    // for (int i = 0; i < 10; i++)
+    {
+      s.Add_LF();
+      AddLangString(s, TestMode ?
+          IDS_PROGRESS_TESTING :
+          IDS_PROGRESS_EXTRACTING);
+      s += ": ";
+      s += ArcPath;
+    }
+    SetItemText(IDT_MEM_MESSAGE, s);
+
+    s = "GB";
+    if (ramSize_defined)
+    {
+      s += " / ";
+      s.Add_UInt32(ramSize_GB);
+      s += " GB (RAM)";
+    }
+    SetItemText(IDT_MEM_GB, s);
+  }
+  const UINT valMin = 1;
+  UINT valMax = 64; // 64GB for RAR7
+  if (ramSize_defined /* && ramSize_GB > valMax */)
+  {
+    const UINT k_max_val = 1u << 14;
+    if (ramSize_GB >= k_max_val)
+      valMax = k_max_val;
+    else if (ramSize_GB > 1)
+      valMax = (UINT)ramSize_GB - 1;
+    else
+      valMax = 1;
+  }
+
+  SendItemMessage(IDC_MEM_SPIN, UDM_SETRANGE, 0, MAKELPARAM(valMax, valMin));    // Sets the controls direction
+  // UDM_SETPOS doesn't set value larger than max value (valMax) of range:
+  SendItemMessage(IDC_MEM_SPIN, UDM_SETPOS, 0, Required_GB);
+  {
+    UString s;
+    s.Add_UInt32(Required_GB);
+    SetItemText(IDE_MEM_SPIN_EDIT, s);
+  }
+
+  EnableSpin(false);
+
+  /*
+  AddAction(IDB_ALLOW_OPERATION);
+  m_Action.SetCurSel(0);
+  AddAction(IDB_MEM_SKIP_ARC);
+  AddAction(IDB_MEM_SKIP_FILE);
+  */
+
+  const UINT buttonId = is_Allowed ?
+      IDR_MEM_ACTION_ALLOW :
+      IDR_MEM_ACTION_SKIP_ARC;
+
+  CheckRadioButton(
+      k_Action_Buttons[0],
+      k_Action_Buttons[Z7_ARRAY_SIZE(k_Action_Buttons) - 1],
+      buttonId);
+  /*
+  if (!ShowSkipFile)
+    HideItem(IDR_MEM_SKIP_FILE);
+  */
+  if (!ShowRemember)
+    HideItem(IDX_MEM_REMEMBER);
+  return CModalDialog::OnInit();
+}
+
+
+bool CMemDialog::OnButtonClicked(unsigned buttonID, HWND buttonHWND)
+{
+  if (buttonID == IDX_MEM_SAVE_LIMIT)
+  {
+    EnableSpin(IsButtonCheckedBool(IDX_MEM_SAVE_LIMIT));
+    return true;
+  }
+  return CDialog::OnButtonClicked(buttonID, buttonHWND);
+}
+
+
+void CMemDialog::OnContinue()
+{
+  Remember = IsButtonCheckedBool(IDX_MEM_REMEMBER);
+  NeedSave = IsButtonCheckedBool(IDX_MEM_SAVE_LIMIT);
+  SkipArc  = IsButtonCheckedBool(IDR_MEM_ACTION_SKIP_ARC);
+  if (NeedSave)
+  {
+#if 0
+    // UDM_GETPOS doesn't support value outside of range that was set:
+    LRESULT lresult = SendItemMessage(IDC_MEM_SPIN, UDM_GETPOS, 0, 0);
+    const UInt32 val = LOWORD(lresult);
+    if (HIWORD(lresult) != 0) // the value outside of allowed range
+#else
+    UString s;
+    GetItemText(IDE_MEM_SPIN_EDIT, s);
+    const wchar_t *end;
+    const UInt32 val = ConvertStringToUInt32(s.Ptr(), &end);
+    if (s.IsEmpty() || *end != 0 || val > (1u << 30))
+#endif
+    {
+      ShowErrorMessage(*this,
+          NWindows::NError::MyFormatMessage(E_INVALIDARG)
+          // L"Incorrect value"
+          );
+      return;
+    }
+    Limit_GB = val;
+  }
+  CModalDialog::OnContinue();
+}

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/MemDialog.h

@@ -0,0 +1,48 @@
+// MemDialog.h
+
+#ifndef ZIP7_INC_MEM_DIALOG_H
+#define ZIP7_INC_MEM_DIALOG_H
+
+#include "../../../Windows/Control/Dialog.h"
+// #include "../../../Windows/Control/ComboBox.h"
+
+#include "MemDialogRes.h"
+
+class CMemDialog: public NWindows::NControl::CModalDialog
+{
+  // NWindows::NControl::CComboBox m_Action;
+  // we can disable default OnOK() when we press Enter
+  // virtual void OnOK() Z7_override { }
+  virtual void OnContinue() Z7_override;
+  virtual bool OnInit() Z7_override;
+  virtual bool OnButtonClicked(unsigned buttonID, HWND buttonHWND) Z7_override;
+  void EnableSpin(bool enable);
+  // int AddAction(UINT id);
+public:
+  bool NeedSave;
+  bool Remember;
+  bool SkipArc;
+  bool TestMode;
+  bool ShowRemember;
+  // bool ShowSkipFile;
+  UInt32 Required_GB;
+  UInt32 Limit_GB;
+  UString ArcPath;
+  UString FilePath;
+
+  void AddInfoMessage_To_String(UString &s, const UInt32 *ramSize_GB = NULL);
+  
+  CMemDialog():
+    NeedSave(false),
+    Remember(false),
+    SkipArc(false),
+    TestMode(false),
+    ShowRemember(true),
+    // ShowSkipFile(true),
+    Required_GB(4),
+    Limit_GB(4)
+    {}
+  INT_PTR Create(HWND parentWindow = NULL) { return CModalDialog::Create(IDD_MEM, parentWindow); }
+};
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/FileManager/MemDialogRes.h

@@ -0,0 +1,13 @@
+#define IDD_MEM                 7800
+
+#define IDX_MEM_SAVE_LIMIT      7801
+#define IDX_MEM_REMEMBER        7802
+#define IDG_MEM_ACTION          7803
+
+#define IDR_MEM_ACTION_ALLOW    7820
+#define IDR_MEM_ACTION_SKIP_ARC 7821
+
+#define IDT_MEM_MESSAGE         101
+#define IDE_MEM_SPIN_EDIT       110
+#define IDC_MEM_SPIN            111
+#define IDT_MEM_GB              112