Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

if (parser.Parse () > 0)

throw_err (_("Incorrect command line specified."));

if (parser.Found (L"help"))

{

ArgCommand = CommandId::Help;

ArgCommand = CommandId::CreateKeyfile;

param1IsFile = true;

}

if (parser.Found (L"delete-token-keyfiles"))

{

CheckCommandSingle();

ArgCommand = CommandId::DismountVolumes;

param1IsMountedVolumeSpec = true;

}

if (parser.Found (L"export-token-keyfile"))

{

CheckCommandSingle();

else

{

ArgMountOptions.FilesystemType = wstring (str);

if (str.IsSameAs (L"FAT", false))

ArgFilesystem = VolumeCreationOptions::FilesystemType::FAT;

#ifdef TC_LINUX

else if (str.IsSameAs (L"exFAT", false))

ArgFilesystem = VolumeCreationOptions::FilesystemType::exFAT;

#elif defined (TC_MACOSX)

|| str.IsSameAs (L"HFS+", false)

|| str.IsSameAs (L"MacOsExt", false)

)

}

ArgForce = parser.Found (L"force");

ArgTrueCryptMode = parser.Found (L"truecrypt");

#if !defined(TC_WINDOWS) && !defined(TC_MACOSX)

if (parser.Found (L"new-password", &str))

ArgNewPassword = ToUTF8Password (str.c_str());

if (parser.Found (L"new-pim", &str))

{

try

else if (ArgNewPim > 0 && ArgTrueCryptMode)

throw_err (LangString["PIM_NOT_SUPPORTED_FOR_TRUECRYPT_MODE"]);

}

if (parser.Found (L"non-interactive"))

{

if (interfaceType != UserInterfaceType::Text)

ArgMountOptions.ProtectionKeyfiles = ToKeyfileList (str);

ArgMountOptions.Protection = VolumeProtection::HiddenVolumeReadOnly;

}

if (parser.Found (L"protection-password", &str))

{

ArgMountOptions.ProtectionPassword = ToUTF8Password (str.c_str());

ArgMountOptions.Protection = VolumeProtection::HiddenVolumeReadOnly;

}

if (parser.Found (L"protection-pim", &str))

{

int pim = -1;

// Parameters

if (parser.GetParamCount() > 0)

{

// specifying volume path without any option/switch

if (Application::GetUserInterfaceType() != UserInterfaceType::Text)

{

if (param1IsVolume)

{

wxFileName volPath (parser.GetParam (0));

#ifdef TC_WINDOWS

if (!parser.GetParam (0).StartsWith (L"\\Device\\"))

#endif

continue;

}

}

if (token.empty() && !tokenizer.HasMoreTokens())

break;

filteredVolumes.push_back (volume);

}

}

if (!mountedVolumeSpec.IsEmpty() && filteredVolumes.size() < 1)

throw_err (_("No such volume is mounted."));

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

CommandLineInterface (const CommandLineInterface &);

CommandLineInterface &operator= (const CommandLineInterface &);

};

shared_ptr<VolumePassword> ToUTF8Password (const wchar_t* str, size_t charCount = (size_t) -1);

shared_ptr<SecureBuffer> ToUTF8Buffer (const wchar_t* str, size_t charCount = (size_t) -1);

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

std::set_terminate (DefaultTerminateHandler);

#endif

}

uint32 FatalErrorHandler::GetAppChecksum ()

{

uint32 checkSum = 0;

}

wstring FatalErrorHandler::GetCallStack (int depth)

#if wxUSE_STACKWALKER == 1

class StackWalker : public wxStackWalker

return stackWalker.StackVars.str();

#else // wxUSE_STACKWALKER

return wstring();

#endif // wxUSE_STACKWALKER

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

wstring attr = wstring (node.Attributes[L"slotnumber"]);

if (!attr.empty())

slotNumber = StringConverter::ToUInt64 (attr);

bool readOnly = false;

attr = wstring (node.Attributes[L"readonly"]);

if (!attr.empty())

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

{

public:

AboutDialog (wxWindow* parent);

void OnWebsiteHyperlinkClick (wxHyperlinkEvent& event) { Gui->OpenHomepageLink (this, L"main"); }

};

}

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

wxBusyCursor busy;

Buffer buffer ((size_t) Gui->GetSelectedData <size_t> (BufferSizeChoice));

BenchmarkThreadRoutine routine(this, results, buffer);

Gui->ExecuteWaitThreadRoutine (this, &routine);

foreach (const BenchmarkResult &result, results)

{

vector <wstring> fields (BenchmarkListCtrl->GetColumnCount());

fields[ColumnAlgorithm] = result.AlgorithmName;

fields[ColumnEncryption] = Gui->SpeedToString (result.EncryptionSpeed);

fields[ColumnDecryption] = Gui->SpeedToString (result.DecryptionSpeed);

Gui->AppendToListCtrl (BenchmarkListCtrl, fields);

}

BenchmarkListCtrl->SetColumnWidth(0, wxLIST_AUTOSIZE);

}

void BenchmarkDialog::DoBenchmark (list<BenchmarkResult>& results, Buffer& buffer)

{

try

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

void DoBenchmark (list<BenchmarkResult>& results, Buffer& buffer);

void OnBenchmarkButtonClick (wxCommandEvent& event);

class BenchmarkThreadRoutine : public WaitThreadRoutine

{

public:

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

NewPasswordPanel = new VolumePasswordPanel (this, NULL, newPassword, true, newKeyfiles, false, enableNewPassword, enableNewKeyfiles, enableNewPassword, enablePkcs5Prf);

NewPasswordPanel->UpdateEvent.Connect (EventConnector <ChangePasswordDialog> (this, &ChangePasswordDialog::OnPasswordPanelUpdate));

NewPasswordPanelSizer->Add (NewPasswordPanel, 1, wxALL | wxEXPAND);

if (mode == Mode::RemoveAllKeyfiles)

NewSizer->Show (false);

CurrentPasswordPanel->SetFocusToPimTextCtrl();

return;

}

shared_ptr <VolumePassword> newPassword;

int newPim = 0;

if (DialogMode == Mode::ChangePasswordAndKeyfiles)

catch (PasswordException& e)

{

Gui->ShowWarning (e);

return;

}

newPim = NewPasswordPanel->GetVolumePim();

{

if (newPim > 0 && newPim < 485)

{

return;

}

if (passwordEmpty && keyfilesEmpty)

ok = false;

if (CurrentPasswordPanel->GetVolumePim () == -1)

ok = false;

ok = false;

if (DialogMode == Mode::ChangePasswordAndKeyfiles

|| !NewPasswordPanel->PasswordsMatch()

|| (NewPasswordPanel->GetVolumePim() == -1)

)

}

OKButton->Enable (ok);

if (DialogMode == Mode::ChangePasswordAndKeyfiles)

{

bool pimChanged = (CurrentPasswordPanel->GetVolumePim() != NewPasswordPanel->GetVolumePim());

NewPasswordPanel->UpdatePimHelpText(pimChanged);

}

}

}

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

DeviceListCtrl->InsertColumn (ColumnMountPoint, LangString["MOUNT_POINT"], wxLIST_FORMAT_LEFT, 1);

colPermilles.push_back (396);

#endif

wxImageList *imageList = new wxImageList (16, 12, true);

imageList->Add (Resources::GetDriveIconBitmap(), Resources::GetDriveIconMaskBitmap());

DeviceListCtrl->AssignImageList (imageList, wxIMAGE_LIST_SMALL);

fields[ColumnMountPoint] = device.MountPoint;

#endif

fields[ColumnSize] = Gui->SizeToString (device.Size);

foreach_ref (HostDevice &partition, device.Partitions)

{

#ifndef TC_WINDOWS

#endif

wstring (partition.Path);

StdButtonsOK->Disable();

StdButtonsOK->SetDefault();

}

void DeviceSelectionDialog::OnListItemActivated (wxListEvent& event)

{

if (StdButtonsOK->IsEnabled())

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

}

EncryptionAlgorithmChoice->Select (0);

Hashes = Hash::GetAvailableAlgorithms();

foreach (shared_ptr <Hash> hash, Hashes)

{

{

Gui->OpenHomepageLink (this, L"hashalgorithms");

}

void EncryptionOptionsWizardPage::OnTestButtonClick (wxCommandEvent& event)

{

EncryptionTestDialog dialog (this);

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Buffer key;

GetTextCtrlData (KeyTextCtrl, key);

if (key.Size() != ea->GetKeySize())

throw_err (LangString["TEST_KEY_SIZE"]);

Buffer sector (ENCRYPTION_DATA_UNIT_SIZE);

BufferPtr block = sector.GetRange (blockNumber * ea->GetMaxBlockSize(), ea->GetMaxBlockSize());

block.CopyFrom (data);

if (encrypt)

{

return Gui->GetSelectedData <EncryptionAlgorithm> (EncryptionAlgorithmChoice)->GetNew();

}

void EncryptionTestDialog::GetTextCtrlData (wxTextCtrl *textCtrl, Buffer &buffer) const

{

vector <byte> data;

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Layout();

Fit();

Center();

#ifdef TC_MACOSX

// wxMac cannot insert items to wxListCtrl due to a bug

MoveUpButton->Show (false);

fields[ColumnVolumePath] = favorite->Path;

fields[ColumnMountPoint] = favorite->MountPoint;

Gui->AppendToListCtrl (FavoritesListCtrl, fields, -1, favorite.get());

if (++itemCount > Favorites.size() - newItemCount)

{

FavoritesListCtrl->SetItemState (itemCount - 1, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);

UpdateButtons();

FavoritesListCtrl->SetFocus();

}

void FavoriteVolumesDialog::OnMoveDownButtonClick (wxCommandEvent& event)

{

FreezeScope freeze (this);

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

void OnRemoveAllButtonClick (wxCommandEvent& event);

void OnRemoveButtonClick (wxCommandEvent& event);

void UpdateButtons ();

enum

{

ColumnVolumePath = 0,

MainFrameBase::MainFrameBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxSize( -1,496 ), wxDefaultSize );

MainMenuBar = new wxMenuBar( 0 );

VolumesMenu = new wxMenu();

wxMenuItem* CreateNewVolumeMenuItem;

CreateNewVolumeMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Create New Volume...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( CreateNewVolumeMenuItem );

VolumesMenu->AppendSeparator();

MountVolumeMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Mount Volume") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( MountVolumeMenuItem );

wxMenuItem* AutoMountDevicesMenuItem;

AutoMountDevicesMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Auto-Mount All Device-Hosted Volumes") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( AutoMountDevicesMenuItem );

VolumesMenu->AppendSeparator();

DismountVolumeMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Dismount Volume") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( DismountVolumeMenuItem );

DismountAllMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Dismount All Mounted Volumes") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( DismountAllMenuItem );

VolumesMenu->AppendSeparator();

wxMenuItem* ChangePasswordMenuItem;

ChangePasswordMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Change Volume Password...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( ChangePasswordMenuItem );

wxMenuItem* ChangePkcs5PrfMenuItem;

ChangePkcs5PrfMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Change Header Key Derivation Algorithm...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( ChangePkcs5PrfMenuItem );

wxMenuItem* ChangeKeyfilesMenuItem;

ChangeKeyfilesMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Add/Remove Keyfiles to/from Volume...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( ChangeKeyfilesMenuItem );

wxMenuItem* RemoveKeyfilesMenuItem;

RemoveKeyfilesMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Remove All Keyfiles from Volume...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( RemoveKeyfilesMenuItem );

VolumesMenu->AppendSeparator();

VolumePropertiesMenuItem = new wxMenuItem( VolumesMenu, wxID_ANY, wxString( _("Volume Properties...") ) , wxEmptyString, wxITEM_NORMAL );

VolumesMenu->Append( VolumePropertiesMenuItem );

FavoritesMenu = new wxMenu();

AddToFavoritesMenuItem = new wxMenuItem( FavoritesMenu, wxID_ANY, wxString( _("Add Selected Volume to Favorites...") ) , wxEmptyString, wxITEM_NORMAL );

FavoritesMenu->Append( AddToFavoritesMenuItem );

AddAllMountedToFavoritesMenuItem = new wxMenuItem( FavoritesMenu, wxID_ANY, wxString( _("Add All Mounted Volumes to Favorites...") ) , wxEmptyString, wxITEM_NORMAL );

FavoritesMenu->Append( AddAllMountedToFavoritesMenuItem );

wxMenuItem* OrganizeFavoritesMenuItem;

OrganizeFavoritesMenuItem = new wxMenuItem( FavoritesMenu, wxID_ANY, wxString( _("Organize Favorite Volumes...") ) , wxEmptyString, wxITEM_NORMAL );

FavoritesMenu->Append( OrganizeFavoritesMenuItem );

FavoritesMenu->AppendSeparator();

wxMenuItem* MountAllFavoritesMenuItem;

MountAllFavoritesMenuItem = new wxMenuItem( FavoritesMenu, wxID_ANY, wxString( _("Mount Favorite Volumes") ) , wxEmptyString, wxITEM_NORMAL );

FavoritesMenu->Append( MountAllFavoritesMenuItem );

FavoritesMenu->AppendSeparator();

ToolsMenu = new wxMenu();

wxMenuItem* BenchmarkMenuItem;

BenchmarkMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Benchmark...") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( BenchmarkMenuItem );

wxMenuItem* EncryptionTestMenuItem;

EncryptionTestMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Test Vectors...") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( EncryptionTestMenuItem );

ToolsMenu->AppendSeparator();

wxMenuItem* VolumeCreationWizardMenuItem;

VolumeCreationWizardMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Volume Creation Wizard") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( VolumeCreationWizardMenuItem );

ToolsMenu->AppendSeparator();

BackupVolumeHeadersMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Backup Volume Header...") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( BackupVolumeHeadersMenuItem );

RestoreVolumeHeaderMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Restore Volume Header...") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( RestoreVolumeHeaderMenuItem );

ToolsMenu->AppendSeparator();

wxMenuItem* CreateKeyfileMenuItem;

CreateKeyfileMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Keyfile Generator") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( CreateKeyfileMenuItem );

wxMenuItem* ManageSecurityTokenKeyfilesMenuItem;

ManageSecurityTokenKeyfilesMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Manage Security Token Keyfiles...") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( ManageSecurityTokenKeyfilesMenuItem );

wxMenuItem* CloseAllSecurityTokenSessionsMenuItem;

CloseAllSecurityTokenSessionsMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Close All Security Token Sessions") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( CloseAllSecurityTokenSessionsMenuItem );

ToolsMenu->AppendSeparator();

WipeCachedPasswordsMenuItem = new wxMenuItem( ToolsMenu, wxID_ANY, wxString( _("Wipe Cached Passwords") ) , wxEmptyString, wxITEM_NORMAL );

ToolsMenu->Append( WipeCachedPasswordsMenuItem );

SettingsMenu = new wxMenu();

HotkeysMenuItem = new wxMenuItem( SettingsMenu, wxID_ANY, wxString( _("Hotkeys...") ) , wxEmptyString, wxITEM_NORMAL );

SettingsMenu->Append( HotkeysMenuItem );

wxMenuItem* DefaultKeyfilesMenuItem;

DefaultKeyfilesMenuItem = new wxMenuItem( SettingsMenu, wxID_ANY, wxString( _("Default Keyfiles...") ) , wxEmptyString, wxITEM_NORMAL );

SettingsMenu->Append( DefaultKeyfilesMenuItem );

wxMenuItem* DefaultMountParametersMenuItem;

DefaultMountParametersMenuItem = new wxMenuItem( SettingsMenu, wxID_ANY, wxString( _("Default Mount Parameters...") ) , wxEmptyString, wxITEM_NORMAL );

SettingsMenu->Append( DefaultMountParametersMenuItem );

wxMenuItem* SecurityTokenPreferencesMenuItem;

SecurityTokenPreferencesMenuItem = new wxMenuItem( SettingsMenu, wxID_ANY, wxString( _("Security Tokens...") ) , wxEmptyString, wxITEM_NORMAL );

SettingsMenu->Append( SecurityTokenPreferencesMenuItem );

SettingsMenu->AppendSeparator();

PreferencesMenuItem = new wxMenuItem( SettingsMenu, wxID_PREFERENCES, wxString( _("&Preferences...") ) , wxEmptyString, wxITEM_NORMAL );

SettingsMenu->Append( PreferencesMenuItem );

HelpMenu = new wxMenu();

wxMenuItem* UserGuideMenuItem;

UserGuideMenuItem = new wxMenuItem( HelpMenu, wxID_HELP, wxString( _("User's Guide") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( UserGuideMenuItem );

wxMenuItem* OnlineHelpMenuItem;

OnlineHelpMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Online Help") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( OnlineHelpMenuItem );

wxMenuItem* BeginnersTutorialMenuItem;

BeginnersTutorialMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Beginner's Tutorial") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( BeginnersTutorialMenuItem );

wxMenuItem* FaqMenuItem;

FaqMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Frequently Asked Questions") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( FaqMenuItem );

HelpMenu->AppendSeparator();

wxMenuItem* WebsiteMenuItem;

WebsiteMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("VeraCrypt Website") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( WebsiteMenuItem );

wxMenuItem* DownloadsMenuItem;

DownloadsMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Downloads") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( DownloadsMenuItem );

wxMenuItem* NewsMenuItem;

NewsMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("News") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( NewsMenuItem );

wxMenuItem* VersionHistoryMenuItem;

VersionHistoryMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Version History") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( VersionHistoryMenuItem );

HelpMenu->AppendSeparator();

wxMenuItem* DonateMenuItem;

DonateMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Donate") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( DonateMenuItem );

wxMenuItem* ContactMenuItem;

ContactMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Contact") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( ContactMenuItem );

wxMenuItem* LegalNoticesMenuItem;

LegalNoticesMenuItem = new wxMenuItem( HelpMenu, wxID_ANY, wxString( _("Legal Notices") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( LegalNoticesMenuItem );

wxMenuItem* AboutMenuItem;

AboutMenuItem = new wxMenuItem( HelpMenu, wxID_ABOUT, wxString( _("About") ) , wxEmptyString, wxITEM_NORMAL );

HelpMenu->Append( AboutMenuItem );

this->SetMenuBar( MainMenuBar );

wxBoxSizer* bSizer1;

bSizer1 = new wxBoxSizer( wxVERTICAL );

MainPanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer2;

bSizer2 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer48;

bSizer48 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer1;

sbSizer1 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

SlotListCtrl = new wxListCtrl( MainPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL|wxLC_VRULES|wxSUNKEN_BORDER );

sbSizer1->Add( SlotListCtrl, 1, wxALL|wxEXPAND, 5 );

bSizer48->Add( sbSizer1, 1, wxEXPAND, 5 );

LowStaticBoxSizer = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

HigherButtonSizer = new wxBoxSizer( wxVERTICAL );

LowStaticBoxSizer->Add( HigherButtonSizer, 0, wxEXPAND|wxTOP, 2 );

wxGridSizer* gSizer1;

gSizer1 = new wxGridSizer( 1, 3, 0, 0 );

wxBoxSizer* bSizer17;

bSizer17 = new wxBoxSizer( wxVERTICAL );

CreateVolumeButton = new wxButton( MainPanel, wxID_ANY, _("&Create Volume"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer17->Add( CreateVolumeButton, 1, wxALL|wxEXPAND, 5 );

gSizer1->Add( bSizer17, 0, 0, 5 );

wxBoxSizer* bSizer18;

bSizer18 = new wxBoxSizer( wxVERTICAL );

VolumePropertiesButton = new wxButton( MainPanel, wxID_ANY, _("&Volume Properties..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer18->Add( VolumePropertiesButton, 1, wxALL|wxALIGN_CENTER_HORIZONTAL|wxEXPAND, 5 );

gSizer1->Add( bSizer18, 0, wxALIGN_CENTER_HORIZONTAL, 5 );

wxBoxSizer* bSizer19;

bSizer19 = new wxBoxSizer( wxVERTICAL );

WipeCacheButton = new wxButton( MainPanel, wxID_ANY, _("&Wipe Cache"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer19->Add( WipeCacheButton, 1, wxALL|wxALIGN_RIGHT|wxEXPAND, 5 );

gSizer1->Add( bSizer19, 0, wxALIGN_RIGHT, 5 );

LowStaticBoxSizer->Add( gSizer1, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );

LowStaticBoxSizer->Add( 0, 0, 0, 0, 5 );

VolumeStaticBoxSizer = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, _("Volume") ), wxVERTICAL );

VolumeGridBagSizer = new wxGridBagSizer( 0, 0 );

VolumeGridBagSizer->SetFlexibleDirection( wxBOTH );

VolumeGridBagSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

LogoBitmap = new wxStaticBitmap( MainPanel, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER );

LogoBitmap->SetMinSize( wxSize( 42,52 ) );

VolumeGridBagSizer->Add( LogoBitmap, wxGBPosition( 0, 0 ), wxGBSpan( 2, 1 ), wxALIGN_CENTER_VERTICAL|wxALL, 5 );

VolumeGridBagSizer->Add( VolumePathComboBox, wxGBPosition( 0, 1 ), wxGBSpan( 1, 2 ), wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer191;

bSizer191 = new wxBoxSizer( wxVERTICAL );

SelectFileButton = new wxButton( MainPanel, wxID_ANY, _("Select &File..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer191->Add( SelectFileButton, 1, wxALL|wxEXPAND, 5 );

VolumeGridBagSizer->Add( bSizer191, wxGBPosition( 0, 3 ), wxGBSpan( 1, 1 ), wxEXPAND, 5 );

NoHistoryCheckBox = new wxCheckBox( MainPanel, wxID_ANY, _("&Never save history"), wxDefaultPosition, wxDefaultSize, 0 );

VolumeGridBagSizer->Add( NoHistoryCheckBox, wxGBPosition( 1, 1 ), wxGBSpan( 1, 1 ), wxBOTTOM|wxRIGHT|wxLEFT, 5 );

wxBoxSizer* bSizer20;

bSizer20 = new wxBoxSizer( wxVERTICAL );

VolumeToolsButton = new wxButton( MainPanel, wxID_ANY, _("Volume &Tools..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer20->Add( VolumeToolsButton, 1, wxALL|wxEXPAND, 5 );

VolumeGridBagSizer->Add( bSizer20, wxGBPosition( 1, 2 ), wxGBSpan( 1, 1 ), wxALIGN_RIGHT, 5 );

wxBoxSizer* bSizer21;

bSizer21 = new wxBoxSizer( wxVERTICAL );

SelectDeviceButton = new wxButton( MainPanel, wxID_ANY, _("Select D&evice..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer21->Add( SelectDeviceButton, 1, wxEXPAND|wxALL, 5 );

VolumeGridBagSizer->Add( bSizer21, wxGBPosition( 1, 3 ), wxGBSpan( 1, 1 ), wxEXPAND, 5 );

VolumeGridBagSizer->AddGrowableCol( 1 );

VolumeGridBagSizer->AddGrowableRow( 0 );

VolumeStaticBoxSizer->Add( VolumeGridBagSizer, 1, wxEXPAND|wxALL, 4 );

LowStaticBoxSizer->Add( VolumeStaticBoxSizer, 1, wxEXPAND, 5 );

LowStaticBoxSizer->Add( 0, 0, 0, 0, 5 );

wxGridSizer* gSizer2;

gSizer2 = new wxGridSizer( 1, 4, 0, 0 );

wxStaticBoxSizer* sbSizer4;

sbSizer4 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

VolumeButton = new wxButton( MainPanel, wxID_ANY, _("&Mount"), wxDefaultPosition, wxDefaultSize, 0 );

VolumeButton->SetMinSize( wxSize( -1,32 ) );

sbSizer4->Add( VolumeButton, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND|wxTOP, 2 );

gSizer2->Add( sbSizer4, 1, wxEXPAND, 0 );

wxStaticBoxSizer* sbSizer41;

sbSizer41 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

MountAllDevicesButton = new wxButton( MainPanel, wxID_ANY, _("&Auto-Mount Devices"), wxDefaultPosition, wxDefaultSize, 0 );

MountAllDevicesButton->SetMinSize( wxSize( -1,32 ) );

sbSizer41->Add( MountAllDevicesButton, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND|wxTOP, 2 );

gSizer2->Add( sbSizer41, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer42;

sbSizer42 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

DismountAllButton = new wxButton( MainPanel, wxID_ANY, _("Di&smount All"), wxDefaultPosition, wxDefaultSize, 0 );

DismountAllButton->SetMinSize( wxSize( -1,32 ) );

sbSizer42->Add( DismountAllButton, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND|wxTOP, 2 );

gSizer2->Add( sbSizer42, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer43;

sbSizer43 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

ExitButton = new wxButton( MainPanel, wxID_ANY, _("E&xit"), wxDefaultPosition, wxDefaultSize, 0 );

ExitButton->SetMinSize( wxSize( -1,32 ) );

sbSizer43->Add( ExitButton, 1, wxALIGN_CENTER_HORIZONTAL|wxEXPAND|wxTOP, 2 );

gSizer2->Add( sbSizer43, 1, wxALIGN_RIGHT|wxEXPAND, 5 );

LowStaticBoxSizer->Add( gSizer2, 0, wxEXPAND, 5 );

bSizer48->Add( LowStaticBoxSizer, 0, wxEXPAND, 5 );

bSizer2->Add( bSizer48, 1, wxEXPAND, 5 );

MainPanel->SetSizer( bSizer2 );

MainPanel->Layout();

bSizer2->Fit( MainPanel );

bSizer1->Add( MainPanel, 1, wxEXPAND, 0 );

this->SetSizer( bSizer1 );

this->Layout();

bSizer1->Fit( this );

this->Centre( wxBOTH );

// Connect Events

this->Connect( wxEVT_ACTIVATE, wxActivateEventHandler( MainFrameBase::OnActivate ) );

this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( MainFrameBase::OnClose ) );

MountAllDevicesButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrameBase::OnMountAllDevicesButtonClick ), NULL, this );

DismountAllButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrameBase::OnDismountAllButtonClick ), NULL, this );

ExitButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MainFrameBase::OnExitButtonClick ), NULL, this );

}

WizardFrameBase::WizardFrameBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxFrame( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxSize( 800,500 ), wxDefaultSize );

MainSizer = new wxBoxSizer( wxVERTICAL );

MainPanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer63;

bSizer63 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer64;

bSizer64 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer27;

sbSizer27 = new wxStaticBoxSizer( new wxStaticBox( MainPanel, wxID_ANY, wxEmptyString ), wxHORIZONTAL );

WizardBitmap = new wxStaticBitmap( MainPanel, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );

sbSizer27->Add( WizardBitmap, 0, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer66;

bSizer66 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer126;

bSizer126 = new wxBoxSizer( wxHORIZONTAL );

PageTitleStaticText = new wxStaticText( MainPanel, wxID_ANY, _("Page Title"), wxDefaultPosition, wxDefaultSize, 0 );

PageTitleStaticText->Wrap( -1 );

PageTitleStaticText->SetFont( wxFont( 16, 70, 90, 90, false, wxT("Times New Roman") ) );

bSizer126->Add( PageTitleStaticText, 0, wxALL, 5 );

bSizer66->Add( bSizer126, 0, wxLEFT, 5 );

PageSizer = new wxBoxSizer( wxVERTICAL );

bSizer66->Add( PageSizer, 1, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

sbSizer27->Add( bSizer66, 1, wxEXPAND|wxLEFT, 5 );

bSizer64->Add( sbSizer27, 1, wxEXPAND|wxRIGHT|wxLEFT, 5 );

wxBoxSizer* bSizer70;

bSizer70 = new wxBoxSizer( wxHORIZONTAL );

bSizer70->Add( 0, 0, 1, wxEXPAND, 5 );

HelpButton = new wxButton( MainPanel, wxID_HELP, _("&Help"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer70->Add( HelpButton, 0, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );

bSizer70->Add( 0, 0, 0, wxLEFT|wxALIGN_RIGHT, 5 );

PreviousButton = new wxButton( MainPanel, wxID_ANY, _("< &Prev"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer70->Add( PreviousButton, 0, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );

NextButton = new wxButton( MainPanel, wxID_ANY, _("&Next >"), wxDefaultPosition, wxDefaultSize, 0|wxWANTS_CHARS );

bSizer70->Add( NextButton, 0, wxTOP|wxBOTTOM|wxRIGHT|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );

bSizer70->Add( 0, 0, 0, wxLEFT|wxALIGN_RIGHT, 5 );

CancelButton = new wxButton( MainPanel, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer70->Add( CancelButton, 0, wxALL|wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 5 );

bSizer64->Add( bSizer70, 0, wxEXPAND|wxALIGN_RIGHT|wxALL, 5 );

bSizer63->Add( bSizer64, 1, wxEXPAND, 5 );

MainPanel->SetSizer( bSizer63 );

MainPanel->Layout();

bSizer63->Fit( MainPanel );

MainSizer->Add( MainPanel, 1, wxEXPAND, 5 );

this->SetSizer( MainSizer );

this->Layout();

MainSizer->Fit( this );

// Connect Events

this->Connect( wxEVT_ACTIVATE, wxActivateEventHandler( WizardFrameBase::OnActivate ) );

this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( WizardFrameBase::OnClose ) );

PreviousButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( WizardFrameBase::OnPreviousButtonClick ), NULL, this );

NextButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( WizardFrameBase::OnNextButtonClick ), NULL, this );

CancelButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( WizardFrameBase::OnCancelButtonClick ), NULL, this );

}

AboutDialogBase::AboutDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer116;

bSizer116 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer117;

bSizer117 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer120;

bSizer120 = new wxBoxSizer( wxVERTICAL );

m_panel14 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

m_panel14->SetBackgroundColour( wxColour( 10, 108, 206 ) );

wxBoxSizer* bSizer121;

bSizer121 = new wxBoxSizer( wxVERTICAL );

bSizer121->Add( 0, 0, 1, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer122;

bSizer122 = new wxBoxSizer( wxVERTICAL );

LogoBitmap = new wxStaticBitmap( m_panel14, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxDefaultSize, 0 );

bSizer122->Add( LogoBitmap, 0, wxALL, 10 );

bSizer121->Add( bSizer122, 0, wxEXPAND|wxLEFT, 8 );

m_panel14->SetSizer( bSizer121 );

m_panel14->Layout();

bSizer121->Fit( m_panel14 );

bSizer120->Add( m_panel14, 1, wxEXPAND, 5 );

bSizer117->Add( bSizer120, 0, wxEXPAND, 5 );

wxBoxSizer* bSizer118;

bSizer118 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer123;

bSizer123 = new wxBoxSizer( wxVERTICAL );

VersionStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

VersionStaticText->Wrap( -1 );

bSizer123->Add( VersionStaticText, 0, wxTOP|wxRIGHT|wxLEFT, 5 );

bSizer123->Add( 0, 0, 0, wxTOP, 3 );

CopyrightStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

CopyrightStaticText->Wrap( -1 );

bSizer123->Add( CopyrightStaticText, 0, wxBOTTOM|wxRIGHT|wxLEFT, 5 );

bSizer123->Add( 0, 0, 0, wxTOP, 3 );

WebsiteHyperlink = new wxHyperlinkCtrl( this, wxID_ANY, wxEmptyString, wxT("."), wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE );

WebsiteHyperlink->SetHoverColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

WebsiteHyperlink->SetNormalColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

WebsiteHyperlink->SetVisitedColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

bSizer123->Add( WebsiteHyperlink, 0, wxALL, 5 );

bSizer118->Add( bSizer123, 1, wxEXPAND|wxLEFT, 5 );

bSizer117->Add( bSizer118, 1, wxALL|wxEXPAND, 15 );

m_staticline3 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

bSizer117->Add( m_staticline3, 0, wxEXPAND|wxBOTTOM, 5 );

CreditsTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY|wxSUNKEN_BORDER );

bSizer117->Add( CreditsTextCtrl, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 10 );

bSizer117->Add( 0, 0, 0, wxTOP, 5 );

m_staticline4 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

bSizer117->Add( m_staticline4, 0, wxEXPAND|wxTOP|wxBOTTOM, 3 );

m_staticline5 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

bSizer117->Add( m_staticline5, 0, wxEXPAND|wxBOTTOM, 5 );

wxBoxSizer* bSizer119;

bSizer119 = new wxBoxSizer( wxHORIZONTAL );

bSizer119->Add( 0, 0, 1, wxEXPAND|wxALL, 5 );

wxButton* OKButton;

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer119->Add( OKButton, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer119->Add( 0, 0, 0, wxLEFT, 5 );

bSizer117->Add( bSizer119, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 6 );

bSizer116->Add( bSizer117, 1, wxEXPAND, 5 );

this->SetSizer( bSizer116 );

this->Layout();

bSizer116->Fit( this );

// Connect Events

WebsiteHyperlink->Connect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( AboutDialogBase::OnWebsiteHyperlinkClick ), NULL, this );

}

{

// Disconnect Events

WebsiteHyperlink->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( AboutDialogBase::OnWebsiteHyperlinkClick ), NULL, this );

}

BenchmarkDialogBase::BenchmarkDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer153;

bSizer153 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer154;

bSizer154 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer155;

bSizer155 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText54;

m_staticText54 = new wxStaticText( this, wxID_ANY, _("Buffer Size:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText54->Wrap( -1 );

bSizer155->Add( m_staticText54, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxArrayString BufferSizeChoiceChoices;

BufferSizeChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, BufferSizeChoiceChoices, 0 );

BufferSizeChoice->SetSelection( 0 );

bSizer155->Add( BufferSizeChoice, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer154->Add( bSizer155, 0, wxEXPAND, 5 );

wxStaticLine* m_staticline6;

m_staticline6 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

bSizer154->Add( m_staticline6, 0, wxEXPAND | wxALL, 5 );

wxBoxSizer* bSizer156;

bSizer156 = new wxBoxSizer( wxHORIZONTAL );

BenchmarkListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxSUNKEN_BORDER );

bSizer156->Add( BenchmarkListCtrl, 1, wxALL|wxEXPAND, 5 );

RightSizer = new wxBoxSizer( wxVERTICAL );

BenchmarkButton = new wxButton( this, wxID_OK, _("Benchmark"), wxDefaultPosition, wxDefaultSize, 0 );

RightSizer->Add( BenchmarkButton, 0, wxALL|wxEXPAND, 5 );

wxButton* CancelButton;

CancelButton = new wxButton( this, wxID_CANCEL, _("Close"), wxDefaultPosition, wxDefaultSize, 0 );

RightSizer->Add( CancelButton, 0, wxALL|wxEXPAND, 5 );

RightSizer->Add( 0, 0, 0, wxEXPAND|wxTOP|wxBOTTOM, 5 );

BenchmarkNoteStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

BenchmarkNoteStaticText->Wrap( -1 );

RightSizer->Add( BenchmarkNoteStaticText, 1, wxALL|wxEXPAND, 5 );

bSizer156->Add( RightSizer, 0, wxEXPAND, 5 );

bSizer154->Add( bSizer156, 1, wxEXPAND, 5 );

bSizer153->Add( bSizer154, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer153 );

this->Layout();

bSizer153->Fit( this );

// Connect Events

BenchmarkButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( BenchmarkDialogBase::OnBenchmarkButtonClick ), NULL, this );

}

{

// Disconnect Events

BenchmarkButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( BenchmarkDialogBase::OnBenchmarkButtonClick ), NULL, this );

}

ChangePasswordDialogBase::ChangePasswordDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

wxBoxSizer* bSizer30;

bSizer30 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer31;

bSizer31 = new wxBoxSizer( wxHORIZONTAL );

wxBoxSizer* bSizer32;

bSizer32 = new wxBoxSizer( wxVERTICAL );

CurrentSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Current") ), wxVERTICAL );

CurrentPasswordPanelSizer = new wxBoxSizer( wxVERTICAL );

CurrentSizer->Add( CurrentPasswordPanelSizer, 0, wxALIGN_LEFT, 5 );

bSizer32->Add( CurrentSizer, 0, wxEXPAND, 5 );

NewSizer = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("New") ), wxVERTICAL );

NewPasswordPanelSizer = new wxBoxSizer( wxVERTICAL );

NewSizer->Add( NewPasswordPanelSizer, 0, wxALIGN_LEFT, 5 );

bSizer32->Add( NewSizer, 0, wxTOP|wxEXPAND, 5 );

bSizer31->Add( bSizer32, 1, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer33;

bSizer33 = new wxBoxSizer( wxVERTICAL );

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer33->Add( OKButton, 0, wxALL|wxEXPAND, 5 );

CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer33->Add( CancelButton, 0, wxALL|wxEXPAND, 5 );

bSizer31->Add( bSizer33, 0, 0, 5 );

bSizer30->Add( bSizer31, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer30 );

this->Layout();

bSizer30->Fit( this );

// Connect Events

OKButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ChangePasswordDialogBase::OnOKButtonClick ), NULL, this );

}

{

// Disconnect Events

OKButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ChangePasswordDialogBase::OnOKButtonClick ), NULL, this );

}

DeviceSelectionDialogBase::DeviceSelectionDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxSize( -1,-1 ), wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

wxBoxSizer* bSizer3;

bSizer3 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer4;

bSizer4 = new wxBoxSizer( wxVERTICAL );

DeviceListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL|wxLC_VRULES|wxSUNKEN_BORDER );

bSizer4->Add( DeviceListCtrl, 1, wxALL|wxEXPAND, 5 );

StdButtons = new wxStdDialogButtonSizer();

StdButtonsOK = new wxButton( this, wxID_OK );

StdButtons->AddButton( StdButtonsOK );

StdButtonsCancel = new wxButton( this, wxID_CANCEL );

StdButtons->AddButton( StdButtonsCancel );

StdButtons->Realize();

bSizer4->Add( StdButtons, 0, wxEXPAND|wxALL, 5 );

bSizer3->Add( bSizer4, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer3 );

this->Layout();

bSizer3->Fit( this );

this->Centre( wxBOTH );

// Connect Events

DeviceListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemActivated ), NULL, this );

DeviceListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemDeselected ), NULL, this );

DeviceListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemActivated ), NULL, this );

DeviceListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemDeselected ), NULL, this );

DeviceListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemSelected ), NULL, this );

}

EncryptionTestDialogBase::EncryptionTestDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer132;

bSizer132 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer133;

bSizer133 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer134;

bSizer134 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText41;

m_staticText41 = new wxStaticText( this, wxID_ANY, _("Encryption algorithm:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText41->Wrap( -1 );

bSizer134->Add( m_staticText41, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxArrayString EncryptionAlgorithmChoiceChoices;

EncryptionAlgorithmChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, EncryptionAlgorithmChoiceChoices, 0 );

EncryptionAlgorithmChoice->SetSelection( 0 );

bSizer134->Add( EncryptionAlgorithmChoice, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

XtsModeCheckBox = new wxCheckBox( this, wxID_ANY, _("XTS mode"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer134->Add( XtsModeCheckBox, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer133->Add( bSizer134, 0, wxALIGN_CENTER_HORIZONTAL, 5 );

wxStaticBoxSizer* sbSizer38;

sbSizer38 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Key (hexadecimal)") ), wxVERTICAL );

KeyTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

KeyTextCtrl->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier") ) );

sbSizer38->Add( KeyTextCtrl, 1, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer135;

bSizer135 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText43;

m_staticText43 = new wxStaticText( this, wxID_ANY, _("Key size:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText43->Wrap( -1 );

bSizer135->Add( m_staticText43, 0, wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

KeySizeStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

KeySizeStaticText->Wrap( -1 );

bSizer135->Add( KeySizeStaticText, 0, wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxRIGHT, 5 );

sbSizer38->Add( bSizer135, 0, wxEXPAND, 5 );

bSizer133->Add( sbSizer38, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer39;

sbSizer39 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("XTS mode") ), wxVERTICAL );

wxStaticText* m_staticText45;

m_staticText45 = new wxStaticText( this, wxID_ANY, _("Secondary key (hexadecimal)"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText45->Wrap( -1 );

sbSizer39->Add( m_staticText45, 0, wxTOP|wxRIGHT|wxLEFT, 5 );

SecondaryKeyTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

SecondaryKeyTextCtrl->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier") ) );

sbSizer39->Add( SecondaryKeyTextCtrl, 0, wxEXPAND|wxALL, 5 );

wxStaticText* m_staticText46;

m_staticText46 = new wxStaticText( this, wxID_ANY, _("Data unit number (64-bit, data unit size is 512 bytes)"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText46->Wrap( -1 );

sbSizer39->Add( m_staticText46, 0, wxTOP|wxRIGHT|wxLEFT, 5 );

DataUnitNumberTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

sbSizer39->Add( DataUnitNumberTextCtrl, 0, wxALL, 5 );

wxStaticText* m_staticText47;

m_staticText47 = new wxStaticText( this, wxID_ANY, _("Block number:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText47->Wrap( -1 );

sbSizer39->Add( m_staticText47, 0, wxTOP|wxRIGHT|wxLEFT, 5 );

BlockNumberTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

sbSizer39->Add( BlockNumberTextCtrl, 0, wxALL, 5 );

bSizer133->Add( sbSizer39, 1, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer40;

sbSizer40 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Plaintext (hexadecimal)") ), wxVERTICAL );

PlainTextTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

PlainTextTextCtrl->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier") ) );

sbSizer40->Add( PlainTextTextCtrl, 0, wxALL|wxEXPAND, 5 );

bSizer133->Add( sbSizer40, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer41;

sbSizer41 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Ciphertext (hexadecimal)") ), wxVERTICAL );

CipherTextTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

CipherTextTextCtrl->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier") ) );

sbSizer41->Add( CipherTextTextCtrl, 0, wxALL|wxEXPAND, 5 );

bSizer133->Add( sbSizer41, 0, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer136;

bSizer136 = new wxBoxSizer( wxHORIZONTAL );

EncryptButton = new wxButton( this, wxID_ANY, _("&Encrypt"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer136->Add( EncryptButton, 0, wxALL, 5 );

DecryptButton = new wxButton( this, wxID_ANY, _("&Decrypt"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer136->Add( DecryptButton, 0, wxALL, 5 );

AutoTestAllButton = new wxButton( this, wxID_ANY, _("&Auto-Test All"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer136->Add( AutoTestAllButton, 0, wxALL, 5 );

ResetButton = new wxButton( this, wxID_ANY, _("&Reset"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer136->Add( ResetButton, 0, wxALL, 5 );

CloseButton = new wxButton( this, wxID_CANCEL, _("Close"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer136->Add( CloseButton, 0, wxALL, 5 );

bSizer133->Add( bSizer136, 0, wxEXPAND, 5 );

bSizer132->Add( bSizer133, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer132 );

this->Layout();

bSizer132->Fit( this );

// Connect Events

EncryptionAlgorithmChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( EncryptionTestDialogBase::OnEncryptionAlgorithmSelected ), NULL, this );

XtsModeCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( EncryptionTestDialogBase::OnXtsModeCheckBoxClick ), NULL, this );

DecryptButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( EncryptionTestDialogBase::OnDecryptButtonClick ), NULL, this );

AutoTestAllButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( EncryptionTestDialogBase::OnAutoTestAllButtonClick ), NULL, this );

ResetButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( EncryptionTestDialogBase::OnResetButtonClick ), NULL, this );

}

FavoriteVolumesDialogBase::FavoriteVolumesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer57;

bSizer57 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer60;

bSizer60 = new wxBoxSizer( wxHORIZONTAL );

wxBoxSizer* bSizer58;

bSizer58 = new wxBoxSizer( wxVERTICAL );

FavoritesListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VRULES|wxSUNKEN_BORDER );

bSizer58->Add( FavoritesListCtrl, 1, wxALL|wxEXPAND, 5 );

wxGridSizer* gSizer5;

gSizer5 = new wxGridSizer( 1, 4, 0, 0 );

MoveUpButton = new wxButton( this, wxID_ANY, _("Move &Up"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer5->Add( MoveUpButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxRIGHT, 5 );

MoveDownButton = new wxButton( this, wxID_ANY, _("Move &Down"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer5->Add( MoveDownButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxRIGHT, 5 );

RemoveButton = new wxButton( this, wxID_ANY, _("&Remove"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer5->Add( RemoveButton, 0, wxALIGN_RIGHT|wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

RemoveAllButton = new wxButton( this, wxID_ANY, _("Remove &All"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer5->Add( RemoveAllButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

bSizer58->Add( gSizer5, 0, wxEXPAND|wxRIGHT|wxLEFT, 5 );

wxFlexGridSizer* fgSizer4;

fgSizer4 = new wxFlexGridSizer( 1, 5, 0, 0 );

fgSizer4->AddGrowableCol( 2 );

fgSizer4->SetFlexibleDirection( wxBOTH );

fgSizer4->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

fgSizer4->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer58->Add( fgSizer4, 0, wxEXPAND, 5 );

bSizer60->Add( bSizer58, 1, wxEXPAND, 5 );

wxBoxSizer* bSizer59;

bSizer59 = new wxBoxSizer( wxVERTICAL );

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer59->Add( OKButton, 0, wxALL, 5 );

CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer59->Add( CancelButton, 0, wxALL, 5 );

bSizer60->Add( bSizer59, 0, wxEXPAND, 5 );

bSizer57->Add( bSizer60, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer57 );

this->Layout();

bSizer57->Fit( this );

// Connect Events

FavoritesListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( FavoriteVolumesDialogBase::OnListItemDeselected ), NULL, this );

FavoritesListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( FavoriteVolumesDialogBase::OnListItemSelected ), NULL, this );

RemoveButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( FavoriteVolumesDialogBase::OnRemoveButtonClick ), NULL, this );

RemoveAllButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( FavoriteVolumesDialogBase::OnRemoveAllButtonClick ), NULL, this );

OKButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( FavoriteVolumesDialogBase::OnOKButtonClick ), NULL, this );

}

KeyfilesDialogBase::KeyfilesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

wxBoxSizer* bSizer26;

bSizer26 = new wxBoxSizer( wxVERTICAL );

UpperSizer = new wxBoxSizer( wxHORIZONTAL );

PanelSizer = new wxBoxSizer( wxVERTICAL );

UpperSizer->Add( PanelSizer, 1, wxEXPAND, 5 );

wxBoxSizer* bSizer22;

bSizer22 = new wxBoxSizer( wxVERTICAL );

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer22->Add( OKButton, 0, wxALL|wxEXPAND, 5 );

CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer22->Add( CancelButton, 0, wxALL|wxEXPAND, 5 );

WarningStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

WarningStaticText->Wrap( -1 );

bSizer22->Add( WarningStaticText, 1, wxALL|wxEXPAND, 5 );

UpperSizer->Add( bSizer22, 0, wxEXPAND, 5 );

bSizer26->Add( UpperSizer, 1, wxTOP|wxRIGHT|wxLEFT, 5 );

wxBoxSizer* bSizer23;

bSizer23 = new wxBoxSizer( wxVERTICAL );

KeyfilesNoteSizer = new wxBoxSizer( wxVERTICAL );

wxStaticLine* m_staticline1;

m_staticline1 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

KeyfilesNoteSizer->Add( m_staticline1, 0, wxEXPAND | wxALL, 5 );

KeyfilesNoteStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

KeyfilesNoteStaticText->Wrap( -1 );

KeyfilesNoteSizer->Add( KeyfilesNoteStaticText, 0, wxALL|wxEXPAND, 5 );

wxStaticLine* m_staticline2;

m_staticline2 = new wxStaticLine( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLI_HORIZONTAL );

KeyfilesNoteSizer->Add( m_staticline2, 0, wxEXPAND | wxALL, 5 );

bSizer23->Add( KeyfilesNoteSizer, 1, wxEXPAND, 5 );

wxFlexGridSizer* fgSizer2;

fgSizer2 = new wxFlexGridSizer( 1, 2, 0, 0 );

fgSizer2->AddGrowableCol( 0 );

fgSizer2->SetFlexibleDirection( wxBOTH );

fgSizer2->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

KeyfilesHyperlink = new wxHyperlinkCtrl( this, wxID_ANY, _("More information on keyfiles"), wxEmptyString, wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE );

KeyfilesHyperlink->SetHoverColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

KeyfilesHyperlink->SetNormalColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

KeyfilesHyperlink->SetVisitedColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

fgSizer2->Add( KeyfilesHyperlink, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

CreateKeyfileButtton = new wxButton( this, wxID_ANY, _("&Generate Random Keyfile..."), wxDefaultPosition, wxDefaultSize, 0 );

fgSizer2->Add( CreateKeyfileButtton, 0, wxALL, 5 );

bSizer23->Add( fgSizer2, 0, wxEXPAND, 5 );

bSizer26->Add( bSizer23, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

this->SetSizer( bSizer26 );

this->Layout();

bSizer26->Fit( this );

// Connect Events

KeyfilesHyperlink->Connect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( KeyfilesDialogBase::OnKeyfilesHyperlinkClick ), NULL, this );

CreateKeyfileButtton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfilesDialogBase::OnCreateKeyfileButttonClick ), NULL, this );

// Disconnect Events

KeyfilesHyperlink->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( KeyfilesDialogBase::OnKeyfilesHyperlinkClick ), NULL, this );

CreateKeyfileButtton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfilesDialogBase::OnCreateKeyfileButttonClick ), NULL, this );

}

KeyfileGeneratorDialogBase::KeyfileGeneratorDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

MainSizer = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer144;

bSizer144 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer145;

bSizer145 = new wxBoxSizer( wxHORIZONTAL );

bSizer145->Add( 0, 0, 1, wxEXPAND, 5 );

wxStaticText* m_staticText49;

m_staticText49 = new wxStaticText( this, wxID_ANY, _("Mixing PRF:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText49->Wrap( -1 );

bSizer145->Add( m_staticText49, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

wxArrayString HashChoiceChoices;

HashChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, HashChoiceChoices, 0 );

HashChoice->SetSelection( 0 );

bSizer145->Add( HashChoice, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer145->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer144->Add( bSizer145, 0, wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer43;

sbSizer43 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxEmptyString ), wxVERTICAL );

wxBoxSizer* bSizer147;

bSizer147 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText52;

m_staticText52 = new wxStaticText( this, wxID_ANY, _("Random Pool:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText52->Wrap( -1 );

bSizer147->Add( m_staticText52, 0, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

RandomPoolStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

RandomPoolStaticText->Wrap( -1 );

RandomPoolStaticText->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier New") ) );

bSizer147->Add( RandomPoolStaticText, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

ShowRandomPoolCheckBox = new wxCheckBox( this, wxID_ANY, _("Show"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer147->Add( ShowRandomPoolCheckBox, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

sbSizer43->Add( bSizer147, 0, wxEXPAND|wxTOP, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer45;

sbSizer45 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Randomness Collected From Mouse Movements") ), wxVERTICAL );

CollectedEntropy = new wxGauge( this, wxID_ANY, 2560, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

sbSizer45->Add( CollectedEntropy, 1, wxALL|wxEXPAND, 5 );

sbSizer43->Add( sbSizer45, 0, wxBOTTOM|wxEXPAND|wxTOP, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

MouseStaticText = new wxStaticText( this, wxID_ANY, _("IMPORTANT: Move your mouse as randomly as possible within this window. The longer you move it, the better. This significantly increases the cryptographic strength of the keyfile."), wxDefaultPosition, wxDefaultSize, 0 );

MouseStaticText->Wrap( -1 );

sbSizer43->Add( MouseStaticText, 0, wxALL|wxALIGN_CENTER_HORIZONTAL, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer144->Add( sbSizer43, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

wxBoxSizer* bSizer162;

bSizer162 = new wxBoxSizer( wxVERTICAL );

wxFlexGridSizer* fgSizer8;

fgSizer8 = new wxFlexGridSizer( 3, 3, 0, 0 );

fgSizer8->AddGrowableCol( 2 );

fgSizer8->SetFlexibleDirection( wxBOTH );

fgSizer8->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

m_staticText60 = new wxStaticText( this, wxID_ANY, _("Number of keyfiles:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText60->Wrap( -1 );

fgSizer8->Add( m_staticText60, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

NumberOfKeyfiles = new wxSpinCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 1, 9999999, 1 );

fgSizer8->Add( NumberOfKeyfiles, 0, wxALL, 5 );

m_panel18 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

fgSizer8->Add( m_panel18, 1, wxEXPAND | wxALL, 5 );

m_staticText63 = new wxStaticText( this, wxID_ANY, _("Keyfiles size (in Bytes):"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText63->Wrap( -1 );

fgSizer8->Add( m_staticText63, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

KeyfilesSize = new wxSpinCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxSP_ARROW_KEYS, 64, 1048576, 64 );

fgSizer8->Add( KeyfilesSize, 0, wxALL, 5 );

RandomSizeCheckBox = new wxCheckBox( this, wxID_ANY, _("Random size (64 <-> 1048576)"), wxDefaultPosition, wxDefaultSize, 0 );

fgSizer8->Add( RandomSizeCheckBox, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

m_staticText65 = new wxStaticText( this, wxID_ANY, _("Keyfiles base name:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText65->Wrap( -1 );

fgSizer8->Add( m_staticText65, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

KeyfilesBaseName = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

fgSizer8->Add( KeyfilesBaseName, 0, wxALL, 5 );

m_panel19 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

fgSizer8->Add( m_panel19, 1, wxEXPAND | wxALL, 5 );

bSizer162->Add( fgSizer8, 1, wxEXPAND, 5 );

bSizer144->Add( bSizer162, 0, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer146;

bSizer146 = new wxBoxSizer( wxHORIZONTAL );

GenerateButton = new wxButton( this, wxID_ANY, _("Generate and Save Keyfile..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer146->Add( GenerateButton, 0, wxALL, 5 );

bSizer146->Add( 0, 0, 1, wxEXPAND, 5 );

wxButton* m_button61;

m_button61 = new wxButton( this, wxID_CANCEL, _("Close"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer146->Add( m_button61, 0, wxALL, 5 );

bSizer144->Add( bSizer146, 0, wxEXPAND, 5 );

MainSizer->Add( bSizer144, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( MainSizer );

this->Layout();

MainSizer->Fit( this );

// Connect Events

this->Connect( wxEVT_MOTION, wxMouseEventHandler( KeyfileGeneratorDialogBase::OnMouseMotion ) );

HashChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( KeyfileGeneratorDialogBase::OnHashSelected ), NULL, this );

ShowRandomPoolCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( KeyfileGeneratorDialogBase::OnShowRandomPoolCheckBoxClicked ), NULL, this );

RandomSizeCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( KeyfileGeneratorDialogBase::OnRandomSizeCheckBoxClicked ), NULL, this );

GenerateButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfileGeneratorDialogBase::OnGenerateButtonClick ), NULL, this );

}

LegalNoticesDialogBase::LegalNoticesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer114;

bSizer114 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer115;

bSizer115 = new wxBoxSizer( wxVERTICAL );

LegalNoticesTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE|wxTE_READONLY );

bSizer115->Add( LegalNoticesTextCtrl, 1, wxALL|wxEXPAND, 5 );

wxButton* OKButton;

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer115->Add( OKButton, 0, wxALL|wxALIGN_CENTER_HORIZONTAL, 5 );

bSizer114->Add( bSizer115, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer114 );

this->Layout();

bSizer114->Fit( this );

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

MainSizer = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer19;

bSizer19 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer14;

bSizer14 = new wxBoxSizer( wxHORIZONTAL );

PasswordSizer = new wxBoxSizer( wxVERTICAL );

bSizer14->Add( PasswordSizer, 1, wxEXPAND, 5 );

wxBoxSizer* bSizer9;

bSizer9 = new wxBoxSizer( wxVERTICAL );

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer9->Add( OKButton, 0, wxALL|wxEXPAND, 5 );

CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer9->Add( CancelButton, 0, wxALL|wxEXPAND, 5 );

bSizer9->Add( 0, 0, 1, wxTOP|wxEXPAND, 5 );

OptionsButton = new wxButton( this, wxID_ANY, _("Op&tions"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer9->Add( OptionsButton, 0, wxALL|wxEXPAND, 5 );

bSizer14->Add( bSizer9, 0, wxEXPAND, 5 );

bSizer19->Add( bSizer14, 0, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer6;

bSizer6 = new wxBoxSizer( wxVERTICAL );

OptionsPanel = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

OptionsSizer = new wxStaticBoxSizer( new wxStaticBox( OptionsPanel, wxID_ANY, wxEmptyString ), wxVERTICAL );

OptionsSizer->Add( 0, 0, 0, wxTOP, 5 );

ReadOnlyCheckBox = new wxCheckBox( OptionsPanel, wxID_ANY, _("Mount volume as &read-only"), wxDefaultPosition, wxDefaultSize, 0 );

OptionsSizer->Add( ReadOnlyCheckBox, 0, wxALL, 5 );

RemovableCheckBox = new wxCheckBox( OptionsPanel, wxID_ANY, _("Mount volume as removable &medium"), wxDefaultPosition, wxDefaultSize, 0 );

OptionsSizer->Add( RemovableCheckBox, 0, wxALL, 5 );

PartitionInSystemEncryptionScopeCheckBox = new wxCheckBox( OptionsPanel, wxID_ANY, _("Mount partition &using system encryption (preboot authentication)"), wxDefaultPosition, wxDefaultSize, 0 );

OptionsSizer->Add( PartitionInSystemEncryptionScopeCheckBox, 0, wxALL, 5 );

ProtectionSizer = new wxStaticBoxSizer( new wxStaticBox( OptionsPanel, wxID_ANY, _("Hidden Volume Protection") ), wxVERTICAL );

ProtectionCheckBox = new wxCheckBox( OptionsPanel, wxID_ANY, _("&Protect hidden volume when mounting outer volume"), wxDefaultPosition, wxDefaultSize, 0 );

ProtectionSizer->Add( ProtectionCheckBox, 0, wxALL, 5 );

ProtectionPasswordSizer = new wxBoxSizer( wxVERTICAL );

ProtectionSizer->Add( ProtectionPasswordSizer, 1, wxEXPAND|wxLEFT, 5 );

ProtectionHyperlinkCtrl = new wxHyperlinkCtrl( OptionsPanel, wxID_ANY, _("What is hidden volume protection?"), wxEmptyString, wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE );

ProtectionHyperlinkCtrl->SetHoverColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

ProtectionHyperlinkCtrl->SetNormalColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

ProtectionHyperlinkCtrl->SetVisitedColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

ProtectionSizer->Add( ProtectionHyperlinkCtrl, 0, wxALL, 5 );

OptionsSizer->Add( ProtectionSizer, 1, wxEXPAND|wxALL, 5 );

FilesystemSizer = new wxBoxSizer( wxVERTICAL );

m_panel8 = new wxPanel( OptionsPanel, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxStaticBoxSizer* sbSizer28;

sbSizer28 = new wxStaticBoxSizer( new wxStaticBox( m_panel8, wxID_ANY, _("Filesystem") ), wxVERTICAL );

wxBoxSizer* bSizer54;

bSizer54 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer55;

bSizer55 = new wxBoxSizer( wxVERTICAL );

NoFilesystemCheckBox = new wxCheckBox( m_panel8, wxID_ANY, _("Do &not mount"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer55->Add( NoFilesystemCheckBox, 0, wxTOP|wxRIGHT|wxLEFT, 5 );

bSizer54->Add( bSizer55, 1, wxEXPAND, 5 );

FilesystemOptionsSizer = new wxGridBagSizer( 0, 0 );

FilesystemOptionsSizer->SetFlexibleDirection( wxBOTH );

FilesystemOptionsSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

FilesystemOptionsSizer->SetEmptyCellSize( wxSize( 0,0 ) );

FilesystemSpacer = new wxBoxSizer( wxVERTICAL );

FilesystemOptionsSizer->Add( FilesystemSpacer, wxGBPosition( 0, 0 ), wxGBSpan( 1, 1 ), wxEXPAND|wxTOP, 5 );

MountPointTextCtrlStaticText = new wxStaticText( m_panel8, wxID_ANY, _("Mount at directory:"), wxDefaultPosition, wxDefaultSize, 0 );

MountPointTextCtrlStaticText->Wrap( -1 );

FilesystemOptionsSizer->Add( MountPointTextCtrlStaticText, wxGBPosition( 1, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

MountPointTextCtrl = new wxTextCtrl( m_panel8, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

FilesystemOptionsSizer->Add( MountPointTextCtrl, wxGBPosition( 1, 1 ), wxGBSpan( 1, 1 ), wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

MountPointButton = new wxButton( m_panel8, wxID_ANY, _("Se&lect..."), wxDefaultPosition, wxDefaultSize, 0 );

FilesystemOptionsSizer->Add( MountPointButton, wxGBPosition( 1, 2 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxRIGHT|wxLEFT, 5 );

FilesystemOptionsStaticText = new wxStaticText( m_panel8, wxID_ANY, _("Mount options:"), wxDefaultPosition, wxDefaultSize, 0 );

FilesystemOptionsStaticText->Wrap( -1 );

FilesystemOptionsSizer->Add( FilesystemOptionsStaticText, wxGBPosition( 2, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxLEFT, 5 );

FilesystemOptionsTextCtrl = new wxTextCtrl( m_panel8, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

FilesystemOptionsSizer->Add( FilesystemOptionsTextCtrl, wxGBPosition( 2, 1 ), wxGBSpan( 1, 2 ), wxALIGN_CENTER_VERTICAL|wxEXPAND|wxTOP|wxRIGHT|wxLEFT, 5 );

FilesystemOptionsSizer->AddGrowableCol( 1 );

bSizer54->Add( FilesystemOptionsSizer, 0, wxEXPAND, 5 );

sbSizer28->Add( bSizer54, 0, wxEXPAND|wxBOTTOM, 5 );

m_panel8->SetSizer( sbSizer28 );

m_panel8->Layout();

sbSizer28->Fit( m_panel8 );

FilesystemSizer->Add( m_panel8, 0, wxEXPAND | wxALL, 5 );

OptionsSizer->Add( FilesystemSizer, 0, wxEXPAND, 5 );

OptionsPanel->SetSizer( OptionsSizer );

OptionsPanel->Layout();

OptionsSizer->Fit( OptionsPanel );

bSizer6->Add( OptionsPanel, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

bSizer19->Add( bSizer6, 0, wxEXPAND, 5 );

MainSizer->Add( bSizer19, 1, wxEXPAND, 5 );

this->SetSizer( MainSizer );

this->Layout();

MainSizer->Fit( this );

this->Centre( wxBOTH );

// Connect Events

this->Connect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( MountOptionsDialogBase::OnInitDialog ) );

OKButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MountOptionsDialogBase::OnOKButtonClick ), NULL, this );

ProtectionHyperlinkCtrl->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( MountOptionsDialogBase::OnProtectionHyperlinkClick ), NULL, this );

NoFilesystemCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( MountOptionsDialogBase::OnNoFilesystemCheckBoxClick ), NULL, this );

MountPointButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( MountOptionsDialogBase::OnMountPointButtonClick ), NULL, this );

}

NewSecurityTokenKeyfileDialogBase::NewSecurityTokenKeyfileDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer143;

bSizer143 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer144;

bSizer144 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer42;

sbSizer42 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxEmptyString ), wxVERTICAL );

wxFlexGridSizer* fgSizer7;

fgSizer7 = new wxFlexGridSizer( 2, 2, 0, 0 );

fgSizer7->SetFlexibleDirection( wxBOTH );

fgSizer7->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText47;

m_staticText47 = new wxStaticText( this, wxID_ANY, _("Security token:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );

m_staticText47->Wrap( -1 );

fgSizer7->Add( m_staticText47, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxArrayString SecurityTokenChoiceChoices;

SecurityTokenChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, SecurityTokenChoiceChoices, 0 );

SecurityTokenChoice->SetSelection( 0 );

fgSizer7->Add( SecurityTokenChoice, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

wxStaticText* m_staticText48;

m_staticText48 = new wxStaticText( this, wxID_ANY, _("Keyfile name:"), wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT );

m_staticText48->Wrap( -1 );

fgSizer7->Add( m_staticText48, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

KeyfileNameTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

fgSizer7->Add( KeyfileNameTextCtrl, 0, wxALIGN_CENTER_VERTICAL|wxEXPAND|wxALL, 5 );

sbSizer42->Add( fgSizer7, 1, wxEXPAND|wxTOP, 5 );

bSizer144->Add( sbSizer42, 1, wxEXPAND|wxALL, 5 );

StdButtons = new wxStdDialogButtonSizer();

StdButtonsOK = new wxButton( this, wxID_OK );

StdButtons->AddButton( StdButtonsOK );

StdButtonsCancel = new wxButton( this, wxID_CANCEL );

StdButtons->AddButton( StdButtonsCancel );

StdButtons->Realize();

bSizer144->Add( StdButtons, 0, wxALIGN_RIGHT|wxALL, 5 );

bSizer143->Add( bSizer144, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer143 );

this->Layout();

bSizer143->Fit( this );

// Connect Events

KeyfileNameTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( NewSecurityTokenKeyfileDialogBase::OnKeyfileNameChanged ), NULL, this );

}

{

// Disconnect Events

KeyfileNameTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( NewSecurityTokenKeyfileDialogBase::OnKeyfileNameChanged ), NULL, this );

}

PreferencesDialogBase::PreferencesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

wxBoxSizer* bSizer32;

bSizer32 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer41;

bSizer41 = new wxBoxSizer( wxVERTICAL );

PreferencesNotebook = new wxNotebook( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0 );

SecurityPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer44;

bSizer44 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer33;

bSizer33 = new wxBoxSizer( wxVERTICAL );

AutoDismountSizer = new wxStaticBoxSizer( new wxStaticBox( SecurityPage, wxID_ANY, _("Auto-Dismount") ), wxVERTICAL );

wxStaticBoxSizer* sbSizer13;

sbSizer13 = new wxStaticBoxSizer( new wxStaticBox( SecurityPage, wxID_ANY, _("Dismount All Volumes When") ), wxVERTICAL );

DismountOnLogOffCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("User logs off"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer13->Add( DismountOnLogOffCheckBox, 0, wxALL, 5 );

DismountOnScreenSaverCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Screen saver is launched"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer13->Add( DismountOnScreenSaverCheckBox, 0, wxALL, 5 );

DismountOnPowerSavingCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("System is entering power saving mode"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer13->Add( DismountOnPowerSavingCheckBox, 0, wxALL, 5 );

AutoDismountSizer->Add( sbSizer13, 0, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer34;

bSizer34 = new wxBoxSizer( wxHORIZONTAL );

DismountOnInactivityCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Auto-dismount volume after no data has been read/written to it for"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer34->Add( DismountOnInactivityCheckBox, 0, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

DismountOnInactivitySpinCtrl = new wxSpinCtrl( SecurityPage, wxID_ANY, wxT("1"), wxDefaultPosition, wxSize( -1,-1 ), wxSP_ARROW_KEYS, 1, 9999, 1 );

DismountOnInactivitySpinCtrl->SetMinSize( wxSize( 60,-1 ) );

bSizer34->Add( DismountOnInactivitySpinCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

wxStaticText* m_staticText5;

m_staticText5 = new wxStaticText( SecurityPage, wxID_ANY, _("minutes"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText5->Wrap( -1 );

bSizer34->Add( m_staticText5, 1, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxRIGHT, 5 );

AutoDismountSizer->Add( bSizer34, 0, wxEXPAND, 5 );

ForceAutoDismountCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Force auto-dismount even if volume contains open files or directories"), wxDefaultPosition, wxDefaultSize, 0 );

AutoDismountSizer->Add( ForceAutoDismountCheckBox, 0, wxALL, 5 );

bSizer33->Add( AutoDismountSizer, 0, wxEXPAND|wxALL, 5 );

FilesystemSecuritySizer = new wxStaticBoxSizer( new wxStaticBox( SecurityPage, wxID_ANY, _("Filesystem") ), wxVERTICAL );

PreserveTimestampsCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Preserve modification timestamp of file containers"), wxDefaultPosition, wxDefaultSize, 0 );

FilesystemSecuritySizer->Add( PreserveTimestampsCheckBox, 0, wxALL, 5 );

bSizer33->Add( FilesystemSecuritySizer, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer14;

sbSizer14 = new wxStaticBoxSizer( new wxStaticBox( SecurityPage, wxID_ANY, _("Password Cache") ), wxVERTICAL );

WipeCacheOnCloseCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Wipe after VeraCrypt window has been closed"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer14->Add( WipeCacheOnCloseCheckBox, 0, wxALL, 5 );

WipeCacheOnAutoDismountCheckBox = new wxCheckBox( SecurityPage, wxID_ANY, _("Wipe after volume has been auto-dismounted"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer14->Add( WipeCacheOnAutoDismountCheckBox, 0, wxALL, 5 );

bSizer33->Add( sbSizer14, 0, wxEXPAND|wxALL, 5 );

bSizer44->Add( bSizer33, 1, wxEXPAND|wxALL, 5 );

SecurityPage->SetSizer( bSizer44 );

SecurityPage->Layout();

bSizer44->Fit( SecurityPage );

DefaultMountOptionsPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer46;

bSizer46 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer35;

bSizer35 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer15;

sbSizer15 = new wxStaticBoxSizer( new wxStaticBox( DefaultMountOptionsPage, wxID_ANY, _("Default Mount Options") ), wxVERTICAL );

MountReadOnlyCheckBox = new wxCheckBox( DefaultMountOptionsPage, wxID_ANY, _("Mount volumes as read-only"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer15->Add( MountReadOnlyCheckBox, 0, wxALL, 5 );

MountRemovableCheckBox = new wxCheckBox( DefaultMountOptionsPage, wxID_ANY, _("Mount volumes as removable media"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer15->Add( MountRemovableCheckBox, 0, wxALL, 5 );

CachePasswordsCheckBox = new wxCheckBox( DefaultMountOptionsPage, wxID_ANY, _("Cache passwords in memory"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer15->Add( CachePasswordsCheckBox, 0, wxALL, 5 );

TrueCryptModeCheckBox = new wxCheckBox( DefaultMountOptionsPage, wxID_ANY, _("TrueCrypt Mode"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer15->Add( TrueCryptModeCheckBox, 0, wxALL, 5 );

wxBoxSizer* bSizer163;

bSizer163 = new wxBoxSizer( wxHORIZONTAL );

Pkcs5PrfStaticText = new wxStaticText( DefaultMountOptionsPage, wxID_ANY, _("PKCS5-PRF:"), wxDefaultPosition, wxDefaultSize, 0 );

Pkcs5PrfStaticText->Wrap( -1 );

bSizer163->Add( Pkcs5PrfStaticText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

wxArrayString Pkcs5PrfChoiceChoices;

Pkcs5PrfChoice = new wxChoice( DefaultMountOptionsPage, wxID_ANY, wxDefaultPosition, wxDefaultSize, Pkcs5PrfChoiceChoices, 0 );

Pkcs5PrfChoice->SetSelection( 0 );

bSizer163->Add( Pkcs5PrfChoice, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

sbSizer15->Add( bSizer163, 0, wxEXPAND, 5 );

bSizer35->Add( sbSizer15, 0, wxEXPAND|wxALL, 5 );

FilesystemSizer = new wxStaticBoxSizer( new wxStaticBox( DefaultMountOptionsPage, wxID_ANY, _("Filesystem") ), wxVERTICAL );

wxFlexGridSizer* fgSizer3;

fgSizer3 = new wxFlexGridSizer( 1, 2, 0, 0 );

fgSizer3->AddGrowableCol( 1 );

fgSizer3->SetFlexibleDirection( wxBOTH );

fgSizer3->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText6;

m_staticText6 = new wxStaticText( DefaultMountOptionsPage, wxID_ANY, _("Mount options:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText6->Wrap( -1 );

fgSizer3->Add( m_staticText6, 0, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );

FilesystemOptionsTextCtrl = new wxTextCtrl( DefaultMountOptionsPage, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

fgSizer3->Add( FilesystemOptionsTextCtrl, 0, wxALL|wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );

FilesystemSizer->Add( fgSizer3, 1, wxEXPAND, 5 );

bSizer35->Add( FilesystemSizer, 0, wxEXPAND|wxALL, 5 );

bSizer46->Add( bSizer35, 1, wxEXPAND|wxALL, 5 );

DefaultMountOptionsPage->SetSizer( bSizer46 );

DefaultMountOptionsPage->Layout();

bSizer46->Fit( DefaultMountOptionsPage );

BackgroundTaskPanel = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer61;

bSizer61 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer62;

bSizer62 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer18;

sbSizer18 = new wxStaticBoxSizer( new wxStaticBox( BackgroundTaskPanel, wxID_ANY, _("VeraCrypt Background Task") ), wxVERTICAL );

BackgroundTaskEnabledCheckBox = new wxCheckBox( BackgroundTaskPanel, wxID_ANY, _("Enabled"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer18->Add( BackgroundTaskEnabledCheckBox, 0, wxALL, 5 );

CloseBackgroundTaskOnNoVolumesCheckBox = new wxCheckBox( BackgroundTaskPanel, wxID_ANY, _("Exit when there are no mounted volumes"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer18->Add( CloseBackgroundTaskOnNoVolumesCheckBox, 0, wxALL, 5 );

wxStaticBoxSizer* sbSizer26;

sbSizer26 = new wxStaticBoxSizer( new wxStaticBox( BackgroundTaskPanel, wxID_ANY, _("Task Icon Menu Items") ), wxVERTICAL );

BackgroundTaskMenuMountItemsEnabledCheckBox = new wxCheckBox( BackgroundTaskPanel, wxID_ANY, _("Mount Favorite Volumes"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer26->Add( BackgroundTaskMenuMountItemsEnabledCheckBox, 0, wxALL, 5 );

BackgroundTaskMenuOpenItemsEnabledCheckBox = new wxCheckBox( BackgroundTaskPanel, wxID_ANY, _("Open Mounted Volumes"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer26->Add( BackgroundTaskMenuOpenItemsEnabledCheckBox, 0, wxALL, 5 );

BackgroundTaskMenuDismountItemsEnabledCheckBox = new wxCheckBox( BackgroundTaskPanel, wxID_ANY, _("Dismount Mounted Volumes"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer26->Add( BackgroundTaskMenuDismountItemsEnabledCheckBox, 0, wxALL, 5 );

sbSizer18->Add( sbSizer26, 1, wxEXPAND|wxALL, 5 );

bSizer62->Add( sbSizer18, 0, wxEXPAND|wxALL, 5 );

bSizer61->Add( bSizer62, 1, wxEXPAND|wxALL, 5 );

BackgroundTaskPanel->SetSizer( bSizer61 );

BackgroundTaskPanel->Layout();

bSizer61->Fit( BackgroundTaskPanel );

SystemIntegrationPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer49;

bSizer49 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer37;

bSizer37 = new wxBoxSizer( wxVERTICAL );

LogOnSizer = new wxStaticBoxSizer( new wxStaticBox( SystemIntegrationPage, wxID_ANY, _("Actions to Perform when User Logs On") ), wxVERTICAL );

StartOnLogonCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Start VeraCrypt Background Task"), wxDefaultPosition, wxDefaultSize, 0 );

LogOnSizer->Add( StartOnLogonCheckBox, 0, wxALL, 5 );

MountFavoritesOnLogonCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Mount favorite volumes"), wxDefaultPosition, wxDefaultSize, 0 );

LogOnSizer->Add( MountFavoritesOnLogonCheckBox, 0, wxALL, 5 );

MountDevicesOnLogonCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Mount all device-hosted VeraCrypt volumes"), wxDefaultPosition, wxDefaultSize, 0 );

LogOnSizer->Add( MountDevicesOnLogonCheckBox, 0, wxALL, 5 );

bSizer37->Add( LogOnSizer, 0, wxALL|wxEXPAND, 5 );

ExplorerSizer = new wxStaticBoxSizer( new wxStaticBox( SystemIntegrationPage, wxID_ANY, _("Filesystem Explorer") ), wxVERTICAL );

OpenExplorerWindowAfterMountCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Open Explorer window for successfully mounted volume"), wxDefaultPosition, wxDefaultSize, 0 );

ExplorerSizer->Add( OpenExplorerWindowAfterMountCheckBox, 0, wxALL, 5 );

CloseExplorerWindowsOnDismountCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Close all Explorer windows of volume being dismounted"), wxDefaultPosition, wxDefaultSize, 0 );

ExplorerSizer->Add( CloseExplorerWindowsOnDismountCheckBox, 0, wxALL, 5 );

bSizer37->Add( ExplorerSizer, 0, wxEXPAND|wxALL, 5 );

KernelServicesSizer = new wxStaticBoxSizer( new wxStaticBox( SystemIntegrationPage, wxID_ANY, _("Kernel Services") ), wxVERTICAL );

NoKernelCryptoCheckBox = new wxCheckBox( SystemIntegrationPage, wxID_ANY, _("Do not use kernel cryptographic services"), wxDefaultPosition, wxDefaultSize, 0 );

KernelServicesSizer->Add( NoKernelCryptoCheckBox, 0, wxALL, 5 );

bSizer37->Add( KernelServicesSizer, 0, wxEXPAND|wxALL, 5 );

bSizer49->Add( bSizer37, 1, wxEXPAND|wxALL, 5 );

SystemIntegrationPage->SetSizer( bSizer49 );

SystemIntegrationPage->Layout();

bSizer49->Fit( SystemIntegrationPage );

PerformanceOptionsPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer151;

bSizer151 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer152;

bSizer152 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer44;

sbSizer44 = new wxStaticBoxSizer( new wxStaticBox( PerformanceOptionsPage, wxID_ANY, _("Hardware Acceleration") ), wxVERTICAL );

wxBoxSizer* bSizer158;

bSizer158 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText57;

m_staticText57 = new wxStaticText( PerformanceOptionsPage, wxID_ANY, _("Processor (CPU) in this computer supports hardware acceleration for AES:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText57->Wrap( -1 );

bSizer158->Add( m_staticText57, 0, wxALL, 5 );

AesHwCpuSupportedStaticText = new wxStaticText( PerformanceOptionsPage, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0|wxSUNKEN_BORDER );

AesHwCpuSupportedStaticText->Wrap( -1 );

bSizer158->Add( AesHwCpuSupportedStaticText, 0, wxALL, 5 );

sbSizer44->Add( bSizer158, 1, wxEXPAND, 5 );

sbSizer44->Add( 0, 0, 0, wxBOTTOM, 5 );

NoHardwareCryptoCheckBox = new wxCheckBox( PerformanceOptionsPage, wxID_ANY, _("Do not accelerate AES encryption/decryption by using the AES instructions of the processor"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer44->Add( NoHardwareCryptoCheckBox, 0, wxALL, 5 );

bSizer152->Add( sbSizer44, 0, wxEXPAND|wxALL, 5 );

bSizer151->Add( bSizer152, 1, wxALL|wxEXPAND, 5 );

PerformanceOptionsPage->SetSizer( bSizer151 );

PerformanceOptionsPage->Layout();

bSizer151->Fit( PerformanceOptionsPage );

DefaultKeyfilesPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer40;

bSizer40 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer43;

bSizer43 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* bSizer42;

bSizer42 = new wxStaticBoxSizer( new wxStaticBox( DefaultKeyfilesPage, wxID_ANY, _("Default Keyfiles") ), wxVERTICAL );

DefaultKeyfilesSizer = new wxBoxSizer( wxVERTICAL );

bSizer42->Add( DefaultKeyfilesSizer, 1, wxEXPAND, 5 );

bSizer43->Add( bSizer42, 1, wxEXPAND|wxALL, 5 );

UseKeyfilesCheckBox = new wxCheckBox( DefaultKeyfilesPage, wxID_ANY, _("Use keyfiles by default"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer43->Add( UseKeyfilesCheckBox, 0, wxALL, 5 );

bSizer40->Add( bSizer43, 1, wxEXPAND|wxALL, 5 );

DefaultKeyfilesPage->SetSizer( bSizer40 );

DefaultKeyfilesPage->Layout();

bSizer40->Fit( DefaultKeyfilesPage );

SecurityTokensPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer127;

bSizer127 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer128;

bSizer128 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer36;

sbSizer36 = new wxStaticBoxSizer( new wxStaticBox( SecurityTokensPage, wxID_ANY, _("PKCS #11 Library Path") ), wxVERTICAL );

wxBoxSizer* bSizer129;

bSizer129 = new wxBoxSizer( wxHORIZONTAL );

Pkcs11ModulePathTextCtrl = new wxTextCtrl( SecurityTokensPage, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

bSizer129->Add( Pkcs11ModulePathTextCtrl, 1, wxALL, 5 );

SelectPkcs11ModuleButton = new wxButton( SecurityTokensPage, wxID_ANY, _("Select &Library..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer129->Add( SelectPkcs11ModuleButton, 0, wxALL, 5 );

sbSizer36->Add( bSizer129, 1, wxEXPAND, 5 );

bSizer128->Add( sbSizer36, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer37;

sbSizer37 = new wxStaticBoxSizer( new wxStaticBox( SecurityTokensPage, wxID_ANY, _("Security Options") ), wxVERTICAL );

CloseSecurityTokenSessionsAfterMountCheckBox = new wxCheckBox( SecurityTokensPage, wxID_ANY, _("&Close token session (log out) after a volume is successfully mounted"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer37->Add( CloseSecurityTokenSessionsAfterMountCheckBox, 0, wxALL, 5 );

bSizer128->Add( sbSizer37, 0, wxEXPAND|wxALL, 5 );

bSizer127->Add( bSizer128, 1, wxEXPAND|wxALL, 5 );

SecurityTokensPage->SetSizer( bSizer127 );

SecurityTokensPage->Layout();

bSizer127->Fit( SecurityTokensPage );

HotkeysPage = new wxPanel( PreferencesNotebook, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL );

wxBoxSizer* bSizer51;

bSizer51 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer38;

bSizer38 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer21;

sbSizer21 = new wxStaticBoxSizer( new wxStaticBox( HotkeysPage, wxID_ANY, _("System-Wide Hotkeys") ), wxVERTICAL );

HotkeyListCtrl = new wxListCtrl( HotkeysPage, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_SINGLE_SEL|wxLC_VRULES|wxSUNKEN_BORDER );

sbSizer21->Add( HotkeyListCtrl, 1, wxALL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer23;

sbSizer23 = new wxStaticBoxSizer( new wxStaticBox( HotkeysPage, wxID_ANY, _("Shortcut") ), wxVERTICAL );

wxFlexGridSizer* fgSizer4;

fgSizer4 = new wxFlexGridSizer( 2, 3, 0, 0 );

fgSizer4->SetFlexibleDirection( wxBOTH );

fgSizer4->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText10;

m_staticText10 = new wxStaticText( HotkeysPage, wxID_ANY, _("Key to assign:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText10->Wrap( -1 );

fgSizer4->Add( m_staticText10, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

HotkeyTextCtrl = new wxTextCtrl( HotkeysPage, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

fgSizer4->Add( HotkeyTextCtrl, 0, wxALL|wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );

AssignHotkeyButton = new wxButton( HotkeysPage, wxID_ANY, _("Assign"), wxDefaultPosition, wxDefaultSize, 0 );

fgSizer4->Add( AssignHotkeyButton, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

fgSizer4->Add( 0, 0, 1, wxEXPAND, 5 );

wxGridSizer* gSizer4;

gSizer4 = new wxGridSizer( 1, 4, 0, 0 );

HotkeyControlCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Control"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer4->Add( HotkeyControlCheckBox, 0, wxALL, 5 );

HotkeyShiftCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Shift"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer4->Add( HotkeyShiftCheckBox, 0, wxALL, 5 );

HotkeyAltCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Alt"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer4->Add( HotkeyAltCheckBox, 0, wxALL, 5 );

HotkeyWinCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Win"), wxDefaultPosition, wxDefaultSize, 0 );

gSizer4->Add( HotkeyWinCheckBox, 0, wxALL, 5 );

fgSizer4->Add( gSizer4, 1, wxEXPAND, 5 );

RemoveHotkeyButton = new wxButton( HotkeysPage, wxID_ANY, _("Remove"), wxDefaultPosition, wxDefaultSize, 0 );

fgSizer4->Add( RemoveHotkeyButton, 1, wxALL, 5 );

sbSizer23->Add( fgSizer4, 1, wxALIGN_RIGHT, 5 );

sbSizer21->Add( sbSizer23, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer24;

sbSizer24 = new wxStaticBoxSizer( new wxStaticBox( HotkeysPage, wxID_ANY, _("Options") ), wxVERTICAL );

BeepAfterHotkeyMountDismountCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Play system notification sound after mount/dismount"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer24->Add( BeepAfterHotkeyMountDismountCheckBox, 0, wxALL, 5 );

DisplayMessageAfterHotkeyDismountCheckBox = new wxCheckBox( HotkeysPage, wxID_ANY, _("Display confirmation message box after dismount"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer24->Add( DisplayMessageAfterHotkeyDismountCheckBox, 0, wxALL, 5 );

sbSizer21->Add( sbSizer24, 0, wxEXPAND|wxALL, 5 );

bSizer38->Add( sbSizer21, 1, wxEXPAND|wxALL, 5 );

bSizer51->Add( bSizer38, 1, wxEXPAND|wxALL, 5 );

HotkeysPage->SetSizer( bSizer51 );

HotkeysPage->Layout();

bSizer51->Fit( HotkeysPage );

PreferencesNotebook->AddPage( HotkeysPage, _("Hotkeys"), false );

bSizer41->Add( PreferencesNotebook, 1, wxEXPAND | wxALL, 5 );

StdButtons = new wxStdDialogButtonSizer();

StdButtonsOK = new wxButton( this, wxID_OK );

StdButtons->AddButton( StdButtonsOK );

StdButtonsCancel = new wxButton( this, wxID_CANCEL );

StdButtons->AddButton( StdButtonsCancel );

StdButtons->Realize();

bSizer41->Add( StdButtons, 0, wxEXPAND|wxALL, 5 );

bSizer32->Add( bSizer41, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer32 );

this->Layout();

bSizer32->Fit( this );

// Connect Events

this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( PreferencesDialogBase::OnClose ) );

DismountOnScreenSaverCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnDismountOnScreenSaverCheckBoxClick ), NULL, this );

RemoveHotkeyButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnRemoveHotkeyButtonClick ), NULL, this );

StdButtonsCancel->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnCancelButtonClick ), NULL, this );

StdButtonsOK->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnOKButtonClick ), NULL, this );

}

RandomPoolEnrichmentDialogBase::RandomPoolEnrichmentDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

MainSizer = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer144;

bSizer144 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer145;

bSizer145 = new wxBoxSizer( wxHORIZONTAL );

bSizer145->Add( 0, 0, 1, wxEXPAND, 5 );

wxStaticText* m_staticText49;

m_staticText49 = new wxStaticText( this, wxID_ANY, _("Mixing PRF:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText49->Wrap( -1 );

bSizer145->Add( m_staticText49, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

wxArrayString HashChoiceChoices;

HashChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, HashChoiceChoices, 0 );

HashChoice->SetSelection( 0 );

bSizer145->Add( HashChoice, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer145->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer144->Add( bSizer145, 0, wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer43;

sbSizer43 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxEmptyString ), wxVERTICAL );

wxBoxSizer* bSizer147;

bSizer147 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText52;

m_staticText52 = new wxStaticText( this, wxID_ANY, _("Random Pool:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText52->Wrap( -1 );

bSizer147->Add( m_staticText52, 0, wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

RandomPoolStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

RandomPoolStaticText->Wrap( -1 );

RandomPoolStaticText->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier New") ) );

bSizer147->Add( RandomPoolStaticText, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

ShowRandomPoolCheckBox = new wxCheckBox( this, wxID_ANY, _("Show"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer147->Add( ShowRandomPoolCheckBox, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

sbSizer43->Add( bSizer147, 0, wxEXPAND|wxTOP, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer45;

sbSizer45 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Randomness Collected From Mouse Movements") ), wxVERTICAL );

CollectedEntropy = new wxGauge( this, wxID_ANY, 2560, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

sbSizer45->Add( CollectedEntropy, 0, wxALL|wxEXPAND, 5 );

sbSizer43->Add( sbSizer45, 0, wxBOTTOM|wxEXPAND|wxTOP, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

MouseStaticText = new wxStaticText( this, wxID_ANY, _("IMPORTANT: Move your mouse as randomly as possible within this window. The longer you move it, the better. This significantly increases security. When done, click 'Continue'."), wxDefaultPosition, wxDefaultSize, 0 );

MouseStaticText->Wrap( -1 );

sbSizer43->Add( MouseStaticText, 0, wxALL|wxALIGN_CENTER_HORIZONTAL, 5 );

sbSizer43->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer144->Add( sbSizer43, 1, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

wxBoxSizer* bSizer146;

bSizer146 = new wxBoxSizer( wxHORIZONTAL );

bSizer146->Add( 0, 0, 1, wxEXPAND, 5 );

ContinueButton = new wxButton( this, wxID_OK, _("&Continue"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer146->Add( ContinueButton, 0, wxALL, 5 );

bSizer146->Add( 0, 0, 1, wxEXPAND, 5 );

bSizer144->Add( bSizer146, 0, wxEXPAND, 5 );

MainSizer->Add( bSizer144, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( MainSizer );

this->Layout();

MainSizer->Fit( this );

this->Centre( wxBOTH );

// Connect Events

this->Connect( wxEVT_MOTION, wxMouseEventHandler( RandomPoolEnrichmentDialogBase::OnMouseMotion ) );

HashChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( RandomPoolEnrichmentDialogBase::OnHashSelected ), NULL, this );

this->Disconnect( wxEVT_MOTION, wxMouseEventHandler( RandomPoolEnrichmentDialogBase::OnMouseMotion ) );

HashChoice->Disconnect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( RandomPoolEnrichmentDialogBase::OnHashSelected ), NULL, this );

ShowRandomPoolCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( RandomPoolEnrichmentDialogBase::OnShowRandomPoolCheckBoxClicked ), NULL, this );

}

SecurityTokenKeyfilesDialogBase::SecurityTokenKeyfilesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxSize( -1,-1 ), wxDefaultSize );

this->SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );

wxBoxSizer* bSizer3;

bSizer3 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer138;

bSizer138 = new wxBoxSizer( wxHORIZONTAL );

wxBoxSizer* bSizer142;

bSizer142 = new wxBoxSizer( wxVERTICAL );

SecurityTokenKeyfileListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VRULES|wxSUNKEN_BORDER );

bSizer142->Add( SecurityTokenKeyfileListCtrl, 1, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer141;

bSizer141 = new wxBoxSizer( wxHORIZONTAL );

ExportButton = new wxButton( this, wxID_ANY, _("&Export..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer141->Add( ExportButton, 0, wxALL, 5 );

DeleteButton = new wxButton( this, wxID_ANY, _("&Delete"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer141->Add( DeleteButton, 0, wxALL, 5 );

bSizer141->Add( 0, 0, 1, wxEXPAND|wxLEFT, 5 );

ImportButton = new wxButton( this, wxID_ANY, _("&Import Keyfile to Token..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer141->Add( ImportButton, 0, wxALL, 5 );

bSizer142->Add( bSizer141, 0, wxEXPAND, 5 );

bSizer138->Add( bSizer142, 1, wxEXPAND, 5 );

wxBoxSizer* bSizer139;

bSizer139 = new wxBoxSizer( wxVERTICAL );

OKButton = new wxButton( this, wxID_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer139->Add( OKButton, 0, wxALL, 5 );

CancelButton = new wxButton( this, wxID_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer139->Add( CancelButton, 0, wxALL, 5 );

bSizer138->Add( bSizer139, 0, wxEXPAND, 5 );

bSizer3->Add( bSizer138, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer3 );

this->Layout();

bSizer3->Fit( this );

// Connect Events

SecurityTokenKeyfileListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler( SecurityTokenKeyfilesDialogBase::OnListItemActivated ), NULL, this );

SecurityTokenKeyfileListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( SecurityTokenKeyfilesDialogBase::OnListItemDeselected ), NULL, this );

DeleteButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SecurityTokenKeyfilesDialogBase::OnDeleteButtonClick ), NULL, this );

ImportButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SecurityTokenKeyfilesDialogBase::OnImportButtonClick ), NULL, this );

OKButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SecurityTokenKeyfilesDialogBase::OnOKButtonClick ), NULL, this );

}

VolumePropertiesDialogBase::VolumePropertiesDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer49;

bSizer49 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer50;

bSizer50 = new wxBoxSizer( wxVERTICAL );

PropertiesListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxLC_VRULES|wxSUNKEN_BORDER );

bSizer50->Add( PropertiesListCtrl, 1, wxALL|wxEXPAND, 5 );

StdButtons = new wxStdDialogButtonSizer();

StdButtonsOK = new wxButton( this, wxID_OK );

StdButtons->AddButton( StdButtonsOK );

StdButtons->Realize();

bSizer50->Add( StdButtons, 0, wxALL|wxALIGN_CENTER_HORIZONTAL, 5 );

bSizer49->Add( bSizer50, 1, wxEXPAND|wxALL, 5 );

this->SetSizer( bSizer49 );

this->Layout();

bSizer49->Fit( this );

{

wxBoxSizer* bSizer93;

bSizer93 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer94;

bSizer94 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer95;

bSizer95 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer29;

sbSizer29 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Encryption Algorithm") ), wxVERTICAL );

wxBoxSizer* bSizer96;

bSizer96 = new wxBoxSizer( wxHORIZONTAL );

wxArrayString EncryptionAlgorithmChoiceChoices;

EncryptionAlgorithmChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, EncryptionAlgorithmChoiceChoices, 0 );

EncryptionAlgorithmChoice->SetSelection( 0 );

bSizer96->Add( EncryptionAlgorithmChoice, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

TestButton = new wxButton( this, wxID_ANY, _("&Test"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer96->Add( TestButton, 0, wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

sbSizer29->Add( bSizer96, 0, wxEXPAND, 5 );

EncryptionAlgorithmStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

EncryptionAlgorithmStaticText->Wrap( -1 );

sbSizer29->Add( EncryptionAlgorithmStaticText, 1, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer97;

bSizer97 = new wxBoxSizer( wxHORIZONTAL );

EncryptionAlgorithmHyperlink = new wxHyperlinkCtrl( this, wxID_ANY, _("More information"), wxEmptyString, wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE );

EncryptionAlgorithmHyperlink->SetHoverColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

EncryptionAlgorithmHyperlink->SetNormalColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

EncryptionAlgorithmHyperlink->SetVisitedColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

bSizer97->Add( EncryptionAlgorithmHyperlink, 0, wxALL, 5 );

bSizer97->Add( 0, 0, 1, wxEXPAND, 5 );

BenchmarkButton = new wxButton( this, wxID_ANY, _("&Benchmark"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer97->Add( BenchmarkButton, 0, wxALL, 5 );

sbSizer29->Add( bSizer97, 0, wxEXPAND, 5 );

bSizer95->Add( sbSizer29, 1, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer30;

sbSizer30 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Hash Algorithm") ), wxHORIZONTAL );

wxArrayString HashChoiceChoices;

HashChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, HashChoiceChoices, 0 );

HashChoice->SetSelection( 0 );

sbSizer30->Add( HashChoice, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

HashHyperlink = new wxHyperlinkCtrl( this, wxID_ANY, _("Information on hash algorithms"), wxEmptyString, wxDefaultPosition, wxDefaultSize, wxHL_DEFAULT_STYLE );

HashHyperlink->SetHoverColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

HashHyperlink->SetNormalColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

HashHyperlink->SetVisitedColour( wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT ) );

sbSizer30->Add( HashHyperlink, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer95->Add( sbSizer30, 0, wxEXPAND|wxALL, 5 );

bSizer94->Add( bSizer95, 1, wxEXPAND, 5 );

bSizer93->Add( bSizer94, 1, wxEXPAND, 5 );

this->SetSizer( bSizer93 );

this->Layout();

bSizer93->Fit( this );

// Connect Events

EncryptionAlgorithmChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( EncryptionOptionsWizardPageBase::OnEncryptionAlgorithmSelected ), NULL, this );

TestButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( EncryptionOptionsWizardPageBase::OnTestButtonClick ), NULL, this );

EncryptionAlgorithmHyperlink->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( EncryptionOptionsWizardPageBase::OnEncryptionAlgorithmHyperlinkClick ), NULL, this );

BenchmarkButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( EncryptionOptionsWizardPageBase::OnBenchmarkButtonClick ), NULL, this );

HashHyperlink->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( EncryptionOptionsWizardPageBase::OnHashHyperlinkClick ), NULL, this );

}

InfoWizardPageBase::InfoWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer71;

bSizer71 = new wxBoxSizer( wxVERTICAL );

InfoPageSizer = new wxBoxSizer( wxVERTICAL );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

InfoPageSizer->Add( InfoStaticText, 1, wxALL|wxEXPAND, 5 );

bSizer71->Add( InfoPageSizer, 1, wxEXPAND, 5 );

this->SetSizer( bSizer71 );

this->Layout();

bSizer71->Fit( this );

KeyfilesPanelBase::KeyfilesPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )

{

this->SetMinSize( wxSize( 500,300 ) );

wxBoxSizer* bSizer19;

bSizer19 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer20;

bSizer20 = new wxBoxSizer( wxHORIZONTAL );

wxBoxSizer* bSizer21;

bSizer21 = new wxBoxSizer( wxVERTICAL );

KeyfilesListCtrl = new wxListCtrl( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxLC_NO_SORT_HEADER|wxLC_REPORT|wxSUNKEN_BORDER );

bSizer21->Add( KeyfilesListCtrl, 1, wxEXPAND|wxALL, 5 );

wxBoxSizer* bSizer137;

bSizer137 = new wxBoxSizer( wxHORIZONTAL );

AddFilesButton = new wxButton( this, wxID_ANY, _("Add &Files..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer137->Add( AddFilesButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

AddDirectoryButton = new wxButton( this, wxID_ANY, _("Add &Path..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer137->Add( AddDirectoryButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

AddSecurityTokenSignatureButton = new wxButton( this, wxID_ANY, _("Add &Token Files..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer137->Add( AddSecurityTokenSignatureButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

RemoveButton = new wxButton( this, wxID_ANY, _("&Remove"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer137->Add( RemoveButton, 0, wxEXPAND|wxTOP|wxBOTTOM|wxLEFT, 5 );

RemoveAllButton = new wxButton( this, wxID_ANY, _("Remove &All"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer137->Add( RemoveAllButton, 0, wxEXPAND|wxALL, 5 );

bSizer21->Add( bSizer137, 0, wxEXPAND, 5 );

bSizer20->Add( bSizer21, 1, wxEXPAND, 5 );

bSizer19->Add( bSizer20, 1, wxEXPAND, 5 );

this->SetSizer( bSizer19 );

this->Layout();

bSizer19->Fit( this );

// Connect Events

KeyfilesListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( KeyfilesPanelBase::OnListItemDeselected ), NULL, this );

KeyfilesListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( KeyfilesPanelBase::OnListItemSelected ), NULL, this );

AddSecurityTokenSignatureButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfilesPanelBase::OnAddSecurityTokenSignatureButtonClick ), NULL, this );

RemoveButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfilesPanelBase::OnRemoveButtonClick ), NULL, this );

RemoveAllButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( KeyfilesPanelBase::OnRemoveAllButtonClick ), NULL, this );

}

ProgressWizardPageBase::ProgressWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer81;

bSizer81 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer82;

bSizer82 = new wxBoxSizer( wxVERTICAL );

ProgressSizer = new wxBoxSizer( wxHORIZONTAL );

ProgressGauge = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxSize( -1,-1 ), wxGA_HORIZONTAL|wxGA_SMOOTH );

ProgressSizer->Add( ProgressGauge, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

AbortButton = new wxButton( this, wxID_ANY, _("&Abort"), wxDefaultPosition, wxDefaultSize, 0 );

AbortButton->Enable( false );

ProgressSizer->Add( AbortButton, 0, wxTOP|wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );

bSizer82->Add( ProgressSizer, 0, wxEXPAND, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer82->Add( InfoStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer81->Add( bSizer82, 0, wxEXPAND, 5 );

this->SetSizer( bSizer81 );

this->Layout();

bSizer81->Fit( this );

// Connect Events

AbortButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

}

{

// Disconnect Events

AbortButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

}

SelectDirectoryWizardPageBase::SelectDirectoryWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

this->SetMinSize( wxSize( 200,65 ) );

wxBoxSizer* bSizer68;

bSizer68 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer69;

bSizer69 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer70;

bSizer70 = new wxBoxSizer( wxHORIZONTAL );

DirectoryTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

bSizer70->Add( DirectoryTextCtrl, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

BrowseButton = new wxButton( this, wxID_ANY, _("&Browse..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer70->Add( BrowseButton, 0, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer69->Add( bSizer70, 0, wxEXPAND, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( 300 );

bSizer69->Add( InfoStaticText, 1, wxALL|wxEXPAND, 5 );

bSizer68->Add( bSizer69, 1, wxEXPAND, 5 );

this->SetSizer( bSizer68 );

this->Layout();

bSizer68->Fit( this );

// Connect Events

DirectoryTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( SelectDirectoryWizardPageBase::OnDirectoryTextChanged ), NULL, this );

BrowseButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SelectDirectoryWizardPageBase::OnBrowseButtonClick ), NULL, this );

// Disconnect Events

DirectoryTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( SelectDirectoryWizardPageBase::OnDirectoryTextChanged ), NULL, this );

BrowseButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SelectDirectoryWizardPageBase::OnBrowseButtonClick ), NULL, this );

}

SingleChoiceWizardPageBase::SingleChoiceWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer71;

bSizer71 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer77;

bSizer77 = new wxBoxSizer( wxVERTICAL );

bSizer77->Add( 0, 0, 0, wxEXPAND|wxTOP, 5 );

OuterChoicesSizer = new wxBoxSizer( wxVERTICAL );

ChoicesSizer = new wxBoxSizer( wxVERTICAL );

OuterChoicesSizer->Add( ChoicesSizer, 0, wxEXPAND, 5 );

bSizer77->Add( OuterChoicesSizer, 0, wxEXPAND, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer77->Add( InfoStaticText, 1, wxALL|wxEXPAND, 5 );

bSizer71->Add( bSizer77, 1, wxEXPAND, 5 );

this->SetSizer( bSizer71 );

this->Layout();

bSizer71->Fit( this );

{

wxBoxSizer* bSizer104;

bSizer104 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer105;

bSizer105 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer31;

sbSizer31 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxEmptyString ), wxVERTICAL );

KeySamplesUpperSizer = new wxBoxSizer( wxVERTICAL );

KeySamplesUpperInnerSizer = new wxBoxSizer( wxVERTICAL );

KeySamplesUpperSizer->Add( KeySamplesUpperInnerSizer, 1, wxEXPAND|wxTOP, 3 );

sbSizer31->Add( KeySamplesUpperSizer, 1, wxEXPAND, 30 );

wxFlexGridSizer* fgSizer5;

fgSizer5 = new wxFlexGridSizer( 3, 2, 0, 0 );

fgSizer5->SetFlexibleDirection( wxBOTH );

fgSizer5->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText25;

m_staticText25 = new wxStaticText( this, wxID_ANY, _("Random Pool:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText25->Wrap( -1 );

fgSizer5->Add( m_staticText25, 0, wxALL|wxALIGN_RIGHT|wxALIGN_BOTTOM, 5 );

wxBoxSizer* bSizer126;

bSizer126 = new wxBoxSizer( wxHORIZONTAL );

RandomPoolSampleStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

RandomPoolSampleStaticText->Wrap( -1 );

RandomPoolSampleStaticText->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier New") ) );

bSizer126->Add( RandomPoolSampleStaticText, 0, wxEXPAND|wxTOP|wxRIGHT|wxALIGN_BOTTOM, 7 );

DisplayKeysCheckBox = new wxCheckBox( this, wxID_ANY, _("Show"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer126->Add( DisplayKeysCheckBox, 0, wxEXPAND|wxRIGHT, 5 );

fgSizer5->Add( bSizer126, 1, wxEXPAND|wxALIGN_BOTTOM, 5 );

wxStaticText* m_staticText28;

m_staticText28 = new wxStaticText( this, wxID_ANY, _("Header Key:"), wxDefaultPosition, wxSize( -1,-1 ), 0 );

m_staticText28->Wrap( -1 );

fgSizer5->Add( m_staticText28, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT|wxALIGN_BOTTOM, 5 );

HeaderKeySampleStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

HeaderKeySampleStaticText->Wrap( -1 );

HeaderKeySampleStaticText->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier New") ) );

fgSizer5->Add( HeaderKeySampleStaticText, 0, wxALIGN_BOTTOM|wxEXPAND|wxTOP|wxRIGHT, 2 );

wxStaticText* m_staticText29;

m_staticText29 = new wxStaticText( this, wxID_ANY, _("Master Key:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText29->Wrap( -1 );

fgSizer5->Add( m_staticText29, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT|wxALIGN_BOTTOM, 5 );

MasterKeySampleStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

MasterKeySampleStaticText->Wrap( -1 );

MasterKeySampleStaticText->SetFont( wxFont( wxNORMAL_FONT->GetPointSize(), 70, 90, 90, false, wxT("Courier New") ) );

fgSizer5->Add( MasterKeySampleStaticText, 0, wxEXPAND|wxALIGN_BOTTOM|wxTOP|wxRIGHT, 2 );

sbSizer31->Add( fgSizer5, 0, wxEXPAND, 5 );

bSizer105->Add( sbSizer31, 0, wxALL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer45;

sbSizer45 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Randomness Collected From Mouse Movements") ), wxVERTICAL );

CollectedEntropy = new wxGauge( this, wxID_ANY, 2560, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

sbSizer45->Add( CollectedEntropy, 0, wxALL|wxEXPAND, 5 );

bSizer105->Add( sbSizer45, 0, wxEXPAND|wxLEFT|wxRIGHT, 5 );

wxStaticBoxSizer* sbSizer32;

sbSizer32 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, wxEmptyString ), wxVERTICAL );

wxBoxSizer* bSizer106;

bSizer106 = new wxBoxSizer( wxHORIZONTAL );

ProgressGauge = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

bSizer106->Add( ProgressGauge, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

AbortButton = new wxButton( this, wxID_ANY, _("Abort"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer106->Add( AbortButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

sbSizer32->Add( bSizer106, 0, wxEXPAND, 5 );

wxGridSizer* gSizer6;

gSizer6 = new wxGridSizer( 1, 3, 0, 0 );

wxBoxSizer* bSizer108;

bSizer108 = new wxBoxSizer( wxHORIZONTAL );

m_staticText31 = new wxStaticText( this, wxID_ANY, _("Done"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText31->Wrap( -1 );

bSizer108->Add( m_staticText31, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

m_panel12 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxSize( -1,-1 ), wxSUNKEN_BORDER );

wxBoxSizer* bSizer115;

bSizer115 = new wxBoxSizer( wxHORIZONTAL );

SizeDoneStaticText = new wxStaticText( m_panel12, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

SizeDoneStaticText->Wrap( -1 );

bSizer115->Add( SizeDoneStaticText, 1, wxALIGN_CENTER_VERTICAL|wxEXPAND|wxALL, 3 );

m_panel12->SetSizer( bSizer115 );

m_panel12->Layout();

bSizer115->Fit( m_panel12 );

bSizer108->Add( m_panel12, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

gSizer6->Add( bSizer108, 1, wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

wxBoxSizer* bSizer1081;

bSizer1081 = new wxBoxSizer( wxHORIZONTAL );

m_staticText311 = new wxStaticText( this, wxID_ANY, _("Speed"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText311->Wrap( -1 );

bSizer1081->Add( m_staticText311, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

m_panel121 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER );

wxBoxSizer* bSizer1151;

bSizer1151 = new wxBoxSizer( wxHORIZONTAL );

SpeedStaticText = new wxStaticText( m_panel121, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

SpeedStaticText->Wrap( -1 );

bSizer1151->Add( SpeedStaticText, 1, wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 3 );

m_panel121->SetSizer( bSizer1151 );

m_panel121->Layout();

bSizer1151->Fit( m_panel121 );

bSizer1081->Add( m_panel121, 1, wxALL|wxEXPAND|wxALIGN_CENTER_VERTICAL, 5 );

gSizer6->Add( bSizer1081, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALIGN_CENTER_HORIZONTAL, 5 );

wxBoxSizer* bSizer1082;

bSizer1082 = new wxBoxSizer( wxHORIZONTAL );

m_staticText312 = new wxStaticText( this, wxID_ANY, _("Left"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText312->Wrap( -1 );

bSizer1082->Add( m_staticText312, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

m_panel122 = new wxPanel( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );

wxBoxSizer* bSizer1152;

bSizer1152 = new wxBoxSizer( wxHORIZONTAL );

TimeLeftStaticText = new wxStaticText( m_panel122, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

TimeLeftStaticText->Wrap( -1 );

bSizer1152->Add( TimeLeftStaticText, 1, wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 3 );

m_panel122->SetSizer( bSizer1152 );

m_panel122->Layout();

bSizer1152->Fit( m_panel122 );

bSizer1082->Add( m_panel122, 1, wxALL|wxEXPAND, 5 );

gSizer6->Add( bSizer1082, 1, wxEXPAND|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );

sbSizer32->Add( gSizer6, 0, wxEXPAND|wxTOP, 2 );

bSizer105->Add( sbSizer32, 0, wxEXPAND|wxBOTTOM|wxRIGHT|wxLEFT, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer105->Add( InfoStaticText, 0, wxBOTTOM|wxLEFT|wxRIGHT, 5 );

bSizer104->Add( bSizer105, 1, wxEXPAND, 5 );

this->SetSizer( bSizer104 );

this->Layout();

bSizer104->Fit( this );

// Connect Events

DisplayKeysCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeCreationProgressWizardPageBase::OnDisplayKeysCheckBoxClick ), NULL, this );

AbortButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeCreationProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

// Disconnect Events

DisplayKeysCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeCreationProgressWizardPageBase::OnDisplayKeysCheckBoxClick ), NULL, this );

AbortButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeCreationProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

}

VolumeLocationWizardPageBase::VolumeLocationWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer86;

bSizer86 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer87;

bSizer87 = new wxBoxSizer( wxVERTICAL );

bSizer87->Add( 0, 0, 0, wxEXPAND|wxTOP, 5 );

wxBoxSizer* bSizer88;

bSizer88 = new wxBoxSizer( wxHORIZONTAL );

wxBoxSizer* bSizer89;

bSizer89 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer126;

bSizer126 = new wxBoxSizer( wxHORIZONTAL );

bSizer126->Add( VolumePathComboBox, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

wxBoxSizer* bSizer90;

bSizer90 = new wxBoxSizer( wxVERTICAL );

SelectFileButton = new wxButton( this, wxID_ANY, _("Select &File..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer90->Add( SelectFileButton, 0, wxALL|wxEXPAND, 5 );

SelectDeviceButton = new wxButton( this, wxID_ANY, _("Select D&evice..."), wxDefaultPosition, wxDefaultSize, 0 );

bSizer90->Add( SelectDeviceButton, 0, wxALL|wxEXPAND, 5 );

bSizer126->Add( bSizer90, 0, wxALIGN_CENTER_VERTICAL, 5 );

bSizer89->Add( bSizer126, 0, wxEXPAND, 5 );

wxBoxSizer* bSizer91;

bSizer91 = new wxBoxSizer( wxHORIZONTAL );

bSizer91->Add( 0, 0, 0, wxLEFT, 5 );

NoHistoryCheckBox = new wxCheckBox( this, wxID_ANY, _("&Never save history"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer91->Add( NoHistoryCheckBox, 0, wxALL|wxEXPAND, 5 );

bSizer89->Add( bSizer91, 0, wxEXPAND, 5 );

bSizer88->Add( bSizer89, 1, wxEXPAND, 5 );

bSizer87->Add( bSizer88, 0, wxEXPAND, 5 );

bSizer87->Add( 0, 0, 0, wxEXPAND|wxBOTTOM, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer87->Add( InfoStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer86->Add( bSizer87, 1, wxEXPAND, 5 );

this->SetSizer( bSizer86 );

this->Layout();

bSizer86->Fit( this );

// Connect Events

VolumePathComboBox->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnVolumePathTextChanged ), NULL, this );

SelectFileButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnSelectFileButtonClick ), NULL, this );

SelectFileButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnSelectFileButtonClick ), NULL, this );

SelectDeviceButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnSelectDeviceButtonClick ), NULL, this );

NoHistoryCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnNoHistoryCheckBoxClick ), NULL, this );

}

VolumeFormatOptionsWizardPageBase::VolumeFormatOptionsWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer124;

bSizer124 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer125;

bSizer125 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer33;

sbSizer33 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Filesystem Options") ), wxVERTICAL );

wxFlexGridSizer* fgSizer6;

fgSizer6 = new wxFlexGridSizer( 2, 2, 0, 0 );

fgSizer6->SetFlexibleDirection( wxBOTH );

fgSizer6->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

m_staticText43 = new wxStaticText( this, wxID_ANY, _("Filesystem type:"), wxDefaultPosition, wxDefaultSize, 0 );

m_staticText43->Wrap( -1 );

fgSizer6->Add( m_staticText43, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxArrayString FilesystemTypeChoiceChoices;

FilesystemTypeChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, FilesystemTypeChoiceChoices, 0 );

FilesystemTypeChoice->SetSelection( 0 );

fgSizer6->Add( FilesystemTypeChoice, 0, wxALL, 5 );

sbSizer33->Add( fgSizer6, 1, wxEXPAND, 5 );

bSizer125->Add( sbSizer33, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer34;

sbSizer34 = new wxStaticBoxSizer( new wxStaticBox( this, wxID_ANY, _("Volume Format Options") ), wxVERTICAL );

QuickFormatCheckBox = new wxCheckBox( this, wxID_ANY, _("Quick format"), wxDefaultPosition, wxDefaultSize, 0 );

sbSizer34->Add( QuickFormatCheckBox, 0, wxALL, 5 );

bSizer125->Add( sbSizer34, 0, wxEXPAND|wxALL, 5 );

bSizer125->Add( 0, 0, 1, wxEXPAND|wxTOP|wxBOTTOM, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer125->Add( InfoStaticText, 0, wxALL, 5 );

bSizer124->Add( bSizer125, 0, wxEXPAND, 5 );

this->SetSizer( bSizer124 );

this->Layout();

bSizer124->Fit( this );

// Connect Events

FilesystemTypeChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( VolumeFormatOptionsWizardPageBase::OnFilesystemTypeSelected ), NULL, this );

QuickFormatCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeFormatOptionsWizardPageBase::OnQuickFormatCheckBoxClick ), NULL, this );

// Disconnect Events

FilesystemTypeChoice->Disconnect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( VolumeFormatOptionsWizardPageBase::OnFilesystemTypeSelected ), NULL, this );

QuickFormatCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeFormatOptionsWizardPageBase::OnQuickFormatCheckBoxClick ), NULL, this );

}

VolumePasswordPanelBase::VolumePasswordPanelBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : wxPanel( parent, id, pos, size, style )

{

wxBoxSizer* bSizer7;

bSizer7 = new wxBoxSizer( wxVERTICAL );

GridBagSizer = new wxGridBagSizer( 0, 0 );

GridBagSizer->SetFlexibleDirection( wxBOTH );

GridBagSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

GridBagSizer->SetEmptyCellSize( wxSize( 0,0 ) );

PasswordStaticText = new wxStaticText( this, wxID_ANY, _("Password:"), wxDefaultPosition, wxDefaultSize, 0 );

PasswordStaticText->Wrap( -1 );

GridBagSizer->Add( PasswordStaticText, wxGBPosition( 1, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxBOTTOM|wxRIGHT, 5 );

PasswordTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );

PasswordTextCtrl->SetMinSize( wxSize( 232,-1 ) );

GridBagSizer->Add( PasswordTextCtrl, wxGBPosition( 1, 1 ), wxGBSpan( 1, 2 ), wxBOTTOM|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

ConfirmPasswordStaticText = new wxStaticText( this, wxID_ANY, _("Confirm password:"), wxDefaultPosition, wxDefaultSize, 0 );

ConfirmPasswordStaticText->Wrap( -1 );

GridBagSizer->Add( ConfirmPasswordStaticText, wxGBPosition( 2, 0 ), wxGBSpan( 1, 1 ), wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT, 5 );

ConfirmPasswordTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );

ConfirmPasswordTextCtrl->SetMinSize( wxSize( 232,-1 ) );

GridBagSizer->Add( ConfirmPasswordTextCtrl, wxGBPosition( 2, 1 ), wxGBSpan( 1, 2 ), wxBOTTOM|wxALIGN_CENTER_VERTICAL|wxEXPAND, 5 );

VolumePimStaticText = new wxStaticText( this, wxID_ANY, _("Volume PIM:"), wxDefaultPosition, wxDefaultSize, 0 );

VolumePimStaticText->Wrap( -1 );

GridBagSizer->Add( VolumePimStaticText, wxGBPosition( 3, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxBOTTOM|wxRIGHT, 5 );

VolumePimTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );

GridBagSizer->Add( VolumePimTextCtrl, wxGBPosition( 3, 1 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxBOTTOM|wxEXPAND, 5 );

VolumePimHelpStaticText = new wxStaticText( this, wxID_ANY, _("(Empty or 0 for default iterations)"), wxDefaultPosition, wxDefaultSize, 0 );

VolumePimHelpStaticText->Wrap( -1 );

GridBagSizer->Add( VolumePimHelpStaticText, wxGBPosition( 3, 2 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxBOTTOM|wxLEFT|wxRIGHT, 5 );

PimCheckBox = new wxCheckBox( this, wxID_ANY, _("Use PIM"), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( PimCheckBox, wxGBPosition( 4, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

CacheCheckBox = new wxCheckBox( this, wxID_ANY, _("Cach&e passwords and keyfiles in memory "), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( CacheCheckBox, wxGBPosition( 5, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

DisplayPasswordCheckBox = new wxCheckBox( this, wxID_ANY, _("&Display password"), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( DisplayPasswordCheckBox, wxGBPosition( 6, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

UseKeyfilesCheckBox = new wxCheckBox( this, wxID_ANY, _("U&se keyfiles"), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( UseKeyfilesCheckBox, wxGBPosition( 7, 1 ), wxGBSpan( 1, 1 ), wxTOP|wxRIGHT|wxLEFT, 5 );

KeyfilesButton = new wxButton( this, wxID_ANY, _("&Keyfiles..."), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( KeyfilesButton, wxGBPosition( 7, 2 ), wxGBSpan( 1, 1 ), wxALIGN_RIGHT|wxALIGN_BOTTOM|wxLEFT, 5 );

Pkcs5PrfSizer = new wxBoxSizer( wxVERTICAL );

GridBagSizer->Add( Pkcs5PrfSizer, wxGBPosition( 8, 1 ), wxGBSpan( 1, 1 ), wxEXPAND|wxTOP|wxBOTTOM, 5 );

Pkcs5PrfStaticText = new wxStaticText( this, wxID_ANY, _("PKCS-5 PRF:"), wxDefaultPosition, wxDefaultSize, 0 );

Pkcs5PrfStaticText->Wrap( -1 );

GridBagSizer->Add( Pkcs5PrfStaticText, wxGBPosition( 9, 0 ), wxGBSpan( 1, 1 ), wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );

wxString Pkcs5PrfChoiceChoices[] = { _("Unchanged") };

int Pkcs5PrfChoiceNChoices = sizeof( Pkcs5PrfChoiceChoices ) / sizeof( wxString );

Pkcs5PrfChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, Pkcs5PrfChoiceNChoices, Pkcs5PrfChoiceChoices, 0 );

Pkcs5PrfChoice->SetSelection( 0 );

GridBagSizer->Add( Pkcs5PrfChoice, wxGBPosition( 9, 1 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );

TrueCryptModeCheckBox = new wxCheckBox( this, wxID_ANY, _("TrueCrypt Mode"), wxDefaultPosition, wxDefaultSize, 0 );

GridBagSizer->Add( TrueCryptModeCheckBox, wxGBPosition( 9, 2 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxLEFT, 5 );

HeaderWipeCountText = new wxStaticText( this, wxID_ANY, _("Header Wipe:"), wxDefaultPosition, wxDefaultSize, 0 );

HeaderWipeCountText->Wrap( -1 );

GridBagSizer->Add( HeaderWipeCountText, wxGBPosition( 10, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxRIGHT, 5 );

wxString HeaderWipeCountChoices[] = { _("1-pass"), _("3-pass"), _("7-pass"), _("35-pass"), _("256-pass") };

int HeaderWipeCountNChoices = sizeof( HeaderWipeCountChoices ) / sizeof( wxString );

HeaderWipeCount = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, HeaderWipeCountNChoices, HeaderWipeCountChoices, 0 );

HeaderWipeCount->SetSelection( 1 );

GridBagSizer->Add( HeaderWipeCount, wxGBPosition( 10, 1 ), wxGBSpan( 1, 1 ), wxALL, 5 );

PasswordPlaceholderSizer = new wxBoxSizer( wxVERTICAL );

GridBagSizer->Add( PasswordPlaceholderSizer, wxGBPosition( 11, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxEXPAND, 5 );

GridBagSizer->AddGrowableCol( 1 );

bSizer7->Add( GridBagSizer, 1, wxALL|wxEXPAND, 5 );

this->SetSizer( bSizer7 );

this->Layout();

bSizer7->Fit( this );

// Connect Events

PasswordTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumePasswordPanelBase::OnTextChanged ), NULL, this );

ConfirmPasswordTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumePasswordPanelBase::OnTextChanged ), NULL, this );

KeyfilesButton->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightDown ), NULL, this );

KeyfilesButton->Disconnect( wxEVT_RIGHT_UP, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightClick ), NULL, this );

TrueCryptModeCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePasswordPanelBase::OnTrueCryptModeChecked ), NULL, this );

}

VolumePasswordWizardPageBase::VolumePasswordWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer101;

bSizer101 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer102;

bSizer102 = new wxBoxSizer( wxVERTICAL );

PasswordPanelSizer = new wxBoxSizer( wxVERTICAL );

bSizer102->Add( PasswordPanelSizer, 0, wxEXPAND, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer102->Add( InfoStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer101->Add( bSizer102, 1, wxEXPAND, 5 );

this->SetSizer( bSizer101 );

this->Layout();

bSizer101->Fit( this );

{

wxBoxSizer* bSizer101;

bSizer101 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer102;

bSizer102 = new wxBoxSizer( wxVERTICAL );

PimPanelSizer = new wxBoxSizer( wxVERTICAL );

PimSizer = new wxBoxSizer( wxHORIZONTAL );

VolumePimStaticText = new wxStaticText( this, wxID_ANY, _("Volume PIM:"), wxDefaultPosition, wxDefaultSize, 0 );

VolumePimStaticText->Wrap( -1 );

PimSizer->Add( VolumePimStaticText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

VolumePimTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );

PimSizer->Add( VolumePimTextCtrl, 0, wxALL, 5 );

VolumePimHelpStaticText = new wxStaticText( this, wxID_ANY, _("(Empty or 0 for default iterations)"), wxDefaultPosition, wxDefaultSize, 0 );

VolumePimHelpStaticText->Wrap( -1 );

PimSizer->Add( VolumePimHelpStaticText, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

PimPanelSizer->Add( PimSizer, 1, wxEXPAND, 5 );

wxBoxSizer* bSizer166;

bSizer166 = new wxBoxSizer( wxHORIZONTAL );

DisplayPimCheckBox = new wxCheckBox( this, wxID_ANY, _("&Display PIM"), wxDefaultPosition, wxDefaultSize, 0 );

bSizer166->Add( DisplayPimCheckBox, 1, wxALL|wxEXPAND, 5 );

PimPanelSizer->Add( bSizer166, 1, wxEXPAND, 5 );

bSizer102->Add( PimPanelSizer, 0, wxEXPAND, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer102->Add( InfoStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer101->Add( bSizer102, 1, wxEXPAND, 5 );

this->SetSizer( bSizer101 );

this->Layout();

bSizer101->Fit( this );

// Connect Events

VolumePimTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumePimWizardPageBase::OnPimChanged ), NULL, this );

DisplayPimCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePimWizardPageBase::OnDisplayPimCheckBoxClick ), NULL, this );

// Disconnect Events

VolumePimTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumePimWizardPageBase::OnPimChanged ), NULL, this );

DisplayPimCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePimWizardPageBase::OnDisplayPimCheckBoxClick ), NULL, this );

}

VolumeSizeWizardPageBase::VolumeSizeWizardPageBase( wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style ) : WizardPage( parent, id, pos, size, style )

{

wxBoxSizer* bSizer98;

bSizer98 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer99;

bSizer99 = new wxBoxSizer( wxVERTICAL );

bSizer99->Add( 0, 0, 0, wxEXPAND|wxTOP|wxBOTTOM, 5 );

wxBoxSizer* bSizer100;

bSizer100 = new wxBoxSizer( wxHORIZONTAL );

VolumeSizeTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

bSizer100->Add( VolumeSizeTextCtrl, 0, wxALL, 5 );

wxArrayString VolumeSizePrefixChoiceChoices;

VolumeSizePrefixChoice = new wxChoice( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, VolumeSizePrefixChoiceChoices, 0 );

VolumeSizePrefixChoice->SetSelection( 0 );

bSizer100->Add( VolumeSizePrefixChoice, 0, wxALL, 5 );

bSizer99->Add( bSizer100, 0, wxEXPAND, 5 );

bSizer99->Add( 0, 0, 0, wxEXPAND|wxTOP|wxBOTTOM, 5 );

FreeSpaceStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

FreeSpaceStaticText->Wrap( -1 );

bSizer99->Add( FreeSpaceStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer99->Add( 0, 0, 0, wxEXPAND|wxTOP|wxBOTTOM, 5 );

InfoStaticText = new wxStaticText( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, 0 );

InfoStaticText->Wrap( -1 );

bSizer99->Add( InfoStaticText, 0, wxALL|wxEXPAND, 5 );

bSizer98->Add( bSizer99, 0, wxEXPAND, 5 );

this->SetSizer( bSizer98 );

this->Layout();

bSizer98->Fit( this );

// Connect Events

VolumeSizeTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizeTextChanged ), NULL, this );

VolumeSizePrefixChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizePrefixSelected ), NULL, this );

// Disconnect Events

VolumeSizeTextCtrl->Disconnect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizeTextChanged ), NULL, this );

VolumeSizePrefixChoice->Disconnect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizePrefixSelected ), NULL, this );

}

WaitDialogBase::WaitDialogBase( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style ) : wxDialog( parent, id, title, pos, size, style )

{

this->SetSizeHints( wxDefaultSize, wxDefaultSize );

wxBoxSizer* bSizer160;

bSizer160 = new wxBoxSizer( wxVERTICAL );

WaitStaticText = new wxStaticText( this, wxID_ANY, _("MyLabel"), wxDefaultPosition, wxDefaultSize, wxALIGN_CENTRE );

WaitStaticText->Wrap( -1 );

bSizer160->Add( WaitStaticText, 0, wxALIGN_CENTER_HORIZONTAL|wxALL|wxEXPAND, 5 );

WaitProgessBar = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

bSizer160->Add( WaitProgessBar, 0, wxALL|wxEXPAND, 5 );

this->SetSizer( bSizer160 );

this->Layout();

bSizer160->Fit( this );

this->Centre( wxBOTH );

// Connect Events

this->Connect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( WaitDialogBase::OnWaitDialogClose ) );

this->Connect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( WaitDialogBase::OnWaitDialogInit ) );

// Disconnect Events

this->Disconnect( wxEVT_CLOSE_WINDOW, wxCloseEventHandler( WaitDialogBase::OnWaitDialogClose ) );

this->Disconnect( wxEVT_INIT_DIALOG, wxInitDialogEventHandler( WaitDialogBase::OnWaitDialogInit ) );

}

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

/// Class MainFrameBase

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

{

private:

protected:

wxMenuBar* MainMenuBar;

wxMenu* VolumesMenu;

wxButton* MountAllDevicesButton;

wxButton* DismountAllButton;

wxButton* ExitButton;

// Virtual event handlers, overide them in your derived class

virtual void OnActivate( wxActivateEvent& event ) { event.Skip(); }

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnSelectDeviceButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnVolumeButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnExitButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

MainFrameBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("VeraCrypt"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxCAPTION|wxCLOSE_BOX|wxMINIMIZE_BOX|wxSYSTEM_MENU|wxTAB_TRAVERSAL );

~MainFrameBase();

};

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

/// Class WizardFrameBase

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

{

private:

protected:

wxBoxSizer* MainSizer;

wxPanel* MainPanel;

wxButton* PreviousButton;

wxButton* NextButton;

wxButton* CancelButton;

// Virtual event handlers, overide them in your derived class

virtual void OnActivate( wxActivateEvent& event ) { event.Skip(); }

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnPreviousButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnNextButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnCancelButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

WizardFrameBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxCAPTION|wxCLOSE_BOX|wxMINIMIZE_BOX|wxSYSTEM_MENU|wxTAB_TRAVERSAL );

~WizardFrameBase();

};

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

/// Class AboutDialogBase

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

{

private:

protected:

wxPanel* m_panel14;

wxStaticBitmap* LogoBitmap;

wxTextCtrl* CreditsTextCtrl;

wxStaticLine* m_staticline4;

wxStaticLine* m_staticline5;

// Virtual event handlers, overide them in your derived class

virtual void OnWebsiteHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

public:

~AboutDialogBase();

};

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

/// Class BenchmarkDialogBase

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

{

private:

protected:

wxChoice* BufferSizeChoice;

wxListCtrl* BenchmarkListCtrl;

wxBoxSizer* RightSizer;

wxButton* BenchmarkButton;

wxStaticText* BenchmarkNoteStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnBenchmarkButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~BenchmarkDialogBase();

};

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

/// Class ChangePasswordDialogBase

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

{

private:

protected:

wxStaticBoxSizer* CurrentSizer;

wxBoxSizer* CurrentPasswordPanelSizer;

wxBoxSizer* NewPasswordPanelSizer;

wxButton* OKButton;

wxButton* CancelButton;

// Virtual event handlers, overide them in your derived class

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~ChangePasswordDialogBase();

};

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

/// Class DeviceSelectionDialogBase

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

{

private:

protected:

wxListCtrl* DeviceListCtrl;

wxStdDialogButtonSizer* StdButtons;

wxButton* StdButtonsOK;

wxButton* StdButtonsCancel;

// Virtual event handlers, overide them in your derived class

virtual void OnListItemActivated( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

public:

~DeviceSelectionDialogBase();

};

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

/// Class EncryptionTestDialogBase

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

{

private:

protected:

wxChoice* EncryptionAlgorithmChoice;

wxCheckBox* XtsModeCheckBox;

wxButton* AutoTestAllButton;

wxButton* ResetButton;

wxButton* CloseButton;

// Virtual event handlers, overide them in your derived class

virtual void OnEncryptionAlgorithmSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnXtsModeCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDecryptButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnAutoTestAllButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnResetButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~EncryptionTestDialogBase();

};

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

/// Class FavoriteVolumesDialogBase

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

{

private:

protected:

wxListCtrl* FavoritesListCtrl;

wxButton* MoveUpButton;

wxButton* RemoveAllButton;

wxButton* OKButton;

wxButton* CancelButton;

// Virtual event handlers, overide them in your derived class

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnRemoveButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRemoveAllButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~FavoriteVolumesDialogBase();

};

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

/// Class KeyfilesDialogBase

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

{

private:

protected:

wxBoxSizer* UpperSizer;

wxBoxSizer* PanelSizer;

wxStaticText* KeyfilesNoteStaticText;

wxHyperlinkCtrl* KeyfilesHyperlink;

wxButton* CreateKeyfileButtton;

// Virtual event handlers, overide them in your derived class

virtual void OnKeyfilesHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

virtual void OnCreateKeyfileButttonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~KeyfilesDialogBase();

};

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

/// Class KeyfileGeneratorDialogBase

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

{

private:

protected:

wxBoxSizer* MainSizer;

wxChoice* HashChoice;

wxTextCtrl* KeyfilesBaseName;

wxPanel* m_panel19;

wxButton* GenerateButton;

// Virtual event handlers, overide them in your derived class

virtual void OnMouseMotion( wxMouseEvent& event ) { event.Skip(); }

virtual void OnHashSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnShowRandomPoolCheckBoxClicked( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRandomSizeCheckBoxClicked( wxCommandEvent& event ) { event.Skip(); }

virtual void OnGenerateButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~KeyfileGeneratorDialogBase();

};

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

/// Class LegalNoticesDialogBase

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

{

private:

protected:

wxTextCtrl* LegalNoticesTextCtrl;

public:

~LegalNoticesDialogBase();

};

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

/// Class MountOptionsDialogBase

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

{

private:

protected:

wxBoxSizer* MainSizer;

wxBoxSizer* PasswordSizer;

wxButton* MountPointButton;

wxStaticText* FilesystemOptionsStaticText;

wxTextCtrl* FilesystemOptionsTextCtrl;

// Virtual event handlers, overide them in your derived class

virtual void OnInitDialog( wxInitDialogEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnProtectionHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

virtual void OnNoFilesystemCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnMountPointButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~MountOptionsDialogBase();

};

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

/// Class NewSecurityTokenKeyfileDialogBase

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

{

private:

protected:

wxChoice* SecurityTokenChoice;

wxTextCtrl* KeyfileNameTextCtrl;

wxStdDialogButtonSizer* StdButtons;

wxButton* StdButtonsOK;

wxButton* StdButtonsCancel;

// Virtual event handlers, overide them in your derived class

virtual void OnKeyfileNameChanged( wxCommandEvent& event ) { event.Skip(); }

public:

~NewSecurityTokenKeyfileDialogBase();

};

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

/// Class PreferencesDialogBase

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

{

private:

protected:

wxNotebook* PreferencesNotebook;

wxPanel* SecurityPage;

wxStdDialogButtonSizer* StdButtons;

wxButton* StdButtonsOK;

wxButton* StdButtonsCancel;

// Virtual event handlers, overide them in your derived class

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnDismountOnScreenSaverCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRemoveHotkeyButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnCancelButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

wxPanel* DefaultMountOptionsPage;

wxPanel* DefaultKeyfilesPage;

wxPanel* SecurityTokensPage;

wxPanel* HotkeysPage;

~PreferencesDialogBase();

};

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

/// Class RandomPoolEnrichmentDialogBase

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

{

private:

protected:

wxBoxSizer* MainSizer;

wxChoice* HashChoice;

wxGauge* CollectedEntropy;

wxStaticText* MouseStaticText;

wxButton* ContinueButton;

// Virtual event handlers, overide them in your derived class

virtual void OnMouseMotion( wxMouseEvent& event ) { event.Skip(); }

virtual void OnHashSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnShowRandomPoolCheckBoxClicked( wxCommandEvent& event ) { event.Skip(); }

public:

~RandomPoolEnrichmentDialogBase();

};

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

/// Class SecurityTokenKeyfilesDialogBase

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

{

private:

protected:

wxListCtrl* SecurityTokenKeyfileListCtrl;

wxButton* ExportButton;

wxButton* ImportButton;

wxButton* OKButton;

wxButton* CancelButton;

// Virtual event handlers, overide them in your derived class

virtual void OnListItemActivated( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnDeleteButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnImportButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~SecurityTokenKeyfilesDialogBase();

};

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

/// Class VolumePropertiesDialogBase

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

{

private:

protected:

wxListCtrl* PropertiesListCtrl;

wxStdDialogButtonSizer* StdButtons;

wxButton* StdButtonsOK;

public:

~VolumePropertiesDialogBase();

};

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

/// Class EncryptionOptionsWizardPageBase

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

class EncryptionOptionsWizardPageBase : public WizardPage

{

private:

protected:

wxChoice* EncryptionAlgorithmChoice;

wxButton* TestButton;

wxButton* BenchmarkButton;

wxChoice* HashChoice;

wxHyperlinkCtrl* HashHyperlink;

// Virtual event handlers, overide them in your derived class

virtual void OnEncryptionAlgorithmSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnTestButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnEncryptionAlgorithmHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

virtual void OnBenchmarkButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnHashHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

public:

~EncryptionOptionsWizardPageBase();

};

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

/// Class InfoWizardPageBase

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

class InfoWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* InfoPageSizer;

wxStaticText* InfoStaticText;

public:

~InfoWizardPageBase();

};

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

/// Class KeyfilesPanelBase

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

{

private:

protected:

wxListCtrl* KeyfilesListCtrl;

wxButton* AddFilesButton;

wxButton* AddSecurityTokenSignatureButton;

wxButton* RemoveButton;

wxButton* RemoveAllButton;

// Virtual event handlers, overide them in your derived class

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnAddSecurityTokenSignatureButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRemoveButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRemoveAllButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~KeyfilesPanelBase();

};

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

/// Class ProgressWizardPageBase

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

class ProgressWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* ProgressSizer;

wxGauge* ProgressGauge;

wxButton* AbortButton;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnAbortButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~ProgressWizardPageBase();

};

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

/// Class SelectDirectoryWizardPageBase

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

class SelectDirectoryWizardPageBase : public WizardPage

{

private:

protected:

wxTextCtrl* DirectoryTextCtrl;

wxButton* BrowseButton;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnDirectoryTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnBrowseButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~SelectDirectoryWizardPageBase();

};

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

/// Class SingleChoiceWizardPageBase

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

class SingleChoiceWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* OuterChoicesSizer;

wxBoxSizer* ChoicesSizer;

wxStaticText* InfoStaticText;

public:

~SingleChoiceWizardPageBase();

};

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

/// Class VolumeCreationProgressWizardPageBase

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

class VolumeCreationProgressWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* KeySamplesUpperSizer;

wxBoxSizer* KeySamplesUpperInnerSizer;

wxPanel* m_panel122;

wxStaticText* TimeLeftStaticText;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnDisplayKeysCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnAbortButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeCreationProgressWizardPageBase();

};

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

/// Class VolumeLocationWizardPageBase

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

class VolumeLocationWizardPageBase : public WizardPage

{

private:

protected:

wxComboBox* VolumePathComboBox;

wxButton* SelectFileButton;

wxButton* SelectDeviceButton;

wxCheckBox* NoHistoryCheckBox;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnVolumePathTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnSelectFileButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnSelectDeviceButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnNoHistoryCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeLocationWizardPageBase();

};

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

/// Class VolumeFormatOptionsWizardPageBase

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

class VolumeFormatOptionsWizardPageBase : public WizardPage

{

private:

protected:

wxStaticText* m_staticText43;

wxChoice* FilesystemTypeChoice;

wxCheckBox* QuickFormatCheckBox;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnFilesystemTypeSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnQuickFormatCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeFormatOptionsWizardPageBase();

};

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

/// Class VolumePasswordPanelBase

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

{

private:

protected:

wxGridBagSizer* GridBagSizer;

wxStaticText* PasswordStaticText;

wxStaticText* HeaderWipeCountText;

wxChoice* HeaderWipeCount;

wxBoxSizer* PasswordPlaceholderSizer;

// Virtual event handlers, overide them in your derived class

virtual void OnTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnPimChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnKeyfilesButtonRightDown( wxMouseEvent& event ) { event.Skip(); }

virtual void OnKeyfilesButtonRightClick( wxMouseEvent& event ) { event.Skip(); }

virtual void OnTrueCryptModeChecked( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumePasswordPanelBase();

};

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

/// Class VolumePasswordWizardPageBase

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

class VolumePasswordWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* PasswordPanelSizer;

wxStaticText* InfoStaticText;

public:

~VolumePasswordWizardPageBase();

};

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

/// Class VolumePimWizardPageBase

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

class VolumePimWizardPageBase : public WizardPage

{

private:

protected:

wxBoxSizer* PimPanelSizer;

wxBoxSizer* PimSizer;

wxStaticText* VolumePimHelpStaticText;

wxCheckBox* DisplayPimCheckBox;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnPimChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDisplayPimCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumePimWizardPageBase();

};

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

/// Class VolumeSizeWizardPageBase

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

class VolumeSizeWizardPageBase : public WizardPage

{

private:

protected:

wxTextCtrl* VolumeSizeTextCtrl;

wxChoice* VolumeSizePrefixChoice;

wxStaticText* FreeSpaceStaticText;

wxStaticText* InfoStaticText;

// Virtual event handlers, overide them in your derived class

virtual void OnVolumeSizeTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnVolumeSizePrefixSelected( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeSizeWizardPageBase();

};

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

/// Class WaitDialogBase

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

{

private:

protected:

wxStaticText* WaitStaticText;

wxGauge* WaitProgessBar;

// Virtual event handlers, overide them in your derived class

virtual void OnWaitDialogClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnWaitDialogInit( wxInitDialogEvent& event ) { event.Skip(); }

public:

~WaitDialogBase();

};

} // namespace VeraCrypt

#endif //__FORMS_H__

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

namespace VeraCrypt

{

{

RandomNumberGenerator::Start();

Hashes = Hash::GetAvailableAlgorithms();

foreach (shared_ptr <Hash> hash, Hashes)

{

HideBytes (RandomPoolStaticText, 24);

MouseStaticText->Wrap (Gui->GetCharWidth (MouseStaticText) * 70);

CollectedEntropy->SetRange (RNG_POOL_SIZE * 8);

MainSizer->SetMinSize (wxSize (-1, Gui->GetCharHeight (this) * 24));

Layout();

Fit();

Center();

MouseEventsCounter = 0;

foreach (wxWindow *c, this->GetChildren())

try

{

int keyfilesCount = NumberOfKeyfiles->GetValue();

bool useRandomSize = RandomSizeCheckBox->IsChecked();

wxString keyfileBaseName = KeyfilesBaseName->GetValue();

keyfileBaseName.Trim(true);

keyfileBaseName.Trim(false);

if (keyfileBaseName.IsEmpty())

{

Gui->ShowWarning("KEYFILE_EMPTY_BASE_NAME");

return;

}

wxFileName baseFileName = wxFileName::FileName (keyfileBaseName);

if (!baseFileName.IsOk())

{

Gui->ShowWarning("KEYFILE_INVALID_BASE_NAME");

return;

}

DirectoryPath keyfilesDir = Gui->SelectDirectory (Gui->GetActiveWindow(), LangString["SELECT_KEYFILE_GENERATION_DIRECTORY"], false);

if (keyfilesDir.IsEmpty())

return;

wxFileName dirFileName = wxFileName::DirName( wstring(keyfilesDir).c_str() );

if (!dirFileName.IsDirWritable ())

{

Gui->ShowWarning(L"You don't have write permission on the selected directory");

return;

}

wxBusyCursor busy;

for (int i = 0; i < keyfilesCount; i++)

{

{

SecureBuffer sizeBuffer (sizeof(int));

RandomNumberGenerator::GetData (sizeBuffer, true);

memcpy(&bufferLen, sizeBuffer.Ptr(), sizeof(int));

/* since keyfilesSize < 1024 * 1024, we mask with 0x000FFFFF */

bufferLen = (long) (((unsigned long) bufferLen) & 0x000FFFFF);

bufferLen %= ((1024*1024 - 64) + 1);

}

else

bufferLen = keyfilesSize;

SecureBuffer keyfileBuffer (bufferLen);

RandomNumberGenerator::GetData (keyfileBuffer, true);

wstringstream convertStream;

convertStream << i;

wxFileName keyfileName;

if (i == 0)

{

keyfileName.Assign(dirFileName.GetPath(), keyfileBaseName + suffix);

}

}

if (keyfileName.Exists())

{

wxString msg = wxString::Format(LangString["KEYFILE_ALREADY_EXISTS"], keyfileName.GetFullPath());

if (!Gui->AskYesNo (msg, false, true))

}

{

ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

else

HideBytes (RandomPoolStaticText, 24);

/* conservative estimate: 1 mouse move event brings 1 bit of entropy

* https://security.stackexchange.com/questions/32844/for-how-much-time-should-i-randomly-move-the-mouse-for-generating-encryption-key/32848#32848

*/

if (MouseEventsCounter < (RNG_POOL_SIZE * 8))

CollectedEntropy->SetValue (++MouseEventsCounter);

}

void KeyfileGeneratorDialog::OnShowRandomPoolCheckBoxClicked (wxCommandEvent& event)

{

if (!event.IsChecked())

str[i] = L'X';

}

}

void KeyfileGeneratorDialog::HideBytes (wxStaticText *textCtrl, size_t len)

{

wxString str;

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

void OnRandomSizeCheckBoxClicked( wxCommandEvent& event );

void ShowBytes (wxStaticText *textCtrl, const ConstBufferPtr &buffer, bool appendDots = true);

void HideBytes (wxStaticText *textCtrl, size_t len);

HashList Hashes;

int MouseEventsCounter;

Mutex AccessMutex;

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Fit();

Center();

}

void KeyfilesDialog::OnCreateKeyfileButttonClick (wxCommandEvent& event)

{

Gui->CreateKeyfile();

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

return keyfiles;

}

void KeyfilesPanel::OnAddDirectoryButtonClick (wxCommandEvent& event)

{

DirectoryPath dir = Gui->SelectDirectory (this, LangString["SELECT_KEYFILE_PATH"]);

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

LegalNoticesTextCtrl->SetMinSize (wxSize (

Gui->GetCharWidth (LegalNoticesTextCtrl) * 88,

Gui->GetCharHeight (LegalNoticesTextCtrl) * 28));

Layout();

Fit();

Center();

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

Copyright (c) 2008-2012 TrueCrypt Developers Association and which is governed

by the TrueCrypt License 3.0.

and all other portions of this file are Copyright (c) 2013-2016 IDRIX

and are governed by the Apache License 2.0 the full text of which is

contained in the file License.txt included in VeraCrypt binary and source

wstring args = StringFormatter (repair ? L"/C echo {0} & chkdsk {1} /F /X & pause" : L"/C echo {0} & chkdsk {1} & pause",

StringFormatter (LangString[repair ? "REPAIRING_FS" : "CHECKING_FS"], mountPoint), mountPoint);

L"runas",

L"cmd.exe", args.c_str(), nullptr, SW_SHOW);

#else

void MainFrame::InitControls ()

{

LogoBitmap->SetBitmap (Resources::GetLogoBitmap());

list <int> colPermilles;

#ifndef TC_WINDOWS

MountAllDevicesButton->SetLabel (_("Mount All Devices"));

#endif

SlotListCtrl->InsertColumn (ColumnSlot, LangString["DRIVE"], wxLIST_FORMAT_LEFT, 1);

colPermilles.push_back (75);

#else

#endif

SlotListCtrl->InsertColumn (ColumnPath, LangString["VOLUME"], wxLIST_FORMAT_LEFT, 1);

colPermilles.push_back (487);

#else

colPermilles.push_back (429);

#endif

SlotListCtrl->InsertColumn (ColumnSize, LangString["SIZE"], wxLIST_FORMAT_RIGHT, 1);

colPermilles.push_back (126);

#else

colPermilles.push_back (130);

#endif

SlotListCtrl->InsertColumn (ColumnEA, LangString["ENCRYPTION_ALGORITHM_LV"], wxLIST_FORMAT_LEFT, 1);

colPermilles.push_back (233);

#else

#ifndef TC_WINDOWS

int screenHeight = wxSystemSettings::GetMetric (wxSYS_SCREEN_Y);

if (screenHeight < 480)

slotListRowCount = 1;

else if (screenHeight <= 600)

SetMaxSize (GetSize());

Gui->SetListCtrlColumnWidths (SlotListCtrl, colPermilles);

UpdateVolumeList();

UpdateWipeCacheButton();

}

{

MainFrame *frame = dynamic_cast <MainFrame *> (Gui->GetMainFrame());

PDEV_BROADCAST_HDR hdr = (PDEV_BROADCAST_HDR) lParam;

if (wParam == DBT_DEVICEREMOVECOMPLETE && hdr->dbch_devicetype == DBT_DEVTYP_VOLUME)

{

PDEV_BROADCAST_VOLUME vol = (PDEV_BROADCAST_VOLUME) lParam;

}

wxMenu *CreatePopupMenu ()

auto_ptr <wxMenu> popup (new wxMenu);

Gui->AppendToMenu (*popup, LangString[Gui->IsInBackgroundMode() ? "SHOW_TC" : "HIDE_TC"], this, wxCommandEventHandler (TaskBarIcon::OnShowHideMenuItemSelected));

popup->AppendSeparator();

Gui->AppendToMenu (*popup, _("Mount All Favorite Volumes"), this, wxCommandEventHandler (TaskBarIcon::OnMountAllFavoritesMenuItemSelected))->Enable (!Busy);

Gui->AppendToMenu (*popup, _("Dismount All Mounted Volumes"), this, wxCommandEventHandler (TaskBarIcon::OnDismountAllMenuItemSelected))->Enable (!Busy);

// Favorite volumes

if (Gui->GetPreferences().BackgroundTaskMenuMountItemsEnabled && !Frame->FavoriteVolumesMenuMap.empty())

{

Gui->SetPreferences (prefs);

NoHistoryCheckBox->SetValue (!prefs.SaveHistory);

}

void MainFrame::MountAllDevices ()

{

try

}

void MainFrame::OnDefaultMountParametersMenuItemSelected(wxCommandEvent& event)

#ifdef TC_MACOSX

if (Gui->IsInBackgroundMode())

Gui->SetBackgroundMode (false);

if (volume->Path.IsDevice() && !Core->IsDevicePresent (volume->Path))

removedVolumes.push_back (volume);

}

if (!removedVolumes.empty())

Gui->AutoDismountVolumes (removedVolumes, true);

}

case Hotkey::Id::MountAllFavorites:

{

size_t mountedCount = Core->GetMountedVolumes().size();

if (event.GetId() == Hotkey::Id::MountAllDevices)

MountAllDevices();

else

if (SelectedItemIndex > itemIndex)

--SelectedItemIndex;

}

void MainFrame::OnListItemDeselected (wxListEvent& event)

{

OnListItemSelectionChanged();