1125 lines
25 KiB
C++
1125 lines
25 KiB
C++
// FM.cpp
|
|
|
|
#include "StdAfx.h"
|
|
|
|
#include "../../../../C/Alloc.h"
|
|
|
|
#include "../../../Common/IntToString.h"
|
|
#include "../../../Common/StringConvert.h"
|
|
#include "../../../Common/StringToInt.h"
|
|
|
|
#include "../../../Windows/ErrorMsg.h"
|
|
// FIXME #include "../../../Windows/MemoryLock.h"
|
|
// FIXME #include "../../../Windows/NtCheck.h"
|
|
#include "../../../Windows/System.h"
|
|
|
|
#ifndef UNDER_CE
|
|
// FIXME #include "../../../Windows/SecurityUtils.h"
|
|
#endif
|
|
|
|
#include "../GUI/ExtractRes.h"
|
|
|
|
#include "resource.h"
|
|
|
|
#include "App.h"
|
|
#include "FormatUtils.h"
|
|
#include "LangUtils.h"
|
|
#include "MyLoadMenu.h"
|
|
#include "Panel.h"
|
|
#include "RegistryUtils.h"
|
|
#include "StringUtils.h"
|
|
#include "ViewSettings.h"
|
|
|
|
static void local_WM_CREATE(HWND hWnd);
|
|
|
|
using namespace NWindows;
|
|
using namespace NFile;
|
|
using namespace NFind;
|
|
|
|
#define MAX_LOADSTRING 100
|
|
|
|
#define MENU_HEIGHT 26
|
|
|
|
UInt64 g_RAM_Size;
|
|
|
|
#ifdef _WIN32
|
|
HINSTANCE g_hInstance;
|
|
#endif
|
|
HWND g_HWND;
|
|
bool g_OpenArchive = false;
|
|
static UString g_MainPath;
|
|
static UString g_ArcFormat;
|
|
static bool g_Maximized = false;
|
|
|
|
// HRESULT LoadGlobalCodecs();
|
|
void FreeGlobalCodecs();
|
|
|
|
#if 0 // #ifndef UNDER_CE
|
|
|
|
DWORD g_ComCtl32Version;
|
|
|
|
static DWORD GetDllVersion(LPCTSTR dllName)
|
|
{
|
|
DWORD dwVersion = 0;
|
|
HINSTANCE hinstDll = LoadLibrary(dllName);
|
|
if (hinstDll)
|
|
{
|
|
DLLGETVERSIONPROC pDllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hinstDll, "DllGetVersion");
|
|
if (pDllGetVersion)
|
|
{
|
|
DLLVERSIONINFO dvi;
|
|
ZeroMemory(&dvi, sizeof(dvi));
|
|
dvi.cbSize = sizeof(dvi);
|
|
HRESULT hr = (*pDllGetVersion)(&dvi);
|
|
if (SUCCEEDED(hr))
|
|
dwVersion = MAKELONG(dvi.dwMinorVersion, dvi.dwMajorVersion);
|
|
}
|
|
FreeLibrary(hinstDll);
|
|
}
|
|
return dwVersion;
|
|
}
|
|
|
|
#endif
|
|
|
|
bool g_IsSmallScreen = false;
|
|
|
|
bool g_LVN_ITEMACTIVATE_Support = true;
|
|
// LVN_ITEMACTIVATE replaces both NM_DBLCLK & NM_RETURN
|
|
// Windows 2000
|
|
// NT/98 + IE 3 (g_ComCtl32Version >= 4.70)
|
|
|
|
|
|
const int kNumDefaultPanels = 1;
|
|
|
|
const int kSplitterWidth = 4;
|
|
int kSplitterRateMax = 1 << 16;
|
|
int kPanelSizeMin = 120;
|
|
|
|
// bool OnMenuCommand(HWND hWnd, int id);
|
|
|
|
#ifdef _WIN32
|
|
class CSplitterPos
|
|
{
|
|
int _ratio; // 10000 is max
|
|
int _pos;
|
|
int _fullWidth;
|
|
void SetRatioFromPos(HWND hWnd)
|
|
{ _ratio = (_pos + kSplitterWidth / 2) * kSplitterRateMax /
|
|
MyMax(GetWidth(hWnd), 1); }
|
|
public:
|
|
int GetPos() const
|
|
{ return _pos; }
|
|
int GetWidth(HWND hWnd) const
|
|
{
|
|
RECT rect;
|
|
::GetClientRect(hWnd, &rect);
|
|
return rect.right;
|
|
}
|
|
void SetRatio(HWND hWnd, int aRatio)
|
|
{
|
|
_ratio = aRatio;
|
|
SetPosFromRatio(hWnd);
|
|
}
|
|
void SetPosPure(HWND hWnd, int pos)
|
|
{
|
|
int posMax = GetWidth(hWnd) - kSplitterWidth;
|
|
if (posMax < kPanelSizeMin * 2)
|
|
pos = posMax / 2;
|
|
else
|
|
{
|
|
if (pos > posMax - kPanelSizeMin)
|
|
pos = posMax - kPanelSizeMin;
|
|
else if (pos < kPanelSizeMin)
|
|
pos = kPanelSizeMin;
|
|
}
|
|
_pos = pos;
|
|
}
|
|
void SetPos(HWND hWnd, int pos)
|
|
{
|
|
_fullWidth = GetWidth(hWnd);
|
|
SetPosPure(hWnd, pos);
|
|
SetRatioFromPos(hWnd);
|
|
}
|
|
void SetPosFromRatio(HWND hWnd)
|
|
{
|
|
int fullWidth = GetWidth(hWnd);
|
|
if (_fullWidth != fullWidth && fullWidth != 0)
|
|
{
|
|
_fullWidth = fullWidth;
|
|
SetPosPure(hWnd, GetWidth(hWnd) * _ratio / kSplitterRateMax - kSplitterWidth / 2);
|
|
}
|
|
}
|
|
};
|
|
|
|
static bool g_CanChangeSplitter = false;
|
|
static UInt32 g_SplitterPos = 0;
|
|
static CSplitterPos g_Splitter;
|
|
#endif
|
|
static bool g_PanelsInfoDefined = false;
|
|
|
|
static int g_StartCaptureMousePos;
|
|
static int g_StartCaptureSplitterPos;
|
|
|
|
CApp g_App;
|
|
|
|
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
|
|
|
|
const wchar_t *kWindowClass = L"FM";
|
|
|
|
#ifdef UNDER_CE
|
|
#define WS_OVERLAPPEDWINDOW ( \
|
|
WS_OVERLAPPED | \
|
|
WS_CAPTION | \
|
|
WS_SYSMENU | \
|
|
WS_THICKFRAME | \
|
|
WS_MINIMIZEBOX | \
|
|
WS_MAXIMIZEBOX)
|
|
#endif
|
|
|
|
// FUNCTION: InitInstance(HANDLE, int)
|
|
static BOOL InitInstance(int nCmdShow)
|
|
{
|
|
CWindow wnd;
|
|
|
|
// LoadString(hInstance, IDS_CLASS, windowClass, MAX_LOADSTRING);
|
|
|
|
UString title = L"7-Zip (ALPHA Software)"; // LangString(IDS_APP_TITLE, 0x03000000);
|
|
|
|
/*
|
|
//If it is already running, then focus on the window
|
|
hWnd = FindWindow(windowClass, title);
|
|
if (hWnd)
|
|
{
|
|
SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
#ifdef _WIN32
|
|
WNDCLASSW wc;
|
|
|
|
// wc.style = CS_HREDRAW | CS_VREDRAW;
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = (WNDPROC) WndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = g_hInstance;
|
|
wc.hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_ICON));
|
|
|
|
// wc.hCursor = LoadCursor (NULL, IDC_ARROW);
|
|
wc.hCursor = ::LoadCursor(0, IDC_SIZEWE);
|
|
// wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
|
|
wc.hbrBackground = (HBRUSH) (COLOR_BTNFACE + 1);
|
|
|
|
wc.lpszMenuName =
|
|
#ifdef UNDER_CE
|
|
0
|
|
#else
|
|
MAKEINTRESOURCEW(IDM_MENU)
|
|
#endif
|
|
;
|
|
|
|
wc.lpszClassName = kWindowClass;
|
|
|
|
MyRegisterClass(&wc);
|
|
|
|
// RECT rect;
|
|
// GetClientRect(hWnd, &rect);
|
|
|
|
DWORD style = WS_OVERLAPPEDWINDOW;
|
|
// DWORD style = 0;
|
|
|
|
CWindowInfo info;
|
|
info.maximized = false;
|
|
int x, y, xSize, ySize;
|
|
x = y = xSize = ySize = CW_USEDEFAULT;
|
|
bool windowPosIsRead;
|
|
info.Read(windowPosIsRead, g_PanelsInfoDefined);
|
|
|
|
if (windowPosIsRead)
|
|
{
|
|
// x = rect.left;
|
|
// y = rect.top;
|
|
xSize = RECT_SIZE_X(info.rect);
|
|
ySize = RECT_SIZE_Y(info.rect);
|
|
}
|
|
|
|
|
|
if (g_PanelsInfoDefined)
|
|
{
|
|
g_SplitterPos = info.splitterPos;
|
|
if (info.numPanels < 1 || info.numPanels > 2)
|
|
info.numPanels = kNumDefaultPanels;
|
|
if (info.currentPanel >= 2)
|
|
info.currentPanel = 0;
|
|
}
|
|
else
|
|
{
|
|
info.numPanels = kNumDefaultPanels;
|
|
info.currentPanel = 0;
|
|
}
|
|
#endif
|
|
g_App.NumPanels = kNumDefaultPanels; // FIXME info.numPanels;
|
|
g_App.LastFocusedPanel = 0; // FIXME info.currentPanel;
|
|
|
|
#ifdef _WIN32
|
|
if (!wnd.Create(kWindowClass, title, style,
|
|
x, y, xSize, ySize, NULL, NULL, g_hInstance, NULL))
|
|
return FALSE;
|
|
#else
|
|
{
|
|
extern HWND myCreateAndShowMainWindow(LPCTSTR title,void (*fct)(HWND));
|
|
g_HWND = myCreateAndShowMainWindow(title,local_WM_CREATE);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
if (nCmdShow == SW_SHOWNORMAL ||
|
|
nCmdShow == SW_SHOW
|
|
#ifndef UNDER_CE
|
|
|| nCmdShow == SW_SHOWDEFAULT
|
|
#endif
|
|
)
|
|
{
|
|
if (info.maximized)
|
|
nCmdShow = SW_SHOWMAXIMIZED;
|
|
else
|
|
nCmdShow = SW_SHOWNORMAL;
|
|
}
|
|
|
|
if (nCmdShow == SW_SHOWMAXIMIZED)
|
|
g_Maximized = true;
|
|
|
|
#ifndef UNDER_CE
|
|
WINDOWPLACEMENT placement;
|
|
placement.length = sizeof(placement);
|
|
if (wnd.GetPlacement(&placement))
|
|
{
|
|
if (windowPosIsRead)
|
|
placement.rcNormalPosition = info.rect;
|
|
placement.showCmd = nCmdShow;
|
|
wnd.SetPlacement(&placement);
|
|
}
|
|
else
|
|
#endif
|
|
wnd.Show(nCmdShow);
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
static void GetCommands(const UString &aCommandLine, UString &aCommands)
|
|
{
|
|
UString aProgramName;
|
|
aCommands.Empty();
|
|
bool aQuoteMode = false;
|
|
for (int i = 0; i < aCommandLine.Length(); i++)
|
|
{
|
|
wchar_t aChar = aCommandLine[i];
|
|
if (aChar == L'\"')
|
|
aQuoteMode = !aQuoteMode;
|
|
else if (aChar == L' ' && !aQuoteMode)
|
|
{
|
|
if (!aQuoteMode)
|
|
{
|
|
i++;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
aProgramName += aChar;
|
|
}
|
|
aCommands = aCommandLine.Ptr(i);
|
|
}
|
|
*/
|
|
|
|
/*
|
|
#ifndef _WIN64
|
|
typedef BOOL (WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
|
|
|
|
static bool IsWow64()
|
|
{
|
|
LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(
|
|
GetModuleHandle("kernel32"), "IsWow64Process");
|
|
if (fnIsWow64Process == NULL)
|
|
return false;
|
|
BOOL isWow;
|
|
if (!fnIsWow64Process(GetCurrentProcess(),&isWow))
|
|
return false;
|
|
return isWow != FALSE;
|
|
}
|
|
#endif
|
|
*/
|
|
|
|
bool IsLargePageSupported()
|
|
{
|
|
#ifdef _WIN64
|
|
return true;
|
|
#elif defined(_WIN32)
|
|
OSVERSIONINFO versionInfo;
|
|
versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
|
|
if (!::GetVersionEx(&versionInfo))
|
|
return false;
|
|
if (versionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || versionInfo.dwMajorVersion < 5)
|
|
return false;
|
|
if (versionInfo.dwMajorVersion > 5)
|
|
return true;
|
|
if (versionInfo.dwMinorVersion < 1)
|
|
return false;
|
|
if (versionInfo.dwMinorVersion > 1)
|
|
return true;
|
|
// return IsWow64();
|
|
return false;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
#if 0 // ifndef UNDER_CE
|
|
|
|
static void SetMemoryLock()
|
|
{
|
|
if (!IsLargePageSupported())
|
|
return;
|
|
// if (ReadLockMemoryAdd())
|
|
NSecurity::AddLockMemoryPrivilege();
|
|
|
|
if (ReadLockMemoryEnable())
|
|
NSecurity::EnablePrivilege_LockMemory();
|
|
}
|
|
|
|
bool g_SymLink_Supported = false;
|
|
|
|
static void Set_SymLink_Supported()
|
|
{
|
|
g_SymLink_Supported = false;
|
|
OSVERSIONINFO versionInfo;
|
|
versionInfo.dwOSVersionInfoSize = sizeof(versionInfo);
|
|
if (!::GetVersionEx(&versionInfo))
|
|
return;
|
|
if (versionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || versionInfo.dwMajorVersion < 6)
|
|
return;
|
|
g_SymLink_Supported = true;
|
|
// if (g_SymLink_Supported)
|
|
{
|
|
NSecurity::EnablePrivilege_SymLink();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
static const int kNumSwitches = 1;
|
|
|
|
namespace NKey {
|
|
enum Enum
|
|
{
|
|
kOpenArachive = 0
|
|
};
|
|
|
|
}
|
|
|
|
static const CSwitchForm kSwitchForms[kNumSwitches] =
|
|
{
|
|
{ L"SOA", NSwitchType::kSimple, false },
|
|
};
|
|
*/
|
|
|
|
// int APIENTRY WinMain2(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */, LPSTR /* lpCmdLine */, int /* nCmdShow */);
|
|
|
|
static void ErrorMessage(const wchar_t *s)
|
|
{
|
|
MessageBoxW(0, s, L"7-Zip", MB_ICONERROR);
|
|
}
|
|
|
|
|
|
#define NT_CHECK_FAIL_ACTION ErrorMessage(L"Unsupported Windows version"); return 1;
|
|
#ifdef _WIN32
|
|
static int WINAPI WinMain2(int nCmdShow)
|
|
{
|
|
g_RAM_Size = NSystem::GetRamSize();
|
|
|
|
#ifdef _WIN32
|
|
|
|
/*
|
|
#ifndef _WIN64
|
|
#ifndef UNDER_CE
|
|
{
|
|
HMODULE hMod = GetModuleHandle("Kernel32.dll");
|
|
if (hMod)
|
|
{
|
|
typedef BOOL (WINAPI *PSETDEP)(DWORD);
|
|
#define MY_PROCESS_DEP_ENABLE 1
|
|
PSETDEP procSet = (PSETDEP)GetProcAddress(hMod,"SetProcessDEPPolicy");
|
|
if (procSet)
|
|
procSet(MY_PROCESS_DEP_ENABLE);
|
|
|
|
typedef BOOL (WINAPI *HSI)(HANDLE, HEAP_INFORMATION_CLASS ,PVOID, SIZE_T);
|
|
HSI hsi = (HSI)GetProcAddress(hMod, "HeapSetInformation");
|
|
#define MY_HeapEnableTerminationOnCorruption ((HEAP_INFORMATION_CLASS)1)
|
|
if (hsi)
|
|
hsi(NULL, MY_HeapEnableTerminationOnCorruption, NULL, 0);
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
*/
|
|
|
|
NT_CHECK
|
|
SetLargePageSize();
|
|
|
|
#endif
|
|
|
|
LoadLangOneTime();
|
|
|
|
InitCommonControls();
|
|
|
|
#ifndef UNDER_CE
|
|
g_ComCtl32Version = ::GetDllVersion(TEXT("comctl32.dll"));
|
|
g_LVN_ITEMACTIVATE_Support = (g_ComCtl32Version >= MAKELONG(71, 4));
|
|
#endif
|
|
|
|
g_IsSmallScreen = !NWindows::NControl::IsDialogSizeOK(200, 200);
|
|
|
|
// OleInitialize is required for drag and drop.
|
|
#ifndef UNDER_CE
|
|
OleInitialize(NULL);
|
|
#endif
|
|
// Maybe needs CoInitializeEx also ?
|
|
// NCOM::CComInitializer comInitializer;
|
|
|
|
UString commandsString;
|
|
// MessageBoxW(0, GetCommandLineW(), L"", 0);
|
|
|
|
#ifdef UNDER_CE
|
|
commandsString = GetCommandLineW();
|
|
#else
|
|
UString programString;
|
|
SplitStringToTwoStrings(GetCommandLineW(), programString, commandsString);
|
|
#endif
|
|
|
|
commandsString.Trim();
|
|
UString paramString, tailString;
|
|
SplitStringToTwoStrings(commandsString, paramString, tailString);
|
|
paramString.Trim();
|
|
tailString.Trim();
|
|
if (tailString.IsPrefixedBy(L"-t"))
|
|
g_ArcFormat = tailString.Ptr(2);
|
|
|
|
/*
|
|
UStringVector switches;
|
|
for (;;)
|
|
{
|
|
if (tailString.IsEmpty())
|
|
break;
|
|
UString s1, s2;
|
|
SplitStringToTwoStrings(tailString, s1, s2);
|
|
if (s2.IsEmpty())
|
|
{
|
|
tailString.Trim();
|
|
switches.Add(tailString);
|
|
break;
|
|
}
|
|
s1.Trim();
|
|
switches.Add(s1);
|
|
tailString = s2;
|
|
}
|
|
|
|
FOR_VECTOR(i, switches)
|
|
{
|
|
const UString &sw = switches[i];
|
|
if (sw.IsPrefixedBy(L"-t"))
|
|
g_ArcFormat = sw.Ptr(2);
|
|
//
|
|
else if (sw.IsPrefixedBy(L"-stp"))
|
|
{
|
|
const wchar_t *end;
|
|
UInt32 val = ConvertStringToUInt32(sw.Ptr(4), &end);
|
|
if (*end != 0)
|
|
throw 111;
|
|
g_TypeParseLevel = val;
|
|
}
|
|
else
|
|
//
|
|
throw 112;
|
|
}
|
|
*/
|
|
|
|
if (!paramString.IsEmpty())
|
|
{
|
|
g_MainPath = paramString;
|
|
// return WinMain2(hInstance, hPrevInstance, lpCmdLine, nCmdShow);
|
|
|
|
// MessageBoxW(0, paramString, L"", 0);
|
|
}
|
|
/*
|
|
UStringVector commandStrings;
|
|
NCommandLineParser::SplitCommandLine(GetCommandLineW(), commandStrings);
|
|
NCommandLineParser::CParser parser(kNumSwitches);
|
|
try
|
|
{
|
|
parser.ParseStrings(kSwitchForms, commandStrings);
|
|
const UStringVector &nonSwitchStrings = parser.NonSwitchStrings;
|
|
if (nonSwitchStrings.Size() > 1)
|
|
{
|
|
g_MainPath = nonSwitchStrings[1];
|
|
// g_OpenArchive = parser[NKey::kOpenArachive].ThereIs;
|
|
CFileInfoW fileInfo;
|
|
if (FindFile(g_MainPath, fileInfo))
|
|
{
|
|
if (!fileInfo.IsDir())
|
|
g_OpenArchive = true;
|
|
}
|
|
}
|
|
}
|
|
catch(...) { }
|
|
*/
|
|
|
|
|
|
#if defined(_WIN32) && !defined(UNDER_CE)
|
|
SetMemoryLock();
|
|
Set_SymLink_Supported();
|
|
#endif
|
|
|
|
g_App.ReloadLang();
|
|
|
|
MSG msg;
|
|
if (!InitInstance (nCmdShow))
|
|
return FALSE;
|
|
|
|
// we will load Global_Codecs at first use instead.
|
|
/*
|
|
OutputDebugStringW(L"Before LoadGlobalCodecs");
|
|
LoadGlobalCodecs();
|
|
OutputDebugStringW(L"After LoadGlobalCodecs");
|
|
*/
|
|
|
|
#ifndef _UNICODE
|
|
if (g_IsNT)
|
|
{
|
|
HACCEL hAccels = LoadAcceleratorsW(g_hInstance, MAKEINTRESOURCEW(IDR_ACCELERATOR1));
|
|
while (GetMessageW(&msg, NULL, 0, 0))
|
|
{
|
|
if (TranslateAcceleratorW(g_HWND, hAccels, &msg) == 0)
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessageW(&msg);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
HACCEL hAccels = LoadAccelerators(g_hInstance, MAKEINTRESOURCE(IDR_ACCELERATOR1));
|
|
while (GetMessage(&msg, NULL, 0, 0))
|
|
{
|
|
if (TranslateAccelerator(g_HWND, hAccels, &msg) == 0)
|
|
{
|
|
// if (g_Hwnd != NULL || !IsDialogMessage(g_Hwnd, &msg))
|
|
// if (!IsDialogMessage(g_Hwnd, &msg))
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Destructor of g_CodecsReleaser can release DLLs.
|
|
// But we suppose that it's better to release DLLs here (before destructor).
|
|
FreeGlobalCodecs();
|
|
|
|
g_HWND = 0;
|
|
#ifndef UNDER_CE
|
|
OleUninitialize();
|
|
#endif
|
|
return (int)msg.wParam;
|
|
}
|
|
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
|
|
#ifdef UNDER_CE
|
|
LPWSTR
|
|
#else
|
|
LPSTR
|
|
#endif
|
|
/* lpCmdLine */, int nCmdShow)
|
|
{
|
|
g_hInstance = hInstance;
|
|
|
|
try
|
|
{
|
|
return WinMain2(nCmdShow);
|
|
}
|
|
catch(const CNewException &)
|
|
{
|
|
ErrorMessage(LangString(IDS_MEM_ERROR));
|
|
return 1;
|
|
}
|
|
catch(const UString &s)
|
|
{
|
|
ErrorMessage(s);
|
|
return 1;
|
|
}
|
|
catch(const AString &s)
|
|
{
|
|
ErrorMessage(GetUnicodeString(s));
|
|
return 1;
|
|
}
|
|
catch(const wchar_t *s)
|
|
{
|
|
ErrorMessage(s);
|
|
return 1;
|
|
}
|
|
catch(const char *s)
|
|
{
|
|
ErrorMessage(GetUnicodeString(s));
|
|
return 1;
|
|
}
|
|
catch(int v)
|
|
{
|
|
wchar_t s[32];
|
|
ConvertUInt32ToString(v, s);
|
|
ErrorMessage(UString(L"Error: ") + s);
|
|
return 1;
|
|
}
|
|
catch(...)
|
|
{
|
|
ErrorMessage(L"Unknown error");
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
static void SaveWindowInfo(HWND aWnd)
|
|
{
|
|
CWindowInfo info;
|
|
|
|
#ifdef UNDER_CE
|
|
|
|
if (!::GetWindowRect(aWnd, &info.rect))
|
|
return;
|
|
info.maximized = g_Maximized;
|
|
|
|
#else
|
|
|
|
WINDOWPLACEMENT placement;
|
|
placement.length = sizeof(placement);
|
|
if (!::GetWindowPlacement(aWnd, &placement))
|
|
return;
|
|
info.rect = placement.rcNormalPosition;
|
|
info.maximized = BOOLToBool(::IsZoomed(aWnd));
|
|
|
|
#endif
|
|
|
|
info.numPanels = g_App.NumPanels;
|
|
info.currentPanel = g_App.LastFocusedPanel;
|
|
info.splitterPos = g_Splitter.GetPos();
|
|
|
|
info.Save();
|
|
}
|
|
#else
|
|
int Main1(int argc,TCHAR **argv)
|
|
{
|
|
if (argc >= 2)
|
|
{
|
|
g_MainPath = argv[1];
|
|
}
|
|
|
|
if (!InitInstance (0))
|
|
return FALSE;
|
|
|
|
MyLoadMenu();
|
|
|
|
// FIXME : install Accelerators ?
|
|
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* FIXME static */ void ExecuteCommand(UINT commandID)
|
|
{
|
|
CPanel::CDisableTimerProcessing disableTimerProcessing1(g_App.Panels[0]);
|
|
CPanel::CDisableTimerProcessing disableTimerProcessing2(g_App.Panels[1]);
|
|
|
|
switch (commandID)
|
|
{
|
|
case kMenuCmdID_Toolbar_Add: g_App.AddToArchive(); break;
|
|
case kMenuCmdID_Toolbar_Extract: g_App.ExtractArchives(); break;
|
|
case kMenuCmdID_Toolbar_Test: g_App.TestArchives(); break;
|
|
}
|
|
}
|
|
|
|
static void local_WM_CREATE(HWND hWnd)
|
|
{
|
|
printf("**local_WM_CREATE**\n");
|
|
|
|
int xSizes[2] = { 0,0 };
|
|
|
|
// g_App.CreateDragTarget();
|
|
bool archiveIsOpened;
|
|
bool encrypted;
|
|
bool needOpenFile = false;
|
|
if (!g_MainPath.IsEmpty() /* && g_OpenArchive */)
|
|
{
|
|
if (NFile::NFind::DoesFileExist(us2fs(g_MainPath)))
|
|
needOpenFile = true;
|
|
}
|
|
HRESULT res = g_App.Create(hWnd, g_MainPath, g_ArcFormat, xSizes, archiveIsOpened, encrypted);
|
|
|
|
if (res == E_ABORT)
|
|
{
|
|
return ; // -1;
|
|
}
|
|
if (needOpenFile && !archiveIsOpened || res != S_OK)
|
|
{
|
|
UString message = L"Error";
|
|
if (res == S_FALSE || res == S_OK)
|
|
{
|
|
message = MyFormatNew(encrypted ?
|
|
IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
|
|
IDS_CANT_OPEN_ARCHIVE,
|
|
g_MainPath);
|
|
}
|
|
else if (res != S_OK)
|
|
message = HResultToMessage(res);
|
|
ErrorMessage(message);
|
|
return ; // -1;
|
|
}
|
|
// g_SplitterPos = 0;
|
|
|
|
// ::DragAcceptFiles(hWnd, TRUE);
|
|
// RegisterDragDrop(hWnd, g_App._dropTarget);
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int wmId, wmEvent;
|
|
switch (message)
|
|
{
|
|
case WM_COMMAND:
|
|
wmId = LOWORD(wParam);
|
|
wmEvent = HIWORD(wParam);
|
|
if ((HWND) lParam != NULL && wmEvent != 0)
|
|
break;
|
|
if (wmId >= kMenuCmdID_Toolbar_Start && wmId < kMenuCmdID_Toolbar_End)
|
|
{
|
|
ExecuteCommand(wmId);
|
|
return 0;
|
|
}
|
|
if (OnMenuCommand(hWnd, wmId))
|
|
return 0;
|
|
break;
|
|
case WM_INITMENUPOPUP:
|
|
OnMenuActivating(hWnd, HMENU(wParam), LOWORD(lParam));
|
|
break;
|
|
|
|
/*
|
|
It doesn't help
|
|
case WM_EXITMENULOOP:
|
|
{
|
|
OnMenuUnActivating(hWnd);
|
|
break;
|
|
}
|
|
case WM_UNINITMENUPOPUP:
|
|
OnMenuUnActivating(hWnd, HMENU(wParam), lParam);
|
|
break;
|
|
*/
|
|
|
|
case WM_CREATE:
|
|
{
|
|
g_HWND = hWnd;
|
|
/*
|
|
INITCOMMONCONTROLSEX icex;
|
|
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
icex.dwICC = ICC_BAR_CLASSES;
|
|
InitCommonControlsEx(&icex);
|
|
|
|
// Toolbar buttons used to create the first 4 buttons.
|
|
TBBUTTON tbb [ ] =
|
|
{
|
|
// {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
|
|
// {VIEW_PARENTFOLDER, kParentFolderID, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
|
|
// {0, 0, TBSTATE_ENABLED, BTNS_SEP, 0L, 0},
|
|
{VIEW_NEWFOLDER, ID_FILE_CREATEFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, 0L, 0},
|
|
};
|
|
|
|
int baseID = 100;
|
|
NWindows::NControl::CToolBar aToolBar;
|
|
aToolBar.Attach(::CreateToolbarEx (hWnd,
|
|
WS_CHILD | WS_BORDER | WS_VISIBLE | TBSTYLE_TOOLTIPS, // | TBSTYLE_FLAT
|
|
baseID + 2, 11,
|
|
(HINSTANCE)HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR,
|
|
(LPCTBBUTTON)&tbb, ARRAY_SIZE(tbb),
|
|
0, 0, 100, 30, sizeof (TBBUTTON)));
|
|
*/
|
|
// HCURSOR cursor = ::LoadCursor(0, IDC_SIZEWE);
|
|
// ::SetCursor(cursor);
|
|
|
|
if (g_PanelsInfoDefined)
|
|
g_Splitter.SetPos(hWnd, g_SplitterPos);
|
|
else
|
|
{
|
|
g_Splitter.SetRatio(hWnd, kSplitterRateMax / 2);
|
|
g_SplitterPos = g_Splitter.GetPos();
|
|
}
|
|
|
|
RECT rect;
|
|
::GetClientRect(hWnd, &rect);
|
|
int xSize = rect.right;
|
|
int xSizes[2];
|
|
xSizes[0] = g_Splitter.GetPos();
|
|
xSizes[1] = xSize - kSplitterWidth - xSizes[0];
|
|
if (xSizes[1] < 0)
|
|
xSizes[1] = 0;
|
|
|
|
g_App.CreateDragTarget();
|
|
|
|
bool archiveIsOpened;
|
|
bool encrypted;
|
|
bool needOpenFile = false;
|
|
|
|
UString fullPath = g_MainPath;
|
|
if (!fullPath.IsEmpty() /* && g_OpenArchive */)
|
|
{
|
|
if (!NFile::NName::IsAbsolutePath(fullPath))
|
|
{
|
|
FString fullPathF;
|
|
if (NFile::NName::GetFullPath(us2fs(fullPath), fullPathF))
|
|
fullPath = fs2us(fullPathF);
|
|
}
|
|
if (NFile::NFind::DoesFileExist(us2fs(fullPath)))
|
|
needOpenFile = true;
|
|
}
|
|
|
|
HRESULT res = g_App.Create(hWnd, fullPath, g_ArcFormat, xSizes, archiveIsOpened, encrypted);
|
|
|
|
if (res == E_ABORT)
|
|
return -1;
|
|
|
|
if (needOpenFile && !archiveIsOpened || res != S_OK)
|
|
{
|
|
UString message = L"Error";
|
|
if (res == S_FALSE || res == S_OK)
|
|
{
|
|
message = MyFormatNew(encrypted ?
|
|
IDS_CANT_OPEN_ENCRYPTED_ARCHIVE :
|
|
IDS_CANT_OPEN_ARCHIVE,
|
|
fullPath);
|
|
}
|
|
else if (res != S_OK)
|
|
message = HResultToMessage(res);
|
|
ErrorMessage(message);
|
|
return -1;
|
|
}
|
|
|
|
// g_SplitterPos = 0;
|
|
|
|
// ::DragAcceptFiles(hWnd, TRUE);
|
|
RegisterDragDrop(hWnd, g_App._dropTarget);
|
|
|
|
break;
|
|
}
|
|
|
|
case WM_DESTROY:
|
|
{
|
|
// ::DragAcceptFiles(hWnd, FALSE);
|
|
RevokeDragDrop(hWnd);
|
|
g_App._dropTarget.Release();
|
|
|
|
g_App.Save();
|
|
g_App.Release();
|
|
SaveWindowInfo(hWnd);
|
|
PostQuitMessage(0);
|
|
break;
|
|
}
|
|
/*
|
|
case WM_MOVE:
|
|
{
|
|
break;
|
|
}
|
|
*/
|
|
case WM_LBUTTONDOWN:
|
|
g_StartCaptureMousePos = LOWORD(lParam);
|
|
g_StartCaptureSplitterPos = g_Splitter.GetPos();
|
|
::SetCapture(hWnd);
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
{
|
|
::ReleaseCapture();
|
|
break;
|
|
}
|
|
|
|
case WM_MOUSEMOVE:
|
|
{
|
|
if ((wParam & MK_LBUTTON) != 0 && ::GetCapture() == hWnd)
|
|
{
|
|
g_Splitter.SetPos(hWnd, g_StartCaptureSplitterPos +
|
|
(short)LOWORD(lParam) - g_StartCaptureMousePos);
|
|
g_App.MoveSubWindows();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_SIZE:
|
|
{
|
|
if (g_CanChangeSplitter)
|
|
g_Splitter.SetPosFromRatio(hWnd);
|
|
else
|
|
{
|
|
g_Splitter.SetPos(hWnd, g_SplitterPos );
|
|
g_CanChangeSplitter = true;
|
|
}
|
|
|
|
g_Maximized = (wParam == SIZE_MAXIMIZED) || (wParam == SIZE_MAXSHOW);
|
|
|
|
g_App.MoveSubWindows();
|
|
/*
|
|
int xSize = LOWORD(lParam);
|
|
int ySize = HIWORD(lParam);
|
|
// int xSplitter = 2;
|
|
int xWidth = g_SplitPos;
|
|
// int xSplitPos = xWidth;
|
|
g_Panel[0]._listView.MoveWindow(0, 0, xWidth, ySize);
|
|
g_Panel[1]._listView.MoveWindow(xSize - xWidth, 0, xWidth, ySize);
|
|
*/
|
|
return 0;
|
|
break;
|
|
}
|
|
|
|
case WM_SETFOCUS:
|
|
// g_App.SetFocus(g_App.LastFocusedPanel);
|
|
g_App.SetFocusToLastItem();
|
|
break;
|
|
|
|
/*
|
|
case WM_ACTIVATE:
|
|
{
|
|
int fActive = LOWORD(wParam);
|
|
switch (fActive)
|
|
{
|
|
case WA_INACTIVE:
|
|
{
|
|
// g_FocusIndex = g_App.LastFocusedPanel;
|
|
// g_App.LastFocusedPanel = g_App.GetFocusedPanelIndex();
|
|
// return 0;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
*/
|
|
|
|
/*
|
|
case kLangWasChangedMessage:
|
|
MyLoadMenu();
|
|
return 0;
|
|
*/
|
|
|
|
/*
|
|
case WM_SETTINGCHANGE:
|
|
break;
|
|
*/
|
|
|
|
case WM_NOTIFY:
|
|
{
|
|
g_App.OnNotify((int)wParam, (LPNMHDR)lParam);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
case WM_DROPFILES:
|
|
{
|
|
g_App.GetFocusedPanel().CompressDropFiles((HDROP)wParam);
|
|
return 0 ;
|
|
}
|
|
*/
|
|
}
|
|
#ifndef _UNICODE
|
|
if (g_IsNT)
|
|
return DefWindowProcW(hWnd, message, wParam, lParam);
|
|
else
|
|
#endif
|
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
|
|
|
}
|
|
|
|
static int Window_GetRealHeight(NWindows::CWindow &w)
|
|
{
|
|
RECT rect;
|
|
w.GetWindowRect(&rect);
|
|
int res = RECT_SIZE_Y(rect);
|
|
#ifndef UNDER_CE
|
|
WINDOWPLACEMENT placement;
|
|
if (w.GetPlacement(&placement))
|
|
res += placement.rcNormalPosition.top;
|
|
#endif
|
|
return res;
|
|
}
|
|
|
|
void CApp::MoveSubWindows()
|
|
{
|
|
HWND hWnd = _window;
|
|
RECT rect;
|
|
if (hWnd == 0)
|
|
return;
|
|
::GetClientRect(hWnd, &rect);
|
|
int xSize = rect.right;
|
|
if (xSize == 0)
|
|
return;
|
|
int headerSize = 0;
|
|
#ifdef UNDER_CE
|
|
_commandBar.AutoSize();
|
|
{
|
|
_commandBar.Show(true); // maybe we need it for
|
|
headerSize += _commandBar.Height();
|
|
}
|
|
#endif
|
|
if (_toolBar)
|
|
{
|
|
_toolBar.AutoSize();
|
|
#ifdef UNDER_CE
|
|
int h2 = Window_GetRealHeight(_toolBar);
|
|
_toolBar.Move(0, headerSize, xSize, h2);
|
|
#endif
|
|
headerSize += Window_GetRealHeight(_toolBar);
|
|
}
|
|
int ySize = MyMax((int)(rect.bottom - headerSize), 0);
|
|
|
|
if (NumPanels > 1)
|
|
{
|
|
Panels[0].Move(0, headerSize, g_Splitter.GetPos(), ySize);
|
|
int xWidth1 = g_Splitter.GetPos() + kSplitterWidth;
|
|
Panels[1].Move(xWidth1, headerSize, xSize - xWidth1, ySize);
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
int otherPanel = 1 - LastFocusedPanel;
|
|
if (PanelsCreated[otherPanel])
|
|
Panels[otherPanel].Move(0, headerSize, 0, ySize);
|
|
*/
|
|
Panels[LastFocusedPanel].Move(0, headerSize, xSize, ySize);
|
|
}
|
|
}
|
|
#else
|
|
void main_WM_DESTROY()
|
|
{
|
|
// // ::DragAcceptFiles(hWnd, FALSE);
|
|
// RevokeDragDrop(hWnd);
|
|
// g_App._dropTarget.Release();
|
|
|
|
g_App.Save();
|
|
g_App.Release();
|
|
// SaveWindowInfo(hWnd);
|
|
// PostQuitMessage(0);
|
|
}
|
|
#endif
|
|
|
|
|
|
// for mac
|
|
void doMacOpenFile( const UString & fileName )
|
|
{
|
|
g_App.GetFocusedPanel().BindToPathAndRefresh(fileName);
|
|
}
|
|
|