// wxGUI.cpp

#include "StdAfx.h"

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"
 
#ifdef __BORLANDC__
    #pragma hdrstop
#endif

// for all others, include the necessary headers (this file is usually all you
// need because it includes almost all "standard" wxWidgets headers)
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#undef _WIN32

#ifdef __WXMAC__

#define UInt32 max_UInt32
#include <ApplicationServices/ApplicationServices.h>
#undef UInt32

#endif

#define static const
#include "../GUI/p7zip_32.xpm"
#undef static

#undef ACTIVATE_DIALOG_TESTS

#ifdef _WIN32
#error 5
#endif

#include "Windows/Window.h"
#include "Windows/Control/DialogImpl.h"

#include "Common/StringConvert.h"

bool GetProgramFolderPath(UString &folder)
{
  const char *p7zip_home_dir = getenv("P7ZIP_HOME_DIR");
  if (p7zip_home_dir == 0) p7zip_home_dir="./";

  folder = MultiByteToUnicodeString(p7zip_home_dir);

  return true;
}


// FIXME

static pthread_t g_main_thread;

bool is_main_thread(void)
{
	return ( g_main_thread == pthread_self() );
}

void verify_main_thread(void)
{
		if ( ! is_main_thread() )
		{
			printf("verify_main_thread-wxGUI\n");
			abort();
		}
}









int Main1(int argc,TCHAR **argv);

#include "Windows/Registry.h"
using namespace NWindows;
using namespace NRegistry;


#include "Common/StringConvert.h"
#include "Windows/FileDir.h"
#include "Windows/Synchronization.h"

#include "ExtractRes.h"
#include "../Explorer/MyMessages.h"

#include "../FileManager/resourceGui.h"
#include "ExtractGUI.h"
#include "UpdateGUI.h"
#include "BenchmarkDialog.h"
#include "../FileManager/RegistryUtils.h"

using namespace NWindows;
using namespace NFile;

#include "../FileManager/ProgramLocation.h"

static LPCWSTR kHelpFileName = L"help/";

void ShowHelpWindow(HWND hwnd, LPCWSTR topicFile)
{
  UString path;
  if (!::GetProgramFolderPath(path))
    return;
  path += kHelpFileName;
  path += topicFile;
  printf("ShowHelpWindow(%p,%ls)=>%ls\n",hwnd,topicFile,(const wchar_t *)path);
  // HtmlHelp(hwnd, GetSystemString(path), HH_DISPLAY_TOPIC, NULL);
  wxString path2(path);
  wxLaunchDefaultBrowser(path2);
}

////////////////////////////// TRIES ///////////////////////////////////

#ifdef ACTIVATE_DIALOG_TESTS
static void ErrorMessage(const wchar_t *message)
{
  MessageBox(0,message, wxT("7-Zip GUI"),wxICON_ERROR);
}

#include "../FileManager/PasswordDialog.h"
#include "../FileManager/MessagesDialog.h"
#include "../FileManager/OverwriteDialog.h"
#include "Windows/Thread.h"

void myErrorMsg(const wchar_t *message)
{
	MessageBox(0,message, wxT("Message"),wxICON_ERROR);
}

void testCMessagesDialog()
{
	UStringVector Messages;

	Messages.Add(L"message 1");
	Messages.Add(L"message 2");
	Messages.Add(L"message 3");
	Messages.Add(L"message 4");
	Messages.Add(L"message 5");
	Messages.Add(L"message 6");
	Messages.Add(L"message 7");
	Messages.Add(L"message 8");
	Messages.Add(L"message 9");

	CMessagesDialog messagesDialog;
    messagesDialog.Messages = &Messages;
   int ret = messagesDialog.Create( 0  ); // ParentWindow

   	if (ret == IDOK) myErrorMsg(wxT("CMessagesDialog => IDOK"));
	else if (ret == IDCANCEL) myErrorMsg(wxT("CMessagesDialog => IDCANCEL"));
	else  myErrorMsg(wxT("CMessagesDialog => ?"));

}

void testCOverwriteDialog()
{
SYSTEMTIME systemTime;
GetSystemTime( &systemTime );


const wchar_t *existName = L"existName";
FILETIME data_existTime;
FILETIME *existTime = &data_existTime ;
UInt64 data_existSize = 1234;
UInt64 *existSize = &data_existSize;
const wchar_t *newName = L"newName";
FILETIME data_newTime;
FILETIME *newTime = &data_newTime;
UInt64 data_newSize = 45678;
UInt64 *newSize = &data_newSize;
Int32 data_answer=0;
Int32 *answer = &data_answer;

SystemTimeToFileTime( &systemTime , &data_existTime);
SystemTimeToFileTime( &systemTime , &data_newTime);

  COverwriteDialog dialog;

  dialog.OldFileInfo.Time = *existTime;
  dialog.OldFileInfo.TimeIsDefined = true; // FIXME : look again at the sample !

  dialog.OldFileInfo.SizeIsDefined = (existSize != NULL);
  if (dialog.OldFileInfo.SizeIsDefined)
    dialog.OldFileInfo.Size = *existSize;
  dialog.OldFileInfo.Name = existName;

  if (newTime == 0)
    dialog.NewFileInfo.TimeIsDefined = false;
  else
  {
    dialog.NewFileInfo.TimeIsDefined = true;
    dialog.NewFileInfo.Time = *newTime;
  }
  
  dialog.NewFileInfo.SizeIsDefined = (newSize != NULL);
  if (dialog.NewFileInfo.SizeIsDefined)
    dialog.NewFileInfo.Size = *newSize;
  dialog.NewFileInfo.Name = newName;
  
  /*
  NOverwriteDialog::NResult::EEnum writeAnswer = 
    NOverwriteDialog::Execute(oldFileInfo, newFileInfo);
  */
  INT_PTR writeAnswer = dialog.Create(NULL); // ParentWindow doesn't work with 7z
  
  switch(writeAnswer)
  {
  case IDCANCEL: myErrorMsg(wxT("COverwriteDialog => IDCANCEL")); break;
  case IDNO:     myErrorMsg(wxT("COverwriteDialog => IDNO")); break;
  case IDC_BUTTON_OVERWRITE_NO_TO_ALL: myErrorMsg(wxT("COverwriteDialog => IDC_BUTTON_OVERWRITE_NO_TO_ALL")); break;
  case IDC_BUTTON_OVERWRITE_YES_TO_ALL:myErrorMsg(wxT("COverwriteDialog => IDC_BUTTON_OVERWRITE_YES_TO_ALL")); break;
  case IDC_BUTTON_OVERWRITE_AUTO_RENAME:myErrorMsg(wxT("COverwriteDialog => IDC_BUTTON_OVERWRITE_AUTO_RENAME")); break;
  case IDYES:  myErrorMsg(wxT("COverwriteDialog => IDYES")); break;
  default:  myErrorMsg(wxT("COverwriteDialog => default")); break;
  }
}

void testCPasswordDialog()
{
    CPasswordDialog dialog;

	int ret = dialog.Create(0);
	if (ret == IDOK) {
    		UString Password = dialog.Password;
		UString msg  = wxT("CPasswordDialog => IDOK password=\"");
		msg += Password;
		msg += wxT("\"");
		myErrorMsg(msg);
	}
	else if (ret == IDCANCEL) myErrorMsg(wxT("CPasswordDialog => IDCANCEL"));
	else  myErrorMsg(wxT("CPasswordDialog => ?"));

}

struct CThreadProgressDialog
{
  CProgressDialog * ProgressDialog;
  static THREAD_FUNC_DECL MyThreadFunction(void *param)
  {
    ((CThreadProgressDialog *)param)->Result = ((CThreadProgressDialog *)param)->Process();
    return 0;
  }
  HRESULT Result;
  HRESULT Process()
  {
	Sleep(1000);
	int total = 1000;

	ProgressDialog->ProgressSynch.SetTitleFileName(L"SetTitleFileName");
	ProgressDialog->ProgressSynch.SetNumFilesTotal(100);
	ProgressDialog->ProgressSynch.SetNumFilesCur(1);
	ProgressDialog->ProgressSynch.SetProgress(total, 0);
	// ProgressDialog.ProgressSynch.SetRatioInfo(inSize, outSize);
	// ProgressDialog.ProgressSynch.SetCurrentFileName(name);

	ProgressDialog->ProgressSynch.SetPos(total/10);
	ProgressDialog->ProgressSynch.SetCurrentFileName(L"File1");
	Sleep(1000);
	ProgressDialog->ProgressSynch.SetPos(total/2);
	ProgressDialog->ProgressSynch.SetCurrentFileName(L"File2");
	Sleep(1000);
	ProgressDialog->ProgressSynch.SetPos(total);
	ProgressDialog->ProgressSynch.SetCurrentFileName(L"File3");
	Sleep(1000);
	ProgressDialog->MyClose();
	return 0;
  }
};

void testCProgressDialog()
{
  CProgressDialog ProgressDialog;

  CThreadProgressDialog benchmarker;
  benchmarker.ProgressDialog = &ProgressDialog;
  NWindows::CThread thread;
  thread.Create(CThreadProgressDialog::MyThreadFunction, &benchmarker);

  //  void StartProgressDialog(const UString &title)
  int ret = ProgressDialog.Create(L"testCProgressDialog", 0);

	if (ret == IDOK) myErrorMsg(wxT("CProgressDialog => IDOK"));
	else if (ret == IDCANCEL) myErrorMsg(wxT("CProgressDialog => IDCANCEL"));
	else  myErrorMsg(wxT("CProgressDialog => ?"));

}

void testDialog(int num)
{
	NWindows::NControl::CModalDialog dialog;

	printf("Generic Dialog(%d)\n",num);
	int ret = dialog.Create(num, 0);
	if (ret == IDOK) myErrorMsg(wxT("Generic Dialog => IDOK"));
	else if (ret == IDCANCEL) myErrorMsg(wxT("Generic Dialog => IDCANCEL"));
	else  myErrorMsg(wxT("Generic Dialog => ?"));
}

void testMessageBox()
{
	int ret = MessageBoxW(0, L"test yes/no/cancel", 
            L"7-Zip", MB_YESNOCANCEL | MB_ICONQUESTION | MB_TASKMODAL);
	if (ret == IDYES) myErrorMsg(wxT("MessageBoxW => IDYES"));
	else if (ret == IDNO) myErrorMsg(wxT("MessageBoxW => IDNO"));
	else if (ret == IDCANCEL) myErrorMsg(wxT("MessageBoxW => IDCANCEL"));
	else  myErrorMsg(wxT("MessageBoxW => ?"));
}

static void testRegistry()
{
	SaveRegLang(L"fr");

	UString langFile;
	ReadRegLang(langFile);

	printf("testRegistry : -%ls-\n",(const wchar_t *)langFile);
}


int Main2(int argc,TCHAR **argv);

int Main3(int argc,wxChar **argv)
{
	testRegistry();

	int num = -1;

	if (argc >=2 )
	{
		num = argv[1][0] - L'0';
	}
	printf("num=%d\n",num);


	switch(num)
	{
		case 0:
		{
			TCHAR **argv2 = (TCHAR **)calloc(argc,sizeof(*argv));

			argv2[0] = argv[0];
			for(int i = 2; i < argc; i++) argv2[i-1] = argv[i];

			return Main2(argc-1,argv2);
		}
	// TODO Benchmark
	// TODO CCompressDialog
	// TODO CExtractDialog ?
		case 1 : testCMessagesDialog();  break;
		case 2 : testCOverwriteDialog(); break;
	 	case 3 : testCPasswordDialog();  break;
		case 4 : testCProgressDialog();  break;
		case 5 : testMessageBox();  break;
		case 9 : 
			if (argc >= 3)
			{
				AString str = GetAnsiString(argv[2]);
				int num = atoi((const char*)str);
				testDialog(num);
			}
			else
			{
				printf("usage : 7zG 9 <windowID>\n");
			}
		      	break;
		default :
			printf("usage : 7zG number\n");

	};

	return 0;
}

#endif // ACTIVATE_DIALOG_TESTS

static const TCHAR *kCUBasePath = TEXT("Software/7-ZIP");
static const WCHAR *kLangValueName = L"Lang";

void SaveRegLang(const UString &langFile)
{
  CKey key;
  key.Create(HKEY_CURRENT_USER, kCUBasePath);
  key.SetValue(kLangValueName, langFile);
}

void ReadRegLang(UString &langFile)
{
  langFile.Empty();
  CKey key;
  if (key.Open(HKEY_CURRENT_USER, kCUBasePath, KEY_READ) == ERROR_SUCCESS)
    key.QueryValue(kLangValueName, langFile);
}


//////////////////////////////////

#define NEED_NAME_WINDOWS_TO_UNIX
#include "myPrivate.h" // global_use_utf16_conversion

void mySplitCommandLineW(int numArguments, TCHAR  **arguments,UStringVector &parts) {

  parts.Clear();
  for(int ind=0;ind < numArguments; ind++) {
      UString tmp = arguments[ind];
      // tmp.Trim(); " " is a valid filename ...
      if (!tmp.IsEmpty()) {
        parts.Add(tmp);
// DEBUG printf("ARG %d : '%ls'\n",ind,(const wchar_t *)tmp);
      }
  }
}

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// Define a new frame type
class MyFrame: public wxFrame
{
public:
    // ctor
    MyFrame(wxFrame *frame, const wxString& title, int x, int y, int w, int h);
    // virtual ~MyFrame();

    // operations
    void WriteText(const wxString& text) { m_txtctrl->WriteText(text); }
    
protected:
    // callbacks
    void OnWorkerEvent(wxCommandEvent& event);
private:
    // just some place to put our messages in
    wxTextCtrl *m_txtctrl;
    DECLARE_EVENT_TABLE()
};

BEGIN_EVENT_TABLE(MyFrame, wxFrame)
    EVT_MENU(WORKER_EVENT, MyFrame::OnWorkerEvent)
    // EVT_IDLE(MyFrame::OnIdle)
END_EVENT_TABLE()

// My frame constructor
MyFrame::MyFrame(wxFrame *frame, const wxString& title,
                 int x, int y, int w, int h)
       : wxFrame(frame, wxID_ANY, title, wxPoint(x, y), wxSize(w, h))
{
	this->SetIcon(wxICON(p7zip_32));
    
#if wxUSE_STATUSBAR
    CreateStatusBar(2);
#endif // wxUSE_STATUSBAR

    m_txtctrl = new wxTextCtrl(this, wxID_ANY, _T(""), wxPoint(0, 0), wxSize(0, 0), wxTE_MULTILINE | wxTE_READONLY);
}

void myCreateHandle(int n);
wxWindow * g_window=0;

void MyFrame::OnWorkerEvent(wxCommandEvent& event)
{
	int n = event.GetInt();
	myCreateHandle(n);
}


// Define a new application type, each program should derive a class from wxApp
class MyApp : public wxApp
{
public:
    // override base class virtuals
    // ----------------------------

    // this one is called on application startup and is a good place for the app
    // initialization (doing it here and not in the ctor allows to have an error
    // return: if OnInit() returns false, the application terminates)
    virtual bool OnInit();
};

// Create a new application object: this macro will allow wxWidgets to create
// the application object during program execution (it's better than using a
// static object for many reasons) and also implements the accessor function
// wxGetApp() which will return the reference of the right type (i.e. MyApp and
// not wxApp)
IMPLEMENT_APP(MyApp)



time_t g_T0 = 0;

/* FIXME : to erase ?
class MyThread : public wxThread
{
	int _argc;
	TCHAR **_argv;
public:
	MyThread(int argc,TCHAR **argv): wxThread(),_argc(argc), _argv(argv) {}

	// thread execution starts here
	virtual void *Entry()
	{
#ifdef ACTIVATE_DIALOG_TESTS
		int ret = Main3(_argc,_argv);
#else
		int ret = Main1(_argc,_argv);
#endif
		exit(ret);
	}
};
*/

// 'Main program' equivalent: the program execution "starts" here
bool MyApp::OnInit()
{
    // don't parse the command-line options !
    // : if ( !wxApp::OnInit() ) return false;

#ifdef __WXMAC__
ProcessSerialNumber PSN;
GetCurrentProcess(&PSN);
TransformProcessType(&PSN,kProcessTransformToForegroundApplication);
#endif
	
	
	g_main_thread = pthread_self();

  { // define P7ZIP_HOME_DIR
    extern void my_windows_split_path(const AString &p_path, AString &dir , AString &base);
    static char p7zip_home_dir[MAX_PATH];

    UString fullPath;
    NDir::MyGetFullPathName(wxApp::argv[0], fullPath);
    AString afullPath = GetAnsiString(fullPath);

    AString dir,name;

    my_windows_split_path(afullPath,dir,name);

    const char *dir2 = nameWindowToUnix((const char *)dir);
    snprintf(p7zip_home_dir,sizeof(p7zip_home_dir),"P7ZIP_HOME_DIR=%s/",dir2);
    p7zip_home_dir[sizeof(p7zip_home_dir)-1] = 0;
    putenv(p7zip_home_dir);
    // DEBUG printf("putenv(%s)\n",p7zip_home_dir);
  }
  global_use_utf16_conversion = 1; // UNICODE !

  g_T0 = time(0);
  // DEBUG printf("MAIN Thread : 0x%lx\n",wxThread::GetCurrentId());

  // Create the main frame window
  MyFrame *frame = new MyFrame((wxFrame *)NULL, _T("7-zip Main Window"), 50, 50, 450, 340);
  // Don't Show the frame !
  // frame->Show(true);

  g_window = frame;

  SetTopWindow(frame);

/* FIXME ?	
    MyThread *thread = new MyThread(wxApp::argc,wxApp::argv);
    thread->Create(); //  != wxTHREAD_NO_ERROR
    thread->Run();

  // success: wxApp::OnRun() will be called which will enter the main message
  // loop and the application will run. If we returned false here, the
  // application would exit immediately.
    return true;
*/
	
	int ret = Main1(wxApp::argc,wxApp::argv);
	
	exit(ret);
	
	return false;
}

//////////////////////////////////////////

#include "resource2.h"
#include "resource3.h"
#include "ExtractRes.h"
// #include "resourceGui.h"
#include "../FileManager/PropertyNameRes.h"


static CStringTable g_stringTable[] =
{
  /* GUI/resource2.rc */	  


    { IDS_PROGRESS_COMPRESSING  ,L"Compressing" },
    { IDS_ARCHIVES_COLON  ,L"Archives:" },

  /* ../FileManager/resourceGui.rc */
  { IDS_MESSAGE_NO_ERRORS     ,L"There are no errors" },

  { IDS_PROGRESS_TESTING      ,L"Testing" },

  { IDS_CHECKSUM_CALCULATING    ,L"Checksum calculating..." },
  { IDS_CHECKSUM_INFORMATION    ,L"Checksum information" },
  { IDS_CHECKSUM_CRC_DATA       ,L"CRC checksum for data:" },
  { IDS_CHECKSUM_CRC_DATA_NAMES ,L"CRC checksum for data and names:" },
  { IDS_CHECKSUM_CRC_STREAMS_NAMES ,L"CRC checksum for streams and names:" },

  { IDS_INCORRECT_VOLUME_SIZE ,L"Incorrect volume size" },

  { IDS_OPENNING  ,L"Opening..." },
  { IDS_SCANNING  ,L"Scanning..." },

  /* ../FileManager/PropertyName.rc */
  { IDS_PROP_PATH         ,L"Path" },
  { IDS_PROP_NAME         ,L"Name" },
  { IDS_PROP_EXTENSION    ,L"Extension" },
  { IDS_PROP_IS_FOLDER    ,L"Folder" },
  { IDS_PROP_SIZE         ,L"Size" },
  { IDS_PROP_PACKED_SIZE  ,L"Packed Size" },
  { IDS_PROP_ATTRIBUTES   ,L"Attributes" },
  { IDS_PROP_CTIME        ,L"Created" },
  { IDS_PROP_ATIME        ,L"Accessed" },
  { IDS_PROP_MTIME        ,L"Modified" },
  { IDS_PROP_SOLID        ,L"Solid" },
  { IDS_PROP_C0MMENTED    ,L"Commented" },
  { IDS_PROP_ENCRYPTED    ,L"Encrypted" },
  { IDS_PROP_SPLIT_BEFORE ,L"Split Before" },
  { IDS_PROP_SPLIT_AFTER  ,L"Split After" },
  { IDS_PROP_DICTIONARY_SIZE ,L"Dictionary" },
  { IDS_PROP_CRC          ,L"CRC" },
  { IDS_PROP_FILE_TYPE    ,L"Type" },
  { IDS_PROP_ANTI         ,L"Anti" },
  { IDS_PROP_METHOD       ,L"Method" },
  { IDS_PROP_HOST_OS      ,L"Host OS" },
  { IDS_PROP_FILE_SYSTEM  ,L"File System" },
  { IDS_PROP_USER         ,L"User" },
  { IDS_PROP_GROUP        ,L"Group" },
  { IDS_PROP_BLOCK        ,L"Block" },
  { IDS_PROP_COMMENT      ,L"Comment" },
  { IDS_PROP_POSITION     ,L"Position" },
  { IDS_PROP_PREFIX       ,L"Path Prefix" },
  { IDS_PROP_FOLDERS      ,L"Folders" },
  { IDS_PROP_FILES        ,L"Files" },
  { IDS_PROP_VERSION      ,L"Version" },
  { IDS_PROP_VOLUME       ,L"Volume" },
  { IDS_PROP_IS_VOLUME    ,L"Multivolume" },
  { IDS_PROP_OFFSET       ,L"Offset" },
  { IDS_PROP_LINKS        ,L"Links" },
  { IDS_PROP_NUM_BLOCKS   ,L"Blocks" },
  { IDS_PROP_NUM_VOLUMES  ,L"Volumes" },

  { IDS_PROP_BIT64        ,L"64-bit" },
  { IDS_PROP_BIG_ENDIAN   ,L"Big-endian" },
  { IDS_PROP_CPU          ,L"CPU" },
  { IDS_PROP_PHY_SIZE     ,L"Physical Size" },
  { IDS_PROP_HEADERS_SIZE ,L"Headers Size" },
  { IDS_PROP_CHECKSUM     ,L"Checksum" },
  { IDS_PROP_CHARACTS     ,L"Characteristics" },
  { IDS_PROP_VA           ,L"Virtual Address" },
  { IDS_PROP_ID           ,L"ID" },
  { IDS_PROP_SHORT_NAME   ,L"Short Name" },
  { IDS_PROP_CREATOR_APP  ,L"Creator Application" },
  { IDS_PROP_SECTOR_SIZE  ,L"Sector Size" },
  { IDS_PROP_POSIX_ATTRIB ,L"Mode" },
  { IDS_PROP_SYM_LINK     ,L"Symbolic Link" },
  { IDS_PROP_ERROR        ,L"Error" },
  { IDS_PROP_TOTAL_SIZE   ,L"Total Size" },
  { IDS_PROP_FREE_SPACE   ,L"Free Space" },
  { IDS_PROP_CLUSTER_SIZE ,L"Cluster Size" },
  { IDS_PROP_VOLUME_NAME  ,L"Label" },
  { IDS_PROP_LOCAL_NAME   ,L"Local Name" },
  { IDS_PROP_PROVIDER     ,L"Provider" },
  { IDS_PROP_NT_SECURITY  ,L"NT Security" },
  { IDS_PROP_ALT_STREAM   ,L"Alternate Stream" },
  { IDS_PROP_AUX          ,L"Aux" },
  { IDS_PROP_DELETED      ,L"Deleted" },
  { IDS_PROP_IS_TREE      ,L"Is Tree" },
  { IDS_PROP_SHA1         ,L"SHA-1" },
  { IDS_PROP_SHA256       ,L"SHA-256" },
  { IDS_PROP_ERROR_TYPE   ,L"Error Type" },
  { IDS_PROP_NUM_ERRORS   ,L"Errors" },
  { IDS_PROP_ERROR_FLAGS  ,L"Errors" },
  { IDS_PROP_WARNING_FLAGS ,L"Warnings" },
  { IDS_PROP_WARNING      ,L"Warning" },
  { IDS_PROP_NUM_STREAMS  ,L"Streams" },
  { IDS_PROP_NUM_ALT_STREAMS ,L"Alternate Streams" },
  { IDS_PROP_ALT_STREAMS_SIZE ,L"Alternate Streams Size" },
  { IDS_PROP_VIRTUAL_SIZE ,L"Virtual Size" },
  { IDS_PROP_UNPACK_SIZE  ,L"Unpack Size" },
  { IDS_PROP_TOTAL_PHY_SIZE ,L"Total Physical Size" },
  { IDS_PROP_VOLUME_INDEX ,L"Volume Index" },
  { IDS_PROP_SUBTYPE      ,L"SubType" },
  { IDS_PROP_SHORT_COMMENT ,L"Short Comment" },
  { IDS_PROP_CODE_PAGE    ,L"Code Page" },
  { IDS_PROP_IS_NOT_ARC_TYPE  ,L"Is not archive type" },
  { IDS_PROP_PHY_SIZE_CANT_BE_DETECTED ,L"Physical Size can't be detected" },
  { IDS_PROP_ZEROS_TAIL_IS_ALLOWED ,L"Zeros Tail Is Allowed" },
  { IDS_PROP_TAIL_SIZE ,L"Tail Size" },
  { IDS_PROP_EMB_STUB_SIZE ,L"Embedded Stub Size" },
  { IDS_PROP_NT_REPARSE   ,L"Link" },
  { IDS_PROP_HARD_LINK    ,L"Hard Link" },
  { IDS_PROP_INODE        ,L"iNode" },
  { IDS_PROP_STREAM_ID    ,L"Stream ID" },



  /* Extract.rc */	  
  /**************/
  { IDS_MEM_ERROR  ,L"The system cannot allocate the required amount of memory" },
  { IDS_CANNOT_CREATE_FOLDER  ,L"Cannot create folder '{0}'" },
  { IDS_UPDATE_NOT_SUPPORTED  ,L"Update operations are not supported for this archive." },
  { IDS_CANT_OPEN_ARCHIVE  ,L"Can not open file '{0}' as archive" },
  { IDS_CANT_OPEN_ENCRYPTED_ARCHIVE  ,L"Can not open encrypted archive '{0}'. Wrong password?" },
  { IDS_UNSUPPORTED_ARCHIVE_TYPE  ,L"Unsupported archive type" },

  { IDS_CANT_OPEN_AS_TYPE   ,L"Can not open the file as {0} archive" },
  { IDS_IS_OPEN_AS_TYPE     ,L"The file is open as {0} archive" },
  { IDS_IS_OPEN_WITH_OFFSET ,L"The archive is open with offset" },

  { IDS_PROGRESS_EXTRACTING ,L"Extracting" },

  { IDS_PROGRESS_SKIPPING ,L"Skipping" },

  { IDS_EXTRACT_SET_FOLDER  ,L"Specify a location for extracted files." },

  { IDS_EXTRACT_PATHS_FULL    ,L"Full pathnames" },
  { IDS_EXTRACT_PATHS_NO      ,L"No pathnames" },
  { IDS_EXTRACT_PATHS_ABS     ,L"Absolute pathnames" },
  { IDS_PATH_MODE_RELAT       ,L"Relative pathnames" },

  { IDS_EXTRACT_OVERWRITE_ASK             ,L"Ask before overwrite" },
  { IDS_EXTRACT_OVERWRITE_WITHOUT_PROMPT  ,L"Overwrite without prompt" },
  { IDS_EXTRACT_OVERWRITE_SKIP_EXISTING   ,L"Skip existing files" },
  { IDS_EXTRACT_OVERWRITE_RENAME          ,L"Auto rename" },
  { IDS_EXTRACT_OVERWRITE_RENAME_EXISTING ,L"Auto rename existing files" },

  { IDS_EXTRACT_MESSAGE_UNSUPPORTED_METHOD   ,L"Unsupported compression method for '{0}'." },
  { IDS_EXTRACT_MESSAGE_DATA_ERROR           ,L"Data error in '{0}'. File is broken" },
  { IDS_EXTRACT_MESSAGE_CRC_ERROR            ,L"CRC failed in '{0}'. File is broken." },
  { IDS_EXTRACT_MESSAGE_DATA_ERROR_ENCRYPTED ,L"Data error in encrypted file '{0}'. Wrong password?" },
  { IDS_EXTRACT_MESSAGE_CRC_ERROR_ENCRYPTED  ,L"CRC failed in encrypted file '{0}'. Wrong password?" },

  { IDS_EXTRACT_MSG_WRONG_PSW_GUESS          ,L"Wrong password?" },
  // { IDS_EXTRACT_MSG_ENCRYPTED            ,L"Encrypted file" },

  { IDS_EXTRACT_MSG_UNSUPPORTED_METHOD   ,L"Unsupported compression method" },
  { IDS_EXTRACT_MSG_DATA_ERROR           ,L"Data error" },
  { IDS_EXTRACT_MSG_CRC_ERROR            ,L"CRC failed" },
  { IDS_EXTRACT_MSG_UNAVAILABLE_DATA     ,L"Unavailable data" },
  { IDS_EXTRACT_MSG_UEXPECTED_END        ,L"Unexpected end of data" },
  { IDS_EXTRACT_MSG_DATA_AFTER_END       ,L"There are some data after the end of the payload data" },
  { IDS_EXTRACT_MSG_IS_NOT_ARC           ,L"Is not archive" },
  { IDS_EXTRACT_MSG_HEADERS_ERROR        ,L"Headers Error" },
  { IDS_EXTRACT_MSG_WRONG_PSW_CLAIM      ,L"Wrong password" },

  { IDS_OPEN_MSG_UNAVAILABLE_START  ,L"Unavailable start of archive" },
  { IDS_OPEN_MSG_UNCONFIRMED_START  ,L"Unconfirmed start of archive" },
  // { IDS_OPEN_MSG_ERROR_FLAGS + 5  ,L"Unexpected end of archive" },
  // { IDS_OPEN_MSG_ERROR_FLAGS + 6  ,L"There are data after the end of archive" },
  { IDS_OPEN_MSG_UNSUPPORTED_FEATURE  ,L"Unsupported feature" },


  // resource3.rc
  { IDS_PROGRESS_REMOVE     ,L"Removing" },

  { IDS_PROGRESS_ADD        ,L"Adding" },
  { IDS_PROGRESS_UPDATE     ,L"Updating" },
  { IDS_PROGRESS_ANALYZE    ,L"Analyzing" },
  { IDS_PROGRESS_REPLICATE  ,L"Replicating" },
  { IDS_PROGRESS_REPACK     ,L"Repacking" },

  { IDS_PROGRESS_DELETE     ,L"Deleting" },
  { IDS_PROGRESS_HEADER     ,L"Header creating" },


	{ 0 , 0 }
};

REGISTER_STRINGTABLE(g_stringTable)