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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

wxFont versionStaticTextFont = VersionStaticText->GetFont();

versionStaticTextFont.SetWeight (wxFONTWEIGHT_BOLD);

VersionStaticText->SetFont (versionStaticTextFont);

CopyrightStaticText->SetLabel (TC_STR_RELEASED_BY);

WebsiteHyperlink->SetLabel (L"www.idrix.fr");

CreditsTextCtrl->SetMinSize (wxSize (

L"Hans Dobbertin, Antoon Bosselaers, Bart Preneel, Jack Lloyd"

L"Paulo Barreto, Brian Gladman, Wei Dai, Peter Gutmann, and many others.\n\n"

L"Portions of this software:\n"

L"Copyright \xA9 2003-2012 TrueCrypt Developers Association. All Rights Reserved.\n"

L"Copyright \xA9 1998-2000 Paul Le Roux. All Rights Reserved.\n"

L"Copyright \xA9 1998-2008 Brian Gladman. All Rights Reserved.\n"

L"Copyright \xA9 2016 Disk Cryptography Services for EFI (DCS), Alex Kolotnikov.\n"

L"Copyright \xA9 2013, Alexey Degtyarev. All rights reserved.\n"

L"\nThis software as a whole:\n"

L"This software uses wxWidgets library, which is copyright \xA9 1998-2011 Julian Smart, Robert Roebling et al.\n\n"

L"An IDRIX Release");

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "System.h"

#include "Volume/EncryptionModeXTS.h"

#include "Main/GraphicUserInterface.h"

#include "BenchmarkDialog.h"

namespace VeraCrypt

{

BufferSizeChoice->Append (Gui->SizeToString (size), (void *) size);

}

BufferSizeChoice->Select (1);

Layout();

Fit();

Center();

}

void BenchmarkDialog::OnBenchmarkButtonClick (wxCommandEvent& event)

{

list <BenchmarkResult> results;

wxBusyCursor busy;

Gui->ExecuteWaitThreadRoutine (this, &routine);

BenchmarkListCtrl->DeleteAllItems();

{

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

fields[ColumnAlgorithm] = result.AlgorithmName;

Gui->AppendToListCtrl (BenchmarkListCtrl, fields);

}

BenchmarkListCtrl->SetColumnWidth(0, wxLIST_AUTOSIZE);

}

{

try

{

{

{

{

time = (uint64) (wxGetLocalTimeMillis().GetValue() - startTime.GetValue());

{

{

}

}

}

}

catch (exception &e)

{

Gui->ShowError (e);

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

{

ColumnAlgorithm = 0,

ColumnEncryption,

ColumnDecryption,

};

struct BenchmarkResult

{

wstring AlgorithmName;

uint64 EncryptionSpeed;

uint64 DecryptionSpeed;

uint64 MeanSpeed;

};

void OnBenchmarkButtonClick (wxCommandEvent& event);

class BenchmarkThreadRoutine : public WaitThreadRoutine

{

public:

BenchmarkDialog* m_pDlg;

list<BenchmarkResult>& m_results;

Buffer& m_buffer;

virtual ~BenchmarkThreadRoutine() { }

};

};

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "WaitDialog.h"

namespace VeraCrypt

{

ChangePasswordDialog::ChangePasswordDialog (wxWindow* parent, shared_ptr <VolumePath> volumePath, Mode::Enum mode, shared_ptr <VolumePassword> password, shared_ptr <KeyfileList> keyfiles, shared_ptr <VolumePassword> newPassword, shared_ptr <KeyfileList> newKeyfiles)

: ChangePasswordDialogBase (parent), DialogMode (mode), Path (volumePath)

{

bool enableNewPassword = false;

bool enableNewKeyfiles = false;

bool enablePkcs5Prf = false;

switch (mode)

{

case Mode::ChangePasswordAndKeyfiles:

enableNewPassword = true;

enableNewKeyfiles = true;

enablePkcs5Prf = true;

break;

case Mode::ChangeKeyfiles:

enableNewKeyfiles = true;

break;

case Mode::RemoveAllKeyfiles:

break;

case Mode::ChangePkcs5Prf:

enablePkcs5Prf = true;

break;

default:

throw ParameterIncorrect (SRC_POS);

}

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

CurrentPasswordPanelSizer->Add (CurrentPasswordPanel, 1, wxALL | wxEXPAND);

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

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

if (mode == Mode::RemoveAllKeyfiles)

return;

try

{

int currentPim = CurrentPasswordPanel->GetVolumePim();

if (-1 == currentPim)

{

CurrentPasswordPanel->SetFocusToPimTextCtrl();

newKeyfiles = CurrentPasswordPanel->GetKeyfiles();

/* force the display of the random enriching interface */

RandomNumberGenerator::SetEnrichedByUserStatus (false);

{

#ifdef TC_UNIX

// Temporarily take ownership of a device if the user is not an administrator

UserId origDeviceOwner ((uid_t) -1);

});

#endif

wxBusyCursor busy;

ChangePasswordThreadRoutine routine(Path, Gui->GetPreferences().DefaultMountOptions.PreserveTimestamps,

Gui->ExecuteWaitThreadRoutine (this, &routine);

}

switch (DialogMode)

{

default:

throw ParameterIncorrect (SRC_POS);

}

EndModal (wxID_OK);

}

catch (UnportablePassword &e)

{

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

};

ChangePasswordDialog (wxWindow* parent, shared_ptr <VolumePath> volumePath, Mode::Enum mode = Mode::ChangePasswordAndKeyfiles, shared_ptr <VolumePassword> password = shared_ptr <VolumePassword> (), shared_ptr <KeyfileList> keyfiles = shared_ptr <KeyfileList> (), shared_ptr <VolumePassword> newPassword = shared_ptr <VolumePassword> (), shared_ptr <KeyfileList> newKeyfiles = shared_ptr <KeyfileList> ());

virtual ~ChangePasswordDialog ();

protected:

void OnOKButtonClick (wxCommandEvent& event);

void OnPasswordPanelUpdate ();

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

DeviceList = Core->GetHostDevices();

foreach_ref (HostDevice &device, DeviceList)

{

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

if (DeviceListCtrl->GetItemCount() > 0)

Gui->AppendToListCtrl (DeviceListCtrl, fields);

#ifdef TC_WINDOWS

fields[ColumnDrive] = device.MountPoint;

fields[ColumnName] = device.Name;

#else

fields[ColumnDevice] = wstring (device.Path) + L":";

fields[ColumnMountPoint] = device.MountPoint;

#endif

Gui->AppendToListCtrl (DeviceListCtrl, fields, 0, &device);

foreach_ref (HostDevice &partition, device.Partitions)

{

fields[ColumnDevice] =

#ifndef TC_WINDOWS

wstring (L" ") +

#endif

Fit();

Layout();

Center();

}

void DeviceSelectionDialog::OnListItemActivated (wxListEvent& event)

{

EndModal (wxID_OK);

}

void DeviceSelectionDialog::OnListItemDeselected (wxListEvent& event)

{

if (DeviceListCtrl->GetSelectedItemCount() == 0)

}

void DeviceSelectionDialog::OnListItemSelected (wxListEvent& event)

{

HostDevice *device = (HostDevice *) (event.GetItem().GetData());

{

SelectedDevice = *device;

}

else

}

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

EncryptionOptionsWizardPage::EncryptionOptionsWizardPage (wxPanel* parent)

: EncryptionOptionsWizardPageBase (parent)

{

EncryptionAlgorithms = EncryptionAlgorithm::GetAvailableAlgorithms();

foreach (shared_ptr <EncryptionAlgorithm> ea, EncryptionAlgorithms)

{

if (!ea->IsDeprecated())

OnEncryptionAlgorithmSelected();

}

shared_ptr <EncryptionAlgorithm> EncryptionOptionsWizardPage::GetEncryptionAlgorithm () const

{

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

}

}

else

EncryptionAlgorithmStaticText->SetLabel (L"");

}

Layout();

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

{

public:

EncryptionOptionsWizardPage (wxPanel* parent);

shared_ptr <EncryptionAlgorithm> GetEncryptionAlgorithm () const;

shared_ptr <Hash> GetHash () const;

bool IsValid () { return true; }

void SetPageText (const wxString &text) { }

void OnEncryptionAlgorithmSelected (wxCommandEvent& event) { OnEncryptionAlgorithmSelected(); }

void OnHashHyperlinkClick (wxHyperlinkEvent& event);

void OnTestButtonClick (wxCommandEvent& event);

EncryptionAlgorithmList EncryptionAlgorithms;

HashList Hashes;

};

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "System.h"

#include "Volume/EncryptionModeXTS.h"

#include "Volume/EncryptionTest.h"

#include "Main/GraphicUserInterface.h"

#include "EncryptionTestDialog.h"

BlockNumberTextCtrl->SetFocus();

throw StringConversionFailed (SRC_POS);

}

shared_ptr <EncryptionMode> xts (new EncryptionModeXTS);

ea->SetMode (xts);

Buffer sector (ENCRYPTION_DATA_UNIT_SIZE);

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

}

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

{

string dataStr = StringConverter::ToSingle (wstring (textCtrl->GetValue()));

for (size_t i = 0; i < dataStr.size() / 2; ++i)

{

textCtrl->SetFocus();

throw StringConversionFailed (SRC_POS);

}

}

if (data.empty())

return;

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

// http://www.wxformbuilder.org/

//

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

#include "System.h"

MainMenuBar = new wxMenuBar( 0 );

VolumesMenu = new wxMenu();

wxMenuItem* CreateNewVolumeMenuItem;

VolumesMenu->Append( CreateNewVolumeMenuItem );

VolumesMenu->AppendSeparator();

VolumesMenu->Append( MountVolumeMenuItem );

wxMenuItem* AutoMountDevicesMenuItem;

VolumesMenu->Append( AutoMountDevicesMenuItem );

VolumesMenu->AppendSeparator();

VolumesMenu->Append( DismountVolumeMenuItem );

VolumesMenu->Append( DismountAllMenuItem );

VolumesMenu->AppendSeparator();

wxMenuItem* ChangePasswordMenuItem;

VolumesMenu->Append( ChangePasswordMenuItem );

wxMenuItem* ChangePkcs5PrfMenuItem;

VolumesMenu->Append( ChangePkcs5PrfMenuItem );

wxMenuItem* ChangeKeyfilesMenuItem;

VolumesMenu->Append( ChangeKeyfilesMenuItem );

wxMenuItem* RemoveKeyfilesMenuItem;

VolumesMenu->Append( RemoveKeyfilesMenuItem );

VolumesMenu->AppendSeparator();

VolumesMenu->Append( VolumePropertiesMenuItem );

FavoritesMenu = new wxMenu();

FavoritesMenu->Append( AddToFavoritesMenuItem );

FavoritesMenu->Append( AddAllMountedToFavoritesMenuItem );

wxMenuItem* OrganizeFavoritesMenuItem;

FavoritesMenu->Append( OrganizeFavoritesMenuItem );

FavoritesMenu->AppendSeparator();

wxMenuItem* MountAllFavoritesMenuItem;

FavoritesMenu->Append( MountAllFavoritesMenuItem );

FavoritesMenu->AppendSeparator();

ToolsMenu = new wxMenu();

wxMenuItem* BenchmarkMenuItem;

ToolsMenu->Append( BenchmarkMenuItem );

wxMenuItem* EncryptionTestMenuItem;

ToolsMenu->Append( EncryptionTestMenuItem );

ToolsMenu->AppendSeparator();

wxMenuItem* VolumeCreationWizardMenuItem;

ToolsMenu->Append( VolumeCreationWizardMenuItem );

ToolsMenu->AppendSeparator();

ToolsMenu->Append( BackupVolumeHeadersMenuItem );

ToolsMenu->Append( RestoreVolumeHeaderMenuItem );

ToolsMenu->AppendSeparator();

wxMenuItem* CreateKeyfileMenuItem;

ToolsMenu->Append( CreateKeyfileMenuItem );

wxMenuItem* ManageSecurityTokenKeyfilesMenuItem;

ToolsMenu->Append( ManageSecurityTokenKeyfilesMenuItem );

wxMenuItem* CloseAllSecurityTokenSessionsMenuItem;

ToolsMenu->Append( CloseAllSecurityTokenSessionsMenuItem );

ToolsMenu->AppendSeparator();

ToolsMenu->Append( WipeCachedPasswordsMenuItem );

SettingsMenu = new wxMenu();

SettingsMenu->Append( HotkeysMenuItem );

wxMenuItem* DefaultKeyfilesMenuItem;

SettingsMenu->Append( DefaultKeyfilesMenuItem );

wxMenuItem* DefaultMountParametersMenuItem;

SettingsMenu->Append( DefaultMountParametersMenuItem );

wxMenuItem* SecurityTokenPreferencesMenuItem;

SettingsMenu->Append( SecurityTokenPreferencesMenuItem );

SettingsMenu->AppendSeparator();

SettingsMenu->Append( PreferencesMenuItem );

HelpMenu = new wxMenu();

wxMenuItem* UserGuideMenuItem;

HelpMenu->Append( UserGuideMenuItem );

wxMenuItem* OnlineHelpMenuItem;

HelpMenu->Append( OnlineHelpMenuItem );

wxMenuItem* BeginnersTutorialMenuItem;

HelpMenu->Append( BeginnersTutorialMenuItem );

wxMenuItem* FaqMenuItem;

HelpMenu->Append( FaqMenuItem );

HelpMenu->AppendSeparator();

wxMenuItem* WebsiteMenuItem;

HelpMenu->Append( WebsiteMenuItem );

wxMenuItem* DownloadsMenuItem;

HelpMenu->Append( DownloadsMenuItem );

wxMenuItem* NewsMenuItem;

HelpMenu->Append( NewsMenuItem );

wxMenuItem* VersionHistoryMenuItem;

HelpMenu->Append( VersionHistoryMenuItem );

HelpMenu->AppendSeparator();

wxMenuItem* DonateMenuItem;

HelpMenu->Append( DonateMenuItem );

wxMenuItem* ContactMenuItem;

HelpMenu->Append( ContactMenuItem );

wxMenuItem* LegalNoticesMenuItem;

HelpMenu->Append( LegalNoticesMenuItem );

wxMenuItem* AboutMenuItem;

HelpMenu->Append( AboutMenuItem );

this->SetMenuBar( MainMenuBar );

wxBoxSizer* bSizer1;

wxStaticBoxSizer* sbSizer1;

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

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

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

wxBoxSizer* bSizer17;

bSizer17 = new wxBoxSizer( wxVERTICAL );

bSizer17->SetMinSize( wxSize( 138,34 ) );

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

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

wxBoxSizer* bSizer18;

bSizer18 = new wxBoxSizer( wxVERTICAL );

bSizer18->SetMinSize( wxSize( 138,34 ) );

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

wxBoxSizer* bSizer19;

bSizer19 = new wxBoxSizer( wxVERTICAL );

bSizer19->SetMinSize( wxSize( 138,34 ) );

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

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

VolumeGridBagSizer = new wxGridBagSizer( 0, 0 );

VolumeGridBagSizer->SetFlexibleDirection( wxBOTH );

VolumeGridBagSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

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 );

bSizer191->SetMinSize( wxSize( 138,34 ) );

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

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

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

wxBoxSizer* bSizer20;

bSizer20 = new wxBoxSizer( wxVERTICAL );

bSizer20->SetMinSize( wxSize( 138,34 ) );

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 );

bSizer21->SetMinSize( wxSize( 138,34 ) );

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

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

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

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

wxGridSizer* gSizer2;

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

wxStaticBoxSizer* sbSizer4;

sbSizer4->SetMinSize( wxSize( 139,-1 ) );

VolumeButton->SetDefault();

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

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

wxStaticBoxSizer* sbSizer41;

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

wxStaticBoxSizer* sbSizer42;

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

wxStaticBoxSizer* sbSizer43;

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

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

// Connect Events

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

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

this->Connect( PreferencesMenuItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnPreferencesMenuItemSelected ) );

this->Connect( UserGuideMenuItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnUserGuideMenuItemSelected ) );

this->Connect( AboutMenuItem->GetId(), wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnAboutMenuItemSelected ) );

SlotListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler( MainFrameBase::OnListItemActivated ), NULL, this );

SlotListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( MainFrameBase::OnListItemDeselected ), NULL, this );

SlotListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, wxListEventHandler( MainFrameBase::OnListItemRightClick ), NULL, this );

SlotListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( MainFrameBase::OnListItemSelected ), NULL, this );

MainFrameBase::~MainFrameBase()

{

// Disconnect Events

this->Disconnect( wxID_PREFERENCES, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnPreferencesMenuItemSelected ) );

this->Disconnect( wxID_HELP, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnUserGuideMenuItemSelected ) );

this->Disconnect( wxID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrameBase::OnAboutMenuItemSelected ) );

SlotListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_ACTIVATED, wxListEventHandler( MainFrameBase::OnListItemActivated ), NULL, this );

SlotListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( MainFrameBase::OnListItemDeselected ), NULL, this );

SlotListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, wxListEventHandler( MainFrameBase::OnListItemRightClick ), NULL, this );

SlotListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( MainFrameBase::OnListItemSelected ), NULL, this );

wxStaticBoxSizer* sbSizer27;

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

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

wxBoxSizer* bSizer66;

bSizer66 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer126;

bSizer126 = new wxBoxSizer( wxHORIZONTAL );

PageTitleStaticText->Wrap( -1 );

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

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

NextButton->SetDefault();

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

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

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

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

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

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

wxButton* OKButton;

OKButton->SetDefault();

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

wxBoxSizer* bSizer154;

bSizer154 = new wxBoxSizer( wxVERTICAL );

wxArrayString BufferSizeChoiceChoices;

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

BufferSizeChoice->SetSelection( 0 );

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 );

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

RightSizer = new wxBoxSizer( wxVERTICAL );

BenchmarkButton->SetDefault();

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

wxButton* CancelButton;

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

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

this->Layout();

bSizer153->Fit( this );

// Connect Events

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

}

BenchmarkDialogBase::~BenchmarkDialogBase()

{

// 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 );

wxBoxSizer* bSizer30;

bSizer30 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer32;

bSizer32 = new wxBoxSizer( wxVERTICAL );

CurrentPasswordPanelSizer = new wxBoxSizer( wxVERTICAL );

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

NewPasswordPanelSizer = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer33;

bSizer33 = new wxBoxSizer( wxVERTICAL );

OKButton->SetDefault();

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

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

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

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 );

wxBoxSizer* bSizer3;

bSizer3 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer4;

bSizer4 = new wxBoxSizer( wxVERTICAL );

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

this->SetSizer( bSizer3 );

this->Layout();

// 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->Connect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( DeviceSelectionDialogBase::OnListItemSelected ), NULL, this );

}

DeviceSelectionDialogBase::~DeviceSelectionDialogBase()

{

// Disconnect Events

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 )

wxBoxSizer* bSizer134;

bSizer134 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText41;

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->SetValue(true);

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

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

wxStaticBoxSizer* sbSizer38;

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

wxBoxSizer* bSizer135;

bSizer135 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText43;

m_staticText43->Wrap( -1 );

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

KeySizeStaticText->Wrap( -1 );

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

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

wxStaticBoxSizer* sbSizer39;

wxStaticText* m_staticText45;

m_staticText45->Wrap( -1 );

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

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

wxStaticText* m_staticText46;

m_staticText46->Wrap( -1 );

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

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

wxStaticText* m_staticText47;

m_staticText47->Wrap( -1 );

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

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

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

wxStaticBoxSizer* sbSizer40;

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

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

wxStaticBoxSizer* sbSizer41;

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

wxBoxSizer* bSizer136;

bSizer136 = new wxBoxSizer( wxHORIZONTAL );

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

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

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

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

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

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

wxBoxSizer* bSizer58;

bSizer58 = new wxBoxSizer( wxVERTICAL );

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

wxGridSizer* gSizer5;

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

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

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

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

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

wxBoxSizer* bSizer59;

bSizer59 = new wxBoxSizer( wxVERTICAL );

OKButton->SetDefault();

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

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

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

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 );

wxBoxSizer* bSizer26;

bSizer26 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer22;

bSizer22 = new wxBoxSizer( wxVERTICAL );

OKButton->SetDefault();

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

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

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

WarningStaticText->Wrap( -1 );

fgSizer2->AddGrowableCol( 0 );

fgSizer2->SetFlexibleDirection( wxBOTH );

fgSizer2->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

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 );

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

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

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

wxStaticText* m_staticText49;

m_staticText49->Wrap( -1 );

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

wxArrayString HashChoiceChoices;

wxBoxSizer* bSizer147;

bSizer147 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText52;

m_staticText52->Wrap( -1 );

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

RandomPoolStaticText->Wrap( -1 );

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

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;

CollectedEntropy->SetValue( 0 );

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

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

MouseStaticText->Wrap( -1 );

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

fgSizer8->AddGrowableCol( 2 );

fgSizer8->SetFlexibleDirection( wxBOTH );

fgSizer8->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

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 );

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

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

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 );

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

m_staticText65->Wrap( -1 );

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

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

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

wxBoxSizer* bSizer146;

bSizer146 = new wxBoxSizer( wxHORIZONTAL );

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

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

wxButton* m_button61;

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

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

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

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

wxButton* OKButton;

OKButton->SetDefault();

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

MountOptionsDialogBase::MountOptionsDialogBase( 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* bSizer19;

wxBoxSizer* bSizer9;

bSizer9 = new wxBoxSizer( wxVERTICAL );

OKButton->SetDefault();

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

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

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

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

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

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

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

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

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

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

ProtectionPasswordSizer = new wxBoxSizer( wxVERTICAL );

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

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

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

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

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

FilesystemSizer = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer28;

wxBoxSizer* bSizer54;

bSizer54 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer55;

bSizer55 = new wxBoxSizer( wxVERTICAL );

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

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

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

MountPointTextCtrlStaticText->Wrap( -1 );

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

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

FilesystemOptionsStaticText->Wrap( -1 );

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

FilesystemOptionsSizer->AddGrowableCol( 1 );

fgSizer7->SetFlexibleDirection( wxBOTH );

fgSizer7->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText47;

m_staticText47->Wrap( -1 );

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

wxArrayString SecurityTokenChoiceChoices;

SecurityTokenChoice->SetSelection( 0 );

wxStaticText* m_staticText48;

m_staticText48->Wrap( -1 );

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

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

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

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

bSizer143->Fit( this );

// Connect Events

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

}

NewSecurityTokenKeyfileDialogBase::~NewSecurityTokenKeyfileDialogBase()

{

// 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 );

bSizer32 = new wxBoxSizer( wxVERTICAL );

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

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

wxBoxSizer* bSizer44;

wxBoxSizer* bSizer33;

bSizer33 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer13;

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

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

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

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

wxBoxSizer* bSizer34;

bSizer34 = new wxBoxSizer( wxHORIZONTAL );

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

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

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

wxStaticText* m_staticText5;

m_staticText5->Wrap( -1 );

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

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

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

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

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

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

wxStaticBoxSizer* sbSizer14;

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

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

bSizer33->Add( sbSizer14, 0, 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->Add( MountReadOnlyCheckBox, 0, wxALL, 5 );

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

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

wxBoxSizer* bSizer163;

bSizer163 = new wxBoxSizer( wxHORIZONTAL );

Pkcs5PrfStaticText->Wrap( -1 );

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

wxArrayString Pkcs5PrfChoiceChoices;

Pkcs5PrfChoice->SetSelection( 0 );

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

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

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->Wrap( -1 );

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

FilesystemSizer->Add( fgSizer3, 1, wxEXPAND, 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->Add( BackgroundTaskEnabledCheckBox, 0, wxALL, 5 );

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

wxStaticBoxSizer* sbSizer26;

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

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

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

sbSizer18->Add( sbSizer26, 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->Add( StartOnLogonCheckBox, 0, wxALL, 5 );

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

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

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

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

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

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

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

bSizer37->Add( KernelServicesSizer, 0, 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;

wxBoxSizer* bSizer158;

bSizer158 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText57;

m_staticText57->Wrap( -1 );

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

AesHwCpuSupportedStaticText->Wrap( -1 );

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

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

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

bSizer152->Add( sbSizer44, 0, wxEXPAND|wxALL, 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;

DefaultKeyfilesSizer = new wxBoxSizer( wxVERTICAL );

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

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;

wxBoxSizer* bSizer129;

bSizer129 = new wxBoxSizer( wxHORIZONTAL );

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

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

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

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

wxStaticBoxSizer* sbSizer37;

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->Add( HotkeyListCtrl, 1, wxALL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer23;

wxFlexGridSizer* fgSizer4;

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

fgSizer4->SetFlexibleDirection( wxBOTH );

fgSizer4->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText10;

m_staticText10->Wrap( -1 );

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

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 );

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

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

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

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

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

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

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

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

wxStaticBoxSizer* sbSizer24;

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

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

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

HotkeysPage->SetSizer( bSizer51 );

HotkeysPage->Layout();

bSizer51->Fit( HotkeysPage );

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 );

DismountOnPowerSavingCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnDismountOnPowerSavingCheckBoxClick ), NULL, this );

ForceAutoDismountCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnForceAutoDismountCheckBoxClick ), NULL, this );

PreserveTimestampsCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnPreserveTimestampsCheckBoxClick ), NULL, this );

HotkeyListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( PreferencesDialogBase::OnHotkeyListItemDeselected ), NULL, this );

HotkeyListCtrl->Connect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( PreferencesDialogBase::OnHotkeyListItemSelected ), NULL, this );

AssignHotkeyButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnAssignHotkeyButtonClick ), NULL, this );

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

}

PreferencesDialogBase::~PreferencesDialogBase()

{

// Disconnect Events

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

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

DismountOnPowerSavingCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnDismountOnPowerSavingCheckBoxClick ), NULL, this );

ForceAutoDismountCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnForceAutoDismountCheckBoxClick ), NULL, this );

PreserveTimestampsCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnPreserveTimestampsCheckBoxClick ), NULL, this );

HotkeyListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_DESELECTED, wxListEventHandler( PreferencesDialogBase::OnHotkeyListItemDeselected ), NULL, this );

HotkeyListCtrl->Disconnect( wxEVT_COMMAND_LIST_ITEM_SELECTED, wxListEventHandler( PreferencesDialogBase::OnHotkeyListItemSelected ), NULL, this );

AssignHotkeyButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnAssignHotkeyButtonClick ), NULL, this );

RemoveHotkeyButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( PreferencesDialogBase::OnRemoveHotkeyButtonClick ), 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 )

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

wxStaticText* m_staticText49;

m_staticText49->Wrap( -1 );

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

wxArrayString HashChoiceChoices;

wxBoxSizer* bSizer147;

bSizer147 = new wxBoxSizer( wxHORIZONTAL );

wxStaticText* m_staticText52;

m_staticText52->Wrap( -1 );

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

RandomPoolStaticText->Wrap( -1 );

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

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;

CollectedEntropy->SetValue( 0 );

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

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

MouseStaticText->Wrap( -1 );

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

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

ContinueButton->SetDefault();

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

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 );

wxBoxSizer* bSizer3;

bSizer3 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer142;

bSizer142 = new wxBoxSizer( wxVERTICAL );

bSizer142->Add( SecurityTokenKeyfileListCtrl, 1, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer141;

bSizer141 = new wxBoxSizer( wxHORIZONTAL );

bSizer141->Add( ExportButton, 0, wxALL, 5 );

bSizer141->Add( DeleteButton, 0, wxALL, 5 );

bSizer141->Add( 0, 0, 1, wxEXPAND|wxLEFT, 5 );

bSizer141->Add( ImportButton, 0, wxALL, 5 );

bSizer142->Add( bSizer141, 0, wxEXPAND, 5 );

wxBoxSizer* bSizer139;

bSizer139 = new wxBoxSizer( wxVERTICAL );

OKButton->SetDefault();

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

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

bSizer138->Add( bSizer139, 0, wxEXPAND, 5 );

wxBoxSizer* bSizer50;

bSizer50 = new wxBoxSizer( wxVERTICAL );

bSizer50->Add( PropertiesListCtrl, 1, wxALL|wxEXPAND, 5 );

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

this->SetSizer( bSizer49 );

this->Layout();

bSizer49->Fit( this );

}

VolumePropertiesDialogBase::~VolumePropertiesDialogBase()

{

}

{

wxBoxSizer* bSizer93;

bSizer93 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer95;

bSizer95 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer29;

wxBoxSizer* bSizer96;

bSizer96 = new wxBoxSizer( wxHORIZONTAL );

wxArrayString EncryptionAlgorithmChoiceChoices;

EncryptionAlgorithmChoice->SetSelection( 0 );

bSizer96->Add( EncryptionAlgorithmChoice, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

sbSizer29->Add( bSizer96, 0, wxEXPAND, 5 );

EncryptionAlgorithmStaticText->Wrap( -1 );

sbSizer29->Add( EncryptionAlgorithmStaticText, 1, wxALL|wxEXPAND, 5 );

wxBoxSizer* bSizer97;

bSizer97 = new wxBoxSizer( wxHORIZONTAL );

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

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

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

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

bSizer97->Add( BenchmarkButton, 0, wxALL, 5 );

sbSizer29->Add( bSizer97, 0, wxEXPAND, 5 );

bSizer95->Add( sbSizer29, 1, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer30;

wxArrayString HashChoiceChoices;

HashChoice->SetSelection( 0 );

sbSizer30->Add( HashChoice, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

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

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

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

HashHyperlink->Disconnect( wxEVT_COMMAND_HYPERLINK, wxHyperlinkEventHandler( EncryptionOptionsWizardPageBase::OnHashHyperlinkClick ), NULL, this );

}

{

wxBoxSizer* bSizer71;

bSizer71 = new wxBoxSizer( wxVERTICAL );

InfoWizardPageBase::~InfoWizardPageBase()

{

}

{

this->SetMinSize( wxSize( 500,300 ) );

wxBoxSizer* bSizer19;

wxBoxSizer* bSizer21;

bSizer21 = new wxBoxSizer( wxVERTICAL );

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

wxBoxSizer* bSizer137;

bSizer137 = new wxBoxSizer( wxHORIZONTAL );

bSizer21->Add( bSizer137, 0, wxEXPAND, 5 );

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

}

{

wxBoxSizer* bSizer81;

bSizer81 = new wxBoxSizer( wxVERTICAL );

ProgressGauge = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxSize( -1,-1 ), wxGA_HORIZONTAL|wxGA_SMOOTH );

ProgressGauge->SetValue( 0 );

ProgressSizer->Add( ProgressGauge, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

AbortButton->Enable( false );

ProgressSizer->Add( AbortButton, 0, wxTOP|wxBOTTOM|wxRIGHT|wxALIGN_CENTER_VERTICAL, 5 );

AbortButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( ProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

}

{

this->SetMinSize( wxSize( 200,65 ) );

wxBoxSizer* bSizer68;

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 );

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

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

BrowseButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( SelectDirectoryWizardPageBase::OnBrowseButtonClick ), NULL, this );

}

{

wxBoxSizer* bSizer71;

bSizer71 = new wxBoxSizer( wxVERTICAL );

SingleChoiceWizardPageBase::~SingleChoiceWizardPageBase()

{

}

{

wxBoxSizer* bSizer104;

bSizer104 = new wxBoxSizer( wxVERTICAL );

fgSizer5->SetFlexibleDirection( wxBOTH );

fgSizer5->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

wxStaticText* m_staticText25;

m_staticText25->Wrap( -1 );

fgSizer5->Add( m_staticText25, 0, wxALL|wxALIGN_RIGHT|wxALIGN_BOTTOM, 5 );

wxBoxSizer* bSizer126;

bSizer126 = new wxBoxSizer( wxHORIZONTAL );

RandomPoolSampleStaticText->Wrap( -1 );

bSizer126->Add( DisplayKeysCheckBox, 0, wxEXPAND|wxRIGHT, 5 );

wxStaticText* m_staticText28;

m_staticText28->Wrap( -1 );

fgSizer5->Add( m_staticText28, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT|wxALIGN_BOTTOM, 5 );

HeaderKeySampleStaticText->Wrap( -1 );

wxStaticText* m_staticText29;

m_staticText29->Wrap( -1 );

fgSizer5->Add( m_staticText29, 0, wxALIGN_RIGHT|wxBOTTOM|wxRIGHT|wxLEFT|wxALIGN_BOTTOM, 5 );

MasterKeySampleStaticText->Wrap( -1 );

sbSizer31->Add( fgSizer5, 0, wxEXPAND, 5 );

bSizer105->Add( sbSizer31, 0, wxALL|wxEXPAND, 5 );

wxStaticBoxSizer* sbSizer45;

CollectedEntropy->SetValue( 0 );

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

wxBoxSizer* bSizer106;

bSizer106 = new wxBoxSizer( wxHORIZONTAL );

bSizer106->Add( ProgressGauge, 1, wxALL|wxALIGN_CENTER_VERTICAL, 5 );

bSizer106->Add( AbortButton, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

sbSizer32->Add( bSizer106, 0, wxEXPAND, 5 );

wxBoxSizer* bSizer108;

bSizer108 = new wxBoxSizer( wxHORIZONTAL );

m_staticText31->Wrap( -1 );

bSizer108->Add( m_staticText31, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxBoxSizer* bSizer115;

bSizer115 = new wxBoxSizer( wxHORIZONTAL );

SizeDoneStaticText = new wxStaticText( m_panel12, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

SizeDoneStaticText->Wrap( -1 );

m_panel12->SetSizer( bSizer115 );

m_panel12->Layout();

bSizer115->Fit( m_panel12 );

wxBoxSizer* bSizer1081;

bSizer1081 = new wxBoxSizer( wxHORIZONTAL );

m_staticText311->Wrap( -1 );

bSizer1081->Add( m_staticText311, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxBoxSizer* bSizer1151;

bSizer1151 = new wxBoxSizer( wxHORIZONTAL );

SpeedStaticText = new wxStaticText( m_panel121, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

SpeedStaticText->Wrap( -1 );

m_panel121->SetSizer( bSizer1151 );

m_panel121->Layout();

bSizer1151->Fit( m_panel121 );

wxBoxSizer* bSizer1082;

bSizer1082 = new wxBoxSizer( wxHORIZONTAL );

m_staticText312->Wrap( -1 );

bSizer1082->Add( m_staticText312, 0, wxALIGN_CENTER_VERTICAL|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxBoxSizer* bSizer1152;

bSizer1152 = new wxBoxSizer( wxHORIZONTAL );

TimeLeftStaticText = new wxStaticText( m_panel122, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxALIGN_RIGHT|wxST_NO_AUTORESIZE );

TimeLeftStaticText->Wrap( -1 );

m_panel122->SetSizer( bSizer1152 );

m_panel122->Layout();

bSizer1152->Fit( m_panel122 );

bSizer1082->Add( m_panel122, 1, wxALL|wxEXPAND, 5 );

sbSizer32->Add( gSizer6, 0, wxEXPAND|wxTOP, 2 );

AbortButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumeCreationProgressWizardPageBase::OnAbortButtonClick ), NULL, this );

}

{

wxBoxSizer* bSizer86;

bSizer86 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer90;

bSizer90 = new wxBoxSizer( wxVERTICAL );

bSizer90->Add( SelectFileButton, 0, wxALL|wxEXPAND, 5 );

bSizer90->Add( SelectDeviceButton, 0, wxALL|wxEXPAND, 5 );

bSizer126->Add( bSizer90, 0, wxALIGN_CENTER_VERTICAL, 5 );

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

bSizer91->Add( NoHistoryCheckBox, 0, wxALL|wxEXPAND, 5 );

bSizer89->Add( bSizer91, 0, wxEXPAND, 5 );

NoHistoryCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeLocationWizardPageBase::OnNoHistoryCheckBoxClick ), NULL, this );

}

{

wxBoxSizer* bSizer124;

bSizer124 = new wxBoxSizer( wxVERTICAL );

wxBoxSizer* bSizer125;

bSizer125 = new wxBoxSizer( wxVERTICAL );

wxStaticBoxSizer* sbSizer33;

wxFlexGridSizer* fgSizer6;

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

fgSizer6->SetFlexibleDirection( wxBOTH );

fgSizer6->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

m_staticText43->Wrap( -1 );

fgSizer6->Add( m_staticText43, 0, wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxTOP|wxBOTTOM|wxLEFT, 5 );

wxArrayString FilesystemTypeChoiceChoices;

FilesystemTypeChoice->SetSelection( 0 );

fgSizer6->Add( FilesystemTypeChoice, 0, wxALL, 5 );

bSizer125->Add( sbSizer33, 0, wxEXPAND|wxALL, 5 );

wxStaticBoxSizer* sbSizer34;

sbSizer34->Add( QuickFormatCheckBox, 0, wxALL, 5 );

bSizer125->Add( sbSizer34, 0, wxEXPAND|wxALL, 5 );

QuickFormatCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumeFormatOptionsWizardPageBase::OnQuickFormatCheckBoxClick ), NULL, this );

}

{

wxBoxSizer* bSizer7;

bSizer7 = new wxBoxSizer( wxVERTICAL );

GridBagSizer->SetFlexibleDirection( wxBOTH );

GridBagSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );

GridBagSizer->SetEmptyCellSize( wxSize( 0,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->SetMaxLength( 1 );

PasswordTextCtrl->SetMinSize( wxSize( 232,-1 ) );

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->SetMaxLength( 1 );

ConfirmPasswordTextCtrl->SetMinSize( wxSize( 232,-1 ) );

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 );

VolumePimTextCtrl->SetMaxLength( 7 );

VolumePimHelpStaticText->Wrap( -1 );

GridBagSizer->Add( VolumePimHelpStaticText, wxGBPosition( 3, 2 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxBOTTOM|wxLEFT|wxRIGHT, 5 );

GridBagSizer->Add( PimCheckBox, wxGBPosition( 4, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

GridBagSizer->Add( CacheCheckBox, wxGBPosition( 5, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

GridBagSizer->Add( DisplayPasswordCheckBox, wxGBPosition( 6, 1 ), wxGBSpan( 1, 2 ), wxTOP|wxBOTTOM|wxLEFT|wxALIGN_CENTER_VERTICAL, 5 );

GridBagSizer->Add( UseKeyfilesCheckBox, wxGBPosition( 7, 1 ), wxGBSpan( 1, 1 ), wxTOP|wxRIGHT|wxLEFT, 5 );

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->Wrap( -1 );

GridBagSizer->Add( Pkcs5PrfStaticText, wxGBPosition( 9, 0 ), wxGBSpan( 1, 1 ), wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );

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 );

HeaderWipeCountText->Wrap( -1 );

GridBagSizer->Add( HeaderWipeCountText, wxGBPosition( 10, 0 ), wxGBSpan( 1, 1 ), wxALIGN_CENTER_VERTICAL|wxALIGN_RIGHT|wxRIGHT, 5 );

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 );

UseKeyfilesCheckBox->Connect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePasswordPanelBase::OnUseKeyfilesCheckBoxClick ), NULL, this );

KeyfilesButton->Connect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonClick ), NULL, this );

KeyfilesButton->Connect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightDown ), NULL, this );

KeyfilesButton->Connect( wxEVT_RIGHT_UP, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightClick ), NULL, this );

}

VolumePasswordPanelBase::~VolumePasswordPanelBase()

{

UseKeyfilesCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePasswordPanelBase::OnUseKeyfilesCheckBoxClick ), NULL, this );

KeyfilesButton->Disconnect( wxEVT_COMMAND_BUTTON_CLICKED, wxCommandEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonClick ), NULL, this );

KeyfilesButton->Disconnect( wxEVT_RIGHT_DOWN, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightDown ), NULL, this );

KeyfilesButton->Disconnect( wxEVT_RIGHT_UP, wxMouseEventHandler( VolumePasswordPanelBase::OnKeyfilesButtonRightClick ), NULL, this );

}

{

wxBoxSizer* bSizer101;

bSizer101 = new wxBoxSizer( wxVERTICAL );

VolumePasswordWizardPageBase::~VolumePasswordWizardPageBase()

{

}

{

wxBoxSizer* bSizer101;

bSizer101 = new wxBoxSizer( wxVERTICAL );

PimPanelSizer = new wxBoxSizer( wxVERTICAL );

PimSizer = new wxBoxSizer( wxHORIZONTAL );

VolumePimStaticText->Wrap( -1 );

PimSizer->Add( VolumePimStaticText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

VolumePimTextCtrl = new wxTextCtrl( this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD );

VolumePimTextCtrl->SetMaxLength( 7 );

PimSizer->Add( VolumePimTextCtrl, 0, wxALL, 5 );

VolumePimHelpStaticText->Wrap( -1 );

PimSizer->Add( VolumePimHelpStaticText, 1, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

wxBoxSizer* bSizer166;

bSizer166 = new wxBoxSizer( wxHORIZONTAL );

bSizer166->Add( DisplayPimCheckBox, 1, wxALL|wxEXPAND, 5 );

PimPanelSizer->Add( bSizer166, 1, wxEXPAND, 5 );

DisplayPimCheckBox->Disconnect( wxEVT_COMMAND_CHECKBOX_CLICKED, wxCommandEventHandler( VolumePimWizardPageBase::OnDisplayPimCheckBoxClick ), NULL, this );

}

{

wxBoxSizer* bSizer98;

bSizer98 = new wxBoxSizer( wxVERTICAL );

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 );

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 );

// Connect Events

VolumeSizeTextCtrl->Connect( wxEVT_COMMAND_TEXT_UPDATED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizeTextChanged ), NULL, this );

VolumeSizePrefixChoice->Connect( wxEVT_COMMAND_CHOICE_SELECTED, wxCommandEventHandler( VolumeSizeWizardPageBase::OnVolumeSizePrefixSelected ), NULL, this );

}

VolumeSizeWizardPageBase::~VolumeSizeWizardPageBase()

{

// 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 )

wxBoxSizer* bSizer160;

bSizer160 = new wxBoxSizer( wxVERTICAL );

WaitStaticText->Wrap( -1 );

WaitProgessBar = new wxGauge( this, wxID_ANY, 100, wxDefaultPosition, wxDefaultSize, wxGA_HORIZONTAL|wxGA_SMOOTH );

WaitProgessBar->SetValue( 0 );

bSizer160->Add( WaitProgessBar, 0, wxALL|wxEXPAND, 5 );

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

// http://www.wxformbuilder.org/

//

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

#include <wx/artprov.h>

#include <wx/xrc/xmlres.h>

#include <wx/intl.h>

#include "WizardPage.h"

#include <wx/string.h>

#include <wx/bitmap.h>

#include <wx/image.h>

#include <wx/dialog.h>

#include <wx/choice.h>

#include <wx/gauge.h>

#include <wx/spinctrl.h>

#include <wx/notebook.h>

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

namespace VeraCrypt

{

wxButton* MountAllDevicesButton;

wxButton* DismountAllButton;

wxButton* ExitButton;

virtual void OnActivate( wxActivateEvent& event ) { event.Skip(); }

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnCreateVolumeButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnMountVolumeMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnCreateKeyfileMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnManageSecurityTokenKeyfilesMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnCloseAllSecurityTokenSessionsMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnWipeCacheButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnHotkeysMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDefaultKeyfilesMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDefaultMountParametersMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnSecurityTokenPreferencesMenuItemSelected( wxCommandEvent& event ) { event.Skip(); }

wxButton* PreviousButton;

wxButton* NextButton;

wxButton* CancelButton;

virtual void OnActivate( wxActivateEvent& event ) { event.Skip(); }

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnMouseMotion( wxMouseEvent& event ) { event.Skip(); }

virtual void OnHelpButtonClick( wxCommandEvent& event ) { event.Skip(); }

wxTextCtrl* CreditsTextCtrl;

wxStaticLine* m_staticline4;

wxStaticLine* m_staticline5;

virtual void OnWebsiteHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

public:

AboutDialogBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE );

~AboutDialogBase();

};

{

private:

protected:

wxChoice* BufferSizeChoice;

wxListCtrl* BenchmarkListCtrl;

wxBoxSizer* RightSizer;

wxButton* BenchmarkButton;

wxStaticText* BenchmarkNoteStaticText;

virtual void OnBenchmarkButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~BenchmarkDialogBase();

};

wxBoxSizer* NewPasswordPanelSizer;

wxButton* OKButton;

wxButton* CancelButton;

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

ChangePasswordDialogBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE );

~ChangePasswordDialogBase();

};

private:

protected:

wxListCtrl* DeviceListCtrl;

virtual void OnListItemActivated( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

public:

~DeviceSelectionDialogBase();

};

wxButton* AutoTestAllButton;

wxButton* ResetButton;

wxButton* CloseButton;

virtual void OnEncryptionAlgorithmSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnXtsModeCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnEncryptButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDecryptButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~EncryptionTestDialogBase();

};

wxButton* RemoveAllButton;

wxButton* OKButton;

wxButton* CancelButton;

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnMoveUpButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnMoveDownButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~FavoriteVolumesDialogBase();

};

wxStaticText* KeyfilesNoteStaticText;

wxHyperlinkCtrl* KeyfilesHyperlink;

wxButton* CreateKeyfileButtton;

virtual void OnKeyfilesHyperlinkClick( wxHyperlinkEvent& event ) { event.Skip(); }

virtual void OnCreateKeyfileButttonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~KeyfilesDialogBase();

};

wxTextCtrl* KeyfilesBaseName;

wxPanel* m_panel19;

wxButton* GenerateButton;

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(); }

public:

KeyfileGeneratorDialogBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = wxEmptyString, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_DIALOG_STYLE );

~KeyfileGeneratorDialogBase();

};

wxTextCtrl* LegalNoticesTextCtrl;

public:

~LegalNoticesDialogBase();

};

wxPanel* OptionsPanel;

wxStaticBoxSizer* OptionsSizer;

wxCheckBox* ReadOnlyCheckBox;

wxCheckBox* RemovableCheckBox;

wxCheckBox* PartitionInSystemEncryptionScopeCheckBox;

wxStaticBoxSizer* ProtectionSizer;

wxCheckBox* ProtectionCheckBox;

wxBoxSizer* ProtectionPasswordSizer;

wxButton* MountPointButton;

wxStaticText* FilesystemOptionsStaticText;

wxTextCtrl* FilesystemOptionsTextCtrl;

virtual void OnInitDialog( wxInitDialogEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnOptionsButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnReadOnlyCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~MountOptionsDialogBase();

};

protected:

wxChoice* SecurityTokenChoice;

wxTextCtrl* KeyfileNameTextCtrl;

virtual void OnKeyfileNameChanged( wxCommandEvent& event ) { event.Skip(); }

public:

~NewSecurityTokenKeyfileDialogBase();

};

{

private:

protected:

wxNotebook* PreferencesNotebook;

wxPanel* SecurityPage;

wxStaticBoxSizer* AutoDismountSizer;

wxCheckBox* DismountOnLogOffCheckBox;

wxCheckBox* WipeCacheOnAutoDismountCheckBox;

wxCheckBox* MountReadOnlyCheckBox;

wxCheckBox* MountRemovableCheckBox;

wxCheckBox* CachePasswordsCheckBox;

wxStaticText* Pkcs5PrfStaticText;

wxChoice* Pkcs5PrfChoice;

wxStaticBoxSizer* FilesystemSizer;

wxTextCtrl* FilesystemOptionsTextCtrl;

wxCheckBox* UseKeyfilesCheckBox;

wxTextCtrl* Pkcs11ModulePathTextCtrl;

wxButton* SelectPkcs11ModuleButton;

wxCheckBox* CloseSecurityTokenSessionsAfterMountCheckBox;

wxListCtrl* HotkeyListCtrl;

wxTextCtrl* HotkeyTextCtrl;

wxButton* AssignHotkeyButton;

wxCheckBox* HotkeyControlCheckBox;

wxCheckBox* HotkeyWinCheckBox;

wxButton* RemoveHotkeyButton;

wxCheckBox* BeepAfterHotkeyMountDismountCheckBox;

wxCheckBox* DisplayMessageAfterHotkeyDismountCheckBox;

virtual void OnClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnDismountOnScreenSaverCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDismountOnPowerSavingCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnForceAutoDismountCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnPreserveTimestampsCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnHotkeyListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnHotkeyListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnAssignHotkeyButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnRemoveHotkeyButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnOKButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

wxPanel* DefaultMountOptionsPage;

wxPanel* DefaultKeyfilesPage;

wxPanel* SecurityTokensPage;

wxPanel* HotkeysPage;

~PreferencesDialogBase();

};

wxGauge* CollectedEntropy;

wxStaticText* MouseStaticText;

wxButton* ContinueButton;

virtual void OnMouseMotion( wxMouseEvent& event ) { event.Skip(); }

virtual void OnHashSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnShowRandomPoolCheckBoxClicked( wxCommandEvent& event ) { event.Skip(); }

public:

~RandomPoolEnrichmentDialogBase();

};

wxButton* ImportButton;

wxButton* OKButton;

wxButton* CancelButton;

virtual void OnListItemActivated( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnExportButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~SecurityTokenKeyfilesDialogBase();

};

private:

protected:

wxListCtrl* PropertiesListCtrl;

public:

~VolumePropertiesDialogBase();

};

wxButton* BenchmarkButton;

wxChoice* HashChoice;

wxHyperlinkCtrl* HashHyperlink;

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(); }

public:

~EncryptionOptionsWizardPageBase();

};

wxStaticText* InfoStaticText;

public:

~InfoWizardPageBase();

};

wxButton* AddSecurityTokenSignatureButton;

wxButton* RemoveButton;

wxButton* RemoveAllButton;

virtual void OnListItemDeselected( wxListEvent& event ) { event.Skip(); }

virtual void OnListItemSelected( wxListEvent& event ) { event.Skip(); }

virtual void OnListSizeChanged( wxSizeEvent& event ) { event.Skip(); }

virtual void OnAddFilesButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~KeyfilesPanelBase();

};

wxGauge* ProgressGauge;

wxButton* AbortButton;

wxStaticText* InfoStaticText;

virtual void OnAbortButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~ProgressWizardPageBase();

};

wxTextCtrl* DirectoryTextCtrl;

wxButton* BrowseButton;

wxStaticText* InfoStaticText;

virtual void OnDirectoryTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnBrowseButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~SelectDirectoryWizardPageBase();

};

wxStaticText* InfoStaticText;

public:

~SingleChoiceWizardPageBase();

};

wxPanel* m_panel122;

wxStaticText* TimeLeftStaticText;

wxStaticText* InfoStaticText;

virtual void OnDisplayKeysCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnAbortButtonClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeCreationProgressWizardPageBase();

};

wxButton* SelectDeviceButton;

wxCheckBox* NoHistoryCheckBox;

wxStaticText* InfoStaticText;

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();

};

wxChoice* FilesystemTypeChoice;

wxCheckBox* QuickFormatCheckBox;

wxStaticText* InfoStaticText;

virtual void OnFilesystemTypeSelected( wxCommandEvent& event ) { event.Skip(); }

virtual void OnQuickFormatCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeFormatOptionsWizardPageBase();

};

wxButton* KeyfilesButton;

wxBoxSizer* Pkcs5PrfSizer;

wxStaticText* Pkcs5PrfStaticText;

wxChoice* Pkcs5PrfChoice;

wxStaticText* HeaderWipeCountText;

wxChoice* HeaderWipeCount;

wxBoxSizer* PasswordPlaceholderSizer;

virtual void OnTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnPimChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnUsePimCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDisplayPasswordCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnUseKeyfilesCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnKeyfilesButtonClick( wxCommandEvent& event ) { event.Skip(); }

virtual void OnKeyfilesButtonRightDown( wxMouseEvent& event ) { event.Skip(); }

virtual void OnKeyfilesButtonRightClick( wxMouseEvent& event ) { event.Skip(); }

public:

~VolumePasswordPanelBase();

};

wxStaticText* InfoStaticText;

public:

~VolumePasswordWizardPageBase();

};

wxStaticText* VolumePimHelpStaticText;

wxCheckBox* DisplayPimCheckBox;

wxStaticText* InfoStaticText;

virtual void OnPimChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnDisplayPimCheckBoxClick( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumePimWizardPageBase();

};

protected:

wxTextCtrl* VolumeSizeTextCtrl;

wxChoice* VolumeSizePrefixChoice;

wxStaticText* FreeSpaceStaticText;

wxStaticText* InfoStaticText;

virtual void OnVolumeSizeTextChanged( wxCommandEvent& event ) { event.Skip(); }

virtual void OnVolumeSizePrefixSelected( wxCommandEvent& event ) { event.Skip(); }

public:

~VolumeSizeWizardPageBase();

};

protected:

wxStaticText* WaitStaticText;

wxGauge* WaitProgessBar;

virtual void OnWaitDialogClose( wxCloseEvent& event ) { event.Skip(); }

virtual void OnWaitDialogInit( wxInitDialogEvent& event ) { event.Skip(); }

public:

WaitDialogBase( wxWindow* parent, wxWindowID id = wxID_ANY, const wxString& title = _("VeraCrypt"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxSize( -1,-1 ), long style = wxCAPTION );

~WaitDialogBase();

};

} // namespace VeraCrypt

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

void KeyfileGeneratorDialog::OnMouseMotion (wxMouseEvent& event)

{

event.Skip();

long coord = event.GetX();

coord = event.GetY();

if (ShowRandomPoolCheckBox->IsChecked())

ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

else

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

};

SetDropTarget (new FileDropTarget (this));

KeyfilesListCtrl->SetDropTarget (new FileDropTarget (this));

foreach (wxWindow *c, GetChildren())

c->SetDropTarget (new FileDropTarget (this));

UpdateButtons();

}

{

SecurityTokenKeyfilesDialog dialog (this);

if (dialog.ShowModal() == wxID_OK)

{

{

vector <wstring> fields;

fields.push_back (path);

Gui->AppendToListCtrl (KeyfilesListCtrl, fields);

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

DEFINE_EVENT_TYPE(wxEVT_COMMAND_OPEN_VOLUME_REQUEST)

DEFINE_EVENT_TYPE(wxEVT_COMMAND_SHOW_WARNING)

MainFrame::MainFrame (wxWindow* parent) : MainFrameBase (parent),

ListItemRightClickEventPending (false),

SelectedItemIndex (-1),

SelectedSlotNumber (0),

ShowRequestFifo (-1)

InitPreferences();

InitTaskBarIcon();

InitEvents();

InitMessageFilter();

if (!GetPreferences().SecurityTokenModule.IsEmpty() && !SecurityToken::IsInitialized())

{

try

Connect( wxID_ANY, wxEVT_COMMAND_UPDATE_VOLUME_LIST, wxCommandEventHandler( MainFrame::OnUpdateVolumeList ) );

Connect( wxID_ANY, wxEVT_COMMAND_PREF_UPDATED, wxCommandEventHandler( MainFrame::OnPreferencesUpdated ) );

Connect( wxID_ANY, wxEVT_COMMAND_OPEN_VOLUME_REQUEST, wxCommandEventHandler( MainFrame::OnOpenVolumeSystemRequest ) );

}

MainFrame::~MainFrame ()

{

Disconnect( wxID_EXIT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler( MainFrame::OnQuit ) );

Disconnect( wxID_ANY, wxEVT_COMMAND_UPDATE_VOLUME_LIST, wxCommandEventHandler( MainFrame::OnUpdateVolumeList ) );

Disconnect( wxID_ANY, wxEVT_COMMAND_PREF_UPDATED, wxCommandEventHandler( MainFrame::OnPreferencesUpdated ) );

Disconnect( wxID_ANY, wxEVT_COMMAND_OPEN_VOLUME_REQUEST, wxCommandEventHandler( MainFrame::OnOpenVolumeSystemRequest ) );

Core->VolumeMountedEvent.Disconnect (this);

Core->VolumeDismountedEvent.Disconnect (this);

Gui->OpenVolumeSystemRequestEvent.Disconnect (this);

Gui->PreferencesUpdatedEvent.Disconnect (this);

L"runas",

L"cmd.exe", args.c_str(), nullptr, SW_SHOW);

#else

# ifdef TC_MACOSX

# endif

Core->CheckFilesystem (selectedVolume, repair);

UpdateVolumeList();

#endif

LowStaticBoxSizer->Detach (HigherButtonSizer);

VolumeStaticBoxSizer->Detach (VolumeGridBagSizer);

VolumeStaticBoxSizer->Add (VolumeGridBagSizer, 1, wxEXPAND, 0);

#endif

#ifdef TC_WINDOWS

SlotListCtrl->InsertColumn (ColumnSlot, LangString["DRIVE"], wxLIST_FORMAT_LEFT, 1);

colPermilles.push_back (75);

#else

colPermilles.push_back (82);

#endif

SlotListCtrl->InsertColumn (ColumnPath, LangString["VOLUME"], wxLIST_FORMAT_LEFT, 1);

MainFrame *Frame;

};

SetDropTarget (new FileDropTarget (this));

foreach (wxWindow *c, MainPanel->GetChildren())

c->SetDropTarget (new FileDropTarget (this));

// Volume history

VolumeHistory::ConnectComboBox (VolumePathComboBox);

SetWindowLongPtr (mainFrameHwnd, GWL_WNDPROC, (LONG_PTR) MainFrameWndProcFilter);

#endif

}

void MainFrame::InitPreferences ()

{

try

{

}

catch (exception &e)

{

Gui->ShowError (e);

}

}

void MainFrame::InitTaskBarIcon ()

}

wxMenu *CreatePopupMenu ()

{

Gui->AppendToMenu (*popup, LangString[Gui->IsInBackgroundMode() ? "SHOW_TC" : "HIDE_TC"], this, wxCommandEventHandler (TaskBarIcon::OnShowHideMenuItemSelected));

popup->AppendSeparator();

// Favorite volumes

if (Gui->GetPreferences().BackgroundTaskMenuMountItemsEnabled && !Frame->FavoriteVolumesMenuMap.empty())

{

popup->AppendSeparator();

typedef pair <int, FavoriteVolume> FavMapPair;

foreach (FavMapPair fp, Frame->FavoriteVolumesMenuMap)

{

this, wxCommandEventHandler (TaskBarIcon::OnFavoriteVolumeMenuItemSelected), fp.first)->Enable (!Busy);

}

}

}

}

popup->AppendSeparator();

#ifndef TC_MACOSX

popup->AppendSeparator();

#endif

return popup.release();

}

{

try

{

MountOptions mountOptions (GetPreferences().DefaultMountOptions);

if (CmdLine->ArgHash)

{

}

if (CmdLine->ArgPim > 0)

{

mountOptions.Pim = CmdLine->ArgPim;

{

try

{

MountOptions mountOptions (GetPreferences().DefaultMountOptions);

if (CmdLine->ArgHash)

{

}

if (CmdLine->ArgPim > 0)

{

mountOptions.Pim = CmdLine->ArgPim;

}

Gui->MountAllFavoriteVolumes (mountOptions);

}

catch (exception &e)

{

void MainFrame::MountVolume ()

{

if (!IsFreeSlotSelected())

{

return;

}

if (!CheckVolumePathNotEmpty())

MountOptions mountOptions (GetPreferences().DefaultMountOptions);

mountOptions.SlotNumber = SelectedSlotNumber;

mountOptions.Path = GetSelectedVolumePath();

if (CmdLine->ArgHash)

{

}

if (CmdLine->ArgPim > 0)

{

mountOptions.Pim = CmdLine->ArgPim;

}

try

{

if (Gui->MountVolume (mountOptions) && GetPreferences().SaveHistory)

{

#ifdef TC_MACOSX

if (Gui->IsInBackgroundMode())

Gui->SetBackgroundMode (false);

#endif

AboutDialog dialog (this);

dialog.ShowModal();

}

#ifdef TC_MACOSX

if (event.GetActive() && Gui->IsInBackgroundMode())

Gui->SetBackgroundMode (false);

#endif

event.Skip();

}

{

SetVolumePath (favorite.Path);

MountOptions mountOptions (GetPreferences().DefaultMountOptions);

if (CmdLine->ArgHash)

{

}

if (CmdLine->ArgPim > 0)

{

mountOptions.Pim = CmdLine->ArgPim;

dialog.SelectPage (dialog.HotkeysPage);

dialog.ShowModal();

}

void MainFrame::OnLegalNoticesMenuItemSelected (wxCommandEvent& event)

{

#ifdef TC_MACOSX

if (Gui->IsInBackgroundMode())

if (IsMountedSlotSelected())

{

Gui->AppendToMenu (popup, LangString["DISMOUNT"], this, wxCommandEventHandler (MainFrame::OnDismountVolumeMenuItemSelected));

Gui->AppendToMenu (popup, LangString["OPEN"], this, wxCommandEventHandler (MainFrame::OnOpenVolumeMenuItemSelected));

popup.AppendSeparator();

popup.AppendSeparator();

Gui->AppendToMenu (popup, LangString["IDPM_CHECK_FILESYS"], this, wxCommandEventHandler (MainFrame::OnCheckFilesystemMenuItemSelected));

Gui->AppendToMenu (popup, LangString["IDPM_REPAIR_FILESYS"], this, wxCommandEventHandler (MainFrame::OnRepairFilesystemMenuItemSelected));

PopupMenu (&popup);

}

else if (IsFreeSlotSelected())

{

popup.AppendSeparator();

Gui->AppendToMenu (popup, LangString["SELECT_FILE_AND_MOUNT"], this, wxCommandEventHandler (MainFrame::OnSelectFileAndMountMenuItemSelected));

Gui->AppendToMenu (popup, LangString["SELECT_DEVICE_AND_MOUNT"], this, wxCommandEventHandler (MainFrame::OnSelectDeviceAndMountMenuItemSelected));

popup.AppendSeparator();

PopupMenu (&popup);

}

}

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

try

{

if (read (ShowRequestFifo, buf, sizeof (buf)) > 0 && Gui->IsInBackgroundMode())

Gui->SetBackgroundMode (false);

}

catch (...)

return;

wxMenu popup;

popup.AppendSeparator ();

popup.AppendSeparator ();

popup.AppendSeparator ();

PopupMenu (&popup, VolumeToolsButton->GetPosition().x + 2, VolumeToolsButton->GetPosition().y + 2);

}

Gui->ShowError (e);

}

}

void MainFrame::ShowTaskBarIcon (bool show)

{

if (!show && mTaskBarIcon->IsIconInstalled())

{

}

else if (show && !mTaskBarIcon->IsIconInstalled())

{

#ifndef TC_MACOSX

mTaskBarIcon->SetIcon (Resources::GetVeraCryptIcon(), L"VeraCrypt");

#endif

}

}

long MainFrame::SlotNumberToItemIndex (uint32 slotNumber) const

void MainFrame::UpdateControls ()

{

bool mounted = IsMountedSlotSelected();

VolumePropertiesButton->Enable (mounted);

DismountVolumeMenuItem->Enable (mounted);

MountVolumeMenuItem->Enable (!mounted);

fields[ColumnMountPoint] = volume->MountPoint;

#endif

fields[ColumnPath] = volume->Path;

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

if (volume->HiddenVolumeProtectionTriggered)

{

fields[ColumnType] += L"(!)";

bool slotUpdated = false;

if (itemIndex == -1)

{

OnListItemInserted (prevItemIndex);

listChanged |= true;

slotUpdated = true;

#endif

{

if (itemIndex == -1)

{

OnListItemInserted (prevItemIndex);

listChanged |= true;

}

else

{

Core->WipePasswordCache();

UpdateWipeCacheButton();

}

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#ifndef TC_HEADER_Main_Forms_MainFrame

#define TC_HEADER_Main_Forms_MainFrame

#include "Forms.h"

#include "ChangePasswordDialog.h"

namespace VeraCrypt

{

struct FavoriteVolume;

#ifdef TC_UNIX

static FilePath GetShowRequestFifoPath () { return Application::GetConfigFilePath (L".show-request-queue", true); }

#endif

protected:

enum

{

ColumnSlot = 0,

void InitEvents ();

void InitMessageFilter ();

void InitPreferences ();

void InitTaskBarIcon ();

bool IsFreeSlotSelected () const { return SlotListCtrl->GetSelectedItemCount() == 1 && Gui->GetListCtrlSubItemText (SlotListCtrl, SelectedItemIndex, ColumnPath).empty(); }

bool IsMountedSlotSelected () const { return SlotListCtrl->GetSelectedItemCount() == 1 && !Gui->GetListCtrlSubItemText (SlotListCtrl, SelectedItemIndex, ColumnPath).empty(); }

void LoadFavoriteVolumes ();

void LoadPreferences ();

void MountAllDevices ();

void MountVolume ();

void OnAboutMenuItemSelected (wxCommandEvent& event);

void OnQuit(wxCommandEvent& event) { Close(true); }

void OnActivate (wxActivateEvent& event);

void OnFaqMenuItemSelected (wxCommandEvent& event) { Gui->OpenHomepageLink (this, L"faq"); }

void OnHiddenVolumeProtectionTriggered (shared_ptr <VolumeInfo> protectedVolume);

void OnHotkey (wxKeyEvent& event);

void OnHotkeysMenuItemSelected (wxCommandEvent& event);

void OnLegalNoticesMenuItemSelected (wxCommandEvent& event);

void OnListChanged ();

void OnListItemActivated (wxListEvent& event);

void OnListItemDeleted (long itemIndex);

void UpdateVolumeList ();

void UpdateWipeCacheButton ();

void WipeCache ();

struct VolumeActivityMapEntry

{

VolumeActivityMapEntry () { }

map <int, FavoriteVolume> FavoriteVolumesMenuMap;

bool ListItemRightClickEventPending;

VolumeInfoList MountedVolumes;

long SelectedItemIndex;

VolumeSlotNumber SelectedSlotNumber;

int ShowRequestFifo;

map <wstring, VolumeActivityMapEntry> VolumeActivityMap;

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "MountOptionsDialog.h"

namespace VeraCrypt

{

MountOptionsDialog::MountOptionsDialog (wxWindow *parent, MountOptions &options, const wxString &title, bool disableMountOptions)

: MountOptionsDialogBase (parent, wxID_ANY, wxString()

#ifdef __WXGTK__ // GTK apparently needs wxRESIZE_BORDER to support dynamic resizing

, wxDefaultPosition, wxSize (-1,-1), wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER

this->SetTitle (LangString["ENTER_TC_VOL_PASSWORD"]);

if (disableMountOptions)

OptionsButton->Show (false);

PasswordPanel->SetCacheCheckBoxValidator (wxGenericValidator (&Options.CachePassword));

PasswordSizer->Add (PasswordPanel, 1, wxALL | wxEXPAND);

#ifdef __WXGTK__

FilesystemOptionsTextCtrl->SetValue (Options.FilesystemOptions);

ReadOnlyCheckBox->SetValue (Options.Protection == VolumeProtection::ReadOnly);

ProtectionCheckBox->SetValue (Options.Protection == VolumeProtection::HiddenVolumeReadOnly);

OptionsButtonLabel = OptionsButton->GetLabel();

OptionsButton->SetLabel (OptionsButtonLabel + L" >");

OptionsPanel->Show (false);

ProtectionPasswordSizer->Add (ProtectionPasswordPanel, 1, wxALL | wxEXPAND);

UpdateDialog();

Center();

}

void MountOptionsDialog::OnOKButtonClick (wxCommandEvent& event)

{

/* verify that PIM values are valid before continuing*/

int Pim = PasswordPanel->GetVolumePim();

int ProtectionPim = (!ReadOnlyCheckBox->IsChecked() && ProtectionCheckBox->IsChecked())?

ProtectionPasswordPanel->GetVolumePim() : 0;

TransferDataFromWindow();

try

{

}

catch (PasswordException& e)

{

Gui->ShowWarning (e);

return;

}

{

return;

}

Options.Keyfiles = PasswordPanel->GetKeyfiles();

if (ReadOnlyCheckBox->IsChecked())

{

else if (ProtectionCheckBox->IsChecked())

{

try

{

}

catch (PasswordException& e)

{

Gui->ShowWarning (e);

return;

}

Options.Protection = VolumeProtection::HiddenVolumeReadOnly;

Options.ProtectionPim = ProtectionPim;

Options.ProtectionKeyfiles = ProtectionPasswordPanel->GetKeyfiles();

}

else

{

if (!mountPoint.empty())

Options.MountPoint = make_shared <DirectoryPath> (mountPoint);

Options.FilesystemOptions = FilesystemOptionsTextCtrl->GetValue();

EndModal (wxID_OK);

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

{

public:

MountOptionsDialog (wxWindow* parent, MountOptions &options, const wxString &title = wxEmptyString, bool disableMountOptions = false);

void OnShow ();

protected:

void OnInitDialog (wxInitDialogEvent& event);

void OnMountPointButtonClick (wxCommandEvent& event);

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

}

void NewSecurityTokenKeyfileDialog::OnKeyfileNameChanged (wxCommandEvent& event)

{

event.Skip();

}

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "System.h"

#include <wx/dynlib.h>

#ifdef TC_WINDOWS

#include <wx/msw/registry.h>

#endif

#include "Common/SecurityToken.h"

#include "Main/Main.h"

#include "Main/Application.h"

MountRemovableCheckBox->SetValidator (wxGenericValidator (&Preferences.DefaultMountOptions.Removable));

FilesystemOptionsTextCtrl->SetValue (Preferences.DefaultMountOptions.FilesystemOptions);

int index, prfInitialIndex = 0;

Pkcs5PrfChoice->Append (LangString["AUTODETECTION"]);

{

index = Pkcs5PrfChoice->Append (kdf.GetName());

if (Preferences.DefaultMountOptions.Kdf

&& (Preferences.DefaultMountOptions.Kdf->GetName() == kdf.GetName())

}

}

Pkcs5PrfChoice->Select (prfInitialIndex);

// Keyfiles

TC_CHECK_BOX_VALIDATOR (UseKeyfiles);

DefaultKeyfilesPanel = new KeyfilesPanel (DefaultKeyfilesPage, make_shared <KeyfileList> (Preferences.DefaultKeyfiles));

// Encryption

AesHwCpuSupportedStaticText->SetLabel (

#ifdef TC_AES_HW_CPU

#else

LangString["NOT_APPLICABLE_OR_NOT_AVAILABLE"]);

#endif

NoHardwareCryptoCheckBox->SetValidator (wxGenericValidator (&Preferences.DefaultMountOptions.NoHardwareCrypto));

// Security tokens

Pkcs11ModulePathTextCtrl->SetValue (wstring (Preferences.SecurityTokenModule));

TC_CHECK_BOX_VALIDATOR (CloseSecurityTokenSessionsAfterMount);

// System integration

TC_CHECK_BOX_VALIDATOR (StartOnLogon);

TC_CHECK_BOX_VALIDATOR (MountDevicesOnLogon);

#endif

#ifdef TC_MACOSX

DismountOnScreenSaverCheckBox->Show (false);

MountRemovableCheckBox->Show (false);

FilesystemSizer->Show (false);

LogOnSizer->Show (false);

Layout();

Fit();

Center();

#ifdef TC_WINDOWS

// Hotkey timer

class Timer : public wxTimer

PreferencesNotebook->ChangeSelection (pageIndex);

}

}

void PreferencesDialog::OnAssignHotkeyButtonClick (wxCommandEvent& event)

{

#ifdef TC_WINDOWS

foreach (long item, Gui->GetListCtrlSelectedItems (HotkeyListCtrl))

{

if (Gui->AskYesNo (LangString["CONFIRM_SETTING_DEGRADES_PERFORMANCE"], true, true))

{

#ifdef TC_LINUX

#endif

}

else

NoHardwareCryptoCheckBox->SetValue (false);

}

}

void PreferencesDialog::OnNoKernelCryptoCheckBoxClick (wxCommandEvent& event)

{

if (event.IsChecked())

}

void PreferencesDialog::OnClose (wxCloseEvent& event)

{

HotkeyTextCtrl->ChangeValue (LangString ["PRESS_A_KEY_TO_ASSIGN"]);

AssignHotkeyButton->Enable (false);

}

void PreferencesDialog::OnOKButtonClick (wxCommandEvent& event)

{

#ifdef TC_WINDOWS

HotkeyTextCtrl->SetValidator (wxTextValidator (wxFILTER_NONE));

if (Pkcs5PrfChoice->GetSelection () != 0)

{

try

{

}

catch (ParameterIncorrect&)

{

return;

}

}

bool securityTokenModuleChanged = (Preferences.SecurityTokenModule != wstring (Pkcs11ModulePathTextCtrl->GetValue()));

Preferences.SecurityTokenModule = wstring (Pkcs11ModulePathTextCtrl->GetValue());

Gui->SetPreferences (Preferences);

try

{

void PreferencesDialog::OnPreserveTimestampsCheckBoxClick (wxCommandEvent& event)

{

#ifdef TC_LINUX

if (!event.IsChecked())

#endif

}

void PreferencesDialog::OnRemoveHotkeyButtonClick (wxCommandEvent& event)

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

void OnHotkeyListItemSelected (wxListEvent& event);

void OnNoHardwareCryptoCheckBoxClick (wxCommandEvent& event);

void OnNoKernelCryptoCheckBoxClick (wxCommandEvent& event);

void OnOKButtonClick (wxCommandEvent& event);

void OnPreserveTimestampsCheckBoxClick (wxCommandEvent& event);

void OnRemoveHotkeyButtonClick (wxCommandEvent& event);

void OnSelectPkcs11ModuleButtonClick (wxCommandEvent& event);

void OnTimer ();

void UpdateHotkeyButtons();

enum

};

KeyfilesPanel *DefaultKeyfilesPanel;

int LastVirtualKeyPressed;

UserPreferences Preferences;

bool RestoreValidatorBell;

HotkeyList UnregisteredHotkeys;

};

}

#endif // TC_HEADER_Main_Forms_PreferencesDialog

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

protected:

void OnAbortButtonClick (wxCommandEvent& event);

void OnTimer ();

int PreviousGaugeValue;

uint64 ProgressBarRange;

int RealProgressBarRange;

};

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

void RandomPoolEnrichmentDialog::OnMouseMotion (wxMouseEvent& event)

{

event.Skip();

long coord = event.GetX();

coord = event.GetY();

if (ShowRandomPoolCheckBox->IsChecked())

ShowBytes (RandomPoolStaticText, RandomNumberGenerator::PeekPool().GetRange (0, 24));

else

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#include "System.h"

#include "Main/GraphicUserInterface.h"

#include "NewSecurityTokenKeyfileDialog.h"

#include "SecurityTokenKeyfilesDialog.h"

namespace VeraCrypt

{

wxBusyCursor busy;

SecurityTokenKeyfileListCtrl->DeleteAllItems();

{

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

}

}

void SecurityTokenKeyfilesDialog::OnDeleteButtonClick (wxCommandEvent& event)

try

{

foreach (long item, Gui->GetListCtrlSelectedItems (SecurityTokenKeyfileListCtrl))

{

FilePathList files = Gui->SelectFiles (this, wxEmptyString, true);

if (!files.empty())

{

wxBusyCursor busy;

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

finally_do_arg (BufferPtr, keyfileDataBuf, { finally_arg.Erase(); });

keyfile.Open (keyfilePath, File::OpenRead, File::ShareReadWrite, File::PreserveTimestamps);

if (keyfile.Length() > 0)

{

BufferPtr keyfileDataBuf (&keyfileData.front(), keyfileData.size());

keyfile.ReadCompleteBuffer (keyfileDataBuf);

finally_do_arg (BufferPtr, keyfileDataBuf, { finally_arg.Erase(); });

OKButton->Disable();

}

}

{

if (event.GetItem().GetData() != (wxUIntPtr) nullptr)

{

ExportButton->Enable();

OKButton->Enable();

}

}

void SecurityTokenKeyfilesDialog::OnOKButtonClick ()

{

foreach (long item, Gui->GetListCtrlSelectedItems (SecurityTokenKeyfileListCtrl))

{

EndModal (wxID_OK);

}

}

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

#ifndef TC_HEADER_Main_Forms_SecurityTokenKeyfilesDialog

#define TC_HEADER_Main_Forms_SecurityTokenKeyfilesDialog

#include "Forms.h"

#include "Common/SecurityToken.h"

#include "Main/Main.h"

namespace VeraCrypt

{

class SecurityTokenKeyfilesDialog : public SecurityTokenKeyfilesDialogBase

{

public:

SecurityTokenKeyfilesDialog (wxWindow* parent, bool selectionMode = true);

protected:

enum

{

void OnListItemSelected (wxListEvent& event);

void OnOKButtonClick ();

void OnOKButtonClick (wxCommandEvent& event) { OnOKButtonClick(); }

};

}

#endif // TC_HEADER_Main_Forms_SecurityTokenKeyfilesDialog

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

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

by the TrueCrypt License 3.0.

Modifications and additions to the original source code (contained in this file)

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

code distribution packages.

*/

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>

<wxFormBuilder_Project>

<object class="Project" expanded="1">

<property name="code_generation">C++</property>

<property name="disconnect_events">1</property>

<property name="disconnect_mode">source_name</property>

<property name="disconnect_php_events">0</property>

<property name="event_generation">connect</property>

<property name="file">Forms</property>

<property name="first_id">1000</property>

<property name="help_provider">none</property>

<property name="internationalize">1</property>

<property name="name">VeraCrypt</property>

<property name="namespace">&quot;VeraCrypt&quot;</property>

<property name="path">.</property>

<property name="skip_lua_events">1</property>

<property name="skip_php_events">1</property>

<property name="skip_python_events">1</property>

<property name="ui_table">UI</property>

<property name="use_enum">1</property>

<property name="use_microsoft_bom">0</property>

<object class="Frame" expanded="0">

<property name="aui_managed">0</property>

<property name="style">wxCAPTION|wxCLOSE_BOX|wxMINIMIZE_BOX|wxSYSTEM_MENU</property>

<property name="subclass"></property>

<property name="title">VeraCrypt</property>

<property name="tooltip"></property>

<property name="window_extra_style"></property>

<property name="window_name"></property>

<property name="window_style">wxTAB_TRAVERSAL</property>

<property name="xrc_skip_sizer">1</property>

<event name="OnActivate">OnActivate</event>

<event name="OnClose">OnClose</event>

<property name="bg"></property>

<property name="context_help"></property>

<property name="context_menu">1</property>

<property name="enabled">1</property>

<property name="fg"></property>

<property name="font"></property>

<property name="hidden">0</property>

<property name="id">wxID_ANY</property>

<property name="maximum_size"></property>

<property name="minimum_size"></property>

<property name="name">MainMenuBar</property>

<property name="permission">protected</property>

<property name="tooltip"></property>

<property name="window_extra_style"></property>

<property name="window_name"></property>

<property name="window_style"></property>

<object class="wxMenu" expanded="0">

<property name="name">VolumesMenu</property>

<property name="permission">protected</property>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">CreateNewVolumeMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnCreateVolumeButtonClick</event>

</object>

<property name="name">m_separator1</property>

<property name="permission">none</property>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">MountVolumeMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnMountVolumeMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">AutoMountDevicesMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnMountAllDevicesButtonClick</event>

</object>

<property name="name">m_separator2</property>

<property name="permission">none</property>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">DismountVolumeMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnDismountVolumeMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">DismountAllMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnDismountAllButtonClick</event>

</object>

<property name="name">m_separator3</property>

<property name="permission">none</property>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">ChangePasswordMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnChangePasswordMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">ChangePkcs5PrfMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnChangePkcs5PrfMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">ChangeKeyfilesMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnChangeKeyfilesMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">RemoveKeyfilesMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnRemoveKeyfilesMenuItemSelected</event>

</object>

<property name="name">m_separator4</property>

<property name="permission">none</property>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">VolumePropertiesMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnVolumePropertiesButtonClick</event>

</object>

</object>

<object class="wxMenu" expanded="0">

<property name="name">FavoritesMenu</property>

<property name="permission">protected</property>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">AddToFavoritesMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnAddToFavoritesMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">AddAllMountedToFavoritesMenuItem</property>

<property name="permission">protected</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnAddAllMountedToFavoritesMenuItemSelected</event>

</object>

<property name="bitmap"></property>

<property name="checked">0</property>

<property name="enabled">1</property>

<property name="help"></property>

<property name="id">wxID_ANY</property>

<property name="kind">wxITEM_NORMAL</property>

<property name="name">OrganizeFavoritesMenuItem</property>

<property name="permission">none</property>

<property name="shortcut"></property>

<property name="unchecked_bitmap"></property>

<event name="OnMenuSelection">OnOrganizeFavoritesMenuItemSelected</event>

</object>