mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1021 lines
40 KiB
C#
1021 lines
40 KiB
C#
// /***************************************************************************
|
|
// The Disc Image Chef
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : frmMain.xeto.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : Main window.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// Implements main GUI window.
|
|
//
|
|
// --[ License ] --------------------------------------------------------------
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General public License as
|
|
// published by the Free Software Foundation, either version 3 of the
|
|
// License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// Copyright © 2011-2020 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using DiscImageChef.CommonTypes;
|
|
using DiscImageChef.CommonTypes.Enums;
|
|
using DiscImageChef.CommonTypes.Interfaces;
|
|
using DiscImageChef.CommonTypes.Structs;
|
|
using DiscImageChef.Console;
|
|
using DiscImageChef.Core;
|
|
using DiscImageChef.Core.Media.Info;
|
|
using DiscImageChef.Database;
|
|
using DiscImageChef.Decoders.SCSI;
|
|
using DiscImageChef.Devices;
|
|
using DiscImageChef.Gui.Dialogs;
|
|
using DiscImageChef.Gui.Panels;
|
|
using DiscImageChef.Settings;
|
|
using Eto.Drawing;
|
|
using Eto.Forms;
|
|
using Eto.Serialization.Xaml;
|
|
using FileAttributes = DiscImageChef.CommonTypes.Structs.FileAttributes;
|
|
using ImageFormat = DiscImageChef.Core.ImageFormat;
|
|
|
|
namespace DiscImageChef.Gui.Forms
|
|
{
|
|
public class frmMain : Form
|
|
{
|
|
readonly Bitmap devicesIcon;
|
|
readonly Bitmap ejectIcon;
|
|
readonly Bitmap hardDiskIcon;
|
|
readonly Bitmap imagesIcon;
|
|
readonly Label lblError;
|
|
/// <summary>This is to remember that column is an image to be set in future</summary>
|
|
readonly Image nullImage;
|
|
readonly Bitmap opticalIcon;
|
|
readonly TreeGridItem placeholderItem;
|
|
readonly Bitmap removableIcon;
|
|
readonly Bitmap sdIcon;
|
|
readonly Bitmap tapeIcon;
|
|
readonly TreeGridItemCollection treeImagesItems;
|
|
readonly ContextMenu treeImagesMenu;
|
|
readonly Bitmap usbIcon;
|
|
bool closing;
|
|
GridView grdFiles;
|
|
TreeGridView treeImages;
|
|
|
|
public frmMain(bool debug, bool verbose)
|
|
{
|
|
XamlReader.Load(this);
|
|
|
|
lblError = new Label();
|
|
grdFiles = new GridView();
|
|
nullImage = null;
|
|
|
|
ConsoleHandler.Init();
|
|
ConsoleHandler.Debug = debug;
|
|
ConsoleHandler.Verbose = verbose;
|
|
|
|
treeImagesItems = new TreeGridItemCollection();
|
|
|
|
treeImages.Columns.Add(new GridColumn
|
|
{
|
|
HeaderText = "Name", DataCell = new ImageTextCell(0, 1)
|
|
});
|
|
|
|
treeImages.AllowMultipleSelection = false;
|
|
treeImages.ShowHeader = false;
|
|
treeImages.DataStore = treeImagesItems;
|
|
|
|
// TODO: SVG
|
|
imagesIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.inode-directory.png"));
|
|
|
|
devicesIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.computer.png"));
|
|
|
|
hardDiskIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.drive-harddisk.png"));
|
|
|
|
opticalIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.drive-optical.png"));
|
|
|
|
usbIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.drive-removable-media-usb.png"));
|
|
|
|
removableIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.drive-removable-media.png"));
|
|
|
|
sdIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.media-flash-sd-mmc.png"));
|
|
|
|
tapeIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.media-tape.png"));
|
|
|
|
ejectIcon =
|
|
new Bitmap(ResourceHandler.
|
|
GetResourceStream("DiscImageChef.Gui.Assets.Icons.oxygen._32x32.media-eject.png"));
|
|
|
|
imagesRoot = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
imagesIcon, "Images"
|
|
}
|
|
};
|
|
|
|
devicesRoot = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
devicesIcon, "Devices"
|
|
}
|
|
};
|
|
|
|
treeImagesItems.Add(imagesRoot);
|
|
treeImagesItems.Add(devicesRoot);
|
|
|
|
placeholderItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, "You should not be seeing this"
|
|
}
|
|
};
|
|
|
|
Closing += OnClosing;
|
|
|
|
treeImagesMenu = new ContextMenu();
|
|
treeImagesMenu.Opening += OnTreeImagesMenuOpening;
|
|
treeImages.ContextMenu = treeImagesMenu;
|
|
}
|
|
|
|
void OnTreeImagesMenuOpening(object sender, EventArgs e)
|
|
{
|
|
OnTreeImagesSelectedItemChanged(treeImages, e);
|
|
|
|
treeImagesMenu.Items.Clear();
|
|
|
|
var menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Close all images"
|
|
};
|
|
|
|
menuItem.Click += CloseAllImages;
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Refresh devices"
|
|
};
|
|
|
|
menuItem.Click += OnDeviceRefresh;
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
if(!(treeImages.SelectedItem is TreeGridItem selectedItem))
|
|
return;
|
|
|
|
if(selectedItem.Values.Length < 4)
|
|
return;
|
|
|
|
if(selectedItem.Values[3] is pnlImageInfo imageInfo)
|
|
{
|
|
var image = selectedItem.Values[5] as IMediaImage;
|
|
|
|
// TODO: Global pool of forms
|
|
treeImagesMenu.Items.Add(new SeparatorMenuItem());
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Calculate entropy"
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmImageEntropy(image).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Verify"
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmImageVerify(image).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Checksum"
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmImageChecksum(image).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Convert to..."
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmImageConvert(image, selectedItem.Values[2] as string).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Create CICM XML sidecar..."
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
// TODO: Pass thru chosen default encoding
|
|
new frmImageSidecar(image, selectedItem.Values[2] as string, ((IFilter)selectedItem.Values[4]).Id,
|
|
null).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "View sectors"
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmPrintHex(image).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
|
|
if(!image.Info.ReadableMediaTags.Any())
|
|
return;
|
|
|
|
menuItem = new ButtonMenuItem
|
|
{
|
|
Text = "Decode media tags"
|
|
};
|
|
|
|
menuItem.Click += (a, b) =>
|
|
{
|
|
new frmDecodeMediaTags(image).Show();
|
|
};
|
|
|
|
treeImagesMenu.Items.Add(menuItem);
|
|
}
|
|
}
|
|
|
|
// TODO
|
|
void CloseAllImages(object sender, EventArgs eventArgs) => MessageBox.Show("Not yet implemented");
|
|
|
|
protected override void OnLoad(EventArgs e)
|
|
{
|
|
base.OnLoad(e);
|
|
|
|
if(Settings.Settings.Current.GdprCompliance < DicSettings.GdprLevel)
|
|
new dlgSettings(true).ShowModal(this);
|
|
}
|
|
|
|
void OnClosing(object sender, CancelEventArgs e)
|
|
{
|
|
// This prevents an infinite loop of crashes :p
|
|
if(closing)
|
|
return;
|
|
|
|
closing = true;
|
|
Application.Instance.Quit();
|
|
}
|
|
|
|
protected void OnMenuOpen(object sender, EventArgs e)
|
|
{
|
|
// TODO: Extensions
|
|
var dlgOpenImage = new OpenFileDialog
|
|
{
|
|
Title = "Choose image to open"
|
|
};
|
|
|
|
DialogResult result = dlgOpenImage.ShowDialog(this);
|
|
|
|
if(result != DialogResult.Ok)
|
|
return;
|
|
|
|
var filtersList = new FiltersList();
|
|
IFilter inputFilter = filtersList.GetFilter(dlgOpenImage.FileName);
|
|
|
|
if(inputFilter == null)
|
|
{
|
|
MessageBox.Show("Cannot open specified file.", MessageBoxType.Error);
|
|
|
|
return;
|
|
}
|
|
|
|
try
|
|
{
|
|
IMediaImage imageFormat = ImageFormat.Detect(inputFilter);
|
|
|
|
if(imageFormat == null)
|
|
{
|
|
MessageBox.Show("Image format not identified.", MessageBoxType.Error);
|
|
|
|
return;
|
|
}
|
|
|
|
DicConsole.WriteLine("Image format identified by {0} ({1}).", imageFormat.Name, imageFormat.Id);
|
|
|
|
try
|
|
{
|
|
if(!imageFormat.Open(inputFilter))
|
|
{
|
|
MessageBox.Show("Unable to open image format", MessageBoxType.Error);
|
|
DicConsole.ErrorWriteLine("Unable to open image format");
|
|
DicConsole.ErrorWriteLine("No error given");
|
|
|
|
return;
|
|
}
|
|
|
|
// TODO: SVG
|
|
Stream logo =
|
|
ResourceHandler.
|
|
GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{imageFormat.Info.MediaType}.png");
|
|
|
|
var imageGridItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
logo == null ? null : new Bitmap(logo),
|
|
$"{Path.GetFileName(dlgOpenImage.FileName)} ({imageFormat.Info.MediaType})",
|
|
dlgOpenImage.FileName, new pnlImageInfo(dlgOpenImage.FileName, inputFilter, imageFormat),
|
|
inputFilter, imageFormat
|
|
}
|
|
};
|
|
|
|
List<Partition> partitions = Core.Partitions.GetAll(imageFormat);
|
|
Core.Partitions.AddSchemesToStats(partitions);
|
|
|
|
bool checkraw = false;
|
|
List<string> idPlugins;
|
|
IFilesystem plugin;
|
|
PluginBase plugins = GetPluginBase.Instance;
|
|
|
|
if(partitions.Count == 0)
|
|
{
|
|
DicConsole.DebugWriteLine("Analyze command", "No partitions found");
|
|
|
|
checkraw = true;
|
|
}
|
|
else
|
|
{
|
|
DicConsole.WriteLine("{0} partitions found.", partitions.Count);
|
|
|
|
foreach(string scheme in partitions.Select(p => p.Scheme).Distinct().OrderBy(s => s))
|
|
{
|
|
var schemeGridItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, // TODO: Add icons to partition schemes
|
|
scheme
|
|
}
|
|
};
|
|
|
|
foreach(Partition partition in partitions.
|
|
Where(p => p.Scheme == scheme).OrderBy(p => p.Start))
|
|
{
|
|
var partitionGridItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, // TODO: Add icons to partition schemes
|
|
$"{partition.Name} ({partition.Type})", null, new pnlPartition(partition)
|
|
}
|
|
};
|
|
|
|
DicConsole.WriteLine("Identifying filesystem on partition");
|
|
|
|
Core.Filesystems.Identify(imageFormat, out idPlugins, partition);
|
|
|
|
if(idPlugins.Count == 0)
|
|
DicConsole.WriteLine("Filesystem not identified");
|
|
else
|
|
{
|
|
DicConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
|
|
|
|
foreach(string pluginName in idPlugins)
|
|
if(plugins.PluginsList.TryGetValue(pluginName, out plugin))
|
|
{
|
|
plugin.GetInformation(imageFormat, partition, out string information, null);
|
|
|
|
var fsPlugin = plugin as IReadOnlyFilesystem;
|
|
|
|
if(fsPlugin != null)
|
|
{
|
|
Errno error =
|
|
fsPlugin.Mount(imageFormat, partition, null,
|
|
new Dictionary<string, string>(), null);
|
|
|
|
if(error != Errno.NoError)
|
|
fsPlugin = null;
|
|
}
|
|
|
|
var filesystemGridItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, // TODO: Add icons to filesystems
|
|
plugin.XmlFsType.VolumeName is null ? $"{plugin.XmlFsType.Type}"
|
|
: $"{plugin.XmlFsType.VolumeName} ({plugin.XmlFsType.Type})",
|
|
fsPlugin, new pnlFilesystem(plugin.XmlFsType, information)
|
|
}
|
|
};
|
|
|
|
if(fsPlugin != null)
|
|
{
|
|
Statistics.AddCommand("ls");
|
|
filesystemGridItem.Children.Add(placeholderItem);
|
|
}
|
|
|
|
Statistics.AddFilesystem(plugin.XmlFsType.Type);
|
|
partitionGridItem.Children.Add(filesystemGridItem);
|
|
}
|
|
}
|
|
|
|
schemeGridItem.Children.Add(partitionGridItem);
|
|
}
|
|
|
|
imageGridItem.Children.Add(schemeGridItem);
|
|
}
|
|
}
|
|
|
|
if(checkraw)
|
|
{
|
|
var wholePart = new Partition
|
|
{
|
|
Name = "Whole device", Length = imageFormat.Info.Sectors,
|
|
Size = imageFormat.Info.Sectors * imageFormat.Info.SectorSize
|
|
};
|
|
|
|
Core.Filesystems.Identify(imageFormat, out idPlugins, wholePart);
|
|
|
|
if(idPlugins.Count == 0)
|
|
DicConsole.WriteLine("Filesystem not identified");
|
|
else
|
|
{
|
|
DicConsole.WriteLine($"Identified by {idPlugins.Count} plugins");
|
|
|
|
foreach(string pluginName in idPlugins)
|
|
if(plugins.PluginsList.TryGetValue(pluginName, out plugin))
|
|
{
|
|
plugin.GetInformation(imageFormat, wholePart, out string information, null);
|
|
|
|
var fsPlugin = plugin as IReadOnlyFilesystem;
|
|
|
|
if(fsPlugin != null)
|
|
{
|
|
Errno error = fsPlugin.Mount(imageFormat, wholePart, null,
|
|
new Dictionary<string, string>(), null);
|
|
|
|
if(error != Errno.NoError)
|
|
fsPlugin = null;
|
|
}
|
|
|
|
var filesystemGridItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, // TODO: Add icons to filesystems
|
|
plugin.XmlFsType.VolumeName is null ? $"{plugin.XmlFsType.Type}"
|
|
: $"{plugin.XmlFsType.VolumeName} ({plugin.XmlFsType.Type})",
|
|
fsPlugin, new pnlFilesystem(plugin.XmlFsType, information)
|
|
}
|
|
};
|
|
|
|
if(fsPlugin != null)
|
|
{
|
|
Statistics.AddCommand("ls");
|
|
filesystemGridItem.Children.Add(placeholderItem);
|
|
}
|
|
|
|
Statistics.AddFilesystem(plugin.XmlFsType.Type);
|
|
imageGridItem.Children.Add(filesystemGridItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
imagesRoot.Children.Add(imageGridItem);
|
|
treeImages.ReloadData();
|
|
|
|
Statistics.AddMediaFormat(imageFormat.Format);
|
|
Statistics.AddMedia(imageFormat.Info.MediaType, false);
|
|
Statistics.AddFilter(inputFilter.Name);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
MessageBox.Show("Unable to open image format", MessageBoxType.Error);
|
|
DicConsole.ErrorWriteLine("Unable to open image format");
|
|
DicConsole.ErrorWriteLine("Error: {0}", ex.Message);
|
|
DicConsole.DebugWriteLine("Image-info command", "Stack trace: {0}", ex.StackTrace);
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
MessageBox.Show("Exception reading file", MessageBoxType.Error);
|
|
DicConsole.ErrorWriteLine($"Error reading file: {ex.Message}");
|
|
DicConsole.DebugWriteLine("Image-info command", ex.StackTrace);
|
|
}
|
|
|
|
Statistics.AddCommand("image-info");
|
|
}
|
|
|
|
protected void OnMenuAbout(object sender, EventArgs e)
|
|
{
|
|
var dlgAbout = new AboutDialog
|
|
{
|
|
Developers = new[]
|
|
{
|
|
"Natalia Portillo", "Michael Drüing"
|
|
},
|
|
License = "This program is free software: you can redistribute it and/or modify\n" +
|
|
"it under the terms of the GNU General public License as\n" +
|
|
"published by the Free Software Foundation, either version 3 of the\n" +
|
|
"License, or (at your option) any later version.\n\n" +
|
|
"This program is distributed in the hope that it will be useful,\n" +
|
|
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n" +
|
|
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" +
|
|
"GNU General public License for more details.\n\n" +
|
|
"You should have received a copy of the GNU General public License\n" +
|
|
"along with this program. If not, see <http://www.gnu.org/licenses/>.",
|
|
ProgramName = "The Disc Image Chef", Website = new Uri("https://github.com/claunia"),
|
|
WebsiteLabel = "Source code on..."
|
|
};
|
|
|
|
dlgAbout.ShowDialog(this);
|
|
}
|
|
|
|
protected void OnMenuQuit(object sender, EventArgs e) => Application.Instance.Quit();
|
|
|
|
protected void OnDeviceRefresh(object sender, EventArgs e) => RefreshDevices();
|
|
|
|
protected void OnMenuSettings(object sender, EventArgs e) => new dlgSettings(false).ShowModal(this);
|
|
|
|
protected override void OnLoadComplete(EventArgs e)
|
|
{
|
|
base.OnLoadComplete(e);
|
|
|
|
RefreshDevices();
|
|
}
|
|
|
|
void RefreshDevices()
|
|
{
|
|
try
|
|
{
|
|
DicConsole.WriteLine("Refreshing devices");
|
|
devicesRoot.Children.Clear();
|
|
|
|
foreach(DeviceInfo device in Device.ListDevices().Where(d => d.Supported).OrderBy(d => d.Vendor).
|
|
ThenBy(d => d.Model))
|
|
{
|
|
DicConsole.DebugWriteLine("Main window",
|
|
"Found supported device model {0} by manufacturer {1} on bus {2} and path {3}",
|
|
device.Model, device.Vendor, device.Bus, device.Path);
|
|
|
|
var devItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
hardDiskIcon, $"{device.Vendor} {device.Model} ({device.Bus})", device.Path, null
|
|
}
|
|
};
|
|
|
|
try
|
|
{
|
|
var dev = new Device(device.Path);
|
|
|
|
if(dev.IsRemote)
|
|
Statistics.AddRemote(dev.RemoteApplication, dev.RemoteVersion, dev.RemoteOperatingSystem,
|
|
dev.RemoteOperatingSystemVersion, dev.RemoteArchitecture);
|
|
|
|
switch(dev.Type)
|
|
{
|
|
case DeviceType.ATAPI:
|
|
case DeviceType.SCSI:
|
|
switch(dev.ScsiType)
|
|
{
|
|
case PeripheralDeviceTypes.DirectAccess:
|
|
case PeripheralDeviceTypes.SCSIZonedBlockDevice:
|
|
case PeripheralDeviceTypes.SimplifiedDevice:
|
|
devItem.Values[0] = dev.IsRemovable ? dev.IsUsb
|
|
? usbIcon
|
|
: removableIcon : hardDiskIcon;
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.SequentialAccess:
|
|
devItem.Values[0] = tapeIcon;
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.OpticalDevice:
|
|
case PeripheralDeviceTypes.WriteOnceDevice:
|
|
case PeripheralDeviceTypes.OCRWDevice:
|
|
devItem.Values[0] = removableIcon;
|
|
|
|
break;
|
|
case PeripheralDeviceTypes.MultiMediaDevice:
|
|
devItem.Values[0] = opticalIcon;
|
|
|
|
break;
|
|
}
|
|
|
|
break;
|
|
case DeviceType.SecureDigital:
|
|
case DeviceType.MMC:
|
|
devItem.Values[0] = sdIcon;
|
|
|
|
break;
|
|
case DeviceType.NVMe:
|
|
devItem.Values[0] = nullImage;
|
|
|
|
break;
|
|
}
|
|
|
|
dev.Close();
|
|
}
|
|
catch
|
|
{
|
|
// ignored
|
|
}
|
|
|
|
devItem.Children.Add(placeholderItem);
|
|
devicesRoot.Children.Add(devItem);
|
|
}
|
|
|
|
treeImages.ReloadData();
|
|
}
|
|
catch(InvalidOperationException ex)
|
|
{
|
|
DicConsole.ErrorWriteLine(ex.Message);
|
|
}
|
|
}
|
|
|
|
protected void OnMenuConsole(object sender, EventArgs e) => new frmConsole().Show();
|
|
|
|
protected void OnMenuPlugins(object sender, EventArgs e) => new dlgPlugins().ShowModal(this);
|
|
|
|
protected void OnMenuEncodings(object sender, EventArgs e) => new dlgEncodings().ShowModal(this);
|
|
|
|
protected void OnMenuStatistics(object sender, EventArgs e)
|
|
{
|
|
var ctx = DicContext.Create(Settings.Settings.LocalDbPath);
|
|
|
|
if(!ctx.Commands.Any() &&
|
|
!ctx.Filesystems.Any() &&
|
|
!ctx.Filters.Any() &&
|
|
!ctx.MediaFormats.Any() &&
|
|
!ctx.Medias.Any() &&
|
|
!ctx.Partitions.Any() &&
|
|
!ctx.SeenDevices.Any())
|
|
{
|
|
MessageBox.Show("There are no statistics.");
|
|
|
|
return;
|
|
}
|
|
|
|
new dlgStatistics().ShowModal(this);
|
|
}
|
|
|
|
protected void OnTreeImagesSelectedItemChanged(object sender, EventArgs e)
|
|
{
|
|
if(!(sender is TreeGridView tree))
|
|
return;
|
|
|
|
if(!(tree.SelectedItem is TreeGridItem selectedItem))
|
|
return;
|
|
|
|
splMain.Panel2 = null;
|
|
|
|
if(selectedItem.Values.Length >= 4 &&
|
|
selectedItem.Values[3] is Panel infoPanel)
|
|
{
|
|
splMain.Panel2 = infoPanel;
|
|
|
|
return;
|
|
}
|
|
|
|
if(selectedItem.Values.Length < 4)
|
|
return;
|
|
|
|
switch(selectedItem.Values[3])
|
|
{
|
|
case null when selectedItem.Parent == devicesRoot:
|
|
try
|
|
{
|
|
var dev = new Device((string)selectedItem.Values[2]);
|
|
|
|
if(dev.IsRemote)
|
|
Statistics.AddRemote(dev.RemoteApplication, dev.RemoteVersion, dev.RemoteOperatingSystem,
|
|
dev.RemoteOperatingSystemVersion, dev.RemoteArchitecture);
|
|
|
|
if(dev.Error)
|
|
{
|
|
selectedItem.Values[3] = $"Error {dev.LastError} opening device";
|
|
|
|
return;
|
|
}
|
|
|
|
var devInfo = new Core.Devices.Info.DeviceInfo(dev);
|
|
|
|
selectedItem.Values[3] = new pnlDeviceInfo(devInfo);
|
|
splMain.Panel2 = (Panel)selectedItem.Values[3];
|
|
|
|
dev.Close();
|
|
}
|
|
catch(SystemException ex)
|
|
{
|
|
selectedItem.Values[3] = ex.Message;
|
|
lblError.Text = ex.Message;
|
|
splMain.Panel2 = lblError;
|
|
DicConsole.ErrorWriteLine(ex.Message);
|
|
}
|
|
|
|
break;
|
|
case string devErrorMessage when selectedItem.Parent == devicesRoot:
|
|
lblError.Text = devErrorMessage;
|
|
splMain.Panel2 = lblError;
|
|
|
|
break;
|
|
case Dictionary<string, FileEntryInfo> files:
|
|
splMain.Panel2 = new pnlListFiles(selectedItem.Values[2] as IReadOnlyFilesystem, files,
|
|
selectedItem.Values[1] as string == "/" ? "/"
|
|
: selectedItem.Values[4] as string);
|
|
|
|
break;
|
|
case null when selectedItem.Values.Length >= 5 && selectedItem.Values[4] is string dirPath &&
|
|
selectedItem.Values[2] is IReadOnlyFilesystem fsPlugin:
|
|
Errno errno = fsPlugin.ReadDir(dirPath, out List<string> dirents);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
MessageBox.Show($"Error {errno} trying to read \"{dirPath}\" of chosen filesystem",
|
|
MessageBoxType.Error);
|
|
|
|
break;
|
|
}
|
|
|
|
Dictionary<string, FileEntryInfo> filesNew = new Dictionary<string, FileEntryInfo>();
|
|
|
|
foreach(string dirent in dirents)
|
|
{
|
|
errno = fsPlugin.Stat(dirPath + "/" + dirent, out FileEntryInfo stat);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
DicConsole.
|
|
ErrorWriteLine($"Error {errno} trying to get information about filesystem entry named {dirent}");
|
|
|
|
continue;
|
|
}
|
|
|
|
if(!stat.Attributes.HasFlag(FileAttributes.Directory))
|
|
filesNew.Add(dirent, stat);
|
|
}
|
|
|
|
selectedItem.Values[3] = filesNew;
|
|
splMain.Panel2 = new pnlListFiles(fsPlugin, filesNew, dirPath);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
protected void OnTreeImagesItemExpanding(object sender, TreeGridViewItemCancelEventArgs e)
|
|
{
|
|
// First expansion of a device
|
|
if((e.Item as TreeGridItem)?.Children?.Count != 1 ||
|
|
((TreeGridItem)e.Item).Children[0] != placeholderItem)
|
|
return;
|
|
|
|
if(((TreeGridItem)e.Item).Parent == devicesRoot)
|
|
{
|
|
var deviceItem = (TreeGridItem)e.Item;
|
|
|
|
deviceItem.Children.Clear();
|
|
Device dev;
|
|
|
|
try
|
|
{
|
|
dev = new Device((string)deviceItem.Values[2]);
|
|
|
|
if(dev.IsRemote)
|
|
Statistics.AddRemote(dev.RemoteApplication, dev.RemoteVersion, dev.RemoteOperatingSystem,
|
|
dev.RemoteOperatingSystemVersion, dev.RemoteArchitecture);
|
|
|
|
if(dev.Error)
|
|
{
|
|
deviceItem.Values[3] = $"Error {dev.LastError} opening device";
|
|
e.Cancel = true;
|
|
treeImages.ReloadData();
|
|
treeImages.SelectedItem = deviceItem;
|
|
|
|
return;
|
|
}
|
|
}
|
|
catch(SystemException ex)
|
|
{
|
|
deviceItem.Values[3] = ex.Message;
|
|
e.Cancel = true;
|
|
treeImages.ReloadData();
|
|
DicConsole.ErrorWriteLine(ex.Message);
|
|
treeImages.SelectedItem = deviceItem;
|
|
|
|
return;
|
|
}
|
|
|
|
if(!dev.IsRemovable)
|
|
deviceItem.Children.Add(new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, "Non-removable device commands not yet implemented"
|
|
}
|
|
});
|
|
else
|
|
{
|
|
// TODO: Removable non-SCSI?
|
|
var scsiInfo = new ScsiInfo(dev);
|
|
|
|
if(!scsiInfo.MediaInserted)
|
|
deviceItem.Children.Add(new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
ejectIcon, "No media inserted"
|
|
}
|
|
});
|
|
else
|
|
{
|
|
// TODO: SVG
|
|
Stream logo =
|
|
ResourceHandler.
|
|
GetResourceStream($"DiscImageChef.Gui.Assets.Logos.Media.{scsiInfo.MediaType}.png");
|
|
|
|
deviceItem.Children.Add(new TreeGridItem
|
|
{
|
|
Values = new[]
|
|
{
|
|
logo == null ? null : new Bitmap(logo), scsiInfo.MediaType, deviceItem.Values[2],
|
|
new pnlScsiInfo(scsiInfo, (string)deviceItem.Values[2])
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
dev.Close();
|
|
}
|
|
else if(((TreeGridItem)e.Item).Values[2] is IReadOnlyFilesystem fsPlugin)
|
|
{
|
|
var fsItem = (TreeGridItem)e.Item;
|
|
|
|
fsItem.Children.Clear();
|
|
|
|
if(fsItem.Values.Length == 5 &&
|
|
fsItem.Values[4] is string dirPath)
|
|
{
|
|
Errno errno = fsPlugin.ReadDir(dirPath, out List<string> dirents);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
MessageBox.Show($"Error {errno} trying to read \"{dirPath}\" of chosen filesystem",
|
|
MessageBoxType.Error);
|
|
|
|
return;
|
|
}
|
|
|
|
List<string> directories = new List<string>();
|
|
|
|
foreach(string dirent in dirents)
|
|
{
|
|
errno = fsPlugin.Stat(dirPath + "/" + dirent, out FileEntryInfo stat);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
DicConsole.
|
|
ErrorWriteLine($"Error {errno} trying to get information about filesystem entry named {dirent}");
|
|
|
|
continue;
|
|
}
|
|
|
|
if(stat.Attributes.HasFlag(FileAttributes.Directory))
|
|
directories.Add(dirent);
|
|
}
|
|
|
|
foreach(string directory in directories)
|
|
{
|
|
var dirItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
imagesIcon, directory, fsPlugin, null, dirPath + "/" + directory
|
|
}
|
|
};
|
|
|
|
dirItem.Children.Add(placeholderItem);
|
|
fsItem.Children.Add(dirItem);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Errno errno = fsPlugin.ReadDir("/", out List<string> dirents);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
MessageBox.Show($"Error {errno} trying to read root directory of chosen filesystem",
|
|
MessageBoxType.Error);
|
|
|
|
return;
|
|
}
|
|
|
|
Dictionary<string, FileEntryInfo> files = new Dictionary<string, FileEntryInfo>();
|
|
List<string> directories = new List<string>();
|
|
|
|
foreach(string dirent in dirents)
|
|
{
|
|
errno = fsPlugin.Stat("/" + dirent, out FileEntryInfo stat);
|
|
|
|
if(errno != Errno.NoError)
|
|
{
|
|
DicConsole.
|
|
ErrorWriteLine($"Error {errno} trying to get information about filesystem entry named {dirent}");
|
|
|
|
continue;
|
|
}
|
|
|
|
if(stat.Attributes.HasFlag(FileAttributes.Directory))
|
|
directories.Add(dirent);
|
|
else
|
|
files.Add(dirent, stat);
|
|
}
|
|
|
|
var rootDirectoryItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
nullImage, // TODO: Get icon from volume
|
|
"/", fsPlugin, files
|
|
}
|
|
};
|
|
|
|
foreach(string directory in directories)
|
|
{
|
|
var dirItem = new TreeGridItem
|
|
{
|
|
Values = new object[]
|
|
{
|
|
imagesIcon, directory, fsPlugin, null, "/" + directory
|
|
}
|
|
};
|
|
|
|
dirItem.Children.Add(placeholderItem);
|
|
rootDirectoryItem.Children.Add(dirItem);
|
|
}
|
|
|
|
fsItem.Children.Add(rootDirectoryItem);
|
|
}
|
|
}
|
|
}
|
|
|
|
#region XAML IDs
|
|
readonly TreeGridItem devicesRoot;
|
|
readonly TreeGridItem imagesRoot;
|
|
Splitter splMain;
|
|
#endregion
|
|
}
|
|
} |