1 files changed, 1585 insertions, 0 deletions
diff --git a/src/Main/Forms/MainFrame.cpp b/src/Main/Forms/MainFrame.cpp
new file mode 100644
index 00000000..cf313a8e
--- /dev/null
+++ b/src/Main/Forms/MainFrame.cpp
@@ -0,0 +1,1585 @@
+/*
+ Copyright (c) 2008-2010 TrueCrypt Developers Association. All rights reserved.
+
+ Governed by the TrueCrypt License 3.0 the full text of which is contained in
+ the file License.txt included in TrueCrypt binary and source code distribution
+ packages.
+*/
+
+#include "System.h"
+
+#ifdef TC_UNIX
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+#include "Common/SecurityToken.h"
+#include "Main/Main.h"
+#include "Main/Resources.h"
+#include "Main/Application.h"
+#include "Main/GraphicUserInterface.h"
+#include "Main/VolumeHistory.h"
+#include "Main/Xml.h"
+#include "MainFrame.h"
+#include "AboutDialog.h"
+#include "BenchmarkDialog.h"
+#include "ChangePasswordDialog.h"
+#include "EncryptionTestDialog.h"
+#include "FavoriteVolumesDialog.h"
+#include "LegalNoticesDialog.h"
+#include "PreferencesDialog.h"
+#include "SecurityTokenKeyfilesDialog.h"
+#include "VolumeCreationWizard.h"
+#include "VolumePropertiesDialog.h"
+
+namespace TrueCrypt
+{
+	MainFrame::MainFrame (wxWindow* parent) : MainFrameBase (parent),
+		ListItemRightClickEventPending (false),
+		SelectedItemIndex (-1),
+		SelectedSlotNumber (0),
+		ShowRequestFifo (-1)
+	{
+		wxBusyCursor busy;
+
+		SetName (Application::GetName());
+		SetTitle (Application::GetName());
+		SetIcon (Resources::GetTrueCryptIcon());
+
+#if defined(TC_UNIX) && !defined(TC_MACOSX)
+		try
+		{
+			string fifoPath = GetShowRequestFifoPath();
+
+			remove (fifoPath.c_str());
+			throw_sys_if (mkfifo (fifoPath.c_str(), S_IRUSR | S_IWUSR) == -1);
+
+			ShowRequestFifo = open (fifoPath.c_str(), O_RDONLY | O_NONBLOCK);
+			throw_sys_if (ShowRequestFifo == -1);
+		}
+		catch (...)
+		{
+#ifdef DEBUG
+			throw;
+#endif
+		}
+#endif
+
+		InitControls();
+		InitPreferences();
+		InitTaskBarIcon();
+		InitEvents();
+		InitMessageFilter();
+
+		if (!GetPreferences().SecurityTokenModule.IsEmpty() && !SecurityToken::IsInitialized())
+		{
+			try
+			{
+				Gui->InitSecurityTokenLibrary();
+			}
+			catch (exception &e)
+			{
+				Gui->ShowError (e);
+			}
+		}
+	}
+
+	MainFrame::~MainFrame ()
+	{
+#if defined(TC_UNIX) && !defined(TC_MACOSX)
+		if (ShowRequestFifo != -1)
+		{
+			try
+			{
+				close (ShowRequestFifo);
+				remove (string (GetShowRequestFifoPath()).c_str());
+			}
+			catch (...) { }
+		}
+#endif
+
+		Core->VolumeMountedEvent.Disconnect (this);
+		Core->VolumeDismountedEvent.Disconnect (this);
+		Gui->OpenVolumeSystemRequestEvent.Disconnect (this);
+		Gui->PreferencesUpdatedEvent.Disconnect (this);
+
+		VolumeHistory::DisconnectComboBox (VolumePathComboBox);
+
+#ifdef TC_WINDOWS
+		Hotkey::UnregisterList (this, GetPreferences().Hotkeys);
+#endif
+	}
+
+	void MainFrame::AddToFavorites (const VolumeInfoList &volumes)
+	{
+		try
+		{
+			FavoriteVolumeList newFavorites;
+
+			// Delete duplicates
+			foreach (shared_ptr <FavoriteVolume> favorite, FavoriteVolume::LoadList())
+			{
+				bool mounted = false;
+				foreach_ref (const VolumeInfo &volume, volumes)
+				{
+					if (volume.Path == favorite->Path)
+					{
+						mounted = true;
+						break;
+					}
+				}
+				if (!mounted)
+					newFavorites.push_back (favorite);
+			}
+
+			size_t newItemCount = 0;
+			foreach_ref (const VolumeInfo &volume, volumes)
+			{
+				newFavorites.push_back (shared_ptr <FavoriteVolume> (new FavoriteVolume (volume.Path, volume.MountPoint, volume.SlotNumber, volume.Protection == VolumeProtection::ReadOnly, volume.SystemEncryption)));
+				++newItemCount;
+			}
+
+			OrganizeFavorites (newFavorites, newItemCount);
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	bool MainFrame::CanExit () const
+	{
+		return Gui->IsTheOnlyTopLevelWindow (this);
+	}
+
+	void MainFrame::ChangePassword (ChangePasswordDialog::Mode::Enum mode)
+	{
+		if (!CheckVolumePathNotEmpty ())
+			return;
+
+		shared_ptr <VolumePath> volumePath = GetSelectedVolumePath();
+
+#ifdef TC_WINDOWS
+		if (Core->IsVolumeMounted (*volumePath))
+		{
+			Gui->ShowInfo (LangString [mode == ChangePasswordDialog::Mode::ChangePkcs5Prf ? "MOUNTED_NO_PKCS5_PRF_CHANGE" : "MOUNTED_NOPWCHANGE"]);
+			return;
+		}
+#endif
+
+		ChangePasswordDialog dialog (this, volumePath, mode);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::CheckFilesystem (bool repair)
+	{
+		shared_ptr <VolumeInfo> selectedVolume = GetSelectedVolume();
+		if (selectedVolume)
+		{
+			try
+			{
+#ifdef TC_WINDOWS
+				string mountPoint = selectedVolume->MountPoint;
+
+				wstring args = StringFormatter (repair ? L"/C echo {0} & chkdsk {1} /F /X & pause" : L"/C echo {0} & chkdsk {1} & pause",
+					StringFormatter (LangString[repair ? "REPAIRING_FS" : "CHECKING_FS"], mountPoint), mountPoint);
+
+				ShellExecute (static_cast <HWND> (GetHandle()), 
+					L"runas",
+					L"cmd.exe", args.c_str(), nullptr, SW_SHOW);
+#else
+#	ifdef TC_MACOSX
+				Gui->ShowInfo (_("Disk Utility will be launched after you press 'OK'.\n\nPlease select your volume in the Disk Utility window and press 'Verify Disk' or 'Repair Disk' button on the 'First Aid' page."));
+#	endif
+				Core->CheckFilesystem (selectedVolume, repair);
+				UpdateVolumeList();
+#endif
+			}
+			catch (exception &e)
+			{
+				Gui->ShowError (e);
+			}
+		}
+	}
+
+	bool MainFrame::CheckVolumePathNotEmpty () const
+	{
+		if (VolumePathComboBox->GetValue().empty())
+		{
+			Gui->ShowInfo ("NO_VOLUME_SELECTED");
+			return false;
+		}
+		return true;
+	}
+
+	void MainFrame::DismountVolume (shared_ptr <VolumeInfo> volume)
+	{
+		try
+		{
+			if (!volume)
+				volume = GetSelectedVolume();
+
+			if (volume)
+				Gui->DismountVolume (volume);
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	shared_ptr <VolumeInfo> MainFrame::GetSelectedVolume () const
+	{
+		return Core->GetMountedVolume (SelectedSlotNumber);
+	}
+
+	void MainFrame::InitControls ()
+	{
+		LogoBitmap->SetBitmap (Resources::GetLogoBitmap());
+		
+		list <int> colPermilles;
+
+#ifndef TC_WINDOWS
+		SettingsMenu->Remove (HotkeysMenuItem);
+#endif
+
+#ifdef TC_MACOSX
+		SettingsMenu->Remove (PreferencesMenuItem);
+		SettingsMenu->AppendSeparator();
+		SettingsMenu->Append (PreferencesMenuItem);
+
+		LowStaticBoxSizer->Detach (HigherButtonSizer);
+		VolumeStaticBoxSizer->Detach (VolumeGridBagSizer);
+		VolumeStaticBoxSizer->Add (VolumeGridBagSizer, 1, wxEXPAND, 0);
+
+		ExitButton->SetLabel (_("Close"));
+		MountAllDevicesButton->SetLabel (_("Mount All Devices"));
+#endif
+
+#ifdef TC_WINDOWS		 
+		SlotListCtrl->InsertColumn (ColumnSlot, LangString["DRIVE"], wxLIST_FORMAT_LEFT, 1);
+		colPermilles.push_back (75);
+#else
+		SlotListCtrl->InsertColumn (ColumnSlot, _("Slot"), wxLIST_FORMAT_LEFT, 1);
+		colPermilles.push_back (82);
+#endif
+
+		SlotListCtrl->InsertColumn (ColumnPath, LangString["VOLUME"], wxLIST_FORMAT_LEFT, 1);
+#ifdef TC_WINDOWS		 
+		colPermilles.push_back (487);
+#else
+		colPermilles.push_back (429);
+#endif
+
+		SlotListCtrl->InsertColumn (ColumnSize, LangString["SIZE"], wxLIST_FORMAT_RIGHT, 1);
+#ifdef TC_WINDOWS		 
+		colPermilles.push_back (126);
+#else
+		colPermilles.push_back (130);
+#endif
+
+#ifdef TC_WINDOWS		 
+		SlotListCtrl->InsertColumn (ColumnEA, LangString["ENCRYPTION_ALGORITHM_LV"], wxLIST_FORMAT_LEFT, 1);
+		colPermilles.push_back (233);
+#else
+		SlotListCtrl->InsertColumn (ColumnMountPoint, LangString["MOUNT_POINT"], wxLIST_FORMAT_LEFT, 1);
+		colPermilles.push_back (259);
+#endif
+
+		SlotListCtrl->InsertColumn (ColumnType, LangString["TYPE"], wxLIST_FORMAT_LEFT, 1);
+		colPermilles.push_back (100);
+
+		wxImageList *imageList = new wxImageList (16, 12, true);
+		imageList->Add (Resources::GetDriveIconBitmap(), Resources::GetDriveIconMaskBitmap());
+		SlotListCtrl->AssignImageList (imageList, wxIMAGE_LIST_SMALL);
+
+		SetMinSize (wxSize (-1, -1));
+
+		size_t slotListRowCount = 12;
+
+#ifndef TC_WINDOWS
+		int screenHeight = wxSystemSettings::GetMetric (wxSYS_SCREEN_Y);
+		
+		if (screenHeight < 480)
+			slotListRowCount = 1;
+		else if (screenHeight <= 600)
+			slotListRowCount = slotListRowCount * screenHeight / 1000;
+#endif
+
+		Gui->SetListCtrlHeight (SlotListCtrl, slotListRowCount);
+
+#ifdef __WXGTK__
+		wxSize size (-1, (int) ((double) Gui->GetCharHeight (this) * 1.53));
+		CreateVolumeButton->SetMinSize (size);
+		VolumePropertiesButton->SetMinSize (size);
+		WipeCacheButton->SetMinSize (size);
+		VolumePathComboBox->SetMinSize (size);
+		SelectFileButton->SetMinSize (size);
+		SelectDeviceButton->SetMinSize (size);
+		VolumeToolsButton->SetMinSize (size);
+		size = wxSize (-1, 38);
+		VolumeButton->SetMinSize (size);
+#endif
+		Fit();
+		Layout();
+		Center();
+
+		VolumePathComboBox->SetMinSize (VolumePathComboBox->GetSize());
+		VolumePathComboBox->SetMaxSize (VolumePathComboBox->GetSize());
+
+		SetMinSize (GetSize());
+		SetMaxSize (GetSize());
+
+		Gui->SetListCtrlColumnWidths (SlotListCtrl, colPermilles);
+		
+		UpdateVolumeList();
+		UpdateWipeCacheButton();
+	}
+
+	void MainFrame::InitEvents ()
+	{
+		Core->VolumeMountedEvent.Connect (EventConnector <MainFrame> (this, &MainFrame::OnVolumeMounted));
+		Core->VolumeDismountedEvent.Connect (EventConnector <MainFrame> (this, &MainFrame::OnVolumeDismounted));
+		Gui->OpenVolumeSystemRequestEvent.Connect (EventConnector <MainFrame> (this, &MainFrame::OnOpenVolumeSystemRequestEvent));
+		Gui->PreferencesUpdatedEvent.Connect (EventConnector <MainFrame> (this, &MainFrame::OnPreferencesUpdated));
+
+		// Drag & drop
+		class FileDropTarget : public wxFileDropTarget
+		{
+		public:
+			FileDropTarget (MainFrame *frame) : Frame (frame) { }
+
+			wxDragResult OnDragOver (wxCoord x, wxCoord y, wxDragResult def)
+			{
+				wxPoint p;
+				wxWindow *w = wxFindWindowAtPointer (p);
+				if (w == Frame || wxGetTopLevelParent (w) == Frame)
+					return wxDragLink;
+				return wxDragNone;
+			}
+
+			bool OnDropFiles (wxCoord x, wxCoord y, const wxArrayString &filenames)
+			{
+				if (!filenames.empty())
+					Frame->SetVolumePath (wstring (filenames.front()));
+				return true;
+			}
+
+			MainFrame *Frame;
+		};
+
+		SetDropTarget (new FileDropTarget (this));
+#ifdef TC_MACOSX
+		foreach (wxWindow *c, MainPanel->GetChildren())
+			c->SetDropTarget (new FileDropTarget (this));
+#endif
+
+		// Volume history
+		VolumeHistory::ConnectComboBox (VolumePathComboBox);
+
+#ifdef TC_WINDOWS
+		// Hotkeys
+		Hotkey::RegisterList (this, GetPreferences().Hotkeys);
+		Connect (wxEVT_HOTKEY, wxKeyEventHandler (MainFrame::OnHotkey));
+#endif
+
+		// Timer
+		class Timer : public wxTimer
+		{
+		public:
+			Timer (MainFrame *frame) : Frame (frame) { }
+
+			void Notify()
+			{
+				Frame->OnTimer();
+			}
+
+			MainFrame *Frame;
+		};
+
+		mTimer.reset (dynamic_cast <wxTimer *> (new Timer (this)));
+		mTimer->Start (2000);
+	}
+
+#ifdef TC_WINDOWS
+#include <dbt.h>
+	static WNDPROC MainFrameWndProc;
+	static LRESULT CALLBACK MainFrameWndProcFilter (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+	{
+		if (message == WM_DEVICECHANGE && !Core->IsDeviceChangeInProgress())
+		{
+			MainFrame *frame = dynamic_cast <MainFrame *> (Gui->GetMainFrame());
+			PDEV_BROADCAST_HDR hdr = (PDEV_BROADCAST_HDR) lParam;
+			
+			if (wParam == DBT_DEVICEREMOVECOMPLETE && hdr->dbch_devicetype == DBT_DEVTYP_VOLUME)
+			{
+				PDEV_BROADCAST_VOLUME vol = (PDEV_BROADCAST_VOLUME) lParam;
+				for (wchar_t driveNo = 0; driveNo < 26; ++driveNo)
+				{
+					if (vol->dbcv_unitmask & (1 << driveNo))
+						frame->OnDeviceChange (wstring (StringFormatter (L"{0}:\\", wchar_t (L'A' + driveNo))));
+				}
+			}
+			else
+			{
+				frame->OnDeviceChange ();
+			}
+		}
+
+		return CallWindowProc (MainFrameWndProc, hwnd, message, wParam, lParam);
+	}
+#endif
+
+	void MainFrame::InitMessageFilter ()
+	{
+#ifdef TC_WINDOWS
+		HWND mainFrameHwnd = static_cast <HWND> (GetHandle());
+		MainFrameWndProc = (WNDPROC) GetWindowLongPtr (mainFrameHwnd, GWL_WNDPROC);
+		SetWindowLongPtr (mainFrameHwnd, GWL_WNDPROC, (LONG_PTR) MainFrameWndProcFilter);
+#endif
+	}
+
+	void MainFrame::InitPreferences ()
+	{
+		try
+		{
+			LoadPreferences();
+
+			VolumeSlotNumber lastSelectedSlotNumber = GetPreferences().LastSelectedSlotNumber;
+			if (Core->IsSlotNumberValid (lastSelectedSlotNumber))
+			{
+				long slotIndex = SlotNumberToItemIndex (lastSelectedSlotNumber);
+				if (slotIndex >= 0)
+				{
+					SlotListCtrl->SetItemState (slotIndex, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED);
+					SlotListCtrl->EnsureVisible (slotIndex);
+				}
+			}
+
+			LoadFavoriteVolumes();
+			VolumeHistory::Load();
+
+			if (VolumePathComboBox->GetValue().empty() && !VolumeHistory::Get().empty())
+				SetVolumePath (VolumeHistory::Get().front());
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+			Gui->ShowError (_("Error while loading configuration files located in ") + wstring (Application::GetConfigFilePath (L"")));
+		}
+	}
+
+	void MainFrame::InitTaskBarIcon ()
+	{
+		class TaskBarIcon : public wxTaskBarIcon
+		{
+		public:
+			TaskBarIcon (MainFrame *frame) : Busy (false), Frame (frame)
+			{
+				Connect (wxEVT_TASKBAR_LEFT_DOWN, wxTaskBarIconEventHandler (TaskBarIcon::OnLeftButtonDown));
+			}
+
+			wxMenu *CreatePopupMenu ()
+			{ 
+				auto_ptr <wxMenu> popup (new wxMenu);
+
+				Gui->AppendToMenu (*popup, LangString[Gui->IsInBackgroundMode() ? "SHOW_TC" : "HIDE_TC"], this, wxCommandEventHandler (TaskBarIcon::OnShowHideMenuItemSelected));
+				
+				popup->AppendSeparator();
+				Gui->AppendToMenu (*popup, _("Mount All Favorite Volumes"), this, wxCommandEventHandler (TaskBarIcon::OnMountAllFavoritesMenuItemSelected))->Enable (!Busy);
+				Gui->AppendToMenu (*popup, _("Dismount All Mounted Volumes"), this, wxCommandEventHandler (TaskBarIcon::OnDismountAllMenuItemSelected))->Enable (!Busy);
+				
+				// Favorite volumes
+				if (Gui->GetPreferences().BackgroundTaskMenuMountItemsEnabled && !Frame->FavoriteVolumesMenuMap.empty())
+				{
+					popup->AppendSeparator();
+					typedef pair <int, FavoriteVolume> FavMapPair;
+					foreach (FavMapPair fp, Frame->FavoriteVolumesMenuMap)
+					{
+						Gui->AppendToMenu (*popup, LangString["MOUNT"] + L" " + wstring (fp.second.Path) + (fp.second.MountPoint.IsEmpty() ? L"" : L"  " + wstring (fp.second.MountPoint)),
+							this, wxCommandEventHandler (TaskBarIcon::OnFavoriteVolumeMenuItemSelected), fp.first)->Enable (!Busy);
+					}
+				}
+
+				// Mounted volumes
+				VolumeInfoList mountedVolumes = Core->GetMountedVolumes();
+				if (!mountedVolumes.empty())
+				{
+					if (Gui->GetPreferences().BackgroundTaskMenuOpenItemsEnabled)
+					{
+						popup->AppendSeparator();
+						OpenMap.clear();
+						foreach (shared_ptr <VolumeInfo> volume, mountedVolumes)
+						{
+							if (!volume->MountPoint.IsEmpty())
+							{
+								wxString label = LangString["OPEN"] + L" " + wstring (volume->MountPoint) + L" (" + wstring (volume->Path) + L")";
+								wxMenuItem *item = Gui->AppendToMenu (*popup, label, this, wxCommandEventHandler (TaskBarIcon::OnOpenMenuItemSelected));
+								OpenMap[item->GetId()] = volume;
+							}
+						}
+					}
+
+					if (Gui->GetPreferences().BackgroundTaskMenuDismountItemsEnabled)
+					{
+						popup->AppendSeparator();
+						DismountMap.clear();
+						foreach (shared_ptr <VolumeInfo> volume, mountedVolumes)
+						{
+							wxString label = LangString["DISMOUNT"] + L" ";
+
+							if (!volume->MountPoint.IsEmpty())
+								label += wstring (volume->MountPoint) + L" (" + wstring (volume->Path) + L")";
+							else
+								label += wstring (volume->Path);
+
+							wxMenuItem *item = Gui->AppendToMenu (*popup, label, this, wxCommandEventHandler (TaskBarIcon::OnDismountMenuItemSelected));
+							item->Enable (!Busy);
+							DismountMap[item->GetId()] = volume;
+						}
+					}
+				}
+
+				popup->AppendSeparator();
+				Gui->AppendToMenu (*popup, _("Preferences..."), this, wxCommandEventHandler (TaskBarIcon::OnPreferencesMenuItemSelected))->Enable (!Busy);
+#ifndef TC_MACOSX
+				popup->AppendSeparator();
+				Gui->AppendToMenu (*popup, _("Exit"), this, wxCommandEventHandler (TaskBarIcon::OnExitMenuItemSelected))->Enable (!Busy && Frame->CanExit());
+#endif
+				return popup.release();
+			}
+
+			void OnDismountAllMenuItemSelected (wxCommandEvent& event) { Busy = true; Frame->OnDismountAllButtonClick (event); Busy = false; }
+			void OnDismountMenuItemSelected (wxCommandEvent& event) { Busy = true; Frame->DismountVolume (DismountMap[event.GetId()]); Busy = false; }
+			void OnFavoriteVolumeMenuItemSelected (wxCommandEvent& event) { Busy = true; Frame->OnFavoriteVolumeMenuItemSelected (event); Busy = false; }
+			void OnMountAllFavoritesMenuItemSelected (wxCommandEvent& event) { Busy = true; Frame->MountAllFavorites (); Busy = false; }
+
+			void OnExitMenuItemSelected (wxCommandEvent& event)
+			{
+				Busy = true;
+				if (Core->GetMountedVolumes().empty() || Gui->AskYesNo (LangString ["CONFIRM_EXIT"], false, true))
+					Frame->Close (true);
+				Busy = false;
+			}
+
+			void OnLeftButtonDown (wxTaskBarIconEvent& event) { Gui->SetBackgroundMode (false); }
+			void OnOpenMenuItemSelected (wxCommandEvent& event) { Gui->OpenExplorerWindow (OpenMap[event.GetId()]->MountPoint); }
+			void OnPreferencesMenuItemSelected (wxCommandEvent& event) { Busy = true; Frame->OnPreferencesMenuItemSelected (event); Busy = false; }
+			void OnShowHideMenuItemSelected (wxCommandEvent& event) { Gui->SetBackgroundMode (!Gui->IsInBackgroundMode()); }
+
+			bool Busy;
+			map < int, shared_ptr <VolumeInfo> > DismountMap;
+			MainFrame *Frame;
+			map < int, shared_ptr <VolumeInfo> > OpenMap;
+		};
+
+		mTaskBarIcon.reset (new TaskBarIcon (this));
+		ShowTaskBarIcon (GetPreferences().BackgroundTaskEnabled);
+	}
+
+	void MainFrame::LoadFavoriteVolumes ()
+	{
+		typedef pair <int, FavoriteVolume> FavMapPair;
+		foreach (FavMapPair p, FavoriteVolumesMenuMap)
+		{
+			FavoritesMenu->Delete (p.first);
+		}
+		FavoriteVolumesMenuMap.clear();
+
+		foreach_ref (const FavoriteVolume &favorite, FavoriteVolume::LoadList())
+		{
+			wstring label = wstring (favorite.Path);
+			if (!favorite.MountPoint.IsEmpty())
+				label += wstring (L"   ") + wstring (favorite.MountPoint);
+
+			wxMenuItem *item = Gui->AppendToMenu (*FavoritesMenu, label, this, wxCommandEventHandler (MainFrame::OnFavoriteVolumeMenuItemSelected));
+			FavoriteVolumesMenuMap[item->GetId()] = favorite;
+		}
+	}
+
+	void MainFrame::LoadPreferences ()
+	{
+		UserPreferences prefs;
+		prefs.Load();
+		Gui->SetPreferences (prefs);
+		NoHistoryCheckBox->SetValue (!prefs.SaveHistory);
+	}
+	
+	void MainFrame::MountAllDevices ()
+	{
+		try
+		{
+			MountOptions mountOptions (GetPreferences().DefaultMountOptions);
+
+			if (SlotListCtrl->GetSelectedItemCount() == 1)
+				mountOptions.SlotNumber = SelectedSlotNumber;
+
+			Gui->MountAllDeviceHostedVolumes (mountOptions);
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::MountAllFavorites ()
+	{
+		try
+		{
+			MountOptions mountOptions (GetPreferences().DefaultMountOptions);
+			Gui->MountAllFavoriteVolumes (mountOptions);
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::MountVolume ()
+	{
+		if (!IsFreeSlotSelected())
+		{
+			Gui->ShowWarning (_("Please select a free drive slot from the list."));
+			return;
+		}
+
+		if (!CheckVolumePathNotEmpty())
+			return;
+
+		MountOptions mountOptions (GetPreferences().DefaultMountOptions);
+		mountOptions.SlotNumber = SelectedSlotNumber;
+		mountOptions.Path = GetSelectedVolumePath();
+
+		try
+		{
+			if (Gui->MountVolume (mountOptions) && GetPreferences().SaveHistory)
+				VolumeHistory::Add (*mountOptions.Path);
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnAboutMenuItemSelected (wxCommandEvent& event)
+	{
+		AboutDialog dialog (this);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnActivate (wxActivateEvent& event)
+	{
+		Gui->SetActiveFrame (this);
+
+#ifdef TC_MACOSX
+		if (event.GetActive() && Gui->IsInBackgroundMode())
+			Gui->SetBackgroundMode (false);
+#endif
+		event.Skip();
+	}
+
+	void MainFrame::OnAddAllMountedToFavoritesMenuItemSelected (wxCommandEvent& event)
+	{
+		AddToFavorites (MountedVolumes);
+	}
+
+	void MainFrame::OnAddToFavoritesMenuItemSelected (wxCommandEvent& event)
+	{
+		shared_ptr <VolumeInfo> selectedVolume = GetSelectedVolume();
+		if (selectedVolume)
+		{
+			VolumeInfoList volumes;
+			volumes.push_back (selectedVolume);
+			AddToFavorites (volumes);
+		}
+	}
+
+	void MainFrame::OnBackupVolumeHeadersMenuItemSelected (wxCommandEvent& event)
+	{
+		if (!CheckVolumePathNotEmpty ())
+			return;
+
+		try
+		{
+			Gui->BackupVolumeHeaders (GetSelectedVolumePath());
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnBenchmarkMenuItemSelected (wxCommandEvent& event)
+	{
+		BenchmarkDialog dialog (this);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnClearSlotSelectionMenuItemSelected (wxCommandEvent& event)
+	{
+		Gui->ClearListCtrlSelection (SlotListCtrl);
+		UpdateControls();
+	}
+
+	void MainFrame::OnClose (wxCloseEvent& event)
+	{
+		if (GetPreferences().WipeCacheOnClose)
+			Core->WipePasswordCache();
+
+#ifdef TC_MACOSX
+		if (!event.CanVeto() && GetPreferences().DismountOnLogOff)
+		{
+			try
+			{
+				Gui->DismountVolumes (Core->GetMountedVolumes(), GetPreferences().ForceAutoDismount, false);
+			}
+			catch (...) { }
+		}
+#endif
+
+		if (!Gui->IsTheOnlyTopLevelWindow (this))
+		{
+			// Bring first frame to foreground
+			wxFrame *frame = nullptr;
+			foreach (wxWindow *window, wxTopLevelWindows)
+			{
+				if (window != this
+					&& dynamic_cast <wxFrame *> (window)
+					&& StringConverter::GetTypeName (typeid (*window)).find ("wxTaskBarIcon") == string::npos)
+				{
+					frame = dynamic_cast <wxFrame *> (window);
+					if (window->IsShown())
+						break;
+				}
+			}
+
+			if (frame)
+			{
+				frame->Show();
+				if (frame->IsIconized())
+					frame->Iconize(false);
+				frame->Raise();
+			}
+		}
+		else if (event.CanVeto() && GetPreferences().BackgroundTaskEnabled
+			&& (!GetPreferences().CloseBackgroundTaskOnNoVolumes || !MountedVolumes.empty()))
+		{
+			// Enter background mode
+			if (!Gui->IsInBackgroundMode())
+				Gui->SetBackgroundMode (true);
+		}
+		else
+		{
+#ifdef __WXGTK__
+			Show();
+#endif
+			SavePreferences();
+
+			Destroy();
+		}
+
+		 // Cancel close - veto is not used to prevent aborting log off procedure on Windows
+		return;
+	}
+
+	void MainFrame::OnCloseAllSecurityTokenSessionsMenuItemSelected (wxCommandEvent& event)
+	{
+		try
+		{
+			{
+				wxBusyCursor busy;
+				SecurityToken::CloseAllSessions();
+			}
+			Gui->ShowInfo ("ALL_TOKEN_SESSIONS_CLOSED");
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnCreateVolumeButtonClick (wxCommandEvent& event)
+	{
+		try
+		{
+			(new VolumeCreationWizard (nullptr))->Show();
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnDefaultKeyfilesMenuItemSelected (wxCommandEvent& event)
+	{
+		PreferencesDialog dialog (this);
+		dialog.SelectPage (dialog.DefaultKeyfilesPage);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnDeviceChange (const DirectoryPath &mountPoint)
+	{
+		// Check if any host device has been removed and force dismount of volumes accordingly
+		VolumeInfoList removedVolumes;
+		foreach (shared_ptr <VolumeInfo> volume, Core->GetMountedVolumes())
+		{
+			// File-hosted volumes
+			if (!volume->Path.IsDevice() && !mountPoint.IsEmpty())
+			{
+				if (wxString (volume->Path).Upper().StartsWith (wstring (mountPoint).c_str()))
+				{
+					removedVolumes.push_back (volume);
+					continue;
+				}
+			}
+
+			// Device-hosted volumes
+			if (volume->Path.IsDevice() && !Core->IsDevicePresent (volume->Path))
+				removedVolumes.push_back (volume);
+		}
+		
+		if (!removedVolumes.empty())
+			Gui->AutoDismountVolumes (removedVolumes, true);
+	}
+
+	void MainFrame::OnDismountAllButtonClick (wxCommandEvent& event)
+	{
+		Gui->DismountAllVolumes();
+	}
+
+	void MainFrame::OnEncryptionTestMenuItemSelected (wxCommandEvent& event)
+	{
+		EncryptionTestDialog dialog (this);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnExitButtonClick (wxCommandEvent& event)
+	{
+		Close();
+	}
+
+	void MainFrame::OnFavoriteVolumeMenuItemSelected (wxCommandEvent& event)
+	{
+		FavoriteVolume favorite = FavoriteVolumesMenuMap[event.GetId()];
+		if (!favorite.Path.IsEmpty())
+		{
+			SetVolumePath (favorite.Path);
+
+			MountOptions mountOptions (GetPreferences().DefaultMountOptions);
+			favorite.ToMountOptions (mountOptions);
+
+			shared_ptr <VolumeInfo> volume = Gui->MountVolume (mountOptions);
+			if (volume)
+				SlotListCtrl->EnsureVisible (SlotNumberToItemIndex (volume->SlotNumber));
+		}
+	}
+
+	void MainFrame::OnHiddenVolumeProtectionTriggered (shared_ptr <VolumeInfo> protectedVolume)
+	{
+		Gui->ShowWarningTopMost (StringFormatter (LangString["DAMAGE_TO_HIDDEN_VOLUME_PREVENTED"], wstring (protectedVolume->Path)));
+	}
+
+	void MainFrame::OnHotkey (wxKeyEvent& event)
+	{
+#ifdef TC_WINDOWS
+		switch (event.GetId())
+		{
+		case Hotkey::Id::CloseAllSecurityTokenSessions:
+			try
+			{
+				SecurityToken::CloseAllSessions();
+				Gui->ShowInfo ("ALL_TOKEN_SESSIONS_CLOSED");
+			}
+			catch (exception &e) { Gui->ShowError (e); }
+			break;
+
+		case Hotkey::Id::DismountAll:
+		case Hotkey::Id::DismountAllWipeCache:
+			{
+				if (event.GetId() == Hotkey::Id::DismountAllWipeCache)
+					WipeCache();
+
+				size_t mountedCount = Core->GetMountedVolumes().size();
+				Gui->DismountAllVolumes();
+				size_t newMountedCount = Core->GetMountedVolumes().size();
+
+				if (newMountedCount < mountedCount)
+				{
+					if (newMountedCount == 0 && GetPreferences().DisplayMessageAfterHotkeyDismount)
+						Gui->ShowInfo ("MOUNTED_VOLUMES_DISMOUNTED");
+					else if (GetPreferences().BeepAfterHotkeyMountDismount)
+						MessageBeep((UINT) -1);
+				}
+			}
+			break;
+
+		case Hotkey::Id::ForceDismountAllWipeCache:
+		case Hotkey::Id::ForceDismountAllWipeCacheExit:
+			{
+				bool mounted = !Core->GetMountedVolumes().empty();
+
+				WipeCache();
+				Gui->DismountAllVolumes (true, true);
+
+				if (mounted && GetPreferences().DisplayMessageAfterHotkeyDismount)
+					Gui->ShowInfo ("VOLUMES_DISMOUNTED_CACHE_WIPED");
+				else if (mounted && GetPreferences().BeepAfterHotkeyMountDismount)
+					MessageBeep((UINT) -1);
+
+				if (event.GetId() == Hotkey::Id::ForceDismountAllWipeCacheExit)
+					Close (true);
+			}
+			break;
+
+		case Hotkey::Id::MountAllDevices:
+		case Hotkey::Id::MountAllFavorites:
+			{
+				size_t mountedCount = Core->GetMountedVolumes().size();
+				
+				if (event.GetId() == Hotkey::Id::MountAllDevices)
+					MountAllDevices();
+				else
+					MountAllFavorites();
+
+				if (Core->GetMountedVolumes().size() > mountedCount && GetPreferences().BeepAfterHotkeyMountDismount)
+					MessageBeep((UINT) -1);
+			}
+			break;
+
+		case Hotkey::Id::ShowHideApplication:
+			Gui->SetBackgroundMode (!Gui->IsInBackgroundMode());
+			break;
+
+		case Hotkey::Id::WipeCache:
+			WipeCache();
+			Gui->ShowInfo ("PASSWORD_CACHE_WIPED");
+			break;
+
+		default:
+			assert (false);
+			break;
+		}
+#endif // TC_WINDOWS
+	}
+
+	void MainFrame::OnHotkeysMenuItemSelected (wxCommandEvent& event)
+	{
+		PreferencesDialog dialog (this);
+		dialog.SelectPage (dialog.HotkeysPage);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnLegalNoticesMenuItemSelected (wxCommandEvent& event)
+	{
+		LegalNoticesDialog dialog (this);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnListChanged ()
+	{
+		OnListItemSelectionChanged();
+		UpdateControls();
+	}
+
+	void MainFrame::OnListItemActivated (wxListEvent& event)
+	{
+		if (IsMountedSlotSelected())
+			OpenSelectedVolume();
+		else
+			MountVolume();
+	}
+
+	void MainFrame::OnListItemDeleted (long itemIndex)
+	{
+		if (SelectedItemIndex > itemIndex)
+			--SelectedItemIndex;
+	}
+	
+	void MainFrame::OnListItemDeselected (wxListEvent& event)
+	{
+		OnListItemSelectionChanged();
+	}
+
+	void MainFrame::OnListItemInserted (long itemIndex)
+	{
+		if (SelectedItemIndex >= itemIndex)
+			++SelectedItemIndex;
+	}
+
+	void MainFrame::OnListItemRightClick (wxListEvent& event)
+	{
+#ifdef TC_MACOSX
+		if (SelectedItemIndex != event.GetIndex())
+		{
+			SelectedItemIndex = event.GetIndex();
+			OnListItemSelectionChanged();
+		}
+
+		if (!ListItemRightClickEventPending)
+		{
+			ListItemRightClickEventPending = true;
+			SlotListCtrl->AddPendingEvent (event);
+			return;
+		}
+
+		ListItemRightClickEventPending = false;
+#endif
+
+		wxMenu popup;
+		if (IsMountedSlotSelected())
+		{
+			Gui->AppendToMenu (popup, LangString["DISMOUNT"], this, wxCommandEventHandler (MainFrame::OnDismountVolumeMenuItemSelected));
+			Gui->AppendToMenu (popup, LangString["OPEN"], this, wxCommandEventHandler (MainFrame::OnOpenVolumeMenuItemSelected));
+			Gui->AppendToMenu (popup, _("Deselect"), this, wxCommandEventHandler (MainFrame::OnClearSlotSelectionMenuItemSelected));
+
+			popup.AppendSeparator();
+			Gui->AppendToMenu (popup, _("Add to Favorites..."), this, wxCommandEventHandler (MainFrame::OnAddToFavoritesMenuItemSelected));
+
+			popup.AppendSeparator();
+			Gui->AppendToMenu (popup, LangString["IDPM_CHECK_FILESYS"], this, wxCommandEventHandler (MainFrame::OnCheckFilesystemMenuItemSelected));
+			Gui->AppendToMenu (popup, LangString["IDPM_REPAIR_FILESYS"], this, wxCommandEventHandler (MainFrame::OnRepairFilesystemMenuItemSelected));
+
+			popup.AppendSeparator();
+			Gui->AppendToMenu (popup, LangString["IDPM_PROPERTIES"], this, wxCommandEventHandler (MainFrame::OnVolumePropertiesButtonClick));
+
+			PopupMenu (&popup);
+		}
+		else if (IsFreeSlotSelected())
+		{
+			Gui->AppendToMenu (popup, _("Mount Volume"), this, wxCommandEventHandler (MainFrame::OnMountVolumeMenuItemSelected));
+			
+			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();
+
+			Gui->AppendToMenu (popup, _("Deselect"), this, wxCommandEventHandler (MainFrame::OnClearSlotSelectionMenuItemSelected));
+
+			PopupMenu (&popup);
+		}
+	}
+
+	void MainFrame::OnListItemSelected (wxListEvent& event)
+	{
+		SelectedItemIndex = event.GetIndex();
+		OnListItemSelectionChanged();
+	}
+			
+	void MainFrame::OnListItemSelectionChanged ()
+	{
+		if (SlotListCtrl->GetSelectedItemCount() < 1)
+			SelectedItemIndex = -1;
+		
+		if (SelectedItemIndex >= 0)
+			SelectedSlotNumber = (VolumeSlotNumber) SlotListCtrl->GetItemData (SelectedItemIndex);
+		else
+			SelectedSlotNumber = 0;
+
+		UpdateControls();
+	}
+	
+	void MainFrame::OnManageSecurityTokenKeyfilesMenuItemSelected (wxCommandEvent& event)
+	{
+		try
+		{
+			SecurityTokenKeyfilesDialog dialog (this, false);
+			dialog.ShowModal();
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnMountAllDevicesButtonClick (wxCommandEvent& event)
+	{
+		MountAllDevices();
+	}
+
+	void MainFrame::OnMountAllFavoritesMenuItemSelected (wxCommandEvent& event)
+	{
+		MountAllFavorites();
+	}
+
+	void MainFrame::OnNoHistoryCheckBoxClick (wxCommandEvent& event)
+	{
+		UserPreferences prefs = GetPreferences();
+		prefs.SaveHistory = !event.IsChecked();
+		Gui->SetPreferences (prefs);
+
+		if (event.IsChecked())
+		{
+			try
+			{
+				VolumeHistory::Clear();
+			}
+			catch (exception &e) { Gui->ShowError (e); }
+		}
+	}
+
+	void MainFrame::OnOrganizeFavoritesMenuItemSelected (wxCommandEvent& event)
+	{
+		try
+		{
+			OrganizeFavorites (FavoriteVolume::LoadList());
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnPreferencesMenuItemSelected (wxCommandEvent& event)
+	{
+		PreferencesDialog dialog (this);
+		dialog.ShowModal();
+	}
+
+	void MainFrame::OnPreferencesUpdated (EventArgs &args)
+	{
+		const UserPreferences &prefs = GetPreferences();
+
+		NoHistoryCheckBox->SetValue (!prefs.SaveHistory);
+
+		ShowTaskBarIcon (prefs.BackgroundTaskEnabled);
+		if (Gui->IsInBackgroundMode() && !prefs.BackgroundTaskEnabled)
+			Close (true);
+
+		SavePreferences();
+	}
+	
+	void MainFrame::OnRestoreVolumeHeaderMenuItemSelected (wxCommandEvent& event)
+	{
+		if (!CheckVolumePathNotEmpty ())
+			return;
+
+		try
+		{
+			Gui->RestoreVolumeHeaders (GetSelectedVolumePath());
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnSecurityTokenPreferencesMenuItemSelected (wxCommandEvent& event)
+	{
+		PreferencesDialog dialog (this);
+		dialog.SelectPage (dialog.SecurityTokensPage);
+		dialog.ShowModal();
+	}
+
+	
+	void MainFrame::OnSelectDeviceAndMountMenuItemSelected (wxCommandEvent& event)
+	{
+		DevicePath path = Gui->SelectDevice (this);
+
+		if (!path.IsEmpty())
+		{
+			SetVolumePath (path);
+			OnMountVolumeMenuItemSelected (event);
+		}
+	}
+
+	void MainFrame::OnSelectDeviceButtonClick (wxCommandEvent& event)
+	{
+		DevicePath path = Gui->SelectDevice (this);
+
+		if (!path.IsEmpty())
+			SetVolumePath (path);
+	}
+
+	void MainFrame::OnSelectFileAndMountMenuItemSelected (wxCommandEvent& event)
+	{
+		FilePath path = Gui->SelectVolumeFile (this);
+
+		if (!path.IsEmpty())
+		{
+			SetVolumePath (path);
+			OnMountVolumeMenuItemSelected (event);
+		}
+	}
+
+	void MainFrame::OnSelectFileButtonClick (wxCommandEvent& event)
+	{
+		FilePath path = Gui->SelectVolumeFile (this);
+		if (!path.IsEmpty())
+			SetVolumePath (path);
+	}
+	
+	void MainFrame::OnTimer ()
+	{
+		try
+		{
+			UpdateVolumeList();
+			UpdateWipeCacheButton();
+
+			if (GetPreferences().BackgroundTaskEnabled)
+			{
+				// Inactivity auto-dismount
+				if (GetPreferences().DismountOnInactivity)
+				{
+					VolumeInfoList inactiveVolumes;
+					wxLongLong currentTime = wxGetLocalTimeMillis().GetValue();
+
+					map <wstring, VolumeActivityMapEntry> newActivityTimeMap;
+
+					foreach (shared_ptr <VolumeInfo> volume, MountedVolumes)
+					{
+						if (VolumeActivityMap.find (volume->Path) != VolumeActivityMap.end()
+							&& VolumeActivityMap[volume->Path].SerialInstanceNumber == volume->SerialInstanceNumber)
+						{
+							VolumeActivityMapEntry ae = VolumeActivityMap[volume->Path];
+
+							if (volume->TotalDataRead != ae.TotalDataRead || volume->TotalDataWritten != ae.TotalDataWritten)
+							{
+								ae.LastActivityTime = currentTime;
+								ae.TotalDataRead = volume->TotalDataRead;
+								ae.TotalDataWritten = volume->TotalDataWritten;
+							}
+							else if ((currentTime - ae.LastActivityTime) > GetPreferences().MaxVolumeIdleTime * 1000LL * 60)
+							{
+								inactiveVolumes.push_back (volume);
+							}
+
+							newActivityTimeMap[volume->Path] = ae;
+						}
+						else
+						{
+							newActivityTimeMap[volume->Path] = VolumeActivityMapEntry (*volume, currentTime);
+						}
+					}
+
+					VolumeActivityMap = newActivityTimeMap;
+
+					if (!inactiveVolumes.empty())
+						Gui->AutoDismountVolumes (inactiveVolumes);
+				}
+
+				// Screen saver auto-dismount
+				if (GetPreferences().DismountOnScreenSaver)
+				{
+#ifdef TC_WINDOWS
+					bool running;
+					if (SystemParametersInfo (SPI_GETSCREENSAVERRUNNING, 0, &running, 0) != 0)
+					{
+						static bool previousState = false;
+						if (running && !previousState)
+						{
+							previousState = true;
+							Gui->OnAutoDismountAllEvent();
+						}
+						else
+						{
+							previousState = running;
+						}
+					}
+#endif
+				}
+			}
+
+			if (Gui->IsInBackgroundMode())
+			{
+				if (!GetPreferences().BackgroundTaskEnabled)
+				{
+					Close (true);
+				}
+				else if (MountedVolumes.empty() && (GetPreferences().CloseBackgroundTaskOnNoVolumes || Core->IsInPortableMode()))
+				{
+					Close (true);
+				}
+			}
+
+#if defined(TC_UNIX) && !defined(TC_MACOSX)
+			try
+			{
+				byte buf[128];
+				if (read (ShowRequestFifo, buf, sizeof (buf)) > 0 && Gui->IsInBackgroundMode())
+					Gui->SetBackgroundMode (false);
+			}
+			catch (...)
+			{
+#ifdef DEBUG
+				throw;
+#endif
+			}
+#endif
+		}
+		catch (exception &e)
+		{
+			Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::OnVolumeButtonClick (wxCommandEvent& event)
+	{
+		if (IsMountedSlotSelected())
+			DismountVolume();
+		else
+			MountVolume();
+	}
+
+	void MainFrame::OnVolumePropertiesButtonClick (wxCommandEvent& event)
+	{
+		shared_ptr <VolumeInfo> selectedVolume = GetSelectedVolume();
+		if (selectedVolume)
+		{
+			VolumePropertiesDialog dialog (this, *selectedVolume);
+			dialog.ShowModal();
+		}
+	}
+
+	void MainFrame::OnVolumeToolsButtonClick (wxCommandEvent& event)
+	{
+		if (!CheckVolumePathNotEmpty())
+			return;
+
+		wxMenu popup;
+
+		Gui->AppendToMenu (popup, _("Change Volume Password..."), this, wxCommandEventHandler (MainFrame::OnChangePasswordMenuItemSelected));
+
+		popup.AppendSeparator ();
+
+		Gui->AppendToMenu (popup, _("Add/Remove Keyfiles to/from Volume..."), this, wxCommandEventHandler (MainFrame::OnChangeKeyfilesMenuItemSelected));
+		Gui->AppendToMenu (popup, _("Remove All Keyfiles from Volume..."), this, wxCommandEventHandler (MainFrame::OnRemoveKeyfilesMenuItemSelected));
+
+		popup.AppendSeparator ();
+
+		Gui->AppendToMenu (popup, _("Change Header Key Derivation Algorithm..."), this, wxCommandEventHandler (MainFrame::OnChangePkcs5PrfMenuItemSelected));
+
+		popup.AppendSeparator ();
+
+		Gui->AppendToMenu (popup, _("Backup Volume Header..."), this, wxCommandEventHandler (MainFrame::OnBackupVolumeHeadersMenuItemSelected));
+		Gui->AppendToMenu (popup, _("Restore Volume Header..."), this, wxCommandEventHandler (MainFrame::OnRestoreVolumeHeaderMenuItemSelected));
+
+		PopupMenu (&popup, VolumeToolsButton->GetPosition().x + 2, VolumeToolsButton->GetPosition().y + 2);
+	}
+
+	void MainFrame::OnWipeCacheButtonClick (wxCommandEvent& event)
+	{
+		WipeCache();
+		Gui->ShowInfo ("PASSWORD_CACHE_WIPED");
+	}
+	
+	void MainFrame::OpenSelectedVolume () const
+	{
+		shared_ptr <VolumeInfo> selectedVolume = GetSelectedVolume();
+		if (selectedVolume)
+		{
+			try
+			{
+				wxBusyCursor busy;
+				Gui->OpenExplorerWindow (selectedVolume->MountPoint);
+			}
+			catch (exception &e)
+			{
+				Gui->ShowError (e);
+			}
+		}
+	}
+
+	void MainFrame::OrganizeFavorites (const FavoriteVolumeList &favorites, size_t newItemCount)
+	{
+		FavoriteVolumesDialog dialog (this, favorites, newItemCount);
+
+		if (dialog.ShowModal() == wxID_OK)
+		{
+			FavoriteVolume::SaveList (dialog.GetFavorites());
+			LoadFavoriteVolumes();
+		}
+	}
+
+	void MainFrame::SavePreferences () const
+	{
+		try
+		{
+			UserPreferences prefs = GetPreferences();
+			prefs.LastSelectedSlotNumber = SelectedSlotNumber;
+			prefs.Save();
+
+			VolumeHistory::Save();
+		}
+		catch (exception &e)
+		{
+			if (!Core->IsInPortableMode())
+				Gui->ShowError (e);
+		}
+	}
+
+	void MainFrame::ShowTaskBarIcon (bool show)
+	{
+		if (!show && mTaskBarIcon->IsIconInstalled())
+		{
+			mTaskBarIcon->RemoveIcon();
+		}
+		else if (show && !mTaskBarIcon->IsIconInstalled())
+		{
+#ifndef TC_MACOSX
+			mTaskBarIcon->SetIcon (Resources::GetTrueCryptIcon(), L"TrueCrypt");
+#endif
+		}
+	}
+
+	long MainFrame::SlotNumberToItemIndex (uint32 slotNumber) const
+	{
+		for (long itemIndex = 0; itemIndex < SlotListCtrl->GetItemCount(); itemIndex++)
+		{
+			wxListItem item;
+			item.SetId (itemIndex);
+			if (slotNumber == (uint32) SlotListCtrl->GetItemData (item))
+				return itemIndex;
+		}
+		return -1;
+	}
+	
+	void MainFrame::UpdateControls ()
+	{
+		bool mounted = IsMountedSlotSelected();
+
+		VolumeButton->SetLabel (mounted ? LangString["DISMOUNT"] : wxString (_("Mount")));
+		VolumePropertiesButton->Enable (mounted);
+
+		DismountVolumeMenuItem->Enable (mounted); 
+		MountVolumeMenuItem->Enable (!mounted);
+		VolumePropertiesMenuItem->Enable (mounted);
+		AddToFavoritesMenuItem->Enable (mounted);
+		AddAllMountedToFavoritesMenuItem->Enable (!MountedVolumes.empty());
+		UpdateWipeCacheButton();
+	}
+
+	void MainFrame::UpdateVolumeList ()
+	{
+		static Mutex mutex;
+		ScopeLock lock (mutex);
+
+		bool listChanged = false;
+
+		MountedVolumes = Core->GetMountedVolumes();
+		
+		map < VolumeSlotNumber, shared_ptr <VolumeInfo> > mountedVolumesMap;
+		foreach (shared_ptr <VolumeInfo> volume, MountedVolumes)
+		{
+			mountedVolumesMap[volume->SlotNumber] = volume;
+		}
+
+		VolumeInfoList protectionTriggeredVolumes;
+
+		// Update list
+		long prevItemIndex = -1;
+		for (VolumeSlotNumber slotNumber = Core->GetFirstSlotNumber(); slotNumber <= Core->GetLastSlotNumber(); ++slotNumber)
+		{
+			long itemIndex = SlotNumberToItemIndex (slotNumber);
+			vector <wstring> fields (SlotListCtrl->GetColumnCount());
+
+			if (mountedVolumesMap.find (slotNumber) != mountedVolumesMap.end())
+			{
+				shared_ptr <VolumeInfo> volume = mountedVolumesMap[slotNumber];
+
+#ifdef TC_WINDOWS
+				fields[ColumnSlot] = volume->MountPoint;
+				fields[ColumnEA] = volume->EncryptionAlgorithmName;
+#else
+				fields[ColumnSlot] = StringConverter::FromNumber (slotNumber);
+				fields[ColumnMountPoint] = volume->MountPoint;
+#endif
+				fields[ColumnPath] = volume->Path;
+				fields[ColumnSize] = Gui->SizeToString (volume->Size);
+				fields[ColumnType] = Gui->VolumeTypeToString (volume->Type, volume->Protection);
+				
+				if (volume->HiddenVolumeProtectionTriggered)
+				{
+					fields[ColumnType] += L"(!)";
+				}
+
+				bool slotUpdated = false;
+				if (itemIndex == -1)
+				{
+					Gui->InsertToListCtrl (SlotListCtrl, ++prevItemIndex, fields, 0, (void *) volume->SlotNumber);
+					OnListItemInserted (prevItemIndex);
+
+					listChanged |= true;
+					slotUpdated = true;
+				}
+				else
+				{
+					if (Gui->UpdateListCtrlItem (SlotListCtrl, itemIndex, fields))
+					{
+						listChanged = true;
+						slotUpdated = true;
+					}
+					prevItemIndex = itemIndex;
+				}
+
+				if (slotUpdated && volume->HiddenVolumeProtectionTriggered)
+					protectionTriggeredVolumes.push_back (volume);
+			}
+			else
+			{
+#ifdef TC_WINDOWS
+				fields[ColumnSlot] = Core->SlotNumberToMountPoint (slotNumber);
+#else
+				fields[ColumnSlot] = StringConverter::FromNumber (slotNumber);
+#endif
+				
+#ifdef TC_WINDOWS
+				if (Core->IsMountPointAvailable (fields[ColumnSlot]))
+#else
+				if (true)
+#endif
+				{
+					if (itemIndex == -1)
+					{
+						Gui->InsertToListCtrl (SlotListCtrl, ++prevItemIndex, fields, 0, (void *) slotNumber);
+						OnListItemInserted (prevItemIndex);
+						listChanged |= true;
+					}
+					else
+					{
+						listChanged |= Gui->UpdateListCtrlItem (SlotListCtrl, itemIndex, fields);
+						prevItemIndex = itemIndex;
+					}
+				}
+				else if (itemIndex != -1)
+				{
+					SlotListCtrl->DeleteItem (itemIndex);
+					OnListItemDeleted (itemIndex);
+					listChanged = true;
+				}
+			}
+		}
+
+		if (listChanged)
+			OnListChanged();
+
+		foreach (shared_ptr <VolumeInfo> volume, protectionTriggeredVolumes)
+			OnHiddenVolumeProtectionTriggered (volume);
+	}
+
+	void MainFrame::UpdateWipeCacheButton ()
+	{
+		bool enabled = WipeCacheButton->IsEnabled();
+		bool empty = Core->IsPasswordCacheEmpty();
+
+		if (empty && enabled)
+		{
+			WipeCacheButton->Disable();
+			WipeCachedPasswordsMenuItem->Enable (false);
+		}
+		else if (!empty && !enabled)
+		{
+			WipeCacheButton->Enable();
+			WipeCachedPasswordsMenuItem->Enable();
+		}
+	}
+
+	void MainFrame::WipeCache ()
+	{
+		Core->WipePasswordCache();
+		UpdateWipeCacheButton();
+	}
+}