static void ErrorInfo_Print(UString &s, const CArcErrorInfo &er)
{
UInt32 errorFlags = er.GetErrorFlags();
UInt32 warningFlags = er.GetWarningFlags();
if (errorFlags != 0)
AddNewLineString(s, GetOpenArcErrorMessage(errorFlags));
if (!er.ErrorMessage.IsEmpty())
AddNewLineString(s, er.ErrorMessage);
if (warningFlags != 0)
{
s += GetNameOfProperty(kpidWarningFlags, L"Warnings");
s.AddAscii(":");
s.Add_LF();
AddNewLineString(s, GetOpenArcErrorMessage(warningFlags));
}
if (!er.WarningMessage.IsEmpty())
{
s += GetNameOfProperty(kpidWarning, L"Warning");
s.AddAscii(": ");
s += er.WarningMessage;
s.Add_LF();
}
}
void GenerateName(UString &s, const char *prefix)
{
s.AddAscii(prefix);
char temp[16];
ConvertUInt32ToString((UInt32)(unsigned)_random.Generate(), temp);
s.AddAscii(temp);
}
UString GetParentSequence() const
{
const CHandler *p = this;
UString res;
while (p && p->NeedParent())
{
if (!res.IsEmpty())
res.AddAscii(" -> ");
UString mainName;
UString anotherName;
if (Dyn.RelativeNameWasUsed)
{
mainName = p->Dyn.RelativeParentNameFromLocator;
anotherName = p->Dyn.ParentName;
}
else
{
mainName = p->Dyn.ParentName;
anotherName = p->Dyn.RelativeParentNameFromLocator;
}
res += mainName;
if (mainName != anotherName && !anotherName.IsEmpty())
{
res.Add_Space();
res += L'(';
res += anotherName;
res += L')';
}
p = p->Parent;
}
return res;
}
static void AddValuePair(UString &s, UINT resourceID, UInt64 value, bool addColon = true)
{
AddLangString(s, resourceID);
if (addColon)
s += L':';
s.Add_Space();
char sz[32];
ConvertUInt64ToString(value, sz);
s.AddAscii(sz);
s.Add_LF();
}
static void ExtractGroupCommand(const UStringVector &arcPaths, UString ¶ms, bool isHash)
{
AddLagePagesSwitch(params);
params.AddAscii(isHash ? kHashIncludeSwitches : kArcIncludeSwitches);
CFileMapping fileMapping;
NSynchronization::CManualResetEvent event;
HRESULT result = CreateMap(arcPaths, fileMapping, event, params);
if (result == S_OK)
result = Call7zGui(params, false, &event);
if (result != S_OK)
ErrorMessageHRESULT(result);
}
UString GetOpenArcErrorMessage(UInt32 errorFlags)
{
UString s;
for (unsigned i = 0; i < ARRAY_SIZE(k_ErrorFlagsIds); i++)
{
UInt32 f = ((UInt32)1 << i);
if ((errorFlags & f) == 0)
continue;
UInt32 id = k_ErrorFlagsIds[i];
UString m = LangString(id);
if (m.IsEmpty())
continue;
if (f == kpv_ErrorFlags_EncryptedHeadersError)
{
m.AddAscii(" : ");
AddLangString(m, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
}
if (!s.IsEmpty())
s.Add_LF();
s += m;
errorFlags &= ~f;
}
if (errorFlags != 0)
{
char sz[16];
sz[0] = '0';
sz[1] = 'x';
ConvertUInt32ToHex(errorFlags, sz + 2);
if (!s.IsEmpty())
s.Add_LF();
s.AddAscii(sz);
}
return s;
}
static void AddRenamePair(CObjectVector<CRenamePair> *renamePairs,
const UString &oldName, const UString &newName, NRecursedType::EEnum type,
bool wildcardMatching)
{
CRenamePair &pair = renamePairs->AddNew();
pair.OldName = oldName;
pair.NewName = newName;
pair.RecursedType = type;
pair.WildcardParsing = wildcardMatching;
if (!pair.Prepare())
{
UString val;
val += pair.OldName;
val.Add_LF();
val += pair.NewName;
val.Add_LF();
if (type == NRecursedType::kRecursed)
val.AddAscii("-r");
else if (type == NRecursedType::kWildcardOnlyRecursed)
val.AddAscii("-r0");
throw CArcCmdLineException("Unsupported rename command:", val);
}
}
static void AddPropertyString(PROPID propID, const wchar_t *nameBSTR,
const NCOM::CPropVariant &prop, UString &s)
{
if (prop.vt != VT_EMPTY)
{
UString val;
if (propID == kpidErrorFlags ||
propID == kpidWarningFlags)
{
UInt32 flags = GetOpenArcErrorFlags(prop);
if (flags == 0)
return;
if (flags != 0)
val = GetOpenArcErrorMessage(flags);
}
if (val.IsEmpty())
if ((prop.vt == VT_UI8 || prop.vt == VT_UI4 || prop.vt == VT_UI2) && IsSizeProp(propID))
{
UInt64 v = 0;
ConvertPropVariantToUInt64(prop, v);
val = ConvertSizeToString(v);
}
else
ConvertPropertyToString(val, prop, propID);
if (!val.IsEmpty())
{
s += GetNameOfProperty(propID, nameBSTR);
s.AddAscii(kPropValueSeparator);
/*
if (propID == kpidComment)
s.Add_LF();
*/
s += val;
s.Add_LF();
}
}
}
static HRESULT Call7zGui(const UString ¶ms,
// LPCWSTR curDir,
bool waitFinish,
NSynchronization::CBaseEvent *event)
{
UString imageName = fs2us(NWindows::NDLL::GetModuleDirPrefix());
imageName.AddAscii(k7zGui);
CProcess process;
WRes res = process.Create(imageName, params, NULL); // curDir);
if (res != 0)
{
ErrorMessageHRESULT(res, imageName);
return res;
}
if (waitFinish)
process.Wait();
else if (event != NULL)
{
HANDLE handles[] = { process, *event };
::WaitForMultipleObjects(ARRAY_SIZE(handles), handles, FALSE, INFINITE);
}
return S_OK;
}
static void AddLagePagesSwitch(UString ¶ms)
{
if (!ReadLockMemoryEnable())
params.AddAscii(kLargePagesDisable);
}
static HRESULT CreateMap(const UStringVector &names,
CFileMapping &fileMapping, NSynchronization::CManualResetEvent &event,
UString ¶ms)
{
size_t totalSize = 1;
{
FOR_VECTOR (i, names)
totalSize += (names[i].Len() + 1);
}
totalSize *= sizeof(wchar_t);
CRandNameGenerator random;
UString mappingName;
for (;;)
{
random.GenerateName(mappingName, "7zMap");
WRes res = fileMapping.Create(PAGE_READWRITE, totalSize, GetSystemString(mappingName));
if (fileMapping.IsCreated() && res == 0)
break;
if (res != ERROR_ALREADY_EXISTS)
return res;
fileMapping.Close();
}
UString eventName;
for (;;)
{
random.GenerateName(eventName, "7zEvent");
WRes res = event.CreateWithName(false, GetSystemString(eventName));
if (event.IsCreated() && res == 0)
break;
if (res != ERROR_ALREADY_EXISTS)
return res;
event.Close();
}
params += L'#';
params += mappingName;
params += L':';
char temp[32];
ConvertUInt64ToString(totalSize, temp);
params.AddAscii(temp);
params += L':';
params += eventName;
LPVOID data = fileMapping.Map(FILE_MAP_WRITE, 0, totalSize);
if (!data)
return E_FAIL;
CFileUnmapper unmapper(data);
{
wchar_t *cur = (wchar_t *)data;
*cur++ = 0; // it means wchar_t strings (UTF-16 in WIN32)
FOR_VECTOR (i, names)
{
const UString &s = names[i];
unsigned len = s.Len() + 1;
wmemcpy(cur, (const wchar_t *)s, len);
cur += len;
}
}
return S_OK;
}
void CPanel::Properties()
{
CMyComPtr<IGetFolderArcProps> getFolderArcProps;
_folder.QueryInterface(IID_IGetFolderArcProps, &getFolderArcProps);
if (!getFolderArcProps)
{
InvokeSystemCommand("properties");
return;
}
{
UString message;
CRecordVector<UInt32> operatedIndices;
GetOperatedItemIndices(operatedIndices);
if (operatedIndices.Size() == 1)
{
UInt32 index = operatedIndices[0];
// message += L"Item:\n";
UInt32 numProps;
if (_folder->GetNumberOfProperties(&numProps) == S_OK)
{
for (UInt32 i = 0; i < numProps; i++)
{
CMyComBSTR name;
PROPID propID;
VARTYPE varType;
if (_folder->GetPropertyInfo(i, &name, &propID, &varType) != S_OK)
continue;
NCOM::CPropVariant prop;
if (_folder->GetProperty(index, propID, &prop) != S_OK)
continue;
AddPropertyString(propID, name, prop, message);
}
}
if (_folderRawProps)
{
_folderRawProps->GetNumRawProps(&numProps);
for (UInt32 i = 0; i < numProps; i++)
{
CMyComBSTR name;
PROPID propID;
if (_folderRawProps->GetRawPropInfo(i, &name, &propID) != S_OK)
continue;
const void *data;
UInt32 dataSize;
UInt32 propType;
if (_folderRawProps->GetRawProp(index, propID, &data, &dataSize, &propType) != S_OK)
continue;
if (dataSize != 0)
{
AString s;
if (propID == kpidNtSecure)
ConvertNtSecureToString((const Byte *)data, dataSize, s);
else
{
const UInt32 kMaxDataSize = 64;
if (dataSize > kMaxDataSize)
{
char temp[64];
s += "data:";
ConvertUInt32ToString(dataSize, temp);
s += temp;
}
else
{
for (UInt32 k = 0; k < dataSize; k++)
{
Byte b = ((const Byte *)data)[k];
s += GetHex((Byte)((b >> 4) & 0xF));
s += GetHex((Byte)(b & 0xF));
}
}
}
message += GetNameOfProperty(propID, name);
message.AddAscii(kPropValueSeparator);
message.AddAscii(s);
message.Add_LF();
}
}
}
message.AddAscii(kSeparator);
}
bool CMenuPage::OnInit()
{
_initMode = true;
Clear_MenuChanged();
LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
#ifdef UNDER_CE
HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU);
HideItem(IDX_SYSTEM_INTEGRATE_TO_MENU_2);
#else
{
UString s;
{
CWindow window(GetItem(IDX_SYSTEM_INTEGRATE_TO_MENU));
window.GetText(s);
}
UString bit64 = LangString(IDS_PROP_BIT64);
if (bit64.IsEmpty())
bit64.SetFromAscii("64-bit");
#ifdef _WIN64
bit64.Replace(L"64", L"32");
#endif
s.Add_Space();
s += L'(';
s += bit64;
s += L')';
SetItemText(IDX_SYSTEM_INTEGRATE_TO_MENU_2, s);
}
const FString prefix = NDLL::GetModuleDirPrefix();
_dlls[0].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU;
_dlls[1].ctrl = IDX_SYSTEM_INTEGRATE_TO_MENU_2;
_dlls[0].wow = 0;
_dlls[1].wow =
#ifdef _WIN64
KEY_WOW64_32KEY
#else
KEY_WOW64_64KEY
#endif
;
for (unsigned d = 0; d < 2; d++)
{
CShellDll &dll = _dlls[d];
dll.wasChanged = false;
#ifndef _WIN64
if (d != 0 && !g_Is_Wow64)
{
HideItem(dll.ctrl);
continue;
}
#endif
FString &path = dll.Path;
path = prefix;
path.AddAscii(d == 0 ? "7-zip.dll" :
#ifdef _WIN64
"7-zip32.dll"
#else
"7-zip64.dll"
#endif
);
if (!NFile::NFind::DoesFileExist(path))
{
path.Empty();
EnableItem(dll.ctrl, false);
}
else
{
dll.prevValue = CheckContextMenuHandler(fs2us(path), dll.wow);
CheckButton(dll.ctrl, dll.prevValue);
}
}
#endif
CContextMenuInfo ci;
ci.Load();
CheckButton(IDX_SYSTEM_CASCADED_MENU, ci.Cascaded.Val);
CheckButton(IDX_SYSTEM_ICON_IN_MENU, ci.MenuIcons.Val);
CheckButton(IDX_EXTRACT_ELIM_DUP, ci.ElimDup.Val);
_listView.Attach(GetItem(IDL_SYSTEM_OPTIONS));
const UInt32 newFlags = LVS_EX_CHECKBOXES | LVS_EX_FULLROWSELECT;
_listView.SetExtendedListViewStyle(newFlags, newFlags);
_listView.InsertColumn(0, L"", 200);
for (unsigned i = 0; i < ARRAY_SIZE(kMenuItems); i++)
{
const CContextMenuItem &menuItem = kMenuItems[i];
UString s = LangString(menuItem.ControlID);
if (menuItem.Flag == kCRC)
s.SetFromAscii("CRC SHA");
if (menuItem.Flag == kOpenAs ||
menuItem.Flag == kCRC)
s.AddAscii(" >");
switch (menuItem.ControlID)
{
case IDS_CONTEXT_EXTRACT_TO:
{
s = MyFormatNew(s, LangString(IDS_CONTEXT_FOLDER));
break;
}
case IDS_CONTEXT_COMPRESS_TO:
case IDS_CONTEXT_COMPRESS_TO_EMAIL:
{
UString s2 = LangString(IDS_CONTEXT_ARCHIVE);
switch (menuItem.Flag)
{
case kCompressTo7z:
case kCompressTo7zEmail:
s2.AddAscii(".7z");
break;
case kCompressToZip:
case kCompressToZipEmail:
s2.AddAscii(".zip");
break;
}
s = MyFormatNew(s, s2);
break;
}
}
int itemIndex = _listView.InsertItem(i, s);
_listView.SetCheckState(itemIndex, ((ci.Flags & menuItem.Flag) != 0));
}
_listView.SetColumnWidthAuto(0);
_initMode = false;
return CPropertyPage::OnInit();
}
void SetExtractErrorMessage(Int32 opRes, Int32 encrypted, const wchar_t *fileName, UString &s)
{
s.Empty();
if (opRes == NArchive::NExtract::NOperationResult::kOK)
return;
UINT messageID = 0;
UINT id = 0;
switch (opRes)
{
case NArchive::NExtract::NOperationResult::kUnsupportedMethod:
messageID = IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD;
id = IDS_EXTRACT_MSG_UNSUPPORTED_METHOD;
break;
case NArchive::NExtract::NOperationResult::kDataError:
messageID = encrypted ?
IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED:
IDS_EXTRACT_MESSAGE_DATA_ERROR;
id = IDS_EXTRACT_MSG_DATA_ERROR;
break;
case NArchive::NExtract::NOperationResult::kCRCError:
messageID = encrypted ?
IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED:
IDS_EXTRACT_MESSAGE_CRC_ERROR;
id = IDS_EXTRACT_MSG_CRC_ERROR;
break;
case NArchive::NExtract::NOperationResult::kUnavailable:
id = IDS_EXTRACT_MSG_UNAVAILABLE_DATA;
break;
case NArchive::NExtract::NOperationResult::kUnexpectedEnd:
id = IDS_EXTRACT_MSG_UEXPECTED_END;
break;
case NArchive::NExtract::NOperationResult::kDataAfterEnd:
id = IDS_EXTRACT_MSG_DATA_AFTER_END;
break;
case NArchive::NExtract::NOperationResult::kIsNotArc:
id = IDS_EXTRACT_MSG_IS_NOT_ARC;
break;
case NArchive::NExtract::NOperationResult::kHeadersError:
id = IDS_EXTRACT_MSG_HEADERS_ERROR;
break;
case NArchive::NExtract::NOperationResult::kWrongPassword:
id = IDS_EXTRACT_MSG_WRONG_PSW_CLAIM;
break;
/*
default:
messageID = IDS_EXTRACT_MESSAGE_UNKNOWN_ERROR;
break;
*/
}
UString msg;
UString msgOld;
#ifndef _SFX
if (id != 0)
LangString_OnlyFromLangFile(id, msg);
if (messageID != 0 && msg.IsEmpty())
LangString_OnlyFromLangFile(messageID, msgOld);
#endif
if (msg.IsEmpty() && !msgOld.IsEmpty())
s = MyFormatNew(msgOld, fileName);
else
{
if (msg.IsEmpty() && id != 0)
LangString(id, msg);
if (!msg.IsEmpty())
s += msg;
else
{
char temp[16];
ConvertUInt32ToString(opRes, temp);
s.AddAscii("Error #");
s.AddAscii(temp);
}
if (encrypted && opRes != NArchive::NExtract::NOperationResult::kWrongPassword)
{
// s.AddAscii(" : ");
// AddLangString(s, IDS_EXTRACT_MSG_ENCRYPTED);
s.AddAscii(" : ");
AddLangString(s, IDS_EXTRACT_MSG_WRONG_PSW_GUESS);
}
s.AddAscii(" : ");
s += fileName;
}
}
bool CExtractDialog::OnInit()
{
#ifdef LANG
{
UString s;
LangString_OnlyFromLangFile(IDD_EXTRACT, s);
if (s.IsEmpty())
GetText(s);
if (!ArcPath.IsEmpty())
{
s.AddAscii(" : ");
s += ArcPath;
}
SetText(s);
// LangSetWindowText(*this, IDD_EXTRACT);
LangSetDlgItems(*this, kLangIDs, ARRAY_SIZE(kLangIDs));
}
#endif
#ifndef _SFX
_passwordControl.Attach(GetItem(IDE_EXTRACT_PASSWORD));
_passwordControl.SetText(Password);
_passwordControl.SetPasswordChar(TEXT('*'));
_pathName.Attach(GetItem(IDE_EXTRACT_NAME));
#endif
#ifdef NO_REGISTRY
PathMode = NExtract::NPathMode::kFullPaths;
OverwriteMode = NExtract::NOverwriteMode::kAsk;
#else
_info.Load();
if (_info.PathMode == NExtract::NPathMode::kCurPaths)
_info.PathMode = NExtract::NPathMode::kFullPaths;
if (!PathMode_Force && _info.PathMode_Force)
PathMode = _info.PathMode;
if (!OverwriteMode_Force && _info.OverwriteMode_Force)
OverwriteMode = _info.OverwriteMode;
// CheckButton_TwoBools(IDX_EXTRACT_ALT_STREAMS, AltStreams, _info.AltStreams);
CheckButton_TwoBools(IDX_EXTRACT_NT_SECUR, NtSecurity, _info.NtSecurity);
CheckButton_TwoBools(IDX_EXTRACT_ELIM_DUP, ElimDup, _info.ElimDup);
CheckButton(IDX_PASSWORD_SHOW, _info.ShowPassword.Val);
UpdatePasswordControl();
#endif
_path.Attach(GetItem(IDC_EXTRACT_PATH));
UString pathPrefix = DirPath;
#ifndef _SFX
if (_info.SplitDest.Val)
{
CheckButton(IDX_EXTRACT_NAME_ENABLE, true);
UString pathName;
SplitPathToParts_Smart(DirPath, pathPrefix, pathName);
if (pathPrefix.IsEmpty())
pathPrefix = pathName;
else
_pathName.SetText(pathName);
}
else
ShowItem_Bool(IDE_EXTRACT_NAME, false);
#endif
_path.SetText(pathPrefix);
#ifndef NO_REGISTRY
for (unsigned i = 0; i < _info.Paths.Size() && i < kHistorySize; i++)
_path.AddString(_info.Paths[i]);
#endif
/*
if (_info.Paths.Size() > 0)
_path.SetCurSel(0);
else
_path.SetCurSel(-1);
*/
#ifndef _SFX
_pathMode.Attach(GetItem(IDC_EXTRACT_PATH_MODE));
_overwriteMode.Attach(GetItem(IDC_EXTRACT_OVERWRITE_MODE));
AddComboItems(_pathMode, kPathMode_IDs, ARRAY_SIZE(kPathMode_IDs), kPathModeButtonsVals, PathMode);
AddComboItems(_overwriteMode, kOverwriteMode_IDs, ARRAY_SIZE(kOverwriteMode_IDs), kOverwriteButtonsVals, OverwriteMode);
#endif
HICON icon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
SetIcon(ICON_BIG, icon);
// CWindow filesWindow = GetItem(IDC_EXTRACT_RADIO_FILES);
// filesWindow.Enable(_enableFilesButton);
NormalizePosition();
return CModalDialog::OnInit();
}
void OnMenuActivating(HWND /* hWnd */, HMENU hMenu, int position)
{
HMENU mainMenu =
#ifdef UNDER_CE
g_App._commandBar.GetMenu(0);
#else
::GetMenu(g_HWND)
#endif
;
if (::GetSubMenu(mainMenu, position) != hMenu)
return;
if (position == kMenuIndex_File)
{
CMenu menu;
menu.Attach(hMenu);
menu.RemoveAllItems();
g_App.GetFocusedPanel().CreateFileMenu(hMenu);
}
else if (position == kMenuIndex_Edit)
{
/*
CMenu menu;
menu.Attach(hMenu);
menu.EnableItem(IDM_EDIT_CUT, MF_ENABLED);
menu.EnableItem(IDM_EDIT_COPY, MF_ENABLED);
menu.EnableItem(IDM_EDIT_PASTE, IsClipboardFormatAvailableHDROP() ? MF_ENABLED : MF_GRAYED);
*/
}
else if (position == kMenuIndex_View)
{
// View;
CMenu menu;
menu.Attach(hMenu);
menu.CheckRadioItem(IDM_VIEW_LARGE_ICONS, IDM_VIEW_DETAILS,
IDM_VIEW_LARGE_ICONS + g_App.GetListViewMode(), MF_BYCOMMAND);
menu.CheckRadioItem(IDM_VIEW_ARANGE_BY_NAME, IDM_VIEW_ARANGE_NO_SORT,
GetSortControlID(g_App.GetSortID()), MF_BYCOMMAND);
menu.CheckItemByID(IDM_VIEW_TWO_PANELS, g_App.NumPanels == 2);
menu.CheckItemByID(IDM_VIEW_FLAT_VIEW, g_App.GetFlatMode());
menu.CheckItemByID(IDM_VIEW_ARCHIVE_TOOLBAR, g_App.ShowArchiveToolbar);
menu.CheckItemByID(IDM_VIEW_STANDARD_TOOLBAR, g_App.ShowStandardToolbar);
menu.CheckItemByID(IDM_VIEW_TOOLBARS_LARGE_BUTTONS, g_App.LargeButtons);
menu.CheckItemByID(IDM_VIEW_TOOLBARS_SHOW_BUTTONS_TEXT, g_App.ShowButtonsLables);
menu.CheckItemByID(IDM_VIEW_AUTO_REFRESH, g_App.Get_AutoRefresh_Mode());
// menu.CheckItemByID(IDM_VIEW_SHOW_STREAMS, g_App.Get_ShowNtfsStrems_Mode());
// menu.CheckItemByID(IDM_VIEW_SHOW_DELETED, g_App.ShowDeletedFiles);
}
else if (position == kMenuIndex_Bookmarks)
{
CMenu menu;
menu.Attach(hMenu);
CMenu subMenu;
subMenu.Attach(menu.GetSubMenu(0));
subMenu.RemoveAllItems();
int i;
for (i = 0; i < 10; i++)
{
UString s = LangString(IDS_BOOKMARK);
s.Add_Space();
wchar_t c = (wchar_t)(L'0' + i);
s += c;
s.AddAscii("\tAlt+Shift+");
s += c;
subMenu.AppendItem(MF_STRING, kSetBookmarkMenuID + i, s);
}
menu.RemoveAllItemsFrom(2);
for (i = 0; i < 10; i++)
{
UString s = g_App.AppState.FastFolders.GetString(i);
const int kMaxSize = 100;
const int kFirstPartSize = kMaxSize / 2;
if (s.Len() > kMaxSize)
{
s.Delete(kFirstPartSize, s.Len() - kMaxSize);
s.Insert(kFirstPartSize, L" ... ");
}
if (s.IsEmpty())
s = L'-';
s.AddAscii("\tAlt+");
s += (wchar_t)(L'0' + i);
menu.AppendItem(MF_STRING, kOpenBookmarkMenuID + i, s);
}
}
}