mirror of
https://github.com/aaru-dps/Aaru.git
synced 2025-12-16 19:24:25 +00:00
1017 lines
36 KiB
C#
1017 lines
36 KiB
C#
// /***************************************************************************
|
|
// Aaru Data Preservation Suite
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Filename : DeviceInfoViewModel.cs
|
|
// Author(s) : Natalia Portillo <claunia@claunia.com>
|
|
//
|
|
// Component : GUI view models.
|
|
//
|
|
// --[ Description ] ----------------------------------------------------------
|
|
//
|
|
// View model and code for the device information panel.
|
|
//
|
|
// --[ 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-2023 Natalia Portillo
|
|
// ****************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Reactive;
|
|
using System.Threading.Tasks;
|
|
using Aaru.Decoders.SCSI.SSC;
|
|
using Aaru.Devices;
|
|
using Aaru.Gui.ViewModels.Tabs;
|
|
using Aaru.Gui.Views.Tabs;
|
|
using Aaru.Localization;
|
|
using Avalonia.Controls;
|
|
using ReactiveUI;
|
|
using DeviceInfo = Aaru.Core.Devices.Info.DeviceInfo;
|
|
|
|
namespace Aaru.Gui.ViewModels.Panels;
|
|
|
|
public sealed class DeviceInfoViewModel : ViewModelBase
|
|
{
|
|
readonly DeviceInfo _devInfo;
|
|
readonly Window _view;
|
|
AtaInfo _ataInfo;
|
|
string _blockLimits;
|
|
string _blockSizeGranularity;
|
|
string _cid;
|
|
string _csd;
|
|
string _densities;
|
|
string _deviceType;
|
|
string _extendedCsd;
|
|
string _firewireGuid;
|
|
string _firewireManufacturer;
|
|
string _firewireModel;
|
|
string _firewireModelId;
|
|
string _firewireVendorId;
|
|
bool _firewireVisible;
|
|
bool _kreon;
|
|
bool _kreonChallengeResponse;
|
|
bool _kreonChallengeResponse360;
|
|
bool _kreonDecryptSs;
|
|
bool _kreonDecryptSs360;
|
|
bool _kreonErrorSkipping;
|
|
bool _kreonLock;
|
|
bool _kreonWxripperUnlock;
|
|
bool _kreonWxripperUnlock360;
|
|
bool _kreonXtremeUnlock;
|
|
bool _kreonXtremeUnlock360;
|
|
string _manufacturer;
|
|
string _maxBlockSize;
|
|
string _mediumDensity;
|
|
string _mediumTypes;
|
|
string _minBlockSize;
|
|
string _model;
|
|
string _ocr;
|
|
PcmciaInfo _pcmciaInfo;
|
|
bool _plextorBitSetting;
|
|
bool _plextorBitSettingDl;
|
|
string _plextorCdReadTime;
|
|
string _plextorCdWriteTime;
|
|
string _plextorDiscs;
|
|
string _plextorDvd;
|
|
bool _plextorDvdPlusWriteTest;
|
|
string _plextorDvdReadTime;
|
|
bool _plextorDvdTimesVisible;
|
|
string _plextorDvdWriteTime;
|
|
bool _plextorEepromVisible;
|
|
bool _plextorGigaRec;
|
|
bool _plextorHidesRecordables;
|
|
bool _plextorHidesSessions;
|
|
bool _plextorHiding;
|
|
bool _plextorPoweRec;
|
|
bool _plextorPoweRecEnabled;
|
|
string _plextorPoweRecLast;
|
|
bool _plextorPoweRecLastVisible;
|
|
string _plextorPoweRecMax;
|
|
bool _plextorPoweRecMaxVisible;
|
|
string _plextorPoweRecRecommended;
|
|
bool _plextorPoweRecRecommendedVisible;
|
|
string _plextorPoweRecSelected;
|
|
bool _plextorPoweRecSelectedVisible;
|
|
bool _plextorSecuRec;
|
|
bool _plextorSilentMode;
|
|
string _plextorSilentModeAccessTime;
|
|
string _plextorSilentModeCdReadSpeedLimit;
|
|
string _plextorSilentModeCdWriteSpeedLimit;
|
|
string _plextorSilentModeDvdReadSpeedLimit;
|
|
bool _plextorSilentModeDvdReadSpeedLimitVisible;
|
|
bool _plextorSilentModeEnabled;
|
|
bool _plextorSpeedEnabled;
|
|
bool _plextorSpeedRead;
|
|
bool _plextorVariRec;
|
|
bool _plextorVariRecDvd;
|
|
bool _plextorVisible;
|
|
bool _removable;
|
|
string _revision;
|
|
bool _saveUsbDescriptorsEnabled;
|
|
string _scr;
|
|
ScsiInfo _scsiInfo;
|
|
string _scsiType;
|
|
string _sdMm;
|
|
SdMmcInfo _sdMmcInfo;
|
|
string _secureDigital;
|
|
string _serial;
|
|
bool _ssc;
|
|
string _usbConnected;
|
|
string _usbManufacturer;
|
|
string _usbProduct;
|
|
string _usbProductId;
|
|
string _usbSerial;
|
|
string _usbVendorId;
|
|
bool _usbVisible;
|
|
|
|
public DeviceInfoViewModel(DeviceInfo devInfo, Window view)
|
|
{
|
|
SaveUsbDescriptorsCommand = ReactiveCommand.Create(ExecuteSaveUsbDescriptorsCommand);
|
|
_view = view;
|
|
_devInfo = devInfo;
|
|
|
|
DeviceType = devInfo.Type.ToString();
|
|
Manufacturer = devInfo.Manufacturer;
|
|
Model = devInfo.Model;
|
|
Revision = devInfo.FirmwareRevision;
|
|
Serial = devInfo.Serial;
|
|
ScsiType = devInfo.ScsiType.ToString();
|
|
Removable = devInfo.IsRemovable;
|
|
UsbVisible = devInfo.IsUsb;
|
|
|
|
if(devInfo.IsUsb)
|
|
{
|
|
UsbVisible = true;
|
|
SaveUsbDescriptorsEnabled = devInfo.UsbDescriptors != null;
|
|
UsbVendorId = $"{devInfo.UsbVendorId:X4}";
|
|
UsbProductId = $"{devInfo.UsbProductId:X4}";
|
|
UsbManufacturer = devInfo.UsbManufacturerString;
|
|
UsbProduct = devInfo.UsbProductString;
|
|
UsbSerial = devInfo.UsbSerialString;
|
|
}
|
|
|
|
if(devInfo.IsFireWire)
|
|
{
|
|
FirewireVisible = true;
|
|
FirewireVendorId = $"{devInfo.FireWireVendor:X4}";
|
|
FirewireModelId = $"{devInfo.FireWireModel:X4}";
|
|
FirewireManufacturer = devInfo.FireWireVendorName;
|
|
FirewireModel = devInfo.FireWireModelName;
|
|
FirewireGuid = $"{devInfo.FireWireGuid:X16}";
|
|
}
|
|
|
|
if(devInfo.IsPcmcia)
|
|
PcmciaInfo = new PcmciaInfo
|
|
{
|
|
DataContext = new PcmciaInfoViewModel(devInfo.Cis, _view)
|
|
};
|
|
|
|
if(devInfo.AtaIdentify != null ||
|
|
devInfo.AtapiIdentify != null)
|
|
AtaInfo = new AtaInfo
|
|
{
|
|
DataContext =
|
|
new AtaInfoViewModel(devInfo.AtaIdentify, devInfo.AtapiIdentify, devInfo.AtaMcptError, _view)
|
|
};
|
|
|
|
if(devInfo.ScsiInquiryData != null)
|
|
{
|
|
ScsiInfo = new ScsiInfo
|
|
{
|
|
DataContext = new ScsiInfoViewModel(devInfo.ScsiInquiryData, devInfo.ScsiInquiry, devInfo.ScsiEvpdPages,
|
|
devInfo.ScsiMode, devInfo.ScsiType, devInfo.ScsiModeSense6,
|
|
devInfo.ScsiModeSense10, devInfo.MmcConfiguration, _view)
|
|
};
|
|
|
|
if(devInfo.PlextorFeatures != null)
|
|
{
|
|
PlextorVisible = true;
|
|
|
|
if(devInfo.PlextorFeatures.Eeprom != null)
|
|
{
|
|
PlextorEepromVisible = true;
|
|
PlextorDiscs = $"{devInfo.PlextorFeatures.Discs}";
|
|
PlextorCdReadTime = TimeSpan.FromSeconds(devInfo.PlextorFeatures.CdReadTime).ToString();
|
|
|
|
PlextorCdWriteTime = TimeSpan.FromSeconds(devInfo.PlextorFeatures.CdWriteTime).ToString();
|
|
|
|
if(devInfo.PlextorFeatures.IsDvd)
|
|
{
|
|
PlextorDvdTimesVisible = true;
|
|
|
|
PlextorDvdReadTime = TimeSpan.FromSeconds(devInfo.PlextorFeatures.DvdReadTime).ToString();
|
|
|
|
PlextorDvdWriteTime = TimeSpan.FromSeconds(devInfo.PlextorFeatures.DvdWriteTime).ToString();
|
|
}
|
|
}
|
|
|
|
PlextorPoweRec = devInfo.PlextorFeatures.PoweRec;
|
|
|
|
if(devInfo.PlextorFeatures.PoweRec)
|
|
{
|
|
PlextorPoweRecEnabled = devInfo.PlextorFeatures.PoweRecEnabled;
|
|
|
|
if(devInfo.PlextorFeatures.PoweRecEnabled)
|
|
{
|
|
PlextorPoweRecEnabled = true;
|
|
|
|
if(devInfo.PlextorFeatures.PoweRecRecommendedSpeed > 0)
|
|
{
|
|
PlextorPoweRecRecommendedVisible = true;
|
|
|
|
PlextorPoweRecRecommended =
|
|
string.Format(UI._0_Kb_sec, devInfo.PlextorFeatures.PoweRecRecommendedSpeed);
|
|
}
|
|
|
|
if(devInfo.PlextorFeatures.PoweRecSelected > 0)
|
|
{
|
|
PlextorPoweRecSelectedVisible = true;
|
|
|
|
PlextorPoweRecSelected =
|
|
string.Format(UI._0_Kb_sec, devInfo.PlextorFeatures.PoweRecSelected);
|
|
}
|
|
|
|
if(devInfo.PlextorFeatures.PoweRecMax > 0)
|
|
{
|
|
PlextorPoweRecMaxVisible = true;
|
|
PlextorPoweRecMax = string.Format(UI._0_Kb_sec, devInfo.PlextorFeatures.PoweRecMax);
|
|
}
|
|
|
|
if(devInfo.PlextorFeatures.PoweRecLast > 0)
|
|
{
|
|
PlextorPoweRecLastVisible = true;
|
|
PlextorPoweRecLast = string.Format(UI._0_Kb_sec, devInfo.PlextorFeatures.PoweRecLast);
|
|
}
|
|
}
|
|
}
|
|
|
|
PlextorSilentMode = devInfo.PlextorFeatures.SilentMode;
|
|
|
|
if(devInfo.PlextorFeatures.SilentMode)
|
|
{
|
|
PlextorSilentModeEnabled = devInfo.PlextorFeatures.SilentModeEnabled;
|
|
|
|
if(devInfo.PlextorFeatures.SilentModeEnabled)
|
|
{
|
|
PlextorSilentModeAccessTime = devInfo.PlextorFeatures.AccessTimeLimit == 2
|
|
? Localization.Core.Access_time_is_slow
|
|
: Localization.Core.Access_time_is_fast;
|
|
|
|
PlextorSilentModeCdReadSpeedLimit =
|
|
devInfo.PlextorFeatures.CdReadSpeedLimit > 0
|
|
? $"{devInfo.PlextorFeatures.CdReadSpeedLimit}x" : UI.unlimited_as_in_speed;
|
|
|
|
PlextorSilentModeCdWriteSpeedLimit =
|
|
devInfo.PlextorFeatures.CdWriteSpeedLimit > 0
|
|
? $"{devInfo.PlextorFeatures.CdReadSpeedLimit}x" : UI.unlimited_as_in_speed;
|
|
|
|
if(devInfo.PlextorFeatures.IsDvd)
|
|
{
|
|
PlextorSilentModeDvdReadSpeedLimitVisible = true;
|
|
|
|
PlextorSilentModeDvdReadSpeedLimit =
|
|
devInfo.PlextorFeatures.DvdReadSpeedLimit > 0
|
|
? $"{devInfo.PlextorFeatures.DvdReadSpeedLimit}x" : UI.unlimited_as_in_speed;
|
|
}
|
|
}
|
|
}
|
|
|
|
PlextorGigaRec = devInfo.PlextorFeatures.GigaRec;
|
|
PlextorSecuRec = devInfo.PlextorFeatures.SecuRec;
|
|
PlextorSpeedRead = devInfo.PlextorFeatures.SpeedRead;
|
|
|
|
if(devInfo.PlextorFeatures.SpeedRead)
|
|
PlextorSpeedEnabled = devInfo.PlextorFeatures.SpeedReadEnabled;
|
|
|
|
PlextorHiding = devInfo.PlextorFeatures.Hiding;
|
|
|
|
if(devInfo.PlextorFeatures.Hiding)
|
|
{
|
|
PlextorHidesRecordables = devInfo.PlextorFeatures.HidesRecordables;
|
|
PlextorHidesSessions = devInfo.PlextorFeatures.HidesSessions;
|
|
}
|
|
|
|
PlextorVariRec = devInfo.PlextorFeatures.VariRec;
|
|
|
|
if(devInfo.PlextorFeatures.IsDvd)
|
|
{
|
|
PlextorVariRecDvd = devInfo.PlextorFeatures.VariRecDvd;
|
|
PlextorBitSetting = devInfo.PlextorFeatures.BitSetting;
|
|
PlextorBitSettingDl = devInfo.PlextorFeatures.BitSettingDl;
|
|
PlextorDvdPlusWriteTest = devInfo.PlextorFeatures.DvdPlusWriteTest;
|
|
}
|
|
}
|
|
|
|
if(devInfo.ScsiInquiry?.KreonPresent == true)
|
|
{
|
|
Kreon = true;
|
|
KreonChallengeResponse = devInfo.KreonFeatures.HasFlag(KreonFeatures.ChallengeResponse);
|
|
KreonDecryptSs = devInfo.KreonFeatures.HasFlag(KreonFeatures.DecryptSs);
|
|
KreonXtremeUnlock = devInfo.KreonFeatures.HasFlag(KreonFeatures.XtremeUnlock);
|
|
KreonWxripperUnlock = devInfo.KreonFeatures.HasFlag(KreonFeatures.WxripperUnlock);
|
|
|
|
KreonChallengeResponse360 = devInfo.KreonFeatures.HasFlag(KreonFeatures.ChallengeResponse360);
|
|
|
|
KreonDecryptSs360 = devInfo.KreonFeatures.HasFlag(KreonFeatures.DecryptSs360);
|
|
KreonXtremeUnlock360 = devInfo.KreonFeatures.HasFlag(KreonFeatures.XtremeUnlock360);
|
|
KreonWxripperUnlock360 = devInfo.KreonFeatures.HasFlag(KreonFeatures.WxripperUnlock360);
|
|
KreonLock = devInfo.KreonFeatures.HasFlag(KreonFeatures.Lock);
|
|
KreonErrorSkipping = devInfo.KreonFeatures.HasFlag(KreonFeatures.ErrorSkipping);
|
|
}
|
|
|
|
if(devInfo.BlockLimits != null)
|
|
{
|
|
BlockLimits.BlockLimitsData? blockLimits = Decoders.SCSI.SSC.BlockLimits.Decode(devInfo.BlockLimits);
|
|
|
|
if(blockLimits.HasValue)
|
|
{
|
|
Ssc = true;
|
|
|
|
if(blockLimits.Value.minBlockLen == blockLimits.Value.maxBlockLen)
|
|
MinBlockSize = string.Format(Localization.Core.Device_block_size_is_fixed_at_0_bytes,
|
|
blockLimits.Value.minBlockLen);
|
|
else
|
|
{
|
|
MaxBlockSize = blockLimits.Value.maxBlockLen > 0
|
|
? string.Format(Localization.Core.Device_maximum_block_size_is_0_bytes,
|
|
blockLimits.Value.maxBlockLen) : Localization.Core.
|
|
Device_does_not_specify_a_maximum_block_size;
|
|
|
|
MinBlockSize = string.Format(Localization.Core.Device_minimum_block_size_is_0_bytes,
|
|
blockLimits.Value.minBlockLen);
|
|
|
|
if(blockLimits.Value.granularity > 0)
|
|
BlockSizeGranularity =
|
|
string.Format(Localization.Core.Device_needs_a_block_size_granularity_of_pow_0_1_bytes,
|
|
blockLimits.Value.granularity,
|
|
Math.Pow(2, blockLimits.Value.granularity));
|
|
}
|
|
}
|
|
}
|
|
|
|
if(devInfo.DensitySupport != null)
|
|
if(devInfo.DensitySupportHeader.HasValue)
|
|
Densities = DensitySupport.PrettifyDensity(devInfo.DensitySupportHeader);
|
|
|
|
if(devInfo.MediumDensitySupport != null)
|
|
{
|
|
if(devInfo.MediaTypeSupportHeader.HasValue)
|
|
MediumTypes = DensitySupport.PrettifyMediumType(devInfo.MediaTypeSupportHeader);
|
|
|
|
MediumDensity = DensitySupport.PrettifyMediumType(devInfo.MediumDensitySupport);
|
|
}
|
|
}
|
|
|
|
SdMmcInfo = new SdMmcInfo
|
|
{
|
|
DataContext = new SdMmcInfoViewModel(devInfo.Type, devInfo.CID, devInfo.CSD, devInfo.OCR,
|
|
devInfo.ExtendedCSD, devInfo.SCR)
|
|
};
|
|
}
|
|
|
|
public ReactiveCommand<Unit, Task> SaveUsbDescriptorsCommand { get; }
|
|
|
|
public string DeviceType
|
|
{
|
|
get => _deviceType;
|
|
set => this.RaiseAndSetIfChanged(ref _deviceType, value);
|
|
}
|
|
|
|
public string Manufacturer
|
|
{
|
|
get => _manufacturer;
|
|
set => this.RaiseAndSetIfChanged(ref _manufacturer, value);
|
|
}
|
|
|
|
public string Model
|
|
{
|
|
get => _model;
|
|
set => this.RaiseAndSetIfChanged(ref _model, value);
|
|
}
|
|
|
|
public string Revision
|
|
{
|
|
get => _revision;
|
|
set => this.RaiseAndSetIfChanged(ref _revision, value);
|
|
}
|
|
|
|
public string Serial
|
|
{
|
|
get => _serial;
|
|
set => this.RaiseAndSetIfChanged(ref _serial, value);
|
|
}
|
|
|
|
public string ScsiType
|
|
{
|
|
get => _scsiType;
|
|
set => this.RaiseAndSetIfChanged(ref _scsiType, value);
|
|
}
|
|
|
|
public bool Removable
|
|
{
|
|
get => _removable;
|
|
set => this.RaiseAndSetIfChanged(ref _removable, value);
|
|
}
|
|
|
|
public string UsbConnected
|
|
{
|
|
get => _usbConnected;
|
|
set => this.RaiseAndSetIfChanged(ref _usbConnected, value);
|
|
}
|
|
|
|
public bool UsbVisible
|
|
{
|
|
get => _usbVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _usbVisible, value);
|
|
}
|
|
|
|
public string UsbVendorId
|
|
{
|
|
get => _usbVendorId;
|
|
set => this.RaiseAndSetIfChanged(ref _usbVendorId, value);
|
|
}
|
|
|
|
public string UsbProductId
|
|
{
|
|
get => _usbProductId;
|
|
set => this.RaiseAndSetIfChanged(ref _usbProductId, value);
|
|
}
|
|
|
|
public string UsbManufacturer
|
|
{
|
|
get => _usbManufacturer;
|
|
set => this.RaiseAndSetIfChanged(ref _usbManufacturer, value);
|
|
}
|
|
|
|
public string UsbProduct
|
|
{
|
|
get => _usbProduct;
|
|
set => this.RaiseAndSetIfChanged(ref _usbProduct, value);
|
|
}
|
|
|
|
public string UsbSerial
|
|
{
|
|
get => _usbSerial;
|
|
set => this.RaiseAndSetIfChanged(ref _usbSerial, value);
|
|
}
|
|
|
|
public bool SaveUsbDescriptorsEnabled
|
|
{
|
|
get => _saveUsbDescriptorsEnabled;
|
|
set => this.RaiseAndSetIfChanged(ref _saveUsbDescriptorsEnabled, value);
|
|
}
|
|
|
|
public bool FirewireVisible
|
|
{
|
|
get => _firewireVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireVisible, value);
|
|
}
|
|
|
|
public string FirewireVendorId
|
|
{
|
|
get => _firewireVendorId;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireVendorId, value);
|
|
}
|
|
|
|
public string FirewireModelId
|
|
{
|
|
get => _firewireModelId;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireModelId, value);
|
|
}
|
|
|
|
public string FirewireManufacturer
|
|
{
|
|
get => _firewireManufacturer;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireManufacturer, value);
|
|
}
|
|
|
|
public string FirewireModel
|
|
{
|
|
get => _firewireModel;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireModel, value);
|
|
}
|
|
|
|
public string FirewireGuid
|
|
{
|
|
get => _firewireGuid;
|
|
set => this.RaiseAndSetIfChanged(ref _firewireGuid, value);
|
|
}
|
|
|
|
public bool PlextorVisible
|
|
{
|
|
get => _plextorVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorVisible, value);
|
|
}
|
|
|
|
public bool PlextorEepromVisible
|
|
{
|
|
get => _plextorEepromVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorEepromVisible, value);
|
|
}
|
|
|
|
public string PlextorDiscs
|
|
{
|
|
get => _plextorDiscs;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDiscs, value);
|
|
}
|
|
|
|
public string PlextorCdReadTime
|
|
{
|
|
get => _plextorCdReadTime;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorCdReadTime, value);
|
|
}
|
|
|
|
public string PlextorCdWriteTime
|
|
{
|
|
get => _plextorCdWriteTime;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorCdWriteTime, value);
|
|
}
|
|
|
|
public bool PlextorDvdTimesVisible
|
|
{
|
|
get => _plextorDvdTimesVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDvdTimesVisible, value);
|
|
}
|
|
|
|
public string PlextorDvdReadTime
|
|
{
|
|
get => _plextorDvdReadTime;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDvdReadTime, value);
|
|
}
|
|
|
|
public string PlextorDvdWriteTime
|
|
{
|
|
get => _plextorDvdWriteTime;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDvdWriteTime, value);
|
|
}
|
|
|
|
public bool PlextorPoweRec
|
|
{
|
|
get => _plextorPoweRec;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRec, value);
|
|
}
|
|
|
|
public bool PlextorPoweRecEnabled
|
|
{
|
|
get => _plextorPoweRecEnabled;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecEnabled, value);
|
|
}
|
|
|
|
public bool PlextorPoweRecRecommendedVisible
|
|
{
|
|
get => _plextorPoweRecRecommendedVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecRecommendedVisible, value);
|
|
}
|
|
|
|
public string PlextorPoweRecRecommended
|
|
{
|
|
get => _plextorPoweRecRecommended;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecRecommended, value);
|
|
}
|
|
|
|
public bool PlextorPoweRecSelectedVisible
|
|
{
|
|
get => _plextorPoweRecSelectedVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecSelectedVisible, value);
|
|
}
|
|
|
|
public string PlextorPoweRecSelected
|
|
{
|
|
get => _plextorPoweRecSelected;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecSelected, value);
|
|
}
|
|
|
|
public bool PlextorPoweRecMaxVisible
|
|
{
|
|
get => _plextorPoweRecMaxVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecMaxVisible, value);
|
|
}
|
|
|
|
public string PlextorPoweRecMax
|
|
{
|
|
get => _plextorPoweRecMax;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecMax, value);
|
|
}
|
|
|
|
public bool PlextorPoweRecLastVisible
|
|
{
|
|
get => _plextorPoweRecLastVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecLastVisible, value);
|
|
}
|
|
|
|
public string PlextorPoweRecLast
|
|
{
|
|
get => _plextorPoweRecLast;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorPoweRecLast, value);
|
|
}
|
|
|
|
public bool PlextorSilentMode
|
|
{
|
|
get => _plextorSilentMode;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentMode, value);
|
|
}
|
|
|
|
public bool PlextorSilentModeEnabled
|
|
{
|
|
get => _plextorSilentModeEnabled;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeEnabled, value);
|
|
}
|
|
|
|
public string PlextorSilentModeAccessTime
|
|
{
|
|
get => _plextorSilentModeAccessTime;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeAccessTime, value);
|
|
}
|
|
|
|
public string PlextorSilentModeCdReadSpeedLimit
|
|
{
|
|
get => _plextorSilentModeCdReadSpeedLimit;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeCdReadSpeedLimit, value);
|
|
}
|
|
|
|
public string PlextorSilentModeCdWriteSpeedLimit
|
|
{
|
|
get => _plextorSilentModeCdWriteSpeedLimit;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeCdWriteSpeedLimit, value);
|
|
}
|
|
|
|
public bool PlextorSilentModeDvdReadSpeedLimitVisible
|
|
{
|
|
get => _plextorSilentModeDvdReadSpeedLimitVisible;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeDvdReadSpeedLimitVisible, value);
|
|
}
|
|
|
|
public string PlextorSilentModeDvdReadSpeedLimit
|
|
{
|
|
get => _plextorSilentModeDvdReadSpeedLimit;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSilentModeDvdReadSpeedLimit, value);
|
|
}
|
|
|
|
public bool PlextorGigaRec
|
|
{
|
|
get => _plextorGigaRec;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorGigaRec, value);
|
|
}
|
|
|
|
public bool PlextorSecuRec
|
|
{
|
|
get => _plextorSecuRec;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSecuRec, value);
|
|
}
|
|
|
|
public bool PlextorSpeedRead
|
|
{
|
|
get => _plextorSpeedRead;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSpeedRead, value);
|
|
}
|
|
|
|
public bool PlextorSpeedEnabled
|
|
{
|
|
get => _plextorSpeedEnabled;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorSpeedEnabled, value);
|
|
}
|
|
|
|
public bool PlextorHiding
|
|
{
|
|
get => _plextorHiding;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorHiding, value);
|
|
}
|
|
|
|
public bool PlextorHidesRecordables
|
|
{
|
|
get => _plextorHidesRecordables;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorHidesRecordables, value);
|
|
}
|
|
|
|
public bool PlextorHidesSessions
|
|
{
|
|
get => _plextorHidesSessions;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorHidesSessions, value);
|
|
}
|
|
|
|
public bool PlextorVariRec
|
|
{
|
|
get => _plextorVariRec;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorVariRec, value);
|
|
}
|
|
|
|
public string PlextorDvd
|
|
{
|
|
get => _plextorDvd;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDvd, value);
|
|
}
|
|
|
|
public bool PlextorVariRecDvd
|
|
{
|
|
get => _plextorVariRecDvd;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorVariRecDvd, value);
|
|
}
|
|
|
|
public bool PlextorBitSetting
|
|
{
|
|
get => _plextorBitSetting;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorBitSetting, value);
|
|
}
|
|
|
|
public bool PlextorBitSettingDl
|
|
{
|
|
get => _plextorBitSettingDl;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorBitSettingDl, value);
|
|
}
|
|
|
|
public bool PlextorDvdPlusWriteTest
|
|
{
|
|
get => _plextorDvdPlusWriteTest;
|
|
set => this.RaiseAndSetIfChanged(ref _plextorDvdPlusWriteTest, value);
|
|
}
|
|
|
|
public bool Kreon
|
|
{
|
|
get => _kreon;
|
|
set => this.RaiseAndSetIfChanged(ref _kreon, value);
|
|
}
|
|
|
|
public bool KreonChallengeResponse
|
|
{
|
|
get => _kreonChallengeResponse;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonChallengeResponse, value);
|
|
}
|
|
|
|
public bool KreonDecryptSs
|
|
{
|
|
get => _kreonDecryptSs;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonDecryptSs, value);
|
|
}
|
|
|
|
public bool KreonXtremeUnlock
|
|
{
|
|
get => _kreonXtremeUnlock;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonXtremeUnlock, value);
|
|
}
|
|
|
|
public bool KreonWxripperUnlock
|
|
{
|
|
get => _kreonWxripperUnlock;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonWxripperUnlock, value);
|
|
}
|
|
|
|
public bool KreonChallengeResponse360
|
|
{
|
|
get => _kreonChallengeResponse360;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonChallengeResponse360, value);
|
|
}
|
|
|
|
public bool KreonDecryptSs360
|
|
{
|
|
get => _kreonDecryptSs360;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonDecryptSs360, value);
|
|
}
|
|
|
|
public bool KreonXtremeUnlock360
|
|
{
|
|
get => _kreonXtremeUnlock360;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonXtremeUnlock360, value);
|
|
}
|
|
|
|
public bool KreonWxripperUnlock360
|
|
{
|
|
get => _kreonWxripperUnlock360;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonWxripperUnlock360, value);
|
|
}
|
|
|
|
public bool KreonLock
|
|
{
|
|
get => _kreonLock;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonLock, value);
|
|
}
|
|
|
|
public bool KreonErrorSkipping
|
|
{
|
|
get => _kreonErrorSkipping;
|
|
set => this.RaiseAndSetIfChanged(ref _kreonErrorSkipping, value);
|
|
}
|
|
|
|
public bool Ssc
|
|
{
|
|
get => _ssc;
|
|
set => this.RaiseAndSetIfChanged(ref _ssc, value);
|
|
}
|
|
|
|
public string BlockLimits
|
|
{
|
|
get => _blockLimits;
|
|
set => this.RaiseAndSetIfChanged(ref _blockLimits, value);
|
|
}
|
|
|
|
public string MinBlockSize
|
|
{
|
|
get => _minBlockSize;
|
|
set => this.RaiseAndSetIfChanged(ref _minBlockSize, value);
|
|
}
|
|
|
|
public string MaxBlockSize
|
|
{
|
|
get => _maxBlockSize;
|
|
set => this.RaiseAndSetIfChanged(ref _maxBlockSize, value);
|
|
}
|
|
|
|
public string BlockSizeGranularity
|
|
{
|
|
get => _blockSizeGranularity;
|
|
set => this.RaiseAndSetIfChanged(ref _blockSizeGranularity, value);
|
|
}
|
|
|
|
public string Densities
|
|
{
|
|
get => _densities;
|
|
set => this.RaiseAndSetIfChanged(ref _densities, value);
|
|
}
|
|
|
|
public string MediumTypes
|
|
{
|
|
get => _mediumTypes;
|
|
set => this.RaiseAndSetIfChanged(ref _mediumTypes, value);
|
|
}
|
|
|
|
public string MediumDensity
|
|
{
|
|
get => _mediumDensity;
|
|
set => this.RaiseAndSetIfChanged(ref _mediumDensity, value);
|
|
}
|
|
|
|
public string SecureDigital
|
|
{
|
|
get => _secureDigital;
|
|
set => this.RaiseAndSetIfChanged(ref _secureDigital, value);
|
|
}
|
|
|
|
public string SdMm
|
|
{
|
|
get => _sdMm;
|
|
set => this.RaiseAndSetIfChanged(ref _sdMm, value);
|
|
}
|
|
|
|
public string Cid
|
|
{
|
|
get => _cid;
|
|
set => this.RaiseAndSetIfChanged(ref _cid, value);
|
|
}
|
|
|
|
public string Csd
|
|
{
|
|
get => _csd;
|
|
set => this.RaiseAndSetIfChanged(ref _csd, value);
|
|
}
|
|
|
|
public string Ocr
|
|
{
|
|
get => _ocr;
|
|
set => this.RaiseAndSetIfChanged(ref _ocr, value);
|
|
}
|
|
|
|
public string ExtendedCsd
|
|
{
|
|
get => _extendedCsd;
|
|
set => this.RaiseAndSetIfChanged(ref _extendedCsd, value);
|
|
}
|
|
|
|
public string Scr
|
|
{
|
|
get => _scr;
|
|
set => this.RaiseAndSetIfChanged(ref _scr, value);
|
|
}
|
|
|
|
public PcmciaInfo PcmciaInfo
|
|
{
|
|
get => _pcmciaInfo;
|
|
set => this.RaiseAndSetIfChanged(ref _pcmciaInfo, value);
|
|
}
|
|
|
|
public ScsiInfo ScsiInfo
|
|
{
|
|
get => _scsiInfo;
|
|
set => this.RaiseAndSetIfChanged(ref _scsiInfo, value);
|
|
}
|
|
|
|
public AtaInfo AtaInfo
|
|
{
|
|
get => _ataInfo;
|
|
set => this.RaiseAndSetIfChanged(ref _ataInfo, value);
|
|
}
|
|
|
|
public SdMmcInfo SdMmcInfo
|
|
{
|
|
get => _sdMmcInfo;
|
|
set => this.RaiseAndSetIfChanged(ref _sdMmcInfo, value);
|
|
}
|
|
|
|
public string DeviceInformationLabel => UI.Title_Device_information;
|
|
public string GeneralLabel => UI.Title_General;
|
|
public string DeviceTypeLabel => UI.Title_Device_type;
|
|
public string ManufacturerLabel => UI.Title_Manufacturer;
|
|
public string ModelLabel => UI.Title_Model;
|
|
public string RevisionLabel => UI.Title_Revision;
|
|
public string SerialNumberLabel => UI.Title_Serial_number;
|
|
public string ScsiTypeLabel => UI.Title_Peripheral_device_type;
|
|
public string RemovableMediaLabel => UI.Title_Removable_media;
|
|
public string UsbConnectedLabel => UI.Title_Connected_by_USB;
|
|
public string USBLabel => UI.Title_USB;
|
|
public string VendorIDLabel => UI.Title_Vendor_ID;
|
|
public string ProductIDLabel => UI.Title_Product_ID;
|
|
public string ProductLabel => UI.Title_Product;
|
|
public string SaveUsbDescriptorsLabel => UI.Save_descriptors_to_file;
|
|
public string FireWireLabel => UI.Title_FireWire;
|
|
public string ModelIDLabel => UI.Title_Model_ID;
|
|
public string GUIDLabel => UI.Title_GUID;
|
|
public string PlextorLabel => UI.Title_Plextor;
|
|
public string PlextorDiscsLabel => UI.Total_loaded_discs;
|
|
public string PlextorCdReadTimeLabel => UI.Time_spent_reading_CDs;
|
|
public string PlextorCdWriteTimeLabel => UI.Time_spent_writing_CDs;
|
|
public string PlextorDvdReadTimeLabel => UI.Time_spent_reading_DVDs;
|
|
public string PlextorDvdWriteTimeLabel => UI.Time_spent_writing_DVDs;
|
|
public string PlextorPoweRecLabel => UI.Supports_PoweRec;
|
|
public string PlextorPoweRecEnabledLabel => UI.PoweRec_is_enabled;
|
|
public string PlextorPoweRecRecommendedLabel => UI.Recommended_speed;
|
|
public string PlextorPoweRecSelectedLabel => UI.Selected_PoweRec_speed_for_currently_inserted_media;
|
|
public string PlextorPoweRecMaxLabel => UI.Maximum_PoweRec_speed_for_currently_inserted_media;
|
|
public string PlextorPoweRecLastLabel => UI.Last_PoweRec_used_speed;
|
|
public string PlextorSilentModeLabel => UI.Supports_SilentMode;
|
|
public string PlextorSilentModeEnabledLabel => UI.SilentMode_is_enabled;
|
|
public string PlextorSilentModeCdReadSpeedLimitLabel => UI.CD_read_speed_limited_to;
|
|
public string PlextorSilentModeCdWriteSpeedLimitLabel => UI.CD_write_speed_limited_to;
|
|
public string PlextorSilentModeDvdReadSpeedLimitLabel => UI.DVD_read_speed_limited_to;
|
|
public string PlextorGigaRecLabel => UI.Supports_GigaRec;
|
|
public string PlextorSecuRecLabel => UI.Supports_SecuRec;
|
|
public string PlextorSpeedReadLabel => UI.Supports_SpeedRead;
|
|
public string PlextorSpeedEnabledLabel => UI.SpeedRead_is_enabled;
|
|
public string PlextorHidingLabel => UI.Supports_hiding_CD_Rs_and_sessions;
|
|
public string PlextorHidesRecordablesLabel => UI.Is_hiding_CD_Rs;
|
|
public string PlextorHidesSessionsLabel => UI.Is_forcing_only_first_session;
|
|
public string PlextorVariRecLabel => UI.Supports_VariRec;
|
|
public string PlextorVariRecDvdLabel => UI.Supports_VariRec_on_DVDs;
|
|
public string PlextorBitSettingLabel => UI.Supports_bitsetting_DVD_R_book_type;
|
|
public string PlextorBitSettingDlLabel => UI.Supports_bitsetting_DVD_R_DL_book_type;
|
|
public string PlextorDvdPlusWriteTestLabel => UI.Supports_test_writing_DVD_Plus;
|
|
public string KreonLabel => UI.Title_Kreon;
|
|
public string KreonChallengeResponseLabel => Localization.Core.Can_do_challenge_response_with_Xbox_discs;
|
|
public string KreonDecryptSsLabel => Localization.Core.Can_read_and_decrypt_SS_from_Xbox_discs;
|
|
public string KreonXtremeUnlockLabel => Localization.Core.Can_set_xtreme_unlock_state_with_Xbox_discs;
|
|
public string KreonWxripperUnlockLabel => Localization.Core.Can_set_wxripper_unlock_state_with_Xbox_discs;
|
|
public string KreonChallengeResponse360Label => Localization.Core.Can_do_challenge_response_with_Xbox_360_discs;
|
|
public string KreonDecryptSs360Label => Localization.Core.Can_read_and_decrypt_SS_from_Xbox_360_discs;
|
|
public string KreonXtremeUnlock360Label => Localization.Core.Can_set_xtreme_unlock_state_with_Xbox_360_discs;
|
|
public string KreonWxripperUnlock360Label => Localization.Core.Can_set_wxripper_unlock_state_with_Xbox_360_discs;
|
|
public string KreonSetLockedLabel => Localization.Core.Can_set_Kreon_locked_state;
|
|
public string KreonErrorSkippingLabel => Localization.Core.Kreon_Can_skip_read_errors;
|
|
public string DensitiesSupportedByDeviceLabel => UI.Densities_supported_by_device;
|
|
public string MediumTypesSupportedByDeviceLabel => UI.Medium_types_supported_by_device;
|
|
public string CIDLabel => UI.Title_CID;
|
|
public string CSDLabel => UI.Title_CSD;
|
|
public string OCRLabel => UI.Title_OCR;
|
|
public string ExtendedCSDLabel => UI.Title_Extended_CSD;
|
|
public string SCRLabel => UI.Title_SCR;
|
|
public string PCMCIALabel => UI.Title_PCMCIA;
|
|
public string ATA_ATAPILabel => UI.Title_ATA_ATAPI;
|
|
public string SCSILabel => UI.Title_SCSI;
|
|
public string SD_MMCLabel => UI.Title_SD_MMC;
|
|
|
|
async Task ExecuteSaveUsbDescriptorsCommand()
|
|
{
|
|
var dlgSaveBinary = new SaveFileDialog();
|
|
|
|
dlgSaveBinary.Filters?.Add(new FileDialogFilter
|
|
{
|
|
Extensions = new List<string>(new[]
|
|
{
|
|
"*.bin"
|
|
}),
|
|
Name = UI.Dialog_Binary_files
|
|
});
|
|
|
|
string result = await dlgSaveBinary.ShowAsync(_view);
|
|
|
|
if(result is null)
|
|
return;
|
|
|
|
var saveFs = new FileStream(result, FileMode.Create);
|
|
saveFs.Write(_devInfo.UsbDescriptors, 0, _devInfo.UsbDescriptors.Length);
|
|
|
|
saveFs.Close();
|
|
}
|
|
} |