react-native-update 10.34.2 → 10.34.4

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/Wildcard.h

@@ -0,0 +1,149 @@
+// Common/Wildcard.h
+
+#ifndef __COMMON_WILDCARD_H
+#define __COMMON_WILDCARD_H
+
+#include "MyString.h"
+
+int CompareFileNames(const wchar_t *s1, const wchar_t *s2) STRING_UNICODE_THROW;
+#ifndef USE_UNICODE_FSTRING
+  int CompareFileNames(const char *s1, const char *s2);
+#endif
+
+bool IsPath1PrefixedByPath2(const wchar_t *s1, const wchar_t *s2);
+
+void SplitPathToParts(const UString &path, UStringVector &pathParts);
+void SplitPathToParts_2(const UString &path, UString &dirPrefix, UString &name);
+void SplitPathToParts_Smart(const UString &path, UString &dirPrefix, UString &name); // ignores dir delimiter at the end of (path)
+
+UString ExtractDirPrefixFromPath(const UString &path);
+UString ExtractFileNameFromPath(const UString &path);
+
+bool DoesNameContainWildcard(const UString &path);
+bool DoesWildcardMatchName(const UString &mask, const UString &name);
+
+namespace NWildcard {
+
+#ifdef _WIN32
+// returns true, if name is like "a:", "c:", ...
+bool IsDriveColonName(const wchar_t *s);
+unsigned GetNumPrefixParts_if_DrivePath(UStringVector &pathParts);
+#endif
+
+struct CItem
+{
+  UStringVector PathParts;
+  bool Recursive;
+  bool ForFile;
+  bool ForDir;
+  bool WildcardMatching;
+  
+  #ifdef _WIN32
+  bool IsDriveItem() const
+  {
+    return PathParts.Size() == 1 && !ForFile && ForDir && IsDriveColonName(PathParts[0]);
+  }
+  #endif
+
+  // CItem(): WildcardMatching(true) {}
+
+  bool AreAllAllowed() const;
+  bool CheckPath(const UStringVector &pathParts, bool isFile) const;
+};
+
+class CCensorNode
+{
+  CCensorNode *Parent;
+  
+  bool CheckPathCurrent(bool include, const UStringVector &pathParts, bool isFile) const;
+  void AddItemSimple(bool include, CItem &item);
+public:
+  bool CheckPathVect(const UStringVector &pathParts, bool isFile, bool &include) const;
+
+  CCensorNode(): Parent(0) { };
+  CCensorNode(const UString &name, CCensorNode *parent): Name(name), Parent(parent) { };
+
+  UString Name; // WIN32 doesn't support wildcards in file names
+  CObjectVector<CCensorNode> SubNodes;
+  CObjectVector<CItem> IncludeItems;
+  CObjectVector<CItem> ExcludeItems;
+
+  bool AreAllAllowed() const;
+
+  int FindSubNode(const UString &path) const;
+
+  void AddItem(bool include, CItem &item, int ignoreWildcardIndex = -1);
+  void AddItem(bool include, const UString &path, bool recursive, bool forFile, bool forDir, bool wildcardMatching);
+  void AddItem2(bool include, const UString &path, bool recursive, bool wildcardMatching);
+
+  bool NeedCheckSubDirs() const;
+  bool AreThereIncludeItems() const;
+
+  // bool CheckPath2(bool isAltStream, const UString &path, bool isFile, bool &include) const;
+  // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
+
+  bool CheckPathToRoot(bool include, UStringVector &pathParts, bool isFile) const;
+  // bool CheckPathToRoot(const UString &path, bool isFile, bool include) const;
+  void ExtendExclude(const CCensorNode &fromNodes);
+};
+
+struct CPair
+{
+  UString Prefix;
+  CCensorNode Head;
+  
+  CPair(const UString &prefix): Prefix(prefix) { };
+};
+
+enum ECensorPathMode
+{
+  k_RelatPath,  // absolute prefix as Prefix, remain path in Tree
+  k_FullPath,   // drive prefix as Prefix, remain path in Tree
+  k_AbsPath     // full path in Tree
+};
+
+struct CCensorPath
+{
+  UString Path;
+  bool Include;
+  bool Recursive;
+  bool WildcardMatching;
+
+  CCensorPath():
+    Include(true),
+    Recursive(false),
+    WildcardMatching(true)
+    {}
+};
+
+class CCensor
+{
+  int FindPrefix(const UString &prefix) const;
+public:
+  CObjectVector<CPair> Pairs;
+
+  CObjectVector<NWildcard::CCensorPath> CensorPaths;
+  
+  bool AllAreRelative() const
+    { return (Pairs.Size() == 1 && Pairs.Front().Prefix.IsEmpty()); }
+  
+  void AddItem(ECensorPathMode pathMode, bool include, const UString &path, bool recursive, bool wildcardMatching);
+  // bool CheckPath(bool isAltStream, const UString &path, bool isFile) const;
+  void ExtendExclude();
+
+  void AddPathsToCensor(NWildcard::ECensorPathMode censorPathMode);
+  void AddPreItem(bool include, const UString &path, bool recursive, bool wildcardMatching);
+  void AddPreItem(const UString &path)
+  {
+    AddPreItem(true, path, false, false);
+  }
+  void AddPreItem_Wildcard()
+  {
+    AddPreItem(true, UString("*"), false, true);
+  }
+};
+
+
+}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/XzCrc64Init.cpp

@@ -0,0 +1,7 @@
+// XzCrc64Init.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/XzCrc64.h"
+
+static struct CCrc64Gen { CCrc64Gen() { Crc64GenerateTable(); } } g_Crc64TableInit;

package/harmony/pushy/src/main/cpp/lzma/CPP/Common/XzCrc64Reg.cpp

@@ -0,0 +1,42 @@
+// XzCrc64Reg.cpp
+
+#include "StdAfx.h"
+
+#include "../../C/CpuArch.h"
+#include "../../C/XzCrc64.h"
+
+#include "../Common/MyCom.h"
+
+#include "../7zip/Common/RegisterCodec.h"
+
+class CXzCrc64Hasher:
+  public IHasher,
+  public CMyUnknownImp
+{
+  UInt64 _crc;
+  Byte mtDummy[1 << 7];
+
+public:
+  CXzCrc64Hasher(): _crc(CRC64_INIT_VAL) {}
+
+  MY_UNKNOWN_IMP1(IHasher)
+  INTERFACE_IHasher(;)
+};
+
+STDMETHODIMP_(void) CXzCrc64Hasher::Init() throw()
+{
+  _crc = CRC64_INIT_VAL;
+}
+
+STDMETHODIMP_(void) CXzCrc64Hasher::Update(const void *data, UInt32 size) throw()
+{
+  _crc = Crc64Update(_crc, data, size);
+}
+
+STDMETHODIMP_(void) CXzCrc64Hasher::Final(Byte *digest) throw()
+{
+  UInt64 val = CRC64_GET_DIGEST(_crc);
+  SetUi64(digest, val);
+}
+
+REGISTER_HASHER(CXzCrc64Hasher, 0x4, "CRC64", 8)

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

@@ -0,0 +1,70 @@
+// Windows/COM.h
+
+#ifndef __WINDOWS_COM_H
+#define __WINDOWS_COM_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+namespace NCOM {
+
+#ifdef _WIN32
+  
+class CComInitializer
+{
+public:
+  CComInitializer()
+  {
+    #ifdef UNDER_CE
+    CoInitializeEx(NULL, COINIT_MULTITHREADED);
+    #else
+    // it's single thread. Do we need multithread?
+    CoInitialize(NULL);
+    #endif
+  };
+  ~CComInitializer() { CoUninitialize(); }
+};
+
+class CStgMedium
+{
+  STGMEDIUM _object;
+public:
+  bool _mustBeReleased;
+  CStgMedium(): _mustBeReleased(false) {}
+  ~CStgMedium() { Free(); }
+  void Free()
+  {
+    if (_mustBeReleased)
+      ReleaseStgMedium(&_object);
+    _mustBeReleased = false;
+  }
+  const STGMEDIUM* operator->() const { return &_object;}
+  STGMEDIUM* operator->() { return &_object;}
+  STGMEDIUM* operator&() { return &_object; }
+};
+
+#endif
+
+/*
+//////////////////////////////////
+// GUID <--> String Conversions
+UString GUIDToStringW(REFGUID guid);
+AString GUIDToStringA(REFGUID guid);
+#ifdef UNICODE
+  #define GUIDToString GUIDToStringW
+#else
+  #define GUIDToString GUIDToStringA
+#endif
+
+HRESULT StringToGUIDW(const wchar_t *string, GUID &classID);
+HRESULT StringToGUIDA(const char *string, GUID &classID);
+#ifdef UNICODE
+  #define StringToGUID StringToGUIDW
+#else
+  #define StringToGUID StringToGUIDA
+#endif
+*/
+
+}}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/CPP/Windows/CommonDialog.cpp

@@ -0,0 +1,185 @@
+// Windows/CommonDialog.cpp
+
+#include "StdAfx.h"
+
+#include "../Common/MyWindows.h"
+
+#ifdef UNDER_CE
+#include <commdlg.h>
+#endif
+
+#ifndef _UNICODE
+#include "../Common/StringConvert.h"
+#endif
+
+#include "CommonDialog.h"
+#include "Defs.h"
+
+#ifndef _UNICODE
+extern bool g_IsNT;
+#endif
+
+namespace NWindows {
+
+#ifndef _UNICODE
+
+class CDoubleZeroStringListA
+{
+  LPTSTR Buf;
+  unsigned Size;
+public:
+  CDoubleZeroStringListA(LPSTR buf, unsigned size): Buf(buf), Size(size) {}
+  bool Add(LPCSTR s) throw();
+  void Finish() { *Buf = 0; }
+};
+
+bool CDoubleZeroStringListA::Add(LPCSTR s) throw()
+{
+  unsigned len = MyStringLen(s) + 1;
+  if (len >= Size)
+    return false;
+  MyStringCopy(Buf, s);
+  Buf += len;
+  Size -= len;
+  return true;
+}
+
+#endif
+
+class CDoubleZeroStringListW
+{
+  LPWSTR Buf;
+  unsigned Size;
+public:
+  CDoubleZeroStringListW(LPWSTR buf, unsigned size): Buf(buf), Size(size) {}
+  bool Add(LPCWSTR s) throw();
+  void Finish() { *Buf = 0; }
+};
+
+bool CDoubleZeroStringListW::Add(LPCWSTR s) throw()
+{
+  unsigned len = MyStringLen(s) + 1;
+  if (len >= Size)
+    return false;
+  MyStringCopy(Buf, s);
+  Buf += len;
+  Size -= len;
+  return true;
+}
+
+#define MY__OFN_PROJECT  0x00400000
+#define MY__OFN_SHOW_ALL 0x01000000
+
+/* if (lpstrFilter == NULL && nFilterIndex == 0)
+  MSDN : "the system doesn't show any files",
+  but WinXP-64 shows all files. Why ??? */
+
+/*
+structures
+  OPENFILENAMEW
+  OPENFILENAMEA
+contain additional members:
+#if (_WIN32_WINNT >= 0x0500)
+  void *pvReserved;
+  DWORD dwReserved;
+  DWORD FlagsEx;
+#endif
+
+If we compile the source code with (_WIN32_WINNT >= 0x0500), some functions
+will not work at NT 4.0, if we use sizeof(OPENFILENAME*).
+So we use size of old version of structure. */
+
+#if defined(UNDER_CE) || defined(_WIN64) || (_WIN32_WINNT < 0x0500)
+// || !defined(WINVER)
+  #define my_compatib_OPENFILENAMEA_size sizeof(OPENFILENAMEA)
+  #define my_compatib_OPENFILENAMEW_size sizeof(OPENFILENAMEW)
+#else
+  #define my_compatib_OPENFILENAMEA_size OPENFILENAME_SIZE_VERSION_400A
+  #define my_compatib_OPENFILENAMEW_size OPENFILENAME_SIZE_VERSION_400W
+#endif
+
+#define CONV_U_To_A(dest, src, temp) AString temp; if (src) { temp = GetSystemString(src); dest = temp; }
+
+bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
+    LPCWSTR initialDir,
+    LPCWSTR filePath,
+    LPCWSTR filterDescription,
+    LPCWSTR filter,
+    UString &resPath
+    #ifdef UNDER_CE
+    , bool openFolder
+    #endif
+    )
+{
+  const unsigned kBufSize = MAX_PATH * 2;
+  const unsigned kFilterBufSize = MAX_PATH;
+  if (!filter)
+    filter = L"*.*";
+  #ifndef _UNICODE
+  if (!g_IsNT)
+  {
+    CHAR buf[kBufSize];
+    MyStringCopy(buf, (const char *)GetSystemString(filePath));
+    // OPENFILENAME_NT4A
+    OPENFILENAMEA p;
+    memset(&p, 0, sizeof(p));
+    p.lStructSize = my_compatib_OPENFILENAMEA_size;
+    p.hwndOwner = hwnd;
+    CHAR filterBuf[kFilterBufSize];
+    {
+      CDoubleZeroStringListA dz(filterBuf, kFilterBufSize);
+      dz.Add(GetSystemString(filterDescription ? filterDescription : filter));
+      dz.Add(GetSystemString(filter));
+      dz.Finish();
+      p.lpstrFilter = filterBuf;
+      p.nFilterIndex = 1;
+    }
+    
+    p.lpstrFile = buf;
+    p.nMaxFile = kBufSize;
+    CONV_U_To_A(p.lpstrInitialDir, initialDir, initialDirA);
+    CONV_U_To_A(p.lpstrTitle, title, titleA);
+    p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY;
+
+    bool res = BOOLToBool(::GetOpenFileNameA(&p));
+    resPath = GetUnicodeString(buf);
+    return res;
+  }
+  else
+  #endif
+  {
+    WCHAR buf[kBufSize];
+    MyStringCopy(buf, filePath);
+    // OPENFILENAME_NT4W
+    OPENFILENAMEW p;
+    memset(&p, 0, sizeof(p));
+    p.lStructSize = my_compatib_OPENFILENAMEW_size;
+    p.hwndOwner = hwnd;
+    
+    WCHAR filterBuf[kFilterBufSize];
+    {
+      CDoubleZeroStringListW dz(filterBuf, kFilterBufSize);
+      dz.Add(filterDescription ? filterDescription : filter);
+      dz.Add(filter);
+      dz.Finish();
+      p.lpstrFilter = filterBuf;
+      p.nFilterIndex = 1;
+    }
+        
+    p.lpstrFile = buf;
+    p.nMaxFile = kBufSize;
+    p.lpstrInitialDir = initialDir;
+    p.lpstrTitle = title;
+    p.Flags = OFN_EXPLORER | OFN_HIDEREADONLY
+        #ifdef UNDER_CE
+        | (openFolder ? (MY__OFN_PROJECT | MY__OFN_SHOW_ALL) : 0)
+        #endif
+        ;
+
+    bool res = BOOLToBool(::GetOpenFileNameW(&p));
+    resPath = buf;
+    return res;
+  }
+}
+
+}

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

@@ -0,0 +1,23 @@
+// Windows/CommonDialog.h
+
+#ifndef __WINDOWS_COMMON_DIALOG_H
+#define __WINDOWS_COMMON_DIALOG_H
+
+#include "../Common/MyString.h"
+
+namespace NWindows {
+
+bool MyGetOpenFileName(HWND hwnd, LPCWSTR title,
+    LPCWSTR initialDir,  // can be NULL, so dir prefix in filePath will be used
+    LPCWSTR filePath,    // full path
+    LPCWSTR filterDescription,  // like "All files (*.*)"
+    LPCWSTR filter,             // like "*.exe"
+    UString &resPath
+    #ifdef UNDER_CE
+    , bool openFolder = false
+    #endif
+);
+
+}
+
+#endif

package/harmony/pushy/src/main/cpp/lzma/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
+
+}}

package/harmony/pushy/src/main/cpp/lzma/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

package/harmony/pushy/src/main/cpp/lzma/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