From 1b607433035eed0919f5a847a684e5ad85517084 Mon Sep 17 00:00:00 2001 From: what Date: Mon, 26 Jul 2021 13:04:16 -0700 Subject: [PATCH] initial commit --- .editorconfig | 141 +++ .gitignore | 387 +++++++ Explorer/AppStatus.cs | 22 + Explorer/AssemblyGitBuildBranch.cs | 18 + Explorer/AssemblyGitBuildSHA1.cs | 18 + Explorer/AssemblyInfo.cs | 18 + Explorer/DiscView/ContextMenuManager.cs | 40 + .../DiscListViewSelectionHandlerFactory.cs | 29 + .../DiscView/DiscSelectionHandlerFactory.cs | 13 + .../DiscView/DiscSelectionHandlerFactory`1.cs | 24 + .../DiscTreeViewSelectionHandlerFactory.cs | 71 ++ Explorer/DiscView/DiscViewSelection`1.cs | 107 ++ Explorer/DiscView/ExplorerListItemFactory.cs | 54 + Explorer/DiscView/ExplorerToolTipFactory.cs | 29 + Explorer/DiscView/ExplorerTreeNodeFactory.cs | 135 +++ Explorer/DiscView/IDiscViewSelection.cs | 23 + Explorer/DiscView/MenuItemFactory.cs | 228 +++++ Explorer/DiscView/UserActions.cs | 34 + Explorer/Events/CancelEventArgs`1.cs | 24 + Explorer/Events/ChangingData`1.cs | 21 + Explorer/Events/EventArgs`1.cs | 17 + Explorer/Events/IEventArgs`1.cs | 13 + Explorer/Explorer.csproj | 220 ++++ Explorer/Forms/FormAbout.cs | 294 ++++++ Explorer/Forms/FormAbout.resx | 123 +++ Explorer/Forms/FormAudioConversionSettings.cs | 89 ++ .../Forms/FormAudioConversionSettings.resx | 120 +++ Explorer/Forms/FormGDEmuExportSettings.cs | 130 +++ Explorer/Forms/FormGDEmuExportSettings.resx | 123 +++ Explorer/Forms/FormGdda.cs | 270 +++++ Explorer/Forms/FormGdda.resx | 123 +++ Explorer/Forms/FormGetDESKey.cs | 185 ++++ Explorer/Forms/FormGetDESKey.resx | 120 +++ Explorer/Forms/FormInitialProgram.cs | 203 ++++ Explorer/Forms/FormInitialProgram.resx | 120 +++ Explorer/Forms/FormLoading.cs | 70 ++ Explorer/Forms/FormLoading.resx | 120 +++ Explorer/Forms/FormPrimaryVolumeDescriptor.cs | 81 ++ .../Forms/FormPrimaryVolumeDescriptor.resx | 123 +++ Explorer/Forms/FormProcess.cs | 423 ++++++++ Explorer/Forms/FormProcess.resx | 123 +++ Explorer/Forms/FormSettings.cs | 363 +++++++ Explorer/Forms/FormSettings.resx | 120 +++ Explorer/Forms/FormSortFileOptions.cs | 158 +++ Explorer/Forms/FormSortFileOptions.resx | 120 +++ Explorer/Forms/GDRomExplorerForm.cs | 446 ++++++++ Explorer/Forms/GDRomExplorerForm.resx | 123 +++ Explorer/GD-ROM Explorer.sln | 60 ++ Explorer/Logger.cs | 474 +++++++++ Explorer/Others/ListViewColumnSorter.cs | 76 ++ .../Others/UserProcessEventArgsConverter.cs | 62 ++ Explorer/Program.cs | 70 ++ Explorer/Properties/Resources.cs | 61 ++ Explorer/Properties/Resources.resx | 374 +++++++ Explorer/Properties/Settings.cs | 41 + Explorer/Resources/Strings.cs | 284 ++++++ Explorer/Resources/Strings.resx | 479 +++++++++ Explorer/Resources/file.ico | Bin 0 -> 2550 bytes Explorer/Resources/icons/gdromexplorer.ico | Bin 0 -> 297086 bytes Explorer/Resources/icons/gdromexplorer2.ico | Bin 0 -> 297086 bytes Explorer/ShellDataTransfert/DataObjectEx.cs | 145 +++ Explorer/ShellDataTransfert/FileDescriptor.cs | 24 + .../FileDescriptorFactory.cs | 112 ++ Explorer/ShellDataTransfert/LOCKTYPE.cs | 15 + Explorer/ShellDataTransfert/NativeMethods.cs | 41 + Explorer/ShellDataTransfert/STGTY.cs | 16 + Explorer/ShellDataTransfert/StreamWrapper.cs | 53 + Explorer/UserControls/DiscViewExplorer.cs | 954 ++++++++++++++++++ Explorer/UserControls/DiscViewExplorer.resx | 129 +++ Explorer/UserControls/DiscViewOpener.cs | 305 ++++++ Explorer/UserControls/DiscViewOpener.resx | 120 +++ Explorer/UserControls/GDDAConverterTool.cs | 203 ++++ Explorer/UserControls/GDDAConverterTool.resx | 120 +++ Explorer/UserControls/GDEmuExportSettings.cs | 210 ++++ .../UserControls/GDEmuExportSettings.resx | 123 +++ Explorer/UserControls/InitialProgramOpener.cs | 115 +++ .../UserControls/InitialProgramOpener.resx | 120 +++ .../UserControls/NaomiEncryptDecryptTool.cs | 131 +++ .../UserControls/NaomiEncryptDecryptTool.resx | 120 +++ .../PrimaryVolumeDescriptorViewer.cs | 424 ++++++++ .../PrimaryVolumeDescriptorViewer.resx | 120 +++ Explorer/app.config | 16 + Explorer/log4net.config | 56 + Explorer/packages.config | 4 + Formats/BIN/AssemblyInfo.cs | 14 + Formats/BIN/BIN.csproj | 59 ++ Formats/BIN/BIN.sln | 24 + Formats/BIN/BinaryImageFormat.cs | 27 + Formats/CDI/AssemblyInfo.cs | 14 + Formats/CDI/CDI.csproj | 64 ++ Formats/CDI/CDI.sln | 20 + Formats/CDI/CDIHeader.cs | 15 + Formats/CDI/CDIHeaderConverter.cs | 35 + Formats/CDI/CDIImageBuilder.cs | 27 + Formats/CDI/CDIImageFormat.cs | 26 + Formats/CDI/CDIToc.cs | 25 + Formats/CDI/CDITocConverter.cs | 245 +++++ Formats/CDI/CDIVersion.cs | 16 + Formats/GDI/AssemblyInfo.cs | 14 + Formats/GDI/GDI.csproj | 67 ++ Formats/GDI/GDIFileSystemValidator.cs | 111 ++ Formats/GDI/GDImageBuilder.cs | 117 +++ Formats/GDI/GDImageFormat.cs | 26 + Formats/GDI/IGDIFileSystemValidator.cs | 17 + Formats/GDI/IInitialProgramProvider.cs | 16 + Formats/GDI/InitialProgramProvider.cs | 34 + Formats/ISO9660/AssemblyInfo.cs | 14 + Formats/ISO9660/ISO9660.csproj | 58 ++ Formats/ISO9660/ISO9660ImageFormat.cs | 27 + GD-ROM Explorer.sln | 79 ++ ImageReader/AssemblyGitBuildBranch.cs | 18 + ImageReader/AssemblyGitBuildSHA1.cs | 18 + ImageReader/AssemblyInfo.cs | 17 + ImageReader/AssemblyTest.cs | 12 + ImageReader/DiscSectors/CDROMDataModeType.cs | 14 + .../DiscSectors/CDROMFrameHeaderConverter.cs | 58 ++ .../DiscSectors/CDROMMode1RawSector.cs | 17 + .../DiscSectors/CDROMXAMode2Form1RawSector.cs | 17 + .../DiscSectors/CDROMXAMode2Form1Sector.cs | 17 + ImageReader/DiscSectors/DiscSectorBase.cs | 33 + ImageReader/DiscSectors/DiscSectorCommon.cs | 14 + ImageReader/DiscSectors/IDiscSector.cs | 17 + ImageReader/DiscSectors/ISO9660Sector.cs | 17 + ImageReader/DiscSectors/RawSector.cs | 17 + .../DirectoryRecords/DirectoryRecord.cs | 199 ++++ .../DirectoryRecordConverter.cs | 114 +++ .../DirectoryRecords/DirectoryRecordFlags.cs | 24 + .../ISO9660/PathTable/PathTableEntry.cs | 40 + .../PrimaryVolumeDescriptor.cs | 82 ++ .../VolumeDescriptors/VolumeDescriptor.cs | 23 + .../VolumeDescriptorConverter.cs | 142 +++ .../VolumeDescriptors/VolumeDescriptorType.cs | 17 + ImageReader/ImageReader.csproj | 85 ++ ImageReader/ImageReader/DiscImageReader.cs | 342 +++++++ .../ImageReader/DiscImageReaderException.cs | 23 + .../ImageReader/DiscImageReaderStatus.cs | 14 + ImageReader/Logger.cs | 475 +++++++++ ImageReader/Properties/Resources.cs | 46 + ImageReader/Properties/Resources.resx | 120 +++ ImageReader/Stream/DiscSectorStream.cs | 211 ++++ ImageReader/packages.config | 4 + README.md | 5 + SEGATools/AssemblyGitBuildBranch.cs | 18 + SEGATools/AssemblyGitBuildSHA1.cs | 18 + SEGATools/AssemblyInfo.cs | 22 + SEGATools/AssemblyTest.cs | 12 + SEGATools/Audio/AudioConversionSettings.cs | 44 + .../Audio/AudioConversionSettingsViewer.cs | 151 +++ .../Audio/AudioConversionSettingsViewer.resx | 120 +++ SEGATools/Audio/CanonicalWaveHeader.cs | 98 ++ SEGATools/Audio/Raw2WavConverter.cs | 142 +++ .../UninitialiedSampleDataSizeException.cs | 18 + SEGATools/Binary/BinaryPatch.cs | 43 + SEGATools/Binary/BinaryPatcher.cs | 37 + SEGATools/Binary/InitialProgramPatches.cs | 170 ++++ SEGATools/Binary/SEGALibrary.cs | 59 ++ SEGATools/Binary/SEGALibraryType.cs | 16 + SEGATools/Binary/SEGALibraryVersion.cs | 35 + SEGATools/CueSheet/CueSheetCreator.cs | 63 ++ SEGATools/Disc/DiscExtractor.cs | 347 +++++++ SEGATools/Disc/DiscExtractorException.cs | 23 + SEGATools/Disc/DiscFormatProvider.cs | 155 +++ SEGATools/Disc/DiscOpener.cs | 119 +++ SEGATools/Disc/DiscSectorEncoder.cs | 60 ++ SEGATools/DiscFileSystem/DiscFileSystem.cs | 113 +++ .../DiscFileSystem/DiscFileSystemBuilder.cs | 161 +++ SEGATools/DiscFileSystem/DiscFileUtils.cs | 20 + .../DiscFileSystem/DiscFormatException.cs | 23 + SEGATools/DiscFileSystem/DiscImageType.cs | 15 + SEGATools/DiscFileSystem/DiscSession.cs | 110 ++ SEGATools/DiscFileSystem/DiscTrack.cs | 87 ++ .../DiscFileSystem/GenericImageConverter.cs | 149 +++ SEGATools/DiscFileSystem/IDiscFileSystem.cs | 45 + .../IDiscFileSystemConverter.cs | 13 + SEGATools/DiscFileSystem/IDiscSession.cs | 42 + SEGATools/DiscFileSystem/IDiscTrack.cs | 35 + SEGATools/DiscFileSystem/TrackModeType.cs | 14 + SEGATools/Encrypt/DESKey.cs | 80 ++ SEGATools/Encrypt/DesEncryptDecryptTool.cs | 133 +++ .../FileFormat/AbstractImageFileFormat.cs | 33 + SEGATools/FileFormat/IImageFileFormat.cs | 21 + SEGATools/Formater/SizeFormater.cs | 27 + SEGATools/GDEmu/DiscTrackCopyInfo.cs | 55 + SEGATools/GDEmu/GDEmuConverter.cs | 328 ++++++ SEGATools/GDEmu/GDEmuExportOptions.cs | 22 + SEGATools/GDEmu/GDICreator.cs | 31 + SEGATools/Graphics/MRImage.cs | 74 ++ SEGATools/Graphics/MRImageColor.cs | 23 + SEGATools/Graphics/MRImageConverter.cs | 117 +++ .../Graphics/MRImageDecompressionException.cs | 23 + SEGATools/Graphics/MRImageExporter.cs | 99 ++ SEGATools/Graphics/MRImageHeader.cs | 25 + .../MRImageIdentifierMissingException.cs | 23 + SEGATools/Graphics/MRImageReadingException.cs | 23 + .../Graphics/MRImageUnknownColorException.cs | 22 + SEGATools/Graphics/MRImageViewer.cs | 284 ++++++ SEGATools/Graphics/MRImageViewer.resx | 120 +++ SEGATools/HashAlgorithm/ECC.cs | 607 +++++++++++ SEGATools/HashAlgorithm/EDC.cs | 322 ++++++ .../DiscFileSystem/DiscFileSystemException.cs | 25 + SEGATools/Logger.cs | 475 +++++++++ SEGATools/Properties/Resources.cs | 94 ++ SEGATools/Properties/Resources.resx | 192 ++++ SEGATools/Registry/EditFlags.cs | 35 + SEGATools/Registry/FileAssociationInfo.cs | 249 +++++ SEGATools/Registry/PerceivedTypes.cs | 19 + SEGATools/Registry/ProgramAssociationInfo.cs | 328 ++++++ SEGATools/Registry/ProgramIcon.cs | 70 ++ SEGATools/Registry/ProgramVerb.cs | 24 + SEGATools/Registry/RegistryException.cs | 27 + SEGATools/Registry/RegistryWrapper.cs | 103 ++ SEGATools/Registry/ShellNotification.cs | 66 ++ SEGATools/SEGATools.csproj | 229 +++++ SEGATools/Scanner/FileScanner.cs | 175 ++++ SEGATools/Scanner/FileScannerException.cs | 23 + SEGATools/Scanner/FileScannerPattern.cs | 46 + .../FileScannerResultConverterException.cs | 29 + ...ileScannerResultConverterForSEGALibrary.cs | 32 + .../FileScannerWrongArgumentsException.cs | 29 + .../Scanner/IFileScannerResultConverter`1.cs | 15 + SEGATools/Security/InitialProgram.cs | 133 +++ SEGATools/Security/InitialProgramConverter.cs | 114 +++ SEGATools/Security/InitialProgramException.cs | 23 + SEGATools/Security/InitialProgramExtended.cs | 46 + .../InitialProgramFieldParsingException.cs | 21 + .../InitialProgramGeneralSettingsViewer.cs | 459 +++++++++ .../InitialProgramGeneralSettingsViewer.resx | 120 +++ .../Security/InitialProgramImagesViewer.cs | 123 +++ .../Security/InitialProgramImagesViewer.resx | 120 +++ ...nitialProgramInvalidHardwareIdException.cs | 16 + .../InitialProgramInvalidMRImageException.cs | 18 + .../InitialProgramInvalidMakerIdException.cs | 16 + .../InitialProgramLibraryReferences.cs | 144 +++ .../InitialProgramLibraryReferences.resx | 120 +++ .../InitialProgramPeripheralsViewer.cs | 373 +++++++ .../InitialProgramPeripheralsViewer.resx | 120 +++ ...itialProgramReleaseDateParsingException.cs | 18 + SEGATools/Security/InitialProgramToc.cs | 25 + .../Security/InitialProgramTocConverter.cs | 96 ++ .../Security/InitialProgramTocException.cs | 23 + ...ialProgramTocIdentifierMissingException.cs | 16 + .../Security/InitialProgramTocTrackBuilder.cs | 53 + SEGATools/Security/InitialProgramTocViewer.cs | 161 +++ .../Security/InitialProgramTocViewer.resx | 120 +++ ...tialProgramTocWrongControlDataException.cs | 24 + ...lProgramTocWrongNumberOfTracksException.cs | 16 + SEGATools/Security/InitialProgramTrackInfo.cs | 41 + SEGATools/Security/InitialProgramUtils.cs | 52 + SEGATools/Security/SupportedAreas.cs | 19 + SEGATools/Security/SupportedButtons.cs | 48 + .../Security/SupportedExpandedPeripherals.cs | 24 + SEGATools/Security/SupportedPeripherals.cs | 24 + SEGATools/SortFile/SortFileCreator.cs | 37 + SEGATools/Stream/SubStream.cs | 151 +++ .../AsyncOperationCompletedEventHandler.cs | 12 + ...yncOperationProgressChangedEventHandler.cs | 11 + ...ncOperationProgressUpdateUIEventHandler.cs | 10 + ...ionProgressWaitingForUserConsentEventHa.cs | 11 + SEGATools/UserProcess/UserProcessBase.cs | 156 +++ .../UserProcessCompletedEventArgs.cs | 26 + .../UserProcessProgressChangedEventArgs.cs | 49 + .../UserProcessUpdateUIViewEventArgs.cs | 55 + ...erProcessWaitingForUserConsentEventArgs.cs | 39 + ...WaitingForUserConsentFileConflictEventA.cs | 21 + SEGATools/VirtualFile/IVirtualFile.cs | 21 + SEGATools/VirtualFile/IVirtualFile`1.cs | 13 + SEGATools/VirtualFile/VirtualFileBase`1.cs | 43 + .../VirtualFile/VirtualFileDirectoryRecord.cs | 32 + SEGATools/VirtualFile/VirtualFileFactory.cs | 38 + .../VirtualFileInitialProgramExtended.cs | 24 + SEGATools/VirtualFile/VirtualFileOnDisc.cs | 23 + SEGATools/VirtualFile/VirtualFileStream.cs | 23 + SEGATools/app.config | 11 + SEGATools/packages.config | 4 + 274 files changed, 25866 insertions(+) create mode 100644 .editorconfig create mode 100644 .gitignore create mode 100644 Explorer/AppStatus.cs create mode 100644 Explorer/AssemblyGitBuildBranch.cs create mode 100644 Explorer/AssemblyGitBuildSHA1.cs create mode 100644 Explorer/AssemblyInfo.cs create mode 100644 Explorer/DiscView/ContextMenuManager.cs create mode 100644 Explorer/DiscView/DiscListViewSelectionHandlerFactory.cs create mode 100644 Explorer/DiscView/DiscSelectionHandlerFactory.cs create mode 100644 Explorer/DiscView/DiscSelectionHandlerFactory`1.cs create mode 100644 Explorer/DiscView/DiscTreeViewSelectionHandlerFactory.cs create mode 100644 Explorer/DiscView/DiscViewSelection`1.cs create mode 100644 Explorer/DiscView/ExplorerListItemFactory.cs create mode 100644 Explorer/DiscView/ExplorerToolTipFactory.cs create mode 100644 Explorer/DiscView/ExplorerTreeNodeFactory.cs create mode 100644 Explorer/DiscView/IDiscViewSelection.cs create mode 100644 Explorer/DiscView/MenuItemFactory.cs create mode 100644 Explorer/DiscView/UserActions.cs create mode 100644 Explorer/Events/CancelEventArgs`1.cs create mode 100644 Explorer/Events/ChangingData`1.cs create mode 100644 Explorer/Events/EventArgs`1.cs create mode 100644 Explorer/Events/IEventArgs`1.cs create mode 100644 Explorer/Explorer.csproj create mode 100644 Explorer/Forms/FormAbout.cs create mode 100644 Explorer/Forms/FormAbout.resx create mode 100644 Explorer/Forms/FormAudioConversionSettings.cs create mode 100644 Explorer/Forms/FormAudioConversionSettings.resx create mode 100644 Explorer/Forms/FormGDEmuExportSettings.cs create mode 100644 Explorer/Forms/FormGDEmuExportSettings.resx create mode 100644 Explorer/Forms/FormGdda.cs create mode 100644 Explorer/Forms/FormGdda.resx create mode 100644 Explorer/Forms/FormGetDESKey.cs create mode 100644 Explorer/Forms/FormGetDESKey.resx create mode 100644 Explorer/Forms/FormInitialProgram.cs create mode 100644 Explorer/Forms/FormInitialProgram.resx create mode 100644 Explorer/Forms/FormLoading.cs create mode 100644 Explorer/Forms/FormLoading.resx create mode 100644 Explorer/Forms/FormPrimaryVolumeDescriptor.cs create mode 100644 Explorer/Forms/FormPrimaryVolumeDescriptor.resx create mode 100644 Explorer/Forms/FormProcess.cs create mode 100644 Explorer/Forms/FormProcess.resx create mode 100644 Explorer/Forms/FormSettings.cs create mode 100644 Explorer/Forms/FormSettings.resx create mode 100644 Explorer/Forms/FormSortFileOptions.cs create mode 100644 Explorer/Forms/FormSortFileOptions.resx create mode 100644 Explorer/Forms/GDRomExplorerForm.cs create mode 100644 Explorer/Forms/GDRomExplorerForm.resx create mode 100644 Explorer/GD-ROM Explorer.sln create mode 100644 Explorer/Logger.cs create mode 100644 Explorer/Others/ListViewColumnSorter.cs create mode 100644 Explorer/Others/UserProcessEventArgsConverter.cs create mode 100644 Explorer/Program.cs create mode 100644 Explorer/Properties/Resources.cs create mode 100644 Explorer/Properties/Resources.resx create mode 100644 Explorer/Properties/Settings.cs create mode 100644 Explorer/Resources/Strings.cs create mode 100644 Explorer/Resources/Strings.resx create mode 100644 Explorer/Resources/file.ico create mode 100644 Explorer/Resources/icons/gdromexplorer.ico create mode 100644 Explorer/Resources/icons/gdromexplorer2.ico create mode 100644 Explorer/ShellDataTransfert/DataObjectEx.cs create mode 100644 Explorer/ShellDataTransfert/FileDescriptor.cs create mode 100644 Explorer/ShellDataTransfert/FileDescriptorFactory.cs create mode 100644 Explorer/ShellDataTransfert/LOCKTYPE.cs create mode 100644 Explorer/ShellDataTransfert/NativeMethods.cs create mode 100644 Explorer/ShellDataTransfert/STGTY.cs create mode 100644 Explorer/ShellDataTransfert/StreamWrapper.cs create mode 100644 Explorer/UserControls/DiscViewExplorer.cs create mode 100644 Explorer/UserControls/DiscViewExplorer.resx create mode 100644 Explorer/UserControls/DiscViewOpener.cs create mode 100644 Explorer/UserControls/DiscViewOpener.resx create mode 100644 Explorer/UserControls/GDDAConverterTool.cs create mode 100644 Explorer/UserControls/GDDAConverterTool.resx create mode 100644 Explorer/UserControls/GDEmuExportSettings.cs create mode 100644 Explorer/UserControls/GDEmuExportSettings.resx create mode 100644 Explorer/UserControls/InitialProgramOpener.cs create mode 100644 Explorer/UserControls/InitialProgramOpener.resx create mode 100644 Explorer/UserControls/NaomiEncryptDecryptTool.cs create mode 100644 Explorer/UserControls/NaomiEncryptDecryptTool.resx create mode 100644 Explorer/UserControls/PrimaryVolumeDescriptorViewer.cs create mode 100644 Explorer/UserControls/PrimaryVolumeDescriptorViewer.resx create mode 100644 Explorer/app.config create mode 100644 Explorer/log4net.config create mode 100644 Explorer/packages.config create mode 100644 Formats/BIN/AssemblyInfo.cs create mode 100644 Formats/BIN/BIN.csproj create mode 100644 Formats/BIN/BIN.sln create mode 100644 Formats/BIN/BinaryImageFormat.cs create mode 100644 Formats/CDI/AssemblyInfo.cs create mode 100644 Formats/CDI/CDI.csproj create mode 100644 Formats/CDI/CDI.sln create mode 100644 Formats/CDI/CDIHeader.cs create mode 100644 Formats/CDI/CDIHeaderConverter.cs create mode 100644 Formats/CDI/CDIImageBuilder.cs create mode 100644 Formats/CDI/CDIImageFormat.cs create mode 100644 Formats/CDI/CDIToc.cs create mode 100644 Formats/CDI/CDITocConverter.cs create mode 100644 Formats/CDI/CDIVersion.cs create mode 100644 Formats/GDI/AssemblyInfo.cs create mode 100644 Formats/GDI/GDI.csproj create mode 100644 Formats/GDI/GDIFileSystemValidator.cs create mode 100644 Formats/GDI/GDImageBuilder.cs create mode 100644 Formats/GDI/GDImageFormat.cs create mode 100644 Formats/GDI/IGDIFileSystemValidator.cs create mode 100644 Formats/GDI/IInitialProgramProvider.cs create mode 100644 Formats/GDI/InitialProgramProvider.cs create mode 100644 Formats/ISO9660/AssemblyInfo.cs create mode 100644 Formats/ISO9660/ISO9660.csproj create mode 100644 Formats/ISO9660/ISO9660ImageFormat.cs create mode 100644 GD-ROM Explorer.sln create mode 100644 ImageReader/AssemblyGitBuildBranch.cs create mode 100644 ImageReader/AssemblyGitBuildSHA1.cs create mode 100644 ImageReader/AssemblyInfo.cs create mode 100644 ImageReader/AssemblyTest.cs create mode 100644 ImageReader/DiscSectors/CDROMDataModeType.cs create mode 100644 ImageReader/DiscSectors/CDROMFrameHeaderConverter.cs create mode 100644 ImageReader/DiscSectors/CDROMMode1RawSector.cs create mode 100644 ImageReader/DiscSectors/CDROMXAMode2Form1RawSector.cs create mode 100644 ImageReader/DiscSectors/CDROMXAMode2Form1Sector.cs create mode 100644 ImageReader/DiscSectors/DiscSectorBase.cs create mode 100644 ImageReader/DiscSectors/DiscSectorCommon.cs create mode 100644 ImageReader/DiscSectors/IDiscSector.cs create mode 100644 ImageReader/DiscSectors/ISO9660Sector.cs create mode 100644 ImageReader/DiscSectors/RawSector.cs create mode 100644 ImageReader/ISO9660/DirectoryRecords/DirectoryRecord.cs create mode 100644 ImageReader/ISO9660/DirectoryRecords/DirectoryRecordConverter.cs create mode 100644 ImageReader/ISO9660/DirectoryRecords/DirectoryRecordFlags.cs create mode 100644 ImageReader/ISO9660/PathTable/PathTableEntry.cs create mode 100644 ImageReader/ISO9660/VolumeDescriptors/PrimaryVolumeDescriptor.cs create mode 100644 ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptor.cs create mode 100644 ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorConverter.cs create mode 100644 ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorType.cs create mode 100644 ImageReader/ImageReader.csproj create mode 100644 ImageReader/ImageReader/DiscImageReader.cs create mode 100644 ImageReader/ImageReader/DiscImageReaderException.cs create mode 100644 ImageReader/ImageReader/DiscImageReaderStatus.cs create mode 100644 ImageReader/Logger.cs create mode 100644 ImageReader/Properties/Resources.cs create mode 100644 ImageReader/Properties/Resources.resx create mode 100644 ImageReader/Stream/DiscSectorStream.cs create mode 100644 ImageReader/packages.config create mode 100644 README.md create mode 100644 SEGATools/AssemblyGitBuildBranch.cs create mode 100644 SEGATools/AssemblyGitBuildSHA1.cs create mode 100644 SEGATools/AssemblyInfo.cs create mode 100644 SEGATools/AssemblyTest.cs create mode 100644 SEGATools/Audio/AudioConversionSettings.cs create mode 100644 SEGATools/Audio/AudioConversionSettingsViewer.cs create mode 100644 SEGATools/Audio/AudioConversionSettingsViewer.resx create mode 100644 SEGATools/Audio/CanonicalWaveHeader.cs create mode 100644 SEGATools/Audio/Raw2WavConverter.cs create mode 100644 SEGATools/Audio/UninitialiedSampleDataSizeException.cs create mode 100644 SEGATools/Binary/BinaryPatch.cs create mode 100644 SEGATools/Binary/BinaryPatcher.cs create mode 100644 SEGATools/Binary/InitialProgramPatches.cs create mode 100644 SEGATools/Binary/SEGALibrary.cs create mode 100644 SEGATools/Binary/SEGALibraryType.cs create mode 100644 SEGATools/Binary/SEGALibraryVersion.cs create mode 100644 SEGATools/CueSheet/CueSheetCreator.cs create mode 100644 SEGATools/Disc/DiscExtractor.cs create mode 100644 SEGATools/Disc/DiscExtractorException.cs create mode 100644 SEGATools/Disc/DiscFormatProvider.cs create mode 100644 SEGATools/Disc/DiscOpener.cs create mode 100644 SEGATools/Disc/DiscSectorEncoder.cs create mode 100644 SEGATools/DiscFileSystem/DiscFileSystem.cs create mode 100644 SEGATools/DiscFileSystem/DiscFileSystemBuilder.cs create mode 100644 SEGATools/DiscFileSystem/DiscFileUtils.cs create mode 100644 SEGATools/DiscFileSystem/DiscFormatException.cs create mode 100644 SEGATools/DiscFileSystem/DiscImageType.cs create mode 100644 SEGATools/DiscFileSystem/DiscSession.cs create mode 100644 SEGATools/DiscFileSystem/DiscTrack.cs create mode 100644 SEGATools/DiscFileSystem/GenericImageConverter.cs create mode 100644 SEGATools/DiscFileSystem/IDiscFileSystem.cs create mode 100644 SEGATools/DiscFileSystem/IDiscFileSystemConverter.cs create mode 100644 SEGATools/DiscFileSystem/IDiscSession.cs create mode 100644 SEGATools/DiscFileSystem/IDiscTrack.cs create mode 100644 SEGATools/DiscFileSystem/TrackModeType.cs create mode 100644 SEGATools/Encrypt/DESKey.cs create mode 100644 SEGATools/Encrypt/DesEncryptDecryptTool.cs create mode 100644 SEGATools/FileFormat/AbstractImageFileFormat.cs create mode 100644 SEGATools/FileFormat/IImageFileFormat.cs create mode 100644 SEGATools/Formater/SizeFormater.cs create mode 100644 SEGATools/GDEmu/DiscTrackCopyInfo.cs create mode 100644 SEGATools/GDEmu/GDEmuConverter.cs create mode 100644 SEGATools/GDEmu/GDEmuExportOptions.cs create mode 100644 SEGATools/GDEmu/GDICreator.cs create mode 100644 SEGATools/Graphics/MRImage.cs create mode 100644 SEGATools/Graphics/MRImageColor.cs create mode 100644 SEGATools/Graphics/MRImageConverter.cs create mode 100644 SEGATools/Graphics/MRImageDecompressionException.cs create mode 100644 SEGATools/Graphics/MRImageExporter.cs create mode 100644 SEGATools/Graphics/MRImageHeader.cs create mode 100644 SEGATools/Graphics/MRImageIdentifierMissingException.cs create mode 100644 SEGATools/Graphics/MRImageReadingException.cs create mode 100644 SEGATools/Graphics/MRImageUnknownColorException.cs create mode 100644 SEGATools/Graphics/MRImageViewer.cs create mode 100644 SEGATools/Graphics/MRImageViewer.resx create mode 100644 SEGATools/HashAlgorithm/ECC.cs create mode 100644 SEGATools/HashAlgorithm/EDC.cs create mode 100644 SEGATools/ImageReader/DiscFileSystem/DiscFileSystemException.cs create mode 100644 SEGATools/Logger.cs create mode 100644 SEGATools/Properties/Resources.cs create mode 100644 SEGATools/Properties/Resources.resx create mode 100644 SEGATools/Registry/EditFlags.cs create mode 100644 SEGATools/Registry/FileAssociationInfo.cs create mode 100644 SEGATools/Registry/PerceivedTypes.cs create mode 100644 SEGATools/Registry/ProgramAssociationInfo.cs create mode 100644 SEGATools/Registry/ProgramIcon.cs create mode 100644 SEGATools/Registry/ProgramVerb.cs create mode 100644 SEGATools/Registry/RegistryException.cs create mode 100644 SEGATools/Registry/RegistryWrapper.cs create mode 100644 SEGATools/Registry/ShellNotification.cs create mode 100644 SEGATools/SEGATools.csproj create mode 100644 SEGATools/Scanner/FileScanner.cs create mode 100644 SEGATools/Scanner/FileScannerException.cs create mode 100644 SEGATools/Scanner/FileScannerPattern.cs create mode 100644 SEGATools/Scanner/FileScannerResultConverterException.cs create mode 100644 SEGATools/Scanner/FileScannerResultConverterForSEGALibrary.cs create mode 100644 SEGATools/Scanner/FileScannerWrongArgumentsException.cs create mode 100644 SEGATools/Scanner/IFileScannerResultConverter`1.cs create mode 100644 SEGATools/Security/InitialProgram.cs create mode 100644 SEGATools/Security/InitialProgramConverter.cs create mode 100644 SEGATools/Security/InitialProgramException.cs create mode 100644 SEGATools/Security/InitialProgramExtended.cs create mode 100644 SEGATools/Security/InitialProgramFieldParsingException.cs create mode 100644 SEGATools/Security/InitialProgramGeneralSettingsViewer.cs create mode 100644 SEGATools/Security/InitialProgramGeneralSettingsViewer.resx create mode 100644 SEGATools/Security/InitialProgramImagesViewer.cs create mode 100644 SEGATools/Security/InitialProgramImagesViewer.resx create mode 100644 SEGATools/Security/InitialProgramInvalidHardwareIdException.cs create mode 100644 SEGATools/Security/InitialProgramInvalidMRImageException.cs create mode 100644 SEGATools/Security/InitialProgramInvalidMakerIdException.cs create mode 100644 SEGATools/Security/InitialProgramLibraryReferences.cs create mode 100644 SEGATools/Security/InitialProgramLibraryReferences.resx create mode 100644 SEGATools/Security/InitialProgramPeripheralsViewer.cs create mode 100644 SEGATools/Security/InitialProgramPeripheralsViewer.resx create mode 100644 SEGATools/Security/InitialProgramReleaseDateParsingException.cs create mode 100644 SEGATools/Security/InitialProgramToc.cs create mode 100644 SEGATools/Security/InitialProgramTocConverter.cs create mode 100644 SEGATools/Security/InitialProgramTocException.cs create mode 100644 SEGATools/Security/InitialProgramTocIdentifierMissingException.cs create mode 100644 SEGATools/Security/InitialProgramTocTrackBuilder.cs create mode 100644 SEGATools/Security/InitialProgramTocViewer.cs create mode 100644 SEGATools/Security/InitialProgramTocViewer.resx create mode 100644 SEGATools/Security/InitialProgramTocWrongControlDataException.cs create mode 100644 SEGATools/Security/InitialProgramTocWrongNumberOfTracksException.cs create mode 100644 SEGATools/Security/InitialProgramTrackInfo.cs create mode 100644 SEGATools/Security/InitialProgramUtils.cs create mode 100644 SEGATools/Security/SupportedAreas.cs create mode 100644 SEGATools/Security/SupportedButtons.cs create mode 100644 SEGATools/Security/SupportedExpandedPeripherals.cs create mode 100644 SEGATools/Security/SupportedPeripherals.cs create mode 100644 SEGATools/SortFile/SortFileCreator.cs create mode 100644 SEGATools/Stream/SubStream.cs create mode 100644 SEGATools/UserProcess/AsyncOperationCompletedEventHandler.cs create mode 100644 SEGATools/UserProcess/AsyncOperationProgressChangedEventHandler.cs create mode 100644 SEGATools/UserProcess/AsyncOperationProgressUpdateUIEventHandler.cs create mode 100644 SEGATools/UserProcess/AsyncOperationProgressWaitingForUserConsentEventHa.cs create mode 100644 SEGATools/UserProcess/UserProcessBase.cs create mode 100644 SEGATools/UserProcess/UserProcessCompletedEventArgs.cs create mode 100644 SEGATools/UserProcess/UserProcessProgressChangedEventArgs.cs create mode 100644 SEGATools/UserProcess/UserProcessUpdateUIViewEventArgs.cs create mode 100644 SEGATools/UserProcess/UserProcessWaitingForUserConsentEventArgs.cs create mode 100644 SEGATools/UserProcess/UserProcessWaitingForUserConsentFileConflictEventA.cs create mode 100644 SEGATools/VirtualFile/IVirtualFile.cs create mode 100644 SEGATools/VirtualFile/IVirtualFile`1.cs create mode 100644 SEGATools/VirtualFile/VirtualFileBase`1.cs create mode 100644 SEGATools/VirtualFile/VirtualFileDirectoryRecord.cs create mode 100644 SEGATools/VirtualFile/VirtualFileFactory.cs create mode 100644 SEGATools/VirtualFile/VirtualFileInitialProgramExtended.cs create mode 100644 SEGATools/VirtualFile/VirtualFileOnDisc.cs create mode 100644 SEGATools/VirtualFile/VirtualFileStream.cs create mode 100644 SEGATools/app.config create mode 100644 SEGATools/packages.config diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..a7cc6c9 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,141 @@ +root = true +; EditorConfig to support per-solution formatting. Use the EditorConfig VS add-in to make this work. http://editorconfig.org/ + +[*.cs] +dotnet_style_qualification_for_field = false:warning +dotnet_style_qualification_for_property = false:warning +dotnet_style_qualification_for_method = false:warning +dotnet_style_qualification_for_event = false:warning +dotnet_style_predefined_type_for_locals_parameters_members = true:warning +dotnet_style_predefined_type_for_member_access = true:warning +dotnet_style_object_initializer = true:error +dotnet_style_collection_initializer = true:error +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_coalesce_expression = true:error +dotnet_style_null_propagation = true:error +csharp_style_var_for_built_in_types = true:warning +csharp_style_var_when_type_is_apparent = true:warning +csharp_style_var_elsewhere = true:warning +csharp_style_expression_bodied_methods = true:warning +csharp_style_expression_bodied_constructors = true:warning +csharp_style_expression_bodied_operators = true:error +csharp_style_expression_bodied_properties = true:warning +csharp_style_expression_bodied_indexers = true:error +csharp_style_expression_bodied_accessors = true:warning +csharp_style_pattern_matching_over_is_with_cast_check = true:suggestion +csharp_style_pattern_matching_over_as_with_null_check = true:suggestion +csharp_style_inlined_variable_declaration = true:suggestion +csharp_style_throw_expression = false:suggestion +csharp_style_conditional_delegate_call = true:error +csharp_indent_switch_labels = false +csharp_indent_labels = one_less_than_current +csharp_prefer_simple_using_statement = true:warning +deltaengine_max_method_lines = 15 +deltaengine_max_parameters = 4 +deltaengine_max_fields = 12 +deltaengine_max_methods = 30 +deltaengine_max_public_methods = 10 +deltaengine_max_class_lines = 400 +deltaengine_max_nesting_depth = 4 + +# Microsoft .NET properties +csharp_preferred_modifier_order = public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:warning +csharp_space_after_cast = false +dotnet_naming_rule.constants_rule.import_to_resharper = as_predefined +dotnet_naming_rule.constants_rule.severity = warning +dotnet_naming_rule.constants_rule.style = upper_camel_case_style +dotnet_naming_rule.constants_rule.symbols = constants_symbols +dotnet_naming_rule.interfaces_rule.import_to_resharper = as_predefined +dotnet_naming_rule.interfaces_rule.severity = warning +dotnet_naming_rule.interfaces_rule.style = upper_camel_case_style +dotnet_naming_rule.interfaces_rule.symbols = interfaces_symbols +dotnet_naming_rule.local_constants_rule.import_to_resharper = as_predefined +dotnet_naming_rule.local_constants_rule.severity = warning +dotnet_naming_rule.local_constants_rule.style = upper_camel_case_style +dotnet_naming_rule.local_constants_rule.symbols = local_constants_symbols +dotnet_naming_rule.private_constants_rule.import_to_resharper = as_predefined +dotnet_naming_rule.private_constants_rule.severity = warning +dotnet_naming_rule.private_constants_rule.style = upper_camel_case_style +dotnet_naming_rule.private_constants_rule.symbols = private_constants_symbols +dotnet_naming_rule.private_instance_fields_rule.import_to_resharper = as_predefined +dotnet_naming_rule.private_instance_fields_rule.severity = warning +dotnet_naming_rule.private_instance_fields_rule.style = lower_camel_case_style +dotnet_naming_rule.private_instance_fields_rule.symbols = private_instance_fields_symbols +dotnet_naming_rule.private_static_fields_rule.import_to_resharper = as_predefined +dotnet_naming_rule.private_static_fields_rule.severity = warning +dotnet_naming_rule.private_static_fields_rule.style = lower_camel_case_style +dotnet_naming_rule.private_static_fields_rule.symbols = private_static_fields_symbols +dotnet_naming_rule.private_static_readonly_rule.import_to_resharper = as_predefined +dotnet_naming_rule.private_static_readonly_rule.severity = warning +dotnet_naming_rule.private_static_readonly_rule.style = upper_camel_case_style +dotnet_naming_rule.private_static_readonly_rule.symbols = private_static_readonly_symbols +dotnet_naming_rule.public_fields_rule.import_to_resharper = as_predefined +dotnet_naming_rule.public_fields_rule.severity = none +dotnet_naming_rule.public_fields_rule.style = lower_camel_case_style +dotnet_naming_rule.public_fields_rule.symbols = public_fields_symbols +dotnet_naming_rule.static_readonly_rule.import_to_resharper = as_predefined +dotnet_naming_rule.static_readonly_rule.severity = warning +dotnet_naming_rule.static_readonly_rule.style = upper_camel_case_style +dotnet_naming_rule.static_readonly_rule.symbols = static_readonly_symbols +dotnet_naming_rule.type_parameters_rule.import_to_resharper = as_predefined +dotnet_naming_rule.type_parameters_rule.severity = warning +dotnet_naming_rule.type_parameters_rule.style = upper_camel_case_style +dotnet_naming_rule.type_parameters_rule.symbols = type_parameters_symbols +dotnet_naming_rule.unity_serialized_field_rule.import_to_resharper = True +dotnet_naming_rule.unity_serialized_field_rule.resharper_description = Unity serialized field +dotnet_naming_rule.unity_serialized_field_rule.resharper_guid = 5f0fdb63-c892-4d2c-9324-15c80b22a7ef +dotnet_naming_rule.unity_serialized_field_rule.severity = warning +dotnet_naming_rule.unity_serialized_field_rule.style = lower_camel_case_style +dotnet_naming_rule.unity_serialized_field_rule.symbols = unity_serialized_field_symbols +dotnet_naming_style.lower_camel_case_style.capitalization = camel_case +dotnet_naming_style.upper_camel_case_style.capitalization = pascal_case +dotnet_naming_symbols.constants_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected +dotnet_naming_symbols.constants_symbols.applicable_kinds = field +dotnet_naming_symbols.constants_symbols.required_modifiers = const +dotnet_naming_symbols.interfaces_symbols.applicable_accessibilities = * +dotnet_naming_symbols.interfaces_symbols.applicable_kinds = interface +dotnet_naming_symbols.local_constants_symbols.applicable_accessibilities = * +dotnet_naming_symbols.local_constants_symbols.applicable_kinds = local +dotnet_naming_symbols.local_constants_symbols.required_modifiers = const +dotnet_naming_symbols.private_constants_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_constants_symbols.applicable_kinds = field +dotnet_naming_symbols.private_constants_symbols.required_modifiers = const +dotnet_naming_symbols.private_instance_fields_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_instance_fields_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_fields_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_static_fields_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_fields_symbols.required_modifiers = static +dotnet_naming_symbols.private_static_readonly_symbols.applicable_accessibilities = private +dotnet_naming_symbols.private_static_readonly_symbols.applicable_kinds = field +dotnet_naming_symbols.private_static_readonly_symbols.required_modifiers = static,readonly +dotnet_naming_symbols.public_fields_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected +dotnet_naming_symbols.public_fields_symbols.applicable_kinds = field +dotnet_naming_symbols.static_readonly_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected +dotnet_naming_symbols.static_readonly_symbols.applicable_kinds = field +dotnet_naming_symbols.static_readonly_symbols.required_modifiers = static,readonly +dotnet_naming_symbols.type_parameters_symbols.applicable_accessibilities = * +dotnet_naming_symbols.type_parameters_symbols.applicable_kinds = type_parameter +dotnet_naming_symbols.unity_serialized_field_symbols.applicable_accessibilities = * +dotnet_naming_symbols.unity_serialized_field_symbols.applicable_kinds = unity_serialised_field +dotnet_naming_symbols.unity_serialized_field_symbols.resharper_applicable_kinds = unity_serialised_field +dotnet_naming_symbols.unity_serialized_field_symbols.resharper_required_modifiers = instance +dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none +dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none +dotnet_style_require_accessibility_modifiers = for_non_interface_members:suggestion + +[*] +end_of_line = crlf +indent_style = spc +indent_size = 2 +max_line_length = 100 +trim_trailing_whitespace = true +charset = utf8 + +[*.{proto,shader}] +indent_style = spc +indent_size = 2 + +[*.{appxmanifest,asax,ascx,aspx,axaml,axml,build,config,cs,cshtml,csproj,css,dbml,discomap,dtd,htm,html,jsproj,lsproj,master,njsproj,nuspec,paml,proj,props,razor,resw,resx,skin,StyleCop,targets,tasks,vb,vbproj,xaml,xamlx,xml,xoml,xsd}] +indent_style = spc +indent_size = 2 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..82b4317 --- /dev/null +++ b/.gitignore @@ -0,0 +1,387 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Nuget personal access tokens and Credentials +nuget.config + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +.idea/ +*.sln.iml diff --git a/Explorer/AppStatus.cs b/Explorer/AppStatus.cs new file mode 100644 index 0000000..927ce61 --- /dev/null +++ b/Explorer/AppStatus.cs @@ -0,0 +1,22 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.AppStatus +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer +{ + public class AppStatus + { + public static void NotifyNewAppStatus(string message) + { + if (AppStatus.OnAppStatusUpdate == null) + return; + AppStatus.OnAppStatusUpdate(message); + } + + public static event AppStatus.AppStatusUpdateEventHandler OnAppStatusUpdate; + + public delegate void AppStatusUpdateEventHandler(string message); + } +} diff --git a/Explorer/AssemblyGitBuildBranch.cs b/Explorer/AssemblyGitBuildBranch.cs new file mode 100644 index 0000000..946e3f8 --- /dev/null +++ b/Explorer/AssemblyGitBuildBranch.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.AssemblyGitBuildBranch +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; + +namespace GDRomExplorer +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildBranch : Attribute + { + public string GitBuildBranch { get; private set; } + + public AssemblyGitBuildBranch(string txt) => this.GitBuildBranch = txt; + } +} diff --git a/Explorer/AssemblyGitBuildSHA1.cs b/Explorer/AssemblyGitBuildSHA1.cs new file mode 100644 index 0000000..4fc543d --- /dev/null +++ b/Explorer/AssemblyGitBuildSHA1.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.AssemblyGitBuildSHA1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; + +namespace GDRomExplorer +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildSHA1 : Attribute + { + public string GitBuildSHA1 { get; private set; } + + public AssemblyGitBuildSHA1(string txt) => this.GitBuildSHA1 = txt; + } +} diff --git a/Explorer/AssemblyInfo.cs b/Explorer/AssemblyInfo.cs new file mode 100644 index 0000000..ef5aee9 --- /dev/null +++ b/Explorer/AssemblyInfo.cs @@ -0,0 +1,18 @@ +using GDRomExplorer; +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyGitBuildSHA1("fd2eb45")] +[assembly: AssemblyGitBuildBranch("release_1.6.3")] +[assembly: AssemblyFileVersion("1.6.3")] +[assembly: AssemblyTitle("GD-ROM Explorer")] +[assembly: AssemblyDescription("GD-ROM Explorer for Dreamcast and Naomi disc images")] +[assembly: ComVisible(true)] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyConfiguration("")] +[assembly: Guid("028a0854-6263-4b97-8b78-7512902f19d5")] +[assembly: AssemblyProduct("GD-ROM Explorer")] +[assembly: AssemblyCopyright("2010 - 2016")] +[assembly: AssemblyVersion("1.6.3.0")] +//[assembly: log4net.Config.XmlConfigurator(ConfigFile = "log4net.config",Watch = true)] diff --git a/Explorer/DiscView/ContextMenuManager.cs b/Explorer/DiscView/ContextMenuManager.cs new file mode 100644 index 0000000..c87458e --- /dev/null +++ b/Explorer/DiscView/ContextMenuManager.cs @@ -0,0 +1,40 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.ContextMenuManager +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class ContextMenuManager + { + private MenuItemFactory Context; + private ContextMenuStrip LastDisplayedContextMenu; + + public ContextMenuManager(MenuItemFactory Context) => this.Context = Context; + + public ContextMenuStrip CreateContextMenu(ToolStripItem[] MenuItems) + { + ContextMenuStrip contextMenuStrip = new ContextMenuStrip(); + contextMenuStrip.Items.AddRange(MenuItems); + return contextMenuStrip; + } + + public ContextMenuStrip CreateAndShowContextMenu(ToolStripItem[] MenuItems) + { + this.CloseContextMenuIfAny(); + this.LastDisplayedContextMenu = this.CreateContextMenu(MenuItems); + this.LastDisplayedContextMenu.Show(Cursor.Position); + return this.LastDisplayedContextMenu; + } + + public void CloseContextMenuIfAny() + { + if (this.LastDisplayedContextMenu == null) + return; + this.LastDisplayedContextMenu.Close(); + } + } +} diff --git a/Explorer/DiscView/DiscListViewSelectionHandlerFactory.cs b/Explorer/DiscView/DiscListViewSelectionHandlerFactory.cs new file mode 100644 index 0000000..d8491d8 --- /dev/null +++ b/Explorer/DiscView/DiscListViewSelectionHandlerFactory.cs @@ -0,0 +1,29 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.DiscListViewSelectionHandlerFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.UserControls; +using ImageReader.ISO9660.DirectoryRecords; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class DiscListViewSelectionHandlerFactory : DiscSelectionHandlerFactory + { + public DiscListViewSelectionHandlerFactory(DiscViewExplorer Context, ListView Control) + : base(Context, Control) + { + } + + private DiscViewSelection> newSelectionHandlers( + IList DirectoryRecords) + { + return DiscViewSelection>.NewHandlersForListView(new DiscViewSelection>.SelectionHandler>(this.Context.DirectoryRecords_MouseRightClickHandler), new DiscViewSelection>.SelectionHandler>(this.Context.DirectoryRecords_MouseLeftClickHandler), new DiscViewSelection>.SelectionHandler>(this.Context.DirectoryRecords_MouseDoubleLeftClicksHandler), DirectoryRecords); + } + + public override IDiscViewSelection newSelectionHandlers(object Handle) => Handle is IList ? (IDiscViewSelection) this.newSelectionHandlers(Handle as IList) : (IDiscViewSelection) null; + } +} diff --git a/Explorer/DiscView/DiscSelectionHandlerFactory.cs b/Explorer/DiscView/DiscSelectionHandlerFactory.cs new file mode 100644 index 0000000..9618187 --- /dev/null +++ b/Explorer/DiscView/DiscSelectionHandlerFactory.cs @@ -0,0 +1,13 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.DiscSelectionHandlerFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer.DiscView +{ + public interface DiscSelectionHandlerFactory + { + IDiscViewSelection newSelectionHandlers(object Handle); + } +} diff --git a/Explorer/DiscView/DiscSelectionHandlerFactory`1.cs b/Explorer/DiscView/DiscSelectionHandlerFactory`1.cs new file mode 100644 index 0000000..f579614 --- /dev/null +++ b/Explorer/DiscView/DiscSelectionHandlerFactory`1.cs @@ -0,0 +1,24 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.DiscSelectionHandlerFactory`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.UserControls; + +namespace GDRomExplorer.DiscView +{ + public abstract class DiscSelectionHandlerFactory : DiscSelectionHandlerFactory + { + protected DiscViewExplorer Context; + private T Control; + + public DiscSelectionHandlerFactory(DiscViewExplorer Context, T Control) + { + this.Context = Context; + this.Control = Control; + } + + public abstract IDiscViewSelection newSelectionHandlers(object Handle); + } +} diff --git a/Explorer/DiscView/DiscTreeViewSelectionHandlerFactory.cs b/Explorer/DiscView/DiscTreeViewSelectionHandlerFactory.cs new file mode 100644 index 0000000..b931c0d --- /dev/null +++ b/Explorer/DiscView/DiscTreeViewSelectionHandlerFactory.cs @@ -0,0 +1,71 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.DiscTreeViewSelectionHandlerFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.UserControls; +using ImageReader.ISO9660.DirectoryRecords; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class DiscTreeViewSelectionHandlerFactory : DiscSelectionHandlerFactory + { + public DiscTreeViewSelectionHandlerFactory(DiscViewExplorer Context, TreeView Control) + : base(Context, Control) + { + } + + private DiscViewSelection newSelectionHandlers( + IDiscFileSystem discFileSystem) + { + return DiscViewSelection.NewHandlersForTreeView(new DiscViewSelection.SelectionHandler(this.Context.Disc_AfterSelectHandler), new DiscViewSelection.SelectionHandler(this.Context.Disc_MouseRightClickHandler), (DiscViewSelection.SelectionHandler) null, discFileSystem); + } + + private DiscViewSelection newSelectionHandlers( + DirectoryRecord DirectoryRecord) + { + return DiscViewSelection.NewHandlersForTreeView(new DiscViewSelection.SelectionHandler(this.Context.DirectoryRecord_AfterSelectClickHandler), new DiscViewSelection.SelectionHandler(this.Context.DirectoryRecord_MouseRightClickHandler), (DiscViewSelection.SelectionHandler) null, DirectoryRecord); + } + + private DiscViewSelection newSelectionHandlers( + InitialProgramExtended InitialProgram) + { + return DiscViewSelection.NewHandlersForTreeView(new DiscViewSelection.SelectionHandler(this.Context.InitialProgram_AfterSelectHandler), new DiscViewSelection.SelectionHandler(this.Context.InitialProgram_MouseRightClickHandler), new DiscViewSelection.SelectionHandler(this.Context.InitialProgram_MouseDoubleLeftClicksHandler), InitialProgram); + } + + private DiscViewSelection newSelectionHandlers( + IDiscSession DiscSession) + { + return DiscViewSelection.NewHandlersForTreeView(new DiscViewSelection.SelectionHandler(this.Context.DiscSession_AfterSelectHandler), new DiscViewSelection.SelectionHandler(this.Context.DiscSession_MouseRightClickHandler), (DiscViewSelection.SelectionHandler) null, DiscSession); + } + + private DiscViewSelection newSelectionHandlers( + IDiscTrack DiscTrack) + { + return DiscViewSelection.NewHandlersForTreeView(new DiscViewSelection.SelectionHandler(this.Context.DiscTrack_AfterSelectHandler), new DiscViewSelection.SelectionHandler(this.Context.DiscTrack_MouseRightClickHandler), (DiscViewSelection.SelectionHandler) null, DiscTrack); + } + + public override IDiscViewSelection newSelectionHandlers(object Handle) + { + switch (Handle) + { + case IDiscFileSystem _: + return (IDiscViewSelection) this.newSelectionHandlers(Handle as IDiscFileSystem); + case IDiscSession _: + return (IDiscViewSelection) this.newSelectionHandlers(Handle as IDiscSession); + case IDiscTrack _: + return (IDiscViewSelection) this.newSelectionHandlers(Handle as IDiscTrack); + case InitialProgramExtended _: + return (IDiscViewSelection) this.newSelectionHandlers(Handle as InitialProgramExtended); + case DirectoryRecord _: + return (IDiscViewSelection) this.newSelectionHandlers(Handle as DirectoryRecord); + default: + return (IDiscViewSelection) null; + } + } + } +} diff --git a/Explorer/DiscView/DiscViewSelection`1.cs b/Explorer/DiscView/DiscViewSelection`1.cs new file mode 100644 index 0000000..84c6818 --- /dev/null +++ b/Explorer/DiscView/DiscViewSelection`1.cs @@ -0,0 +1,107 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.DiscViewSelection`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class DiscViewSelection : IDiscViewSelection + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private DiscViewSelection.SelectionHandler AfterSelectHandler; + private DiscViewSelection.SelectionHandler RightClickHandler; + private DiscViewSelection.SelectionHandler LeftClickHandler; + private DiscViewSelection.SelectionHandler DoubleLeftClickHandler; + private Selection Handle; + + private DiscViewSelection( + DiscViewSelection.SelectionHandler AfterSelectHandler, + DiscViewSelection.SelectionHandler RightClickHandler, + DiscViewSelection.SelectionHandler LeftClickHandler, + DiscViewSelection.SelectionHandler DoubleLeftClickHandler, + Selection Handle) + { + this.AfterSelectHandler = AfterSelectHandler; + this.RightClickHandler = RightClickHandler; + this.LeftClickHandler = LeftClickHandler; + this.DoubleLeftClickHandler = DoubleLeftClickHandler; + this.Handle = Handle; + } + + public static DiscViewSelection NoHandler(Selection Handle) => new DiscViewSelection((DiscViewSelection.SelectionHandler) null, (DiscViewSelection.SelectionHandler) null, (DiscViewSelection.SelectionHandler) null, (DiscViewSelection.SelectionHandler) null, Handle); + + public static DiscViewSelection NewHandlersForTreeView( + DiscViewSelection.SelectionHandler AfterSelectHandler, + DiscViewSelection.SelectionHandler RightClickHandler, + DiscViewSelection.SelectionHandler DoubleLeftClickHandler, + Selection Handle) + { + return new DiscViewSelection(AfterSelectHandler, RightClickHandler, (DiscViewSelection.SelectionHandler) null, DoubleLeftClickHandler, Handle); + } + + public static DiscViewSelection NewHandlersForListView( + DiscViewSelection.SelectionHandler RightClickHandler, + DiscViewSelection.SelectionHandler LeftClickHandler, + DiscViewSelection.SelectionHandler DoubleLeftClickHandler, + Selection Handle) + { + return new DiscViewSelection((DiscViewSelection.SelectionHandler) null, RightClickHandler, LeftClickHandler, DoubleLeftClickHandler, Handle); + } + + public void HandleAfterSelect() + { + if (this.AfterSelectHandler == null) + return; + this.AfterSelectHandler(this.Handle); + } + + public void HandleLeftClick() + { + if (this.LeftClickHandler == null) + return; + this.LeftClickHandler(this.Handle); + } + + public void HandleDoubleLeftClicks() + { + if (this.DoubleLeftClickHandler == null) + return; + this.DoubleLeftClickHandler(this.Handle); + } + + public void HandleRightClick() + { + if (this.RightClickHandler == null) + return; + this.RightClickHandler(this.Handle); + } + + public void HandleMouseEvent(MouseEventArgs MouseEvent) + { + switch (MouseEvent.Button) + { + case MouseButtons.Left: + if (MouseEvent.Clicks == 1) + { + this.HandleLeftClick(); + return; + } + if (MouseEvent.Clicks == 2) + { + this.HandleDoubleLeftClicks(); + return; + } + break; + case MouseButtons.Right: + this.HandleRightClick(); + return; + } + DiscViewSelection.logger.DebugFormat("No handler for {0} with {1} click(s) mouse button(s) {2}", (object) this.Handle, (object) MouseEvent.Clicks, (object) MouseEvent.Button); + } + + public delegate void SelectionHandler(HandleType handle); + } +} diff --git a/Explorer/DiscView/ExplorerListItemFactory.cs b/Explorer/DiscView/ExplorerListItemFactory.cs new file mode 100644 index 0000000..207f22d --- /dev/null +++ b/Explorer/DiscView/ExplorerListItemFactory.cs @@ -0,0 +1,54 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.ExplorerListItemFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using ImageReader.ISO9660.DirectoryRecords; +using SEGATools.DiscFileSystem; +using SEGATools.Formater; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class ExplorerListItemFactory + { + public static ListViewItem CreateItem( + DirectoryRecord DirectoryRecord, + IDiscFileSystem Disc) + { + ListViewItem listViewItem = new ListViewItem(DirectoryRecord.Name, DirectoryRecord.IsDirectory ? 1 : 0); + listViewItem.Name = DirectoryRecord.Name; + listViewItem.Tag = (object) DirectoryRecord; + listViewItem.UseItemStyleForSubItems = true; + listViewItem.ToolTipText = ExplorerToolTipFactory.CreateToolTipText(DirectoryRecord); + listViewItem.SubItems.Add(SizeFormater.ToHumanReadableSize((long) DirectoryRecord.ExtentSize)); + listViewItem.SubItems.Add(DirectoryRecord.ExtentSize.ToString()); + listViewItem.SubItems.Add(DirectoryRecord.Extent.ToString()); + if (DirectoryRecord.RecordingDateTime.HasValue) + listViewItem.SubItems.Add(string.Format("{0:G}", (object) DirectoryRecord.RecordingDateTime)); + else + listViewItem.SubItems.Add(Strings.InvalidDateTimeText); + if (!DirectoryRecord.HasValidFileIdentifier) + { + listViewItem.BackColor = Color.OrangeRed; + listViewItem.ForeColor = Color.White; + listViewItem.ToolTipText = Strings.ToolTipInvalidFileIdentifier; + } + else if (Disc.MainBinary != null && Disc.MainBinary.FullPath.Equals(DirectoryRecord.FullPath)) + { + listViewItem.Font = new Font(listViewItem.Font, FontStyle.Bold); + listViewItem.ToolTipText = string.Format(Strings.ToolTipMainBinaryWithFormat, (object) DirectoryRecord.Name); + } + return listViewItem; + } + + public static ListViewItem CreateParentDirectoryItem(DirectoryRecord DirectoryRecord) => new ListViewItem(DirectoryRecord.PARENT_DIRECTORY_NAME, 2) + { + Name = DirectoryRecord.PARENT_DIRECTORY_NAME, + Tag = (object) DirectoryRecord + }; + } +} diff --git a/Explorer/DiscView/ExplorerToolTipFactory.cs b/Explorer/DiscView/ExplorerToolTipFactory.cs new file mode 100644 index 0000000..cc08864 --- /dev/null +++ b/Explorer/DiscView/ExplorerToolTipFactory.cs @@ -0,0 +1,29 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.ExplorerToolTipFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using ImageReader.ISO9660.DirectoryRecords; +using SEGATools.Formater; +using System.Text; + +namespace GDRomExplorer.DiscView +{ + public class ExplorerToolTipFactory + { + public static string CreateToolTipText(DirectoryRecord directoryRecord) + { + StringBuilder stringBuilder = new StringBuilder(); + if (directoryRecord.IsDirectory) + { + stringBuilder.AppendLine(string.Format(Strings.ToolTipFileSizeWithFormat, (object) SizeFormater.ToHumanReadableSize((long) directoryRecord.UsedSpace))); + int count1 = directoryRecord.GetAllSubFiles().Count; + int count2 = directoryRecord.GetAllSubFolder().Count; + stringBuilder.AppendLine(string.Format(Strings.ToolTipDirectoryContentWithFormat, (object) count1, count1 > 1 ? (object) Strings.ToolTipFiles : (object) Strings.ToolTipFile, (object) count2, count2 > 1 ? (object) Strings.ToolTipDirectories : (object) Strings.ToolTipDirectory)); + } + return stringBuilder.ToString(); + } + } +} diff --git a/Explorer/DiscView/ExplorerTreeNodeFactory.cs b/Explorer/DiscView/ExplorerTreeNodeFactory.cs new file mode 100644 index 0000000..8cea15a --- /dev/null +++ b/Explorer/DiscView/ExplorerTreeNodeFactory.cs @@ -0,0 +1,135 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.ExplorerTreeNodeFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using ImageReader.ISO9660.DirectoryRecords; +using SEGATools.Binary; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using System; +using System.Collections.Generic; +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class ExplorerTreeNodeFactory + { + public static TreeNode CreateTree(IDiscFileSystem Disc) + { + TreeNode treeNode1 = ExplorerTreeNodeFactory.CreateTreeNode(Disc); + foreach (IDiscSession session in Disc.Sessions) + { + TreeNode treeNode2 = ExplorerTreeNodeFactory.CreateTreeNode(session); + treeNode1.Nodes.Add(treeNode2); + foreach (IDiscTrack track in session.Tracks) + { + TreeNode treeNode3 = ExplorerTreeNodeFactory.CreateTreeNode(track); + treeNode2.Nodes.Add(treeNode3); + if (track == session.FirstDataTrack) + { + if (session.BootStrap != null) + { + TreeNode treeNode4 = ExplorerTreeNodeFactory.CreateTreeNode(session.BootStrap, Disc); + treeNode3.Nodes.Add(treeNode4); + } + if (session.RootDirectoryRecord != null) + { + string identifier = session.PrimaryVolumeDescriptor.Identifier; + TreeNode discFileSystemTree = ExplorerTreeNodeFactory.CreateDiscFileSystemTree(session.RootDirectoryRecord, identifier); + treeNode3.Nodes.Add(discFileSystemTree); + } + } + } + } + return treeNode1; + } + + private static TreeNode CreateDiscFileSystemTree( + DirectoryRecord RootDirectoryRecord, + string RootDirectoryName) + { + TreeNode treeNode = ExplorerTreeNodeFactory.CreateTreeNode(RootDirectoryRecord, RootDirectoryName, 5, 5); + ExplorerTreeNodeFactory.CreateDiscFileSystemTreeRec(treeNode); + return treeNode; + } + + private static void CreateDiscFileSystemTreeRec(TreeNode ParentNode) + { + foreach (DirectoryRecord DirectoryRecord in (IEnumerable) (ParentNode.Tag as DirectoryRecord).SubDirectories.FindAll((Predicate) (directoryRecord => directoryRecord.IsDirectory))) + { + TreeNode treeNode = ExplorerTreeNodeFactory.CreateTreeNode(DirectoryRecord, 6, 7); + ParentNode.Nodes.Add(treeNode); + ExplorerTreeNodeFactory.CreateDiscFileSystemTreeRec(treeNode); + } + } + + private static TreeNode CreateTreeNode( + DirectoryRecord DirectoryRecord, + int ImageIndex, + int SelectedImageIndex) + { + return ExplorerTreeNodeFactory.CreateTreeNode(DirectoryRecord, DirectoryRecord.Name, ImageIndex, SelectedImageIndex); + } + + private static TreeNode CreateTreeNode( + DirectoryRecord DirectoryRecord, + string Name, + int ImageIndex, + int SelectedImageIndex) + { + return new TreeNode(Name, ImageIndex, SelectedImageIndex) + { + Name = Name, + Tag = (object) DirectoryRecord, + ToolTipText = ExplorerToolTipFactory.CreateToolTipText(DirectoryRecord) + }; + } + + private static TreeNode CreateTreeNode( + InitialProgram InitialProgram, + IDiscFileSystem Disc) + { + List segaLibraries = Disc.GetSEGALibraries((object) InitialProgram); + InitialProgramExtended initialProgramExtended = InitialProgramExtended.create(InitialProgram, segaLibraries); + return new TreeNode(initialProgramExtended.FileName, 4, 4) + { + Name = initialProgramExtended.FileName, + Tag = (object) initialProgramExtended + }; + } + + private static TreeNode CreateTreeNode(IDiscTrack DiscTrack) + { + TreeNode treeNode = new TreeNode(DiscTrack.ToString()); + switch (DiscTrack.TrackData) + { + case TrackModeType.Audio: + treeNode.ImageIndex = 3; + treeNode.ToolTipText = string.Format("CD-DA ({0})", (object) DiscTrack.Name); + break; + case TrackModeType.Data: + treeNode.ImageIndex = 2; + treeNode.ToolTipText = string.Format("Data ({0})", (object) DiscTrack.Name); + break; + } + treeNode.Name = DiscTrack.Name; + treeNode.Tag = (object) DiscTrack; + treeNode.SelectedImageIndex = treeNode.ImageIndex; + return treeNode; + } + + private static TreeNode CreateTreeNode(IDiscSession DiscSession) => new TreeNode(DiscSession.Name, 1, 1) + { + Name = DiscSession.Name, + Tag = (object) DiscSession + }; + + private static TreeNode CreateTreeNode(IDiscFileSystem Disc) => new TreeNode(Disc.DiscName, 0, 0) + { + Name = Disc.DiscName, + Tag = (object) Disc + }; + } +} diff --git a/Explorer/DiscView/IDiscViewSelection.cs b/Explorer/DiscView/IDiscViewSelection.cs new file mode 100644 index 0000000..af7beb1 --- /dev/null +++ b/Explorer/DiscView/IDiscViewSelection.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.IDiscViewSelection +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public interface IDiscViewSelection + { + void HandleAfterSelect(); + + void HandleDoubleLeftClicks(); + + void HandleLeftClick(); + + void HandleRightClick(); + + void HandleMouseEvent(MouseEventArgs MouseEvent); + } +} diff --git a/Explorer/DiscView/MenuItemFactory.cs b/Explorer/DiscView/MenuItemFactory.cs new file mode 100644 index 0000000..3faffd1 --- /dev/null +++ b/Explorer/DiscView/MenuItemFactory.cs @@ -0,0 +1,228 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.MenuItemFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using ImageReader.ISO9660.DirectoryRecords; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Windows.Forms; + +namespace GDRomExplorer.DiscView +{ + public class MenuItemFactory + { + private UserActions Context; + private ImageList ContextMenuImageList; + + public MenuItemFactory(UserActions Context, ImageList ImageList) + { + this.Context = Context; + this.ContextMenuImageList = ImageList; + } + + private ToolStripItem CreateMenuItem( + string Text, + int ImageIndex, + EventHandler Handler) + { + return (ToolStripItem) new ToolStripMenuItem(Text, this.ContextMenuImageList.Images[ImageIndex], Handler); + } + + public ToolStripItem[] CreateDiscMenuItems(IDiscFileSystem Disc) + { + ToolStripItem menuItem = this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemExportForGDEmu, 0, this.Context.GetHandler(UserActions.Action.ExportForGDEmu)); + menuItem.Enabled = Disc.CanBeExportedToGdi; + menuItem.Tag = (object) Disc; + return new ToolStripItem[1]{ menuItem }; + } + + public ToolStripItem[] CreateDiscSessionMenuItems(IDiscSession Session) + { + ToolStripItem[] toolStripItemArray = new ToolStripItem[2] + { + this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemCreateCUE, 0, this.Context.GetHandler(UserActions.Action.CreateCueSheet)), + null + }; + toolStripItemArray[0].Enabled = Session.Disc.CanBeExportedToCueSheet && Session.Tracks.Count > 0; + toolStripItemArray[0].Tag = (object) Session; + toolStripItemArray[1] = this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemConvertGDDA, 0, this.Context.GetHandler(UserActions.Action.ShowGDDAConversion)); + toolStripItemArray[1].Enabled = Session.Disc.CanExtractData && Session.AudioTracks.Count > 0; + toolStripItemArray[1].Tag = (object) Session; + return toolStripItemArray; + } + + public ToolStripItem[] CreateDiscTrackMenuItems(IDiscTrack Track) + { + IList source = (IList) new List(); + string fileName = Path.GetFileName(Track.Name); + DirectoryRecord rootDirectoryRecord = Track.Session.RootDirectoryRecord; + ToolStripItem menuItem1 = this.CreateMenuItem(string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemExtract, (object) fileName), 0, this.Context.GetHandler(UserActions.Action.ExtractItem)); + menuItem1.Enabled = Track.Session.Disc.CanExtractData; + menuItem1.Tag = (object) Track; + source.Add(menuItem1); + if (Track.TrackData == TrackModeType.Data && Track == Track.Session.FirstDataTrack) + { + ToolStripItem menuItem2 = this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemGenerateSortFile, 1, this.Context.GetHandler(UserActions.Action.CreateSortFile)); + menuItem2.Tag = (object) Track.Session; + source.Add(menuItem2); + ToolStripItem menuItem3 = this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemViewPvd, 3, this.Context.GetHandler(UserActions.Action.ShowPrimaryVolumeDescriptor)); + menuItem3.Tag = (object) Track; + source.Add(menuItem3); + } + else if (Track.TrackData == TrackModeType.Audio) + { + ToolStripItem menuItem2 = this.CreateMenuItem(string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemConvertAudio, (object) fileName), 0, this.Context.GetHandler(UserActions.Action.ConvertGDDA)); + menuItem2.Enabled = Track.Session.Disc.CanExtractData; + menuItem2.Tag = (object) Track; + source.Add(menuItem2); + } + return source.ToArray(); + } + + public ToolStripItem[] CreateInitialProgramMenuItems( + InitialProgramExtended InitialProgramFile) + { + List toolStripItemList = new List(); + ToolStripItem menuItem1 = this.CreateMenuItem(GDRomExplorer.Resources.Strings.ContextMenuItemViewIP, 2, this.Context.GetHandler(UserActions.Action.ShowBootSector)); + menuItem1.Tag = (object) InitialProgramFile; + toolStripItemList.Add(menuItem1); + ToolStripItem menuItem2 = this.CreateMenuItem(string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemExtractIP, (object) InitialProgramFile.FileName), 0, this.Context.GetHandler(UserActions.Action.ExtractBootSector)); + menuItem2.Tag = (object) InitialProgramFile; + toolStripItemList.Add(menuItem2); + return toolStripItemList.ToArray(); + } + + public ToolStripItem[] CreateFileExtractMenuItems( + string ItemLabel, + object Tag, + bool SupportDecryption) + { + string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemExtract, (object) ItemLabel); + string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemDecryptAndExtract, (object) ItemLabel); + return this.CreateFileMenuItems(string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemExtract, (object) ItemLabel), string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemDecryptAndExtract, (object) ItemLabel), Tag, SupportDecryption); + } + + public ToolStripItem[] CreateFileExtractContentMenuItems( + string ItemLabel, + object Tag) + { + return this.CreateFileMenuItems(string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemExtractContent, (object) ItemLabel), string.Format(GDRomExplorer.Resources.Strings.ContextMenuItemDecryptAndExtract, (object) ItemLabel), Tag, false); + } + + private ToolStripItem[] CreateFileMenuItems( + string ExtractText, + string DecryptExtractText, + object Tag, + bool SupportDecryption) + { + List toolStripItemList = new List(); + if (SupportDecryption) + { + ToolStripItem menuItem = this.CreateMenuItem(DecryptExtractText, 0, this.Context.GetHandler(UserActions.Action.DecryptNaomiBinary)); + menuItem.Tag = Tag; + toolStripItemList.Add(menuItem); + } + ToolStripItem menuItem1 = this.CreateMenuItem(ExtractText, 0, this.Context.GetHandler(UserActions.Action.ExtractItem)); + menuItem1.Tag = Tag; + toolStripItemList.Add(menuItem1); + return toolStripItemList.ToArray(); + } + + public ToolStripItem[] CreateDiscWithSessionTopMenuItem(IDiscFileSystem Disc) + { + List toolStripItemList = new List(); + toolStripItemList.AddRange((IEnumerable) this.CreateDiscMenuItems(Disc)); + toolStripItemList.Add((ToolStripItem) new ToolStripSeparator()); + foreach (IDiscSession session in Disc.Sessions) + { + ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(session.Name); + toolStripMenuItem.DropDownItems.AddRange(this.CreateDiscSessionMenuItems(session)); + toolStripItemList.Add((ToolStripItem) toolStripMenuItem); + } + return toolStripItemList.ToArray(); + } + + public ToolStripMenuItem CreateSelectionTopMenuItemForListView( + ToolStripItem[] MenuItems) + { + ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(GDRomExplorer.Resources.Strings.EditSelectionMenuItemName); + toolStripMenuItem.DropDownItems.AddRange(MenuItems); + toolStripMenuItem.Enabled = toolStripMenuItem.DropDownItems.Count > 0; + return toolStripMenuItem; + } + + public ToolStripItem[] CreateSelectionMenuItemsForListView( + object NewSelection, + IDiscFileSystem Disc) + { + ToolStripItem[] toolStripItemArray = new ToolStripItem[0]; + List directoryRecordList = NewSelection is List ? NewSelection as List : throw new NotSupportedException(); + if (directoryRecordList.Count != 1) + return this.CreateFileExtractMenuItems(GDRomExplorer.Resources.Strings.MsgBoxToolStripMenuSelectedFiles, NewSelection, false); + DirectoryRecord directoryRecord = directoryRecordList[0]; + string ItemLabel = directoryRecord == Disc.MainBinary ? string.Format(GDRomExplorer.Resources.Strings.ToolTipMainBinaryWithFormat, (object) directoryRecord.Name) : directoryRecord.Name; + bool SupportDecryption = Disc.DiscType == DiscImageType.Naomi && directoryRecord == Disc.MainBinary; + return this.CreateFileExtractMenuItems(ItemLabel, NewSelection, SupportDecryption); + } + + public ToolStripItem[] CreateSelectionDisabledTopMenuItem() => new ToolStripItem[0]; + + public static ToolStripMenuItem CreateEditSelectionTopMenuItem( + ToolStripItem[] MenuItems) + { + ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(GDRomExplorer.Resources.Strings.EditSelectionMenuItemName); + if (MenuItems != null && MenuItems.Length > 0) + toolStripMenuItem.DropDownItems.AddRange(MenuItems); + toolStripMenuItem.Enabled = MenuItems != null && MenuItems.Length > 0; + return toolStripMenuItem; + } + + public static ToolStripMenuItem CreateEditDiscTopMenuItem( + ToolStripItem[] MenuItems) + { + ToolStripMenuItem toolStripMenuItem = new ToolStripMenuItem(GDRomExplorer.Resources.Strings.EditDiscMenuItemName); + toolStripMenuItem.DropDownItems.AddRange(MenuItems); + toolStripMenuItem.Enabled = MenuItems != null && MenuItems.Length > 0; + return toolStripMenuItem; + } + + public static ToolStripItem[] CreateEditMenuItems( + ToolStripItem[] DiscMenuItems, + ToolStripItem[] SelectionMenuItems) + { + return new ToolStripItem[3] + { + (ToolStripItem) MenuItemFactory.CreateEditSelectionTopMenuItem(SelectionMenuItems), + (ToolStripItem) new ToolStripSeparator(), + (ToolStripItem) MenuItemFactory.CreateEditDiscTopMenuItem(DiscMenuItems) + }; + } + + public ToolStripItem[] CreateSelectionMenuItemsForTreeView(object NewSelection) + { + ToolStripItem[] toolStripItemArray = new ToolStripItem[0]; + switch (NewSelection) + { + case IDiscFileSystem _: + return this.CreateDiscMenuItems(NewSelection as IDiscFileSystem); + case IDiscSession _: + return this.CreateDiscSessionMenuItems(NewSelection as IDiscSession); + case IDiscTrack _: + return this.CreateDiscTrackMenuItems(NewSelection as IDiscTrack); + case InitialProgramExtended _: + return this.CreateInitialProgramMenuItems(NewSelection as InitialProgramExtended); + case DirectoryRecord _: + DirectoryRecord directoryRecord = NewSelection as DirectoryRecord; + return this.CreateFileExtractContentMenuItems(directoryRecord.Name, (object) directoryRecord.SubDirectories); + default: + throw new NotSupportedException(); + } + } + } +} diff --git a/Explorer/DiscView/UserActions.cs b/Explorer/DiscView/UserActions.cs new file mode 100644 index 0000000..5d6040d --- /dev/null +++ b/Explorer/DiscView/UserActions.cs @@ -0,0 +1,34 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.DiscView.UserActions +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; +using System.Collections.Generic; + +namespace GDRomExplorer.DiscView +{ + public class UserActions + { + private Dictionary EventHandlers = new Dictionary(); + + public void SetHandler(UserActions.Action Action, EventHandler Handler) => this.EventHandlers.Add(Action, Handler); + + public EventHandler GetHandler(UserActions.Action Action) => this.EventHandlers.ContainsKey(Action) ? this.EventHandlers[Action] : throw new NotSupportedException("Action not supported"); + + public enum Action + { + ExportForGDEmu, + CreateCueSheet, + ShowGDDAConversion, + ShowBootSector, + ExtractBootSector, + ExtractItem, + CreateSortFile, + ShowPrimaryVolumeDescriptor, + ConvertGDDA, + DecryptNaomiBinary, + } + } +} diff --git a/Explorer/Events/CancelEventArgs`1.cs b/Explorer/Events/CancelEventArgs`1.cs new file mode 100644 index 0000000..8b58086 --- /dev/null +++ b/Explorer/Events/CancelEventArgs`1.cs @@ -0,0 +1,24 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Events.CancelEventArgs`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.ComponentModel; + +namespace GDRomExplorer.Events +{ + public class CancelEventArgs : CancelEventArgs, IEventArgs + { + public CancelEventArgs(T value) + : this(value, false) + { + } + + public CancelEventArgs(T value, bool cancel) + : base(cancel) + => this.Value = value; + + public T Value { get; private set; } + } +} diff --git a/Explorer/Events/ChangingData`1.cs b/Explorer/Events/ChangingData`1.cs new file mode 100644 index 0000000..9f89fcf --- /dev/null +++ b/Explorer/Events/ChangingData`1.cs @@ -0,0 +1,21 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Events.ChangingData`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer.Events +{ + public class ChangingData + { + public ChangingData(T oldData, T newData) + { + this.OldData = oldData; + this.NewData = newData; + } + + public T OldData { get; private set; } + + public T NewData { get; private set; } + } +} diff --git a/Explorer/Events/EventArgs`1.cs b/Explorer/Events/EventArgs`1.cs new file mode 100644 index 0000000..6986fca --- /dev/null +++ b/Explorer/Events/EventArgs`1.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Events.EventArgs`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; + +namespace GDRomExplorer.Events +{ + public class EventArgs : EventArgs, IEventArgs + { + public EventArgs(T value) => this.Value = value; + + public T Value { get; private set; } + } +} diff --git a/Explorer/Events/IEventArgs`1.cs b/Explorer/Events/IEventArgs`1.cs new file mode 100644 index 0000000..4ace136 --- /dev/null +++ b/Explorer/Events/IEventArgs`1.cs @@ -0,0 +1,13 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Events.IEventArgs`1 +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer.Events +{ + public interface IEventArgs + { + T Value { get; } + } +} diff --git a/Explorer/Explorer.csproj b/Explorer/Explorer.csproj new file mode 100644 index 0000000..c303f1f --- /dev/null +++ b/Explorer/Explorer.csproj @@ -0,0 +1,220 @@ + + + + + Debug + AnyCPU + {47780501-F392-43CA-A50C-9479421B4B55} + WinExe + GD-ROM Explorer + v3.5 + 512 + GDRomExplorer + + + + + 3.5 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.6.3.0 + false + false + true + + + AnyCPU + true + full + false + ..\bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + ..\bin\Release\ + TRACE + prompt + 4 + + + Resources\icons\gdromexplorer.ico + + + + packages\log4net.2.0.12\lib\net35\log4net.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + Form + + + + + + + + + + + + + + Component + + + UserControl + + + Component + + + UserControl + + + UserControl + + + Component + + + UserControl + + + + + + + + + + + + + + + + + + + Designer + + + + + + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + + + {4d3ab913-88d2-4dd1-a403-ea46d14c98e6} + SEGATools + True + + + + + + PreserveNewest + + + + + + + + + + + + + + + False + .NET Framework 3.5 SP1 + true + + + + \ No newline at end of file diff --git a/Explorer/Forms/FormAbout.cs b/Explorer/Forms/FormAbout.cs new file mode 100644 index 0000000..5ea36aa --- /dev/null +++ b/Explorer/Forms/FormAbout.cs @@ -0,0 +1,294 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormAbout +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Properties; +using System; +using System.ComponentModel; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + internal class FormAbout : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IContainer components; + private TableLayoutPanel tableLayoutPanel; + private PictureBox logoPictureBox; + private TextBox textBoxDescription; + private TableLayoutPanel tableLayoutPanelButton; + private Button okButton; + private PictureBox pictureBoxPaypal; + private Panel panel1; + private LinkLabel llblog; + + public FormAbout() + { + this.InitializeComponent(); + this.Text = string.Format("About {0}", (object) this.AssemblyTitle); + StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.AppendLine(string.Format("{0}", (object) this.AssemblyProduct)); + stringBuilder.AppendLine(string.Format("Version {0} build {1}", (object) this.AssemblyVersion, (object) this.AssemblyBuildSHA1)); + stringBuilder.Append(string.Format("Created by {0} ({1})", (object) this.AssemblyCompany, (object) this.AssemblyCopyright)); + this.textBoxDescription.Text = stringBuilder.ToString(); + this.llblog.Text = GDRomExplorer.Resources.Strings.GoToBlogLinkTitle; + } + + public string AssemblyTitle + { + get + { + object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyTitleAttribute), false); + if (customAttributes.Length > 0) + { + AssemblyTitleAttribute assemblyTitleAttribute = (AssemblyTitleAttribute) customAttributes[0]; + if (!string.IsNullOrEmpty(assemblyTitleAttribute.Title)) + return assemblyTitleAttribute.Title; + } + return Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase); + } + } + + public string AssemblyVersion + { + get + { + Version version = Assembly.GetExecutingAssembly().GetName().Version; + return string.Format("{0}.{1}.{2}", (object) version.Major, (object) version.Minor, (object) version.Build); + } + } + + public string AssemblyBuildSHA1 + { + get + { + try + { + return typeof (AssemblyGitBuildSHA1).Assembly.GetCustomAttributes(typeof (AssemblyGitBuildSHA1), false).Cast().First().GitBuildSHA1; + } + catch (Exception ex) + { + logger.Error(ex); + return "unknown"; + } + } + } + + public string AssemblyBuildBranch + { + get + { + try + { + return typeof (AssemblyGitBuildBranch).Assembly.GetCustomAttributes(typeof (AssemblyGitBuildBranch), false).Cast().First().GitBuildBranch; + } + catch (Exception ex) + { + logger.Error(ex); + return "unknown"; + } + } + } + + public string AssemblyDescription + { + get + { + object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyDescriptionAttribute), false); + return customAttributes.Length == 0 ? "" : ((AssemblyDescriptionAttribute) customAttributes[0]).Description; + } + } + + public string AssemblyProduct + { + get + { + object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyProductAttribute), false); + return customAttributes.Length == 0 ? "" : ((AssemblyProductAttribute) customAttributes[0]).Product; + } + } + + public string AssemblyCopyright + { + get + { + object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyCopyrightAttribute), false); + return customAttributes.Length == 0 ? "" : ((AssemblyCopyrightAttribute) customAttributes[0]).Copyright; + } + } + + public string AssemblyCompany + { + get + { + object[] customAttributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof (AssemblyCompanyAttribute), false); + return customAttributes.Length == 0 ? "" : ((AssemblyCompanyAttribute) customAttributes[0]).Company; + } + } + + private void paypalDonatePictureBox_Click(object sender, EventArgs e) + { + try + { + Process.Start(Settings.Default.PayPalDonateUrl); + } + catch + { + } + } + + private void llblog_LinkClicked(object sender, EventArgs e) + { + try + { + Process.Start(Settings.Default.BlogUrl); + } + catch + { + } + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (FormAbout)); + this.tableLayoutPanel = new TableLayoutPanel(); + this.logoPictureBox = new PictureBox(); + this.textBoxDescription = new TextBox(); + this.tableLayoutPanelButton = new TableLayoutPanel(); + this.pictureBoxPaypal = new PictureBox(); + this.panel1 = new Panel(); + this.llblog = new LinkLabel(); + this.okButton = new Button(); + this.tableLayoutPanel.SuspendLayout(); + ((ISupportInitialize) this.logoPictureBox).BeginInit(); + this.tableLayoutPanelButton.SuspendLayout(); + ((ISupportInitialize) this.pictureBoxPaypal).BeginInit(); + this.panel1.SuspendLayout(); + this.SuspendLayout(); + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 33f)); + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 67f)); + this.tableLayoutPanel.Controls.Add((Control) this.logoPictureBox, 0, 0); + this.tableLayoutPanel.Controls.Add((Control) this.textBoxDescription, 1, 0); + this.tableLayoutPanel.Controls.Add((Control) this.tableLayoutPanelButton, 1, 1); + this.tableLayoutPanel.Dock = DockStyle.Fill; + this.tableLayoutPanel.Location = new Point(9, 9); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 2; + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 42.64706f)); + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 57.35294f)); + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Absolute, 20f)); + this.tableLayoutPanel.Size = new Size(417, 136); + this.tableLayoutPanel.TabIndex = 0; + this.logoPictureBox.Dock = DockStyle.Fill; + this.logoPictureBox.Image = (Image) componentResourceManager.GetObject("logoPictureBox.Image"); + this.logoPictureBox.Location = new Point(3, 3); + this.logoPictureBox.Name = "logoPictureBox"; + this.tableLayoutPanel.SetRowSpan((Control) this.logoPictureBox, 2); + this.logoPictureBox.Size = new Size(131, 130); + this.logoPictureBox.TabIndex = 12; + this.logoPictureBox.TabStop = false; + this.textBoxDescription.BackColor = SystemColors.Window; + this.textBoxDescription.BorderStyle = BorderStyle.None; + this.textBoxDescription.Dock = DockStyle.Fill; + this.textBoxDescription.Location = new Point(143, 3); + this.textBoxDescription.Margin = new Padding(6, 3, 3, 3); + this.textBoxDescription.Multiline = true; + this.textBoxDescription.Name = "textBoxDescription"; + this.textBoxDescription.ReadOnly = true; + this.textBoxDescription.Size = new Size(271, 52); + this.textBoxDescription.TabIndex = 23; + this.textBoxDescription.TabStop = false; + this.textBoxDescription.Text = "Description"; + this.tableLayoutPanelButton.ColumnCount = 2; + this.tableLayoutPanelButton.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50f)); + this.tableLayoutPanelButton.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50f)); + this.tableLayoutPanelButton.Controls.Add((Control) this.pictureBoxPaypal, 1, 0); + this.tableLayoutPanelButton.Controls.Add((Control) this.panel1, 0, 0); + this.tableLayoutPanelButton.Controls.Add((Control) this.okButton, 1, 1); + this.tableLayoutPanelButton.Dock = DockStyle.Fill; + this.tableLayoutPanelButton.Location = new Point(140, 61); + this.tableLayoutPanelButton.Name = "tableLayoutPanelButton"; + this.tableLayoutPanelButton.RowCount = 2; + this.tableLayoutPanelButton.RowStyles.Add(new RowStyle(SizeType.Percent, 100f)); + this.tableLayoutPanelButton.RowStyles.Add(new RowStyle(SizeType.Absolute, 37f)); + this.tableLayoutPanelButton.RowStyles.Add(new RowStyle(SizeType.Absolute, 20f)); + this.tableLayoutPanelButton.Size = new Size(274, 72); + this.tableLayoutPanelButton.TabIndex = 27; + this.pictureBoxPaypal.Image = (Image) GDRomExplorer.Properties.Resources.paypal_donate; + this.pictureBoxPaypal.Location = new Point(140, 3); + this.pictureBoxPaypal.Name = "pictureBoxPaypal"; + this.pictureBoxPaypal.Size = new Size(131, 29); + this.pictureBoxPaypal.SizeMode = PictureBoxSizeMode.CenterImage; + this.pictureBoxPaypal.TabIndex = 28; + this.pictureBoxPaypal.TabStop = false; + this.pictureBoxPaypal.Click += new EventHandler(this.paypalDonatePictureBox_Click); + this.panel1.Controls.Add((Control) this.llblog); + this.panel1.Dock = DockStyle.Fill; + this.panel1.Location = new Point(3, 3); + this.panel1.Name = "panel1"; + this.panel1.Size = new Size(131, 29); + this.panel1.TabIndex = 33; + this.llblog.ActiveLinkColor = Color.FromArgb(248, 48, 0); + this.llblog.AutoSize = true; + this.llblog.LinkBehavior = LinkBehavior.HoverUnderline; + this.llblog.LinkColor = Color.FromArgb(248, 48, 0); + this.llblog.Location = new Point(25, 8); + this.llblog.Name = "llblog"; + this.llblog.Size = new Size(40, 13); + this.llblog.TabIndex = 24; + this.llblog.TabStop = true; + this.llblog.Text = "blogUrl"; + this.llblog.TextAlign = ContentAlignment.MiddleCenter; + this.llblog.Click += new EventHandler(this.llblog_LinkClicked); + this.okButton.Anchor = AnchorStyles.None; + this.okButton.DialogResult = DialogResult.OK; + this.okButton.FlatStyle = FlatStyle.Popup; + this.okButton.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.okButton.ForeColor = Color.FromArgb(248, 48, 0); + this.okButton.Location = new Point(151, 42); + this.okButton.Name = "okButton"; + this.okButton.Size = new Size(108, 22); + this.okButton.TabIndex = 31; + this.okButton.Text = "&Ok"; + this.okButton.UseVisualStyleBackColor = false; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.ClientSize = new Size(435, 154); + this.Controls.Add((Control) this.tableLayoutPanel); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormAbout); + this.Padding = new Padding(9); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "AboutBox"; + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + ((ISupportInitialize) this.logoPictureBox).EndInit(); + this.tableLayoutPanelButton.ResumeLayout(false); + ((ISupportInitialize) this.pictureBoxPaypal).EndInit(); + this.panel1.ResumeLayout(false); + this.panel1.PerformLayout(); + this.ResumeLayout(false); + } + } +} diff --git a/Explorer/Forms/FormAbout.resx b/Explorer/Forms/FormAbout.resx new file mode 100644 index 0000000..5396e52 --- /dev/null +++ b/Explorer/Forms/FormAbout.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/Forms/FormAudioConversionSettings.cs b/Explorer/Forms/FormAudioConversionSettings.cs new file mode 100644 index 0000000..9dcf5f4 --- /dev/null +++ b/Explorer/Forms/FormAudioConversionSettings.cs @@ -0,0 +1,89 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormAudioConversionSettings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using SEGATools.Audio; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormAudioConversionSettings : Form + { + private IContainer components; + private Button btOk; + private Button btCancel; + private AudioConversionSettingsViewer audioConversionSettingsViewer; + + public AudioConversionSettings AudioConversionSettings => this.audioConversionSettingsViewer.AudioConversionSettings; + + public FormAudioConversionSettings() => this.InitializeComponent(); + + private void btCancel_Click(object sender, EventArgs e) => this.Close(); + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.btOk = new Button(); + this.btCancel = new Button(); + this.audioConversionSettingsViewer = new AudioConversionSettingsViewer(); + this.SuspendLayout(); + this.btOk.DialogResult = DialogResult.OK; + this.btOk.FlatStyle = FlatStyle.Popup; + this.btOk.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btOk.ForeColor = Color.FromArgb(248, 48, 0); + this.btOk.Location = new Point(195, 52); + this.btOk.Name = "btOk"; + this.btOk.Size = new Size((int) sbyte.MaxValue, 22); + this.btOk.TabIndex = 1; + this.btOk.Text = "&OK"; + this.btOk.UseVisualStyleBackColor = false; + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(12, 52); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size((int) sbyte.MaxValue, 22); + this.btCancel.TabIndex = 2; + this.btCancel.Text = "&Cancel"; + this.btCancel.UseVisualStyleBackColor = false; + this.btCancel.Click += new EventHandler(this.btCancel_Click); + this.audioConversionSettingsViewer.AutoSize = true; + this.audioConversionSettingsViewer.BackColor = Color.Transparent; + this.audioConversionSettingsViewer.Location = new Point(9, 12); + this.audioConversionSettingsViewer.Name = "audioConversionSettingsViewer"; + this.audioConversionSettingsViewer.Size = new Size(325, 23); + this.audioConversionSettingsViewer.TabIndex = 3; + this.AcceptButton = (IButtonControl) this.btOk; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.ClientSize = new Size(334, 86); + this.Controls.Add((Control) this.audioConversionSettingsViewer); + this.Controls.Add((Control) this.btCancel); + this.Controls.Add((Control) this.btOk); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormAudioConversionSettings); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Audio Conversion Options"; + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/FormAudioConversionSettings.resx b/Explorer/Forms/FormAudioConversionSettings.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormAudioConversionSettings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/FormGDEmuExportSettings.cs b/Explorer/Forms/FormGDEmuExportSettings.cs new file mode 100644 index 0000000..c0dcd92 --- /dev/null +++ b/Explorer/Forms/FormGDEmuExportSettings.cs @@ -0,0 +1,130 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormGDEmuExportSettings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using GDRomExplorer.UserControls; +using SEGATools.DiscFileSystem; +using SEGATools.GDEmu; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormGDEmuExportSettings : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private FormProcess formProcess; + private IContainer components; + private GDEmuExportSettings gdEmuExportSettings; + private Button btCancel; + private Button btOk; + private GDEmuConverter gdEmuConverter; + + public IDiscFileSystem InputDiscImage => this.gdEmuExportSettings.InputDiscImage; + + public FormGDEmuExportSettings() => this.InitializeComponent(); + + public FormGDEmuExportSettings(string InitialDirectory) + : this() + => this.gdEmuExportSettings.InitialDirectory = InitialDirectory; + + public FormGDEmuExportSettings(IDiscFileSystem DiscFileSystem) + : this() + => this.SetLoadedDiscImage(DiscFileSystem); + + private void SetLoadedDiscImage(IDiscFileSystem discFileSystem) => this.gdEmuExportSettings.SetLoadedDiscImage(discFileSystem); + + private bool AreSettingsValid() => this.gdEmuExportSettings.InputDiscImage != null && !string.IsNullOrEmpty(this.gdEmuExportSettings.ExportOptions.OutputPath); + + private void ShowIncompleteMessagBox() + { + string text = this.gdEmuExportSettings.InputDiscImage != null ? Strings.MsgBoxGDEmuSettingsOutputPathMissing : Strings.MsgBoxGDEmuSettingsImageMissing; + FormGDEmuExportSettings.logger.WarnFormat("Cannot start the conversion: {0}", (object) text); + int num = (int) MessageBox.Show((IWin32Window) this, text, this.Text, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); + } + + private void StartConversion() + { + Guid TaskId = Guid.NewGuid(); + this.formProcess = FormProcess.createForGDEmuConverter(this.gdEmuConverter, TaskId); + this.gdEmuConverter.ConvertAsync(this.gdEmuExportSettings.InputDiscImage, this.gdEmuExportSettings.ExportOptions, (object) TaskId); + } + + private void btOk_Click(object sender, EventArgs e) + { + if (this.AreSettingsValid()) + this.StartConversion(); + else + this.ShowIncompleteMessagBox(); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.components = (IContainer) new Container(); + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (FormGDEmuExportSettings)); + this.btCancel = new Button(); + this.btOk = new Button(); + this.gdEmuExportSettings = new GDEmuExportSettings(); + this.gdEmuConverter = new GDEmuConverter(this.components); + this.SuspendLayout(); + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(12, 174); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size((int) sbyte.MaxValue, 22); + this.btCancel.TabIndex = 2; + this.btCancel.Text = "&Close"; + this.btCancel.UseVisualStyleBackColor = false; + this.btOk.CausesValidation = false; + this.btOk.FlatStyle = FlatStyle.Popup; + this.btOk.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btOk.ForeColor = Color.FromArgb(248, 48, 0); + this.btOk.Location = new Point(340, 174); + this.btOk.Name = "btOk"; + this.btOk.Size = new Size((int) sbyte.MaxValue, 22); + this.btOk.TabIndex = 1; + this.btOk.Text = "&OK"; + this.btOk.UseVisualStyleBackColor = false; + this.btOk.Click += new EventHandler(this.btOk_Click); + this.gdEmuExportSettings.AutoSize = true; + this.gdEmuExportSettings.BackColor = SystemColors.Window; + this.gdEmuExportSettings.InitialDirectory = ""; + this.gdEmuExportSettings.Location = new Point(0, 0); + this.gdEmuExportSettings.Name = "gdEmuExportSettings"; + this.gdEmuExportSettings.Size = new Size(480, 157); + this.gdEmuExportSettings.TabIndex = 0; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.CausesValidation = false; + this.ClientSize = new Size(479, 208); + this.Controls.Add((Control) this.btCancel); + this.Controls.Add((Control) this.btOk); + this.Controls.Add((Control) this.gdEmuExportSettings); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.Icon = (Icon) componentResourceManager.GetObject("$this.Icon"); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormGDEmuExportSettings); + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Export GDI for GDEMU"; + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/FormGDEmuExportSettings.resx b/Explorer/Forms/FormGDEmuExportSettings.resx new file mode 100644 index 0000000..f847f0e --- /dev/null +++ b/Explorer/Forms/FormGDEmuExportSettings.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/Forms/FormGdda.cs b/Explorer/Forms/FormGdda.cs new file mode 100644 index 0000000..22f4cc5 --- /dev/null +++ b/Explorer/Forms/FormGdda.cs @@ -0,0 +1,270 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormGdda +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using SEGATools.Audio; +using SEGATools.DiscFileSystem; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Linq; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormGdda : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IDiscSession discSession; + private List selectedDiscTracks; + private IContainer components; + private Button btConvertSelection; + private GroupBox groupBox; + private Button btUnselectAll; + private Button btInverseSelection; + private Button btSelectAll; + private ListView listViewTracks; + private ColumnHeader columnHeader1; + private ColumnHeader columnHeader2; + private Button btClose; + private FolderBrowserDialog folderBrowserDialogForAudio; + private SaveFileDialog saveFileDialogForAudio; + private AudioConversionSettingsViewer audioConversionSettingsViewer; + + public List SelectedDiscTracks => this.selectedDiscTracks.ToList(); + + public AudioConversionSettings AudioConversionSettings => this.audioConversionSettingsViewer.AudioConversionSettings; + + public FormGdda(IDiscSession discSession) + { + this.InitializeComponent(); + this.discSession = discSession; + this.selectedDiscTracks = new List(); + } + + private void frmGdda_Load(object sender, EventArgs e) + { + this.LoadTracks(); + this.UpdateConvertButton(); + this.listViewTracks.ItemCheck += new ItemCheckEventHandler(this.listViewTracks_ItemCheck); + this.listViewTracks.ItemChecked += new ItemCheckedEventHandler(this.listViewTracks_ItemChecked); + this.listViewTracks.ItemSelectionChanged += new ListViewItemSelectionChangedEventHandler(this.listViewTracks_ItemSelectionChanged); + } + + private void listViewTracks_ItemCheck(object sender, ItemCheckEventArgs e) => this.UpdateConvertButton(); + + private void listViewTracks_ItemChecked(object sender, ItemCheckedEventArgs e) => this.UpdateConvertButton(); + + private void listViewTracks_ItemSelectionChanged( + object sender, + ListViewItemSelectionChangedEventArgs e) + { + this.UpdateConvertButton(); + } + + private void UpdateConvertButton() => this.btConvertSelection.Enabled = this.listViewTracks.CheckedItems.Count > 0; + + private void LoadTracks() + { + this.listViewTracks.BeginUpdate(); + this.listViewTracks.Items.Clear(); + foreach (IDiscTrack audioTrack in this.discSession.AudioTracks) + this.listViewTracks.Items.Add(new ListViewItem() + { + SubItems = { + audioTrack.ToString() + }, + Tag = (object) audioTrack, + Checked = true, + ToolTipText = audioTrack.FileName + }); + this.listViewTracks.EndUpdate(); + } + + private void EnableAll(bool isEnabled) + { + foreach (ListViewItem listViewItem in this.listViewTracks.Items) + listViewItem.Checked = isEnabled; + } + + private void InverseSelection() + { + foreach (ListViewItem listViewItem in this.listViewTracks.Items) + listViewItem.Checked = !listViewItem.Checked; + } + + private void btSelectAll_Click(object sender, EventArgs e) + { + this.EnableAll(true); + this.UpdateConvertButton(); + } + + private void btUnselectAll_Click(object sender, EventArgs e) + { + this.EnableAll(false); + this.UpdateConvertButton(); + } + + private void btInverseSelection_Click(object sender, EventArgs e) + { + this.InverseSelection(); + this.UpdateConvertButton(); + } + + private void btConvertSelection_Click(object sender, EventArgs e) + { + this.selectedDiscTracks.Clear(); + foreach (ListViewItem listViewItem in this.listViewTracks.Items) + { + if (listViewItem.Checked) + this.selectedDiscTracks.Add(listViewItem.Tag as IDiscTrack); + } + if (this.selectedDiscTracks.Count > 0) + this.DialogResult = DialogResult.OK; + else + this.DialogResult = DialogResult.None; + } + + private void btClose_Click(object sender, EventArgs e) => this.DialogResult = DialogResult.Cancel; + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (FormGdda)); + this.btConvertSelection = new Button(); + this.groupBox = new GroupBox(); + this.listViewTracks = new ListView(); + this.columnHeader1 = new ColumnHeader(); + this.columnHeader2 = new ColumnHeader(); + this.btUnselectAll = new Button(); + this.btInverseSelection = new Button(); + this.btSelectAll = new Button(); + this.btClose = new Button(); + this.folderBrowserDialogForAudio = new FolderBrowserDialog(); + this.saveFileDialogForAudio = new SaveFileDialog(); + this.audioConversionSettingsViewer = new AudioConversionSettingsViewer(); + this.groupBox.SuspendLayout(); + this.SuspendLayout(); + this.btConvertSelection.FlatStyle = FlatStyle.Popup; + this.btConvertSelection.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btConvertSelection.ForeColor = Color.FromArgb(248, 48, 0); + this.btConvertSelection.Location = new Point(248, 225); + this.btConvertSelection.Name = "btConvertSelection"; + this.btConvertSelection.Size = new Size(108, 22); + this.btConvertSelection.TabIndex = 5; + this.btConvertSelection.Text = "Convert to CDDA"; + this.btConvertSelection.UseVisualStyleBackColor = false; + this.btConvertSelection.Click += new EventHandler(this.btConvertSelection_Click); + this.groupBox.Controls.Add((Control) this.listViewTracks); + this.groupBox.Controls.Add((Control) this.btUnselectAll); + this.groupBox.Controls.Add((Control) this.btInverseSelection); + this.groupBox.Controls.Add((Control) this.btSelectAll); + this.groupBox.Location = new Point(12, 12); + this.groupBox.Name = "groupBox"; + this.groupBox.Size = new Size(344, 183); + this.groupBox.TabIndex = 6; + this.groupBox.TabStop = false; + this.groupBox.Text = "Select GD-DA tracks to convert:"; + this.listViewTracks.CheckBoxes = true; + this.listViewTracks.Columns.AddRange(new ColumnHeader[2] + { + this.columnHeader1, + this.columnHeader2 + }); + this.listViewTracks.FullRowSelect = true; + this.listViewTracks.HeaderStyle = ColumnHeaderStyle.None; + this.listViewTracks.HideSelection = false; + this.listViewTracks.Location = new Point(6, 47); + this.listViewTracks.MultiSelect = false; + this.listViewTracks.Name = "listViewTracks"; + this.listViewTracks.ShowItemToolTips = true; + this.listViewTracks.Size = new Size(332, 130); + this.listViewTracks.TabIndex = 3; + this.listViewTracks.UseCompatibleStateImageBehavior = false; + this.listViewTracks.View = View.Details; + this.columnHeader1.Text = ""; + this.columnHeader1.Width = 20; + this.columnHeader2.Text = "Track name"; + this.columnHeader2.Width = 280; + this.btUnselectAll.FlatStyle = FlatStyle.Popup; + this.btUnselectAll.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btUnselectAll.ForeColor = Color.FromArgb(248, 48, 0); + this.btUnselectAll.Location = new Point(118, 19); + this.btUnselectAll.Name = "btUnselectAll"; + this.btUnselectAll.Size = new Size(106, 22); + this.btUnselectAll.TabIndex = 1; + this.btUnselectAll.Text = "Unselect all"; + this.btUnselectAll.UseVisualStyleBackColor = false; + this.btUnselectAll.Click += new EventHandler(this.btUnselectAll_Click); + this.btInverseSelection.FlatStyle = FlatStyle.Popup; + this.btInverseSelection.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btInverseSelection.ForeColor = Color.FromArgb(248, 48, 0); + this.btInverseSelection.Location = new Point(230, 19); + this.btInverseSelection.Name = "btInverseSelection"; + this.btInverseSelection.Size = new Size(106, 22); + this.btInverseSelection.TabIndex = 2; + this.btInverseSelection.Text = "Inverse selection"; + this.btInverseSelection.UseVisualStyleBackColor = false; + this.btInverseSelection.Click += new EventHandler(this.btInverseSelection_Click); + this.btSelectAll.FlatStyle = FlatStyle.Popup; + this.btSelectAll.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btSelectAll.ForeColor = Color.FromArgb(248, 48, 0); + this.btSelectAll.Location = new Point(6, 19); + this.btSelectAll.Name = "btSelectAll"; + this.btSelectAll.Size = new Size(106, 22); + this.btSelectAll.TabIndex = 0; + this.btSelectAll.Text = "Select all"; + this.btSelectAll.UseVisualStyleBackColor = false; + this.btSelectAll.Click += new EventHandler(this.btSelectAll_Click); + this.btClose.DialogResult = DialogResult.Cancel; + this.btClose.FlatStyle = FlatStyle.Popup; + this.btClose.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btClose.ForeColor = Color.FromArgb(248, 48, 0); + this.btClose.Location = new Point(12, 225); + this.btClose.Name = "btClose"; + this.btClose.Size = new Size(108, 22); + this.btClose.TabIndex = 4; + this.btClose.Text = "Close"; + this.btClose.UseVisualStyleBackColor = false; + this.btClose.Click += new EventHandler(this.btClose_Click); + this.audioConversionSettingsViewer.AutoSize = true; + this.audioConversionSettingsViewer.BackColor = Color.Transparent; + this.audioConversionSettingsViewer.Location = new Point(13, 201); + this.audioConversionSettingsViewer.Name = "audioConversionSettingsViewer"; + this.audioConversionSettingsViewer.Size = new Size(343, 23); + this.audioConversionSettingsViewer.TabIndex = 7; + this.AcceptButton = (IButtonControl) this.btConvertSelection; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btClose; + this.ClientSize = new Size(368, 259); + this.Controls.Add((Control) this.audioConversionSettingsViewer); + this.Controls.Add((Control) this.btClose); + this.Controls.Add((Control) this.groupBox); + this.Controls.Add((Control) this.btConvertSelection); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.Icon = (Icon) componentResourceManager.GetObject("$this.Icon"); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormGdda); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Convert GD-DA to CD-DA"; + this.Load += new EventHandler(this.frmGdda_Load); + this.groupBox.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/FormGdda.resx b/Explorer/Forms/FormGdda.resx new file mode 100644 index 0000000..e277683 --- /dev/null +++ b/Explorer/Forms/FormGdda.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/Forms/FormGetDESKey.cs b/Explorer/Forms/FormGetDESKey.cs new file mode 100644 index 0000000..933b4ed --- /dev/null +++ b/Explorer/Forms/FormGetDESKey.cs @@ -0,0 +1,185 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormGetDESKey +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using SEGATools.Encrypt; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormGetDESKey : Form + { + private IContainer components; + private TextBox tbDESKey; + private Label lbDESKey; + private Button btProceed; + private Button btCancel; + + public DESKey DESKey { get; private set; } + + public static FormGetDESKey aGetDESKeyFormWithDecryptLabel() => new FormGetDESKey(FormGetDESKey.ButtonLabel.DecryptOnly, (DESKey) null); + + public static FormGetDESKey aGetDESKeyFormWithEncryptLabel() => new FormGetDESKey(FormGetDESKey.ButtonLabel.EncryptOnly, (DESKey) null); + + public static FormGetDESKey aGetDESKeyFormWithExtractAndDecryptLabel( + DESKey inputDESKey) + { + return new FormGetDESKey(FormGetDESKey.ButtonLabel.ExtractAndDecrypt, inputDESKey); + } + + private FormGetDESKey() + : this(FormGetDESKey.ButtonLabel.ExtractAndDecrypt, (DESKey) null) + { + } + + private FormGetDESKey(FormGetDESKey.ButtonLabel buttonLabel, DESKey suggestedDESKey) + { + string extractButtonLabel; + switch (buttonLabel) + { + case FormGetDESKey.ButtonLabel.ExtractAndDecrypt: + extractButtonLabel = Strings.DESKeyFormButtonLabelExtractAndDecrypt; + break; + case FormGetDESKey.ButtonLabel.EncryptOnly: + extractButtonLabel = Strings.DESKeyFormButtonLabelEncrypt; + break; + case FormGetDESKey.ButtonLabel.DecryptOnly: + extractButtonLabel = Strings.DESKeyFormButtonLabelDecrypt; + break; + default: + extractButtonLabel = Strings.DESKeyFormButtonLabelDecrypt; + break; + } + this.DESKey = suggestedDESKey; + this.Initialize(extractButtonLabel); + } + + private void Initialize(string extractButtonLabel) + { + this.InitializeComponent(); + this.Activated += new EventHandler(this.FormGetDESKey_Activated); + this.btProceed.Text = extractButtonLabel; + this.tbDESKey.CharacterCasing = CharacterCasing.Upper; + this.tbDESKey.TextChanged += new EventHandler(this.tbDESKey_TextChanged); + } + + private void ValidateDESKey(string key) + { + string key1 = key.Trim(); + if (DESKey.TryParse(key1)) + { + this.DESKey = DESKey.Parse(key1); + this.btProceed.Enabled = true; + } + else + { + this.DESKey = (DESKey) null; + this.btProceed.Enabled = false; + } + } + + private void FormGetDESKey_Load(object sender, EventArgs e) + { + this.btProceed.Enabled = false; + this.tbDESKey.Text = this.DESKey != null ? this.DESKey.KeyString : string.Empty; + this.tbDESKey.Focus(); + } + + private void FormGetDESKey_Activated(object sender, EventArgs e) + { + if (!Clipboard.ContainsText() || !DESKey.TryParse(Clipboard.GetText().Trim())) + return; + this.tbDESKey.Text = Clipboard.GetText().Trim(); + } + + private void tbDESKey_TextChanged(object sender, EventArgs e) => this.ValidateDESKey(this.tbDESKey.Text); + + private void btProceed_Click(object sender, EventArgs e) => this.ValidateDESKey(this.tbDESKey.Text); + + private void btCancel_Click(object sender, EventArgs e) => this.Close(); + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.tbDESKey = new TextBox(); + this.lbDESKey = new Label(); + this.btProceed = new Button(); + this.btCancel = new Button(); + this.SuspendLayout(); + this.tbDESKey.Location = new Point(71, 6); + this.tbDESKey.MaxLength = 16; + this.tbDESKey.Name = "tbDESKey"; + this.tbDESKey.Size = new Size(210, 20); + this.tbDESKey.TabIndex = 0; + this.tbDESKey.TextAlign = HorizontalAlignment.Center; + this.lbDESKey.AutoSize = true; + this.lbDESKey.Location = new Point(12, 9); + this.lbDESKey.Name = "lbDESKey"; + this.lbDESKey.Size = new Size(53, 13); + this.lbDESKey.TabIndex = 2; + this.lbDESKey.Text = "DES Key:"; + this.btProceed.DialogResult = DialogResult.OK; + this.btProceed.FlatStyle = FlatStyle.Popup; + this.btProceed.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btProceed.ForeColor = Color.FromArgb(248, 48, 0); + this.btProceed.Location = new Point(154, 32); + this.btProceed.Name = "btProceed"; + this.btProceed.Size = new Size((int) sbyte.MaxValue, 22); + this.btProceed.TabIndex = 1; + this.btProceed.Text = "&OK"; + this.btProceed.UseVisualStyleBackColor = false; + this.btProceed.Click += new EventHandler(this.btProceed_Click); + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(15, 32); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size((int) sbyte.MaxValue, 22); + this.btCancel.TabIndex = 2; + this.btCancel.Text = "&Cancel"; + this.btCancel.UseVisualStyleBackColor = false; + this.btCancel.Click += new EventHandler(this.btCancel_Click); + this.AcceptButton = (IButtonControl) this.btProceed; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.ClientSize = new Size(295, 65); + this.Controls.Add((Control) this.btCancel); + this.Controls.Add((Control) this.btProceed); + this.Controls.Add((Control) this.tbDESKey); + this.Controls.Add((Control) this.lbDESKey); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormGetDESKey); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Enter the Naomi DES key"; + this.Load += new EventHandler(this.FormGetDESKey_Load); + this.ResumeLayout(false); + this.PerformLayout(); + } + + private enum ButtonLabel : short + { + ExtractAndDecrypt, + EncryptOnly, + DecryptOnly, + } + } +} diff --git a/Explorer/Forms/FormGetDESKey.resx b/Explorer/Forms/FormGetDESKey.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormGetDESKey.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/FormInitialProgram.cs b/Explorer/Forms/FormInitialProgram.cs new file mode 100644 index 0000000..286c469 --- /dev/null +++ b/Explorer/Forms/FormInitialProgram.cs @@ -0,0 +1,203 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormInitialProgram +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using SEGATools.Security; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormInitialProgram : Form + { + private InitialProgramExtended ip; + private string basePath; + private IContainer components; + private Button btClose; + private TabControl tcInitialProgram; + private TabPage tpGeneralSettings; + private InitialProgramGeneralSettingsViewer ipGeneralSettingsViewer; + private TabPage tpPeripheralSettings; + private InitialProgramPeripheralsViewer ipPeriperalsViewer; + private TabPage tpMRImages; + private InitialProgramImagesViewer ipImagesViewer; + private TabPage tpLibraryReferences; + private TabPage tpTrackList; + private InitialProgramLibraryReferences ipLibraryReferences; + private InitialProgramTocViewer ipTocViewer; + + public FormInitialProgram(InitialProgramExtended ip, string basePath) + { + this.InitializeComponent(); + this.StartPosition = FormStartPosition.CenterParent; + this.ip = ip; + this.basePath = basePath; + } + + private void FormIp_Load(object sender, EventArgs e) + { + this.Text = "Initial Program Viewer: " + this.ip.FileName; + this.ipGeneralSettingsViewer.LoadInitialProgram(this.ip); + this.ipPeriperalsViewer.LoadInitialProgram(this.ip); + this.ipImagesViewer.LoadInitialProgram(this.ip, this.basePath); + this.ipLibraryReferences.LoadInitialProgram(this.ip); + this.ipTocViewer.LoadInitialProgram(this.ip); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.btClose = new Button(); + this.tcInitialProgram = new TabControl(); + this.tpGeneralSettings = new TabPage(); + this.ipGeneralSettingsViewer = new InitialProgramGeneralSettingsViewer(); + this.tpPeripheralSettings = new TabPage(); + this.ipPeriperalsViewer = new InitialProgramPeripheralsViewer(); + this.tpMRImages = new TabPage(); + this.ipImagesViewer = new InitialProgramImagesViewer(); + this.tpLibraryReferences = new TabPage(); + this.ipLibraryReferences = new InitialProgramLibraryReferences(); + this.tpTrackList = new TabPage(); + this.ipTocViewer = new InitialProgramTocViewer(); + this.tcInitialProgram.SuspendLayout(); + this.tpGeneralSettings.SuspendLayout(); + this.tpPeripheralSettings.SuspendLayout(); + this.tpMRImages.SuspendLayout(); + this.tpLibraryReferences.SuspendLayout(); + this.tpTrackList.SuspendLayout(); + this.SuspendLayout(); + this.btClose.DialogResult = DialogResult.Cancel; + this.btClose.FlatStyle = FlatStyle.Popup; + this.btClose.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btClose.ForeColor = Color.FromArgb(248, 48, 0); + this.btClose.Location = new Point(378, 292); + this.btClose.Name = "btClose"; + this.btClose.Size = new Size(108, 22); + this.btClose.TabIndex = 0; + this.btClose.Text = "Close"; + this.btClose.UseVisualStyleBackColor = false; + this.tcInitialProgram.Controls.Add((Control) this.tpGeneralSettings); + this.tcInitialProgram.Controls.Add((Control) this.tpPeripheralSettings); + this.tcInitialProgram.Controls.Add((Control) this.tpMRImages); + this.tcInitialProgram.Controls.Add((Control) this.tpLibraryReferences); + this.tcInitialProgram.Controls.Add((Control) this.tpTrackList); + this.tcInitialProgram.Location = new Point(12, 12); + this.tcInitialProgram.Name = "tcInitialProgram"; + this.tcInitialProgram.SelectedIndex = 0; + this.tcInitialProgram.Size = new Size(474, 274); + this.tcInitialProgram.TabIndex = 0; + this.tpGeneralSettings.BackColor = Color.Transparent; + this.tpGeneralSettings.Controls.Add((Control) this.ipGeneralSettingsViewer); + this.tpGeneralSettings.Cursor = Cursors.Default; + this.tpGeneralSettings.Location = new Point(4, 22); + this.tpGeneralSettings.Name = "tpGeneralSettings"; + this.tpGeneralSettings.Padding = new Padding(3); + this.tpGeneralSettings.Size = new Size(466, 248); + this.tpGeneralSettings.TabIndex = 0; + this.tpGeneralSettings.Text = "General Settings"; + this.tpGeneralSettings.UseVisualStyleBackColor = true; + this.ipGeneralSettingsViewer.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + this.ipGeneralSettingsViewer.AutoSize = true; + this.ipGeneralSettingsViewer.BackColor = Color.Transparent; + this.ipGeneralSettingsViewer.Location = new Point(3, 3); + this.ipGeneralSettingsViewer.Name = "ipGeneralSettingsViewer"; + this.ipGeneralSettingsViewer.Size = new Size(460, 243); + this.ipGeneralSettingsViewer.TabIndex = 12; + this.tpPeripheralSettings.BackColor = Color.Transparent; + this.tpPeripheralSettings.Controls.Add((Control) this.ipPeriperalsViewer); + this.tpPeripheralSettings.Location = new Point(4, 22); + this.tpPeripheralSettings.Name = "tpPeripheralSettings"; + this.tpPeripheralSettings.Padding = new Padding(3); + this.tpPeripheralSettings.Size = new Size(466, 248); + this.tpPeripheralSettings.TabIndex = 1; + this.tpPeripheralSettings.Text = "Peripheral Settings"; + this.tpPeripheralSettings.UseVisualStyleBackColor = true; + this.ipPeriperalsViewer.Anchor = AnchorStyles.Top | AnchorStyles.Bottom | AnchorStyles.Left | AnchorStyles.Right; + this.ipPeriperalsViewer.AutoSize = true; + this.ipPeriperalsViewer.BackColor = Color.Transparent; + this.ipPeriperalsViewer.Location = new Point(3, 3); + this.ipPeriperalsViewer.Name = "ipPeriperalsViewer"; + this.ipPeriperalsViewer.Size = new Size(463, 242); + this.ipPeriperalsViewer.TabIndex = 13; + this.tpMRImages.BackColor = Color.Transparent; + this.tpMRImages.Controls.Add((Control) this.ipImagesViewer); + this.tpMRImages.Location = new Point(4, 22); + this.tpMRImages.Name = "tpMRImages"; + this.tpMRImages.Padding = new Padding(3); + this.tpMRImages.Size = new Size(466, 248); + this.tpMRImages.TabIndex = 2; + this.tpMRImages.Text = "MR Images"; + this.tpMRImages.UseVisualStyleBackColor = true; + this.ipImagesViewer.BackColor = Color.Transparent; + this.ipImagesViewer.Location = new Point(0, 6); + this.ipImagesViewer.Name = "ipImagesViewer"; + this.ipImagesViewer.Size = new Size(463, 239); + this.ipImagesViewer.TabIndex = 0; + this.tpLibraryReferences.BackColor = Color.Transparent; + this.tpLibraryReferences.Controls.Add((Control) this.ipLibraryReferences); + this.tpLibraryReferences.Location = new Point(4, 22); + this.tpLibraryReferences.Name = "tpLibraryReferences"; + this.tpLibraryReferences.Padding = new Padding(3); + this.tpLibraryReferences.Size = new Size(466, 248); + this.tpLibraryReferences.TabIndex = 3; + this.tpLibraryReferences.Text = "Library References"; + this.tpLibraryReferences.UseVisualStyleBackColor = true; + this.ipLibraryReferences.BackColor = Color.Transparent; + this.ipLibraryReferences.Dock = DockStyle.Fill; + this.ipLibraryReferences.Location = new Point(3, 3); + this.ipLibraryReferences.Name = "ipLibraryReferences"; + this.ipLibraryReferences.Size = new Size(460, 242); + this.ipLibraryReferences.TabIndex = 0; + this.tpTrackList.Controls.Add((Control) this.ipTocViewer); + this.tpTrackList.Location = new Point(4, 22); + this.tpTrackList.Name = "tpTrackList"; + this.tpTrackList.Padding = new Padding(3); + this.tpTrackList.Size = new Size(466, 248); + this.tpTrackList.TabIndex = 4; + this.tpTrackList.Text = "Track List"; + this.tpTrackList.UseVisualStyleBackColor = true; + this.ipTocViewer.BackColor = Color.Transparent; + this.ipTocViewer.Dock = DockStyle.Fill; + this.ipTocViewer.Location = new Point(3, 3); + this.ipTocViewer.Name = "ipTocViewer"; + this.ipTocViewer.Size = new Size(460, 242); + this.ipTocViewer.TabIndex = 0; + this.AcceptButton = (IButtonControl) this.btClose; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btClose; + this.ClientSize = new Size(497, 321); + this.Controls.Add((Control) this.tcInitialProgram); + this.Controls.Add((Control) this.btClose); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormInitialProgram); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "IP Viewer"; + this.Load += new EventHandler(this.FormIp_Load); + this.tcInitialProgram.ResumeLayout(false); + this.tpGeneralSettings.ResumeLayout(false); + this.tpGeneralSettings.PerformLayout(); + this.tpPeripheralSettings.ResumeLayout(false); + this.tpPeripheralSettings.PerformLayout(); + this.tpMRImages.ResumeLayout(false); + this.tpLibraryReferences.ResumeLayout(false); + this.tpTrackList.ResumeLayout(false); + this.ResumeLayout(false); + } + } +} diff --git a/Explorer/Forms/FormInitialProgram.resx b/Explorer/Forms/FormInitialProgram.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormInitialProgram.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/FormLoading.cs b/Explorer/Forms/FormLoading.cs new file mode 100644 index 0000000..2d973fe --- /dev/null +++ b/Explorer/Forms/FormLoading.cs @@ -0,0 +1,70 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormLoading +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormLoading : Form + { + private IContainer components; + private Label lbLoadingMessage; + private ProgressBar progressBar; + + public FormLoading(string Title, string Message) + { + this.InitializeComponent(); + this.Text = Title; + this.lbLoadingMessage.Text = Message; + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.lbLoadingMessage = new Label(); + this.progressBar = new ProgressBar(); + this.SuspendLayout(); + this.lbLoadingMessage.Anchor = AnchorStyles.None; + this.lbLoadingMessage.ImageAlign = ContentAlignment.TopCenter; + this.lbLoadingMessage.Location = new Point(12, 9); + this.lbLoadingMessage.Name = "lbLoadingMessage"; + this.lbLoadingMessage.Size = new Size(320, 20); + this.lbLoadingMessage.TabIndex = 5; + this.lbLoadingMessage.Text = "Message"; + this.lbLoadingMessage.TextAlign = ContentAlignment.MiddleLeft; + this.progressBar.Location = new Point(12, 32); + this.progressBar.MarqueeAnimationSpeed = 30; + this.progressBar.Name = "progressBar"; + this.progressBar.Size = new Size(320, 23); + this.progressBar.Style = ProgressBarStyle.Marquee; + this.progressBar.TabIndex = 6; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.ClientSize = new Size(344, 62); + this.ControlBox = false; + this.Controls.Add((Control) this.progressBar); + this.Controls.Add((Control) this.lbLoadingMessage); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormLoading); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Title"; + this.ResumeLayout(false); + } + } +} diff --git a/Explorer/Forms/FormLoading.resx b/Explorer/Forms/FormLoading.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormLoading.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/FormPrimaryVolumeDescriptor.cs b/Explorer/Forms/FormPrimaryVolumeDescriptor.cs new file mode 100644 index 0000000..f6aa1c1 --- /dev/null +++ b/Explorer/Forms/FormPrimaryVolumeDescriptor.cs @@ -0,0 +1,81 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormPrimaryVolumeDescriptor +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.UserControls; +using ImageReader.ISO9660.VolumeDescriptors; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormPrimaryVolumeDescriptor : Form + { + private PrimaryVolumeDescriptor PrimaryVolumeDescriptor; + private IContainer components; + private Button btClose; + private PrimaryVolumeDescriptorViewer primaryVolumeDescriptorViewer; + + public FormPrimaryVolumeDescriptor(PrimaryVolumeDescriptor PrimaryVolumeDescriptor) + { + this.InitializeComponent(); + this.PrimaryVolumeDescriptor = PrimaryVolumeDescriptor; + } + + private void FormInfo_Load(object sender, EventArgs e) => this.primaryVolumeDescriptorViewer.LoadPrimaryVolumeDescriptor(this.PrimaryVolumeDescriptor); + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (FormPrimaryVolumeDescriptor)); + this.btClose = new Button(); + this.primaryVolumeDescriptorViewer = new PrimaryVolumeDescriptorViewer(); + this.SuspendLayout(); + this.btClose.DialogResult = DialogResult.Cancel; + this.btClose.FlatStyle = FlatStyle.Popup; + this.btClose.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btClose.ForeColor = Color.FromArgb(248, 48, 0); + this.btClose.Location = new Point(466, 198); + this.btClose.Name = "btClose"; + this.btClose.Size = new Size(108, 22); + this.btClose.TabIndex = 1; + this.btClose.Text = "Close"; + this.btClose.UseVisualStyleBackColor = false; + this.primaryVolumeDescriptorViewer.AutoSize = true; + this.primaryVolumeDescriptorViewer.Location = new Point(5, 8); + this.primaryVolumeDescriptorViewer.Margin = new Padding(1); + this.primaryVolumeDescriptorViewer.Name = "primaryVolumeDescriptorViewer"; + this.primaryVolumeDescriptorViewer.Size = new Size(571, 181); + this.primaryVolumeDescriptorViewer.TabIndex = 2; + this.AcceptButton = (IButtonControl) this.btClose; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btClose; + this.ClientSize = new Size(584, 226); + this.Controls.Add((Control) this.primaryVolumeDescriptorViewer); + this.Controls.Add((Control) this.btClose); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.Icon = (Icon) componentResourceManager.GetObject("$this.Icon"); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormPrimaryVolumeDescriptor); + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Primary Volume Descriptor Viewer"; + this.Load += new EventHandler(this.FormInfo_Load); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/FormPrimaryVolumeDescriptor.resx b/Explorer/Forms/FormPrimaryVolumeDescriptor.resx new file mode 100644 index 0000000..d59bc03 --- /dev/null +++ b/Explorer/Forms/FormPrimaryVolumeDescriptor.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/Forms/FormProcess.cs b/Explorer/Forms/FormProcess.cs new file mode 100644 index 0000000..a52f457 --- /dev/null +++ b/Explorer/Forms/FormProcess.cs @@ -0,0 +1,423 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormProcess +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Others; +using GDRomExplorer.Resources; +using SEGATools.Audio; +using SEGATools.Disc; +using SEGATools.Encrypt; +using SEGATools.GDEmu; +using SEGATools.Scanner; +using SEGATools.UserProcess; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormProcess : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private UserProcessBase process; + private FormProcess.ProcessInfo processInfo; + private Guid currentConversionTaskId; + private ProgressBar progressBarUnique; + private Label progressBarLabelUnique; + private Point progressBarLabelUniqueInitialLocation; + private Size progressBarLabelUniqueInitialSize; + private bool NotifyAppStatusEvent; + private IContainer components; + private GroupBox groupBoxProgress; + private ProgressBar progressBarTotal; + private ProgressBar progressBarCurrent; + private Label lbOutputTitle; + private Label lbInputTitle; + private Button btCancel; + private Label lbOutput; + private Label lbInput; + private Label lbTotalPercentage; + private Label lbCurrentPercentage; + + public static FormProcess createForDiscExtractor( + DiscExtractor discExtractor, + Guid TaskId) + { + FormProcess.ProcessInfo forDiscExtractor = FormProcess.ProcessInfo.GetProcessInfoForDiscExtractor(); + return new FormProcess((UserProcessBase) discExtractor, forDiscExtractor, TaskId, true); + } + + public static FormProcess createForRawToWavConverter( + Raw2WavConverter raw2WavConverter, + Guid TaskId) + { + FormProcess.ProcessInfo rawToWavConverter = FormProcess.ProcessInfo.GetProcessInfoForRawToWavConverter(); + return new FormProcess((UserProcessBase) raw2WavConverter, rawToWavConverter, TaskId, true); + } + + public static FormProcess createForDesEncryptor( + DesEncryptDecryptTool desDecryptor, + Guid TaskId) + { + FormProcess.ProcessInfo infoForDesEncryptor = FormProcess.ProcessInfo.GetProcessInfoForDesEncryptor(); + return new FormProcess((UserProcessBase) desDecryptor, infoForDesEncryptor, TaskId, true); + } + + public static FormProcess createForDesDecryptor( + DesEncryptDecryptTool desDecryptor, + Guid TaskId) + { + FormProcess.ProcessInfo infoForDesDecryptor = FormProcess.ProcessInfo.GetProcessInfoForDesDecryptor(); + return new FormProcess((UserProcessBase) desDecryptor, infoForDesDecryptor, TaskId, true); + } + + public static FormProcess createForFileScanner(FileScanner fileScanner, Guid TaskId) + { + FormProcess.ProcessInfo infoForFileScanner = FormProcess.ProcessInfo.GetProcessInfoForFileScanner(); + return new FormProcess((UserProcessBase) fileScanner, infoForFileScanner, TaskId, true); + } + + public static FormProcess createForGDEmuConverter( + GDEmuConverter gdEmuConverter, + Guid TaskId) + { + FormProcess.ProcessInfo forGdEmuConverter = FormProcess.ProcessInfo.GetProcessInfoForGDEmuConverter(); + return new FormProcess((UserProcessBase) gdEmuConverter, forGdEmuConverter, TaskId, false); + } + + private FormProcess( + UserProcessBase Process, + FormProcess.ProcessInfo ProcessInfo, + Guid TaskId, + bool NotifyAppStatusEvent) + { + this.InitializeComponent(); + this.process = Process; + this.processInfo = ProcessInfo; + this.Text = this.processInfo.ProcessTitle; + this.groupBoxProgress.Text = this.processInfo.ProcessSubTitle + ":"; + this.currentConversionTaskId = TaskId; + this.progressBarUnique = this.progressBarCurrent; + this.progressBarLabelUnique = this.lbCurrentPercentage; + this.progressBarLabelUniqueInitialLocation = this.progressBarLabelUnique.Location; + this.progressBarLabelUniqueInitialSize = this.progressBarUnique.Size; + this.NotifyAppStatusEvent = NotifyAppStatusEvent; + this.AddEventListeners(); + } + + private void AddEventListeners() + { + this.process.AsyncOperationProgressChanged += new AsyncOperationProgressChangedEventHandler(this.ProgressChanged); + this.process.AsyncOperationCompleted += new AsyncOperationCompletedEventHandler(this.ProcessCompleted); + this.process.AsyncOperationWaitForUserConsent += new AsyncOperationProgressWaitingForUserConsentEventHandler(this.ProcessWaitForUserConsent); + this.process.AsyncOperationUpdateUIView += new AsyncOperationProgressUpdateUIEventHandler(this.ProcessUpdateUIView); + } + + private void RemoveEventListeners() + { + this.process.AsyncOperationProgressChanged -= new AsyncOperationProgressChangedEventHandler(this.ProgressChanged); + this.process.AsyncOperationCompleted -= new AsyncOperationCompletedEventHandler(this.ProcessCompleted); + this.process.AsyncOperationWaitForUserConsent -= new AsyncOperationProgressWaitingForUserConsentEventHandler(this.ProcessWaitForUserConsent); + this.process.AsyncOperationUpdateUIView -= new AsyncOperationProgressUpdateUIEventHandler(this.ProcessUpdateUIView); + } + + private void UpdateProgressBar( + ProgressBar ProgressBar, + Label ProgressPercentage, + int Percentage) + { + if (Percentage == ProgressBar.Value) + return; + ProgressBar.Value = Percentage >= 100 ? 100 : Percentage; + ProgressPercentage.Text = ProgressBar.Value.ToString() + "%"; + } + + private void NotifyNewAppStatus(string message) + { + if (!this.NotifyAppStatusEvent) + return; + AppStatus.NotifyNewAppStatus(message); + } + + private void UpdateProgressBarsWithInitialValues() + { + this.progressBarUnique.Size = this.progressBarLabelUniqueInitialSize; + this.progressBarLabelUnique.Location = this.progressBarLabelUniqueInitialLocation; + } + + private void ResizeForOneProgressBarWithPercentage() + { + this.progressBarUnique.Height = this.progressBarTotal.Location.Y + this.progressBarTotal.Height - this.progressBarCurrent.Location.Y; + this.progressBarLabelUnique.Location = new Point(this.lbCurrentPercentage.Location.X, this.progressBarCurrent.Location.Y + (this.progressBarCurrent.Height - this.lbCurrentPercentage.Height) / 2); + } + + private void ResizeForOneProgressBarWithoutPercentage() + { + this.ResizeForOneProgressBarWithPercentage(); + this.progressBarUnique.Width = this.lbTotalPercentage.Location.X + this.lbTotalPercentage.Width - this.progressBarTotal.Location.X; + } + + private void UpdateInputTitleAndText(string newTitle, bool showText) + { + this.lbInputTitle.Text = newTitle; + this.lbInput.Visible = showText; + } + + private void ProgressChanged(UserProcessProgressChangedEventArgs e) + { + if (!this.Visible) + { + int num = (int) this.ShowDialog(); + } + this.UpdateProgressBar(this.progressBarCurrent, this.lbCurrentPercentage, e.ProgressPercentage); + this.UpdateProgressBar(this.progressBarTotal, this.lbTotalPercentage, e.TotalProgressPercentage); + this.lbInput.Text = e.Input; + this.lbOutput.Text = e.Output; + this.Update(); + } + + private void ProcessCompleted(object sender, UserProcessCompletedEventArgs e) + { + if (e.Error != null) + { + string str = string.Format("{0} error with \"{1}\":\n{2}", (object) this.processInfo.ProcessTypeName, (object) e.ResourceName, (object) e.Error.Message); + FormProcess.logger.Error((object) str); + int num = (int) MessageBox.Show((IWin32Window) this, str, this.processInfo.ProcessTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + this.NotifyNewAppStatus(str); + } + else if (e.Cancelled) + { + string message = string.Format("{0} canceled!", (object) this.processInfo.ProcessTypeName); + FormProcess.logger.Info((object) message); + this.NotifyNewAppStatus(message); + } + else + { + this.UpdateProgressBar(this.progressBarCurrent, this.lbCurrentPercentage, 100); + this.UpdateProgressBar(this.progressBarTotal, this.lbTotalPercentage, 100); + string message = string.Format("{0} successfully completed!", (object) this.processInfo.ProcessTypeName); + FormProcess.logger.Info((object) message); + this.NotifyNewAppStatus(message); + } + this.RemoveEventListeners(); + this.Close(); + } + + private void ProcessWaitForUserConsent(UserProcessWaitingForUserConsentEventArgs e) + { + string caption = Strings.ResourceManager.GetString(e.QuestionTitleResourceName); + if (MessageBox.Show((IWin32Window) this, UserProcessEventArgsConverter.ToFormatedString(e, Strings.ResourceManager), caption, MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) != DialogResult.Yes) + this.process.CancelAsync((object) this.currentConversionTaskId); + e.ResetEvent.Set(); + } + + private void ProcessUpdateUIView(UserProcessUpdateUIViewEventArgs e) + { + this.UpdateProgressBarsWithInitialValues(); + switch (e.UIStyle) + { + case UserProcessUpdateUIViewEventArgs.UserProgressUIStyle.OneProgressBarWithPercentage: + this.progressBarTotal.Visible = false; + this.lbTotalPercentage.Visible = false; + this.progressBarCurrent.Visible = true; + this.lbCurrentPercentage.Visible = true; + this.progressBarCurrent.Style = ProgressBarStyle.Continuous; + this.ResizeForOneProgressBarWithPercentage(); + break; + case UserProcessUpdateUIViewEventArgs.UserProgressUIStyle.OneProgressBarWithoutPercentage: + this.progressBarTotal.Visible = false; + this.lbTotalPercentage.Visible = false; + this.progressBarCurrent.Visible = true; + this.lbCurrentPercentage.Visible = false; + this.progressBarCurrent.Style = ProgressBarStyle.Marquee; + this.ResizeForOneProgressBarWithoutPercentage(); + break; + case UserProcessUpdateUIViewEventArgs.UserProgressUIStyle.TwoProgressBarsWithPercentage: + this.progressBarTotal.Visible = true; + this.lbTotalPercentage.Visible = true; + this.progressBarCurrent.Visible = true; + this.lbCurrentPercentage.Visible = true; + this.progressBarTotal.Style = ProgressBarStyle.Continuous; + this.progressBarCurrent.Style = ProgressBarStyle.Continuous; + break; + } + if (!e.UpdateInputTitle) + return; + this.UpdateInputTitleAndText(Strings.ResourceManager.GetString(e.InputTitleResourceName), e.ShowInputText); + } + + private void btCancel_Click(object sender, EventArgs e) => this.process.CancelAsync((object) this.currentConversionTaskId); + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (FormProcess)); + this.groupBoxProgress = new GroupBox(); + this.lbCurrentPercentage = new Label(); + this.lbTotalPercentage = new Label(); + this.lbOutput = new Label(); + this.lbInput = new Label(); + this.btCancel = new Button(); + this.progressBarTotal = new ProgressBar(); + this.progressBarCurrent = new ProgressBar(); + this.lbOutputTitle = new Label(); + this.lbInputTitle = new Label(); + this.groupBoxProgress.SuspendLayout(); + this.SuspendLayout(); + this.groupBoxProgress.Controls.Add((Control) this.lbOutputTitle); + this.groupBoxProgress.Controls.Add((Control) this.lbInputTitle); + this.groupBoxProgress.Controls.Add((Control) this.lbCurrentPercentage); + this.groupBoxProgress.Controls.Add((Control) this.lbTotalPercentage); + this.groupBoxProgress.Controls.Add((Control) this.lbOutput); + this.groupBoxProgress.Controls.Add((Control) this.lbInput); + this.groupBoxProgress.Controls.Add((Control) this.btCancel); + this.groupBoxProgress.Controls.Add((Control) this.progressBarTotal); + this.groupBoxProgress.Controls.Add((Control) this.progressBarCurrent); + this.groupBoxProgress.Location = new Point(12, 12); + this.groupBoxProgress.Name = "groupBoxProgress"; + this.groupBoxProgress.Size = new Size(421, 137); + this.groupBoxProgress.TabIndex = 9; + this.groupBoxProgress.TabStop = false; + this.groupBoxProgress.Text = "ProgressSubTitle"; + this.lbCurrentPercentage.AutoSize = true; + this.lbCurrentPercentage.BackColor = Color.Transparent; + this.lbCurrentPercentage.Font = new Font("Microsoft Sans Serif", 9.75f, FontStyle.Bold, GraphicsUnit.Point, (byte) 0); + this.lbCurrentPercentage.ImageAlign = ContentAlignment.MiddleRight; + this.lbCurrentPercentage.Location = new Point(370, 66); + this.lbCurrentPercentage.Name = "lbCurrentPercentage"; + this.lbCurrentPercentage.Size = new Size(45, 16); + this.lbCurrentPercentage.TabIndex = 9; + this.lbCurrentPercentage.Text = "100%"; + this.lbCurrentPercentage.TextAlign = ContentAlignment.MiddleRight; + this.lbTotalPercentage.AutoSize = true; + this.lbTotalPercentage.BackColor = Color.Transparent; + this.lbTotalPercentage.Font = new Font("Microsoft Sans Serif", 9.75f, FontStyle.Bold, GraphicsUnit.Point, (byte) 0); + this.lbTotalPercentage.ImageAlign = ContentAlignment.MiddleRight; + this.lbTotalPercentage.Location = new Point(370, 87); + this.lbTotalPercentage.Name = "lbTotalPercentage"; + this.lbTotalPercentage.Size = new Size(45, 16); + this.lbTotalPercentage.TabIndex = 10; + this.lbTotalPercentage.Text = "100%"; + this.lbTotalPercentage.TextAlign = ContentAlignment.MiddleRight; + this.lbOutput.AutoEllipsis = true; + this.lbOutput.Location = new Point(51, 43); + this.lbOutput.Name = "lbOutput"; + this.lbOutput.Size = new Size(358, 14); + this.lbOutput.TabIndex = 8; + this.lbInput.AutoEllipsis = true; + this.lbInput.Location = new Point(51, 20); + this.lbInput.Name = "lbInput"; + this.lbInput.Size = new Size(358, 14); + this.lbInput.TabIndex = 7; + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(156, 108); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size(108, 22); + this.btCancel.TabIndex = 6; + this.btCancel.Text = "Cancel"; + this.btCancel.UseVisualStyleBackColor = false; + this.btCancel.Click += new EventHandler(this.btCancel_Click); + this.progressBarTotal.Location = new Point(8, 87); + this.progressBarTotal.Name = "progressBarTotal"; + this.progressBarTotal.Size = new Size(356, 15); + this.progressBarTotal.TabIndex = 4; + this.progressBarCurrent.Location = new Point(8, 66); + this.progressBarCurrent.Name = "progressBarCurrent"; + this.progressBarCurrent.Size = new Size(356, 15); + this.progressBarCurrent.TabIndex = 3; + this.lbOutputTitle.AutoSize = true; + this.lbOutputTitle.Location = new Point(6, 43); + this.lbOutputTitle.Name = "lbOutputTitle"; + this.lbOutputTitle.Size = new Size(42, 13); + this.lbOutputTitle.TabIndex = 1; + this.lbOutputTitle.Text = "Output:"; + this.lbInputTitle.AutoSize = true; + this.lbInputTitle.Location = new Point(6, 20); + this.lbInputTitle.Name = "lbInputTitle"; + this.lbInputTitle.Size = new Size(34, 13); + this.lbInputTitle.TabIndex = 0; + this.lbInputTitle.Text = "Input:"; + this.lbInputTitle.TextAlign = ContentAlignment.MiddleLeft; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.ClientSize = new Size(445, 161); + this.ControlBox = false; + this.Controls.Add((Control) this.groupBoxProgress); + this.DoubleBuffered = true; + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.Icon = (Icon) componentResourceManager.GetObject("$this.Icon"); + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormProcess); + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "ProcessTitle"; + this.groupBoxProgress.ResumeLayout(false); + this.groupBoxProgress.PerformLayout(); + this.ResumeLayout(false); + } + + internal class ProcessInfo + { + internal string ProcessTitle; + internal string ProcessSubTitle; + internal string ProcessTypeName; + + internal static FormProcess.ProcessInfo GetProcessInfoForDesEncryptor() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.DESEncryptorTitle, + ProcessSubTitle = Strings.DESEncryptorSubTitle, + ProcessTypeName = Strings.DESEncryptorTypeName + }; + + internal static FormProcess.ProcessInfo GetProcessInfoForDesDecryptor() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.DESDecryptorTitle, + ProcessSubTitle = Strings.DESDecryptorSubTitle, + ProcessTypeName = Strings.DESDescriptorTypeName + }; + + internal static FormProcess.ProcessInfo GetProcessInfoForFileScanner() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.FileScannerTitle, + ProcessSubTitle = Strings.FileScannerSubTitle, + ProcessTypeName = Strings.FileScannerTypeName + }; + + internal static FormProcess.ProcessInfo GetProcessInfoForDiscExtractor() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.FileExtractorTitle, + ProcessSubTitle = Strings.FileExtractorSubTitle, + ProcessTypeName = Strings.FileExtractorTypeName + }; + + internal static FormProcess.ProcessInfo GetProcessInfoForRawToWavConverter() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.Raw2WavConverterTitle, + ProcessSubTitle = Strings.Raw2WavConverterSubTitle, + ProcessTypeName = Strings.Raw2WavConverterTypeName + }; + + internal static FormProcess.ProcessInfo GetProcessInfoForGDEmuConverter() => new FormProcess.ProcessInfo() + { + ProcessTitle = Strings.GDEmuExporterTitle, + ProcessSubTitle = Strings.GDEmuExporterSubTitle, + ProcessTypeName = Strings.GDEmuExporterTypeName + }; + } + } +} diff --git a/Explorer/Forms/FormProcess.resx b/Explorer/Forms/FormProcess.resx new file mode 100644 index 0000000..81cdbcf --- /dev/null +++ b/Explorer/Forms/FormProcess.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/Forms/FormSettings.cs b/Explorer/Forms/FormSettings.cs new file mode 100644 index 0000000..ae0e630 --- /dev/null +++ b/Explorer/Forms/FormSettings.cs @@ -0,0 +1,363 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormSettings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Properties; +using GDRomExplorer.Resources; +using SEGATools.Disc; +using SEGATools.FileFormat; +using SEGATools.Registry; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Globalization; +using System.IO; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormSettings : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private readonly List initialFileExtensions; + private IContainer components; + private TableLayoutPanel tableLayoutPanel; + private Button btSaveClose; + private Button btCancel; + private TabControl tabControl; + private TabPage tpAppSettings; + private TabPage tpImageReaderSettings; + private DiscFormatProvider discFormatProvider; + private GroupBox gbFileExtensions; + private CheckedListBox checkedListBox; + private FlowLayoutPanel flowLayoutPanel; + private LinkLabel lbCheckAll; + private LinkLabel lbSelectNone; + private TableLayoutPanel tableLayoutPanelImageReading; + private GroupBox gbImageReaderOptions; + private CheckBox cbComputePathTable; + private Label lbInfoPathTable; + + public FormSettings() + { + this.InitializeComponent(); + this.initialFileExtensions = new List(); + this.FillFileAssociationList(); + this.cbComputePathTable.Checked = Settings.Default.ImageReaderComputePathTable; + this.lbInfoPathTable.Text = Strings.SettingsInfoPathTable; + } + + private string GetFileAssociationInfoName(string FileExtension) => "GDRomExplorer" + FileExtension; + + private void FillFileAssociationList() + { + this.checkedListBox.Items.Clear(); + foreach (IImageFileFormat ImageFileFormat in this.discFormatProvider.SupportedFileFormat) + { + for (int index = 0; index < ImageFileFormat.FileExtentions.Length; ++index) + { + string fileExtention = ImageFileFormat.FileExtentions[index]; + string extentionDescription = ImageFileFormat.FileExtentionDescriptions[index]; + bool application = this.IsExtensionAssociatedToApplication(fileExtention); + FormSettings.CheckedListBoxItem checkedListBoxItem = new FormSettings.CheckedListBoxItem(fileExtention, extentionDescription, ImageFileFormat); + if (application) + this.initialFileExtensions.Add(checkedListBoxItem); + this.checkedListBox.Items.Add((object) checkedListBoxItem, application); + } + } + } + + private bool IsExtensionAssociatedToApplication(string fileExtension) + { + FileAssociationInfo fileAssociationInfo = new FileAssociationInfo(fileExtension); + return fileAssociationInfo.Exists && fileAssociationInfo.ProgID.Equals(this.GetFileAssociationInfoName(fileExtension)); + } + + private void AddFileAssociation(FormSettings.CheckedListBoxItem item) + { + FileAssociationInfo fileAssociationInfo = new FileAssociationInfo(item.FileExtension); + fileAssociationInfo.Create(this.GetFileAssociationInfoName(item.FileExtension)); + string fullPath = Path.GetFullPath(Environment.GetCommandLineArgs()[0]); + ProgramAssociationInfo programAssociationInfo = new ProgramAssociationInfo(fileAssociationInfo.ProgID); + programAssociationInfo.Create(item.FileDescription, new ProgramVerb("Open", fullPath + " \"%1\"")); + string path = fullPath; + programAssociationInfo.DefaultIcon = new ProgramIcon(path, 1); + } + + private void RemoveFileAssociation(string fileExtension) + { + FileAssociationInfo fileAssociationInfo = new FileAssociationInfo(fileExtension); + if (!this.IsExtensionAssociatedToApplication(fileExtension)) + return; + ProgramAssociationInfo programAssociationInfo = new ProgramAssociationInfo(fileAssociationInfo.ProgID); + if (programAssociationInfo.Exists) + programAssociationInfo.Delete(); + fileAssociationInfo.Delete(); + } + + private void UpdateFileExtensions() + { + FormSettings.logger.Info((object) "Updating file extensions"); + foreach (FormSettings.CheckedListBoxItem checkedListBoxItem in (ListBox.ObjectCollection) this.checkedListBox.Items) + { + bool flag1 = this.initialFileExtensions.Contains(checkedListBoxItem); + bool flag2 = this.checkedListBox.CheckedItems.Contains((object) checkedListBoxItem); + if (!flag1 && flag2) + this.AddFileAssociation(checkedListBoxItem); + if (flag1 && !flag2) + this.RemoveFileAssociation(checkedListBoxItem.FileExtension); + } + } + + private void UpdateImageReaderSettings() + { + FormSettings.logger.Info((object) "Updating image reader settings"); + Settings.Default.ImageReaderComputePathTable = this.cbComputePathTable.Checked; + } + + private void btSaveClose_Click(object sender, EventArgs e) + { + this.UpdateFileExtensions(); + this.UpdateImageReaderSettings(); + AppStatus.NotifyNewAppStatus(Strings.SettingsSaved); + } + + private void lbSelectNone_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + for (int index = 0; index < this.checkedListBox.Items.Count; ++index) + this.checkedListBox.SetItemChecked(index, false); + } + + private void lbCheckAll_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e) + { + for (int index = 0; index < this.checkedListBox.Items.Count; ++index) + this.checkedListBox.SetItemChecked(index, true); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.tableLayoutPanel = new TableLayoutPanel(); + this.btCancel = new Button(); + this.btSaveClose = new Button(); + this.tabControl = new TabControl(); + this.tpAppSettings = new TabPage(); + this.gbFileExtensions = new GroupBox(); + this.flowLayoutPanel = new FlowLayoutPanel(); + this.lbCheckAll = new LinkLabel(); + this.lbSelectNone = new LinkLabel(); + this.checkedListBox = new CheckedListBox(); + this.tpImageReaderSettings = new TabPage(); + this.tableLayoutPanelImageReading = new TableLayoutPanel(); + this.gbImageReaderOptions = new GroupBox(); + this.lbInfoPathTable = new Label(); + this.cbComputePathTable = new CheckBox(); + this.discFormatProvider = new DiscFormatProvider(); + this.tableLayoutPanel.SuspendLayout(); + this.tabControl.SuspendLayout(); + this.tpAppSettings.SuspendLayout(); + this.gbFileExtensions.SuspendLayout(); + this.flowLayoutPanel.SuspendLayout(); + this.tpImageReaderSettings.SuspendLayout(); + this.tableLayoutPanelImageReading.SuspendLayout(); + this.gbImageReaderOptions.SuspendLayout(); + this.SuspendLayout(); + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50f)); + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50f)); + this.tableLayoutPanel.Controls.Add((Control) this.btCancel, 0, 1); + this.tableLayoutPanel.Controls.Add((Control) this.btSaveClose, 1, 1); + this.tableLayoutPanel.Controls.Add((Control) this.tabControl, 0, 0); + this.tableLayoutPanel.Dock = DockStyle.Fill; + this.tableLayoutPanel.Location = new Point(0, 0); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 2; + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 89.3617f)); + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 10.6383f)); + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Absolute, 20f)); + this.tableLayoutPanel.Size = new Size(271, 235); + this.tableLayoutPanel.TabIndex = 0; + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.Dock = DockStyle.Fill; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(3, 212); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size(129, 20); + this.btCancel.TabIndex = 11; + this.btCancel.Text = "&Cancel"; + this.btCancel.UseVisualStyleBackColor = false; + this.btSaveClose.DialogResult = DialogResult.Cancel; + this.btSaveClose.Dock = DockStyle.Fill; + this.btSaveClose.FlatStyle = FlatStyle.Popup; + this.btSaveClose.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btSaveClose.ForeColor = Color.FromArgb(248, 48, 0); + this.btSaveClose.Location = new Point(138, 212); + this.btSaveClose.Name = "btSaveClose"; + this.btSaveClose.Size = new Size(130, 20); + this.btSaveClose.TabIndex = 10; + this.btSaveClose.Text = "&OK"; + this.btSaveClose.UseVisualStyleBackColor = false; + this.btSaveClose.Click += new EventHandler(this.btSaveClose_Click); + this.tableLayoutPanel.SetColumnSpan((Control) this.tabControl, 2); + this.tabControl.Controls.Add((Control) this.tpAppSettings); + this.tabControl.Controls.Add((Control) this.tpImageReaderSettings); + this.tabControl.Dock = DockStyle.Fill; + this.tabControl.Location = new Point(3, 3); + this.tabControl.Name = "tabControl"; + this.tabControl.SelectedIndex = 0; + this.tabControl.Size = new Size(265, 203); + this.tabControl.TabIndex = 12; + this.tpAppSettings.BackColor = SystemColors.Window; + this.tpAppSettings.Controls.Add((Control) this.gbFileExtensions); + this.tpAppSettings.Location = new Point(4, 22); + this.tpAppSettings.Name = "tpAppSettings"; + this.tpAppSettings.Padding = new Padding(3); + this.tpAppSettings.Size = new Size(257, 177); + this.tpAppSettings.TabIndex = 0; + this.tpAppSettings.Text = "General"; + this.gbFileExtensions.BackColor = SystemColors.Window; + this.gbFileExtensions.Controls.Add((Control) this.flowLayoutPanel); + this.gbFileExtensions.Controls.Add((Control) this.checkedListBox); + this.gbFileExtensions.Dock = DockStyle.Top; + this.gbFileExtensions.Location = new Point(3, 3); + this.gbFileExtensions.Name = "gbFileExtensions"; + this.gbFileExtensions.Size = new Size(251, 167); + this.gbFileExtensions.TabIndex = 1; + this.gbFileExtensions.TabStop = false; + this.gbFileExtensions.Text = "File Extensions:"; + this.flowLayoutPanel.Controls.Add((Control) this.lbCheckAll); + this.flowLayoutPanel.Controls.Add((Control) this.lbSelectNone); + this.flowLayoutPanel.Dock = DockStyle.Bottom; + this.flowLayoutPanel.Location = new Point(3, 147); + this.flowLayoutPanel.Name = "flowLayoutPanel"; + this.flowLayoutPanel.Size = new Size(245, 17); + this.flowLayoutPanel.TabIndex = 3; + this.lbCheckAll.AutoSize = true; + this.lbCheckAll.Dock = DockStyle.Bottom; + this.lbCheckAll.Location = new Point(3, 0); + this.lbCheckAll.Name = "lbCheckAll"; + this.lbCheckAll.Size = new Size(48, 13); + this.lbCheckAll.TabIndex = 6; + this.lbCheckAll.TabStop = true; + this.lbCheckAll.Text = "select all"; + this.lbCheckAll.LinkClicked += new LinkLabelLinkClickedEventHandler(this.lbCheckAll_LinkClicked); + this.lbSelectNone.AutoSize = true; + this.lbSelectNone.Dock = DockStyle.Bottom; + this.lbSelectNone.Location = new Point(57, 0); + this.lbSelectNone.Name = "lbSelectNone"; + this.lbSelectNone.Size = new Size(62, 13); + this.lbSelectNone.TabIndex = 7; + this.lbSelectNone.TabStop = true; + this.lbSelectNone.Text = "select none"; + this.lbSelectNone.LinkClicked += new LinkLabelLinkClickedEventHandler(this.lbSelectNone_LinkClicked); + this.checkedListBox.CheckOnClick = true; + this.checkedListBox.Dock = DockStyle.Top; + this.checkedListBox.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.checkedListBox.FormattingEnabled = true; + this.checkedListBox.Location = new Point(3, 16); + this.checkedListBox.Name = "checkedListBox"; + this.checkedListBox.Size = new Size(245, 124); + this.checkedListBox.Sorted = true; + this.checkedListBox.TabIndex = 1; + this.tpImageReaderSettings.BackColor = SystemColors.Window; + this.tpImageReaderSettings.Controls.Add((Control) this.tableLayoutPanelImageReading); + this.tpImageReaderSettings.Location = new Point(4, 22); + this.tpImageReaderSettings.Name = "tpImageReaderSettings"; + this.tpImageReaderSettings.Padding = new Padding(3); + this.tpImageReaderSettings.Size = new Size(257, 177); + this.tpImageReaderSettings.TabIndex = 1; + this.tpImageReaderSettings.Text = "Image Reading"; + this.tableLayoutPanelImageReading.BackColor = Color.Transparent; + this.tableLayoutPanelImageReading.ColumnCount = 1; + this.tableLayoutPanelImageReading.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50f)); + this.tableLayoutPanelImageReading.Controls.Add((Control) this.gbImageReaderOptions, 0, 0); + this.tableLayoutPanelImageReading.Dock = DockStyle.Fill; + this.tableLayoutPanelImageReading.Location = new Point(3, 3); + this.tableLayoutPanelImageReading.Name = "tableLayoutPanelImageReading"; + this.tableLayoutPanelImageReading.RowCount = 1; + this.tableLayoutPanelImageReading.RowStyles.Add(new RowStyle(SizeType.Percent, 50f)); + this.tableLayoutPanelImageReading.Size = new Size(251, 171); + this.tableLayoutPanelImageReading.TabIndex = 0; + this.gbImageReaderOptions.Controls.Add((Control) this.lbInfoPathTable); + this.gbImageReaderOptions.Controls.Add((Control) this.cbComputePathTable); + this.gbImageReaderOptions.Dock = DockStyle.Top; + this.gbImageReaderOptions.Location = new Point(3, 3); + this.gbImageReaderOptions.Name = "gbImageReaderOptions"; + this.gbImageReaderOptions.Size = new Size(245, 90); + this.gbImageReaderOptions.TabIndex = 0; + this.gbImageReaderOptions.TabStop = false; + this.gbImageReaderOptions.Text = "ISO9660 File System:"; + this.lbInfoPathTable.Dock = DockStyle.Bottom; + this.lbInfoPathTable.Location = new Point(3, 40); + this.lbInfoPathTable.Name = "lbInfoPathTable"; + this.lbInfoPathTable.Size = new Size(239, 47); + this.lbInfoPathTable.TabIndex = 1; + this.lbInfoPathTable.Text = "Info path table"; + this.cbComputePathTable.AutoSize = true; + this.cbComputePathTable.Location = new Point(7, 20); + this.cbComputePathTable.Name = "cbComputePathTable"; + this.cbComputePathTable.Size = new Size(118, 17); + this.cbComputePathTable.TabIndex = 0; + this.cbComputePathTable.Text = "Compute path table"; + this.cbComputePathTable.UseVisualStyleBackColor = true; + this.AcceptButton = (IButtonControl) this.btSaveClose; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.ClientSize = new Size(271, 235); + this.Controls.Add((Control) this.tableLayoutPanel); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormSettings); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Settings"; + this.tableLayoutPanel.ResumeLayout(false); + this.tabControl.ResumeLayout(false); + this.tpAppSettings.ResumeLayout(false); + this.gbFileExtensions.ResumeLayout(false); + this.flowLayoutPanel.ResumeLayout(false); + this.flowLayoutPanel.PerformLayout(); + this.tpImageReaderSettings.ResumeLayout(false); + this.tableLayoutPanelImageReading.ResumeLayout(false); + this.gbImageReaderOptions.ResumeLayout(false); + this.gbImageReaderOptions.PerformLayout(); + this.ResumeLayout(false); + } + + private class CheckedListBoxItem + { + public string FileExtension { get; private set; } + + public string FileDescription { get; private set; } + + public IImageFileFormat ImageFileFormat { get; private set; } + + internal CheckedListBoxItem( + string FileExtension, + string FileDescription, + IImageFileFormat ImageFileFormat) + { + this.FileExtension = FileExtension; + this.FileDescription = FileDescription; + this.ImageFileFormat = ImageFileFormat; + } + + public override string ToString() => string.Format("*{0} - {1}", (object) this.FileExtension.ToUpper(CultureInfo.InvariantCulture), (object) this.FileDescription); + } + } +} diff --git a/Explorer/Forms/FormSettings.resx b/Explorer/Forms/FormSettings.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormSettings.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/FormSortFileOptions.cs b/Explorer/Forms/FormSortFileOptions.cs new file mode 100644 index 0000000..3afc6ed --- /dev/null +++ b/Explorer/Forms/FormSortFileOptions.cs @@ -0,0 +1,158 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.FormSortFileOptions +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.Forms +{ + public class FormSortFileOptions : Form + { + protected static string DEFAULT_PREFIX = "data\\"; + protected static int DEFAULT_LOWEST_FILE_WEIGHT = 0; + private IContainer components; + private TextBox tbPathPrefix; + private Label lbDESKey; + private Button btGenerateSortFile; + private Button btCancel; + private Label lbLowestFileWeight; + private Label lbInfoSortFile; + private NumericUpDown nudFileWeight; + + public string PathPrefix { get; private set; } + + public int LowestFileWeight { get; private set; } + + public FormSortFileOptions() + { + this.InitializeComponent(); + this.PathPrefix = FormSortFileOptions.DEFAULT_PREFIX; + this.LowestFileWeight = FormSortFileOptions.DEFAULT_LOWEST_FILE_WEIGHT; + } + + private void btCancel_Click(object sender, EventArgs e) => this.Close(); + + private void FormGetSortTxtPrefix_Load(object sender, EventArgs e) + { + this.lbInfoSortFile.Text = Strings.SortFileOptionsHint; + this.nudFileWeight.Value = (Decimal) this.LowestFileWeight; + this.tbPathPrefix.Text = this.PathPrefix; + this.tbPathPrefix.Focus(); + } + + private void btGenerateSortFile_Click(object sender, EventArgs e) + { + this.PathPrefix = this.tbPathPrefix.Text; + this.LowestFileWeight = Convert.ToInt32(this.nudFileWeight.Value); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.tbPathPrefix = new TextBox(); + this.lbDESKey = new Label(); + this.btGenerateSortFile = new Button(); + this.btCancel = new Button(); + this.lbLowestFileWeight = new Label(); + this.lbInfoSortFile = new Label(); + this.nudFileWeight = new NumericUpDown(); + this.nudFileWeight.BeginInit(); + this.SuspendLayout(); + this.tbPathPrefix.Location = new Point(78, 6); + this.tbPathPrefix.MaxLength = 0; + this.tbPathPrefix.Name = "tbPathPrefix"; + this.tbPathPrefix.Size = new Size(130, 20); + this.tbPathPrefix.TabIndex = 0; + this.tbPathPrefix.Text = "data\\"; + this.lbDESKey.AutoSize = true; + this.lbDESKey.Location = new Point(12, 9); + this.lbDESKey.Name = "lbDESKey"; + this.lbDESKey.Size = new Size(60, 13); + this.lbDESKey.TabIndex = 2; + this.lbDESKey.Text = "Path prefix:"; + this.btGenerateSortFile.DialogResult = DialogResult.OK; + this.btGenerateSortFile.FlatStyle = FlatStyle.Popup; + this.btGenerateSortFile.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btGenerateSortFile.ForeColor = Color.FromArgb(248, 48, 0); + this.btGenerateSortFile.Location = new Point(250, 102); + this.btGenerateSortFile.Name = "btGenerateSortFile"; + this.btGenerateSortFile.Size = new Size((int) sbyte.MaxValue, 22); + this.btGenerateSortFile.TabIndex = 1; + this.btGenerateSortFile.Text = "&Generate sort file"; + this.btGenerateSortFile.UseVisualStyleBackColor = false; + this.btGenerateSortFile.Click += new EventHandler(this.btGenerateSortFile_Click); + this.btCancel.DialogResult = DialogResult.Cancel; + this.btCancel.FlatStyle = FlatStyle.Popup; + this.btCancel.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btCancel.ForeColor = Color.FromArgb(248, 48, 0); + this.btCancel.Location = new Point(15, 102); + this.btCancel.Name = "btCancel"; + this.btCancel.Size = new Size((int) sbyte.MaxValue, 22); + this.btCancel.TabIndex = 2; + this.btCancel.Text = "&Cancel"; + this.btCancel.UseVisualStyleBackColor = false; + this.btCancel.Click += new EventHandler(this.btCancel_Click); + this.lbLowestFileWeight.AutoSize = true; + this.lbLowestFileWeight.Location = new Point(214, 9); + this.lbLowestFileWeight.Name = "lbLowestFileWeight"; + this.lbLowestFileWeight.Size = new Size(94, 13); + this.lbLowestFileWeight.TabIndex = 3; + this.lbLowestFileWeight.Text = "Lowest file weight:"; + this.lbInfoSortFile.Location = new Point(12, 35); + this.lbInfoSortFile.Name = "lbInfoSortFile"; + this.lbInfoSortFile.Size = new Size(364, 64); + this.lbInfoSortFile.TabIndex = 0; + this.lbInfoSortFile.Text = "Info sort file"; + this.nudFileWeight.Location = new Point(316, 7); + this.nudFileWeight.Maximum = new Decimal(new int[4] + { + int.MaxValue, + 0, + 0, + 0 + }); + this.nudFileWeight.Name = "nudFileWeight"; + this.nudFileWeight.Size = new Size(60, 20); + this.nudFileWeight.TabIndex = 1; + this.nudFileWeight.TextAlign = HorizontalAlignment.Center; + this.nudFileWeight.ThousandsSeparator = true; + this.AcceptButton = (IButtonControl) this.btGenerateSortFile; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = SystemColors.Window; + this.CancelButton = (IButtonControl) this.btCancel; + this.ClientSize = new Size(389, 136); + this.Controls.Add((Control) this.nudFileWeight); + this.Controls.Add((Control) this.lbInfoSortFile); + this.Controls.Add((Control) this.lbLowestFileWeight); + this.Controls.Add((Control) this.btCancel); + this.Controls.Add((Control) this.btGenerateSortFile); + this.Controls.Add((Control) this.tbPathPrefix); + this.Controls.Add((Control) this.lbDESKey); + this.FormBorderStyle = FormBorderStyle.FixedToolWindow; + this.MaximizeBox = false; + this.MinimizeBox = false; + this.Name = nameof (FormSortFileOptions); + this.ShowIcon = false; + this.ShowInTaskbar = false; + this.StartPosition = FormStartPosition.CenterParent; + this.Text = "Sort file options:"; + this.Load += new EventHandler(this.FormGetSortTxtPrefix_Load); + this.nudFileWeight.EndInit(); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/FormSortFileOptions.resx b/Explorer/Forms/FormSortFileOptions.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/Forms/FormSortFileOptions.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/Forms/GDRomExplorerForm.cs b/Explorer/Forms/GDRomExplorerForm.cs new file mode 100644 index 0000000..cdbae07 --- /dev/null +++ b/Explorer/Forms/GDRomExplorerForm.cs @@ -0,0 +1,446 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Forms.GDRomExplorerForm +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.DiscView; +using GDRomExplorer.Events; +using GDRomExplorer.Resources; +using GDRomExplorer.UserControls; +using SEGATools.Audio; +using SEGATools.Disc; +using SEGATools.DiscFileSystem; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Reflection; +using System.Windows.Forms; +using System.Windows.Forms.Layout; + +namespace GDRomExplorer.Forms +{ + public class GDRomExplorerForm : Form + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IDiscFileSystem discFileSystem; + private DiscViewExplorer.ActionsForEditMenuItem editMenuActions; + private string initialDirectory; + private IContainer components; + private StatusStrip statusStrip; + private DiscViewOpener discViewOpener; + private ToolStripStatusLabel toolStripStatusLabel; + private DiscViewExplorer discView; + private ToolStripMenuItem fileToolStripMenuItem; + private ToolStripMenuItem openToolStripMenuItem; + private ToolStripMenuItem closeToolStripMenuItem; + private ToolStripMenuItem exitToolStripMenuItem; + private ToolStripMenuItem toolsToolStripMenuItem; + private ToolStripMenuItem ConvertToolStripMenuItem; + private ToolStripMenuItem naomiBinarydecryptionToolStripMenuItem; + private ToolStripSeparator toolStripSeparator; + private ToolStripMenuItem aboutToolStripMenuItem; + private ToolStripMenuItem aboutGDRomExplorerToolStripMenuItem; + private MenuStrip menuStrip; + private DiscFormatProvider discFormatProvider; + private ToolStripMenuItem settingsToolStripMenuItem; + private ToolStripMenuItem ipViewerToolStripMenuItem; + private InitialProgramOpener ipOpener; + private ToolStripMenuItem encryptANaomiBinaryToolStripMenuItem; + private NaomiEncryptDecryptTool naomiEncryptDecryptTool; + private ToolStripMenuItem convertGDIForGDEMUToolStripMenuItem; + private ToolStripSeparator toolStripSeparator1; + private ToolStripMenuItem editToolStripMenuItem; + private GDDAConverterTool gddaConverterTool; + + public GDRomExplorerForm() + { + this.InitializeComponent(); + this.Text = Assembly.GetExecutingAssembly().GetName().Name; + } + + private void GDRomExplorerForm_Load(object sender, EventArgs e) + { + this.RemoveImageMargin(this.menuStrip); + this.MenuClose(); + this.DragDrop += new DragEventHandler(this.GDRomExplorerForm_DragDrop); + this.DragEnter += new DragEventHandler(this.GDRomExplorerForm_DragEnter); + this.discViewOpener.ImageLoaded += new EventHandler>(this.discViewOpener_ImageLoaded); + this.discViewOpener.ImageNotLoaded += new EventHandler(this.discViewOpener_ImageNotLoaded); + this.discView.SelectionChanged += new EventHandler>(this.discView_SelectionChanged); + AppStatus.OnAppStatusUpdate += new AppStatus.AppStatusUpdateEventHandler(this.AppStatus_OnAppStatusUpdate); + string progamArgument = Program.GetProgamArgument(); + if (!string.IsNullOrEmpty(progamArgument)) + this.UpdateDialogInitialDirectory(progamArgument); + else + this.UpdateDialogInitialDirectory(Assembly.GetExecutingAssembly().GetName().CodeBase); + if (string.IsNullOrEmpty(progamArgument)) + return; + this.discViewOpener.Open(progamArgument); + } + + private void AppStatus_OnAppStatusUpdate(string message) + { + string str = char.ToUpper(message[0]).ToString() + message.Substring(1); + this.toolStripStatusLabel.Text = str; + this.toolStripStatusLabel.ToolTipText = str; + } + + private void GDRomExplorerForm_DragEnter(object sender, DragEventArgs e) + { + if (e.Data.GetDataPresent(DataFormats.FileDrop)) + e.Effect = DragDropEffects.All; + else + e.Effect = DragDropEffects.None; + } + + private void GDRomExplorerForm_DragDrop(object sender, DragEventArgs e) + { + string[] data = (string[]) e.Data.GetData(DataFormats.FileDrop, false); + if (data.Length == 1) + this.discViewOpener.Open(Path.GetFullPath(data[0])); + else + GDRomExplorerForm.logger.Error((object) "Unhandled data for the drag & drop operation!"); + } + + private void discViewOpener_ImageLoaded(object sender, EventArgs e) + { + this.discFileSystem = e.Value; + this.MenuOpen(); + this.UpdateDialogInitialDirectory(this.discFileSystem.FileName); + this.discView.LoadDisc(this.discFileSystem); + } + + private void discViewOpener_ImageNotLoaded(object sender, EventArgs e) + { + this.discFileSystem = (IDiscFileSystem) null; + this.MenuClose(); + } + + private void discView_SelectionChanged( + object sender, + EventArgs e) + { + this.editMenuActions = e.Value; + if (!this.editMenuActions.AnyAvailable) + this.editToolStripMenuItem.Enabled = false; + else + this.editToolStripMenuItem.Enabled = true; + } + + private void MenuClose() + { + this.toolStripStatusLabel.Text = Strings.StatusLabelImageNotLoaded; + this.closeToolStripMenuItem.Enabled = false; + this.editToolStripMenuItem.Enabled = false; + this.discView.CloseDisc(); + } + + private void MenuOpen() + { + this.closeToolStripMenuItem.Enabled = true; + this.editToolStripMenuItem.Enabled = true; + } + + private void UpdateDialogInitialDirectory(string initialPath) + { + this.initialDirectory = Path.GetDirectoryName(initialPath); + this.gddaConverterTool.InitialDirectory = this.initialDirectory; + this.naomiEncryptDecryptTool.InitialDirectory = this.initialDirectory; + } + + private void RemoveImageMargin(MenuStrip Menu) + { + foreach (ToolStripItem toolStripItem in (ArrangedElementCollection) Menu.Items) + this.RemoveItemImageMargin(toolStripItem); + } + + private void RemoveItemImageMargin(ToolStripItem Item) + { + if (!(Item is ToolStripMenuItem)) + return; + ToolStripMenuItem toolStripMenuItem = Item as ToolStripMenuItem; + (toolStripMenuItem.DropDown as ToolStripDropDownMenu).ShowImageMargin = false; + foreach (object dropDownItem in (ArrangedElementCollection) toolStripMenuItem.DropDownItems) + { + if (dropDownItem is ToolStripItem) + this.RemoveItemImageMargin(dropDownItem as ToolStripItem); + } + } + + private void ToolStripMenuItemExit_Click(object sender, EventArgs e) + { + this.discViewOpener.Close(); + this.discView.CloseDisc(); + this.discFileSystem = (IDiscFileSystem) null; + Application.Exit(); + } + + private void ToolStripMenuItemClose_Click(object sender, EventArgs e) => this.discViewOpener.Close(); + + private void ToolStripMenuItemOpenImageFile_Click(object sender, EventArgs e) => this.discViewOpener.Open(); + + private void ToolStripMenuItemShowGDDAConverter_Click(object sender, EventArgs e) => this.gddaConverterTool.OpenAndConvertGDDAFiles((IWin32Window) this, AudioConversionSettings.defaultAudioConvOptions()); + + private void ToolStripMenuItemAboutGDRomExplorer_Click(object sender, EventArgs e) + { + using (FormAbout formAbout = new FormAbout()) + { + int num = (int) formAbout.ShowDialog((IWin32Window) this); + } + } + + private void ToolStripMenuItemExportGDIForGDEMU_Click(object sender, EventArgs e) + { + using (FormGDEmuExportSettings emuExportSettings = new FormGDEmuExportSettings(this.initialDirectory)) + { + int num = (int) emuExportSettings.ShowDialog((IWin32Window) this); + } + } + + private void ToolStripMenuItemEncryptNaomiBinary_Click(object sender, EventArgs e) => this.naomiEncryptDecryptTool.OpenAndEncryptNaomiBinary((IWin32Window) this); + + private void ToolStripMenuItemDecryptNaomiBinary_Click(object sender, EventArgs e) => this.naomiEncryptDecryptTool.OpenAndDecryptNaomiBinary((IWin32Window) this); + + private void ToolStripMenuItemSettings_Click(object sender, EventArgs e) + { + using (FormSettings formSettings = new FormSettings()) + { + int num = (int) formSettings.ShowDialog((IWin32Window) this); + } + } + + private void ToolStripMenuItemIPViewer_Click(object sender, EventArgs e) => this.ipOpener.OpenAndViewInitialProgram((IWin32Window) this); + + private void ToolStripMenuItemEdit_DropDownOpening(object sender, EventArgs e) + { + this.editToolStripMenuItem.DropDownItems.Clear(); + this.editToolStripMenuItem.DropDownItems.AddRange(MenuItemFactory.CreateEditMenuItems(this.editMenuActions.DiscMenuItems, this.editMenuActions.SelectionMenuItems)); + this.RemoveItemImageMargin((ToolStripItem) this.editToolStripMenuItem); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.components = (IContainer) new Container(); + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (GDRomExplorerForm)); + this.statusStrip = new StatusStrip(); + this.toolStripStatusLabel = new ToolStripStatusLabel(); + this.fileToolStripMenuItem = new ToolStripMenuItem(); + this.openToolStripMenuItem = new ToolStripMenuItem(); + this.closeToolStripMenuItem = new ToolStripMenuItem(); + this.exitToolStripMenuItem = new ToolStripMenuItem(); + this.toolsToolStripMenuItem = new ToolStripMenuItem(); + this.ipViewerToolStripMenuItem = new ToolStripMenuItem(); + this.ConvertToolStripMenuItem = new ToolStripMenuItem(); + this.convertGDIForGDEMUToolStripMenuItem = new ToolStripMenuItem(); + this.toolStripSeparator1 = new ToolStripSeparator(); + this.encryptANaomiBinaryToolStripMenuItem = new ToolStripMenuItem(); + this.naomiBinarydecryptionToolStripMenuItem = new ToolStripMenuItem(); + this.toolStripSeparator = new ToolStripSeparator(); + this.settingsToolStripMenuItem = new ToolStripMenuItem(); + this.aboutToolStripMenuItem = new ToolStripMenuItem(); + this.aboutGDRomExplorerToolStripMenuItem = new ToolStripMenuItem(); + this.menuStrip = new MenuStrip(); + this.editToolStripMenuItem = new ToolStripMenuItem(); + this.discFormatProvider = new DiscFormatProvider(this.components); + this.discView = new DiscViewExplorer(); + this.discViewOpener = new DiscViewOpener(); + this.ipOpener = new InitialProgramOpener(); + this.naomiEncryptDecryptTool = new NaomiEncryptDecryptTool(this.components); + this.gddaConverterTool = new GDDAConverterTool(this.components); + this.statusStrip.SuspendLayout(); + this.menuStrip.SuspendLayout(); + this.SuspendLayout(); + this.statusStrip.BackColor = Color.Transparent; + this.statusStrip.Items.AddRange(new ToolStripItem[1] + { + (ToolStripItem) this.toolStripStatusLabel + }); + this.statusStrip.Location = new Point(0, 540); + this.statusStrip.Name = "statusStrip"; + this.statusStrip.ShowItemToolTips = true; + this.statusStrip.Size = new Size(784, 22); + this.statusStrip.TabIndex = 27; + this.statusStrip.Text = "statusStrip"; + this.toolStripStatusLabel.AutoToolTip = true; + this.toolStripStatusLabel.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.toolStripStatusLabel.Margin = new Padding(3, 3, 0, 2); + this.toolStripStatusLabel.Name = "toolStripStatusLabel"; + this.toolStripStatusLabel.Size = new Size(766, 17); + this.toolStripStatusLabel.Spring = true; + this.toolStripStatusLabel.Text = "AppStatus"; + this.toolStripStatusLabel.TextAlign = ContentAlignment.MiddleLeft; + this.fileToolStripMenuItem.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.fileToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[3] + { + (ToolStripItem) this.openToolStripMenuItem, + (ToolStripItem) this.closeToolStripMenuItem, + (ToolStripItem) this.exitToolStripMenuItem + }); + this.fileToolStripMenuItem.Name = "fileToolStripMenuItem"; + this.fileToolStripMenuItem.Size = new Size(37, 20); + this.fileToolStripMenuItem.Text = "&File"; + this.openToolStripMenuItem.BackColor = SystemColors.Window; + this.openToolStripMenuItem.BackgroundImageLayout = ImageLayout.None; + this.openToolStripMenuItem.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.openToolStripMenuItem.Name = "openToolStripMenuItem"; + this.openToolStripMenuItem.ShortcutKeys = Keys.O | Keys.Control; + this.openToolStripMenuItem.Size = new Size(155, 22); + this.openToolStripMenuItem.Text = "&Open..."; + this.openToolStripMenuItem.TextImageRelation = TextImageRelation.TextAboveImage; + this.openToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemOpenImageFile_Click); + this.closeToolStripMenuItem.BackColor = SystemColors.Window; + this.closeToolStripMenuItem.Name = "closeToolStripMenuItem"; + this.closeToolStripMenuItem.Size = new Size(155, 22); + this.closeToolStripMenuItem.Text = "Close"; + this.closeToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemClose_Click); + this.exitToolStripMenuItem.BackColor = SystemColors.Window; + this.exitToolStripMenuItem.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.exitToolStripMenuItem.Name = "exitToolStripMenuItem"; + this.exitToolStripMenuItem.ShortcutKeys = Keys.F4 | Keys.Alt; + this.exitToolStripMenuItem.Size = new Size(155, 22); + this.exitToolStripMenuItem.Text = "Exit"; + this.exitToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemExit_Click); + this.toolsToolStripMenuItem.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.toolsToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[8] + { + (ToolStripItem) this.ipViewerToolStripMenuItem, + (ToolStripItem) this.ConvertToolStripMenuItem, + (ToolStripItem) this.convertGDIForGDEMUToolStripMenuItem, + (ToolStripItem) this.toolStripSeparator1, + (ToolStripItem) this.encryptANaomiBinaryToolStripMenuItem, + (ToolStripItem) this.naomiBinarydecryptionToolStripMenuItem, + (ToolStripItem) this.toolStripSeparator, + (ToolStripItem) this.settingsToolStripMenuItem + }); + this.toolsToolStripMenuItem.Name = "toolsToolStripMenuItem"; + this.toolsToolStripMenuItem.Size = new Size(48, 20); + this.toolsToolStripMenuItem.Text = "&Tools"; + this.ipViewerToolStripMenuItem.Name = "ipViewerToolStripMenuItem"; + this.ipViewerToolStripMenuItem.ShortcutKeys = Keys.I | Keys.Control; + this.ipViewerToolStripMenuItem.Size = new Size(242, 22); + this.ipViewerToolStripMenuItem.Text = "IP.BIN Viewer"; + this.ipViewerToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemIPViewer_Click); + this.ConvertToolStripMenuItem.BackColor = SystemColors.Window; + this.ConvertToolStripMenuItem.Name = "ConvertToolStripMenuItem"; + this.ConvertToolStripMenuItem.ShortcutKeys = Keys.T | Keys.Control; + this.ConvertToolStripMenuItem.Size = new Size(242, 22); + this.ConvertToolStripMenuItem.Text = "Convert audio tracks"; + this.ConvertToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemShowGDDAConverter_Click); + this.convertGDIForGDEMUToolStripMenuItem.Name = "convertGDIForGDEMUToolStripMenuItem"; + this.convertGDIForGDEMUToolStripMenuItem.ShortcutKeys = Keys.G | Keys.Control; + this.convertGDIForGDEMUToolStripMenuItem.Size = new Size(242, 22); + this.convertGDIForGDEMUToolStripMenuItem.Text = "Convert GDI for GDEMU"; + this.convertGDIForGDEMUToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemExportGDIForGDEMU_Click); + this.toolStripSeparator1.Name = "toolStripSeparator1"; + this.toolStripSeparator1.Size = new Size(239, 6); + this.encryptANaomiBinaryToolStripMenuItem.Name = "encryptANaomiBinaryToolStripMenuItem"; + this.encryptANaomiBinaryToolStripMenuItem.ShortcutKeys = Keys.E | Keys.Control; + this.encryptANaomiBinaryToolStripMenuItem.Size = new Size(242, 22); + this.encryptANaomiBinaryToolStripMenuItem.Text = "&Encrypt a Naomi binary"; + this.encryptANaomiBinaryToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemEncryptNaomiBinary_Click); + this.naomiBinarydecryptionToolStripMenuItem.BackColor = SystemColors.Window; + this.naomiBinarydecryptionToolStripMenuItem.Name = "naomiBinarydecryptionToolStripMenuItem"; + this.naomiBinarydecryptionToolStripMenuItem.ShortcutKeys = Keys.D | Keys.Control; + this.naomiBinarydecryptionToolStripMenuItem.Size = new Size(242, 22); + this.naomiBinarydecryptionToolStripMenuItem.Text = "&Decrypt a Naomi binary"; + this.naomiBinarydecryptionToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemDecryptNaomiBinary_Click); + this.toolStripSeparator.BackColor = SystemColors.Window; + this.toolStripSeparator.ForeColor = SystemColors.ControlText; + this.toolStripSeparator.Name = "toolStripSeparator"; + this.toolStripSeparator.Size = new Size(239, 6); + this.settingsToolStripMenuItem.BackColor = SystemColors.Window; + this.settingsToolStripMenuItem.Name = "settingsToolStripMenuItem"; + this.settingsToolStripMenuItem.Size = new Size(242, 22); + this.settingsToolStripMenuItem.Text = "Settings"; + this.settingsToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemSettings_Click); + this.aboutToolStripMenuItem.BackColor = SystemColors.Window; + this.aboutToolStripMenuItem.DisplayStyle = ToolStripItemDisplayStyle.Text; + this.aboutToolStripMenuItem.DropDownItems.AddRange(new ToolStripItem[1] + { + (ToolStripItem) this.aboutGDRomExplorerToolStripMenuItem + }); + this.aboutToolStripMenuItem.Name = "aboutToolStripMenuItem"; + this.aboutToolStripMenuItem.Size = new Size(24, 20); + this.aboutToolStripMenuItem.Text = "?"; + this.aboutGDRomExplorerToolStripMenuItem.BackColor = SystemColors.Window; + this.aboutGDRomExplorerToolStripMenuItem.Name = "aboutGDRomExplorerToolStripMenuItem"; + this.aboutGDRomExplorerToolStripMenuItem.Size = new Size(107, 22); + this.aboutGDRomExplorerToolStripMenuItem.Text = "About"; + this.aboutGDRomExplorerToolStripMenuItem.Click += new EventHandler(this.ToolStripMenuItemAboutGDRomExplorer_Click); + this.menuStrip.BackColor = SystemColors.Window; + this.menuStrip.Items.AddRange(new ToolStripItem[4] + { + (ToolStripItem) this.fileToolStripMenuItem, + (ToolStripItem) this.editToolStripMenuItem, + (ToolStripItem) this.toolsToolStripMenuItem, + (ToolStripItem) this.aboutToolStripMenuItem + }); + this.menuStrip.Location = new Point(0, 0); + this.menuStrip.Name = "menuStrip"; + this.menuStrip.ShowItemToolTips = true; + this.menuStrip.Size = new Size(784, 24); + this.menuStrip.TabIndex = 25; + this.menuStrip.Text = "menuStrip"; + this.editToolStripMenuItem.Name = "editToolStripMenuItem"; + this.editToolStripMenuItem.Size = new Size(39, 20); + this.editToolStripMenuItem.Text = "&Edit"; + this.editToolStripMenuItem.DropDownOpening += new EventHandler(this.ToolStripMenuItemEdit_DropDownOpening); + this.discView.AutoSize = true; + this.discView.BackColor = SystemColors.Window; + this.discView.Dock = DockStyle.Fill; + this.discView.Location = new Point(0, 82); + this.discView.Name = "discView"; + this.discView.Padding = new Padding(4); + this.discView.Size = new Size(784, 458); + this.discView.TabIndex = 31; + this.discViewOpener.AutoSize = true; + this.discViewOpener.ButtonText = "&Open"; + this.discViewOpener.Dock = DockStyle.Top; + this.discViewOpener.FileDialogFilters = (List) null; + this.discViewOpener.InitialDirectory = ""; + this.discViewOpener.Location = new Point(0, 24); + this.discViewOpener.MinimumSize = new Size(0, 58); + this.discViewOpener.Name = "discViewOpener"; + this.discViewOpener.NotifyStatusEvents = true; + this.discViewOpener.Padding = new Padding(4); + this.discViewOpener.Size = new Size(784, 58); + this.discViewOpener.TabIndex = 28; + this.AllowDrop = true; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.AutoScroll = true; + this.AutoSize = true; + this.BackColor = SystemColors.Window; + this.BackgroundImageLayout = ImageLayout.None; + this.ClientSize = new Size(784, 562); + this.Controls.Add((Control) this.discView); + this.Controls.Add((Control) this.discViewOpener); + this.Controls.Add((Control) this.statusStrip); + this.Controls.Add((Control) this.menuStrip); + this.DoubleBuffered = true; + this.Icon = (Icon) componentResourceManager.GetObject("$this.Icon"); + this.MainMenuStrip = this.menuStrip; + this.MinimumSize = new Size(800, 600); + this.Name = nameof (GDRomExplorerForm); + this.StartPosition = FormStartPosition.CenterScreen; + this.Text = "GD-ROM Explorer"; + this.Load += new EventHandler(this.GDRomExplorerForm_Load); + this.statusStrip.ResumeLayout(false); + this.statusStrip.PerformLayout(); + this.menuStrip.ResumeLayout(false); + this.menuStrip.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/Forms/GDRomExplorerForm.resx b/Explorer/Forms/GDRomExplorerForm.resx new file mode 100644 index 0000000..e277683 --- /dev/null +++ b/Explorer/Forms/GDRomExplorerForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + \ No newline at end of file diff --git a/Explorer/GD-ROM Explorer.sln b/Explorer/GD-ROM Explorer.sln new file mode 100644 index 0000000..d655ec9 --- /dev/null +++ b/Explorer/GD-ROM Explorer.sln @@ -0,0 +1,60 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31424.327 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GD-ROM Explorer", "GD-ROM Explorer.csproj", "{47780501-F392-43CA-A50C-9479421B4B55}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImageReader", "..\ImageReader\ImageReader.csproj", "{2185F55E-A4DA-486F-ACC8-3EE955205CE4}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SEGATools", "..\SEGATools\SEGATools.csproj", "{4D3AB913-88D2-4DD1-A403-EA46D14C98E6}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BIN", "..\formats\BIN\BIN.csproj", "{9BE87EC9-C89C-4521-BB87-5BBD997FA627}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CDI", "..\formats\CDI\CDI.csproj", "{A3861387-BB2E-4C3A-9AB2-43B77C393C24}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GDI", "..\formats\GDI\GDI.csproj", "{F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ISO9660", "..\formats\ISO9660\ISO9660.csproj", "{A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {47780501-F392-43CA-A50C-9479421B4B55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Debug|Any CPU.Build.0 = Debug|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Release|Any CPU.ActiveCfg = Release|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Release|Any CPU.Build.0 = Release|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Release|Any CPU.Build.0 = Release|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Release|Any CPU.Build.0 = Release|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.Build.0 = Release|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.Build.0 = Release|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Release|Any CPU.Build.0 = Release|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {B500B1BD-BB99-4FFC-8B90-459648214A7E} + EndGlobalSection +EndGlobal diff --git a/Explorer/Logger.cs b/Explorer/Logger.cs new file mode 100644 index 0000000..51163ff --- /dev/null +++ b/Explorer/Logger.cs @@ -0,0 +1,474 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Logger +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using log4net; +using log4net.Core; +using System; +using System.Diagnostics; +using System.Globalization; +using System.Reflection; + +namespace GDRomExplorer +{ + internal static class Logger + { + private static readonly bool loggingIsOff = true; + + static Logger() + { + try + { + Assembly.Load("log4net"); + //log4net.Config.XmlConfigurator.Configure(); + Logger.loggingIsOff = false; + } + catch + { + } + } + + public static Logger.ILog CreateLog() + { + Type declaringType = new StackFrame(1, false).GetMethod().DeclaringType; + return !Logger.loggingIsOff ? (Logger.ILog) new Logger.Log4NetLogger(declaringType) : (Logger.ILog) new Logger.NoLog(); + } + + internal interface ILog + { + bool IsDebugEnabled { get; } + + bool IsInfoEnabled { get; } + + bool IsWarnEnabled { get; } + + bool IsErrorEnabled { get; } + + bool IsFatalEnabled { get; } + + void Debug(object message); + + void Debug(object message, Exception exception); + + void DebugFormat(string format, params object[] args); + + void DebugFormat(string format, object arg0); + + void DebugFormat(string format, object arg0, object arg1); + + void DebugFormat(string format, object arg0, object arg1, object arg2); + + void DebugFormat(IFormatProvider provider, string format, params object[] args); + + void Info(object message); + + void Info(object message, Exception exception); + + void InfoFormat(string format, params object[] args); + + void InfoFormat(string format, object arg0); + + void InfoFormat(string format, object arg0, object arg1); + + void InfoFormat(string format, object arg0, object arg1, object arg2); + + void InfoFormat(IFormatProvider provider, string format, params object[] args); + + void Warn(object message); + + void Warn(object message, Exception exception); + + void WarnFormat(string format, params object[] args); + + void WarnFormat(string format, object arg0); + + void WarnFormat(string format, object arg0, object arg1); + + void WarnFormat(string format, object arg0, object arg1, object arg2); + + void WarnFormat(IFormatProvider provider, string format, params object[] args); + + void Error(object message); + + void Error(object message, Exception exception); + + void ErrorFormat(string format, params object[] args); + + void ErrorFormat(string format, object arg0); + + void ErrorFormat(string format, object arg0, object arg1); + + void ErrorFormat(string format, object arg0, object arg1, object arg2); + + void ErrorFormat(IFormatProvider provider, string format, params object[] args); + + void Fatal(object message); + + void Fatal(object message, Exception exception); + + void FatalFormat(string format, params object[] args); + + void FatalFormat(string format, object arg0); + + void FatalFormat(string format, object arg0, object arg1); + + void FatalFormat(string format, object arg0, object arg1, object arg2); + + void FatalFormat(IFormatProvider provider, string format, params object[] args); + } + + private class NoLog : Logger.ILog + { + public bool IsDebugEnabled => false; + + public bool IsInfoEnabled => false; + + public bool IsWarnEnabled => false; + + public bool IsErrorEnabled => false; + + public bool IsFatalEnabled => false; + + public void Debug(object message) + { + } + + public void Debug(object message, Exception exception) + { + } + + public void DebugFormat(string format, params object[] args) + { + } + + public void DebugFormat(string format, object arg0) + { + } + + public void DebugFormat(string format, object arg0, object arg1) + { + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Info(object message) + { + } + + public void Info(object message, Exception exception) + { + } + + public void InfoFormat(string format, params object[] args) + { + } + + public void InfoFormat(string format, object arg0) + { + } + + public void InfoFormat(string format, object arg0, object arg1) + { + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Warn(object message) + { + } + + public void Warn(object message, Exception exception) + { + } + + public void WarnFormat(string format, params object[] args) + { + } + + public void WarnFormat(string format, object arg0) + { + } + + public void WarnFormat(string format, object arg0, object arg1) + { + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Error(object message) + { + } + + public void Error(object message, Exception exception) + { + } + + public void ErrorFormat(string format, params object[] args) + { + } + + public void ErrorFormat(string format, object arg0) + { + } + + public void ErrorFormat(string format, object arg0, object arg1) + { + } + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Fatal(object message) + { + } + + public void Fatal(object message, Exception exception) + { + } + + public void FatalFormat(string format, params object[] args) + { + } + + public void FatalFormat(string format, object arg0) + { + } + + public void FatalFormat(string format, object arg0, object arg1) + { + } + + public void FatalFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) + { + } + } + + private class Log4NetLogger : Logger.ILog + { + private readonly log4net.ILog rootLogger; + private readonly Type loggingType; + private readonly ILogger logger; + + public Log4NetLogger(Type type) + { + this.loggingType = type; + this.rootLogger = LogManager.GetLogger(this.loggingType); + this.logger = ((ILoggerWrapper) this.rootLogger).Logger; + } + + public bool IsDebugEnabled => this.rootLogger.IsDebugEnabled; + + public bool IsInfoEnabled => this.rootLogger.IsInfoEnabled; + + public bool IsWarnEnabled => this.rootLogger.IsWarnEnabled; + + public bool IsErrorEnabled => this.rootLogger.IsFatalEnabled; + + public bool IsFatalEnabled => this.rootLogger.IsFatalEnabled; + + public void Debug(object message) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, (Exception) null); + } + + public void Debug(object message, Exception exception) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, exception); + } + + public void DebugFormat(string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void DebugFormat(string format, object arg0) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Info(object message) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, (Exception) null); + } + + public void Info(object message, Exception exception) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, exception); + } + + public void InfoFormat(string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void InfoFormat(string format, object arg0) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Warn(object message) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, (Exception) null); + } + + public void Warn(object message, Exception exception) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, exception); + } + + public void WarnFormat(string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void WarnFormat(string format, object arg0) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Error(object message) => this.logger.Log(this.loggingType, (Level) Level.Error, message, (Exception) null); + + public void Error(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Error, message, exception); + + public void ErrorFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void ErrorFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format(provider, format, args), (Exception) null); + + public void Fatal(object message) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, (Exception) null); + + public void Fatal(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, exception); + + public void FatalFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void FatalFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format(provider, format, args), (Exception) null); + } + } +} diff --git a/Explorer/Others/ListViewColumnSorter.cs b/Explorer/Others/ListViewColumnSorter.cs new file mode 100644 index 0000000..2802334 --- /dev/null +++ b/Explorer/Others/ListViewColumnSorter.cs @@ -0,0 +1,76 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Others.ListViewColumnSorter +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using ImageReader.ISO9660.DirectoryRecords; +using System; +using System.Collections; +using System.Windows.Forms; + +namespace GDRomExplorer.Others +{ + public class ListViewColumnSorter : IComparer + { + public int SortColumn; + public SortOrder Order; + private CaseInsensitiveComparer ObjectCompare; + + public ListViewColumnSorter() + { + this.SortColumn = 0; + this.Order = SortOrder.None; + this.ObjectCompare = new CaseInsensitiveComparer(); + } + + public int Compare(object x, object y) + { + ListViewItem listViewItem1 = (ListViewItem) x; + ListViewItem listViewItem2 = (ListViewItem) y; + int num; + if (listViewItem1.Name.Equals(DirectoryRecord.PARENT_DIRECTORY_NAME)) + num = this.Order == SortOrder.Ascending ? -1 : 1; + else if (listViewItem1.Tag != null && listViewItem2.Tag != null) + { + DirectoryRecord tag1 = (DirectoryRecord) listViewItem1.Tag; + DirectoryRecord tag2 = (DirectoryRecord) listViewItem2.Tag; + switch (this.SortColumn) + { + case 0: + num = this.CompareFilename(tag1, tag2); + break; + case 1: + case 2: + num = this.ObjectCompare.Compare((object) tag1.ExtentSize, (object) tag2.ExtentSize); + break; + case 3: + num = this.ObjectCompare.Compare((object) tag1.Extent, (object) tag2.Extent); + break; + case 4: + num = this.CompareDateTime(tag1.RecordingDateTime, tag2.RecordingDateTime); + break; + default: + num = this.ObjectCompare.Compare((object) listViewItem1.SubItems[this.SortColumn].Text, (object) listViewItem2.SubItems[this.SortColumn].Text); + break; + } + } + else + num = this.ObjectCompare.Compare((object) listViewItem1.SubItems[this.SortColumn].Text, (object) listViewItem2.SubItems[this.SortColumn].Text); + if (this.Order == SortOrder.Ascending) + return num; + return this.Order == SortOrder.Descending ? -num : 0; + } + + private int CompareFilename(DirectoryRecord x, DirectoryRecord y) => !x.IsDirectory || y.IsDirectory ? (!y.IsDirectory || x.IsDirectory ? this.ObjectCompare.Compare((object) x.Name, (object) y.Name) : 1) : -1; + + private int CompareDateTime(DateTime? x, DateTime? y) + { + if (!x.HasValue && !y.HasValue) + return 0; + if (!x.HasValue) + return 1; + return !y.HasValue ? -1 : DateTime.Compare(x.Value, y.Value); + } + } +} diff --git a/Explorer/Others/UserProcessEventArgsConverter.cs b/Explorer/Others/UserProcessEventArgsConverter.cs new file mode 100644 index 0000000..05dccb0 --- /dev/null +++ b/Explorer/Others/UserProcessEventArgsConverter.cs @@ -0,0 +1,62 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Others.UserProcessEventArgsConverter +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using SEGATools.UserProcess; +using System; +using System.Resources; +using System.Text; + +namespace GDRomExplorer.Others +{ + public class UserProcessEventArgsConverter + { + public static int MaximumNumberOfLinesToDisplay = 10; + + public static string ToFormatedString( + UserProcessWaitingForUserConsentEventArgs eventArgs, + ResourceManager resourceManager) + { + return !(eventArgs is UserProcessWaitingForUserConsentFileConflictEventArgs) ? UserProcessEventArgsConverter.DefaultWaitForUserConsentEventArgs.ToFormatedString(eventArgs, resourceManager) : UserProcessEventArgsConverter.FileConflictEventArgs.ToFormatedString(eventArgs, resourceManager); + } + + private static class DefaultWaitForUserConsentEventArgs + { + public static string ToFormatedString( + UserProcessWaitingForUserConsentEventArgs eventArgs, + ResourceManager resourceManager) + { + string format = resourceManager.GetString(eventArgs.QuestionContentResourceName); + if (eventArgs.HasStringArguments) + format = string.Format(format, (object[]) eventArgs.QuestionContentArgs); + return format; + } + } + + private static class FileConflictEventArgs + { + public static string ToFormatedString( + UserProcessWaitingForUserConsentEventArgs eventArgs, + ResourceManager resourceManager) + { + return string.Format(resourceManager.GetString(eventArgs.QuestionContentResourceName), (object) UserProcessEventArgsConverter.FileConflictEventArgs.CreateFileList(eventArgs.QuestionContentArgs, UserProcessEventArgsConverter.MaximumNumberOfLinesToDisplay)); + } + + private static string CreateFileList(string[] files, int MaximumNumberOfFilesToDisplay) + { + StringBuilder stringBuilder = new StringBuilder(); + int num = Math.Min(MaximumNumberOfFilesToDisplay, files.Length); + for (int index = 0; index < num; ++index) + { + string file = files[index]; + stringBuilder.Append("- ").Append(file).Append("\n"); + } + if (num < files.Length) + stringBuilder.Append("- etc.").Append("\n"); + return stringBuilder.ToString(); + } + } + } +} diff --git a/Explorer/Program.cs b/Explorer/Program.cs new file mode 100644 index 0000000..54e85cd --- /dev/null +++ b/Explorer/Program.cs @@ -0,0 +1,70 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Program +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Forms; +using System; +using System.Reflection; +using System.Security; +using System.Security.Permissions; +using System.Security.Policy; +using System.Threading; +using System.Windows.Forms; + +namespace GDRomExplorer +{ + public class Program + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly string THRUSTED_DOMAIN_NAME = "GDROMExplorer Thrusted Domain"; + private static string inputImageFile = string.Empty; + + public static string GetProgamArgument() => Program.inputImageFile; + + [STAThread] + private static void Main(string[] args) + { + if (args.Length > 0) + Program.inputImageFile = args[0]; + PermissionSet grantSet = new PermissionSet(PermissionState.Unrestricted); + AppDomain.CreateDomain(Program.THRUSTED_DOMAIN_NAME, (Evidence) null, new AppDomainSetup() + { + ApplicationBase = AppDomain.CurrentDomain.SetupInformation.ApplicationBase + }, grantSet).CreateInstance(Assembly.GetExecutingAssembly().FullName, typeof (Program).FullName); + } + + public Program() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.SetUnhandledExceptionMode(UnhandledExceptionMode.Automatic); + Application.ThreadException += new ThreadExceptionEventHandler(Program.Application_ThreadException); + if (!Program.LoadAssembly("ImageReader", "ImageReader.AssemblyTest") || !Program.LoadAssembly("SEGATools", "SEGATools.AssemblyTest")) + return; + Application.Run((Form) new GDRomExplorerForm()); + } + + private static void Application_ThreadException(object sender, ThreadExceptionEventArgs e) + { + Program.logger.ErrorFormat("Unhandled exception: {0}", (object) e.Exception); + int num = (int) MessageBox.Show("An unexpected error occurred.", "Error in Application", MessageBoxButtons.OK, MessageBoxIcon.Hand, MessageBoxDefaultButton.Button1); + } + + private static bool LoadAssembly(string assemblyName, string typeName) + { + try + { + AppDomain.CurrentDomain.CreateInstance(assemblyName, typeName); + } + catch (Exception ex) + { + Program.logger.Error((object) ex); + int num = (int) MessageBox.Show(assemblyName + ".dll is corrupted or missing!", Application.ProductName + ": Error!", MessageBoxButtons.OK, MessageBoxIcon.Hand); + return false; + } + return true; + } + } +} diff --git a/Explorer/Properties/Resources.cs b/Explorer/Properties/Resources.cs new file mode 100644 index 0000000..80e4ff1 --- /dev/null +++ b/Explorer/Properties/Resources.cs @@ -0,0 +1,61 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Properties.Resources +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Drawing; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace GDRomExplorer.Properties +{ + [DebuggerNonUserCode] + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [CompilerGenerated] + internal class Resources + { + private static ResourceManager resourceMan; + private static CultureInfo resourceCulture; + + internal Resources() + { + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager + { + get + { + if (object.ReferenceEquals((object) GDRomExplorer.Properties.Resources.resourceMan, (object) null)) + GDRomExplorer.Properties.Resources.resourceMan = new ResourceManager("GDRomExplorer.Properties.Resources", typeof (GDRomExplorer.Properties.Resources).Assembly); + return GDRomExplorer.Properties.Resources.resourceMan; + } + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture + { + get => GDRomExplorer.Properties.Resources.resourceCulture; + set => GDRomExplorer.Properties.Resources.resourceCulture = value; + } + + internal static Icon extract_icon => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (extract_icon), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Icon file => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (file), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Icon folder_open => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (folder_open), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Icon folder_up => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (folder_up), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Icon help => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (help), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Bitmap paypal_donate => (Bitmap) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (paypal_donate), GDRomExplorer.Properties.Resources.resourceCulture); + + internal static Icon zoom => (Icon) GDRomExplorer.Properties.Resources.ResourceManager.GetObject(nameof (zoom), GDRomExplorer.Properties.Resources.resourceCulture); + } +} diff --git a/Explorer/Properties/Resources.resx b/Explorer/Properties/Resources.resx new file mode 100644 index 0000000..81183d7 --- /dev/null +++ b/Explorer/Properties/Resources.resx @@ -0,0 +1,374 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + + + AAABAAIAEBAAAAEACABoBQAAJgAAABAQAAABACAAaAQAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAAAB + AAAAAAAAAAAAAAABAAAAAQAAAAAAAANpCAAEawsABHQKAAR7CwAEfgoAA2gRABB9HQAVfy4AAmxwAASA + CwAFgwwABYYNAAaRDQAJhxMACoAUAAmOEgAPhx8ACpoUAB6BLQAVkyoAHZk1ABKhIwAUpScAE6kmABqn + MgAdsDYAH7U4AC2XVAAnrEUAJ7xHAC24UQAsnGcAOax+AFiyfgArwk0AMslaADXKXAA1zF0ANs5gAEHe + dQBG43oAAnGZAANvpwACdKsAAnSsAEm1kQBbx7AAI5jMACedzgAsoc4AL6bPADOpzwBKvvYAbNnJAF7Q + 4gBPxPcAU8f3AFTH9wBTx/gAVMf4AFfK+ABe0fkAZ9n3AGnc+gBv4/oAcOL2AHTl+wB66/4Ag8ngAIzY + +gCS3fsAl+DyAJ3j8gCZ4/sAgvL9AIn5/gCP/v8Ao+nzAKnu8wCh6fwAp+/8AKzw9AC59P4A1Pf6AP7+ + /gAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtLS0tLS0tLS0tLS0tAAAtNS1GNTU1NTU1NTUwSC0ALTgtRzw6 + PDo8PDw6MEktAC09LUo+Pj4+Pj4+PjJOLQAtPi1QQCABAyA3QEAyUi0ALT8tUENDIQoKCEJDNFItAC1B + LVVTU1MiCgoTU0VULQAtRC0tLS0tCQoNBiotLS0ALUtLS0tLSy8PEgouKwAAAC1VTExMTEw2ERgQHCsA + AAAALVVMAQEBARQbFgEBAQEAAAAtLSoBESclHhoXEAYAAAAAAAAAAAEVKCUjGQEAAAAAAAAAAAAAAR0p + JQEAAAAAAAAAAAAAAAABHwEAAAAAAAAAAAAAAAAAAAEAAAAAAACAAwAAAAEAAAABAAAAAQAAAAEAAAAB + AAAAAQAAAAEAAAAHAAAABwAAgAEAAMADAAD8BwAA/g8AAP8fAAD/vwAAKAAAABAAAAAgAAAAAQAgAAAA + AABABAAAAAAAAAAAAAAAAAAAAAAAAAJ0rE0CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0 + rP8CdKz/AnSs/wJ0rP8CdKz/AnSsTQAAAAACdKz/SLz2/wJ0rP+M2Pr/S7/3/0q/9v9Kv/f/Sr/3/0q/ + 9v9Kv/f/Sr/2/0u/9v8jmMz/l+Dy/wJ0rP8AAAAAAnSs/0/E9/8CdKz/kt37/1TH+P9Ux/f/U8f4/1TH + 9/9Ux/j/VMf4/1TH+P9Tx/f/J53O/53j8v8CdKz/AAAAAAJ0rP9Xyvj/AnSs/5nj+/9e0fr/XtH6/17R + +v9e0fr/XtH6/1/R+v9e0fj/XtH4/yyhzv+j6fP/AnSs/wAAAAACdKz/XtP6/wJ0rP+h6fz/adz6/yyd + Z/8DaQj/BHQK/yycZ/9e0OL/adz6/2rd+/8vps//qe7z/wJ0rP8AAAAAAnSs/2fZ9/8CdKv/p+/8/3Tl + +/905fv/Oax+/wV/C/8EgAv/FX8u/3Di9v905fv/M6nP/6zw9P8CdKz/AAAAAAJ0rP9v4/r/AnSr//// + //+69P7/uPT+/7r0/v9Ysn7/BYYN/wR+Cv8egS3/uPT+/4PJ4P/U9/r/AnSs/wAAAAACdKz/euv+/wJ0 + rP8CdKz/AnSs/wJ0rP8CdKz/Amxw/wWDDP8GkQ3/A2gR/wJwmv8CdKz/AnSs/wJ0rP8AAAAAAnSs/4Py + /v+C8/7/gvP+/4Py/P+D8/7/gvP+/1vHsP8KgBT/CpoU/wR7C/9JtZH/A2+n/wAAAAAAAAAAAAAAAAJ0 + rP/+/v7/ifr//4n6/v+J+v7/ivj+/4r6/v9s2cn/D4cf/xOpJv8JjhL/LZdU/wNvp/8AAAAAAAAAAAAA + AAACdKxNAnSs//7+/v+P/v//BGsL/wRrC/8Eawv/BGsL/xWTKv8ftTj/EqEj/wRrC/8Eawv/BGsL/wRr + C/8AAAAAAAAAAAJ0rE0CdKz/AnSs/wJzmf8Eawv/EH0d/zbOYP8yyVr/J7xH/x2wNv8UpSf/CYcT/wRr + C/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARrC/8dmTX/Qd51/zXMXf8rwk3/Gqcy/wRr + C/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABGsL/yesRf9G43r/Ncpc/wRr + C/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEawv/LbhR/wRr + C/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAARr + C/8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAEAAAABAAAAAQAAAAEAAAABAAAAAQAAAAEAAAAH + AAAABwAAAAEAAIADAAD8BwAA/g8AAP8fAAD/vwAA + + + + + AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAGw0IACURFAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAABPiAlBIxJkQNuNg4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAABMRkPB65g2gSDRC0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAABHtCfQe/ae4CSSYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAASUTAQanW9YHtmTrATseAgAAAAAAAAAAAAAAAAAAAAAAAAAAASsVDwE+ + HykAAAAAAAAAAAAAAAAAAAAAAAAAAAExGAwHv2n7B8Vt/gJTKzkAAAAAAAAAAAAAAAAAAAAAAAAAAAJO + JyEHtGTkAksnKgAAAAAAAAAAAAAAAAAAAAAFRiQZEcBu/wjAa/8GoljYATseJAAAAAAAAAAAAAAAAAAA + AAACTSYhCMtx/weyYuQCSiYqAAAAAAAAAAAAAAAADT8kDVvPlvw4yYT/Dr5r/wexYfEEcz6VAksnVwI/ + IVACPyFQAlcsZgfFbv8Ix2//Bq9g5AJJJSoAAAAAAAAAAAAAAABPuIPPbdij/2fWn/9EzIr/I8J3/wu8 + af8IvGj/CL5p/wi/av8IwGr/CMFr/wjCbP8Gq17kAkglKgAAAAAAAAAAMZZhXWzXov9s16L/adag/2TW + nv9d1Jv/Ss+Q/znKhf8rxn3/IcR3/xjCc/8SwW//DcBt/wmpXeQDSCUnAAAAAAAAAABCr3eUa9eh/mrX + of9l1p//YNWc/1zUmv9X05j/UtKW/07Rk/9J0ZH/Q9CO/z7PjP8vwHvbD4RJHQAAAAAAAAAAAAAAADiv + cldTxozTY9Sd/mHVnf9d1Jv/WNOY/1PTlv9P0pT/StGR/0XQj/80wH3cGJdYHQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACKSVyArnmM6K6BkOimgYzohkFdUTtGT/0vRkv85wX/bG5VXHQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADEgoIU/Rk/8+wYLcHZRXHQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtHKCFBwILbIJNYHQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKSygLFoNKHAAAAAAAAAAAAAAAAAAA + AAAAAAAA5/8AAMf/AACP/wAAj/8AAA+fAAAPjwAAB4cAAAADAACAAQAAgAAAAMAAAADgAQAA+AMAAP+H + AAD/jwAA/58AAA== + + + + + R0lGODlhXAAaAIcPAP/x2//9+P7mtP+vM/+sLf7kr/7gpf7hqv7fof7ShP+xOP+zPUBRVv61Qr65oM8L + AhA+a3+Ddb6qfEBedYBvR/63SGB0fL+OOxA+ahA6Yu7br56fkDBUc6+FOyBKcc6/lq6qlf/CZSBJbe+n + Ns7AnSBDYDBKW56hlDBRbFBZVH+KiL61lf66TXCBhv/HaiBJb/61Q56knmB0fv++Wo6VjP+pJp6fjf/c + qI6Uid+fOWBvcXBoTSBJbiBCXn+JhEBbbt7Qqu7euv/nw/+2R0BRWI6Md8+YPY6Th/+0Qc+UNCBHar+Q + QI92Q++jLEBgeyBCX//Uk2B1gH+Mi/+9Wu7Vof+tL//Eat+bMP+yO//js/7Oe/7NenCCi/+2Q/7OgP+6 + T//is1Brfv7RhP/y3b60kv7cmv+5S/7ZlO7Und7LoWB2gRA7Yv+/V56WeXBnS87Fqv/Nf/7Zl66qkX+N + kP7HbP6zPb61mWBgT//gro95SXB/gv/Jb//cp//v1H+Ok//Pg86/md7Opv/owv/26EBedmBhUXB/gP7B + X+7Zqv7Mef7CYf7CYkBfd//z3/68Uv/Gb0BSWRA7Y1Blb/+qKf66Tv/qx+7Wps+VOP7gqHB5c4BwSVBp + eq6smK6unN7Knf7Pfa+IQ/+4Sv/hss7EpUBgev+uMZ+ARp99P//qw1Bqe6+GP/7DZFBrgJ9+QnB/hP7d + n7+MOP7NfY6Wj/7nuv7pwP/57v/lvf/Znv/25f/NgP/y2//v0v/BYf/syP+1Qv+qKAAzZswAAP+ZMwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + ACH/C05FVFNDQVBFMi4wAwEBAAAh+QQBAAAPACwAAAAAXAAaAAAI/wAfCBw4UJjBgwgTKlzIsKHDhwwJ + Spz4QFgIPmMCaNzIsaPHjyBDihzJcZCoR8IoShRmpU+tlzBjypxJs6bNmzhvNoKTUqUwPLiCCh1KtKjR + o0iTKl0aVFDPlWB0SZ1KtarVq1izat3KlWqlpwKF/dlFtqzZs2jTql3Ltq1btFnAlkLVq67du3jz6t3L + t6/fv3q/FFxEq7Dhw4gPxwDGGJgHP0ESS55MmVaQGJUzI/bSk8CqWaBDix4tmotjJ04gAGNFurXr1288 + zHlNu3UsAhWxOMIkoLfv38B9kwLmoDcQ1aN+O3CgIbgADQ6AAF/e3HcYYJ18Qy/uvPvvQ3UMwv9gQaeA + +fPo059njOh8C2CyzJ9QzbjFemBS6HOSTx/YCfP9qVFAfoy9EIh6CKInBgswGFTBg4kcIOGEFFZ4AAnA + vEChCsCocMAGwGCwAQgcALPBhYxxAEIUwDBygCUhgkBDiAek4QpjKpAwIwd2sJiKhUBOGAclDxrUwJEN + KPKKAUw26aSTOAAjg5N6AIODATwAswKTcgCziQE2AMMDFWBK+SQgjDG5AjCEMIkBMJ4YQEWaT9bZ5BZI + NmDQAnzy2cUeZyAg6KCECmoBMEcQKgIwH3wAjAiDkgHMBAgc6oOhiCKAhgWLMkYpAj4AYwgCjk46wQSM + FaoqAmVoEUqffBr/pMCstM5qhgufJKDrrruiAIwEuxYBjBIJSADMD8ECo0MCvgLL7K8J/ACMJBJEAEwm + uuoATBvFDhvBt9/yKm4CLrBRa60GVTHAuuy26267jK07Qh6MLTFADsCUMMIAI0QCjL3xrhtwwJAAY8q6 + JQBjxL35rmsEKO9GHHEVBv1CwMUYZ6wxxhc05nErGBMBjAmaPAFMIQR0bMLFKl9scgopMHbBxYztoAoB + MROxwxrAXLLxzxtPkpIwvxRt9NFIG90BA0wzTcEVRzfhRgbA9EBB0UszgTUDWv8CSw8ZUEABA0kUTQHV + p/zSxB1Uk53022/3JEwNcNdt991456133TU8jyWML4AHLvjghBdu+OGIJ6644WAJgwQvkEcu+eSUV275 + 5ZhnrjnlSIBV0Qy5hC766KSXbvrpqKeu+uqjz+B5WCHcIvvstNdu++2456777rzLHsLrBQ1xgy3EF2/8 + 8cgnr/zyzDfP/A1DAL/SFFAIAcD12Gev/fbcd+/99+BnLwQUU0jvE0Top6/++gep9EBAADs= + + + + + AAABAAIAEBAAAAEACABoBQAAJgAAABAQAAABACAAaAQAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAAAB + AAAAAAAAAAAAAAABAAAAAQAAAAAAAANvpwACdKwACX60AP8A/wALgbcADIG6ABGEtwATisQAI5LEACOY + zAAnnc4ALKHOAC+mzwAzqc8AK6TRADOq4ABKsdcAVrbhAEq/9gBc0e8AS8D3AFPH9wBUx/cAU8f4AFTH + +ABXyvgAXtH5AGrL+ABo2vsAadz6AHDj+wB05fsAdOX8AHng+wB66/0Ag8neAILV7wCJ2foAmeL7AJbr + +wCC8v0Aifn+AI/+/wC66+8AufT8AMXv9gDj/v4A/v7+AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAgICAgICAgICAgIAAAACCBIcFRUVFRUVFRUKBgAAAhAJJhkX + GRcZGRkXCiwCAAIaAicbGxsbGxsbGwwsAgACGwUlIh4eHh4eHh4MLAUAAh4PESggICAgICAgDiwsAgIg + FAcwLS0tLS0tLSQvLgICIyMDAgICAgICAgICAgICAikpKSkpKSkpKSkpAQAAAAIwKioqKioqKioqKgEA + AAAAAjAqKysCAgICAgIAAAAAAAACAgICAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACABwAAAAMAAAABAAAAAQAAAAEAAAAA + AAAAAAAAAAAAAAAHAAAABwAAgA8AAMP/AAD//wAA//8AAP//AAD//wAAKAAAABAAAAAgAAAAAQAgAAAA + AABABAAAAAAAAAAAAAAAAAAAAAAAAAJ0rE0CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0 + rP8CdKz/AnSs/wJ0rP8CdKz/AAAAAAAAAAACdKz/E4rE/1W24P9Qwff/S7/3/0q/9/9Kv/f/Sr/3/0q/ + 9v9Kv/f/Sr/2/0vA9/8jmMz/AnSs/wJ0rE0AAAAAAnSs/zOq4P9Dpc//e9X6/1TH+P9Ux/f/U8f4/1TH + 9/9Ux/j/VMf4/1TH+P9Tx/f/J53O/2rL5f8CdKz/AAAAAAJ0rP9Xyvj/CXqx/6Pm/P9j0/r/XtH6/17R + +v9e0fr/XtH6/1/R+v9e0fj/XtH4/yyhzv+Z7ff/AnSs/wAAAAACdKz/XtP6/wuBt/970+//i+X7/2rc + +v9p3Pv/adz7/2rc+/9p3Pv/adz6/2rd+/8vps//n/D3/wJ0rP8CdKxNAnSs/2ja+/8rpNH/MqbQ/63w + /P915fv/dOX7/3Tl/P905fz/dOX7/3Tl/P905fv/M6nP/6P09/9Su9f/AnSs/wJ0rP9w4/v/XNHv/wl+ + sv//////uvb+/7r2/v+69v7/uvb//7r0//+69v7/uvb//4TK4P/V+Pr/0PT4/wJ0rP8CdKz/euv+/3rr + /P8Kf7X/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8CdKz/AnSs/4Py + /v+C8/7/gvP+/4Py/P+D8/7/gvP+/4Py/v+C8/z/g/L+/4Lz/v+C8/7/A2+n/wAAAAAAAAAAAAAAAAJ0 + rP/+/v7/ifr//4n6/v+J+v7/ivj+/4r6/v+J+P7/ivr+/4r6//+J+v//ivr//wNvp/8AAAAAAAAAAAAA + AAACdKxNAnSs//7+/v+P/v//j/7//4/+//8CdKz/AnSs/wJ0rP8CdKz/AnSs/wJ0rP8AAAAAAAAAAAAA + AAAAAAAAAAAAAAJ0rE0CdKz/AnSs/wJ0rP8CdKz/AnSsTQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAEAAAABAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAH + AAAABwAAAA8AAIH/AAD//wAA//8AAP//AAD//wAA + + + + + AAABAAIAEBAAAAEACABoBQAAJgAAABAQAAABACAAaAQAAI4FAAAoAAAAEAAAACAAAAABAAgAAAAAAAAB + AAAAAAAAAAAAAAABAAAAAQAAAAAAAJyLfgD/AP8AsZCOALCekACyoJIAtaGTALqmlwDTwbEA1cC3AN7P + zgD/3sIA/+HGAP/jywD/5s8A/+nUAP/r2QD/7d0A/u/iAP7y5gD+9OsA+vbwAP738AD++vQA/vv6AAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwMDAwMDAAAAAAMYGBgYGBgYGBgYAwAAAAADGBgY + GBgYGBgYGAMAAAAAAxcXFxcXFxcXFxcDAAAAAAMWFhYWFhYWFhYWAwAAAAADFBQUFBQUFBQUFAMAAAAA + AxMTExMTExMTExMDAAAAAAMSEhISEhISEhISAwAAAAADEREREREREREREQMAAAAAAxEQERAREAgICAgD + AAAAAAMQDhAOEBAGBQQEAwAAAAADDg4ODg4OAQEBAQMAAAAAAw4MDgwOBhQUCgMAAAAAAAMMDAwMDAcX + CAMAAAAAAAADCwsLCwsGCAMAAAAAAAAAAwMDAwMDAwMAAAAAAADAAwAAwAMAAMADAADAAwAAwAMAAMAD + AADAAwAAwAMAAMADAADAAwAAwAMAAMADAADABwAAwA8AAMAfAADAPwAAKAAAABAAAAAgAAAAAQAgAAAA + AABABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsZCO/7GQjv+xkI7/sZCO/7GQjv+xkI7/sZCO/7GQ + jv+xkI7/sZCO/7GQjv+xkI7/AAAAAAAAAAAAAAAAAAAAALGQjv/++/r//vv6//77+v/++/r//vv6//77 + +v/++/r//vv6//77+v/++/r/sZCO/wAAAAAAAAAAAAAAAAAAAACxkI7//vv6//77+v/++/r//vv6//77 + +v/++/r//vv6//77+v/++/r//vv6/7GQjv8AAAAAAAAAAAAAAAAAAAAAsZCO//769P/++vT//vr0//76 + 9P/++vT//vr0//769P/++vT//vr0//769P+xkI7/AAAAAAAAAAAAAAAAAAAAALGQjv/+9/D//vfw//73 + 8P/+9/D//vfw//738P/+9/D//vfw//738P/+9/D/sZCO/wAAAAAAAAAAAAAAAAAAAACxkI7//vTr//70 + 6//+9Ov//vTr//706//+9Ov//vTr//706//+9Ov//vTr/7GQjv8AAAAAAAAAAAAAAAAAAAAAsZCO//7y + 5v/+8ub//vLm//7y5v/+8ub//vLm//7y5v/+8ub//vLm//7y5v+xkI7/AAAAAAAAAAAAAAAAAAAAALGQ + jv/+7+L//u/i//7v4v/+7+L//u/i//7v4v/+7+L//u/i//7v4v/+7+L/sZCO/wAAAAAAAAAAAAAAAAAA + AACxkI7//+3d///t3f//7d3//+3d///t3f//7d3//+3d///t3f//7d3//+3d/7GQjv8AAAAAAAAAAAAA + AAAAAAAAsZCO///r2f//69n//+vZ///r2f//69n//+vZ/9PBsf/TwbH/08Gx/9PBsf+xkI7/AAAAAAAA + AAAAAAAAAAAAALGQjv//6dT//+nU///p1P//6dT//+nU///p1P+1oZP/sqCS/7Gfkf+wnpD/sZCO/wAA + AAAAAAAAAAAAAAAAAACxkI7//+bP///mz///5s///+bP///mz///5s//nIt+/5yLfv+ci37/nIt+/7GQ + jv8AAAAAAAAAAAAAAAAAAAAAsZCO///jy///48v//+PL///jy///48v/uqaX//r28P/69vD/3s/O/7GQ + jv8AAAAAAAAAAAAAAAAAAAAAAAAAALGQjv//4cb//+HG///hxv//4cb//+HG/7qml//69vD/1cC3/7GQ + jv8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACxkI7//97C///ewv//3sL//97C///ewv+6ppf/1cC3/7GQ + jv8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAsZCO/7GQjv+xkI7/sZCO/7GQjv+xkI7/sZCO/7GQ + jv8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAAwAAwAMAAMADAADAAwAAwAMAAMADAADAAwAAwAMAAMAD + AADAAwAAwAMAAMADAADABwAAwA8AAMAfAADAPwAA + + + + + AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA4AAAAWAAAAFcAAAA2AAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAADAYEAIZJLADtgEwA/5hZAP+WVwD/e0YA/0QnAOsFAwCDAAAACwAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAIzEfANqtawD/wHQA/7lrAP+1ZwD/tGYA/7VnAP+2aAD/nlkA/ysY + ANcAAAAhAAAAAAAAAAAAAAAAAAAAETcjAN3FewD/vnEA/7VmAP+0ZgD/27aH/9+9kv+0ZgD/tGYA/7Zn + AP+vYwD/LxoA2wAAAA8AAAAAAAAAAAwIAJS8eAD/wnYA/7lrAP+5awD/uWsA//Dfyf/06dn/uWsA/7lr + AP+5awD/uGoA/6RcAP8KBQCSAAAAAAAAAAxdPQD1zoQA/75xAP+9cQD/vXEA/71xAP/KjjT/y440/71x + AP+9cQD/vXEA/71xAP+4agD/UC0A9AAAAAsAAABCmWUA/8uBAP/CdgD/wnYA/8J2AP/CdgD/7de0//jv + 4//EfAn/wnYA/8J2AP/CdgD/vXAA/4NLAP8AAABCAAAAWrF2AP/NgwD/x3wA/8d8AP/HfAD/x3wA/9ae + Qv/9+vX/9OXO/82JGv/HfAD/x3wA/8J2AP+YWAD/AAAAWgAAAFuxdgD/0okA/8yCAP/MggD/zIMC/8yD + Af/MggD/1psz//78+v/v2LD/zIIA/8yCAP/FeQD/mlsA/wAAAFoAAABEmGMA/9iQAP/RhwD/0YcA//Xm + yv/58N//0YkD/9GJBP/79u3/9urS/9GHAP/RhwD/w3cA/4hRAP8AAABCAAAADVg2APXclQD/148A/9WN + AP/ov3D///////bny//26M3//////+rGgP/VjQD/z4UA/8N3AP9UMgD1AAAADAAAAAAKBQCVvnsA/9yV + AP/akgD/2pIA/+e5Wv/y2qf/8tij/+e6XP/akwH/04sA/8h8AP+zbgD/CgUAlQAAAAAAAAAAAAAAETId + AN7QiQD/3JUA/9uTAP/blAD/3JUA/9uUAP/YkAD/0ogA/8yCAP/HfgD/Mx4A3gAAABEAAAAAAAAAAAAA + AAAAAAAkMBwA2bp6AP/dlgD/25QA/9ePAP/VjQD/1IwA/9aNAP+5eAD/MR4A2gAAACQAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAwHBACFUDUA7JZnAP+7hAD/vIUA/5hpAP9SNgDsBwQAhgAAAAwAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUAAAA3AAAAVwAAAFcAAAA3AAAABQAAAAAAAAAAAAAAAAAA + AAAAAAAA+B8AAOAHAADAAwAAgAEAAIABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAQAAgAEAAMAD + AADgBwAA+B8AAA== + + + + + AAABAAEAEBAAAAEAIABoBAAAFgAAACgAAAAQAAAAIAAAAAEAIAAAAAAAQAQAAAAAAAAAAAAAAAAAAAAA + AAAAAAAfGhcTxyciHO4AAAA8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAGhcTx5GEd/+Yi3//Qzw18gAAADwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAACgiHO6Xin7/xr+3/720qv9NR0DyAAAAPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA + AAAAAAAAAAAAAAAAAAAAAAA+RD0287uyqf/k4N3/x7+3/05HQfIAAAA8AAAAAAAAACMAAABMAAAASwAA + ACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD5OSEHzxr61/+Xi3v+9tKv/Lysm7SQgHMtiWlH/i4N5/4qB + eP9fV07+IB0ZxAAAADYAAAAAAAAAAAAAAAAAAAAAAAAAPk9IQfPGvrX/3djT/56TiP+4rZr/1Mmw/9zT + vv/c0r3/08iu/7armf9bU0v5AQEAUwAAAAAAAAAAAAAAAAAAAAAAAAA+NDAr7J2Sh/+9ro7/2MSM/+fa + sP/u5cX/7uTD/+bYrf/VwIj/vK6Q/1JMRvUAAAAjAAAAAAAAAAAAAAAAAAAAABcVFKmypZD/zrVr/+LR + kv/r36v/7uS2/+7ktf/r3qn/4M6O/8uyaf+uo5D/Dw4NmQAAAAAAAAAAAAAAAAAAAAFPS0bxuqVx/9W8 + aP/j0YX/59eU/+nam//p2pv/59eT/+LPg//TuWX/uKV1/0RAPOMAAAAAAAAAAAAAAAAAAAAPaWNe/7ui + X//WvGP/4Mx3/+LPf//j0IH/4tCA/+HNev/eyG//0rZX/7igX/9eWlX+AAAAAAAAAAAAAAAAAAAABWVh + XPy9qHD/2sR1/+PQhP/l1Iv/5dWO/+TTiP/hzn3/3MVp/82wSf+0nV3/WVVS8wAAAAAAAAAAAAAAAAAA + AAA4NzXKvK2M/97Nj//m15r/6duf/+rcof/q3KH/6duf/+bXmf/dy43/vK6R/ywrKbsAAAAAAAAAAAAA + AAAAAAAAAQEBZ66pov/GtIX/7OK8/+/lv//w58D/8OfA/+/lv//s4bv/xLKG/6Wgm/8AAABYAAAAAAAA + AAAAAAAAAAAAAAAAAAYwLizQy8S7/8W2k//o3sH/+fXq//n16v/m3L7/xbaT/8nDvP8nJiTEAAAAAgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAHTMxL9TCvrn/08vA/8m8of/JvaL/1M3D/7+7t/8tKynMAAAAFgAA + AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJBAQEdUA/Pc9wb235b25t+D49PMsDAwNuAAAABgAA + AAAAAAAAD/8AAAf/AAAD/wAAAQ8AAIADAADAAQAA4AAAAPAAAADgAAAA4AAAAOAAAADwAAAA8AAAAPAA + AAD4AQAA/AMAAA== + + + + + ..\Resources\icons\gdromexplorer.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + + ..\Resources\icons\gdromexplorer2.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a + + \ No newline at end of file diff --git a/Explorer/Properties/Settings.cs b/Explorer/Properties/Settings.cs new file mode 100644 index 0000000..3cdd753 --- /dev/null +++ b/Explorer/Properties/Settings.cs @@ -0,0 +1,41 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Properties.Settings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.CodeDom.Compiler; +using System.Configuration; +using System.Diagnostics; +using System.Runtime.CompilerServices; + +namespace GDRomExplorer.Properties +{ + [CompilerGenerated] + [GeneratedCode("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed class Settings : ApplicationSettingsBase + { + private static Settings defaultInstance = (Settings) SettingsBase.Synchronized((SettingsBase) new Settings()); + + public static Settings Default => Settings.defaultInstance; + + [DebuggerNonUserCode] + [DefaultSettingValue("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=982C3EY58BF8U")] + [ApplicationScopedSetting] + public string PayPalDonateUrl => (string) this[nameof (PayPalDonateUrl)]; + + [ApplicationScopedSetting] + [DebuggerNonUserCode] + [DefaultSettingValue("http://japanese-cake.livejournal.com/")] + public string BlogUrl => (string) this[nameof (BlogUrl)]; + + [UserScopedSetting] + [DebuggerNonUserCode] + [DefaultSettingValue("True")] + public bool ImageReaderComputePathTable + { + get => (bool) this[nameof (ImageReaderComputePathTable)]; + set => this[nameof (ImageReaderComputePathTable)] = (object) value; + } + } +} diff --git a/Explorer/Resources/Strings.cs b/Explorer/Resources/Strings.cs new file mode 100644 index 0000000..2769d71 --- /dev/null +++ b/Explorer/Resources/Strings.cs @@ -0,0 +1,284 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.Resources.Strings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace GDRomExplorer.Resources +{ + [DebuggerNonUserCode] + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [CompilerGenerated] + internal class Strings + { + private static ResourceManager resourceMan; + private static CultureInfo resourceCulture; + + internal Strings() + { + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager + { + get + { + if (object.ReferenceEquals((object) Strings.resourceMan, (object) null)) + Strings.resourceMan = new ResourceManager("GDRomExplorer.Resources.Strings", typeof (Strings).Assembly); + return Strings.resourceMan; + } + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture + { + get => Strings.resourceCulture; + set => Strings.resourceCulture = value; + } + + internal static string ContextMenuItemConvertAudio => Strings.ResourceManager.GetString(nameof (ContextMenuItemConvertAudio), Strings.resourceCulture); + + internal static string ContextMenuItemConvertGDDA => Strings.ResourceManager.GetString(nameof (ContextMenuItemConvertGDDA), Strings.resourceCulture); + + internal static string ContextMenuItemCreateCUE => Strings.ResourceManager.GetString(nameof (ContextMenuItemCreateCUE), Strings.resourceCulture); + + internal static string ContextMenuItemDecryptAndExtract => Strings.ResourceManager.GetString(nameof (ContextMenuItemDecryptAndExtract), Strings.resourceCulture); + + internal static string ContextMenuItemExportForGDEmu => Strings.ResourceManager.GetString(nameof (ContextMenuItemExportForGDEmu), Strings.resourceCulture); + + internal static string ContextMenuItemExtract => Strings.ResourceManager.GetString(nameof (ContextMenuItemExtract), Strings.resourceCulture); + + internal static string ContextMenuItemExtractContent => Strings.ResourceManager.GetString(nameof (ContextMenuItemExtractContent), Strings.resourceCulture); + + internal static string ContextMenuItemExtractIP => Strings.ResourceManager.GetString(nameof (ContextMenuItemExtractIP), Strings.resourceCulture); + + internal static string ContextMenuItemGenerateSortFile => Strings.ResourceManager.GetString(nameof (ContextMenuItemGenerateSortFile), Strings.resourceCulture); + + internal static string ContextMenuItemViewIP => Strings.ResourceManager.GetString(nameof (ContextMenuItemViewIP), Strings.resourceCulture); + + internal static string ContextMenuItemViewPvd => Strings.ResourceManager.GetString(nameof (ContextMenuItemViewPvd), Strings.resourceCulture); + + internal static string DESDecryptorSubTitle => Strings.ResourceManager.GetString(nameof (DESDecryptorSubTitle), Strings.resourceCulture); + + internal static string DESDecryptorTitle => Strings.ResourceManager.GetString(nameof (DESDecryptorTitle), Strings.resourceCulture); + + internal static string DESDescriptorTypeName => Strings.ResourceManager.GetString(nameof (DESDescriptorTypeName), Strings.resourceCulture); + + internal static string DESEncryptorSubTitle => Strings.ResourceManager.GetString(nameof (DESEncryptorSubTitle), Strings.resourceCulture); + + internal static string DESEncryptorTitle => Strings.ResourceManager.GetString(nameof (DESEncryptorTitle), Strings.resourceCulture); + + internal static string DESEncryptorTypeName => Strings.ResourceManager.GetString(nameof (DESEncryptorTypeName), Strings.resourceCulture); + + internal static string DESKeyFormButtonLabelDecrypt => Strings.ResourceManager.GetString(nameof (DESKeyFormButtonLabelDecrypt), Strings.resourceCulture); + + internal static string DESKeyFormButtonLabelEncrypt => Strings.ResourceManager.GetString(nameof (DESKeyFormButtonLabelEncrypt), Strings.resourceCulture); + + internal static string DESKeyFormButtonLabelExtractAndDecrypt => Strings.ResourceManager.GetString(nameof (DESKeyFormButtonLabelExtractAndDecrypt), Strings.resourceCulture); + + internal static string DiscViewExplorerGroupLabelWithFormat => Strings.ResourceManager.GetString(nameof (DiscViewExplorerGroupLabelWithFormat), Strings.resourceCulture); + + internal static string DiscViewListColumnFileName => Strings.ResourceManager.GetString(nameof (DiscViewListColumnFileName), Strings.resourceCulture); + + internal static string DiscViewListColumnLBA => Strings.ResourceManager.GetString(nameof (DiscViewListColumnLBA), Strings.resourceCulture); + + internal static string DiscViewListColumnModifiedDate => Strings.ResourceManager.GetString(nameof (DiscViewListColumnModifiedDate), Strings.resourceCulture); + + internal static string DiscViewListColumnSize => Strings.ResourceManager.GetString(nameof (DiscViewListColumnSize), Strings.resourceCulture); + + internal static string DiscViewListColumnSizeInBytes => Strings.ResourceManager.GetString(nameof (DiscViewListColumnSizeInBytes), Strings.resourceCulture); + + internal static string DiscViewNoDiscTitle => Strings.ResourceManager.GetString(nameof (DiscViewNoDiscTitle), Strings.resourceCulture); + + internal static string DiscViewOpenerButtonClose => Strings.ResourceManager.GetString(nameof (DiscViewOpenerButtonClose), Strings.resourceCulture); + + internal static string DiscViewOpenerButtonOpen => Strings.ResourceManager.GetString(nameof (DiscViewOpenerButtonOpen), Strings.resourceCulture); + + internal static string DiscViewOpenerButtonToolStripText => Strings.ResourceManager.GetString(nameof (DiscViewOpenerButtonToolStripText), Strings.resourceCulture); + + internal static string DiscViewOpenerFileDialogTitle => Strings.ResourceManager.GetString(nameof (DiscViewOpenerFileDialogTitle), Strings.resourceCulture); + + internal static string DiscViewOpenerImageLoadingMessage => Strings.ResourceManager.GetString(nameof (DiscViewOpenerImageLoadingMessage), Strings.resourceCulture); + + internal static string DiscViewOpenerImageLoadingTitle => Strings.ResourceManager.GetString(nameof (DiscViewOpenerImageLoadingTitle), Strings.resourceCulture); + + internal static string DiscViewOpenerInvalidInitialProgram => Strings.ResourceManager.GetString(nameof (DiscViewOpenerInvalidInitialProgram), Strings.resourceCulture); + + internal static string DiscViewOpenerLabel => Strings.ResourceManager.GetString(nameof (DiscViewOpenerLabel), Strings.resourceCulture); + + internal static string DiscViewOpenerNoFileSystemError => Strings.ResourceManager.GetString(nameof (DiscViewOpenerNoFileSystemError), Strings.resourceCulture); + + internal static string DiscViewOpenerUnknownError => Strings.ResourceManager.GetString(nameof (DiscViewOpenerUnknownError), Strings.resourceCulture); + + internal static string EditDiscMenuItemName => Strings.ResourceManager.GetString(nameof (EditDiscMenuItemName), Strings.resourceCulture); + + internal static string EditSelectionMenuItemName => Strings.ResourceManager.GetString(nameof (EditSelectionMenuItemName), Strings.resourceCulture); + + internal static string FbdConvertGddaTitle => Strings.ResourceManager.GetString(nameof (FbdConvertGddaTitle), Strings.resourceCulture); + + internal static string FbdExtractFilesTitle => Strings.ResourceManager.GetString(nameof (FbdExtractFilesTitle), Strings.resourceCulture); + + internal static string FileExtractorSubTitle => Strings.ResourceManager.GetString(nameof (FileExtractorSubTitle), Strings.resourceCulture); + + internal static string FileExtractorTitle => Strings.ResourceManager.GetString(nameof (FileExtractorTitle), Strings.resourceCulture); + + internal static string FileExtractorTypeName => Strings.ResourceManager.GetString(nameof (FileExtractorTypeName), Strings.resourceCulture); + + internal static string FileScannerSubTitle => Strings.ResourceManager.GetString(nameof (FileScannerSubTitle), Strings.resourceCulture); + + internal static string FileScannerTitle => Strings.ResourceManager.GetString(nameof (FileScannerTitle), Strings.resourceCulture); + + internal static string FileScannerTypeName => Strings.ResourceManager.GetString(nameof (FileScannerTypeName), Strings.resourceCulture); + + internal static string GDEmuExporterBinaryPatcherHint => Strings.ResourceManager.GetString(nameof (GDEmuExporterBinaryPatcherHint), Strings.resourceCulture); + + internal static string GDEmuExporterDiscSectorEncoderHint => Strings.ResourceManager.GetString(nameof (GDEmuExporterDiscSectorEncoderHint), Strings.resourceCulture); + + internal static string GDEmuExporterFileConflictQuestionContent => Strings.ResourceManager.GetString(nameof (GDEmuExporterFileConflictQuestionContent), Strings.resourceCulture); + + internal static string GDEmuExporterFileConflictQuestionTitle => Strings.ResourceManager.GetString(nameof (GDEmuExporterFileConflictQuestionTitle), Strings.resourceCulture); + + internal static string GDEmuExporterSubTitle => Strings.ResourceManager.GetString(nameof (GDEmuExporterSubTitle), Strings.resourceCulture); + + internal static string GDEmuExporterTitle => Strings.ResourceManager.GetString(nameof (GDEmuExporterTitle), Strings.resourceCulture); + + internal static string GDEmuExporterTypeName => Strings.ResourceManager.GetString(nameof (GDEmuExporterTypeName), Strings.resourceCulture); + + internal static string GoToBlogLinkTitle => Strings.ResourceManager.GetString(nameof (GoToBlogLinkTitle), Strings.resourceCulture); + + internal static string InitialProgramLoadingMessage => Strings.ResourceManager.GetString(nameof (InitialProgramLoadingMessage), Strings.resourceCulture); + + internal static string InitialProgramLoadingTitle => Strings.ResourceManager.GetString(nameof (InitialProgramLoadingTitle), Strings.resourceCulture); + + internal static string InvalidDateTimeText => Strings.ResourceManager.GetString(nameof (InvalidDateTimeText), Strings.resourceCulture); + + internal static string MsgBoxAudioConverterError => Strings.ResourceManager.GetString(nameof (MsgBoxAudioConverterError), Strings.resourceCulture); + + internal static string MsgBoxAudioConverterNoTrackWarning => Strings.ResourceManager.GetString(nameof (MsgBoxAudioConverterNoTrackWarning), Strings.resourceCulture); + + internal static string MsgBoxAudioConverterTitle => Strings.ResourceManager.GetString(nameof (MsgBoxAudioConverterTitle), Strings.resourceCulture); + + internal static string MsgBoxCueCreatorError => Strings.ResourceManager.GetString(nameof (MsgBoxCueCreatorError), Strings.resourceCulture); + + internal static string MsgBoxCueCreatorSuccess => Strings.ResourceManager.GetString(nameof (MsgBoxCueCreatorSuccess), Strings.resourceCulture); + + internal static string MsgBoxCueCreatorTitle => Strings.ResourceManager.GetString(nameof (MsgBoxCueCreatorTitle), Strings.resourceCulture); + + internal static string MsgBoxGDEmuSettingsImageMissing => Strings.ResourceManager.GetString(nameof (MsgBoxGDEmuSettingsImageMissing), Strings.resourceCulture); + + internal static string MsgBoxGDEmuSettingsOutputPathMissing => Strings.ResourceManager.GetString(nameof (MsgBoxGDEmuSettingsOutputPathMissing), Strings.resourceCulture); + + internal static string MsgBoxImageOpenerBadFileExtensionErrorWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxImageOpenerBadFileExtensionErrorWithFormat), Strings.resourceCulture); + + internal static string MsgBoxImageOpenerFileNotFoundErrorWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxImageOpenerFileNotFoundErrorWithFormat), Strings.resourceCulture); + + internal static string MsgBoxImageOpenerTitle => Strings.ResourceManager.GetString(nameof (MsgBoxImageOpenerTitle), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramExtractionErrorWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramExtractionErrorWithFormat), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramExtractionSuccessWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramExtractionSuccessWithFormat), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramExtractionTitle => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramExtractionTitle), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramOpenerErrorWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramOpenerErrorWithFormat), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramOpenerSuccessWithFormat => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramOpenerSuccessWithFormat), Strings.resourceCulture); + + internal static string MsgBoxInitialProgramOpenerTitle => Strings.ResourceManager.GetString(nameof (MsgBoxInitialProgramOpenerTitle), Strings.resourceCulture); + + internal static string MsgBoxSortFileCreationError => Strings.ResourceManager.GetString(nameof (MsgBoxSortFileCreationError), Strings.resourceCulture); + + internal static string MsgBoxSortFileCreationSuccess => Strings.ResourceManager.GetString(nameof (MsgBoxSortFileCreationSuccess), Strings.resourceCulture); + + internal static string MsgBoxSortFileCreationTitle => Strings.ResourceManager.GetString(nameof (MsgBoxSortFileCreationTitle), Strings.resourceCulture); + + internal static string MsgBoxToolStripMenuSelectedFiles => Strings.ResourceManager.GetString(nameof (MsgBoxToolStripMenuSelectedFiles), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolOfdDecFilter => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolOfdDecFilter), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolOfdDecTitle => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolOfdDecTitle), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolOfdEncFilter => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolOfdEncFilter), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolOfdEncTitle => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolOfdEncTitle), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolSfdDecFilter => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolSfdDecFilter), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolSfdDecTitle => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolSfdDecTitle), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolSfdEncFilter => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolSfdEncFilter), Strings.resourceCulture); + + internal static string NaomiEncryptDecryptToolSfdEncTitle => Strings.ResourceManager.GetString(nameof (NaomiEncryptDecryptToolSfdEncTitle), Strings.resourceCulture); + + internal static string OfdConvertGddaFilter => Strings.ResourceManager.GetString(nameof (OfdConvertGddaFilter), Strings.resourceCulture); + + internal static string OfdConvertGddaTitle => Strings.ResourceManager.GetString(nameof (OfdConvertGddaTitle), Strings.resourceCulture); + + internal static string OfdInitialProgramFilter => Strings.ResourceManager.GetString(nameof (OfdInitialProgramFilter), Strings.resourceCulture); + + internal static string OfdInitialProgramTitle => Strings.ResourceManager.GetString(nameof (OfdInitialProgramTitle), Strings.resourceCulture); + + internal static string Raw2WavConverterSubTitle => Strings.ResourceManager.GetString(nameof (Raw2WavConverterSubTitle), Strings.resourceCulture); + + internal static string Raw2WavConverterTitle => Strings.ResourceManager.GetString(nameof (Raw2WavConverterTitle), Strings.resourceCulture); + + internal static string Raw2WavConverterTypeName => Strings.ResourceManager.GetString(nameof (Raw2WavConverterTypeName), Strings.resourceCulture); + + internal static string SettingsInfoPathTable => Strings.ResourceManager.GetString(nameof (SettingsInfoPathTable), Strings.resourceCulture); + + internal static string SettingsSaved => Strings.ResourceManager.GetString(nameof (SettingsSaved), Strings.resourceCulture); + + internal static string SfdCddaDefaultFileName => Strings.ResourceManager.GetString(nameof (SfdCddaDefaultFileName), Strings.resourceCulture); + + internal static string SfdCddaFilter => Strings.ResourceManager.GetString(nameof (SfdCddaFilter), Strings.resourceCulture); + + internal static string SfdCddaTitle => Strings.ResourceManager.GetString(nameof (SfdCddaTitle), Strings.resourceCulture); + + internal static string SfdCueSheetFilter => Strings.ResourceManager.GetString(nameof (SfdCueSheetFilter), Strings.resourceCulture); + + internal static string SfdCueSheetTitle => Strings.ResourceManager.GetString(nameof (SfdCueSheetTitle), Strings.resourceCulture); + + internal static string SfdExtractFilter => Strings.ResourceManager.GetString(nameof (SfdExtractFilter), Strings.resourceCulture); + + internal static string SfdExtractTitle => Strings.ResourceManager.GetString(nameof (SfdExtractTitle), Strings.resourceCulture); + + internal static string SfdInitialProgramFilter => Strings.ResourceManager.GetString(nameof (SfdInitialProgramFilter), Strings.resourceCulture); + + internal static string SfdInitialProgramTitle => Strings.ResourceManager.GetString(nameof (SfdInitialProgramTitle), Strings.resourceCulture); + + internal static string SfdSortFileFilter => Strings.ResourceManager.GetString(nameof (SfdSortFileFilter), Strings.resourceCulture); + + internal static string SfdSortFileTitle => Strings.ResourceManager.GetString(nameof (SfdSortFileTitle), Strings.resourceCulture); + + internal static string SortFileOptionsHint => Strings.ResourceManager.GetString(nameof (SortFileOptionsHint), Strings.resourceCulture); + + internal static string StatusLabelImageError => Strings.ResourceManager.GetString(nameof (StatusLabelImageError), Strings.resourceCulture); + + internal static string StatusLabelImageLoaded => Strings.ResourceManager.GetString(nameof (StatusLabelImageLoaded), Strings.resourceCulture); + + internal static string StatusLabelImageNotLoaded => Strings.ResourceManager.GetString(nameof (StatusLabelImageNotLoaded), Strings.resourceCulture); + + internal static string ToolTipDirectories => Strings.ResourceManager.GetString(nameof (ToolTipDirectories), Strings.resourceCulture); + + internal static string ToolTipDirectory => Strings.ResourceManager.GetString(nameof (ToolTipDirectory), Strings.resourceCulture); + + internal static string ToolTipDirectoryContentWithFormat => Strings.ResourceManager.GetString(nameof (ToolTipDirectoryContentWithFormat), Strings.resourceCulture); + + internal static string ToolTipFile => Strings.ResourceManager.GetString(nameof (ToolTipFile), Strings.resourceCulture); + + internal static string ToolTipFiles => Strings.ResourceManager.GetString(nameof (ToolTipFiles), Strings.resourceCulture); + + internal static string ToolTipFileSizeWithFormat => Strings.ResourceManager.GetString(nameof (ToolTipFileSizeWithFormat), Strings.resourceCulture); + + internal static string ToolTipInvalidFileIdentifier => Strings.ResourceManager.GetString(nameof (ToolTipInvalidFileIdentifier), Strings.resourceCulture); + + internal static string ToolTipMainBinaryWithFormat => Strings.ResourceManager.GetString(nameof (ToolTipMainBinaryWithFormat), Strings.resourceCulture); + } +} diff --git a/Explorer/Resources/Strings.resx b/Explorer/Resources/Strings.resx new file mode 100644 index 0000000..d8f17cc --- /dev/null +++ b/Explorer/Resources/Strings.resx @@ -0,0 +1,479 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + &Open + + + Save decrypted Naomi binary file as... + + + folders + + + Generate a sort file + + + The extension "{0}" is not a valid extension. + + + Extracting file + + + Applying patches... + + + Computing the path table rather than parsing it improves the compatibility. + + + Select an output folder. + + + Image successfully loaded. + + + The files will be sorted with the highest weights first (lowest LBA, i.e. center of the disc) and lowest last. You can change the lowest weight if you plan to add files that you want to be located in the most outer part of the disc. + + + Select a Naomi binary to decrypt... + + + Encrypted binary file|*.bin|Encrypted data file|*.dat|All files|*.* + + + Software Name: {0} + + + &Encrypt + + + Save sort file as... + + + Decrypted data file|*.dat|Decrypted binary file|*.bin|All files|*.* + + + Data file|*.dat|Binary file|*.bin|All files|*.* + + + An error occured while creating the cue sheet. + + + CUE Sheet Creator + + + Modified + + + DES decryption + + + The {0} file has been successfully read. + + + Open a GDROM Image file... + + + Export for GDEMU... + + + Raw audio file|*.raw|All files|*.* + + + &Close + + + N/A + + + GDI to GDEMU Exporter + + + export + + + Save initial program file as... + + + Sort file|*.str|Sort file|*.txt + + + files + + + The file "{0}" does not exist. + + + Settings saved! + + + IP.BIN/IP0000.BIN File Opener + + + Create CUE sheet + + + Filename + + + LBA + + + File Scanner + + + The following files will be overridden in the specified ouput: +{0} +Do you want to continue? + + + Disc Image + + + &Decrypt + + + The {0} file has been successfully extracted. + + + Loading IP.BIN/IP0000.BIN file + + + NAOMI Decryptor + + + File extractor + + + extraction + + + Save CDDA file as... + + + InitialProgram extractor + + + Extract {0} to... + + + track.wav + + + Click here to open a disc image + + + Converting GDDA to WAVE + + + View Primary Volume Descriptor + + + Encrypting file + + + Extract to... + + + Size: {0} + + + selected files + + + scanner + + + The sort file has been successfully created. + + + Exporting GDI file for GDEMU + + + Loading image file + + + Open IP.BIN/IP0000.BIN file + + + Unable to open image: {0} + + + Decrypt and Extract {0} to... + + + Save encrypted Naomi binary file as... + + + DES encryption + + + The filename has been changed to match the d-character encoding. + + + Extract files to... + + + Binary file|*.bin|All files|*.* + + + Extract Initial Program as a file ({0}) to... + + + Disc + + + An unknown error has occured + + + Generating EDC and ECC data... + + + Binary file|*.bin|All files|*.* + + + File conflict + + + Extract content of {0} to... + + + Size (Bytes) + + + N/A + + + Visit my blog + + + Unable to open the file: {0} + + + No valid file-system found + + + View Initial Program + + + audio conversion + + + Sort file creator + + + An error occured while creating the sort file. + + + NAOMI Encryptor + + + Contains: {0} {1}, {2} {3} + + + Please wait while loading image content... + + + Audio converter + + + Cannot convert no audio tracks. + + + An error occured while extracting the {0} file. + + + The cue file has been successfully created. + + + WAVE file|*.wav|All files|*.* + + + Decrypting file + + + file + + + All files|*.* + + + Select a GDI file. + + + Scanning file + + + Please wait while loading the file... + + + There isn't any audio tracks to convert. Are some tracks missing? + + + &Extract and decrypt + + + No image loaded + + + Select a Naomi binary to encrypt... + + + The boot sector contains an invalid IP ({0}) + + + Select GDDA files to convert... + + + Save CUE (*.cue) + + + Binary file|*.bin|Data file|*.dat|All files|*.* + + + Selection + + + cue sheet|*.cue|All files|*.* + + + folder + + + Audio Converter + + + Convert GDDA to... + + + Convert GDDA... + + + Image opener + + + Convert {0} to wave... + + + Size + + + {0} (Main binary) + + \ No newline at end of file diff --git a/Explorer/Resources/file.ico b/Explorer/Resources/file.ico new file mode 100644 index 0000000000000000000000000000000000000000..ba3ca7d637e64f7190a3a1a6eb81c38a96b8f090 GIT binary patch literal 2550 zcmeHJ%}T>S7@V5gik6ycQE&DnzJ)%HPvHv)QuW|P{JD6xf(V|p2QLLZs0R-gR47Q1 zmQoZVG& zAQfD?gQnX_Qv#Oiqi{rjAO z)s*a{m)Te*3@57jr|k9*A>?GL|W(n zYzy-tkyd}VDa@HfTK%1dFsl-2^|xMxd6!6=pLr?2q1E4f6z1*#nbi`d)&F)c%x93-Duu+YP!%#Iw)ug^U^9>Em*$Myv literal 0 HcmV?d00001 diff --git a/Explorer/Resources/icons/gdromexplorer.ico b/Explorer/Resources/icons/gdromexplorer.ico new file mode 100644 index 0000000000000000000000000000000000000000..d1820218314b79532414a93385504db851bd3a62 GIT binary patch literal 297086 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 E0lrCO)Bpeg literal 0 HcmV?d00001 diff --git a/Explorer/Resources/icons/gdromexplorer2.ico b/Explorer/Resources/icons/gdromexplorer2.ico new file mode 100644 index 0000000000000000000000000000000000000000..82f62c585a48ca99660f1210090b8cc9adc6e5af GIT binary patch literal 297086 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

u#sbJ))(0~m@Cb8zF&6k|{5OyL;~1jg z;9$c~r|m%bVbuR3|F;D)WrM;0RZ00j#Q)9qKltwf{y%y0SU-J^)z^q2hGHI}M;JrM zxr!K1pbRkk0+a!?0T>%3xJ}!DbCBLZ-QYP~+j0M16W&c=n*96F*nVBxy=v9)XYabz z%g+b*8v@jQ|85J%^|3yhK2TxFkfl0we{1PzxlpXHTu8b7X-MiLjP=7FhF+wf%vx8* z*Y<#a7oeNz!?T``aXrTO$Zc|*@5A^M2Y&#(ryXF(0BoCOfKd;C^EjurdEDQ9@So%R zyQ%V4$hIu+@E3pga6e3%=?-7Z`AtWzL@i4Z7*Z~%=fXzhxg3d9{Mbd z`5C$&--R)ZwpSDF{zhiI-yOa@bTRdQ3GlKoxS9_)C<&=YOx@>U04|AaVB0(>Ep5f7w~lKFV7=5czb)%N+LF5t8-wzb!_wp+jC16UhK zTb|rA#{wDWV+_!2|I_xTT;RArj{Bv&VD67`#IO0!`oC2=|C{_j#{gYCcLu)0WBnW( zhaBL0e12xg66O;ATm~Q(kdzxpv;z`z1GEP&V{G$TR~O7Ryj@pWFHD&9`><%duk?BA zhP95=s#Io1r7}gE7S5YJJHYwt|6LYxKOK-5^UGVJxm0gESVr0I#k=a?q=xRt*fA65 z?qFV={xf++pPP0+eRb-8@|V86Sq_lflmXZ{_UhI6dcc8-&VE{W0}LkK?%$(H`;7aEA30?rnr zwp$fGz{98ytmT?1Z^H)|zT92rE;s6RTwGjKZJ@8OubLM?98wEpe*p1MpP$$#4^SIm z-yiD+*iXbd0-irmSpQ4=&-#DV|FZtisQ>vA`rkL0{Wni`2k($`sb|#ZT}GU74n0JS zCCDfAJ@~ow1DF#iNefUM!2BTaPk$gBu|VLC?c%y|ops)fDFs9O_qqA$JFg|Z+_6pI zQ_UI-2KHN#1O9&jKmMQOI?nQ8jqfu!m!}W@XKfy}diw0t@7cpgUw~L52e$z0Soh=peZc>Hc>X@%zbx=y2Jb5a>|3~i ze+z!r0_>|*BKEB&?B4*^bFhkGKhVH_nG&%7unqg=ZP>3^BKG5@`kHvDu_|6_xx`8B z6>(C>DNgD+#!JgpN%FFHhI|rwRR%=nN&jPrh2Rgh!grwJ7LTjaZbPDcv?@#{tk@z; zoR*8@^5y8=StV|q9SEPAJ~sV(`uW5^vCqZ()CSo1LyR(SK>Yv7{+sYWO4a{;DI*mA z=gXduopSyx@SmSASHLf6;2HWG)B!aIkbgM0NOORW1B_UJ{s8m<69?==4svJU4&?{T zpD`tW=#PD_eEilci7$0*v$AEQ+WqU-sN4Zb@JF#|8~@k;QS)G5FXwo5v2_1-oMra@ zofem~(EIcA>mkpNx_&GDWybupuhiUGheLgiJ~}yoF*|vH_M3K`^}XZ(*8I`V6YIo0 z&*90p`2m^(SQl^}@6~Yt`vF)F$Xo#X{>?D}&&{C*$hjUk{zg>(4}TAH|BK)Qu-2cm zvRLO&?Vo=$d-T|oN8O*by{zNqnOj=-<7|D_tv408oGq7m)Ph$c5(DxPg zx5vx*L%{e5De zu|MxKKR|m;Y;v}c#=oxrRq;Ri4Yd7N`2X%J;J*)RcVsX6f6kvxRiBrQJR*Mwa|y}d z8*&agfIa|o0^|VZ1ej+a=8G?_2e1c;@jyt>PI2G7!8&L9#Dal+KfC%~kC%>hY~5s2 zy{eCY4(!*&`d{uFWUin2KEw7`srwRU^?zaMJJ%7pzQhMM=Uk-T&w3TwO4?7>(Jek@ zZ2d!6_hXgCDud?=ac{;x z?Y_4C8uzzhpLRbV*e=EA-%;fAo3a1kUts_7!g!xPzs>Fw`zwKc=XhX0UK+seH(Uz; z-#%6vImAm-r&H2#<2m^#Cw)x1h<9>;&I>9(0M8Nsk&(ukL?OXJ@B^G>&h!a+1Hb#?!aLnw zh-}}Y@w_^ZS9rftxd)p;?<@=MB3Ay_{t^51{aNGR($eas4=~GPoMp<6?UpS!ub0P} zTsVVP&F^8}oLV|(*s-6UzBg?!Z87o4-W=+H?A1MVvB(#o9cMg1OrHa`wI;wkAaet( z5h~;W_y^Pt`97ru;Aa_AkWc7eaHcPH0M7Je{~v$iyNc!2!Vd zW4L`7>jB&^OU!HBn#q0eu_eqCU{ zz7w#&EM6KfiIc|mSc}02ixZ_KhNN`!%977fYcv%30L~v`9MEE?6*UE{3%Vkm)*Y9x zTz1Md%nM*W0P}&&;Zx5K3ky>=nD&`{0mMJ+ey9u3J`;<~8EX7f|6~0>?SD!5$2q~` z0{rjW6)b76{{;p4_}pvAC0>#Y{0`7zZ#fsN;a*bpbja;Pb>k`-arH zMDQ`(Hm|q-G5NRr{$G4>rRU4f?P=evfnDv#EA)8s$tNEm2mG&r--dn8@f`CnG0<_o4 z7r0{h0*vVy53uHs@xaAgqZWYJR|{OA{D50U9KiQ$Eg%Y?!we_Yn^U0Nl-nmi-zHkliJgJOT0X;L1;OwmjeXP*^`pogZ_W5l&zS6L7w)@pez&`E1#(txv@$v-h{uA~Iz<;7N zv^yb9Q9$*~x^#Kd?~440+Q45pUkKk1&t|E+1KNkzO=*nU;BIRop#^$~9pZpx&;mF^ zoU=mc1JLiLuTLLsKzvdBkIG{q*%GXWn_GQ&{&-ZN@+UbhDSR{ulFtto4EBU#5+vOxaf~Zw;JjaY#5? zX8on~vfkE$*6@LeeeL%%r#27xw}*YDt)=e9{F~wd*kR`7n4hD4CPs->p5eiMKF;Z< zFQDUrG!qA?8UY&*uvdUO0p|ti`9Q1TgkS^#{3q2K||)a!rL ziW)%7&w{_(8$ER&?71O5QET`5j;r#@wj6nJE9zjqF3Z!NSEMyobIj3hgtK+(dR<4( z{|55>xl++54>`U9xgT}2)bE79g?9f6@SlaHb^fAw-?9TbKd}Fg z+Wnf;`n26&QH1@*OKjLz_(x4J4jpKOrisS(r=_XmS$TG2CVYS!G6cDRVKG)UkBEDr zqHlpz@BkNXJR^NqY?E1-9lCg#;R8?yU`-F>d*Y8izxMr!P1<8>e?dV(s`i(#|>l6U&Pr>T^ zzheLK|1N_$PxSqbe1En2T`jG;e1kf_)s{6`=O1>zd9^ZXd>IQ9`_#|q`%eRY$N|*X z*kePzjdS(L1N6Ze6Hu2g^aT(PuznY9r)mzsF&hW4=Z`r;`T;6Gm}kTS+81E&5Osn= z4#0aA2jJ(aF_KfrE#!c|^aJ3l%sy$A>4{d%`zgRouRIwQ4ciuVQ+_^tO@26#BYpN< zmM?Z;R?f~Wd2c&%UA`I8!~24~;*l<$-O}V)toE+y(#GwAv~bIiChnQi&^=4)cwCek z9+y!Ikd3qVt|9+^LmmJp+=sk*8DGTph?^~#zg?8yD{l8S_S1p?vsj4tZFc|fV4rrM zT3=Q8{MzoDv9IEN?elB9?|>RW2Vfruk33e0SEpEe)l!v|8HUc7sD|Ml}kp|jjqr%oM6o3>iNHm`hO`D*%P%e3G?i)-%9$~dQ|8Rqq~CY*VG zVxKj%)Y2z`16Wtf+8^cs?SL=#+){s2F#$M$xp``X%+<4Q7wsyA9H9LGa)3D&;F;a5 z4P=cFc|iFAc&;=KC>{$?4=5fBIN@({06#5AvSRL60cPyql8Mnb}p8*e%-ZLwP6u)gM4 zPhd4b?z|2Hkm}%vO5lV?F;lOc_cd@pu9Vr92kaB`ce48$`=#4`>V3Md@3tJ@X5{vX zeQNxrV85=-?l)5LzRB)u>^md@|EFR5Q-J?eski8?Jh3cYp51aq-rIRYMjXwTF}UWe z`{)>Im8#&gN;q@818RxBSQ#wSoN+!M@J}4mp0gf+cAhp^W0Kk&eQ^5zto_lof7A|_ zBag_~f8oMKGHcc>nKS`sf&%}8fd3Ic_LY@O?PNdjp9cI}tyalHT>)bN`T&eA$T4OP z&{_b0XUVleh8}pkCU{Ws6YB_%W6oG~H0Bcr_{*B*OReLE4b1(t=c^Z9@6us2us?tt z@IT-Ou+INcOWFJCSsp0Y&eHXZ0hVz-8!SuWk6Jtn@*85mlJD6cGZk1T?l~8aegL&} zasr=cZ#`@6=?k#;hO;)cF5m_pP#gdsy^sT-32+_|bA*fqSTCgffE$J$z&atu0%kuz z#{#S?H0uHM1IPioHi&*e5eHah-B~Nn-YS4rnJ4xqZp!?)>+%Q4XKLgnnQ$mm#_Ug* z;bG@w(9SdR^Haeb-taeSRDE zcL4i4PGKb$=J>SFe<$oeZp!b`?lZqfyI-3*KAX<3T<*zpEqlN^cl4FNBsX$9REM{l~ut1f!(``@NcUrU~EBc z(aZt#HOyLo)&qc<;@l zufEWJBkBXbd*PW@&9Rs>`)~b6&A*c6!H1ez%2(=Qd2hrt%aX*ymh~6UmqFamzI5it zSTjS-kG-=)5C<>^z~{&V`MQs2$ASF+n zPu-BEI52S0u`HPzkuEb1o|P$>l`&yYs{Fd^j0}U%JrMZ+!S}TE0scP+{y+9elJ~#? zZ@VYU>sZ~ey0|6F^WcO|;Dl%38?=LO&>FnZ5`54Ut1*0p`dGC$CP{U0LS=A51$+Sy zduE_E_cCJm9MtSz70XU&eLKyyJ;eS=tfKtB#(p_%_fg+d9`*bcP}j%W9;22YcApwQ z@_W@-*JI1?5&N|Hg*m?4?7qq8H(|dKu;0kx9PpopJV3fMu+Kn#fOWq)@_FbjoKIlI zHMgp{huj+#5!*cOff*zlPs?}C{xW-+i#UJ-bS{v60ranFe;JPxhkVS~pV}WeLf8JX z_n)&r7h?YZAG2o5MEd`#{s;D-_+Mrx;d^#T`gxoE2mW(&Z^8$-uJi?R0Am6A0n9s4 z4>ZRCngg^R$Xeywa{>nb$pMGdTw%-)i8izV@`RV`W}G|vd%@5j`rLTG$4lp4?flGg zV81t3i~m;e(nB*q_5Xea`6B9Kbq0<_5?C?Dc1kUvmIw0smEZdd>^G*)r{et+D&8+{_lf;R4r##u1*{CIZ=WS~9WF_Wl{xZ; zf3EZkFF>ECRfgf3Ge6o8dCN*$^Q7*U3-Z3I2iPnNR;*Te0BZX5@0sVP=EpdIi}=^} zpRcRlUz`574EmqlVtbrRK3679H1IzV^FK%Y^zEPUpPz5k6f*{(55PD;`vKGgs0T9c z&~ZRXdLZpQv8^=#A0zyV4ZH2DFF1CSfofH=U+0V)=-aRBp!C2|1#0CGS{dO#-lfqnpI zhq1;`)d!FR5D)ClDv;pxJlT%Kfp>DYxFuea4Y3)rI_83`IF>F;qte9g$a$G_@VxxK z@0?78|34=9tPF?tHYgxf`fr1-4G#FyCq;UL2R;A~^zwoqfb}|7cRcQj=Q~3q=;W0m z9kAMYo|ZOPEuk4S1t&BDAJm7BP{$PZDXk`1j7 z{kyu4uMqpJ>ofK7v7W!U-LF=xuIJ8npZK?FeI~n4pTDsU`;8okedwCNetr8(Qfu)Q zY2b8KI=bJK4={(|SLlEfaGjYC>afeu0eF5umvvF{J$!(f&Ks1L&sqR#`?U4+`I!q~ z?w|J=|1(EOjlkXAUFH8)LIZGu2B7QzCr_gOKUnGi!-4;mu>S{O|I=*tpEZT-EztPa z9KgN<<^-5`C>{rtR2yX01B-aT-~j%uk(?t24md>JA|zN=uUINm#||&(|Mkb&@4VU> za|1fe2KKvQaYojE%Rk-c$KHmEL+^JdlJOA^ZTu5B1$Ki_0|u91sf*hz187l?q#;q`X@c>S>R{7l?r`5R3d? zoXYXthJE<^?By|QeZ_tLzi0Oi?3?Yr_W5b|iTy?nz`jG4G=SZ&=Ws=8IAGS$^6S!M zW3IfkJzsvtd1B*%e_ngeMynUde#dLjLX)J|>b)`^eF3ZoVm^=af*Au)2c!?c_?z~Y zxxw3F0Q3;Aw$=YEMLjV!fGLwT{=bxAKlM@gH~aq@|Ew)wjS-jD0(2ZeJ+L?j6psVw z127IK%@1H+kbVGX3$t#)$J0%mFhgwo$ieyF_U?7%-5y>2yL4(lsngSKdbDoRxGEO= z=l;|Gv6q3dKWqKlSh{^P5a)KeT2`En;XJ=5gK=gYW=!*}F4p*ufQ@I(KWF1G7eEb| zx=1jbMIM2&5V!NO{_xl-liWjOsQX^|+T#fF z1u@bMJkZJOq_puyEZ~J)I%aLvcSoO%TQoQzN~&x=g83WaQfbp(@W5X90^#rlBH#J>tpYJv3URQ*?q?Q^!YIl)MWQd!hR!Qzag++f5{c8vouF)I9`{k&Nop* zm?te!_0Os{r3qX5Mj8Rvoz2yuJ z&JLso$k&-KRRV{T~GTZ{VNt|G~XQ@jvm;x zWE@bE7Ert{pyW8fm?=shfVn`<4&e$5-9-+tE}lEnI%?qex4!!Doind>>9qT~cCAMM z`)#oP8}fq2x!w1dYhrn%!VB>ICu4^Hf&12HrQ(d}g6DP{zCF*NrS8Xb>8SZ~E)MHs zIVXcP^ZzOiU@T8P!0ZPQ=d}66z0M1$d7|_KZd&CmoPs30AwKJd9J_E;4xhUs`%*8< zuG5z!F!`cvJ9SaK60>A;Y^JO`nkFuXQ)R`zQ?fiXR-A&4iqnoGvSRywS-CAt*7@#~ zO+Nmz$;(eRdilym&#h{0@bHoK9yn(bw`)DT#l_u69Nm0nz8hxcy9LW=_b?gcu}{A7 zJS6YIw!h*PE$uyHq=iQ`>I9;sj@uEb;TjGoa42S&r0nx+c|t{YtBD$)oEqf6&t^ zZ^AF+%tZ1$bzq+LP}MIVwGY>&1$98w1Mw_j&I_gv$of9!`iXgJZd|mrtPy4okTn2| z0oJeI0Nr2}a){2tGf1aTn<}F*|JSJh>7(L*Gye5FG4>ZQ2H?^@fSCgr2Nc%=7zY&R z0P+(5F5d1wI~UW|0HF z2G)6wd^hNUZ-4{XCqr$3G2mBs@B{c6x=v^jasv0t4zc$}$dO}d*@^@9g9E}+F3Zm3OS1LEMcHyZQ#M4Lm9_g5WkYC`xb564UID?f)gSTb zHhpyP}TG)k9Xg zdCLNKe;Ml$B7HsgNe|D%@{C7>G=qQ8z~dn7X&on$PRd0UMyU;W3{Asl6Fz47u!*@ypg>Ua*VO0jcj%>!%J#AAoTH`|=nA zPy^unPY(}IXaL3;fG#d8RUOdG8NbVzk;7H}4>b2u@Sm^xi_G}fv4G|PT_0FH4k%3v zC>{qW{DTAdJpX>KgPdKm%~v+8a<(uxf*snzn_)i5t z{x1G)H7s>ozG!*jqi-!k*KV?Gyq5jAPu?x+e)R8|&*$|e*K;mTr%=qd1_$u02=;>9 zEe9|+_>Xb`{Q&BE)c2_M|49$Xw<14KAUU~ta`75wLSDHpDHpHF$;_(~p8*a?&ygeN zvt=*hfSo5Z#P9ey@r+0kj{~vd5q3npgZGMGV6gZH?2rJ=q2KQBC;qsu{=Qpf+g2ah z1`hB82l#q>8cT73hinB0Yy}7SfCIe20bXuf)FKzSLi1Yd<|#|vedTw=2tz$~$(J6x zRX^Q)G-9n`%@LzpnkW^b21m8MHs;mi-%Io$>rHzMR@1YU6#@_Dp{|)RL zIzMCmyTiVY_m$6Y!v5pHeuZ_YYu->G_ie&VU=L&NA!nmf6Jq@rf8{{3Z1oLePJGeJ^qXVh#}&ii<$sy1gQ_`Jixkj>rp?*bAX*>4r&0#;|$P2-}e#B zM;?8+jSXl2iGBce|Js=8`L?Cs!U>j{dr|L~ zcdMS7>1VZ4=clb^jSuxcV!kcnJkG%7ynDp~cklzuxk37g?7yFJ0$Kt%Wg+|k&gWQu zmwG@+9H8}pYj6T?=Ajqt<}Jy-hI1uyuFLt$m<@mFnj~eB1Fk9#*nc`p0^`n!e?+2e z+Z!Rp`JVC1J7V-4?bw@zDw$D2|MlDmiz`H`A&*vN-9cysF-CsBSY6-U=lAap`$h47w$xd6Rcb=(tLmI9 z2KLd{v=Mzxo6*4Jy2@_f7K(vzpZpV(3mMs4&b?ioFT{=Vwfc?%WwC<8z_}Y% z^amHnB@_qb0Q*;OV7AnC%$HFdaKrEezya~;*%EOkOZFwCN>F6H1RjW#onh!b2?-VU zdIuwp3*H%s`7eRW7iBz3O^P;&J}Z4w=BOB>Qm5jgt>U6h<6;eqUfjdv0b<_=et|b` zJ-`8LpcUA8`pFp2?eZD4#FyQJP&XJXjW&cx{dK`o2l%h;5+t>pgQTW&h}2lQ7xnuQ zsO62p!kj)^P4Azuk6M1Cf1f?PSSr77*!{-P`WoXR8g+eV;NKgyJw-ad5$`LVe@QXy zBi?@u@jkI%Zi`j!cSBE;J7y9B|D0#Yc}PD%`=d5Q&6hqvQ|yn&(D%>;%^yA19+9yw zo(jjz>#@d%-z{Tj`u?=H#F5Se@cZU>>yGbl)8;L*3iW_?3o!$9!dMxK+F#cHyTJb6 zhJSECJ~)6HATBp4=~38W-Y*68)Vi3%pCA1EdV|M^MINI_&VzXyl}SA;<+qHN57xC{r9-WeC|nH+b06i1CLuiCjYZH{;vH1_z}z*-N_Fq&H+5< z$IJm{KOp&9fuv$^0Av0v`2AOaea?ixhD9F8%DEwDE?<|}a~CB%F;#X)#mcUI=s6AB z1N}BsLg9<(03UdO4-^l;FYp8xcynQ2 zd*k`lo<1_ebDMncwnJV5{+|T?pI8?n4Oa(Cec->|iXf@$6eM+)?*bR>M-6WT=Jgym zX7-@APuKL`R@aAm-l9G}L+3ZJuWNdV{j*p`ZBHWy9q%L7cepI|Y}l{igg!>veU1H1 zu=}w2_W}21p!->{$^ieIX;^Q&F*AvEVVncQS;}p(Co1~ld=j@Td2U^-48^SQCCKGD zJG-d-KKYb*C;nLrz+2*nIv~G$zD^F{_qQIkL-uxyWZJ}W$o+k%>i?Agzq_dZU-^ZB4T|SN7jgi2fO)83@BsbO(m0?rUqJf=X1~DG<`Zxqdjj`f-~nm{ zevB17y$lZU*e3m4cgP!?f}}m{fAiHL(qtw40pPzO@L%6C81wkTzyk-QmdjD#{k1w zU}^xwJ#+Bn0NUCEoCN?*F64l%zOn`J!qO!U@;hn(hW*q}&HuR#{~}_=DxeQw%LA6g z0mb70tp#WfpcbI(1I-+u`-Q3X754$i2Yik(z!Bh|IRW|ufdR-Dtyx(BJ@8upFF#6o ztLt-1+BR+QUeh`?nz?P>_@6Q}$e8c@Q2EA|$7{c6`FQ*ci_@9ta+|X+RKPi2Z$sx} zKOcK~82eM_tM1S1in$Mn?|4=`;{Y=UnEe2r8^IYmIxoP!A)ci@5c^~({6x(GoW=7y zeh+8!EVStX?9nTU0|IOuV8jAe)b|uf%*9(0mvvoEUc9dCJUJi>9B|3D&SYGY=%iFR z91|x8aIN;EhhsnVCeC`?vuC&LhRq2B4{!zz_vD>8ptN{^F@bq$E>J#!Ej}>f0uO@+ zfPWuwf*&-*jqn2&xckYVEdkPfeXu+Q{I^8x-)u#&Gy(n_FAajd4uTdRCiR>SVNTyM zHKVtVb3$P~zs9~%&ujMi|H|&$YI|V!iT&y;Zb+4t8v6zEFm%2`yAP}r^Je^8zzLNR z1H6d5ALpl21K^Csw{Y!Q4_w*%mNdfru+LZQkZDU-io=RkYAz6cBIIYyw zU?lQ^`=ABT7Yo=PfY^&OfxTq8qod56I$4Gd_zv;^H}L-v|7-hi!#{n1;`rBofYt)^ zZE-E2xE^??*fLi1umMV2yS(-opj-{X7Qp>8W)W@G%zR+>3rf-nit7W! z|2E*C`r!s}z-+f|^4+FDc>_K`$5kQHdIfj@w!b;>-_(95`f)>~(UN`AVA&Di{`eiR zfAVkGebn`t?7qVOnmj3wc>m#z8vCYMh9%&?g10djnf@XDMCOW^Girm}U{&-4aV|iw zm0>c*aic6;u}1X+QUhdcMSYD}qupgsU@ZIq+F8a1jKy{Y?gX#;%Gx!nW#Qb}GWwSR zs{U`;qS-kA(@#=Ul9m2P?3;B!>Hzcs%zl8zzSaWB0j1Rj>A6AlO~^~SS5Vgmnf(CX zSNK1CNZJ1=a2o4`p$%Aly*#YT?dRu?{pH7#U-o(}@V!?%kM7i}Nhhp28`iEX8xtM< zf5`&|{u{RKV0q=6uPh_BY_x2+akZ*X{;d{4Rx9~@ZK{#mkAZ8+nG z9Dq20S^&?lY!htE$1JV~Xb#|>V6K=m_I^N&sQrLZ@GZuIWB#rm5PTtDc4Jt`fwXHX zugCmeJaT=^`6t5{IFWuuVp1+hWPFkw2KEmfMqMYb6}Xu>Tk21W1KxAkS`1iKe6Kq3HaXmO-rklU?-xw&};RCb>{@Vio zt(OEzOW?n`9eBVl6g~L|Fr)Jrdhz0HK0p2al6-#l@0RTIQ|H%OUv238)tAHW+kF1= z>tOeR{RiOlmqom^|2cQPX?}@%L?LYJJ)Z^Kg!@5A)Pu2(oAj@jz*Mpyng~ZR7y%{2V5h+m zJQwpe4$yu8>I4-BM1TXpEu6KdH~{$t#Q||P4uB0&u>kfF^A2jJ81#U3_**#B&*Qum zvxEv{`}tcEboQEroz0Q`=TP61h8#cqfEcXUbmaO{G9@D6v>b_sO+jp?>os`oG=H;( zTk`-pfP2pD2N36a5%)SapijU>UNCb5@AG*x7npqktrePizz6o({6D!6{=lNW(!@Rj*glS>dw7`N!_1z-c;D#VZ>+Sw z^N1fxsOLA?eIwq#RcQAO?Az?V#(VKw8~z`}^EI#+UVwi{{eJhijr{%@Yt#Q`UXD5(@kT9x_}UAdCS(_K>xct3VwTv}&j&6bEQMkQ_iQz+4-o^}svL4%7R{jDN!q zz&XR1AIO;j)CBiJ4_xo!DARu%cB^micjLP~`_$Iw+B6&1s8+QOwW~hPntSSS{}+A$ zXZ=*PJoDCTmLDC)S>}WXBJY>q6lZ$$JYco*S`u@EfYWxc?Yzd+dpO&cK0rlZ)OnBt z{GkCO7N8Aa&X9fr=VWURV4Waq2ygQP$N{hsiUZ&aaQ@~f{61<&v?0`y7)x?5*(YJP z@M#ejasYCJo6i=A$JspDntDUFr({de8PxWtUQrxya`Ts#AwJfN=~_n77Y)}YYu)Eqz_;C;R57tsFG@2BnJBF>3-zQ*_Q=lOHw3C#n1 z-<>#s{=W}v3!xMEVy*D-lM#pmdZPyD6=?s@E)9`q?1Sa$MM2VbK6qe$n6y}U5Wc`s z!~}7+x*lRb35z*Cjs0`DPwZ3UH+p#*ITY#qwEHz+_lbSx_nG5+7&*Q_+5O_U*N=&R ztov;Hf%zczf6@QvTqvHU@C5cv1@CLpZeyZ+yed?k8_wB2oC!n@BVVpgWyM7?iGF@VN@NpV1F zdLX%o{)py)(zJl08e!v1LG2H)7U0Mc?6)X`1CC*C&<=lJS?OqJ{dMpUH$Hf+OZp3K zTe>x@S#{{+k3ISVFvuRE|BLfPSod26HGjPq*hTNQcoh`10d{%qCIW}6fjRne zjeu?9o&FxL_k-{OGzTa@031L)z{~+=KY(ZF-ZKt3lP{Z7a>WCKe|(azh<`Hbc~h>) zt~1%P2R(lKP~*S|bU5Dt%Yl zFD~}9u}+1raX<6D)C9~v0d)iBwC|KRq+dYn`=hRClh;<6iynf(>vzh#$p62zEJU6M z{-0eGEFFOVr|0dGHuLsL%Y_lrbTRSIcwg&$2KJ5oUJ>>iI<9XX%n?&FW-TD=##&-8J?4#G0L(pkd-VbNZTS{8*OPTX)Bwqw z)YpkQ;*q&I%>ncam=}nKFU_92Q1I$1XD69Hag2;W4Dj2K{^GS|y_`ynmn)e4t?|!W zv;VI-K>GmZSU__CeE>Z#prqMhj04C?<~Tsl3^Cgh%>k-M031N7ukB2On zIYkD1{mCtyD;U$VQC-(+l`4E+woKV3F#epm`S1S683na0FMs)&WpcnWi{pud?Dy+{ z-0cAHIA>(@49zbQw-e(J`51i9>&@BrW)8TcAAlNxF7OSNA7JYldLMeiC-~ei?%)S- zrr>RU0Ac}0{5>wow`3g#1#UW-E$$~SiO;FaiUR_YuSj50w(L5QDSP8n>~V2 z{%!HT#(8PC*aun@;GU?v9sM7;rkoMMS+FDF&#?}myw6Q(#JON=B4w15t2!%~y+FDS zkk^B@mKfC99DVV$^faXlo+9>6o{|V$J5SVDFPt+&e)-`W`RS{V#o2y7`T)aF2Yl`} z{OcHiJfOLN_`eee=$rsGLCpcWPk?bi@tmN!Hi#Ucv0rq1NW}p$vGMR_qMDc{A|6N)fPW+|NXCn0~-CC!OwVuwFvbsulDVW^L#g0oX;GyV9poM z@%}Z|I4g%UJU>R?&0M;g4mQ4v4)jSWc6PMA?b6I?`f)dh{?LU0%xWaz~@K3CBpJ@)zJU~By z*Ne8FSS4nOd)ji^b{7{Hg=x;BCbr21v|Y?$b8)T(_p&qQRq=Jck3YlL=rb@@pdZ0_ zfIa~~n;c;F1vC$^uGklgT;S=mRhA$hFl23@e6k`)-f#$(SAhSQfd9_(pbN|ig&%N0 zp0qoT+yMG`?J=jbu&$@b?i>C47o|RGd+NgO*D_(hB6WV+eG~RoZBJ= z_y~JtB4Rjdfb<{P56JU^>$sv02(?Q?9o^MjPkvvz4v^TP-cH;R|HLS<$e3Ks?SL+L z9xEyNH1yhivSs61nK){Q!v7x=eihfXE)swIm~aMgL4JNA50C>i514%b%>g{EB-ypJZ9H+~#wS#-?LvN}D1_$Nkbcgf+b`{Oyd zbhptS*=D`20&HtdtN&;qA!43HmJ?v(eJ1j}o{f42p}(iQmcJU3K2&Oabe*~K6? za0+@Lb$+e${W;#Ri~N2q^82TMO`A_Fn)7zVBY7bwhjV?e zNGkG#;qavw!v`4Bk7oh*k(m=ltFypzaj#ws9_V3*zzFuxJXW9h$;q&)z_U!h;&S#!{Vsf48 zRl59}@lVZ>vk978-X1j4vh>96vgam|g*?wMk+qG7=wtb*E z;9<=Henpz#9XSBMNBIG;87dagxk1E@C2~MQfy_$GlLc|t#6J3>EQ`*P6<8~Ae@)CK z*?b&xJuuT}S8R$LJsxY*j|{DkI42jFIe?G3_q6RNPKj5IVcK%qdiJB!ZWF_d6L?L{ zpU20#e}%T2euMS}Xy>R8kRQk$^aZE~@OKsOD$4 z!SdGPUD9LWF6lNu6dVvH&(9B+XY8V-jr~b!4!{2iX#9IxJD=15pDc2lBh4 z=Fj;Y#5*xcymDzCyRV*B9GA`TY~MYc{D{t!icHN@bA)rH%fV{Il7A;=cygla_afPC(87(FZnXr{i2t zE9ZG|PM^|o;mf@O4(GY`g*ji%0jB*yUx0pq;sE3ZxEFL@KyyIrAe@~CJ&1jStR>>- z_Q3vNo`~n|7S{tb2aH54@*8}~iE;TdJ@%%|iq4S*ky&CFnJEsqU54cpbxAg2j*tKG z^RoANl5uW}(vOSqPt5ZB*BroWMfS!?2#@D!sWR|$E3ae32C+DtTe-X?kCK>`^x9Xye^y1UxfVvc?dmx?Bgkm9{xg3 zH(k%a4$pBdsy&0Q)T8CUcfJ$&%&9`GDj* zUIW(HPy;09h7{tF87@j3h~ z@=EFb0h$L&iv#Y|FRXn4VqPuo7u%j;UGOo~HAKS?V11CUm%A)o@JGSO0evrj`1*?{ zUVOUM(#ExFd{U*tW3Ah?Y4afbBjWR4^3Q~Sp6}U4&G}w+;pD?^*DqGVybtzo@%%2H z>BpJA#40uazuG7C1L!CGi36YuDGmt4*|{bTV9luF0QeWTae(#%u#axzfS5d)bo9DR zkGLYU4ra()toesBWzpd*S$rf*)?<#}&f}>Pe*C2J%Z@=WI*gjE;&?S{IaiQ&-^oxTpD<^aGYHTc*yzAqP+cpvJ&kem?yQvoAp2 z@W%>3&#|wspSb#LlZ9J$$j_Lg@yXKN^6ui@^5&vF;DCMd3UYuiE;=gD+9yi8rRSv8 z(oAqb7JLBc{IL6VF|Vr@X7;eAxAMwc%IAL+z57Mj|0nG}_k`XTz<)*ff6V!Ojq6AM zk>@Udj{B{GtWpi-^aK9H0f-ChkprL!G%v;hjV}FLs4$lM^WXjse^RnwW>V1wU%JG=!wkh@$;A~pms>S(?8I9 zApHQ%0h$N4BUc#UZ`2of`E8SB?mJ}o>Rs}c;~x3YVV}HXw;vp^A9}z+d3jNkbjDeo z9fAM0%d+IjrI)11(krMD);j;qQm}sy?7kWQ?$C(A{X84JH*7xf?~Ggxdp@4QT;Lk0 z1FpL%Lq0)1bMmsaVuwBeeJ&8M0rPy++Rgaa98i)kKn_SxJ0}5KJ!Ss%i8A=R&jsi6 ziVNm%L>xSzIKYg5tCd>d-^2g)>(B$47X&AjR2x)UT>xzY_lkji)S8E5(IX zIN&fe>0Kc^t&WT56$~Hn?X8dBel@jIo96o)*Q+tGVugomRI2#Mzidtb@Ndlfz3=`y zIP2pX%g1BqTGm}jtK^k?wGnE6IMbhJbg=%0`P>fR^s?Z0`grEJzce55Ha$Sc0(Zj! z+7Cc(fc3_O9Du)v`N$y=xiaEFw)~1i{>Fu-V@`LvOxcqm)4>BX_oc}i%<$U--#_v= zYBi%VS1Qt&&7|u6ZGM=>zRvd%i;VBJ-%ssc*QJz%ck^=^`(_`2*yp0Y$oHB*pPCo> zfc^%30CE8DYd^ru0|DTG?c@Ng)m{NI0W-n+JMWRtmL8Dz?8CtU;oyM7@~YiY=?eTm zzwDem<8)ElI9-uuPC3$G`8D(mqox=AyA?63^Iu~3i{bxKJZ`ZAv*2+382|IkC(Z?a z4(Ef_#2KNrH)YBP&Y?1X*?L)oa{-8d+JEL-}-^IFsqICoJIY*GQgsBB^ zhUg{u0hxC-LzMha-?O+MV4N$8v&D}_p;tIuHg8xhv!;wK_^HpQId69Dl-#~`ld1J; zS7}qDTE&0a+|WY&mwULrrDB!mET2tY0Q{#{_RhW5G{|bD&F7iD#Q(PusO1a(d-&IW z0P6%FhE1qo;sEA|Sxdy;Vb+UrhKSY!lpmlu05;@fZ~*;B&Kd8A^;7sw8MOPd48tIR zQNd|4CL|3!a6u-8p2y7Y6j>dfB>Q4cLi%sff{22Gs z&Qph;Idi7s0P1(drq=n)csJiSV_)N6>k4K+fcI(RwI0Zv7h_)j4swIWznKHb0|C$n zcWn2Uo!k9ni_dnMy(w6RVHVIgPT}&=lEd=e;zQEY?ufjx_^5QpOwTTk=cUt%OVZ9c zM_RaCmxe2EN=?-CJr3-bhtFTm7Vnq27xBKvy}tE?U4Z?61dp4-$9oTY&SK!7wd0%x zz&-%tzviYa>E*IpezWxf5&!(Yc^y~-#Mt^y_}BgbV*;(|(>G6ujlsE`_A+WvKl%CF z-Z&rl8(HVPOpYEoC>h{@BK)&Qh#X+d3Svy57eDj%MGewexAMphJXeIXgjpwi5qU|T zG0Yml+k1u?$MFB6YXdkNjP-!ws9|LOU+IDL1865uBOHJkbE}sxwN4!U%gwJod@JL% zE*+LU)x5zQ4eC^F{4a6-@u4>SKVYd|zmcU*(=L{8X4wJ%892B4TFYRobrAe*p4ChI zGnQ-j58$61p!5LTY7VFjO|S<1fZ`lr)&yThjR0p1y@fs03wDJ0KAs1a)^~UQTWNk>sn2Wt$7(PGTM>n0+xnU20w!y{izkWno0mujBfYKNB#-f#v`${uJZjm(uSCJdI z0v@;s9>~bVxgyXa&Ye4tzdu#gD4aNPN)i$|(;xwR(a8HBMJ;e-q!AY~AIKhI)&{aS z0R2H$yE)VIhxY$E=fk&O+5TL+<`dhtX!ut7N6Xd3;%vTq`mYfGbz3}vzTa+^AMBS{ z)@Nr`-$F1KdKR6#oE-+F)afpx)7Dqu3 zJSJ}}IU%n&Uyv8pTH7sxcQR2xf17tJG#nz=iBkm?}{}*jI&F}|4qaO#v&f6 zL zf#j+glew5Jb6qZHqh9&aWy#38DCrqlaz5>XoIRI@vj)#g%9*q1Z9XF>Pw}i%a6-Zf z#5qPiGxGq)P!kk^{)TsF8I$EcV9hTRp_q)kmI=0@`yiuL;!2XL^_1d;=drxzL zHvHdjY5Q7J)%!Eh+0n8-=TgnBw{AQgYPIs3@!VYEpK&-fowD%n?l%4}zOT%FfaZYe z;D9>VE1V_NG|-qS))sz7N5li2H3vW!d<&}={Kt>NaMnb~b%p=_ffwXw*#9Aj0fxc< z9~W|3W(3B_mi?%;2Irngh*$CCQTSKHC9!H=#4>#XVvJa%?l*nNU*YNemjC?#nwGC-SwahSra9F zG5_N$$D{HodVoJ%8YAyGos?HsXUK~iuS$n4x1_aOfjr?+Aay(oq>49YaU%v}&n9!Y z{}K+c;r}7r*2gtv{Rr{z4h?BctT8vHF8sc#n=i}jD-U26n7hn#URP-U`Ts2m|9|Fz zBK)(?$KU|Nho@#w4hRhjP_qH2{Q3*#gnTVHn@g5rR)C+Et3-kyPA0^uTH#92^1ufM+6_~+-{XX((hnWf8TZ(4?~Uv61{^>S_BTQ@tR z@0ZsMF1G69U@gFtz~?`MfAWF$10KR2BnLc>Sb+6nwXt7Ry)b@9OYn^5fEST-=ms8m z6RQ{WqmM%igP2QF}9Fa@c8^6BI3;;m5(TiIQ{z-)}s5);M2A zV^iPKwiA=|{b`e_&Ci%IL!DQDxA@nbpm~6|{CpkzYuiu!^Y_u$pw37Qkof?{_{2MP z2qQkZeHHjMtT0`ExqZBw)iT60|byTr)1&M}y)6DuFAN|HA= zW=U7K>(bFPPg(=>O?<3UcPnhJuT}MJJ&N!ALFDJi#l`vgpMGq@Kl41S7o-30aUQcH zw;iat5{ir;|>pSpug{B+7}z1W803 zp8!8H?l^1;a!Jw0&_f!<{!zqxh~E!E&!@IjI7144Jm>!H-iK18}5>F;e(&~xOTa9!ssFSpY-gW^IZEUee2e$GP>&H z<)6Q&&Obg3_MiAKYkB#rrs(~7(=vRc!hap$zZ3A!nSa5VhW)=M_~-t>Vh)k>Lo^4l zMyM9{3ug&71@>7R!2IzG!2Zj?{p-jLzJv84?Eh!G3#3ozb?F~`Q3i!%$k1KsGGg}y z8IAnk;_$Lo&>=XYb#s9=VeS5|L z8vo4o5&z^NtxNKKnhSUveqf&*IU^m@f21wES|+t6TTMXF7|M+j=Rtguw9qC$?M*cBltP+ z4{862f5vSNu>aJM*~8TfT26ib4L1A_Ug0J4R&G#!Q1STR?Ejl_Zp8kE{nyX)mUV&T z0IlOur=#v44&L0f##z+}{yO9b89)4I^xqH1ncdT6&2oFx3ayg>UoY9=>#deQdh_Tb z_qP2#y_gSexv$Q3;Yo7b-fMpw#))u>%qh5DtH%Vo8*qpV!9%vj5p z$tv8}Yb74LI4u!pM+f!34QpJ~SrH+y1&m8$;j5lZIxR`i4I+@M3JmZQyScxUuWr5F zt@FXw%^Em9(V*r>k5?*R1?yg)BUlF5Z(`~C#p{+~8=NfbuU%I7hyOno_z%f4>Nlys zalZ3EW&ch4jD2D%FMxeWAAt6svqOk|<{4iE?z;o?Z$by`1>gT8)RTUO`2XvD1=4TN z4H>ZOk_^US;X}hN$nZTEWEAi}X?Kdu0scLSf7t(I_GyB<{|f)aAayy~|EW`_s@|Qy zYyV5azvck#0}$82!NJP@)Bh*u(Eii+FRnH6yz2v^{2Uwpwg0~q`1eV>9sg$gKX2tm)j!SrpIQGm>wg;OTKChjzkc4h zr8ducA){tEAAUeCcp)<*9rim0b(G%Xywpzd!1&<JLZZ zGe-^X58VNapZ^OMZh4>2j~e`gjQQm!nJ{9I%$htFb$@fjebWXB+lAg|=mDu0GUP;3 zvWgowuUje8#thBx^U1r(FLh|Wt3~6wqk#Q(Sgh5(xBohS+}P5o*Q=JntCqt5zgP?L zKhAJg_J0@fKmVjLyR*$-;lKDkGCzjB*YQ7l1DFW;km{J*-@_Mf=d%Nz&r^T;)v9l#s_<9})o^zr!`KVScC z{4D+Z4j($GYTWkhKP29}qGS~`&INv_@a&SJK{U#Ob6y%8EbKVD`z=yegm%wYde)LV7_i8-7hV6;Cq38>VFMz zO{v*BC1YkY@INsgdLaH5`u|m7|9hzT-$UlZ{_7b)^n*BCOXvS@$9GXqzK92I@8jkB z`I^oP&=(+Aa3(-ve5~vV4Tc@ZIU@E8Wd83H70wwCP$QTIywfk>t?}GY;GgRkZ~)g3 ztiftc95onxFjyvl3-lr{j2}5raNY-ejDf&7mg)5gBl-Tp>h*ERO^gSBOau?in?4D= zv>3JCTO|V8XDsYiB6NhHfNkR9Fu!2bznHS zU}^PISIdt}?ScQy8e4B&Zx>?B{UQEY!^JZ_+X0_ept4K9+R~@6J+uBWSQlE zMy6v;+MX(71J24w#6v^&Uy}ic^DwKWK)#8D&ve8%pSc(OH|A0cxd7iWeJy_fwZH?s zCJ*D{{J7tzY!bg8Xl(PfM9JQlTs+m;<3o0s`@Jnv*TN1PVV70mv`TA=Eb=S`m|xaN zXkX9Lp!ExuzVjAA|G!Y(=hn5>$p4Qzjn$wC{`3JpgdOXRT7a+i=OPBk zmLK_3Nk;8Qrq6SY5y##ye6|5*c268?#2VvjL7b$J&T7r|L5 zGH>2I)$>CifUo}*?)B>$|7IL(`_Ehe^(|`utTUkAsPq4{{rnm8dwE}T0kx*6h(ogP zV1)SXIWFr%PRNp-XJlUBS@~n0Y3Eg~&|%aDh9OT7xXrt8?ezDNApfmJYdh|nR&anXYB9L{ zjI{&zu{eXcaN)JW`*?m=;5G@}xg86&9O&otfu7(DE|@j(R~a|-N8tZU<8UwxuEP z-VFPT`oUA!Ys5Qefza1ii}=TS7F_T=-qQuQui&*;u{YnqdK>%nUF_HQv2UqEe10Go zH9*{aqODq-If8dGuB3_9- z#+}4EG0FJJkAU|ulgXyAG{>LM%|PV(FHOj+Nye{ z`X2>%M;f)0tfOWgms&2*X?+v+nf(?otf6SU*xj35dZYI5)zF5Ki2=3hV#;% zFOGj53$UI~>w>&bUEnJE3oj%0myw=^vjfk{`E#ji@qW5_oyX&n7V-tx{{lk_7Ga{d)HM>Uf@79^*>Jm$dQp?O8X(y+vJ*9MTDkGeLR# zET1Fxu{zoC{~~U?;&C^;)&uXM2G|p}pZf6!*i)Z{=SrXbIr784OY$>p{~+Lh2=G7h z-~}0fC{0|B;(Q;>`#nw{0Qir!;h)&l_$1zFbLro6-%;;l&p&5-&7M75=FXk_xB7pI zbATEDe2un^8aH)+#{QfM#MqzD^L1jLI;CFB7al{d=@_0rh8l6^oc2b<$kv1KZ}z9k zihb$gu>+27rAyTW^P&4ELF}`X6=2yD5H;xbJssRZ1@6- z2W)WxYc0FN$085#9H%z;{>j;ma2@Fv@R~Arz#4Ay0ew6A1-I!1v@-U|zTISS@G=x3F&K6+>fCpN-msTrAcg{MBN8B3JH>n{xeXj%2_G zIh7bE`$L1obJJQ`^v4wFk^N*Gbb+a3N6Lz2_Ly_(DX!=XShZ|n0rbX<-aUInzto}K zxMub0v}jnfI%oFWi+^P-4?ufQn?PI7c%GQ2Pfr`KvHl#fjz#YH)8g~M`15%Gb6C&Y@ZTA?UGSK3fbs!= z|F>bMXtUnOp6Y$*mV6U_Rr(#cECYc3fr$MFWB(67lp$k|WQgOj^AeVT*&oC|{K;5b z{=X#r6MOXW8GCXM(gz?1Oqei1-D+L>@9F?%{A=tp$H3Y`=KWc7z~4##gYRXXB70w` zfAPMtqE-JAdl(`xH!dtPLA=o0wC+&4ti=D-@oBd}V%#xQ{sQ<6CF+)B=|KB9^ z|2eE&t9&7TAG{8nt;ZhQdyRk11!f*lK0yI`0I+n7P|_`5zipxRFQ3cwd`UlNeonnt z{hU#!L{7PW?W$yDT#(bJP9Wa!mF0`)L5mzF1N(k16QDURK#r2i{dnEg8? z0lp&kMLFP|bKZIF=^JX?v!9oHg!_d!XKYEn(2I|`xUUKq-rE^_t22I1E#RKmr~U7O z=adeB&+38S%b4{Y?9*P@v!6iU`s&bi`7Zp5{Iow)eg^&r0slh}!v{Emc_7Eq#UFD& z4<(@168MiR0sq7tm)QrPe@+|CIbVzeX5p-PY66VYb)DYb@Bn#+pH07B^9pl){4B=) zdY%aPJKsxNPwdA*`_ddh9*8{-PJr*ida)yzUmkk&qGSre5d&RC97nPPu5 zOBP07mbtOlWM)FXOiMJ*PoU;Tzniv~bJXYya27A;a&tN z<;d&CYszcOJ}q_bD|mqVZB_6mA%T{!kv<^RY(?EkH~HDBs) zOqb7=2g-Du1GWtKXFh~^P<~(RrDg74&j4keeQEZ-wC6R}?{s?`50t_IW_%an*M@z~ z0mXQr@MrQ3oGbki_gR-@^c5M;Yi^)Va2d=Q>RT-VZT_$bTDw5SKSTupln z^MAI&w*f5!df z66PBj_mfLB_NjYuX$~L{#KvM)95^5vTyP{hUP7ajWotD4Z!ws4cpS6Nuv}um0l0OD z&5=b3H)P(4d{wW>xsBxP3E%+MaZ$@14i2DCM_l#?2bgsMB?)0#T+8ni&*pxsNJ-|b>co?j8GZ&fM)>J1SjyC@prO+ob`Ww!8fgf3Iy7+ItTC@ zCqFg+XZfnt>icFa#P5u~KaBl3b3@PNEDh(SJ%1F@O`^68+e7xoHRxTe)~CMf*)k+uS2ahwjKqhmb)>w&2UaF!=+I5k1$3djZY z7l>mn>IdWw`U%80KZ983&(NP>+|SQsUXi?@{eI${niu0<-f9jY55&dAN<26q8ujA` zV^2wF>{;=P%ff8a%d!PCk2he>>6*BUvJ#J%Ctj1KCvwqmTcFNLnRCLJ**Faxz}mZU zHeX;QIAAC^U=ZxF_63Md_IL7noAp8F3tz`~&s+g#!J3!m1gS>Ix3{6ptGPsFtTYhz{?hk1c3y#7QLT5P&C(!dPM4(({d1b37i*-8l!;vcr3_#YRASwM&Z zw#1}JWE}c{;XmIA|KtJfuM_{oF)>U(fVgEoaLSY^sy3K&!N>(JE-p&9qJ5`Ez+1kb z7^l8R?qEG3Z>jlnkCPMl+4ME2?GyXN{fQGN)Y2TFc_2O>bxh!ZWAP_sKjN8?#0wH| z67$VZWsB#@E8>b7=Nl6*$+{ESvg*`LS&@`4%aSo0J;|86&AFR@fCqjD2k`7x?F&%L zQN92;U?6+}p6SZ7UHZV^qdrKiGFQl$fM+$42RNTmU+2Q>X}Z?j3#!Hl*O0b1s~e(w8kb<2F|xo0M{YTmS3{d%?U z1^)jZdG7%pRk?Nz4;EBF5fMd25i2O7hzf`TBG^zw5J40viXcU#BUO5@(tAnhz4w41 zorDxRNg#w!LlP3wGwWaLnLJ@LhT?fW=RNQDb6tzQXV0EJlbOBle&3JQ|9ZexrEy)? zkiD~A)1rc0%iJ0I&9v6mTK26yDZoHD@M z7EoN^SNR0wXdBuBn$xRUFPit{^a&&fY?PXCDf{)jwRZJ%=c2HMwgJ+Je0jm&%MBi?rw(*NTB=j4A4^8f3AR5bKY zKoft~0+au({8FpD(^jU(4Q? zZr8mkPK*1J1@aBlFQlzv1w)1mG3x-Sj!@_7HOeW-PtdjG@9TZUeQ{o~uJG`11E(Aa zrCbPQ@6vJBFB~}$j-aqJ*b@WTF^K$*4rx%<<#aRc?ezM25va^3AcO?VW zTkGV8lQZ7?|IJ*_?z1^Rzw>Xj{8y|{v4RBh|8(RTv)0+71@ka?KyUoUI_37w8lXjk z+Gtd(TGD6lzdNMt>&0Jq^VOFh`k#`YuU8E59`*o#;Oe@fuWRhlt*)gR8S>c`Lt1$r zIFsaAb60U(#fpsF=Wnfe@h!pMzAE)XRbH!9O$-d>OQSXF^?#(=yR_p9=K zKjr;cjrZ3V)K#?u)9~E^`Tzk}(45@=*`Kw*0q4<%^FP}jID>vc5wroqu`1{Y*Z=eM zY??KI2z^j>qu$Ng|<#P5YFeqSRWD^%G#ySa2yVgL{P*D?oQQt3kGir)s>7CW zbl4V&j;xvN9GvX21tPoT!~G=IOsNJRqTD5A0 zjvYH187ezTHj?t5s{d2{uahHA?s)GjUf^6aTy~u5C}dB`o{&GGYw2~`D!!<7d}MFf zT&v=a-gyVT&ilGLUvf${3ig`Waou^$`}2A~w)~e5aFw4ghJSn1x%1}tS6pe1uMdU~ z>|=VCer9fv{7+$D;DWbaE7qXQ>o1r12l(%q15mcc+pe~=+qgyst#K{RNLRkc{FYI` z#S~8-w+n4Y<&Gr(^_$B-l%J3-_`KE(sz&}-Bgd zKL2Ory+t*?e|6fcUj}8MZg3jc5Kq8Q0n7pTpQrzS7Oex$kpHLAjdg$ngTvqx#N5h( zVC?4_%<=(LPiwjF&40z?owk6j4-k*_Tlo3;T^Hk1-MV07f{Oo1-^*^04y73V-a-WDgrJfV&Az$?4lglPC4Kgbrl=V zCS%Q6u7S*T&`qrNtS9F-oBW$aIiPhL$1yK3c<(uMSrf#00jtqq++zGNeH~gZ4?yRA zmp!%sf7cHDE?Y6D(r9fcKA*4-mHYePy}q+hdE_!wTNsQl*$iH5SF-U56dMrN_4^xH zka-WtXOK;yxlspV_?aS-(PPhfl$^E~Ie(plhw64hp^9JN*^;GEtXMIWC{Y6MzWXjX z+rs2p6ble{Z5+UI%$qZo%kmXuGsu6FttGiEJ50WqVzv4`wSJdmgkEDgEq_CD+WK$$ zt@L~7TzhTp>t4`rtLw@4)A`Z^`aP{&adJJo{p>!w^O%$WSK?WpOxY3{#rh!r{(-9d z;Jv3FVy$)7>W6yxuEr$=M+=YEdGzlYw2kD0yhNDsZL&3C;zLH=c?h)f*$L* z&Jpaj$ouNNhYaLv2-No$pNso}ZhXP|_AjZg>V%}De$Z7k;o2X~sry@z`>g{`(*`)j zTG()OXU=>~5bI_F4`J&8ts|{k`b_?7jsx!-Q)kPqerw$?wgyj+#a){p5SJ~a)8!*5 zUZ{IX`#PrQl}ixxI$cBeigbqby!4C{e~|(52~Kj2$y29sJn|flo{zFEI-G2JCp$nD6{8K2KZ10j6W2MKAelx zj4`*Wzx;;xerStN+V#b^zt2afZ4s;&a5J{cdLhPAnyfy88e^8D>`y&VyjByG_~vJn zX*&d;P2YyEH*s$Nt|a3V*xDf@2Y3%i2Bir_-5itJkx3z z?yTArxk^^T{ZBrJ-1#0xu3Wir|NZyl(MKNzXItU3&pt!jww%*LA4_=>{SN8{yiq*>1Ht5-+UrcI5#A{l?9IwdE!Z)e}~Uon8#xLD2(^UM?qWiRlNqsNUO zFyD6;`m#T{^^f&Y?~9MzmCL;uSNz3i!;8Q8OpAYl|K=J$jCg@Hz@NIht()$eop|-B z)oE$v|8%>@GM*eu{_l(N_;SkYTHUYTyr#f=z-;Zl9+THK$$$0jTn8N!c+Z&EIbTce z*Cgi+$orZC?G(F7wLpQF@e}?2R^)!`fK$}};bmTu#D4%77rs z0RIa~*mEHTe_l$bTy|sAMK{)8^w?;MyD8_cyqo-i@qy>jWx*DF_3J>q^llXtdbuQC zu2dBtx9)}Z>q3|#a5FC8Mu+WZ@b$Q5DA(jy6ngy~JXrVzJjU%SU$?+#|_bmM`o86mB(*5!i^c_n-H)_-fZ@&2^ z9)J9CaP1t!R~^^yAU{AdK);`24heRezm6}z{L=V<`VD0xc*E1DyAlz-d7 zgNLwW{#-LNpk333s8{_%ca?YEN-I(H`Pf%pe74;`#{VimJn1S|>up!d86#XXV$K#= zmYnbs`v4U)lK+1o&XWsN{K)Ej#fOzEx(?*CV!*Y?|61hvb0EA||{miLVTd0$H) z=MBjDS^{}ri@Z0W?NN)|uSLCIDzNZ-rPxAA>( zU%Fqvsg(gv{yX<0I0Ghv+>f{zgVQkyIDI7<5%DPqk4wf0%7LSl0f(ZK5fq&Q|L8RA zxtsyELE(>Rm|0C5C_u4?g%H^5n^5AfA;kU*70k@lQ6EzBk$1&b*-ZH77*;Rt%#nzVy=+0D4!LZ=d!dd%p4TDYv!KU1uJd%hK)xH0^K}IB-GH30BaruX z$oV>qPhW%V{xsAMNkQ#{v`4uPV7-tS{J?d;TF~zQlvgUphqbzT1%jk^J2w8TX00 z6od0|S8*YMYuj8+#o2^ZoTdyo8JA*gfupf0I24ny?hFR;`T( z3l+h=4?Kwc&lJTQ-?l*Y;q&n0x=^%cytNg5F2#h@Q=~d#es?Yg2urOGH&1(Cok@}=RVwhUv50~NI^XP-1B&idbC`*a)#$+%a%2|_=zW; zF#Nygo_mllUp~C};*0p|tFKHyreuJ%;Vqx6{@3@f_^Zx+_St6*|0Pp&{ZXSv8TqYv zf;gq~5#9H+q(S zM>s$0QRaRR9XU!}70lUVb4@L9XU-C8!g_$}A67)!H%cbGQR3x)j{mtI%;U=a;A30| zthsA^m|xDhG2wYuyE7!~bx$$PhT{nyA3(WcPF_hx=#?}ay^@YYS27SB=QeVAKYyFul+7FgU~=x7+bVxRy|=T1qww3DwfM4C z7d-v)tH@XIaXkNKIeh$6M|4}gAA|QXU$SsJKJPS$c0n2Bdhj7U`1n(Jp~A=btmim1 zSr)+gDwolTdZ0Za8~?hVB2$ayMnejqwo7)RS^v=}_u;2_?C~dXU+z4}aZfJXRiF^^ zJzoMP->!hF)jmhP?>LXMd2_UB!`YmzTN~Y5ty(p_{PN3&`;q~Q56B-7uT^6q*(*EV z$$$9;`tIe=*R5OE@LGD>@?U(Ge31N=FQI(HYp=bAhaY|z)SCu(+;N9_FUgMf?c19? zgnnoJcH+PMk*A(|%E%RMD_5>;`~v-kiUHWqbGuvl7Z&z4S^TFxbC$6`#ej~G|C$Tt zPkVI{=K>7r-Hr1CenN}-wNUHRDyaDOTS?{1zWGn`|8DX>7uNy)+Vy+L{2a3`gxtB* zogqJ6Jpj@((ToGEpk9$ppq^6kU;U)&^{hv3*CWrfz}M9ibWG0+kdDv8fHF0{!^2NKgFN{kL6JA!L50Tc(PZv6bYt;XclueX z8&WSpNB$OBy#&S0qMKZabTD&x5?8spoa zJD^YBzQ$fxu2ePBim@qQDqCN90ObT8dgvjepXC$CPgguZ=jeO2oU!pg*;lHuu3x{t zu^Ghw0tE^feXe|fegnmB^m@q%$p+c{mjAK=WDCeAkq@D@A62I%pF{S)_-^@Mq(~8b z^wCE~9?7PVO=3UK?QSji?N+a|{8!xJoNN`oxA?C$Lj3~*Id|08tZUk>Z8Nm`z7D>w z{t>E_FPrpUxwrl?{&Nmf4$9y=UBmW$kH(6eRBOe=$M`(@3nrH0eP?4RQ1Vu1M4B#-g*~x(0v;SG|LmhM~OaC(# zK;3^bG71srE+9&J|4KZrBr->x%=KlGIkSqmLOBpiL{ko2OiIVOqzs%%%)qIuZiHR+ z*kecH0g6H6qXp0okeuF0IUpIJ-)sTDlYaBpqE72Bc&7Mk$VVIenG&T?zE*uS9y$d- z4xf&Sb$>(=#sqRx_upTjAYOW}Dn9Kv5bf47K6pIC#0M4kvAqPUACxVid!S`tDq6A^ zv(dbrsM4qvUMle#^5%O8uDkDnE8kiJV_Ua?c@TFFl3 zPo%FEla~yT{uh_U%g;am+~nWHOPdc6e-smtZkK(a*A*>VG|T_5P@#g!*GXn5UauH| zxUB0w@PH=!khmK$bYU6$k~F;@XHTh{%6Gz`uUZ0bzIQaHG*{j^V8Ey zZFbY&b7LuE%E{!v{D3LU33lZ@Af5gl(MTZIuY-<}_Xgy?`b^Y+o&|Eg5jmd)-b;-H z^1c!8Ed#zsBXYkHx!;J~Z$$1lBKI4S`;89A5Yfa%;yk`L{6CAP!Do0+o<=+70lMrD zL-+lm=t=Y;`VoVOVf#Wco?D-QP^_RWur25?_60M(C*Bk48B*_UcKp}eVqgah%0*lH2f#m-;ZMxvOS4!gkeECtJ z5aZsjm%+O=>!Dorx_Gi!335N5iOWC0_+W`D)$m1^A^3G|FoqsW!(hq)_4D+l3{WpY zk4#%Yc3^A&t7x-19QDU6#OohcNB)Nk7~Sv6lMk*JN+Zul-{YnBV^IC~W#~O+uIZ7m zJ=Kb}$On>LuY8+wD5{-Qj9qbjaaFujeo*m!#qVrBK>ojEf%LzV|H>!mweP?GzBw-c zO??^iH59+U_uhMrKd+ddWQ0(tP$6^N@>}&tiW`dm%1hd~qI`s^RjdBn`ETrh=Ki#X zo%Fwx|E<3N8g;+;i2N`6@8N&L!NpuPI@EA=T{Y7+Cn>(jn)KAlJKgRHtOZsckkm8v z9Yaqr-z$ET=Z&4FZ>j87A=FKObyVl{wK-*aPmJ4efEW605OOd%sDzE zxt+l0eElT@s3Vvo+{IeK{i+uZ(Yj2U#o>wn8{JR+e}q1$;lAO&WB_#+{Y%yBA3yGd z;(yHjIbwie%;$!lQb%zF4$dz902^k47>275CD%zKi+29QmJstK3(}*RUVn={p-g zPFaOvvlf~fO4ZP)Z&I>T+?U-eUtasFr4Uz3mMm#>zhVL6r|fRkUP@jl?`HWg{V!kQ z`|rOu@dEK*ak@&CDw&*~>O}T zov!=bbI%!hAQ`0`fj;+*^#6_Yz4vja{*UGL6d1oNp?S_Xgy9Q-ONKfcm~EdEfM?kU^vqDMTWXK(OckXe<#;T;#du@e|RE z{BK6?Hz!(zoMSEfImWA_&@mtqUHv1_YyU~~+ZT?3Np!ZjIif_A53 zfvV#@79N44C(q#M>GL=m6^-NPnP0vXkCV*rN5*l@sw+vj7@tfVfHHt`KrsNxfE02+ zC6#sIY3vP4b0a?0jTp*c$$;~e0Z~c7Y5pcBDFgJo9J4Zjav+eukw0a?+9OdIv2ZOK zFed-vYo%}>ed@dKx!2&nJon>X#^~;(oo)T$yLg}Hd8hyimv{s3(l7XSz$DfV24YC? z6%3;c7@FBj(3f&ReFVSmzJT_#*W;UZJ@CS-rI3?+y_31V98bK69A9+6qn&*5`5<3( z8Sjg+Gr5Ka`=RW-A8}Vcw6*Ca1LR|=hVRo)KQ(^0^#R^~`)$)xspn;Ti~q9!<)@2} zKmPcmi4};a^4FC^RNO!@JmvR`7cXw)iDCS@Nrj-j=#7jo!Wi(+_=cxE8Q7ClGBPW%iq*}x19AQzmmtT#C3B2Cvv|z_nVXV z2IRhK1+&0&n+xQ-0Xg4XAm&js3)dgIuHS5Z4o8KmH*?YqlMs{yKV8 z>$oXb%YL0>p*Vb;>$wRhPU3JVXAp!%;^4`1ILJEwgJ&+|@VPh~y_kR#mlF{l!(I>a zKZ^YK$bcjx1L6`>jQ=n0Ypuz&3^!6TJn@(KG>;v|5&&GF3^>c*g5`F9@ds>7VB^s! zj9#?Xx19(?!_Jiu)(=H`{7zl+c3;p3+z1M2*MA4dA3 z$A*I#5)^}xVQvfybz?B)fNX(YyU(J_jAdx>b9=m4{8hd-C+^63FYYW{9QV}iiD!B( zLH(h#FnIh_Oqu0tVt(?+Rg0rMn{=qn?Tgd$yA=!k=9_PfzEx~a{<`dS$pzI|$yd<1 zg5vPvqqwU4fp{wWU+2q@P+UOzU2#A0TQxt5^Q)&rzJcmE^jNtD#TrzTs5pRRf^@(2 z4|HASBx}^DVQPov`%7+l>+`?+_&WX1Yetd(CjaNffBFAi+lc?Q@%85)q6+mt@z3l3 zJP+n1|MR#${kgVlcz|z?8Rr7;T$+*oIdl1{Cs%ywD&qj#8Cx1ke^4?&`u`_#U;X4Q z1@hj2&uJa;mgKwv`QB0>=MBjBmIC$2HLwrmXc}6Q`z^`+mdCCV@kA`ab-#|W*8kWA z{49|Ft!V%MLhiRF_k}j(e_Qgu9qR$wvnJ?Q_5^hIKZD-;PLuy!BaD0(|3?vHi1B

hZga6yide-&%FCV%(E*#_Xjf;A4S?bkiSQp&kphu6X7gc&9B%WNjn2xDY9=$(| zH_j+>e-ybtirgQ?xc4aX|964>A5HF$5y<_q#5nSQJo!JK{GUMX3loV+ z42_7>gysu|6JZG%CJ&+bqxy_ggDg8k@=CvT>8)-QSe1cC=3PSNsXOrVq$L$sj5hi}Axd)#g@~HoV|q^~|8-5vbG!9EW3jL)JmiN*AQOPIWeGw`RZK(!y*;HA>#*#n!Get>7*&F#v8yO|HWKmQ{r z`9U=_95?~JSMSA?qgTv2J9C-ym`^MswDyKK|JP9l82(cR$OkYs0Cm4+bUEVy2b_KY zxo>TNEEz!As+wLK3s5Z1+5zII;xDQJa@ql;J_OkVsvBf$p^+0hSFcelQMz6A#DvY(%y(f!hy zvT4O1apzWWa>DY(Zk^BBefyl*?ACs6ZJpnRp4V#)|M{JX z|3_H==Zyb3`Cps;fA3TO6aW7Fzqc7s`m?*q|6H!RJ*&8SuIrs++%dm97N({?w>|?O zQwEG@%wM|cGW*vqrns?($*MW$lQ5b6ZNGa9 zuQa2|MV)@T{1^ANZbsE+9noX?E{tPs;Y{W-w9eK%@?L9h-HiW=0cei8i38I9SG+_% zfZ_nw2T&Zq+Xk>Qz~lt!2bfrZQwH$6HaP)uI9nM&&SxtF$Y~=3CUK&nWIo zb|~IIoi(4D<5+AH*YjSSfMVqSC)55!*Xc_!)n^VCELv>hZJOn&n4Go2rHh^S`>poH z56c<5b#lkKujlP!%Om?5aq54<>)Uzl%{cG;T+Yv_ziVm}&o8H(a%Dk6WuLY#4N_igjP0PBKFeNq$O^&7|e z0TGySDxK@=xv%k`dVdjdBmM8>{}%G!!~wa@iUX4S;=kemS^2=sSfFz5>gDy$30j^? zcN-Z%9WBl}?EvX~@%Jw>fX8L0$);EQKt6=7A$vm5V{u=$gs!hTAI*1ob4$93_dmg0 zf8}Yr(42PFNXGlso2R-M&Gpk!Ysmv{P!XMeaU}eHu*nC zAphr*`@%f(e?IwdK>p7^97kNqL_D`b0%mh|)r@`T(PIYJ!f4hRCEl)NVu81-{|gm; z1(n$Y*ka-$jOJW{napqc{!RYd7=V-iSv~-{uUy~(!sY^O9KhBEg-Qlct~%=iY&_8B z1*OZKGC&-*{X(}R157M|GC{wcYKkQbc2G_YI{|1-_(z%Rdt$*wyy0^YO{T2E(5b$d zLAzfua>e*nucQ2#?qzHHTW&kI-aPPr&hp3d%Rau{t$m&4miQ&yj!w_+9Q%6bHoNz* z$8PjFz5njN@c-n^?f?H4{m(f;IoKz0r>p1sa;{c0I=Ke!TJD;iaPjFiX-V(zaJz@_ ze$joaUiJjuNXNLQ%?8Go7oLm9bjAS0`?-FO(kvKF{n!(Z?u z~-Urb?L~rFcu|zkK)Vef1vlYg-}nOa^jk&r`cSZ<*%5YjhWe4oRi<$w> z9JEhnAa{a5zwb(~whm-Dgqo$qfyllRv7ciU^6wIJc#BV0GE&R$P_*gmdNmqY_Jnz83lu4A+9 zaw7fZE3}>C$bWL4m`%(f|L2nX7W2se`Q*Q_fczI0lK+dy|Hb6Lu!Q_y!nvT=Bc6|$ zgEzR!t&o_BB+OVU>7pgfyt`Z30Yx|qvwG|9oPo0r&?@_#n@ zZ)1N8EdLq%_m2PB9AK9I&x`@uTAVmTK1G13;;;yqk zNc!AaA7EvGbiDX38DVV&`3pAQH;eJUFZo+Ovpya9mnNdf+(^_Q_q$A8jPbq;4EJq6 zpY{0_?|1Uwxo_`#%Ln^7yRALPxpi{Od*6AUbKjol&C|d8*k0#WTjzUgKfAw8$L#l_ zb9BwKXEl#7jBEdLmaO=nmH+d_z@A;0|NrmezX=7f;mwuvzWk;?pwE`ct_k70UGtOU zOKeO}Yv}KGPh*{kbk+sN0%OzCIg>60o7v~KjI%K3PzKB)_vaGxSP!&7U`?Q~kafX} z1oj0j7Q)E$&?{Ja;tG}t$FE>{7UKEXB7yt7zCj|lLQ*D@DF>2_Eiin=J~Zhy8WpO4 zgGZSYyeC)go7M$r?c7hAwB-z(Wf;%?B9HCw&f@>V8}NTMWB)hfzjrN=w-0cTyjNYY z^#K$IFg5`F02>Q5Jpz;gwok~$0&XY+obdqiUoybP2_z#FKak9s&3Io6uKiMMQwH)Z zNyJn1`76v~J;n5u7&mhc<}O@pdT&)Lr`|f{-evPEm*)+8uWNfFJ~%m%-Fe=;^5&uU z^Y(r0aqsj0?qhqMTW#(8+O6|%ckbKoNayLATKhLFEc6Ea?|eP~S^x9?f3W_?a6P;K za^80*`JdDE+6Tp5^#^?A>a}r_%O@rx?~>&Brx_2_`akoiCj;X+%T9Ixl}+f?RNB3X zSV}u!LF5(ok9)YknEW>&|CbO;$^WI~{xX65UrzoDE6D$qS%~L;JdY(1R~<;?zK}#D zXJI+_m!3$$EY1V@eO)k`aLu|>m8#;=!dyF+eQ!6i0}4LFe%Tt|pvf@y>~jX-9Qyuq z&#?DBGxjh3FD8~!|EvDT=KpWTfA3mAn+LEl0OJEV`0wolm^c7)0Zgx6%L!5r*qosJ z0QCS~X9q~%XL3G+TWbf{*nqgNIKyK8U5x^OSIGVRE7DMK{zbeuV;`DMTZ`eoOEHhJ z{*}!0%jZ`Ok7|2l_umfxogA?Hx8jPog#wd^TdLK(1xGGHnBFDxUL zlm9Eo{}tr^N`d@eC6NEZYJ+%gg#;eEN+fzAiI0KZkf1ka9+0+K)d-QP>D_a4zJNCiwt%op+?>CnB#c6YE#s zoqT><<7e+>@B92#kDc7MoVlH?<>8HZY@h$9wzu<{bWV1Euek0FeP7P+EHaX_KWO{w z`?U7|0n`5@``_}PedUJ#Z;}81-1?uE#{cs6^VT`Z|NC9_2bOiUp4HSfc<)@-?Dz}$ zmZv5?x6$oxa)9?0c@lEPV+X|04v3%~;D0#@>nQ_PvNp)@p4?watRnwclmEgR^51~` zUlSH@u$J4kERYx0&>;38k=rB(lDRLW5bVd{+<{fZ%9H6>&R)cB(J9mE>m`rQVj z#5?cf;U}IlGwi+X0Iidw=PK1{gzob;U?SHPn5&v!ai0+Pow+|-|Eu~x)&E?V|8w~N zvj3g@*IM3L{I@Xx$^qHqSv~+cDj&c*A86}>j2~d_0NDV9a(t2jst;03P&NQd0<-up z?n|D?c4-;}l-k1jzLgm$Fh2%mX9nZD>6_8tcR6M)Sd3*WR>9BD&(!fM-lsY~-N!f5 z{n_!sc}$$K9KBtRWp|#g;VlbpbX~o_^L_1k*=_B6IX|=Ax6f&7k2!g+W6sCgx4gGo z`#OD(;{P$NCqw`L(4oWlKf`}3I2sLo)YWKcNzM=Nz_kPXTr)3*xfZ1*zqutNqjj*` z&G3=AceR#fJe|&ngjDR0PQoAOXbVsVtd1Z~k>kW#VjX*g*IRH-$a;eWZWFMM1n?k{ zTOlbE$=nJlnMlQ2a(xYXznXdbRS_9jc{&5jX~QofhvzVd*n7by)N0ikuUGmA4?q6o zU*Z9({nb32SISkw_w4!UzhZ}}J6gn=|HWso)%|AK{^Y#V_IL7Ma}rbosQ91t|7{(h zlmE^bipJfA3_h;Dv+*b`&R!%T8pKtsC^4!J(#eezzIxf3HpS=s$ zUVMYKz4=z8qQHV!yy6>*Z>MiTubE3RZT?a-`*PE!O{V8ob^E$!mFu(j@V~ls^2o`h z8(q))eEZm223S7Z=e@7(Jbt778-0fCj(c-GJHCte`pzu>?Q8U1YTZc5)FYh#bz}Zl zq5c0~rvI<;|6cMxpR4(#_gozov~vyfU+S8h5dF}Kw3HWV2Q;P~AQ@oe0g?e1n1DLM z8lml!0h>4WgxBBu2n7p2W9Io-JHS)_eOt?k~ooWh+dcPyP0)?YA{Px_`6d!tETh_x|l%!=9__-iWKta5lXM zo4MW0c>#WGg7F}ckAd{|#k6szw=5#LT~S)(2oeamsXwcOWtXJOA(Pn6b;_2~cX?SIewk1Cx1^%nbo|BL*8%X_84@jayic?I0jcmb} zlCb+M4f!e^y+*ORv*}n7nF61{NQ_vs6F>DEg?Bj1>nYB@)_Qo>4$zudS|{^m zu66x&o37|JXEo+=4xxJe&GmRKT~9GT`Te%;N8C3v0IcpO|DC?S&Hvl{pK5@-`R~;K zSw6rG_^-M^TNk7r9_e|uWM$O?OCIPwRMY=0b2P>MGVt)qG(5U625TJCFWpEJF`4*skE$J_t^Kf`}32ip1+a<%n&hjoHo zT%$rZxu%{yruu;58`D$jvp!%P`-OBL>VDPz8B4_!Nf~g2^Dy_(klo4V^X=sQHiJZL zV}tQ_8oD0PXNXMZG3F8sSYO218{5eHKO)nxmA3tssC4*|_nT>>ZzAtElJ^_PRn0CH zHx0C(iPdLl&$HHO#OfVr(sKyj<62lxaTebF59YgWo$LaP5xl`zL4(eHFlyZ%EI4uj ztD{n~uA}S8=2y*67Wcj4ezyO|`2LLhS>IpzKT`w9@5S2xPXAx_zmxwq2B5w@`2Z#k z!0+>XW)490z|#9Pv&>fULCG7*-yZ|j$De`wmnPxS1<@!u=LEi)MVsGuC8jT0p5^b` z*&LSp+3~<0yV=&sn;Y$Wzux;i=kw0zblmd$R$HBGU+c|TJ+{x?Y@6NdESJ5vPQH8Z z+jC`89cS!MYkzC~kN-#bpNsr2z`WqQu4WUPx%zCG>6&%vc-|#RF-2G(@cAy!+CiF? zp?FmS6Hy6_30!25`V^JcAtti+8aW`&C*n`u;5*6rooAA@5jdxB!J)I5xFrA`exHg@>ixiV za^Es*=UO}9Ue*ge%zR;)4?jcGUPCc##a1k1ucGsM;{A2p=VKG|qYWVL+ql2c{p5UB z?vMLM_mls|_ot0+Yk+JHP<23x0fv$D;=lC)?3@tWyDOXD>V4(;bbJG4(}3eZwcWrA z8|mvWPr>8!FQB|n5E{+eg8p;YV8-GVShi{n{QUe(j?eo0x_5QoTMl~j!ydoU*8BV$ zJ$CXlyK}O8UdL|5d;7foe7bgaJobLi?9Q>g)z&_5k6DiEvEA4F5O3%?`W`SJv%LW_IGhWD<1ylYwfKH>Qp?afcc=5GTW-SlR#@5;v!V}Lvj|!jHLbE=@ zFn-fM))!vDhI1*`T~qNs`TWZF+u1+r`?I}&^82OxowmQN|Gg#ul>;Db3{bwm^t)_+ zabLMU>3%)d9D#NGj(Z*<_jhHW@Y*yyz&_qW2y|7-lehx~ugRj0=ruJ8JPyRA5mYXn%}1aS+$3+j};Za=;=Dd&&Pj zXNhx^1LxAQi@e_{P?!HnUBB&;XT375S*H0r*CCUe;-?c^E@seXV66aW5Bu&uioP?K z;JY?mQ1*kWc;tyf%mv9h-H+Az%I%5&I;Qs-LtpEM13=k7fWm9i zP+)O9o@FxT6W;**JlhY$7p%dYWvj4q%{o)pr#W59@!43Plbe=bmOr<clx7$4`)a{lnAU{|4 zuI}S_<_XTRcqJ@09S1o(Kag{@{mJ+J0(JgA@_sMZrrAT@@20-rP2TS!?{{(z;hzQ` z+gtYc-@!J@fvxB15BP^+==|0Av2$;{UFBmu&6vOg`M5?UoZ0q`XAf)zfkfo5DQ zW8!+Q?|bANHj|LsE@klj^ckr8$#>)PlZ*2C#Ytz(UpYS;_simbX58P_|JXht>;Fsl z%jQ@7L~(v`U*A^}p~pI3Ycz}s1-_zuePv@h3UXHeBMUC0*ql@Ncy=J#&)$Tw3sz#$ z$~7j=r+R*I-`4i%{&ez0``(=Le*ShJ-;B>rPTT9<>iq0pV_$2x&d+X-X{*;-K3h)y z-L2)fbL-@~_r7MN=v?*wsP|9uR=NMfhqeB9_Wb`pk^i%N_uf|dJ}3Eqzw7OqFS<%p zdf!#IPdnF$pt*O=ybzdcaZ1wDYct$swz}OvQcsPiz7kiJr&150?15O?0_V9t-YKq? zb0nH;QE|p#0QLNSVy{5H?j`s4lKXqeyWL!4V;6G_yU4YF34Hy|Xxaj-PhNQ_5))Q$ zMMtjR^+o;0T-URdSt~0i*SFESe+9Wt?%P#9LF3N7Fl;{c=#eOFr@gY1v;OUStJm*V z+_!T;t=<>+z4@=)pKN}s^KFbz+*e*-u@uRgNnD3P-(`8uWq4*i=XNbi!t-oad}sC{ zH1uJdZ_ZjwTD%5JR$>BPe6EromUA^7*W5Ms*i_e)sGvJ$$41?~I3?lbjp?cEId>0XoJ#%j zy8q?Z#xgFDKwPGRJEIwuT#N1)`F)T)JwU$u6Z?sMy!WMBrDL@|ffM`q`0qk_$~`d| z*l^+keE;yrZ)2ySX2T{ZRjz_rJ1frv56}*{2ai2f7-hJQ-uE54Vf51VSb89odC54l z&bD5!&!P9W{=RpvKRdf$f4kB9+{%a7EKtSxjh|1RtENYFz0&;`Syvg#HN-a24jOhW z4d3laMe+41rg!(@1#x(8?isv4I|z+^w_>pGGWafFAJ6JF#@-kAHM>XiJ9K~Q{uZCS z?{g>Dyq~kLu{^YVwXd;{E&uG}|LN9V-){fT^_-tYueX1b<*w!Nt+tlm*=?PC*S>1~ zEIj-_1NHtMWvoT<7Onr8o&NuSi2rwx|2bXxAAiL4Lg}K634ZD7>(|%yd&u$}zA<5W z7bnL)z1p2#fxc=3e_-ed#_AcvJI;GseS|5*RoVkr=oeh(dUR0Uh+@EB&u};LY@XMjlVck9(6*eq#cjT^54^oY7mz=M>(W5r{8Y&(~qrT8!Y@ z-!s|AvwY<$Z1(drdSBd^%`ZJ9pI}J~=UDv)QyXWn5-k-=zjhyTCff2KV!ckbLARjO3E z!_|IH5#j?^_tlyuw9qv+bPv}XJ}o&=WNmsX=L=`_IP7-MVePQi%#i&n8&^C~Kby83 zGs>PKPi|biQS4m$R6eyJ|2hjg{y)I(^Q=`qeil0A^7a;dU)y8*P*rZ?q#2V z*4BKfBk+gbn8`-+c<_lhTKE`P7X>8QRv8O4`gLjK9ekZZ(V5JKh>A{jF^NhKweqCrLGc^)e=WW26< zR-~jsnc2_(`R;R{YuU~|=iI3GegDq=eAZoiIA@=|*IvKhGp@Cy{cCUfYumi@&O7qq zhaZZ*1Aom7=J6o6f9lk!8HIf-!QK3Yh)Kg^qBYmBlIVA$ea^07xOed!+>VCt;4zc+!5V%w{KKIuRxCeE{x41+ z|M%))}!l9amL^QTm3S0SazryVqBaL_4ze^_|N z;N8Dw8FOIo4O2a@q~;4WN>yL>x`P4jbelIxzkM#=xQ@gB@b#_|KV313pL% z6plqJCXb`lixtE3$yHvxMTXB#l{Y>fAhn)uE_dBu++S0dHMUtl_v+l&%RMC?lKQRM z%R58H$(Ti}HBRw|&hO);mk9pBzODVE(;4`fHp~+bC4bMA_w4g*#4_Gh8=rO9O3&4C zdsFsF)?qv3!d}bdqBaBM(mF3o*7A)cXX)y4Yw1dIpRPk*rhG-IQl*O2s8K`e)Ttv+ zKKZ0HYSc)ce)?%?+O%oh^2{^ONRuW_{O|BRwpkamRjXG1dfu$*-M)Q$dHLm+{k6Yd zdF2(qe&dZdq-W2b!kWG|Um)X$Sx*Zt02_uy;{n@Gqz+=%uxrQN+P$6~k9Lf6roVvG zAbx}UF77!8zJs5!ebcSj=XXZRHx1Bd?-_GkMA3R8$pyLYF2Q+^b8y_A( zHzuzYotT(6Isx*Llc+X@wyy3e+eH*}4Rk>8}r*BiFUqHVin8GcN)TeyGZ zIQomGJZ9MTek?DY+u$|wcX$S3h{*ewR*Fm_gAy#5;7x88cIzYh29x8E)l*5nQ=_8ICs z@4VAr$FE3{BJ%LV4@;#=m3&UAtZQVJD_71xM*YYmkNDesrhNJG{#tqs8#eTLg0(q& z_wFqN2M+Y-5n`P%<`F_Sz?J|LhE2D2aq4axRt@)Ia+>q*_2O;wdBeV8Hdq^`-I~wD zv!hJ^;d`uMMt-&7f0=SYDEm{7Pe^D}})zBs> zoo4h(d2izv|5V?=*~9kk%{KOcmv@Tim6#>cV6o^L!I5$J*!|eTZ~z6{0J+KdcCZ9L zFfPtG0nC9X@Q2P#fg2Jn%heyTT-V8(uX7tuU$II0P5Me+?%7AGH+Wj|-*t~%uDJnc zY3}g(7hSBJaJ`f$|ERR<(p~yZP+$An&9YkOKlo0acia>B_I-JJpYRuXd-(I!)#1nT zuwfWu_~u%XhD$^qP+jOo&6~JlyvSvm!*|8dpXJ7Z8>B?Ph4Q$r$?T; zniSSGwXaj$Uw--Ja)GY-ea<=O_-kaJciwsa+SaUZoteUQZo26vVa;CF+C*H&tJC}PUzIBlYI2iM}F=Rc}MU7 zxQK>V!+j9DhJ9-AZ@2|#_%+b6!KHmJ`2A@6?zIf}T+hX}i+kJVy!k|o3)r_3yaw}r zMDVXVfcpQAOZ=zvfXajuiWV(;VoI$p7i+mGrNMhuQ=T34O3F)L4OQPj>Ir?eY(1&( zw*43Ay3@HQ?3EH!~qAa{RFK@tI)*5C=zJ22&L51;)a19GjZhIiDkrj-EhV z4c!`Uz|UX>o`_c#ZP6Uyh0EpL{zIf;^VU+l)I)Mj&T9pnvEKESSLcwD&i2MqStv3~Kz7o|ai2L3v`cj%hCtY;0@xt|kH z%-lLiCu`2*SsLr$8YN1U5OB--zW5SYFPGnf2hamp>$gCG0s_`qm;2I7FZDU+j5E&g z*Z*b>aITdtTQ;97N|!Dz_3PL7*8xT^7(IHlKi<&dk>DyCKHX!6YZtTN%yesfocPz- zcX`15UbJnOOAO0F{2Dh{?c(3I;UFt653o({|1!0Od>g>Q|6tYsI|udu|F81j^Z>2Z zuXKW9|5PpKrj%@$BjrYo6+Y15(UgWCwEo9)BS)RtY3h!1-bs`5KHn~vkJ>G{CLNT5 z8s{#n`Y>x%ytYQ?=T?6qdAI2IU>q5XUVvOhzJfRO1L9}MUa$vO@Hy;m><9de$Y;0$ z{hI=3fKLkB6pnwlW3R0J@mE>2YQ0R=HFkS_@R2;x;3>JcaACinU!?xQY}v1p0)_6C zTJ@ilx8La{v%Z-po4)_S=K!vOO~O4hCcmr7dY+}6K2yP&B6+5Il6C9>xlH5u*@kSF z8wYKY5(Ae>ox$Hod!5Uy=jbnFfa)OQrq7URUw-BL;_%6l&&xWy*x+F7KGg@n9UO4d zNhf8DZ`5Xwx&3dAaol+0jlLd_Ezi8)=v!d(F2G_zm;{7wgfsUF;fW!4}`e z|43V~PB8aMti%0$tZlO;&?kcU2it~u_nhII+Qq-cOW=Ww&*=6l=KM)Jg#V@K`oD|+ zhShcae@V6fj|2QWRKVuRT24#Jn&*m?`yRjjjM}fhcG**J{B&vC0doGEbL5=fYvkYk zw#j*#(|Ylky>i3U1M=W3PwFr7q|-`IKG3ml=+58@dFsd0RL+B2unzv=gABXDNmR25-P0{%4h7e%q~MnROi3XP*y{maW^!gQZH#b!vlOs2p(FKtXAR(aA;=iVhx|2mcRmyX>l=a1SY7YzShE*t!-=-c4Y zJ|C|(d%|$ewYisI;droscf&q4`)*mK_qbH?&%8gr|4-lFB7KiR{8v)^7g79c`TN)Z z(~j^T`a3~?_vDn*&ptinlB+McpyD&l@;+2`>#bFul>ARUFZnxsB)4{-F4y;6E;)v6 zmn#)3*~aXboZ}D5O_Mz#kD!$L#~)v$b6YOg@o#HH-cfy;^}5N)A(x)>~VZ$q*)JJWHp95P%`q3(w(Vlyw(T5s1pjFc{&oESk|h44@lD|Z`Ri%fQoNY@ zpDR?5@=v#tDzASm6*Rx)q0!$;!7H12_U-K*o4`)%{r~*L()9FA@JC zdIs0PS3g$QG3h;PwKVTLR*E-!MRJs=DyQYhCnsE>^NpUTIRm+Gmw%USBxg45BmaDT zww(6|S3>hLbXU_C(dGN+{jSCE?)P`x=1s=jq z;dk*>;I|+K0S6F=v~iB+zjJH5j$M;;LCm|j2j4EX4e#h<6x+AYQIq?dmbOIWq07|w zr@DZ~0i)r+BJscDPyauR2EhM)1#jC@x_Du!TCt2YZu+#m@K$%}K6Jc%_RSi3d-g_Y zF?pR-AGb-0kN#fn9JNhu9QBLj8nr{N8o5)ltM4rPxPy{=ib#I-85H_jq?r2COU@B_ zNcDt@^CN5BHcS&~rTRk0RU(~LXLwV&qNnN&y>6(WuG zyNtKvS|w)gm3t=tCO4`K&(b?p&gw8+PJZk~NhwrWPP{6goSfwvIVJlIa_X(c~ zt{`vW%{Sll=OO1hhIyXLwhgN$uW2Xj0C)rbAl`tll6(dD0KWzI#phh?+cwv6uj$$V zhIJR$?zZ7RTFvJ;PVUbVmG>F=XZ(-p|8D+|#s7~l{r@oh7rE>9dRn%WEq<@mu2@Ri zHESU6ckd#T$B$NS)xNcQgN$3SO8U%RBQMO@D2=CYmTHr?N(r5q?+(q4yKdO8a^>)y z>POop7pbjq;ppA!Pv4_+U}>)W=zVg@*!^^*h(84XaCrc3!e7XJlD|L>6FEl1hY$C;1Pr;@ zcd^RvP-r*gJRE>60si4LVwl~#clYxi7cE-k%Wghv*tgoQL(MVM0SxQW@Xaya86|k$ zJ%+yqyCzLz0L=Z97J~l@rSF%*I{%-RD|4Ej7 zyG>?q{7G|le~^(&x5&ryzm+aC)=S%I8>HdnjZ$O6CMi31qZCt{;jWQeRY8C6{u}O}aSHog==J`$lY(5`)tGT>L8C21$+fU8F*tr{un34@e&M z55fWG>v}|aZYwBdD_4^jUVcT_*&F8D?cg1}fnDab1jpdq*0Xf+?{a|Q-mUpAz5rx7 zaeHF(@#H@?IX--H0I}u40rtk9#XtH0IKn1C2gk?Pty?#F;)y4OSS7g%#0l-b&;{7% zKCZdu8Y!%C6><;AV}_67;h*0^R-^lnvrL@vsi&UuW0}|%AKglg4ev*8{w@Y62EnYwDXUQ{E$IlN@dt!*zgSShbAwS9WL$*oYq1)u9VY)u{ z@E;|=mb*uMFU3ZEE9FM7m+E8INP}@JrN#KA^1_5v={j+Nyff}==`&)Iyw&?-Y16KQ zFVpac5ibXiU;uv`b}D#7Mu0ak57vMG{dd0@?yWXHFde|fy}M1n1qUy@@PZ$Y2+CW- zoz=wZz#TRNwga*o4*0Y9H@$#of(y7GbdtV(`}!O}o*{8T{DEc7|$aoW*E@qg-i9A! z#+vVC@`}weX6bh_H1%8Qw_u}uFn7JY`}Jz+_Qi7PGHsc>GG&>(sOyJ!n6zBlPFx|a zC#=-6LfVX9F6|W49Vev8OB0vKD-%=Y^~s9wsX9h*TAI8&U1jW7Y0_`jG8y{K3K_d_ zl}uf-MrJNsCv%srk$Gt=WX}AB^2L{5`L-}vr$3V$2N#g9i=5+FuU@@;ISE$4HqXWL z8Sbq%{KwM)keBGY`18r-L$?NNhWB6%=Exl+uZP$?v2^;ci+^~QV%SckHvEH8{B&TC zaY>9LpdGL~EIwfOWPSl+h~y-|li2Z$Qv%=M)x|v9hGB4vE{^_#9~55#b`AN_x~{#S zBSD+sr-XC)9^bLT_1$gb0MqXc)6r^h&odhStq#Ti=jrQzJNMT=$jg2ggp{$iOvFIA>!nfT2T znK(C9Ce2waQ|2s`>2v1GjJfk<_S|pe8`WizMPMtU)1~>>;+kCB)#F`Vo^yH z5jHFBX1KRH7Vg1&u)t|nXa{l!xG!=B?!NnOKX)1aarFSZKe&NB!$%)|)Q|1iIt5(E zIDqY70mtb2`2P4E^ex(em?OE3=oIh?Z4H+Be6(WtM}G;!yx|<|yTy)kAM}+Y zW$kz0%i2wwwR|V*HmYs8QRM{vOl1xFr`eD7B7m6J~8xU`VPtbG78-mZdUaSKC;dsNeE9YIzN83)~KONi& zR7c?d+35CvH2H6OKu{NO^#XWd&mPUmSG@slh*s>{#uqjeG z6KtY;lDpfbOBX-q7C$|@Zoz^D{qeiR&l$H*-=RN)JMit^1KW0QoO26203RXWi0LEq zzz}!>=Z3FfjgG+h9&(9Cj2PkD?O@h$@7BfvF4m)MyZEO0 z#XgtBe*(Zy|41nQzdGFiw{z#NBlQ17@ec zz!CC&r&uwTpY(P89!eg5ln3IE8z|CPEiyt^wpSxeC$l4_-hI zAh)=B_3C~s0X>RqaDUM_faBm6T%!l!3m_JNJwZE=msGrXacSMUwQuk68Lk(txcEm0 z2x6Vz2p+TjrOI=Qm0y-o-;AQJy?Z}LBYe=rA@z?O^q;I=FKV{IEJ zgw-xbMB8>Tp2)Uw23SSM1_#*O9XodP$J3*$VjIH;={6JGg8f470Jajo5`6jO7@7Px z>{HW5V4uQoz!lgu_&15a;Ol_v;6&O5I|NQ4b_mYFyUPLWyBuKn=e=1mE^zrEP5sQ+ z7s!9`@6Z29{$CRRhl5}Djy3*GABZLU-E(2`-;PI<{qC_uWWW0v(*w-5z-9*%U>v=e zm^F4PxTvgS?_0EJ;U7n*$9|^YgF(Ir?t>hF4gd!r*T}ztOTcy*zKj>(2=a09o53C2 z6SxlI-{k<~0%|@R4fl4;@NYG^LC4|uz+#vk!2J;?Kz`#Z0kiNWG8=3f{=vSBe{hV< zW}E=+KwIJuLEpjN;ClQnevkLxf8Vzkh<_Ll81}>P&+i)tP`mrYB9r((0_sr@WETHm z@4$frele^^t6hx8+BTer)h^bfZM)b`WIKp|d;?&a7z6l5E`kekTEPZB0t$X}a^t`z z{fp0I69hTH>;U>cvX7Vpx_wx@&F~NYzy~;CUO)OY91sovb}WehSR7!uw;CBuOdcH^ zy@TJz-naV+*5oqa$HS*VE`g09j)i})OPk_vVeSHKEaHpgMp5uT(l+Q^*a=*d=ces~ z_%}bG$$Rkb7W_4~504OsI3)jd{7>qVbot-PkN>g$PsP$jlli}v|DT}!pD6x~6JlXM z+POc=1I7*UIKc29tW6&PzsO8_S1~7RK=B>ap#sP-^ zR2|n9(f?QI{C{at@vmdwbpGGllKKBh{Ac7XzybKn=~LLc#LPba_+#nXwW~kQ7JZhv zKbWVRzJ^Ue?h)U!7$JD2?-J``Tnw=^bY8=Iu(ljLA|lL7ZS@yCWqmlHXs*=*ec@-h;`xvwCBej zU2-@590KN|wP{2RMbO7+q{aZ0ENY&q4sP~1Q78C!ait7B|N&Kq~u%+x@ zg#XOy0kPyivK_gNtj3Rr?vAX*=0+C>gW$!*jO}xt&+&P_7nVm5)C<5gGLwEz9xd1> zSAd#*Vq$Or{oix}zJpD{KC%zJLFZuf{a@Da!)knF#0}sYd=g>U=eWs!w>Az4%6;26 z`49dn$Zp~R@Edc8gyjX<{o)VgGsFbo40LwdCJg`RFvx74g?R$V!zAWl*RvYk0*?HHXQ)GgK;bH0LK?uczWMIK zIsM#pSnNLf3i>uNWyYjZ*rwm%gF*(;Z?ISSF4uq$kk?!{hcbQr*JLwd&andACA#ik*jK16eSH7(!M}3CVffei ze_wI&Uot8GgZ}>xn*Z}b&o^cESJVCRzhL|C#J|aTut;A*w*)_oC8vL)dlQ!@wvH^J zpO8~ls8At4K85@uPQ^a)G;&YKH^IM!e*2it6G{w=I3F?wnFKHJ8}JG;1{n%=qv-{3 z688pfuubW6;2ynz@3YT+a}BtQnqy#@IXIakFgX6s`aU)Gu;tvq8N?mo0Ddz}=Xdo0 ze$PrG@}K8`ThRfSCmdfOK1lri+>3i}?lyJ+c0A*J$RmJ{!5+^}G3--=f6k#ZF+Q5H z7w)y(ZS(;A0r)`}M+L9rXK}G__~)L@27n{LJ7wX*1^O<&N#b7{Hr`(-{%0JHf3v;A z0y5|w+;Si^2&&xoqhJ%zHQ1e zeA(!d^dk!MU6G50`)oFpLdg^55bF=08Brqx;eq z!8!er`$x~_9N*_U^kMQ~@PE<2^}WO_%nydm0B<1A4F9GFSnXop-G&2P{F~lyHTPr% z4gja{7h`v@!5P1dt`h4$;Q;&<;1nGUUn!i(^Bexz=2)Wmx8Fk#f+v_$gg6XsK-(G* zm=Dlw0Pt^Rf!hAypEZ9DlmD9kla&95Gs1rh{=o`z4xOGHGh{rvD0pXm8^)6}Ru){) z=kP&cD^q9Fd@^#(k@>8TMLd~!ovp)1&3IpYPh1NgAm^U%!4Z5HIfkwP9}xG)WG^nuLa zA0EI40$cDDbNA3ruAe^IePScPz3?$@j6W2dqeBJpk6eb!h;6{#(XQtnL-*i46O-V5 zkV}j$0Pd~uZcGQ@`rscshPL*7K0f|+{!g6)%;J9;{y%^I|D^tZtnr^&JpdemA7m%8 z7yX`bWArIxI2aG=q3DRn2a6lwTjx9E+JG_gbg&n&&ABFeCwc_)bc1jDA3iSRoB89A zW#|xa0yYGnBNoMX>096ltegA~)}{}j!+>|53GA~^f!nwzaKe}xo+*}%ZTUdN*?0yp z3a14109WR_+hO=OnQygm7W>!%;D_nM=$E`EU4Ntoc7l{A+U`{+C(&u&mnd~I}m5Fxx`HW2mj^=T(oF$I{xRT9T>#t#S1=xfMCSKjO0W?-Lwhup`8#$Si6N5Sf0Y3!x1G+dejq8B*ApYTmXdD1%fKg(P#M$v}#gl_@ z09=O+fc^`XT+F-MnZdttfs1{%!9TuCbPZyf=sv;m!L$i+dTcX%nY0UjN@5j!2OQEq za22_{fVo{RV$I=kg9;;(=sc~36x@%zJx_~&U8 z<{F?ulod4hQ|03~!%{@IV{@zeMGK82*us^j+jAHXU{&I)5~o@Ad=aFgT^p zVe6aD?_!_rMDdU81dGJ{&;jV5vGh`85V9C~M}84<9K3|#Kd1*7{^1>RmhfpKKd~`l zaUYl=Hy)nEf5>x#T^Ik+aL%!4$BhTV@Xs@$AAu!&CHO!Y|A>E;oJ4%A==sD)xF2#M zvElH$FpeMl23>{c!)`)v$3CF_(BIs5nwf3B%XRRF(EhwTw{X9!({{@cs_%b^(ho6go^8>iG;XbU!H%^=h z8A!|x`Ibn(K>x#Dr$6$2)AfV+58Ds&0z8ELCf%r8f6 z=h)`+c8+bHjd&Y5j>uc)OXr#4E@VBn8|Se}u=zPg+y$M1_-i5caiZVAZ;8C$u;;hq z=t(96@cW==1j`}(s}B(WpXLN&`)9=e2J{QyKe_&2bp0Rse+d73_wMuMDwsQ3{L@F# z-I-Sdo1gv>O9w_T;JnFxbWN@ihV!uFLHvVL@QEEl&M@%+{7ly0!fJR3{{#L&zKeg4 z>lp5>Hod^*06q)lhetbu zUt~1?4(tbTik#*=@e+KR;28Oh{!RhY)STn2_gl?H;Ec(9y5~$lDBJ-`yvM>F56>@vlu7`!6p34<3}g`x3{$=>lQ$ zA3cp&Jn?njXDsaNo%`pp{mBDi-U<3MdadOThT%Qzc#sE>b=VX5wgCQdO3VIHOW8_+3fAJoO$6G!oa{}=m zk@e_uU^VPH+;&WK8@UfZ;wvE@fzE+G62!c_ACCW^{jd6e6919)f78eRA7TGH_(yhv zJFp)Q|HcKz0~QCsZ)Wpi(r4oJ1F(qQM~)wUC3ICVXZR1+VRGM&2jxGq7<&R=7yc?@ zeX;!1_y~ywkY|jH#b3rX4DZ1@Xa~R*6m<4!s)r*_!IZ^5!`cIE;d=***g)9l;2wJd z4#2O+bKn~>JpjF*7zZ+)wj&0Q{|^5Jc!z`WrxCjc)A;$3|Ome}=oq}_TO}KauZinLk2>&1W zzg6Y`t;zX+{s#PmL2Odw4r6d);mrC9{S4WMkDjr-*roLOAntA7a2{3%@sE8@{s1x) zJC?piKeyix)@F}`8T4WL8a8+k_qK2N59$HPZgc>~#InXlynG;VK|A12Cw~#U9GjoE zfDerW@B`x4yt^M2|K$Jp z_>YYLe~SG75=s0gZ2v2E|BU=MJpg>-Kja9^?Y^h+>>+%>$1)j|BDGk{t2A>wP;(DZ-zcie4$6D}nF zfUga^oqkSRSTP=eTi_&Y8*~JV>EYjpGvEgB0xuB%!2f}Nk86@&gP!o*bI;EqP!3OUV z-I;d|w%tA+ZQGUq6GCoXfYw}RTaBs&= z4{+lF#2<+v;M2p-rcIEcVZV!PMef3d#M$5u!@ku)4lo|TJ|M>r{Q%nozb9Nk?hH6W zrXpLpCOS6$1M>OsA((FvodFIe4v8I(KY{yz2k|K|zaLyio&fC#PocMiW%3uWInXcI zr|mdL?jYl$@u%Y7<(hC1T!c+#`31!C;b?T4Fx=bmB>uIBCir(W^56UbiTDE0$H4$L zGrA?VWuo{;$3*U+Z^yI$4gXe$*#UOk>;W)gIl+uki5HhdcA=l*PlJ>2>+^hu_pmys z2avx^T#a$Dtd+~}!ae%>q89XIWG*%o_(Z;=M_|KH-~r@<`IBT@l}xP0C$r!1YfcbmvD}p0=|P@ z$hELjXixACo-MbJ+H!mh=V5iC_^+Vyzp&c>T9WpE(Ed+f|LZ^u|6gYDkL=4V{;_+B zDS_igAO48t2Q)qi>H)}P;)wjN zjYWu+hX`k4f5V5!N$eqT>f%2d2N?dtH~{<`2iRBu>;`NGFb_5@rijl1*~~teXN)w3 zZQ6o@j~+b&eF98V;0ucFTmAv@Ofb*ypof5cGpq z;@`Ny^!;EB{tW-vci4)F$bV!ZG7*0pb}2q{`fxnl2hWG$-;Se;)7Q-(ho38!f71MM z_|L&EeHZ)~&g0dl2Y^+67rbC+Gv+>4T!i+351Atmog2)7k$Cuzr3V=H4gcr>R?tt- zi;&s)3enTic^H31JQn*Lz0BrW#81b3r`QbOoO{F0;2H5tay<&iDCiax;uiQNC^oLo zt&Imv2Z+T1iQ>O}I{uXdlJfs3<$pZ+TfRd zi=0cu|8M;se>*uV$Y=D^cz6$<55v73#|Mah0uJ$K;p4_fZNDE@^BH1f_^Oe2U>Quu zlmB+!cmNrQjIFM@^TbBt#nH%#AXbUr0Qrpl0@i~(5X65pJ;24kZNmZR0NDJR;156(Fhb+b~20t0Tmf-Z%=4L11QApT7cFx*?6 zh#r9bk6pvshsgPOaZ%a@-GmqgIRo$pwmmq-j|c~Z@qlXw7zY^Mqt&tWfF%C)O(gi| z`u~pw{^Rig`XF=Qp+Dk7)7wm_kpIs3d&Zv9Kfo)Px4go5__y<6__yQOr1+$XUxBZ9 za+vePD3RIN@A$d#VS&3?dBH(m0GHUb*b${lmGb?MvFsz{EcOX8ck{} zK_0MpfXRPkKRkhogrU(DX;CS~4 z2auzLPD7j!Z)}jKTYG_qiu@fAR+L)!>^1`{3QMZ}qX@0K>o80mcD7{-cfm z)%-s{|L1AV|EaF_f5~M0@2`^oVR`_4l(-dR$MAE-(sA9sMZW@%*bekb;%(ULhJUL~ z&WF_|=g}YF5Acb-4qoW{a0~ZGt_nFmiQu36gab_WVZ)Pek1qjCgD+x(=mTMVV8`jh zQL!2)j_rQzzYO@7m#RSY2u-JgrK^*`NFdkT>d4f^L|3|}r0ge9`Nc#U7|933q ze;EF;^XOB^S7LzJi}Ct6_ySw>b@WPd!{8BOc7}Va!*FlM4gX*tJmTk~-w;Y{6MzJt+ST|KNgLTyp8~wa3c`A{NNK zVtWvSM{e^wLHwHz5RU^4|6mhe4LKLc^LXQW(M5=vlEXkgBiN^1$xR5u|Iu)O;h);| z2lAVX7U>!Q^PlMlvCvpNh%bWYCH{wf zMqVQN10{%m;{wwIOb5tJT)=by>L3sBK3V@0{L>aktp7v)zpMWz<^P}Z|NmM1(;sKr0J{}?F;@Q$_B&)VHUKgeTOt?- zF#KC>cn{Xt4#*tzbH*d#TR@H?Z_(k8Md4Z$d>8NlIz74W_{2=#5846T7cvsx8L>TV zo$-kX#uq}f)58J1|@f~C~vJ@_XQw;CHI*5DQH`^cE9Df`B2=WUUn~d*| z{51;W)!5H$Ar3$e0lowq&r0kPI{u z4pFi>|@= z7vvy*KnnK`HnF?03*a=yInXY|A2Mr)ptoReFb$4CcTeHWOHPHmJBwMc zH_>&;H)kGr{LIL&Al`%fhI^~A8<4?#mwUl)gxyR*epp^P+g89xqJ_L!u7xj;dn6Xf zb@(mhF4)Hp2(8K&%@-Aalu}10Rx0)>OVgG}D)`s_W%ysD@*n(n^6_6^{eMaPqXqn@E|ZL;?>zS=N`WueVBd-p1^Dn@4@{r+}rUm+}rWYV4u&r*k{}DkKPXl(tnZt z*aztB=+wwq{O;&Dj6*^uW7mU2d>`25@E>hPJcQaUb`0$EJ+4J8fp#XB58h-B)`krm z`nba{F@%& z>i@<8<_mCnfVQNhDgGC$?v=zp2#@{uSK&XX7X&Nm#yzwH~|Jv~t_3^JhiL|t(zCV!oUsU|-{J(|oNY4MII)K0a-?6m+4fnx1$OC2r zW0R8ahHn{PvuZ6di}|I|hmo1cQ2HYB92x(g;(?(2w|$fQR+}AQJU~7Ye1Kj+P2m`v zMtlHU!Q%9WL7vyepJ9&LbZ>BG*aAbyOw*a!<{0Ps4%g*(tk~}b#|PN&C!z-g@o%<( z=>f(Ac8@_Fz-$1Q2e@bBgA5&j=hCuLOPZepoC*Bjk<9q* z{wMMOACv#a2k3Lm8;j2gKQuZ(BEA6p0L%@B{Xi}c{Si$4x8vXRfUw&1gG6iNkRWHc zx`c5@kTVSL!5S_I;@{N;*bZ__5dSU@nCy3J@i3bYmwxrX z;s*$m|8_hx^54aOX7vD9Cvdmn1LJ_8>^J!zrUOLdfFS;D-|(M^9$;KxJ^06#p$0|8+I~|A;^TXW={Y@79u>|2Jd&e*@{$v#ZQX zpZ^md{eF$pfhX*0d~0C$X#axvM_%(A=zZjrwb!v{R~K+`Z`-C1gmHk$|3o+-Ob2lF0Pr7+0}T6CyBy%+ zKQ&$dU%D)U|3yjsD^!mB%ZUFMxA{N7{~HyjAku$ekgU zO&>efc7WkJ(K-zGc03ICcHD5CXl;4`@q=hFgrFW^xVJhM{!IsfpM(AY(*w*85XJ#; zK{Or+`T>jw%okvok5-#5U|g___@6(HV~LObCF%Gd_<2PCZ>9QwgQWiN(?C@G_c)~g z8@>(y;E8SH06TxIYU369BYaMtij7A@#>a~ZFrNVVZsgLzAz%QkCMy3;U*I`2Q^NSb za2~HVyvM6E!vikDacTVmngJJ>K_W#Q&|64V#lf-|z5^y;FbK)=J5CpU=oF3AtX7Kr5&LH)?9rU#h(H#;C9JwWllR_y_QET@D2 zRJ8-<>3;uDKa>}rYbGrl)=v8Wj=+Cmsa>(Ov~BXFyxX<2d^L5F{J!J23_aiUa&QR` zu>V)$-*|w2NWL1mtK_mX9*r?-@%#bU3^o@XeG2)^J^$T2KwHsfuH3dZG(L4}&c!P3 zbz*IY*#SX4!1%y8z-r?F!+)@LIlz1X!FWIz2e`ID&?jj4x7v8X@E`OAm~KFg{5Sj) z2To00qFk^{bAK1h?74H~(~o+~^R1dl%cp8dWc@Glf0O?I`|rMeOSuONOPxm_mNq&! zVz2rpqzXShZfxgB(7ObtoI9A5Lk@piTF2LATatRsV zN?s8C3{3pp_@}+V60#CJP=i4i^X_&m>~k&_=G}9Kf71biwt(T@tquED$Kn9PKlRb* z0j@6~r~|+OhJVuo4DY7*+dehNuo;p6hW|93`(xg``FpFH8P`T5BoJonsl{V}cN6wx2(r^a1>6%Uvnz%UKI=-22l^h;{)!*Fh& z3)Xf%UhQH&+P3ik_z!XbJmliv-G&1U|3P1Xs|y$p@JzAv0JzW92h0v|@$be2O#WMK z_;>XH!#>9-;GYeacNj1GXC#g9si@{ zIFA44uXpdAw`?i%z&%p8%ELZ4zSO3f4C(i=tXi(?N-Mt~NY|U`qx45=d;sPHJeGPu z5cjsv@6y-6F?Ky;RT&$fP3Hk%J`6Qy4lD2i$62=qUjTCjG1eIS6rB7W_~&=%qm12S zd;;_EkfX?aIbaKH261ou@o;bFqha1XX85O$#sMzogWE0#xR`gh4gb_G2SoD+M8kj3 z4-m!yrU!)KpY!&vyxnjB`M=l#(R>2L444P!kw+f!$GS2$l)m~`>jB^s zJTZ=zoFsmqdA*oBi#b4f2F@Ga!)n8MyxPTlv~A;oAO{37@9w+!5BdXL4q)5x?{Yvi ze}KyYK|equx`62cuIx8%K=w0Ud9nKa=ll5A@xLop>Re}E$dEywOSjivR{gfFJX62A zG^kO@d$@Sv1Gn9D{SGb9rn|$AyXuZx^Onzl({)74#71^JFd_{20Whkda}yx8w0}Z|9?7-aTgc zx7y_a7xTgGAO{3-Z~H+#z<9vb18f@(FdpDN1WPm?h-L?Xdy5&O7pz>l!XNj;yo=y} z>9XZI9(avRpEgzcee#jK(W!&9P~TsZx>eEOPhOeAnfgf9s8TY8`jLPk-Qi zd2`*T<(&uaD=@cS)pEO@u2V&tDL;09{Uw<)evGWqHr=ylw=d_xIywM-j{fP!0S%wW z3jcN;yKb=Nx9P*YYw*OJI2Iqo_7Ca;#0(f$$hKqt+&+uo@0TZYhqp>=GmZ68_vUO!*`;!i}_gF@Br->%Liaw5aa;U1)}){j0X(= zu1~ ztIxNQ<_&5{Bn=&R+S;~4+h6#vB@xUXQ3dXGJ_y-}@4wS6Ad zwrV9q`uCN^3+Ac4yfZ`32P5=v>#tzIbO11Vtp9?zw|%=0`V6)nbJ(3=&?_{^b|^70ls<4};&fb_}Z% z#l3wl7Utb^t{xDN18AQx4lwy|wc(%I@E)ypbpe+HOcyX6fZF8%+7-MT_BoI2M;~0g zc#-OMvt*vmSB4D${+F*@t+xLN>DJ{Hd9n2~()@{P(x~R6;D1l$hadP@v0qY4j^h>o zJa@&?#ZG8ct8zUpn;X`wq_$Cc>DZ!?^wvDUnO{tm9l!mWfpM^oe59Y#pXj&jyBzR$ z@__LH{eUN%H2k~R=RAJDr8?$!p8Bh1em&FI{mJ`7|6i;zfPuR1=gT_pFS%{a z)xK@`cqOS*rQELCmCLrgr@+l89Ou~or{ez{ZI34E6ZxLDX;ibK=1A3&7ur1I>j3N5 ztdbq-uSP~5Jm~o~{oVR5eI7hS&PT=u{9Ss0;h(;X9ANznbOEr9O@O_fJ9q93eE=@N z79fv^`E?mzz#1Ls0{D*TmpoTy^#S7pc!a*od}ORCgx|rP&xpJQ)&)f`fUm#}STwyM z8s^<&VYm+-kA;2roY?_p3m69&?t^tu4+!Gk_T%9nZZLjuIlyr5*2V#*2e3~;4jX*O53S>mzQPEj4x#Krj33d z1#fTw{e91#h%eB1z&OA#N&R>KaWC{M?0e?OY_H>pvH8&l7)y*kfGvP+fGz+JFkS$g zoH2*UZTcg)u;&7srWY751Z$q1&+*$fj|pq?2GZhtdvH65 z^H}>X&SP!6x`4|ALG0UpkOTgVAHeW$91!LYFrR>7-gtq1un%W1)L1`y|6I)#pRezI zsm`amYV8{N@{4Km`KKTIvcF!n^74$z{^uIil18;ENsWr7c9$+zsPkQS%ukW`@;r+f5=T_u6^d=#Rq`QH2hPWE)Z6` z?Hy}77B{%(Ty6+*fy)O$-N1Oj%@Yda0vGRWyM6-W0Mi3#?_e<>0l3Ep;OqRV<1bhc zS!0R(&_#=M&JT_E`{R8z=XcoPf%0bO7p0ZP{K;)=rugsBw7%4@_K1{u;NIPL-IlL& zo}AgQyft6$;}-u{UY_O5E3#ac^~OB8THasij&EyJd}#l3PuKIBY8>FPGDUTqR0Z_~ zJS`&z_0wE{&9YZ*WY^ZG|I<(DPxKx75`7XJx}S4(g1>W{d!er(*BKK`{ExW;;Q{<| z_y}yx8}bMkH^BNE%(ss(0UsWIeEJ=I8$7thFo8{q?LjPp`S*$U5qAXhZovkY6XAd$H^kxr&bfGxwQXErJYcmwvpp|0`T!gd#sjpM@qvr?XxlCazyr|= z9Du&GZe1kDmvsqd&YY#~K1aui&GU2p)~LTfHFb&1R37g0Zg*+fxW4N9m8Fi#vS;g8 zljoZ~>D8?C(1H63-n!$uYp;6wq6^Nu;^GU>`}grG|1Z7h!c))r_gUv>&zhxbfm?1I zRiRX|)z8$czNaZM(#OimlggD1AAeMOy#BJx`f{3lyODf=JsI%;Fz#{yeT)7^ABF== zM+o+Bj+^W}+S-2S$eJ;Wk$eIA4)g3YzZjS%50AVY*4)8Qz}gtdWc&pbIDoi4>uEEe zfUTRwcx2|-xB2(cEs*12nVdwfLyQ4C-;F;Q2jG7o4#Ao} z$BER2^z24@C0^qU(cqipBUM`Mqf>_vdLo=N!fUY+av3 z*KAy(bN#K*_5W6`k}sxDlL7rck!x0D z`K9$wKkd{D&pqd?(~ejC>vNx?<@5{AJ?EahxvuF@sz{*;PgJY;OOv{f9cWg+n)l>m z<)muqBGRUDJ?ZyBFPT4kW`-T$%5kuVOal9^Y+|2&Y5k6E;|TY2N4w4M9A3B=w?xj< zr;$m>YwQE`b##4ne%8mUu6jH8w{^D2E6SfgzZBB-@$eI{J~(UVux5^}!^3)6_!7}4 zuqVvs2kR7U0P{Iu|FeEE^BclJ_zK{r-vfGui#=<*KZw~=Vth8*Iag+z+%^nThn;ti z^EuP=sbk?j1M8}Hx!XSGRo8K`?#g+1aO>6|eE+G7dF*_~^}ye>*F5#}%~E^RxB1oI zN1p%6Rcn0wFV=bgh7B1YU0-=#nm4Q?H7k^oCaTM}Yf|4+xptuLW94@}Q26fYxv#mp z^9ARfTU`788R;0%>bU$nQJ?yh)Bg3ZtQVel?p+TSzN>Z3N@b=rs#Rq}^QRu)+gS4f zYL+jd{=h2olEzQ_fAqf0pEFA~f43>B9$+%qbXc&ybLWxxHx4))vq20ewtq-I!Yzl& zu3e0mV?6CHpM&5Y@Il|DFVe^8SM(|L0%C#04&Vav3Ojb}=;st*3lOsh^Q@f(2N1)1 z@WBWDI3nW=nRf_ZKYBj}A0K%L@CfUhlBdiXXXF7BbKv^ZbPdgoYRhiZd*Pm97VxLz zv47Rifxl?Q^li6xWiZ<=9;0s`^2@t28qE4OxpGyQZ4Qqiv&~oM*0eR8``veu^}mqk z-|DklE)Vs_jhi$U8yUyLd%-sX=HY49^u<;}=VwlcZxr|VcvDr^PvxBIQONz_Lk3EZ zH(rr8O`gy^KV8F6v=(J*z_LVlU*$nd9Covu4Ro-`4^Ll7HF) z)hj$ys9O2bZ#+@G;>;EeYya_#+Dx=zy~+=3DI+hoYAOTz_E8S_TKnKHp?1FM1BdV* z;Q*8WhcFv^yn7;_9z|KU(ExydoMqsc})hI|7z^mFW zk>BV9VA~3QMYsSxftUmSM0f*#1M!8D4~cy+gly;>ok z0-5a=e{L?d+t;XHp0>5Q`d2H)SFh5weYLF8vQqW;<*eDQ{u+20%rBU~K=b-Ewx>Qm za<{?%!Ue4FNq+w-|1)2IJwxaB{Z!ske;?SdU!|MaMue+&`uZ@~LzdBR>4)?^VhOCp z$C}01|BOY(_P2s>0InD?V1Nu6GQ^MX@p(9e^|H}1kXgvJ&5AE%`7YIuC_5?Xc2Y#g z*ZWXiWrthT=l0u<-}QUw;^+Z~7kI;$@yL0K&kL4^b7*|-k3Yf{3u)fa%f#o z7ysXVr}nqvf77Nz_=meP3UXWVPg(C{U+3ajx85(z$FX+pI>o)NJ+?+=x?+E2I?h+< znxZRKSV7inzMkgnEnBucf`1*Wg>0wr4w%n#iDI6D&c8r8V7A)-CRj8w$)tMg3)__@@SrGvggd5Bm1K| zCh{ZAkJ#3@PSt}iwruFN(zq$(gRuo_mU~dzG^!`PyLFMN<3`KIwX5Yfl}-EhM#cm( zUjX=z@WG+ELS27Ba$94lp5{_%JME`vo9$Ds+`CWnD)wq_m6l!VzsM-N_b5N?R{I|t z25xZ5@2n+?T?04#Ccpd^(I?Oue*RhYhV5{H>J2}^1)7(eUTpivZ8|rJ@`29*zWu$` z*MX4#KK8#=>}%Pm`1f`6bgUo3Jh(+0Owb<&0dBwYrc^!kZN(;DOp@lJd%aHNl zJfk4#FbjI0x@KhF3oWS8$Eh$|YQb7~ia~XUTYt>3qwdK{eO}wV{s~xOd=E0o>ZoP3})+`s-$d={e8GkHTGH&=_KSyYJTB?vM zNQ_|Xmd)zt-KKr=7uCK0klpEizlc7sHah!`uI}pXncm*1I{z^!+~=_@fBf;gVl}+{ zuIGOL9se8aed_w3={^A8&!)Cj1i!WxUqqh!zH`Ti=KIo!m#O^zL9x4a>-T>7UdL^3 zq3CALzFaHsk8=q;;seQnkPU#WVZTd>nt ztXS^nODxlz32b)e-eL_N##~3_x5{$0*NJ(c*GJ02NWE~8uN$G)V|StR&)57t^!~Z% z{Tf^STF3Fv`07iUI%TqqA3NIj@xRyOO@B`BW-8+uyMnFSMCE@=o#UsK=KHDcfAFzK zN^L80*KKLJa$MQzoPVEr_azsemo<9tPaZw}w11tUCCjB3pI`Zg+&Mlide0pTYgBmX zx2AQg?bq1p!PX6Hc~4cZ;Nc6XUFl&RPgP60zSK@WdB2B0XVCOXf>3jee-*t3z$pf=j}hq&&msM!}gza&B<-Ys3-=0id%I4EuGUWTG^(@xBa+Pw*3&h z{HW)7o_OU4{mj-MwkQ^36vZbz=@-T4RxRIa*`j4L7*$+;r+Js(QgkjRzo>q_NylVw z+OW*y>|yt1AaYicZByin)XU!e1AM=1;Dt6e@{u{+=Q)A{&S zUp-^;zR_461uV~P(^J<@b(urBMoRvg+^cGO;|3k}}=bU|J-b*e%ztWA@UHe>#B6s(x_DJa& z8WZ^GnR?asYFzLjxs>DxFqdKn%@OR>uDQJNQhVvqrIYm5eCy9NRycg%XEJ`&FquAi zoP0HHlFU$lL8MHU8Pg{F$2k7w(H5Pn^vi_GMEzWN`C`gM`C`h11j~5+TzHwT=cZ2{ zFVkX`NqS!S63( zei^Uz_|d~<+~{GEGHR%dbIVBGA2~$ES{X4!#;7hgdiWq2HGH6q)H&cr4jm{X)TbUP z1GF9>!v}w^rGI*1JG~6*FT>KyP_2g!>?cDg13vT1V8t$LaQH>%;$}TAD+4uNKd@il zNcpU<4EXG0`TUcQq~Aw&;X%5P3FSb*8-%4I+-AvjwYpC{qU6nzPYi?gv zUq5aBWDVx9*{7Va#>W@jsBirUeh|f^wM*Fc}wdA%6s}53ZH$KqHX3Eos0P$zr3P#jG{5Go_^`1 zwU(}(q=#GHcv<6O6g^JSaUF*h#a4H}yd-by+z*s)>E*50UJ^<-zq}}Kz4}5z<;~77 zX#VY?LQMV*zjV~vDeAX-!!0V;-_Y{xhsFZhp)(b*^Q_CI7|@)R*T~H+xyf5Wd=>rM%X$wY>g(u(Z-+e{*?3e=kaTP4DBi zj+rRW>odhF9eL)XD72ZC_ATXAithWx_7AID=x3bLp@nqLD9v?SOM8kQ_lxaot-9Oc z9y_R-vX|DT}$gxiCnyJobYYeCv@(}R=GlX5o zjt8#SR`(;Np4Ksn#<|+MCG@j)J*(}Swx3?>{qVjH{eJqkwpm-h==YjXY(LT3zE@9k z@cwMk{?xRtw11|abZAyz+G|Wt@6}VEw925W2Q^N8utuda`^%QNe{YdOcWl4?=IcMa z?%M2+Xt_45KPQi8t_2kP=V-}!)AhMa+WES{$u5JezgkfkE!5qvtQ4Oj>BXu=6_|edrYK`_Y8?#!~IP9^;ECY@o7%c z&(MAe7x%k~Y=>Ptk?&^mGdky9q+ifC5-mFZ>`98w*ZpLTit>aOovT7>XkXKLD?HWl z_Z7Rhz{YzD%$1QnVYbm4H&!y$O%=Pl*r{lH24Y_lkqUH45*IadPjw`di zeC^d&PR^VAnr(O7e8V2q3-*+{ztG-t%ELO2$S*p-z+TNIN|vK+gYx?Q{~x8OK1U`> zsiJ!|Uw5x!-LK2(e#xSR_R`nxxH<2h8**K0vIUYYkZgfu3nW`0*#gNHNVY(-1&)^% zNMGB^^Pl(Mp(|abH%Fn64@AD6l9Dat{D$=JpYZ3-+vQVIqTgY>^Y-&8Dba5r&iO-^ zkNz0(&hJV8+M%lbVeJs_{PaU#Oy4@Z89E$s{-5skkGQ=+GsHW8A74@B8P&Uaz*Q-+)JP-tR#%z8~+r|9~;R@1OrQ z?DgyM_9C+3D9#s(^Zjgb&eMRgem~xM8YtHHkHz`vG1`agcQ}gkDcNFw|G)mczMxpo zpK{Vso{x8ZeF4*Bv_IO`hNC^wpnCnIJs-1!==G2Gd`yPd>mT*`=`mgq z*N^oA6FDENf%$&C^RXI`@5ehItAY4_-19LS!2f={^D!RK|9-slF&@zWe!TNB9?<`O z-1FfN82Ntq14Pb;-(X_r!*4M1{ct59{e0*RCU`#d2GYNuJf9N%FWElg|8`*&^K|**?*mCyAeA|L|KN$sf@H^54QA)1%*BN}=PV|Ar`_I57Rc|Mv4C z8vH-){^OmO4N*Hld;5Oe^HCcpqxnLNNauXU4<$DaZviG3yirRHEhnU0q5qHW@9cXk zoOWuCe3$E0ZcaJrlwv98URp8b;;X8qoPT-Mlz*IBR*x4s;p9_pJ}vw8SueS-!l_61 zYsc=}=NBk>=1FIqoi8P8o?0p8TD*VqOOxlE_WtT`&;IyC2xQ* z<+T|LPpH;uU`nn#pF8DWr#*i5MVA)IU#{9Um0NVo*0}u(* z(7MYjFJyb6U90nt-JKqOrK@YSKI!z!uf8fJ=j~6N*nZ5ci$?9*b<3BYS9_u7bzA3o zpML9kqqch9;LV=*&U(*lnCf{2XLw%LaeKWB-!<5`ZJIuj zQJ!o1q}QTR9i0!c+}09B3Uz7Ms@XA}lj@3+)&H4t=DGKt*zo<4myh4Sul{0@ky}MJ z?-u!CkLPXLC9>uZ&s)AjWbv;e^M3KXxj&0c`$^;-eYWZgL~>0%D0x0k^PcV0RX+Ui zLzz8ij<-nH_@FFayvSqCo?boQmiKh7_WCs{FD?DR{Ur}?!9TZmRjC@Mo{%+n$y0kQ zUQuGU=MDSb^H%>ZlJ=X(Y`w=xKYHGX??nb}@w|TDiF~|Cn($FzS{TI6}7FWf)vKV8>k?$YIT`Mhr*k9A#HvvK&~ z0bbo|kM?@Ed*+_uf`TRgeNw~sKd&^;^A`OYx&NK}MKpZ zdATQxTrg7P-y=Nl^f4m;8ZUCnq=Vi`lef!B6W7YAqgHxn4_YZ%K3gqiX6*KE8N5M0 z?)N!se|q$zapT9!>#x5igFgGv`&QS$OHEDH_2=h#{rY~m|FH@Wx9j=#nkUb3YEHH%Km*lluIW4;CV~6?`+@edB5-Typ`IArfC29SUKlK?cep4Yf8>K;N38G zuXow8$G7}jTy57zGTI?nw;YL40H6&tc%Zqhcr zeDJs4sUx?`2@`+RvRdzbrJOThrCj{+3h#*R{=-+Sez?UkEGZ<7x```lv< zG1gJ--1!w5+W!+U;jd||>yYsbx?b2KdAHjezqfp*QL%W>@Q<5|-kx{D&K=d1_a4*I zN^#jk`DBE0<^sj;kBWmG`#f2`eV2?|^OM(i=5pyf_Dk=h5#y!DunE#|*eoy4&;@e# zps(e$;Y+>9y{{C#caM9&vgh}b<=x-B?86R7iCG7w@rPr)S-NH!Ys$a%)|)bY+O=r9scy~cp=%Oe(dLsAPI|OM^XkeQxu%NT`!&ztd98R4+TVvO ze=hjdlkb1uD_ej0LuSrfNF8OE$ z_b%CcuJinR@3lkD=y$+7akwXsFBG}If2zm2weaUBef!D~?LP+&91t+A>(hCx{mi;< zx)!rHbH-OvrCjMzVecSYJ(Gd-`0K2M9~Dr>bb4f}4N zH*50_Z{f04e&5u!ay{;U#E20*gEwKq1W%vC>oRr}r zhj)5^#l>*Nhn7+*6K)%`&C_*yJzd+{n>+U#uUEI%z5U9ka4NDv*U9yCooY|lp!4R< zo9|7XJjp9tqUZ~qUw-k3x#O}w+w1fTdo5X5QF$k2xX5XvMXs8}Gl*2tzSNv&Sh_=o zFZ;n?!w!7;ZLasO{Ozy*J9zM5zdczGxI@25-d%6bmK;5|%4NNN_fGr#farZwyp$0l zw|yyc*YthfN1uMC>vjGlyLIi)5rg`Bi|2piuc^9s?;f7PU*A{P(oV<1Lh0K1#hU>DfZT_-=Mlinm1?mY_Dqh(t}^>*!HmXd9HnR?77zs z*|O*rFLQDLsW(|*Hr{kE-spWm}*ug6;P13&#x z*ShQJecGp&e5mV=s&3@HtLwqMqwB_u8a~wfFH%U3&ke^tt}8yX%08`snr=W4e-J)Wm$Q$*1v4{Zfu;UyS;hW;C&& z#!gV9B8Y-0(qyRuQWT{LD4?K%f)xRQMX@2Gf*>N@iVd)%$i46WhFu@V^7OrT&O7J* z&lzWT*`2vFbLZaQE#pkfspZ%sC*^Ln!%8MZMn>YkXhpxQ0roKA{%GvE>_a6Kxc>s% z72V;<`JyLsn)UKqsU&i>c}|AzYocXw35tKPXQdGCzJ?5{udAiH+DoiT-6fLuTqn3m zmzGRnOZ@qd--pHqEL?C`uYKkc`}FI<2X`(MO!MzOL_f&delK(W{f_2(fbfrL-Zk>b zuc3p7^VOcp%*>?a%a@bfiA`~Faccj{9g-yXz0;oZa}-~3l|rhB+(g$|3N{)e@@#T^u#g^408>1$;P2qGJ-c?&jLBnf&9*-4_}a z-k#_aPUfN$zMgE$BNGd0L>{wiS^;HB0F%(PcDh)F^ci<}bhe0xZYB z{q~!ZrO<0A7#r@{#=UlSHdbR=(%&O!?=Wwft68FdO%F&B*=brJb)m@X;zs(TxQ;Cf zPO{s~iEfSs%K=@AUePf1YkfI?*9x#*AS%H#g8tUw-)|TU%T6d+)tRPEJnz{`>FC{jO?# zfVVLQIwALoE|GhJ+?^dvTGHP?I=ACzn=hT%B={KXZ7KTKQgE8(@kS~2WOeL3%{g+O zTn?V0p#4>}Cbx>V=U36bqH4-LewGfMs;9Er8+7SLBi*_~R416JQgENSy$kjE)tEm1 zS3mlFegK6YIzyd$d_bPcwU!Gdq>r_4e>{bM9!&p) zjRjA=v2?%xvdX5W?29)z@x&G0RB?s2lwIX5W!HIgSp&PqrqPQ=FLS4Ef2X+WTMDCs ze%NTh+sCdFRf~NO%z9O5zeBPPmx%i$%AU#8DV+uE5A1*fn;7Gea^Gu=6W>wy2+MEE z%F7l1EO5J@|1tk~CZ|`t&?V}41jbN!No>3m*D347P1c>b&FQD^aI(y!cI8HXxx?!; zN$bm7Ynm9g@t)dd`i~0z71x>1h_3=`kba){hs~!rAyr4Xs~EI^U!)jbqgHfcEQY_~ z?|6Og9PT}?L7`H)t2l6>J1=mZ|3Lm}9zm;C=4qwRbn;ADFyqjjTh&+Z(2?_vwEtWa z?YV?`ZY~kq_mSKpKsNqi@>vt*ik$%dDHi&xZV1oFJ`NN)Ffg%{l6UL@?V$OdBDAUZ zhT8CV&#C<;~8{ z&IF$jd_Y2@np@OZA3fdbwd`lHi%&A_0V#xg+A;qgE{=~yKgMAmvANyX&dZYrY^V?& ze4E#bo-PnyP`Su=(0jbDf!)I6sL!x5Y_%bmhh$u$*{LPG^Pt=fUsObJI9pq$H(p|Ni&CtFhsGGSBMnYT#JVi?LK!SHli~en(M03dm0n?c>vrF<8v8 zU6GxYP6tocQds^4vfh23CS}&p#EcsHWBX~EoPL7bw&c(xGjp0f$5z?qkRy;CSo1gD zctgo7=qo)>E8c+J@YY*z(T5*?NWit2Z?PfB)zy_MDk=!{LpQ(<0KO_LI;!}`U3;(o z1&xn-EUm3qKR%EN~b2c8A}`a8u-g#IE9^l@jmzu<>Q(T=~_ zSXnCig=TKHEp7wrD$EPq3;LmBAOoRiK=ZC$yEr~RUah~_2i&e*J9_4sXBc*ZL9T#) z@QsU$3qAGJQ!ML%yUhuAp!e(7kNfuR3p+{C4;~XcM(FooxB2#u&Htd^e)fzNIlFf- zXa)UJ6#dHPh>vICar*h^pV`dJj3-Q(K(lAhhE1c!0(=KL2M->s^!D$+|9&6+z&|~D z^uQYN+_`hroKKrJO|98aKmBC5pPljr>w&YhwA)gHlKka4Lwo;Povl8fTcW!cjVnr&=s6rTR)KmSS3KKrct9%z^GvW!h( z?7Q>tXlDYxc-+Tfww`|Bo2I5Fk^#alOVIZbm^kjA3h1}YplbP zB}*9Jhs=>V2OlZ^2mgpqk%NMQpdV<#f(1%X2!?}gcQ5~VyR+*P(r<60_@8bI@9XJ@ zzeKIC%mHb&TIIXZ?`dTN4jed8{T)03Uk>PpeC*b(oBDj|(xnQ=0Xu+~;Fke!p}qO@ z=PUUMnTfF#7Z(#`Q8WLz3;#UX{M+07=loOi!|3y+mtIoq{KXevDEe@JZQ_u$49M=$XL+I&|8rG*#E%O7(;>R zYsk<44f-(**ncu#{PfdL!xseEq~wy&133;F1hZFy4uuQgGsIZ12H-EqEMH$=C3D24 zVNXv_$V$aq(818T_$|hO&kMzFT@3zt()riRAMj7h2XlfwiZvfSdbG0fz(WQ;!dhTI zqrmB5-^W`3`+kNiT)M(=}Gy2o|UWCttoOe%~+T-s8*rva=L_U`|07=3ZaaoC5>FpKf7c!SLZ=T|~DjUykfoIxBOE zdDqje^cr|bPrq6x*plEQ*lE}oz|qH#mo&#%{k?h8m|>NZCX9XJyOxay{TM2Dy7KO< z4DnCG?+wfezfv{ZZLQv>{Vn!)Ev zUY3ZYRb6AQO3WGeUiC1eAm%-_A{nqMmSF#HRQUD znJLYmGvm?4M*ePNA>WZAwG&?Ji_>g#YFUs^fa0J^bDn{{l^LPf&74Y>lgHBd;lG}l zIBuk|!(8jTzFPxrPf|-9p-W^)pl0pL6`GCf*J`$GSf|-4Wph%3CMkZkCO$S=BYtj8 zM931&5`P~}fRCppQ0kCCe@#T_QuVilxRsg>39IG%aTrAb)5QWGB+qglHu zO0!1Vj*E`e#6*T^mIW=AHas+12iyOb_w{j>93~YlsuZdGgJb=Dq()+vMrxcB1RAW8 zx{bbuHJc^x@gr@^+FAd;4?dK~P#ZPBZDptp5fnphh-yi##aACtXX!sT)K&WThFYCx zl;5d@GO3|d(TMZG3#;MM-pa!8Dsnye}74o#YN$D%)zmuoc?#lr$J@@tp zAGXqbJhs(0#xAYCpSZA9uV1yT-s~~1?JFI7b@;q*$6jO2{zrRGNW1TOYna(H&-VDd zPut19@m<%QyEs_l6?2N1-AW|)rI5M5#7a6x9Y51?f@4wdetq|tnNQO>&a>9JIoRmj z9c^@WR?~GRqm5@d+s}F8e3!rdII3Oi?@e7kO}TtELUKaj_bt69xkTcZK_1Z#$s>}ew?AuD>A7=T?6D1}xvfvhfv-2j;ib+xZ0t3OX zyg0y*cjz)%WX#2RvuA$wkS_0j+}+%}b=yJabFGeue^~NkDrC%AGFIduIUi#c@BKDg z;%yQmL~hAD62t3~eSNn1%I7+gFRw5DcuPD6CytD^ps>3gN%)eyy`9ii};`GEBK|2r=;&PZYOs_T*l{B+$w5ndIdizk)z=$G$22t^eS=9 zie~*o7_5yxQ)c9hh|?>ey@s(O5T!`pfDKl3;Z;Q{q2=luGu6LtClo$ zc8dS`SBd2!77ZFc5gJD45j*cb&j$||sIkKahaCpL0&K0-o450i!AJRxmRg#LIbNse+HSe$q3iA(f>gFU) z-ngDOu3y7~4LB)b4bL>2>}Tk|o8zip$lLlt@*n;!xfT6(F#oiVd0JjQXBQkrJYTIR ze7u-{vF$jwq?%WhUT3Yygo*OoANMkUq+_0RKw=TPEM*H}?NRiYm~S=P;9MiP(81cG zR&YmK(D3!L-R))`x_y15#8*ekI*gQ9?#KdSlOy%)fA}~b65km7;fM!|zf~}$_>b#v z@SaOe>=>KOqy1L$;Gj)xy7w}F`P(QK|Ad;e72-#aii+ZKSCrJ!oD`Y+iDMEsM{y)1lM6;y?xO$S>zZ#Z`Qy>Kvb_7r$&{6Q7kh zieF3uf7<)sJY=31n};Uw5DPoSYr}>OgYSyP|HgCX%uzM^1utH`c9qx0Mzh5F4Je}3 z$4htouuS6e+Hzu-${Xxjeu=${FS6aH9PZhxx5RWha_6q^@I*UT-jY|W@&_9v4j8+B z1OGaD0#BUl%%1yBbN~MRdE&&091#)0@RcDJ2zw3jOtFX5*kSXnT@}rO9q;y!dH80- zsf6Tk7gJx7+;am=wg_T8Gt&ph`$Ki{rB2jy0Cis+vGq8G|UK3%#cN$e5?yLh9K z4@(}DSz?~D2eH>6cVIK3FN19W8wl@V!>o;s;l+OU_CI2M{wqT>E*0*&aFe%GUEyt_ z1d=Nn*fwM>w|ljNq6hu&6+H<3gcwD=$VkMqOj4?3Zxt%}kM>dEziC+vwiD>X_!s$l z-7|j7!Gvw4oqtLy-;*nO1_x>yd6&e%C{~n1A{+U|A z2MY?7oP(@uS)hvyHnZMtR(^Wbe~a};--c(F#K^u3&#|-5t-mT;P>r)(bW%n^DNmSc z&Y6dgaklj9kavYm7sv5{0RvPKpDz5JY-eYubO6Q)Ul06=@TJ3E*ZY2C{-fC6$Me4N z8)!gn?Koc-ReYH}4@;2%sL!D~cHVc6$GI%#;ZBRV>cmO4&gfUZ&XAGtPeDe4-w@M6 zf7pZAzk0u!*sRBS&8jH&^Y(aT|Bm*yI><1{57gMZ*gvS@cUZY{rIJk;8)Ec`M;YcC z`UZY5D=RCdgW*pDedt@_2&#WyuSfUq>M%!#zV-eR#Z%Z<$jd-XJs}}MwGBTS;sWrq zz@KJVXT;gz)0J2fFI>0~K5O2&b0=(P#ecpF+#fl9cSq@8{59|+08_pD?z@a!5bPto zhirjw5BnNpYTLFgOMFVrIo@LqCQO*Xj*gD%w^*a0Lx<}7kK)Jazft;zPa8S_zel_Y zYk`7XDU1*L05nLzccG`-BggM1<46DE6H?d` z{e#yH`~aMR&k#q!oJ;PLibuvs-X!)qc(Hfy-ijuy3kqn39#Q=-c>Mmc28cmD|NQf6 zFM$T+SfDS-wNiaUH%dH_Kls_}ccK63sYZ7g+Y8+{vS0RMx}5yLa= z3(!z0eoVvu#2$sN10B!-Eos2M#T>*$h9Xw?$o^-WPYx(9EKvO@0`&8MbqC)=zk%3Qg-9k4< zosX-7&d0@G=Y=A_72mA-yMwj4Zi>lhfAQ1)x6U!#PvQUklRK?MkIR3&RV8~lOa6;F zt$0_YXry3$P~c4wkB2I-_gicAB};0QDkXuyRl;9F0LT*EG2S0%4{uXRDREI zgcI$*SJk;CA}P9!d;ggr*D$#$tiIc;szWM8mxT(&_64} zLl67=EO@15AFrCaefY!fJB`Tk52}RyPju!=18vJK;&ofoC~QLt{j_cecZe$>&9dX% zEx3kWTYZ~GZL3l-+Er1JDxQTsj~KR#4i2%?Ww>;%|sVNxD_vavyI#^${A@8s-V#-9DqBeZ8{ zCLKPopZD$FNhw=5lgv|%qph`?r*{J~%m+!%^cRwU+(&H0QTrQcQ+_GVPQflD8H0+C zZY-)HISa%?bBR9GNp7E#BHI6XZDHG~Sv4i|O5}W4*)6s!xk%1=r^(DKgw5y7C#`=lzZsLqx(w<&d^|zMBe&_RufC$dz(B-S)xLmk^IPDSg!b|DPpbGm`cz}n z(&~B+KVHW^$$8x7>9+jMkkOo2aYgb7<-Ca4D;MgoaAr;(2OPe{8`ClrHie!7W`pj= zSfM}9o~^m3ee^MCOOB^$Jp9`nL6tsI7sDHiyl^SH9h`Sxg)>@zMl8Ck3R5BS+sK0lALOa5eH|q9Om=N zDxoP}!R(d1pDL<##-8ABgsANL2hFFw}6)s@XLRh-or zGGquzz6bC&Ne%>X4@s^PayBq8z~zd6fE6^76D@f_D&O75&G~`!FP8RCR8^>)5)%^> z)jqHm#@)Vsdlg$l9+lVy$U}n+A>@bv<4gQsy$05OX!{FQ`wV=CxFm2Za4j&J!486~LoPUEO;}hMBR53h!4{YoV?!Un+wg%~ zPBqmUc=E5cnd#UCF%iLcwkL0*G!%*DOCgEh@yZp;XmesbiSG_IZ(O&UB%Vj{anZaw zW;v}03nHs&rg=7&W}W`pZp-)nUasv|Ee|u2-x{r39b*(19bpt1y2MD%drQ64D0W4- z(VCUZjpCvrj8-jQW)vL}ViXY)XymuR)yQGatfvia)l0-FO9Ee73G!&~!ZHIiQ?N|F z+FWa;&e9jbb`ooQcxjNo-4SR99QLx5ZmJdh`{+k}_OG-bV{h~6{1wT)y%TnJp6n6X zbKq!;8CEk*Je}v6SeySj@L?@C z&DqDRqL%OTa&^A@{|5YRUX&?(rZ_iVdG!vj+*8aBNxQj6;$iMAv4pOnH9T<3X?1?E zy!5!jM!|sr@dg?`iOh?5HCc3|_^3A(o>Km9n6aF_-T1?G*MLy{)28Oi6vc?&K|=9T3hznQ|^wFd=fWmmfOCr^L?F>pWG%7qEAC zHqNBq#jYmtxticz#TPf7Y+&y#d)YTBlM@bsm4-3qmcK`qY literal 0 HcmV?d00001 diff --git a/Explorer/ShellDataTransfert/DataObjectEx.cs b/Explorer/ShellDataTransfert/DataObjectEx.cs new file mode 100644 index 0000000..20ea3a2 --- /dev/null +++ b/Explorer/ShellDataTransfert/DataObjectEx.cs @@ -0,0 +1,145 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.DataObjectEx +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; +using System.Drawing; +using System.IO; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Security.Permissions; +using System.Windows.Forms; + +namespace GDRomExplorer.ShellDataTransfert +{ + public class DataObjectEx : DataObject, System.Runtime.InteropServices.ComTypes.IDataObject + { + private static readonly TYMED[] ALLOWED_TYMEDS = new TYMED[5] + { + TYMED.TYMED_HGLOBAL, + TYMED.TYMED_ISTREAM, + TYMED.TYMED_ENHMF, + TYMED.TYMED_MFPICT, + TYMED.TYMED_GDI + }; + private FileDescriptor[] fileDescriptors; + private int fileDescriptorIndex; + + public void SetItems(FileDescriptor[] FileDescriptors) + { + this.fileDescriptors = FileDescriptors; + this.SetData("FileGroupDescriptorW", (object) null); + this.SetData("FileContents", (object) null); + this.SetData("Performed DropEffect", (object) null); + } + + public override object GetData(string format, bool autoConvert) + { + if (string.Compare(format, "FileGroupDescriptorW", StringComparison.OrdinalIgnoreCase) == 0 && this.fileDescriptors != null) + this.SetData("FileGroupDescriptorW", (object) this.GetFileDescriptor(this.fileDescriptors)); + else if (string.Compare(format, "FileContents", StringComparison.OrdinalIgnoreCase) == 0) + this.SetData("FileContents", (object) this.GetFileContents(this.fileDescriptors, this.fileDescriptorIndex)); + else + string.Compare(format, "Performed DropEffect", StringComparison.OrdinalIgnoreCase); + return base.GetData(format, autoConvert); + } + + [SecurityPermission(SecurityAction.Demand, Flags = SecurityPermissionFlag.UnmanagedCode)] + void System.Runtime.InteropServices.ComTypes.IDataObject.GetData( + ref FORMATETC formatetc, + out STGMEDIUM medium) + { + if ((int) formatetc.cfFormat == (int) (short) DataFormats.GetFormat("FileContents").Id) + this.fileDescriptorIndex = formatetc.lindex; + medium = new STGMEDIUM(); + if (DataObjectEx.GetTymedUseable(formatetc.tymed)) + { + if ((formatetc.tymed & TYMED.TYMED_ISTREAM) != TYMED.TYMED_NULL) + { + medium.tymed = TYMED.TYMED_ISTREAM; + medium.unionmember = IntPtr.Zero; + System.Runtime.InteropServices.ComTypes.IStream fileContents = this.GetFileContents(this.fileDescriptors, this.fileDescriptorIndex); + if (fileContents == null) + return; + medium.unionmember = Marshal.GetComInterfaceForObject((object) fileContents, typeof (System.Runtime.InteropServices.ComTypes.IStream)); + } + else + { + medium.tymed = formatetc.tymed; + ((System.Runtime.InteropServices.ComTypes.IDataObject) this).GetDataHere(ref formatetc, ref medium); + } + } + else + Marshal.ThrowExceptionForHR(-2147221399); + } + + private static bool GetTymedUseable(TYMED tymed) + { + for (int index = 0; index < DataObjectEx.ALLOWED_TYMEDS.Length; ++index) + { + if ((tymed & DataObjectEx.ALLOWED_TYMEDS[index]) != TYMED.TYMED_NULL) + return true; + } + return false; + } + + private MemoryStream GetFileDescriptor(FileDescriptor[] FileDescriptors) + { + MemoryStream memoryStream = new MemoryStream(); + memoryStream.Write(BitConverter.GetBytes(FileDescriptors.Length), 0, 4); + DataObjectEx.FILEDESCRIPTOR filedescriptor = new DataObjectEx.FILEDESCRIPTOR(); + foreach (FileDescriptor fileDescriptor in FileDescriptors) + { + filedescriptor.cFileName = fileDescriptor.FileName; + filedescriptor.dwFlags = 16384U; + filedescriptor.dwFlags |= 68U; + filedescriptor.dwFlags |= 56U; + filedescriptor.dwFileAttributes = fileDescriptor.IsDirectory ? 16U : 128U; + long fileTime = fileDescriptor.WriteTime.ToFileTime(); + System.Runtime.InteropServices.ComTypes.FILETIME filetime = new System.Runtime.InteropServices.ComTypes.FILETIME() + { + dwLowDateTime = (int) (fileTime & (long) uint.MaxValue), + dwHighDateTime = (int) (fileTime >> 32) + }; + filedescriptor.ftLastWriteTime = filetime; + filedescriptor.ftCreationTime = filetime; + filedescriptor.nFileSizeHigh = (uint) (fileDescriptor.FileSize >> 32); + filedescriptor.nFileSizeLow = (uint) ((ulong) fileDescriptor.FileSize & (ulong) uint.MaxValue); + int length = Marshal.SizeOf((object) filedescriptor); + IntPtr num = Marshal.AllocHGlobal(length); + Marshal.StructureToPtr((object) filedescriptor, num, true); + byte[] numArray = new byte[length]; + Marshal.Copy(num, numArray, 0, length); + Marshal.FreeHGlobal(num); + memoryStream.Write(numArray, 0, numArray.Length); + } + return memoryStream; + } + + private System.Runtime.InteropServices.ComTypes.IStream GetFileContents( + FileDescriptor[] FileDescriptors, + int FileNumber) + { + return FileNumber >= FileDescriptors.Length || FileDescriptors[FileNumber].Data == null ? (System.Runtime.InteropServices.ComTypes.IStream) null : (System.Runtime.InteropServices.ComTypes.IStream) new StreamWrapper(FileDescriptors[FileNumber].Data, FileDescriptors[FileNumber].FileName); + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)] + private struct FILEDESCRIPTOR + { + public uint dwFlags; + public Guid clsid; + public Size sizel; + public Point pointl; + public uint dwFileAttributes; + public System.Runtime.InteropServices.ComTypes.FILETIME ftCreationTime; + public System.Runtime.InteropServices.ComTypes.FILETIME ftLastAccessTime; + public System.Runtime.InteropServices.ComTypes.FILETIME ftLastWriteTime; + public uint nFileSizeHigh; + public uint nFileSizeLow; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] + public string cFileName; + } + } +} diff --git a/Explorer/ShellDataTransfert/FileDescriptor.cs b/Explorer/ShellDataTransfert/FileDescriptor.cs new file mode 100644 index 0000000..8e26746 --- /dev/null +++ b/Explorer/ShellDataTransfert/FileDescriptor.cs @@ -0,0 +1,24 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.FileDescriptor +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; +using System.IO; + +namespace GDRomExplorer.ShellDataTransfert +{ + public class FileDescriptor + { + public string FileName { get; set; } + + public long FileSize { get; set; } + + public DateTime WriteTime { get; set; } + + public Stream Data { get; set; } + + public bool IsDirectory { get; set; } + } +} diff --git a/Explorer/ShellDataTransfert/FileDescriptorFactory.cs b/Explorer/ShellDataTransfert/FileDescriptorFactory.cs new file mode 100644 index 0000000..559297c --- /dev/null +++ b/Explorer/ShellDataTransfert/FileDescriptorFactory.cs @@ -0,0 +1,112 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.FileDescriptorFactory +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.Stream; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using SEGATools.VirtualFile; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; + +namespace GDRomExplorer.ShellDataTransfert +{ + public class FileDescriptorFactory + { + private static readonly string DEFAULT_FILENAME = "no_name"; + + public static FileDescriptor createFromVirtualFile(IVirtualFile virtualFile) + { + FileDescriptor fileDescriptor = new FileDescriptor(); + System.IO.Stream fileInputStream = virtualFile.FileInputStream; + fileDescriptor.FileName = virtualFile.VirtualName; + fileDescriptor.WriteTime = DateTime.Now; + fileDescriptor.IsDirectory = false; + fileDescriptor.Data = fileInputStream; + fileDescriptor.FileSize = fileInputStream.Length; + return fileDescriptor; + } + + private static FileDescriptor createFromDirectoryRecord( + DirectoryRecord directoryRecord, + IDiscFileSystem discFileSystem, + string directoryRecordFileName) + { + string str = directoryRecordFileName; + if (string.Empty.Equals(directoryRecordFileName)) + str = FileDescriptorFactory.DEFAULT_FILENAME; + FileDescriptor fileDescriptor = new FileDescriptor(); + DiscSectorStream forDirectoryRecord = discFileSystem.GetDiscStreamForDirectoryRecord(directoryRecord); + fileDescriptor.FileName = str; + fileDescriptor.WriteTime = directoryRecord.RecordingDateTime.HasValue ? directoryRecord.RecordingDateTime.Value : DateTime.Now; + fileDescriptor.IsDirectory = directoryRecord.IsDirectory; + fileDescriptor.Data = (System.IO.Stream) forDirectoryRecord; + fileDescriptor.FileSize = directoryRecord.IsDirectory ? 0L : forDirectoryRecord.Length; + return fileDescriptor; + } + + public static FileDescriptor[] createFromDirectoryRecordTree( + DirectoryRecord directoryRecord, + IDiscFileSystem discFileSystem) + { + List fileDescriptorList = new List(); + int count = 1; + if (!directoryRecord.IsRoot) + { + count = directoryRecord.ParentDirectory.FullPath.Length; + if (!directoryRecord.ParentDirectory.IsRoot) + ++count; + fileDescriptorList.Add(FileDescriptorFactory.createFromDirectoryRecord(directoryRecord, discFileSystem, directoryRecord.Name)); + } + foreach (DirectoryRecord allSubDirectory in directoryRecord.GetAllSubDirectories()) + { + string directoryRecordFileName = allSubDirectory.FullPath.Remove(0, count); + fileDescriptorList.Add(FileDescriptorFactory.createFromDirectoryRecord(allSubDirectory, discFileSystem, directoryRecordFileName)); + } + return fileDescriptorList.ToArray(); + } + + public static DataObject createDataObject(object Handle, IDiscFileSystem Disc) + { + DataObjectEx dataObjectEx = new DataObjectEx(); + FileDescriptor[] FileDescriptors; + switch (Handle) + { + case DirectoryRecord _: + FileDescriptors = FileDescriptorFactory.createFromDirectoryRecordTree(Handle as DirectoryRecord, Disc); + break; + case InitialProgramExtended _: + FileDescriptors = new FileDescriptor[1] + { + FileDescriptorFactory.createFromVirtualFile((IVirtualFile) VirtualFileFactory.createVirtualFile(Handle as InitialProgramExtended)) + }; + break; + case IVirtualFile _: + FileDescriptors = new FileDescriptor[1] + { + FileDescriptorFactory.createFromVirtualFile(Handle as IVirtualFile) + }; + break; + case IList _: + IList directoryRecordList = Handle as IList; + List fileDescriptorList = new List(directoryRecordList.Count); + foreach (DirectoryRecord directoryRecord in (IEnumerable) directoryRecordList) + { + FileDescriptor[] directoryRecordTree = FileDescriptorFactory.createFromDirectoryRecordTree(directoryRecord, Disc); + fileDescriptorList.AddRange((IEnumerable) ((IEnumerable) directoryRecordTree).ToList()); + } + FileDescriptors = fileDescriptorList.ToArray(); + break; + default: + return (DataObject) null; + } + dataObjectEx.SetItems(FileDescriptors); + return (DataObject) dataObjectEx; + } + } +} diff --git a/Explorer/ShellDataTransfert/LOCKTYPE.cs b/Explorer/ShellDataTransfert/LOCKTYPE.cs new file mode 100644 index 0000000..e15091f --- /dev/null +++ b/Explorer/ShellDataTransfert/LOCKTYPE.cs @@ -0,0 +1,15 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.LOCKTYPE +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer.ShellDataTransfert +{ + public enum LOCKTYPE + { + LOCK_WRITE = 1, + LOCK_EXCLUSIVE = 2, + LOCK_ONLYONCE = 4, + } +} diff --git a/Explorer/ShellDataTransfert/NativeMethods.cs b/Explorer/ShellDataTransfert/NativeMethods.cs new file mode 100644 index 0000000..61c9df1 --- /dev/null +++ b/Explorer/ShellDataTransfert/NativeMethods.cs @@ -0,0 +1,41 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.NativeMethods +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; +using System.Runtime.InteropServices; + +namespace GDRomExplorer.ShellDataTransfert +{ + public class NativeMethods + { + public const string CFSTR_PREFERREDDROPEFFECT = "Preferred DropEffect"; + public const string CFSTR_PERFORMEDDROPEFFECT = "Performed DropEffect"; + public const string CFSTR_FILEDESCRIPTORW = "FileGroupDescriptorW"; + public const string CFSTR_FILECONTENTS = "FileContents"; + public const int FD_CLSID = 1; + public const int FD_SIZEPOINT = 2; + public const int FD_ATTRIBUTES = 4; + public const int FD_CREATETIME = 8; + public const int FD_ACCESSTIME = 16; + public const int FD_WRITESTIME = 32; + public const int FD_FILESIZE = 64; + public const int FD_PROGRESSUI = 16384; + public const int FD_LINKUI = 32768; + public const uint FILE_ATTRIBUTE_READONLY = 1; + public const uint FILE_ATTRIBUTE_HIDDEN = 2; + public const uint FILE_ATTRIBUTE_SYSTEM = 4; + public const uint FILE_ATTRIBUTE_DIRECTORY = 16; + public const uint FILE_ATTRIBUTE_ARCHIVE = 32; + public const uint FILE_ATTRIBUTE_NORMAL = 128; + public const int DV_E_TYMED = -2147221399; + + [DllImport("kernel32.dll", CharSet = CharSet.Auto)] + public static extern IntPtr GlobalAlloc(int uFlags, int dwBytes); + + [DllImport("kernel32.dll", CharSet = CharSet.Auto)] + public static extern IntPtr GlobalFree(HandleRef handle); + } +} diff --git a/Explorer/ShellDataTransfert/STGTY.cs b/Explorer/ShellDataTransfert/STGTY.cs new file mode 100644 index 0000000..faf1724 --- /dev/null +++ b/Explorer/ShellDataTransfert/STGTY.cs @@ -0,0 +1,16 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.STGTY +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +namespace GDRomExplorer.ShellDataTransfert +{ + public enum STGTY + { + STGTY_STORAGE = 1, + STGTY_STREAM = 2, + STGTY_LOCKBYTES = 3, + STGTY_PROPERTY = 4, + } +} diff --git a/Explorer/ShellDataTransfert/StreamWrapper.cs b/Explorer/ShellDataTransfert/StreamWrapper.cs new file mode 100644 index 0000000..a619507 --- /dev/null +++ b/Explorer/ShellDataTransfert/StreamWrapper.cs @@ -0,0 +1,53 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ShellDataTransfert.StreamWrapper +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using System; +using System.IO; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; + +namespace GDRomExplorer.ShellDataTransfert +{ + public class StreamWrapper : IStream + { + private Stream fileStream; + private string fileName; + + public StreamWrapper(Stream fileStream, string fileName) + { + this.fileStream = fileStream; + this.fileName = fileName; + } + + public void Read(byte[] pv, int cb, IntPtr pcbRead) => Marshal.WriteInt32(pcbRead, this.fileStream.Read(pv, 0, cb)); + + public void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition) => Marshal.WriteInt32(plibNewPosition, (int) this.fileStream.Seek(dlibMove, (SeekOrigin) dwOrigin)); + + public void Clone(out IStream ppstm) => throw new NotImplementedException(); + + public void Commit(int grfCommitFlags) => throw new NotImplementedException(); + + public void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten) => throw new NotImplementedException(); + + public void LockRegion(long libOffset, long cb, int dwLockType) => throw new NotImplementedException(); + + public void Revert() => throw new NotImplementedException(); + + public void SetSize(long libNewSize) => throw new NotImplementedException(); + + public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag) + { + pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG(); + pstatstg.type = 2; + pstatstg.cbSize = this.fileStream.Length; + pstatstg.pwcsName = this.fileName; + } + + public void UnlockRegion(long libOffset, long cb, int dwLockType) => throw new NotImplementedException(); + + public void Write(byte[] pv, int cb, IntPtr pcbWritten) => throw new NotImplementedException(); + } +} diff --git a/Explorer/UserControls/DiscViewExplorer.cs b/Explorer/UserControls/DiscViewExplorer.cs new file mode 100644 index 0000000..19b963e --- /dev/null +++ b/Explorer/UserControls/DiscViewExplorer.cs @@ -0,0 +1,954 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.DiscViewExplorer +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.DiscView; +using GDRomExplorer.Events; +using GDRomExplorer.Forms; +using GDRomExplorer.Others; +using GDRomExplorer.ShellDataTransfert; +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.ISO9660.VolumeDescriptors; +using SEGATools.CueSheet; +using SEGATools.Disc; +using SEGATools.DiscFileSystem; +using SEGATools.Encrypt; +using SEGATools.Security; +using SEGATools.SortFile; +using SEGATools.VirtualFile; +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class DiscViewExplorer : UserControl + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IDiscFileSystem discFileSystem; + private TreeNode treeNodeInListView; + private Control lastControlWithFocus; + private MenuItemFactory menuItemFactory; + private ContextMenuManager contextMenuManager; + private UserActions userActions; + private ToolStripItem[] discMenuItems; + private DiscSelectionHandlerFactory treeViewSelectionHandlerFactory; + private DiscSelectionHandlerFactory listViewSelectionHandlerFactory; + private IContainer components; + private GroupBox groupBox; + private SplitContainer splitContainer; + private TreeView treeView; + private ListView listView; + private DiscExtractor discExtractor; + private SaveFileDialog saveFileDialogForInitialProgram; + private SaveFileDialog saveFileDialogForExtraction; + private SaveFileDialog saveFileDialogForCueSheet; + private SaveFileDialog saveFileDialogForSortFile; + private FolderBrowserDialog folderBrowserDialogForExtraction; + private SaveFileDialog saveFileDialogForDesDecrypt; + private GDDAConverterTool gddaConverterTool; + private ImageList treeViewImageList; + private ImageList listViewImageList; + private ImageList contextMenuImageList; + + public event EventHandler> SelectionChanged; + + public string Title + { + get => this.groupBox.Text; + private set => this.groupBox.Text = string.Format(GDRomExplorer.Resources.Strings.DiscViewExplorerGroupLabelWithFormat, (object) value); + } + + public string Filename => this.discFileSystem != null ? this.discFileSystem.FileName : string.Empty; + + public DiscViewExplorer() + { + this.InitializeComponent(); + this.userActions = new UserActions(); + this.userActions.SetHandler(UserActions.Action.ExportForGDEmu, new EventHandler(this.UserActionExportForGDEmu)); + this.userActions.SetHandler(UserActions.Action.CreateCueSheet, new EventHandler(this.UserActionCreateCueSheet)); + this.userActions.SetHandler(UserActions.Action.ShowGDDAConversion, new EventHandler(this.UserActionShowGDDAConversionForm)); + this.userActions.SetHandler(UserActions.Action.ShowBootSector, new EventHandler(this.UserActionShowBootSector)); + this.userActions.SetHandler(UserActions.Action.ExtractBootSector, new EventHandler(this.UserActionExtractInitialProgram)); + this.userActions.SetHandler(UserActions.Action.ExtractItem, new EventHandler(this.UserActionExtractItem)); + this.userActions.SetHandler(UserActions.Action.CreateSortFile, new EventHandler(this.UserActionGenerateSortFile)); + this.userActions.SetHandler(UserActions.Action.ShowPrimaryVolumeDescriptor, new EventHandler(this.UserActionShowPrimaryVolumeDescriptor)); + this.userActions.SetHandler(UserActions.Action.ConvertGDDA, new EventHandler(this.UserActionConvertGDDA)); + this.userActions.SetHandler(UserActions.Action.DecryptNaomiBinary, new EventHandler(this.UserActionDecryptBinaryFromDisc)); + this.treeViewSelectionHandlerFactory = (DiscSelectionHandlerFactory) new DiscTreeViewSelectionHandlerFactory(this, this.treeView); + this.listViewSelectionHandlerFactory = (DiscSelectionHandlerFactory) new DiscListViewSelectionHandlerFactory(this, this.listView); + this.menuItemFactory = new MenuItemFactory(this.userActions, this.contextMenuImageList); + this.contextMenuManager = new ContextMenuManager(this.menuItemFactory); + this.Resize += new EventHandler(this.DiscViewExplorer_Resize); + this.Leave += new EventHandler(this.DiscViewExplorer_Leave); + this.listView.Columns.Add(GDRomExplorer.Resources.Strings.DiscViewListColumnFileName, -2, HorizontalAlignment.Left); + this.listView.Columns.Add(GDRomExplorer.Resources.Strings.DiscViewListColumnSize, -2, HorizontalAlignment.Right); + this.listView.Columns.Add(GDRomExplorer.Resources.Strings.DiscViewListColumnSizeInBytes, -2, HorizontalAlignment.Right); + this.listView.Columns.Add(GDRomExplorer.Resources.Strings.DiscViewListColumnLBA, -2, HorizontalAlignment.Right); + this.listView.Columns.Add(GDRomExplorer.Resources.Strings.DiscViewListColumnModifiedDate, -2, HorizontalAlignment.Right); + this.listView.MouseClick += new MouseEventHandler(this.listView_MouseClick); + this.listView.MouseDoubleClick += new MouseEventHandler(this.listView_MouseClick); + this.listView.MouseUp += new MouseEventHandler(this.listView_MouseClick); + this.listView.ColumnClick += new ColumnClickEventHandler(this.listView_ColumnClick); + this.listView.KeyDown += new KeyEventHandler(this.listView_KeyDown); + this.listView.KeyUp += new KeyEventHandler(this.listView_KeyUp); + this.listView.ItemDrag += new ItemDragEventHandler(this.DiscViewExplorer_ItemDrag); + this.listView.GotFocus += new EventHandler(this.listView_GotFocus); + this.listView.LostFocus += new EventHandler(this.DiscViewExplorer_Leave); + this.listView.ListViewItemSorter = (IComparer) new ListViewColumnSorter() + { + Order = SortOrder.Ascending + }; + this.treeView.AfterSelect += new TreeViewEventHandler(this.treeView_AfterSelect); + this.treeView.MouseClick += new MouseEventHandler(this.treeView_MouseClick); + this.treeView.MouseDoubleClick += new MouseEventHandler(this.treeView_MouseClick); + this.treeView.ItemDrag += new ItemDragEventHandler(this.DiscViewExplorer_ItemDrag); + this.treeView.GotFocus += new EventHandler(this.treeView_GotFocus); + this.treeView.Leave += new EventHandler(this.DiscViewExplorer_Leave); + this.saveFileDialogForInitialProgram.Title = GDRomExplorer.Resources.Strings.SfdInitialProgramTitle; + this.saveFileDialogForInitialProgram.Filter = GDRomExplorer.Resources.Strings.SfdInitialProgramFilter; + this.saveFileDialogForExtraction.Title = GDRomExplorer.Resources.Strings.SfdExtractTitle; + this.saveFileDialogForExtraction.Filter = GDRomExplorer.Resources.Strings.SfdExtractFilter; + this.saveFileDialogForCueSheet.Title = GDRomExplorer.Resources.Strings.SfdCueSheetTitle; + this.saveFileDialogForCueSheet.Filter = GDRomExplorer.Resources.Strings.SfdCueSheetFilter; + this.saveFileDialogForSortFile.Title = GDRomExplorer.Resources.Strings.SfdSortFileTitle; + this.saveFileDialogForSortFile.Filter = GDRomExplorer.Resources.Strings.SfdSortFileFilter; + this.saveFileDialogForDesDecrypt.Title = GDRomExplorer.Resources.Strings.NaomiEncryptDecryptToolSfdDecTitle; + this.saveFileDialogForDesDecrypt.Filter = GDRomExplorer.Resources.Strings.NaomiEncryptDecryptToolSfdDecFilter; + this.folderBrowserDialogForExtraction.Description = GDRomExplorer.Resources.Strings.FbdExtractFilesTitle; + this.folderBrowserDialogForExtraction.RootFolder = Environment.SpecialFolder.Desktop; + } + + private void DiscViewExplorer_ItemDrag(object sender, ItemDragEventArgs e) + { + if (e.Button != MouseButtons.Left) + return; + if (sender == this.listView) + { + this.HandleDragAndDropFrom(this.listView); + } + else + { + if (sender != this.treeView) + throw new NotSupportedException(); + this.treeView.SelectedNode = e.Item as TreeNode; + this.HandleDragAndDropFrom(this.treeView); + } + } + + private void DiscViewExplorer_Load(object sender, EventArgs e) => this.CloseDisc(); + + private void DiscViewExplorer_Resize(object sender, EventArgs e) => this.ResizeListView(); + + private void DiscViewExplorer_Leave(object sender, EventArgs e) => this.contextMenuManager.CloseContextMenuIfAny(); + + public void LoadDisc(IDiscFileSystem discFileSystem) + { + this.EnableUIElements(); + this.discFileSystem = discFileSystem; + this.discExtractor.DiscFileSystem = discFileSystem; + this.Title = discFileSystem.DiscName; + this.discMenuItems = this.menuItemFactory.CreateDiscWithSessionTopMenuItem(discFileSystem); + this.UpdateDialogsPath(Path.GetDirectoryName(discFileSystem.FileName)); + TreeNode tree = ExplorerTreeNodeFactory.CreateTree(discFileSystem); + this.treeView.Nodes.Add(tree); + this.UpdateTreeViewSelectedNode(this.FindFileSystemTreeNode(discFileSystem, tree)); + } + + public void CloseDisc() + { + this.DisableUIElements(); + this.treeNodeInListView = (TreeNode) null; + this.discFileSystem = (IDiscFileSystem) null; + this.DisableSelectionAndNotify(); + } + + private TreeNode FindFileSystemTreeNode(IDiscFileSystem disc, TreeNode rootNode) + { + TreeNode treeNode1 = rootNode; + foreach (IDiscSession discSession in (IEnumerable) disc.Sessions.OrderByDescending((Func) (session => session.Index))) + { + TreeNode[] treeNodeArray = rootNode.Nodes.Find(discSession.Name, false); + if (treeNodeArray.Length != 0) + { + TreeNode treeNode2 = treeNodeArray[0]; + treeNode1 = treeNode2; + if (treeNode2.FirstNode != null) + { + TreeNode firstNode = treeNode2.FirstNode; + if (firstNode.Tag is IDiscTrack tag && tag.TrackData == TrackModeType.Data && (firstNode.LastNode != null && firstNode.LastNode.Tag is DirectoryRecord)) + { + treeNode1 = firstNode.LastNode; + break; + } + } + } + } + return treeNode1; + } + + private void DisableUIElements() + { + this.Title = GDRomExplorer.Resources.Strings.DiscViewNoDiscTitle; + this.treeView.Enabled = false; + this.treeView.Nodes.Clear(); + this.treeView.BackColor = SystemColors.Control; + this.listView.Enabled = false; + this.listView.Items.Clear(); + this.listView.Scrollable = false; + } + + private void EnableUIElements() + { + this.treeView.BackColor = SystemColors.Window; + this.treeView.Nodes.Clear(); + this.treeView.Enabled = true; + this.listView.Items.Clear(); + this.listView.Scrollable = true; + this.listView.Enabled = true; + } + + private void ShowBootSector(InitialProgramExtended ip) + { + using (FormInitialProgram formInitialProgram = new FormInitialProgram(ip, Path.GetDirectoryName(this.discFileSystem.FileName))) + { + int num = (int) formInitialProgram.ShowDialog((IWin32Window) this); + } + } + + private void ShowPVD(PrimaryVolumeDescriptor PrimVolDesc) + { + using (FormPrimaryVolumeDescriptor volumeDescriptor = new FormPrimaryVolumeDescriptor(PrimVolDesc)) + { + int num = (int) volumeDescriptor.ShowDialog((IWin32Window) this); + } + } + + private void FillListView(DirectoryRecord directoryRecordToRead, TreeNode origin) + { + this.listView.Cursor = Cursors.AppStarting; + this.listView.BeginUpdate(); + this.listView.Items.Clear(); + ListViewItem listViewItem1 = (ListViewItem) null; + if (!directoryRecordToRead.IsRoot) + { + ListViewItem parentDirectoryItem = ExplorerListItemFactory.CreateParentDirectoryItem(directoryRecordToRead); + this.listView.Items.Add(parentDirectoryItem); + listViewItem1 = parentDirectoryItem; + } + ListViewItem[] items = new ListViewItem[directoryRecordToRead.SubDirectories.Count]; + int num = 0; + foreach (DirectoryRecord subDirectory in directoryRecordToRead.SubDirectories) + { + ListViewItem listViewItem2 = ExplorerListItemFactory.CreateItem(subDirectory, this.discFileSystem); + items[num++] = listViewItem2; + if (origin != null && listViewItem2.Tag == origin.Tag) + listViewItem1 = listViewItem2; + } + this.listView.Items.AddRange(items); + this.listView.FocusedItem = listViewItem1; + this.listView.Cursor = Cursors.Default; + this.listView.EndUpdate(); + this.ResizeListView(); + } + + private void ConvertGDDA(IDiscTrack discTrack) + { + using (FormAudioConversionSettings conversionSettings = new FormAudioConversionSettings()) + { + if (conversionSettings.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + this.gddaConverterTool.ConvertGDDATracks(discTrack, conversionSettings.AudioConversionSettings); + } + } + + private void ExtractAndDecryptFile(DirectoryRecord directoryRecord) + { + if (directoryRecord == null || directoryRecord.IsDirectory) + return; + DESKey desKey; + using (FormGetDESKey extractAndDecryptLabel = FormGetDESKey.aGetDESKeyFormWithExtractAndDecryptLabel(this.discFileSystem.NaomiDESKey)) + { + if (extractAndDecryptLabel.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + desKey = extractAndDecryptLabel.DESKey; + } + this.saveFileDialogForDesDecrypt.FileName = Path.GetFileNameWithoutExtension(directoryRecord.Name); + if (this.saveFileDialogForDesDecrypt.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + string fileName = this.saveFileDialogForDesDecrypt.FileName; + this.UpdateDialogsPath(Path.GetDirectoryName(fileName)); + this.saveFileDialogForDesDecrypt.FileName = Path.GetFileNameWithoutExtension(fileName); + IVirtualFile virtualFile1 = VirtualFileFactory.createVirtualFile(directoryRecord, this.discFileSystem); + IVirtualFile virtualFile2 = VirtualFileFactory.createVirtualFile(fileName); + DesEncryptDecryptTool desDecryptor = new DesEncryptDecryptTool(); + Guid TaskId = Guid.NewGuid(); + FormProcess.createForDesDecryptor(desDecryptor, TaskId); + desDecryptor.DecryptAsync((IVirtualFile) virtualFile1, (IVirtualFile) virtualFile2, desKey, (object) TaskId); + } + + private void ExtractInitialProgram(InitialProgramExtended initialProgramExtended) + { + this.saveFileDialogForInitialProgram.FileName = initialProgramExtended.FileName; + if (this.saveFileDialogForInitialProgram.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + string fileName = this.saveFileDialogForInitialProgram.FileName; + this.UpdateDialogsPath(Path.GetDirectoryName(fileName)); + try + { + this.discExtractor.ExtractBootStrap((InitialProgram) initialProgramExtended, fileName); + AppStatus.NotifyNewAppStatus(string.Format(GDRomExplorer.Resources.Strings.MsgBoxInitialProgramExtractionSuccessWithFormat, (object) fileName)); + } + catch (Exception ex) + { + DiscViewExplorer.logger.ErrorFormat("Unable to extract the boot file: {0}", (object) ex); + int num = (int) MessageBox.Show((IWin32Window) this, GDRomExplorer.Resources.Strings.MsgBoxInitialProgramExtractionErrorWithFormat, GDRomExplorer.Resources.Strings.MsgBoxInitialProgramExtractionTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + AppStatus.NotifyNewAppStatus(string.Format(GDRomExplorer.Resources.Strings.MsgBoxInitialProgramExtractionErrorWithFormat, (object) fileName)); + } + } + + private void ExportForGDEmu(IDiscFileSystem discFileSystem) + { + using (FormGDEmuExportSettings emuExportSettings = new FormGDEmuExportSettings(discFileSystem)) + { + int num = (int) emuExportSettings.ShowDialog((IWin32Window) this); + } + } + + private void CreateCueSheet(IDiscSession discSession) + { + string Title = string.Format("{0} ({1})", (object) this.discFileSystem.DiscName, (object) discSession.Name); + this.saveFileDialogForCueSheet.FileName = Title; + if (this.saveFileDialogForCueSheet.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + string fileName = this.saveFileDialogForCueSheet.FileName; + this.UpdateDialogsPath(Path.GetDirectoryName(fileName)); + this.saveFileDialogForCueSheet.FileName = Path.GetFileNameWithoutExtension(fileName); + try + { + CueSheetCreator.CreateFromDiscSession(discSession, fileName, Title); + AppStatus.NotifyNewAppStatus(GDRomExplorer.Resources.Strings.MsgBoxCueCreatorSuccess); + } + catch (Exception ex) + { + DiscViewExplorer.logger.ErrorFormat("Unable to create the sort file: {0}", (object) ex); + int num = (int) MessageBox.Show((IWin32Window) this, GDRomExplorer.Resources.Strings.MsgBoxCueCreatorError, GDRomExplorer.Resources.Strings.MsgBoxCueCreatorTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + AppStatus.NotifyNewAppStatus(GDRomExplorer.Resources.Strings.MsgBoxCueCreatorError); + } + } + + private void CreateSortFile(IDiscSession discSession) + { + string pathPrefix; + int lowestFileWeight; + using (FormSortFileOptions formSortFileOptions = new FormSortFileOptions()) + { + if (formSortFileOptions.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + pathPrefix = formSortFileOptions.PathPrefix; + lowestFileWeight = formSortFileOptions.LowestFileWeight; + } + if (string.IsNullOrEmpty(Path.GetFileName(this.saveFileDialogForSortFile.FileName))) + this.saveFileDialogForSortFile.FileName = SortFileCreator.DefaultFileName; + if (this.saveFileDialogForSortFile.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + string fileName = this.saveFileDialogForSortFile.FileName; + this.saveFileDialogForSortFile.FileName = Path.GetFileNameWithoutExtension(fileName); + this.UpdateDialogsPath(Path.GetDirectoryName(fileName)); + try + { + SortFileCreator.CreateSortFile(discSession, pathPrefix, lowestFileWeight, fileName); + AppStatus.NotifyNewAppStatus(GDRomExplorer.Resources.Strings.MsgBoxSortFileCreationSuccess); + } + catch (Exception ex) + { + DiscViewExplorer.logger.ErrorFormat("Unable to create the sort file: {0}", (object) ex); + int num = (int) MessageBox.Show((IWin32Window) this, GDRomExplorer.Resources.Strings.MsgBoxSortFileCreationError, GDRomExplorer.Resources.Strings.MsgBoxSortFileCreationTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + AppStatus.NotifyNewAppStatus(GDRomExplorer.Resources.Strings.MsgBoxSortFileCreationError); + } + } + + private void OpenExtractNodesDialog(List DirectoryRecords) + { + if (DirectoryRecords == null || DirectoryRecords.Count == 0) + { + DiscViewExplorer.logger.Debug((object) "Nothing to extract!"); + } + else + { + string str; + if (DirectoryRecords.Count == 1 && !DirectoryRecords[0].IsDirectory) + { + this.saveFileDialogForExtraction.FileName = DirectoryRecords[0].Name; + if (this.saveFileDialogForExtraction.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + str = this.saveFileDialogForExtraction.FileName; + this.UpdateDialogsPath(Path.GetDirectoryName(str)); + } + else + { + if (this.folderBrowserDialogForExtraction.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + str = this.folderBrowserDialogForExtraction.SelectedPath; + this.UpdateDialogsPath(str); + } + Guid TaskId = Guid.NewGuid(); + FormProcess.createForDiscExtractor(this.discExtractor, TaskId); + this.discExtractor.ExtractPathsAsync(DirectoryRecords, str, (object) TaskId); + } + } + + private void OpenExtractNodesDialogForDiscTrack(IDiscTrack discTrack) + { + this.saveFileDialogForExtraction.FileName = Path.GetFileName(discTrack.VirtualName); + if (this.saveFileDialogForExtraction.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + string fileName = this.saveFileDialogForExtraction.FileName; + this.UpdateDialogsPath(Path.GetDirectoryName(fileName)); + Guid TaskId = Guid.NewGuid(); + FormProcess.createForDiscExtractor(this.discExtractor, TaskId); + this.discExtractor.ExtractDiscTracksAsync(discTrack, fileName, (object) TaskId); + } + + private void UpdateDialogsPath(string outputPath) => this.saveFileDialogForInitialProgram.InitialDirectory = this.saveFileDialogForExtraction.InitialDirectory = this.saveFileDialogForCueSheet.InitialDirectory = this.saveFileDialogForSortFile.InitialDirectory = this.saveFileDialogForDesDecrypt.InitialDirectory = this.folderBrowserDialogForExtraction.SelectedPath = outputPath; + + private void ResizeListView() + { + this.listView.SuspendLayout(); + for (int index = 0; index < this.listView.Columns.Count; ++index) + this.listView.Columns[index].Width = -2; + this.listView.ResumeLayout(false); + } + + private void DisableSelectionAndNotify() + { + if (this.SelectionChanged == null) + return; + this.SelectionChanged((object) this, new EventArgs(DiscViewExplorer.ActionsForEditMenuItem.NoEditActions())); + } + + private void RemoveSelectionAndNotify() + { + if (this.SelectionChanged == null) + return; + this.SelectionChanged((object) this, this.CreateNewSelectionEvent(this.menuItemFactory.CreateSelectionDisabledTopMenuItem())); + } + + private void NotifySelectionChanged(ToolStripItem[] NewSelectionMenuItems) + { + if (this.SelectionChanged == null) + return; + this.SelectionChanged((object) this, this.CreateNewSelectionEvent(NewSelectionMenuItems)); + } + + private EventArgs CreateNewSelectionEvent( + ToolStripItem[] NewSelectionMenuItems) + { + return new EventArgs(new DiscViewExplorer.ActionsForEditMenuItem(this.discMenuItems, NewSelectionMenuItems)); + } + + private void UpdateTreeViewSelectedNode(TreeNode newSelection) + { + this.treeView.SelectedNode = newSelection; + this.treeView.SelectedNode.EnsureVisible(); + this.treeView.SelectedNode.Expand(); + } + + private void NagivateUp() + { + if (this.treeNodeInListView.Parent == null || !(this.treeNodeInListView.Parent.Tag is DirectoryRecord)) + return; + this.treeView.SelectedNode = this.treeNodeInListView.Parent; + } + + private void NavigateDown() + { + if (this.listView.FocusedItem == null || !(this.listView.FocusedItem.Tag is DirectoryRecord) || !(this.listView.FocusedItem.Tag as DirectoryRecord).IsDirectory) + return; + if (this.treeNodeInListView.Tag == this.listView.FocusedItem.Tag) + { + this.NagivateUp(); + } + else + { + TreeNode[] treeNodeArray = this.treeNodeInListView.Nodes.Find(this.listView.FocusedItem.Name, false); + if (treeNodeArray.Length != 1) + return; + this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView(treeNodeArray[0].Tag)); + } + } + + private void SelectAllListViewItems() + { + foreach (ListViewItem listViewItem in this.listView.Items) + { + if (!DirectoryRecord.PARENT_DIRECTORY_NAME.Equals(listViewItem.Text)) + listViewItem.Selected = true; + } + } + + private void UserActionExportForGDEmu(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscFileSystem)) + return; + this.ExportForGDEmu(toolStripItem.Tag as IDiscFileSystem); + } + + private void UserActionCreateCueSheet(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscSession)) + return; + this.CreateCueSheet(toolStripItem.Tag as IDiscSession); + } + + private void UserActionShowGDDAConversionForm(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscSession)) + return; + using (FormGdda formGdda = new FormGdda(toolStripItem.Tag as IDiscSession)) + { + if (formGdda.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + this.gddaConverterTool.ConvertGDDATracks((IList) formGdda.SelectedDiscTracks, formGdda.AudioConversionSettings); + } + } + + private void UserActionShowBootSector(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is InitialProgramExtended)) + return; + this.ShowBootSector(toolStripItem.Tag as InitialProgramExtended); + } + + private void UserActionExtractInitialProgram(object sender, EventArgs eventArgs) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is InitialProgramExtended)) + return; + this.ExtractInitialProgram(toolStripItem.Tag as InitialProgramExtended); + } + + private void UserActionExtractItem(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + List DirectoryRecords = new List(); + if (toolStripItem.Tag is List) + this.OpenExtractNodesDialog(toolStripItem.Tag as List); + else if (toolStripItem.Tag is DirectoryRecord) + { + DirectoryRecords.Add(toolStripItem.Tag as DirectoryRecord); + this.OpenExtractNodesDialog(DirectoryRecords); + } + else if (toolStripItem.Tag is IDiscTrack) + this.OpenExtractNodesDialogForDiscTrack(toolStripItem.Tag as IDiscTrack); + else + DiscViewExplorer.logger.ErrorFormat("Unhandled tag object {0} for ToolStripItem {1}", toolStripItem.Tag, (object) toolStripItem); + } + + private void UserActionGenerateSortFile(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscSession)) + return; + this.CreateSortFile(toolStripItem.Tag as IDiscSession); + } + + private void UserActionShowPrimaryVolumeDescriptor(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscTrack)) + return; + this.ShowPVD((toolStripItem.Tag as IDiscTrack).Session.PrimaryVolumeDescriptor); + } + + private void UserActionConvertGDDA(object sender, EventArgs e) + { + if (!(sender is ToolStripItem)) + return; + ToolStripItem toolStripItem = sender as ToolStripItem; + if (!(toolStripItem.Tag is IDiscTrack)) + return; + this.ConvertGDDA(toolStripItem.Tag as IDiscTrack); + } + + private void UserActionDecryptBinaryFromDisc(object sender, EventArgs e) + { + if (this.listView.SelectedItems.Count != 1 || !(this.listView.SelectedItems[0].Tag is DirectoryRecord)) + return; + this.ExtractAndDecryptFile(this.listView.SelectedItems[0].Tag as DirectoryRecord); + } + + private void HandleDragAndDropFrom(ListView ListView) + { + List list = ListView.SelectedItems.Cast().Select((Func) (item => (DirectoryRecord) item.Tag)).ToList(); + DataObject dataObject = FileDescriptorFactory.createDataObject((object) list, this.discFileSystem); + if (dataObject != null) + { + int num = (int) this.DoDragDrop((object) dataObject, DragDropEffects.Copy); + } + else + DiscViewExplorer.logger.WarnFormat("Drag'n Drop canceled: FileDescriptorFactory does not support {0}", (object) list); + } + + private void HandleDragAndDropFrom(TreeView TreeView) + { + object tag = TreeView.SelectedNode.Tag; + DataObject dataObject = FileDescriptorFactory.createDataObject(tag, this.discFileSystem); + if (dataObject != null) + { + int num = (int) this.DoDragDrop((object) dataObject, DragDropEffects.Copy); + } + else + DiscViewExplorer.logger.WarnFormat("Drag'n Drop canceled: FileDescriptorFactory does not support {0}", tag); + } + + public void Disc_AfterSelectHandler(IDiscFileSystem disc) => this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) disc)); + + public void Disc_MouseRightClickHandler(IDiscFileSystem disc) + { + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) disc); + this.contextMenuManager.CreateAndShowContextMenu(itemsForTreeView); + this.NotifySelectionChanged(itemsForTreeView); + } + + public void DirectoryRecord_AfterSelectClickHandler(DirectoryRecord DirectoryRecord) + { + DiscViewExplorer.logger.InfoFormat("Opening path \"{0}\"", (object) DirectoryRecord.FullPath); + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DirectoryRecord); + TreeNode treeNodeInListView = this.treeNodeInListView; + this.treeNodeInListView = this.treeView.SelectedNode; + this.FillListView(DirectoryRecord, treeNodeInListView); + this.NotifySelectionChanged(itemsForTreeView); + } + + public void DirectoryRecord_MouseRightClickHandler(DirectoryRecord DirectoryRecord) + { + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DirectoryRecord); + this.contextMenuManager.CreateAndShowContextMenu(itemsForTreeView); + this.NotifySelectionChanged(itemsForTreeView); + } + + public void DirectoryRecords_MouseLeftClickHandler(IList DirectoryRecords) + { + DirectoryRecord firstDirectoryRecord = DirectoryRecords[0]; + if (!DirectoryRecords.All((Func) (directoryRecord => directoryRecord.ParentDirectory == firstDirectoryRecord.ParentDirectory))) + this.RemoveSelectionAndNotify(); + else + this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForListView((object) DirectoryRecords, this.discFileSystem)); + } + + public void DirectoryRecords_MouseDoubleLeftClicksHandler( + IList DirectoryRecords) + { + DirectoryRecord directoryRecord = DirectoryRecords[0]; + if (!directoryRecord.IsDirectory) + return; + this.UpdateTreeViewSelectedNode(this.treeNodeInListView.Tag as DirectoryRecord != directoryRecord || this.treeNodeInListView.Parent == null ? this.treeNodeInListView.Nodes[directoryRecord.Name] : this.treeNodeInListView.Parent); + } + + public void DirectoryRecords_MouseRightClickHandler(IList DirectoryRecords) + { + DirectoryRecord firstDirectoryRecord = DirectoryRecords[0]; + if (!DirectoryRecords.All((Func) (directoryRecord => directoryRecord.ParentDirectory == firstDirectoryRecord.ParentDirectory))) + { + this.RemoveSelectionAndNotify(); + } + else + { + ToolStripItem[] itemsForListView = this.menuItemFactory.CreateSelectionMenuItemsForListView((object) DirectoryRecords, this.discFileSystem); + this.contextMenuManager.CreateAndShowContextMenu(itemsForListView); + this.NotifySelectionChanged(itemsForListView); + } + } + + public void InitialProgram_AfterSelectHandler(InitialProgramExtended InitialProgram) => this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) InitialProgram)); + + public void InitialProgram_MouseDoubleLeftClicksHandler(InitialProgramExtended InitialProgram) + { + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) InitialProgram); + this.ShowBootSector(InitialProgram); + this.NotifySelectionChanged(itemsForTreeView); + } + + public void InitialProgram_MouseRightClickHandler(InitialProgramExtended InitialProgram) => this.contextMenuManager.CreateAndShowContextMenu(this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) InitialProgram)); + + public void DiscSession_AfterSelectHandler(IDiscSession DiscSession) => this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DiscSession)); + + public void DiscSession_MouseRightClickHandler(IDiscSession DiscSession) + { + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DiscSession); + this.contextMenuManager.CreateAndShowContextMenu(itemsForTreeView); + this.NotifySelectionChanged(itemsForTreeView); + } + + public void DiscTrack_AfterSelectHandler(IDiscTrack DiscTrack) => this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DiscTrack)); + + public void DiscTrack_MouseRightClickHandler(IDiscTrack DiscTrack) + { + ToolStripItem[] itemsForTreeView = this.menuItemFactory.CreateSelectionMenuItemsForTreeView((object) DiscTrack); + this.contextMenuManager.CreateAndShowContextMenu(itemsForTreeView); + this.NotifySelectionChanged(itemsForTreeView); + } + + private void treeView_MouseClick(object sender, MouseEventArgs e) + { + TreeNode nodeAt = this.treeView.GetNodeAt(e.Location); + if (nodeAt == null) + return; + this.treeView.SelectedNode = nodeAt; + IDiscViewSelection discViewSelection = this.treeViewSelectionHandlerFactory.newSelectionHandlers(this.treeView.SelectedNode.Tag); + if (discViewSelection != null) + discViewSelection.HandleMouseEvent(e); + else + DiscViewExplorer.logger.ErrorFormat("Unhandled object {0}", (object) this.Handle); + } + + private void treeView_AfterSelect(object sender, TreeViewEventArgs e) + { + TreeNode node = e.Node; + if (node == null) + return; + this.treeViewSelectionHandlerFactory.newSelectionHandlers(node.Tag)?.HandleAfterSelect(); + } + + private void treeView_GotFocus(object sender, EventArgs e) + { + if (this.lastControlWithFocus == this.treeView) + return; + this.lastControlWithFocus = (Control) this.treeView; + if (this.treeView.SelectedNode != null) + this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForTreeView(this.treeView.SelectedNode.Tag)); + else + this.RemoveSelectionAndNotify(); + } + + private void listView_MouseClick(object sender, MouseEventArgs mouseEvent) + { + if (this.listView.SelectedItems.Count == 0) + this.RemoveSelectionAndNotify(); + else + this.listViewSelectionHandlerFactory.newSelectionHandlers((object) this.listView.SelectedItems.Cast().Select((Func) (item => (DirectoryRecord) item.Tag)).ToList()).HandleMouseEvent(mouseEvent); + } + + private void listView_ColumnClick(object sender, ColumnClickEventArgs e) + { + this.listView.BeginUpdate(); + this.listView.Sorting = this.listView.Sorting != SortOrder.Ascending ? (((ListViewColumnSorter) this.listView.ListViewItemSorter).Order = SortOrder.Ascending) : (((ListViewColumnSorter) this.listView.ListViewItemSorter).Order = SortOrder.Descending); + ((ListViewColumnSorter) this.listView.ListViewItemSorter).SortColumn = e.Column; + this.listView.Sort(); + this.listView.EndUpdate(); + } + + private void listView_KeyUp(object sender, KeyEventArgs e) + { + if (this.listView.SelectedItems.Count == 0) + this.RemoveSelectionAndNotify(); + else + this.listViewSelectionHandlerFactory.newSelectionHandlers((object) this.listView.SelectedItems.Cast().Select((Func) (item => (DirectoryRecord) item.Tag)).ToList()).HandleLeftClick(); + } + + private void listView_KeyDown(object sender, KeyEventArgs e) + { + if (e.Control) + { + if (e.KeyCode != Keys.A) + return; + this.SelectAllListViewItems(); + } + else if (e.KeyCode == Keys.Return) + { + this.NavigateDown(); + } + else + { + if (e.KeyCode != Keys.Back) + return; + this.NagivateUp(); + } + } + + private void listView_GotFocus(object sender, EventArgs e) + { + if (this.lastControlWithFocus == this.listView) + return; + this.lastControlWithFocus = (Control) this.listView; + if (this.listView.SelectedItems.Count > 0) + this.NotifySelectionChanged(this.menuItemFactory.CreateSelectionMenuItemsForListView((object) this.listView.SelectedItems.Cast().Select((Func) (item => (DirectoryRecord) item.Tag)).ToList(), this.discFileSystem)); + else + this.RemoveSelectionAndNotify(); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.components = (IContainer) new Container(); + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (DiscViewExplorer)); + this.groupBox = new GroupBox(); + this.splitContainer = new SplitContainer(); + this.treeView = new TreeView(); + this.treeViewImageList = new ImageList(this.components); + this.listView = new ListView(); + this.listViewImageList = new ImageList(this.components); + this.saveFileDialogForInitialProgram = new SaveFileDialog(); + this.saveFileDialogForExtraction = new SaveFileDialog(); + this.saveFileDialogForCueSheet = new SaveFileDialog(); + this.saveFileDialogForSortFile = new SaveFileDialog(); + this.folderBrowserDialogForExtraction = new FolderBrowserDialog(); + this.saveFileDialogForDesDecrypt = new SaveFileDialog(); + this.discExtractor = new DiscExtractor(this.components); + this.contextMenuImageList = new ImageList(this.components); + this.gddaConverterTool = new GDDAConverterTool(this.components); + this.groupBox.SuspendLayout(); + this.splitContainer.Panel1.SuspendLayout(); + this.splitContainer.Panel2.SuspendLayout(); + this.splitContainer.SuspendLayout(); + this.SuspendLayout(); + this.groupBox.AutoSize = true; + this.groupBox.BackColor = SystemColors.Window; + this.groupBox.Controls.Add((Control) this.splitContainer); + this.groupBox.Dock = DockStyle.Fill; + this.groupBox.Location = new Point(4, 4); + this.groupBox.Name = "groupBox"; + this.groupBox.Size = new Size(632, 472); + this.groupBox.TabIndex = 0; + this.groupBox.TabStop = false; + this.groupBox.Text = "Disc title"; + this.splitContainer.Dock = DockStyle.Fill; + this.splitContainer.Location = new Point(3, 16); + this.splitContainer.Name = "splitContainer"; + this.splitContainer.Panel1.Controls.Add((Control) this.treeView); + this.splitContainer.Panel2.Controls.Add((Control) this.listView); + this.splitContainer.Size = new Size(626, 453); + this.splitContainer.SplitterDistance = 207; + this.splitContainer.TabIndex = 0; + this.splitContainer.TabStop = false; + this.treeView.BackColor = SystemColors.Window; + this.treeView.Dock = DockStyle.Fill; + this.treeView.HideSelection = false; + this.treeView.HotTracking = true; + this.treeView.ImageIndex = 0; + this.treeView.ImageList = this.treeViewImageList; + this.treeView.Indent = 18; + this.treeView.ItemHeight = 18; + this.treeView.Location = new Point(0, 0); + this.treeView.Name = "treeView"; + this.treeView.SelectedImageIndex = 0; + this.treeView.ShowLines = false; + this.treeView.ShowNodeToolTips = true; + this.treeView.Size = new Size(207, 453); + this.treeView.TabIndex = 1; + this.treeViewImageList.ImageStream = (ImageListStreamer) componentResourceManager.GetObject("treeViewImageList.ImageStream"); + this.treeViewImageList.TransparentColor = Color.Transparent; + this.treeViewImageList.Images.SetKeyName(0, "gd_icon.png"); + this.treeViewImageList.Images.SetKeyName(1, "dclogo_black.png"); + this.treeViewImageList.Images.SetKeyName(2, "cdrom_data.png"); + this.treeViewImageList.Images.SetKeyName(3, "cdrom_audio.png"); + this.treeViewImageList.Images.SetKeyName(4, "file_binary.png"); + this.treeViewImageList.Images.SetKeyName(5, "iso9660.png"); + this.treeViewImageList.Images.SetKeyName(6, "folder_closed.ico"); + this.treeViewImageList.Images.SetKeyName(7, "folder_open.ico"); + this.listView.AllowColumnReorder = true; + this.listView.Dock = DockStyle.Fill; + this.listView.Font = new Font("Microsoft Sans Serif", 8.25f); + this.listView.FullRowSelect = true; + this.listView.HideSelection = false; + this.listView.LabelWrap = false; + this.listView.Location = new Point(0, 0); + this.listView.Name = "listView"; + this.listView.ShowGroups = false; + this.listView.ShowItemToolTips = true; + this.listView.Size = new Size(415, 453); + this.listView.SmallImageList = this.listViewImageList; + this.listView.Sorting = SortOrder.Ascending; + this.listView.TabIndex = 2; + this.listView.UseCompatibleStateImageBehavior = false; + this.listView.View = View.Details; + this.listViewImageList.ImageStream = (ImageListStreamer) componentResourceManager.GetObject("listViewImageList.ImageStream"); + this.listViewImageList.TransparentColor = Color.Transparent; + this.listViewImageList.Images.SetKeyName(0, "file.ico"); + this.listViewImageList.Images.SetKeyName(1, "folder_closed.ico"); + this.listViewImageList.Images.SetKeyName(2, "folder_up.ico"); + this.discExtractor.DiscFileSystem = (IDiscFileSystem) null; + this.contextMenuImageList.ImageStream = (ImageListStreamer) componentResourceManager.GetObject("contextMenuImageList.ImageStream"); + this.contextMenuImageList.TransparentColor = Color.Transparent; + this.contextMenuImageList.Images.SetKeyName(0, "extract_icon.ico"); + this.contextMenuImageList.Images.SetKeyName(1, "file.ico"); + this.contextMenuImageList.Images.SetKeyName(2, "zoom.ico"); + this.contextMenuImageList.Images.SetKeyName(3, "help.ico"); + this.contextMenuImageList.Images.SetKeyName(4, "folder_open.ico"); + this.contextMenuImageList.Images.SetKeyName(5, "folder_up.ico"); + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.AutoSize = true; + this.Controls.Add((Control) this.groupBox); + this.DoubleBuffered = true; + this.Name = nameof (DiscViewExplorer); + this.Padding = new Padding(4); + this.Size = new Size(640, 480); + this.Load += new EventHandler(this.DiscViewExplorer_Load); + this.Leave += new EventHandler(this.DiscViewExplorer_Leave); + this.groupBox.ResumeLayout(false); + this.splitContainer.Panel1.ResumeLayout(false); + this.splitContainer.Panel2.ResumeLayout(false); + this.splitContainer.ResumeLayout(false); + this.ResumeLayout(false); + this.PerformLayout(); + } + + public sealed class ActionsForEditMenuItem + { + public bool AnyAvailable { get; private set; } + + public bool SelectionMenuAvailable { get; private set; } + + public ToolStripItem[] DiscMenuItems { get; private set; } + + public ToolStripItem[] SelectionMenuItems { get; private set; } + + internal ActionsForEditMenuItem( + ToolStripItem[] DiscMenuItems, + ToolStripItem[] SelectionMenuItems) + { + this.DiscMenuItems = DiscMenuItems; + this.SelectionMenuItems = SelectionMenuItems; + this.SelectionMenuAvailable = SelectionMenuItems != null && SelectionMenuItems.Length > 0; + this.AnyAvailable = this.SelectionMenuAvailable || DiscMenuItems != null && DiscMenuItems.Length > 0; + } + + internal static DiscViewExplorer.ActionsForEditMenuItem NoEditActions() => new DiscViewExplorer.ActionsForEditMenuItem((ToolStripItem[]) null, (ToolStripItem[]) null); + } + } +} diff --git a/Explorer/UserControls/DiscViewExplorer.resx b/Explorer/UserControls/DiscViewExplorer.resx new file mode 100644 index 0000000..9909735 --- /dev/null +++ b/Explorer/UserControls/DiscViewExplorer.resx @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 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 + + + 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 + + + AAEAAAD/////AQAAAAAAAAAMAgAAAFdTeXN0ZW0uV2luZG93cy5Gb3JtcywgVmVyc2lvbj0yLjAuMC4wLCBDdWx0dXJlPW5ldXRyYWwsIFB1YmxpY0tleVRva2VuPWI3N2E1YzU2MTkzNGUwODkFAQAAACZTeXN0ZW0uV2luZG93cy5Gb3Jtcy5JbWFnZUxpc3RTdHJlYW1lcgEAAAAERGF0YQcCAgAAAAkDAAAADwMAAAD+CQAAAk1TRnQBSQFMAgEBAwEAASABAAEgAQABEAEAARABAAT/AREBEAj/AUIBTQE2BwABNgMAASgDAAFAAwABEAMAAQEBAAEQBgABCBYAAVYBRgFWAUYBVgFGAVYBRgFWAUYBVgFGAVYBRgFWAUYBVgFGAVYBRgFWAUYBVgFGBAABuwF3AcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQG7AXcCAAG7AXcBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAbsBdyYAAVYBRgH/AX8B/wF/Af8BfwH/AX8B/wF/Af8BfwH/AX8B/wF/Af8BfwH/AX8BVgFGBAABwAFVAekBegHAAVUBcQF/AekBegHpAXoB6QF6AekBegHpAXoB6QF6AekBegHpAXoBZAFmAZIBewHAAVUCAAHAAVUB6QF6AcABVQFxAX8B6QF6AekBegHpAXoB6QF6AekBegHpAXoB6QF6AekBegFkAWYBkgF7AcABVSYAAVYBRgH/AX8B/wF/Af8BfwH/AX8B/wF/Af8BfwH/AX8B/wF/Af8BfwH/AX8BVgFGBAABwAFVAQkBewHAAVUBcgF/AQoBfwEKAXsBCgF/AQoBewEKAX8BCgF/AQoBfwEKAXsBZAFmAZMBewHAAVUCAAHAAVUBCQF7AcABVQFyAX8BCgF/AQoBewEKAX8BCgF7AQoBfwEKAX8BCgF/AQoBewFkAWYBkwF7AcABVSYAAVYBRgH/AXsB/wF7Af8BewH/AXsB/wF7Af8BewH/AXsB/wF7Af8BewH/AXsBVgFGBAABwAFVASoBfwHAAVUBkwF/AUsBfwFLAX8BSwF/AUsBfwFLAX8BSwF/AUsBfwFLAX8BhQFmAbQBewHAAVUCAAHAAVUBKgF/AcABVQGTAX8BSwF/AUsBfwFLAX8BSwF/AUsBfwFLAX8BSwF/AUsBfwGFAWYBtAF7AcABVSYAAVYBRgHfAXsB3wF7Ad8BewHfAXsB3wF7Ad8BewHfAXsB3wF7Ad8BewHfAXsBVgFGBAABwAFVAUsBfwHAAVUBtAF/AW0BfwFtAX8BbQF/AW0BfwFtAX8BbQF/AW0BfwFtAX8BhQFmAbUBewHAAVUCAAHAAVUBSwF/AcABVQG0AX8BbQF/AWUBMgGgAQUBwAEFAWUBMgFLAXMBbQF/AW0BfwGFAWYBtQF7AcABVSYAAVYBRgHfAXcB3wF3Ad8BdwHfAXcB3wF3Ad8BdwHfAXcB3wF3Ad8BdwHfAXcBVgFGBAABwAFVAW0BfwHAAVUBtAF/AY4BfwGOAX8BjgF/AY4BfwGOAX8BjgF/AY4BfwGOAX8BpgFmAdUBewHAAVUCAAHAAVUBbAF7AcABVQG0AX8BjgF/AY4BfwGnAT4B4AEFAQABBgHiARUBjgF7AY4BfwGmAWYB1QF7AcABVSYAAVYBRgHfAXMB3wFzAd8BcwHfAXMB3wFzAd8BcwHfAXMB3wFzAd8BcwHfAXMBVgFGBAABwAFVAY4BfwHAAVUB/wF/AdcBfwHXAX8B1wF/AdcBfwHXAX8B1wF/AdcBfwHXAX8BMAFzAdoBfwHAAVUCAAHAAVUBjQF/AcABVQH/AX8B1wF/AdcBfwHXAX8BywE+AQABBgHgAQUBAwEWAdcBfwEwAXMB2gF/AcABVSYAAVYBRgG/AXMBvwFzAb8BcwG/AXMBvwFzAb8BcwG/AXMBvwFzAb8BcwG/AXMBVgFGBAABwAFVAa8BfwHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAcABVQHAAVUCAAHAAVUBrwF/AcABVQHAAVUBwAFVAcABVQHAAVUBoAE5AQABBgFAAQYBoAEJAcABTQHAAVUBwAFVAcABVSYAAVYBRgG/AW8BvwFvAb8BbwG/AW8BvwFvAb8BbwG/AW8BvwFvAb8BbwG/AW8BVgFGBAABwAFVAdABfwHQAX8B0AF/AdABfwHQAX8B0AF/AdABfwHQAX8B0AF/AdABfwHQAX8BoAFRBgABwAFVAdABfwHQAX8B0AF/AdABfwHQAX8B0AF/AQsBWwEBAQoBYQEKAeABBQHJAUoBoAFRKgABVgFGAb8BbwG/AW8BvwFvAb8BbwG/AW8BvwFvARoBWwEaAVsBGgFbARoBWwFWAUYEAAHAAVUB/wF/AfEBfwHxAX8B8QF/AfEBfwHxAX8B8QF/AfEBfwHxAX8B8QF/AfEBfwGgAVEGAAHAAVUB/wF/AfEBfwHxAX8B8QF/AfEBfwHxAX8BbQFnAQEBDgGiARIBIQEKAUUBKgGgAVEqAAFWAUYBvwFrAb8BawG/AWsBvwFrAb8BawG/AWsBlgFKAZYBSgF2AUoBdgFKAVYBRgQAAbsBdwHAAVUB/wF/AfEBfwHxAX8B8QF/AcABVQHAAVUBwAFVAcABVQHAAVUBwAFVAbsBdwYAAbsBdwHAAVUB/wF/AfEBfwGgAQUBoAEFAaABBQGgAQUBQgEWAcMBHgGCARIBoAEFAaABBQGgAQUBoAEFJgABVgFGAZ8BZwGfAWcBnwFnAZ8BZwGfAWcBnwFnATMBPgEzAT4BMwE+ATMBPgFWAUYGAAG7AXcBwAFVAcABVQHAAVUBwAFVFgABuwF3AcABVQHAAVUBwAFNAaABBQHiAQ0BJgEzASYBLwHkASIBwwEaAYIBEgEBAQoBoAEFKAABVgFGAZ8BZwGfAWcBnwFnAZ8BZwGfAWcBlwFKAd8BewHfAXsBOwFnAVYBRjIAAaABBQFjARoBaAE7ASYBLwEFAScBgwEaAaABBSoAAVYBRgGfAWMBnwFjAZ8BYwGfAWMBnwFjAZcBSgHfAXsBGgFbAVYBRjYAAaABBQGkASIBiAE/ASYBLwGgAQUsAAFWAUYBfwFjAX8BYwF/AWMBfwFjAX8BYwGXAUoBGgFbAVYBRjoAAaABBQHlASoBoAEFLgABVgFGAVYBRgFWAUYBVgFGAVYBRgFWAUYBVgFGAVYBRj4AAaABBSwAAUIBTQE+BwABPgMAASgDAAFAAwABEAMAAQEBAAEBBQABgBcAA/8BAAHAAQMBAAEBAQABAQIAAcABAwEAAQEBAAEBAgABwAEDAQABAQEAAQECAAHAAQMBAAEBAQABAQIAAcABAwEAAQEBAAEBAgABwAEDAQABAQEAAQECAAHAAQMBAAEBAQABAQIAAcABAwEAAQEBAAEBAgABwAEDAQABBwEAAQcCAAHAAQMBAAEHAQABBwIAAcABAwEAAQcBAAEBAgABwAEDAYMB/wGAAQMCAAHAAQcC/wH8AQcCAAHAAQ8C/wH+AQ8CAAHAAR8D/wEfAgABwAE/A/8BvxgACw== + + \ No newline at end of file diff --git a/Explorer/UserControls/DiscViewOpener.cs b/Explorer/UserControls/DiscViewOpener.cs new file mode 100644 index 0000000..07122d1 --- /dev/null +++ b/Explorer/UserControls/DiscViewOpener.cs @@ -0,0 +1,305 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.DiscViewOpener +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Events; +using GDRomExplorer.Forms; +using GDRomExplorer.Properties; +using GDRomExplorer.Resources; +using ImageReader.DiscFileSystem; +using SEGATools.Disc; +using SEGATools.DiscFileSystem; +using SEGATools.FileFormat; +using SEGATools.Security; +using SEGATools.UserProcess; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class DiscViewOpener : UserControl + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private FormLoading formLoading; + private List fileDialogIncludeFilters = new List(); + private string SelectedDiscImage; + private bool notifyStatusEvents; + private IContainer components; + private TableLayoutPanel tableLayoutPanel; + private Button btOpen; + private TextBox tbDiscImageFile; + private GroupBox groupBox; + private DiscOpener discOpener; + private DiscFormatProvider discFormatProvider; + private OpenFileDialog openFileDialog; + + public event EventHandler> ImageLoaded; + + public event EventHandler ImageNotLoaded; + + [Description("Specifies the text of the group box.")] + [Category("Appearance")] + [Browsable(true)] + public override string Text + { + get => this.groupBox.Text; + set => this.groupBox.Text = value; + } + + [Description("Specifies the text of the open button.")] + [Category("Appearance")] + [Browsable(true)] + public string ButtonText + { + get => this.btOpen.Text; + set => this.btOpen.Text = value; + } + + [Browsable(true)] + [Description("Indicates the initial directory for the OpenFileDialog.")] + [Category("Behavior")] + public string InitialDirectory + { + get => this.openFileDialog.InitialDirectory; + set => this.openFileDialog.InitialDirectory = value; + } + + [Description("Indicates whether the control should notify the application status bar control.")] + [Category("Behavior")] + [Browsable(true)] + public bool NotifyStatusEvents + { + get => this.notifyStatusEvents; + set => this.notifyStatusEvents = value; + } + + [Category("Behavior")] + [Description("Restrict the list of valid file extensions.")] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)] + [EditorBrowsable(EditorBrowsableState.Always)] + [Browsable(true)] + [Editor("System.Windows.Forms.Design.StringCollectionEditor, System.Design", "System.Drawing.Design.UITypeEditor, System.Drawing")] + public List FileDialogFilters + { + get => this.fileDialogIncludeFilters; + set => this.fileDialogIncludeFilters = value; + } + + public DiscViewOpener() + { + this.InitializeComponent(); + this.btOpen.Text = Strings.DiscViewOpenerButtonOpen; + this.groupBox.Text = Strings.DiscViewOpenerLabel + (object) ':'; + this.openFileDialog.Title = Strings.DiscViewOpenerFileDialogTitle; + this.discOpener = new DiscOpener(); + } + + public void SetLoadedDiscImage(IDiscFileSystem discFileSystem) + { + string message = string.Format(Strings.StatusLabelImageLoaded, (object) discFileSystem.FileName); + DiscViewOpener.logger.InfoFormat("Image successfully opened: {0}", (object) discFileSystem.FileName); + this.tbDiscImageFile.Text = discFileSystem.FileName; + this.tbDiscImageFile.BackColor = SystemColors.Window; + if (this.ImageLoaded != null) + this.ImageLoaded((object) this, new EventArgs(discFileSystem)); + this.NotifyNewAppStatus(message); + } + + public void Open() + { + this.openFileDialog.Filter = this.discFormatProvider.GetFileDialogFilters(this.FileDialogFilters != null ? this.FileDialogFilters.ToArray() : (string[]) null); + if (this.openFileDialog.ShowDialog() != DialogResult.OK) + return; + this.Open(this.openFileDialog.FileName); + } + + public void Open(string FileName) + { + if (!File.Exists(FileName)) + { + DiscViewOpener.logger.ErrorFormat("File not found {0}", (object) FileName); + string str = string.Format(Strings.MsgBoxImageOpenerFileNotFoundErrorWithFormat, (object) Path.GetFullPath(FileName)); + int num = (int) MessageBox.Show((IWin32Window) this, str, Strings.MsgBoxImageOpenerTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + this.NotifyNewAppStatus(str); + this.Close(); + } + else + { + string extension = Path.GetExtension(FileName); + if (!this.discFormatProvider.IsFileExtensionSupported(extension)) + { + DiscViewOpener.logger.ErrorFormat("Not supported file extension for file {0}", (object) FileName); + string str = string.Format(Strings.MsgBoxImageOpenerBadFileExtensionErrorWithFormat, (object) Path.GetExtension(FileName)); + int num = (int) MessageBox.Show((IWin32Window) this, str, Strings.MsgBoxImageOpenerTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + this.NotifyNewAppStatus(str); + this.Close(); + } + else + { + this.SelectedDiscImage = FileName; + IImageFileFormat forFileExtension = this.discFormatProvider.FindImageFileFormatForFileExtension(extension); + this.openFileDialog.InitialDirectory = Path.GetDirectoryName(this.SelectedDiscImage); + this.openFileDialog.FileName = Path.GetFileName(this.SelectedDiscImage); + if (this.openFileDialog.FilterIndex > 1) + this.openFileDialog.FilterIndex = this.discFormatProvider.GetFileFormatIndex(forFileExtension); + this.formLoading = new FormLoading(Strings.DiscViewOpenerImageLoadingTitle, Strings.DiscViewOpenerImageLoadingMessage); + this.discOpener.FileOpenerProgressChanged += new AsyncOperationProgressChangedEventHandler(this.GDRomFileSystem_GDRomImageOpenProgressChanged); + this.discOpener.FileOpenerCompleted += new AsyncOperationCompletedEventHandler(this.GDRomFileSystem_GDRomImageOpenCompleted); + this.discOpener.OpenImageAsync(this.SelectedDiscImage, forFileExtension.ImageFileConverter, Settings.Default.ImageReaderComputePathTable); + } + } + } + + public void Close() + { + this.tbDiscImageFile.Text = string.Empty; + this.tbDiscImageFile.BackColor = SystemColors.Menu; + this.SelectedDiscImage = string.Empty; + this.discOpener.CloseImage(); + if (this.ImageNotLoaded == null) + return; + this.ImageNotLoaded((object) this, new EventArgs()); + } + + private void btOpen_Click(object sender, EventArgs e) => this.Open(); + + private void NotifyNewAppStatus(string message) + { + if (!this.NotifyStatusEvents) + return; + AppStatus.NotifyNewAppStatus(message); + } + + private string GetErrorMessage(Exception e) + { + switch (e) + { + case DiscFileSystemException _: + return string.Format(Strings.StatusLabelImageError, (object) Strings.DiscViewOpenerNoFileSystemError); + case InitialProgramException _: + return string.Format(Strings.StatusLabelImageError, (object) string.Format(Strings.DiscViewOpenerInvalidInitialProgram, (object) e.Message)); + case DiscFormatException _: + return string.Format(Strings.StatusLabelImageError, (object) e.Message); + default: + return string.Format(Strings.StatusLabelImageError, (object) Strings.DiscViewOpenerUnknownError); + } + } + + private void GDRomFileSystem_GDRomImageOpenCompleted( + object sender, + UserProcessCompletedEventArgs e) + { + this.formLoading.Close(); + this.formLoading = (FormLoading) null; + this.discOpener.FileOpenerProgressChanged -= new AsyncOperationProgressChangedEventHandler(this.GDRomFileSystem_GDRomImageOpenProgressChanged); + this.discOpener.FileOpenerCompleted -= new AsyncOperationCompletedEventHandler(this.GDRomFileSystem_GDRomImageOpenCompleted); + if (e.Error != null) + { + string errorMessage = this.GetErrorMessage(e.Error); + DiscViewOpener.logger.ErrorFormat("Unable to open image {0}: {1}", (object) e.ResourceName, (object) e.Error); + int num = (int) MessageBox.Show((IWin32Window) this, errorMessage, Strings.MsgBoxImageOpenerTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + this.NotifyNewAppStatus(errorMessage); + this.Close(); + } + else + this.SetLoadedDiscImage(this.discOpener.DiscFileSystem); + } + + private void GDRomFileSystem_GDRomImageOpenProgressChanged(UserProcessProgressChangedEventArgs e) + { + if (this.formLoading.Visible) + return; + int num = (int) this.formLoading.ShowDialog((IWin32Window) this); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.components = (IContainer) new Container(); + this.tableLayoutPanel = new TableLayoutPanel(); + this.tbDiscImageFile = new TextBox(); + this.btOpen = new Button(); + this.groupBox = new GroupBox(); + this.openFileDialog = new OpenFileDialog(); + this.discOpener = new DiscOpener(this.components); + this.discFormatProvider = new DiscFormatProvider(this.components); + this.tableLayoutPanel.SuspendLayout(); + this.groupBox.SuspendLayout(); + this.SuspendLayout(); + this.tableLayoutPanel.AutoSize = true; + this.tableLayoutPanel.ColumnCount = 2; + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 100f)); + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle()); + this.tableLayoutPanel.ColumnStyles.Add(new ColumnStyle(SizeType.Absolute, 20f)); + this.tableLayoutPanel.Controls.Add((Control) this.tbDiscImageFile, 0, 0); + this.tableLayoutPanel.Controls.Add((Control) this.btOpen, 1, 0); + this.tableLayoutPanel.Dock = DockStyle.Fill; + this.tableLayoutPanel.Location = new Point(3, 16); + this.tableLayoutPanel.Margin = new Padding(0); + this.tableLayoutPanel.Name = "tableLayoutPanel"; + this.tableLayoutPanel.RowCount = 1; + this.tableLayoutPanel.RowStyles.Add(new RowStyle(SizeType.Percent, 100f)); + this.tableLayoutPanel.Size = new Size(762, 31); + this.tableLayoutPanel.TabIndex = 0; + this.tbDiscImageFile.BackColor = Color.White; + this.tbDiscImageFile.Dock = DockStyle.Fill; + this.tbDiscImageFile.HideSelection = false; + this.tbDiscImageFile.Location = new Point(3, 3); + this.tbDiscImageFile.Name = "tbDiscImageFile"; + this.tbDiscImageFile.ReadOnly = true; + this.tbDiscImageFile.Size = new Size(670, 20); + this.tbDiscImageFile.TabIndex = 1; + this.tbDiscImageFile.TabStop = false; + this.tbDiscImageFile.WordWrap = false; + this.btOpen.Anchor = AnchorStyles.Top | AnchorStyles.Right; + this.btOpen.AutoSize = true; + this.btOpen.FlatStyle = FlatStyle.Popup; + this.btOpen.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btOpen.ForeColor = Color.FromArgb(248, 48, 0); + this.btOpen.Location = new Point(679, 1); + this.btOpen.Margin = new Padding(3, 1, 3, 3); + this.btOpen.Name = "btOpen"; + this.btOpen.Size = new Size(80, 24); + this.btOpen.TabIndex = 2; + this.btOpen.Text = "&Open"; + this.btOpen.UseVisualStyleBackColor = false; + this.btOpen.Click += new EventHandler(this.btOpen_Click); + this.groupBox.BackColor = SystemColors.Window; + this.groupBox.Controls.Add((Control) this.tableLayoutPanel); + this.groupBox.Dock = DockStyle.Fill; + this.groupBox.Location = new Point(4, 4); + this.groupBox.Margin = new Padding(0); + this.groupBox.MaximumSize = new Size(0, 50); + this.groupBox.MinimumSize = new Size(0, 50); + this.groupBox.Name = "groupBox"; + this.groupBox.Size = new Size(768, 50); + this.groupBox.TabIndex = 0; + this.groupBox.TabStop = false; + this.groupBox.Text = "disc image"; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.AutoSize = true; + this.Controls.Add((Control) this.groupBox); + this.Name = nameof (DiscViewOpener); + this.Padding = new Padding(4); + this.Size = new Size(776, 55); + this.tableLayoutPanel.ResumeLayout(false); + this.tableLayoutPanel.PerformLayout(); + this.groupBox.ResumeLayout(false); + this.groupBox.PerformLayout(); + this.ResumeLayout(false); + } + } +} diff --git a/Explorer/UserControls/DiscViewOpener.resx b/Explorer/UserControls/DiscViewOpener.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/UserControls/DiscViewOpener.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/UserControls/GDDAConverterTool.cs b/Explorer/UserControls/GDDAConverterTool.cs new file mode 100644 index 0000000..054fbf4 --- /dev/null +++ b/Explorer/UserControls/GDDAConverterTool.cs @@ -0,0 +1,203 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.GDDAConverterTool +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Forms; +using SEGATools.Audio; +using SEGATools.DiscFileSystem; +using SEGATools.VirtualFile; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class GDDAConverterTool : Component + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + public string InitialDirectory; + private IWin32Window owner; + private Raw2WavConverter raw2wavConverter; + private IContainer components; + private OpenFileDialog openFileDialog; + private SaveFileDialog saveFileDialog; + private FolderBrowserDialog folderBrowserDialog; + + public GDDAConverterTool() + { + this.InitializeComponent(); + this.InitializeDialogs(); + this.raw2wavConverter = new Raw2WavConverter(); + } + + public GDDAConverterTool(IContainer container) + { + container.Add((IComponent) this); + this.InitializeComponent(); + this.InitializeDialogs(); + this.raw2wavConverter = new Raw2WavConverter(container); + } + + public void OpenAndConvertGDDAFiles( + IWin32Window owner, + AudioConversionSettings AudioConversionSettings) + { + this.owner = owner; + this.UpdateInitialDirectory(this.InitialDirectory); + IList inputFiles; + string outputLocation; + if (this.AskUserForInputFiles(out inputFiles) != DialogResult.OK || this.AskUserForSaveLocation(inputFiles, out outputLocation) != DialogResult.OK) + return; + this.StartAudioConversion(inputFiles, outputLocation, AudioConversionSettings); + } + + public void ConvertGDDATracks( + IDiscTrack AudioTrack, + AudioConversionSettings AudioConversionSettings) + { + this.ConvertGDDATracks((IList) new List() + { + AudioTrack + }, AudioConversionSettings); + } + + public void ConvertGDDATracks( + IList AudioTracks, + AudioConversionSettings AudioConversionSettings) + { + this.CheckTrackListIsValid(AudioTracks); + this.UpdateInitialDirectory(this.InitialDirectory); + if (AudioTracks.Count == 0) + { + this.ShowNoTrackWarning(); + } + else + { + IList list = (IList) AudioTracks.Select((Func) (track => (IVirtualFile) track)).ToList(); + string outputLocation; + if (this.AskUserForSaveLocation(list, out outputLocation) != DialogResult.OK) + return; + this.StartAudioConversion(list, outputLocation, AudioConversionSettings); + } + } + + private void StartAudioConversion( + IList files, + string outputPath, + AudioConversionSettings AudioConversionSettings) + { + Guid TaskId = Guid.NewGuid(); + this.raw2wavConverter.AudioConversionSettings = AudioConversionSettings; + FormProcess.createForRawToWavConverter(this.raw2wavConverter, TaskId); + this.raw2wavConverter.ConvertAsync(files, outputPath, (object) TaskId); + } + + private void InitializeDialogs() + { + this.openFileDialog.Title = GDRomExplorer.Resources.Strings.OfdConvertGddaTitle; + this.openFileDialog.Filter = GDRomExplorer.Resources.Strings.OfdConvertGddaFilter; + this.saveFileDialog.Title = GDRomExplorer.Resources.Strings.SfdCddaTitle; + this.saveFileDialog.Filter = GDRomExplorer.Resources.Strings.SfdCddaFilter; + this.folderBrowserDialog.Description = GDRomExplorer.Resources.Strings.FbdConvertGddaTitle; + this.folderBrowserDialog.RootFolder = Environment.SpecialFolder.Desktop; + } + + private void UpdateInitialDirectory(string newInitialDirectory) + { + this.openFileDialog.InitialDirectory = newInitialDirectory; + this.saveFileDialog.InitialDirectory = newInitialDirectory; + this.folderBrowserDialog.SelectedPath = newInitialDirectory; + } + + private DialogResult AskUserForInputFiles(out IList inputFiles) + { + inputFiles = (IList) null; + if (this.openFileDialog.ShowDialog(this.owner) != DialogResult.OK) + return DialogResult.Cancel; + inputFiles = (IList) ((IEnumerable) this.openFileDialog.FileNames).Select((Func) (inputFilename => (IVirtualFile) VirtualFileFactory.createVirtualFile(inputFilename))).ToList(); + this.openFileDialog.InitialDirectory = Path.GetDirectoryName(this.openFileDialog.FileName); + this.openFileDialog.FileName = Path.GetFileName(this.openFileDialog.FileName); + return DialogResult.OK; + } + + private DialogResult AskUserForSaveLocation( + IList AudioTracks, + out string outputLocation) + { + outputLocation = (string) null; + if (AudioTracks.Count == 1) + { + if (this.AskUserForSaveFileLocation(AudioTracks[0], out outputLocation) != DialogResult.OK) + return DialogResult.Cancel; + } + else if (this.AskUserForSaveDirectoryLocation(out outputLocation) != DialogResult.OK) + return DialogResult.Cancel; + return DialogResult.OK; + } + + private DialogResult AskUserForSaveFileLocation( + IVirtualFile suggestedFileName, + out string outputPath) + { + outputPath = (string) null; + this.saveFileDialog.FileName = Path.GetFileNameWithoutExtension(suggestedFileName.VirtualName); + if (this.saveFileDialog.ShowDialog(this.owner) != DialogResult.OK) + return DialogResult.Cancel; + outputPath = this.saveFileDialog.FileName; + this.UpdateInitialDirectory(Path.GetDirectoryName(outputPath)); + this.saveFileDialog.FileName = Path.GetFileName(outputPath); + return DialogResult.OK; + } + + private DialogResult AskUserForSaveDirectoryLocation(out string outputDirectory) + { + outputDirectory = (string) null; + if (this.folderBrowserDialog.ShowDialog(this.owner) != DialogResult.OK) + return DialogResult.Cancel; + outputDirectory = this.folderBrowserDialog.SelectedPath; + this.UpdateInitialDirectory(outputDirectory); + return DialogResult.OK; + } + + private void CheckTrackListIsValid(IList tracks) + { + if (tracks == null) + throw new ArgumentNullException(); + foreach (IDiscTrack track in (IEnumerable) tracks) + { + if (track.TrackData != TrackModeType.Audio) + { + GDDAConverterTool.logger.ErrorFormat("The track {0} is not an audio track!", (object) track); + throw new ArgumentException("must be an audio track"); + } + } + } + + private void ShowNoTrackWarning() + { + GDDAConverterTool.logger.Warn((object) "No audio track to convert!"); + int num = (int) MessageBox.Show(this.owner, GDRomExplorer.Resources.Strings.MsgBoxAudioConverterNoTrackWarning, GDRomExplorer.Resources.Strings.MsgBoxAudioConverterTitle, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); + AppStatus.NotifyNewAppStatus(GDRomExplorer.Resources.Strings.MsgBoxAudioConverterNoTrackWarning); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.openFileDialog = new OpenFileDialog(); + this.saveFileDialog = new SaveFileDialog(); + this.folderBrowserDialog = new FolderBrowserDialog(); + this.openFileDialog.Multiselect = true; + } + } +} diff --git a/Explorer/UserControls/GDDAConverterTool.resx b/Explorer/UserControls/GDDAConverterTool.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/UserControls/GDDAConverterTool.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/UserControls/GDEmuExportSettings.cs b/Explorer/UserControls/GDEmuExportSettings.cs new file mode 100644 index 0000000..b3a5778 --- /dev/null +++ b/Explorer/UserControls/GDEmuExportSettings.cs @@ -0,0 +1,210 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.GDEmuExportSettings +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Events; +using SEGATools.DiscFileSystem; +using SEGATools.GDEmu; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class GDEmuExportSettings : UserControl + { + private IContainer components; + private FolderBrowserDialog folderBrowserDialog; + private GroupBox gbOutputDiscImage; + private TextBox tbAppOutputFolder; + private Button btSelectOutputFolder; + private DiscViewOpener discViewOpener; + private GroupBox gbExportOptions; + private FlowLayoutPanel flpExportOptions; + private CheckBox cbRegionFree; + private CheckBox cbForceVGA; + + public string InitialDirectory + { + get => this.folderBrowserDialog.SelectedPath; + set + { + this.folderBrowserDialog.SelectedPath = value; + this.discViewOpener.InitialDirectory = value; + } + } + + public IDiscFileSystem InputDiscImage { get; private set; } + + public GDEmuExportOptions ExportOptions { get; private set; } + + private static GDEmuExportOptions GetDefaultOptions() => new GDEmuExportOptions() + { + ForceVGA = true, + RegionFree = true + }; + + public GDEmuExportSettings() + { + this.InitializeComponent(); + this.ExportOptions = GDEmuExportSettings.GetDefaultOptions(); + this.cbRegionFree.Checked = this.ExportOptions.RegionFree; + this.cbForceVGA.Checked = this.ExportOptions.ForceVGA; + this.InitializeUI(); + } + + public void SetLoadedDiscImage(IDiscFileSystem discFileSystem) + { + this.InputDiscImage = discFileSystem; + this.discViewOpener.SetLoadedDiscImage(discFileSystem); + this.InitialDirectory = Path.GetDirectoryName(discFileSystem.FileName); + } + + private void InitializeUI() + { + this.discViewOpener.ImageLoaded += new EventHandler>(this.discViewOpener_ImageLoaded); + this.discViewOpener.ImageNotLoaded += new EventHandler(this.discViewOpener_ImageNotLoaded); + this.cbRegionFree.CheckedChanged += new EventHandler(this.cbRegionFree_CheckedChanged); + this.cbForceVGA.CheckedChanged += new EventHandler(this.cbForceVGA_CheckedChanged); + } + + private void discViewOpener_ImageNotLoaded(object sender, EventArgs e) => this.InputDiscImage = (IDiscFileSystem) null; + + private void discViewOpener_ImageLoaded(object sender, EventArgs e) + { + this.InputDiscImage = e.Value; + this.InitialDirectory = Path.GetDirectoryName(this.InputDiscImage.FileName); + } + + private void btSelectOutputFolder_Click(object sender, EventArgs e) + { + if (this.folderBrowserDialog.ShowDialog() != DialogResult.OK) + return; + this.tbAppOutputFolder.Text = Path.Combine(this.folderBrowserDialog.SelectedPath, this.ExportOptions.GDIFileName); + this.ExportOptions.OutputPath = this.folderBrowserDialog.SelectedPath; + } + + private void cbForceVGA_CheckedChanged(object sender, EventArgs e) => this.ExportOptions.ForceVGA = this.cbForceVGA.Checked; + + private void cbRegionFree_CheckedChanged(object sender, EventArgs e) => this.ExportOptions.RegionFree = this.cbRegionFree.Checked; + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + ComponentResourceManager componentResourceManager = new ComponentResourceManager(typeof (GDEmuExportSettings)); + this.folderBrowserDialog = new FolderBrowserDialog(); + this.gbOutputDiscImage = new GroupBox(); + this.btSelectOutputFolder = new Button(); + this.tbAppOutputFolder = new TextBox(); + this.gbExportOptions = new GroupBox(); + this.flpExportOptions = new FlowLayoutPanel(); + this.cbRegionFree = new CheckBox(); + this.cbForceVGA = new CheckBox(); + this.discViewOpener = new DiscViewOpener(); + this.gbOutputDiscImage.SuspendLayout(); + this.gbExportOptions.SuspendLayout(); + this.flpExportOptions.SuspendLayout(); + this.SuspendLayout(); + this.gbOutputDiscImage.BackColor = SystemColors.Window; + this.gbOutputDiscImage.Controls.Add((Control) this.btSelectOutputFolder); + this.gbOutputDiscImage.Controls.Add((Control) this.tbAppOutputFolder); + this.gbOutputDiscImage.Location = new Point(3, 60); + this.gbOutputDiscImage.Name = "gbOutputDiscImage"; + this.gbOutputDiscImage.Padding = new Padding(0); + this.gbOutputDiscImage.Size = new Size(473, 46); + this.gbOutputDiscImage.TabIndex = 1; + this.gbOutputDiscImage.TabStop = false; + this.gbOutputDiscImage.Text = " Output Disc Image:"; + this.btSelectOutputFolder.CausesValidation = false; + this.btSelectOutputFolder.FlatStyle = FlatStyle.Popup; + this.btSelectOutputFolder.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btSelectOutputFolder.ForeColor = Color.FromArgb(248, 48, 0); + this.btSelectOutputFolder.Location = new Point(388, 14); + this.btSelectOutputFolder.Name = "btSelectOutputFolder"; + this.btSelectOutputFolder.Size = new Size(79, 24); + this.btSelectOutputFolder.TabIndex = 2; + this.btSelectOutputFolder.Text = "..."; + this.btSelectOutputFolder.UseVisualStyleBackColor = false; + this.btSelectOutputFolder.Click += new EventHandler(this.btSelectOutputFolder_Click); + this.tbAppOutputFolder.BackColor = SystemColors.Window; + this.tbAppOutputFolder.Location = new Point(6, 17); + this.tbAppOutputFolder.Name = "tbAppOutputFolder"; + this.tbAppOutputFolder.ReadOnly = true; + this.tbAppOutputFolder.Size = new Size(376, 20); + this.tbAppOutputFolder.TabIndex = 3; + this.tbAppOutputFolder.TabStop = false; + this.gbExportOptions.BackColor = SystemColors.Window; + this.gbExportOptions.Controls.Add((Control) this.flpExportOptions); + this.gbExportOptions.Location = new Point(4, 112); + this.gbExportOptions.Name = "gbExportOptions"; + this.gbExportOptions.Padding = new Padding(3, 0, 3, 3); + this.gbExportOptions.Size = new Size(473, 42); + this.gbExportOptions.TabIndex = 4; + this.gbExportOptions.TabStop = false; + this.gbExportOptions.Text = "Export Options:"; + this.flpExportOptions.AutoSize = true; + this.flpExportOptions.Controls.Add((Control) this.cbRegionFree); + this.flpExportOptions.Controls.Add((Control) this.cbForceVGA); + this.flpExportOptions.Dock = DockStyle.Fill; + this.flpExportOptions.Location = new Point(3, 13); + this.flpExportOptions.Name = "flpExportOptions"; + this.flpExportOptions.Padding = new Padding(3); + this.flpExportOptions.Size = new Size(467, 26); + this.flpExportOptions.TabIndex = 0; + this.cbRegionFree.AutoSize = true; + this.cbRegionFree.Location = new Point(6, 6); + this.cbRegionFree.Name = "cbRegionFree"; + this.cbRegionFree.Size = new Size(84, 17); + this.cbRegionFree.TabIndex = 0; + this.cbRegionFree.Text = "Region Free"; + this.cbRegionFree.UseVisualStyleBackColor = true; + this.cbForceVGA.AutoSize = true; + this.cbForceVGA.Location = new Point(96, 6); + this.cbForceVGA.Name = "cbForceVGA"; + this.cbForceVGA.Size = new Size(78, 17); + this.cbForceVGA.TabIndex = 1; + this.cbForceVGA.Text = "Force VGA"; + this.cbForceVGA.UseVisualStyleBackColor = true; + this.discViewOpener.AutoSize = true; + this.discViewOpener.BackColor = SystemColors.Window; + this.discViewOpener.ButtonText = "&Open"; + this.discViewOpener.FileDialogFilters = (List) componentResourceManager.GetObject("discViewOpener.FileDialogFilters"); + this.discViewOpener.InitialDirectory = ""; + this.discViewOpener.Location = new Point(0, 0); + this.discViewOpener.Margin = new Padding(0); + this.discViewOpener.Name = "discViewOpener"; + this.discViewOpener.NotifyStatusEvents = false; + this.discViewOpener.Padding = new Padding(3); + this.discViewOpener.Size = new Size(479, 57); + this.discViewOpener.TabIndex = 0; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.AutoSize = true; + this.BackColor = SystemColors.Window; + this.Controls.Add((Control) this.gbExportOptions); + this.Controls.Add((Control) this.gbOutputDiscImage); + this.Controls.Add((Control) this.discViewOpener); + this.Name = nameof (GDEmuExportSettings); + this.Size = new Size(480, 157); + this.gbOutputDiscImage.ResumeLayout(false); + this.gbOutputDiscImage.PerformLayout(); + this.gbExportOptions.ResumeLayout(false); + this.gbExportOptions.PerformLayout(); + this.flpExportOptions.ResumeLayout(false); + this.flpExportOptions.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/UserControls/GDEmuExportSettings.resx b/Explorer/UserControls/GDEmuExportSettings.resx new file mode 100644 index 0000000..ca83e5a --- /dev/null +++ b/Explorer/UserControls/GDEmuExportSettings.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + AAEAAAD/////AQAAAAAAAAAEAQAAAH9TeXN0ZW0uQ29sbGVjdGlvbnMuR2VuZXJpYy5MaXN0YDFbW1N5c3RlbS5TdHJpbmcsIG1zY29ybGliLCBWZXJzaW9uPTIuMC4wLjAsIEN1bHR1cmU9bmV1dHJhbCwgUHVibGljS2V5VG9rZW49Yjc3YTVjNTYxOTM0ZTA4OV1dAwAAAAZfaXRlbXMFX3NpemUIX3ZlcnNpb24GAAAICAkCAAAAAQAAAAIAAAARAgAAAAQAAAAGAwAAAAQuZ2RpDQML + + \ No newline at end of file diff --git a/Explorer/UserControls/InitialProgramOpener.cs b/Explorer/UserControls/InitialProgramOpener.cs new file mode 100644 index 0000000..7896466 --- /dev/null +++ b/Explorer/UserControls/InitialProgramOpener.cs @@ -0,0 +1,115 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.InitialProgramOpener +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Forms; +using GDRomExplorer.Resources; +using SEGATools.Binary; +using SEGATools.Scanner; +using SEGATools.Security; +using SEGATools.VirtualFile; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class InitialProgramOpener : Component + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IWin32Window owner; + private FormLoading formLoading; + private IContainer components; + private BackgroundWorker backgroundWorker; + private OpenFileDialog openFileDialogForInitialProgram; + + public InitialProgramOpener() + { + this.InitializeComponent(); + this.Initialize(); + } + + private void Initialize() + { + this.openFileDialogForInitialProgram.Title = Strings.OfdInitialProgramTitle; + this.openFileDialogForInitialProgram.Filter = Strings.OfdInitialProgramFilter; + this.backgroundWorker.DoWork += new DoWorkEventHandler(this.bwOpenInitialProgramFile_DoWork); + this.backgroundWorker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(this.bwOpenInitialProgramFile_RunWorkerCompleted); + } + + public void OpenAndViewInitialProgram(IWin32Window owner) + { + this.owner = owner; + if (this.openFileDialogForInitialProgram.ShowDialog(owner) != DialogResult.OK) + return; + this.backgroundWorker.RunWorkerAsync((object) VirtualFileFactory.createVirtualFile(this.openFileDialogForInitialProgram.FileName)); + using (this.formLoading = new FormLoading(Strings.InitialProgramLoadingTitle, Strings.InitialProgramLoadingMessage)) + { + int num = (int) this.formLoading.ShowDialog(owner); + } + } + + private void bwOpenInitialProgramFile_DoWork(object sender, DoWorkEventArgs e) + { + IVirtualFile virtualFile1 = (IVirtualFile) e.Argument; + InitialProgram initialProgram; + using (Stream fileInputStream = virtualFile1.FileInputStream) + { + byte[] buffer = new byte[InitialProgramConverter.INITIAL_PROGRAM_SIZE]; + fileInputStream.Read(buffer, 0, buffer.Length); + initialProgram = InitialProgramConverter.ToInitialProgram(buffer, 0); + } + List libraries; + using (FileScanner fileScanner = new FileScanner()) + { + IVirtualFile virtualFile2 = (IVirtualFile) VirtualFileFactory.createVirtualFile(initialProgram.Stream, virtualFile1.OriginalFileName); + libraries = fileScanner.ScanFile(virtualFile2, FileScannerPattern.aPatternForSEGALibraries(), (IFileScannerResultConverter) new FileScannerResultConverterForSEGALibrary()); + } + e.Result = (object) InitialProgramExtended.create(initialProgram, libraries); + } + + private void bwOpenInitialProgramFile_RunWorkerCompleted( + object sender, + RunWorkerCompletedEventArgs e) + { + if (!this.formLoading.IsDisposed) + this.formLoading.Dispose(); + if (e.Error != null) + { + string str = string.Format(Strings.MsgBoxInitialProgramOpenerErrorWithFormat, (object) e.Error.Message); + InitialProgramOpener.logger.ErrorFormat("Unable to open ip: {0}", (object) e.Error); + int num = (int) MessageBox.Show(this.owner, str, Strings.MsgBoxInitialProgramOpenerTitle, MessageBoxButtons.OK, MessageBoxIcon.Hand); + AppStatus.NotifyNewAppStatus(str); + } + else + { + string fileName = this.openFileDialogForInitialProgram.FileName; + this.openFileDialogForInitialProgram.FileName = Path.GetFileName(fileName); + string message = string.Format(Strings.MsgBoxInitialProgramOpenerSuccessWithFormat, (object) fileName); + InitialProgramOpener.logger.InfoFormat("File {0} successfully opened", (object) fileName); + AppStatus.NotifyNewAppStatus(message); + using (FormInitialProgram formInitialProgram = new FormInitialProgram((InitialProgramExtended) e.Result, Path.GetDirectoryName(fileName))) + { + int num = (int) formInitialProgram.ShowDialog(this.owner); + } + } + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.backgroundWorker = new BackgroundWorker(); + this.openFileDialogForInitialProgram = new OpenFileDialog(); + this.openFileDialogForInitialProgram.Multiselect = true; + } + } +} diff --git a/Explorer/UserControls/InitialProgramOpener.resx b/Explorer/UserControls/InitialProgramOpener.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/UserControls/InitialProgramOpener.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/UserControls/NaomiEncryptDecryptTool.cs b/Explorer/UserControls/NaomiEncryptDecryptTool.cs new file mode 100644 index 0000000..93cbec3 --- /dev/null +++ b/Explorer/UserControls/NaomiEncryptDecryptTool.cs @@ -0,0 +1,131 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.NaomiEncryptDecryptTool +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Forms; +using GDRomExplorer.Resources; +using SEGATools.Encrypt; +using SEGATools.VirtualFile; +using System; +using System.ComponentModel; +using System.IO; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class NaomiEncryptDecryptTool : Component + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private IWin32Window owner; + public string InitialDirectory; + private IContainer components; + private OpenFileDialog openFileDialog; + private SaveFileDialog saveFileDialog; + + public NaomiEncryptDecryptTool() => this.InitializeComponent(); + + public NaomiEncryptDecryptTool(IContainer container) + { + container.Add((IComponent) this); + this.InitializeComponent(); + } + + public void OpenAndEncryptNaomiBinary(IWin32Window owner) + { + this.owner = owner; + this.ChangeFileDialogsForEncryption(); + NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder filesAndKeyHolder = this.OpenDialogsForInputAndOutputFiles(true); + if (filesAndKeyHolder == null) + return; + DesEncryptDecryptTool desDecryptor = new DesEncryptDecryptTool(); + Guid TaskId = Guid.NewGuid(); + FormProcess.createForDesEncryptor(desDecryptor, TaskId); + desDecryptor.EncryptAsync(filesAndKeyHolder.InputFile, filesAndKeyHolder.OutputFile, filesAndKeyHolder.DESKey, (object) TaskId); + } + + public void OpenAndDecryptNaomiBinary(IWin32Window owner) + { + this.owner = owner; + this.ChangeFileDialogsForDecryption(); + NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder filesAndKeyHolder = this.OpenDialogsForInputAndOutputFiles(false); + if (filesAndKeyHolder == null) + return; + DesEncryptDecryptTool desDecryptor = new DesEncryptDecryptTool(); + Guid TaskId = Guid.NewGuid(); + FormProcess.createForDesDecryptor(desDecryptor, TaskId); + desDecryptor.DecryptAsync(filesAndKeyHolder.InputFile, filesAndKeyHolder.OutputFile, filesAndKeyHolder.DESKey, (object) TaskId); + } + + private NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder OpenDialogsForInputAndOutputFiles( + bool isForEncryption) + { + if (this.openFileDialog.ShowDialog(this.owner) != DialogResult.OK) + return (NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder) null; + IVirtualFile virtualFile1 = (IVirtualFile) VirtualFileFactory.createVirtualFile(this.openFileDialog.FileName); + this.openFileDialog.InitialDirectory = Path.GetDirectoryName(this.openFileDialog.FileName); + this.openFileDialog.FileName = Path.GetFileName(this.openFileDialog.FileName); + FormGetDESKey formGetDesKey = !isForEncryption ? FormGetDESKey.aGetDESKeyFormWithDecryptLabel() : FormGetDESKey.aGetDESKeyFormWithEncryptLabel(); + if (formGetDesKey.ShowDialog(this.owner) != DialogResult.OK) + { + formGetDesKey.Dispose(); + return (NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder) null; + } + formGetDesKey.Dispose(); + DESKey desKey = formGetDesKey.DESKey; + this.saveFileDialog.FileName = Path.GetFileNameWithoutExtension(this.openFileDialog.FileName); + if (this.saveFileDialog.ShowDialog(this.owner) != DialogResult.OK) + return (NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder) null; + IVirtualFile virtualFile2 = (IVirtualFile) VirtualFileFactory.createVirtualFile(this.saveFileDialog.FileName); + this.saveFileDialog.InitialDirectory = Path.GetDirectoryName(this.saveFileDialog.FileName); + this.saveFileDialog.FileName = Path.GetFileName(this.saveFileDialog.FileName); + return new NaomiEncryptDecryptTool.InputOutputFilesAndKeyHolder() + { + InputFile = virtualFile1, + OutputFile = virtualFile2, + DESKey = desKey + }; + } + + private void ChangeFileDialogsForEncryption() + { + this.openFileDialog.Title = Strings.NaomiEncryptDecryptToolOfdEncTitle; + this.openFileDialog.Filter = Strings.NaomiEncryptDecryptToolOfdEncFilter; + this.openFileDialog.InitialDirectory = this.InitialDirectory; + this.saveFileDialog.Title = Strings.NaomiEncryptDecryptToolSfdEncTitle; + this.saveFileDialog.Filter = Strings.NaomiEncryptDecryptToolSfdEncFilter; + this.saveFileDialog.InitialDirectory = this.InitialDirectory; + } + + private void ChangeFileDialogsForDecryption() + { + this.openFileDialog.Title = Strings.NaomiEncryptDecryptToolOfdDecTitle; + this.openFileDialog.Filter = Strings.NaomiEncryptDecryptToolOfdDecFilter; + this.openFileDialog.InitialDirectory = this.InitialDirectory; + this.saveFileDialog.Title = Strings.NaomiEncryptDecryptToolSfdDecTitle; + this.saveFileDialog.Filter = Strings.NaomiEncryptDecryptToolSfdDecFilter; + this.saveFileDialog.InitialDirectory = this.InitialDirectory; + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.openFileDialog = new OpenFileDialog(); + this.saveFileDialog = new SaveFileDialog(); + } + + private class InputOutputFilesAndKeyHolder + { + public IVirtualFile InputFile; + public IVirtualFile OutputFile; + public DESKey DESKey; + } + } +} diff --git a/Explorer/UserControls/NaomiEncryptDecryptTool.resx b/Explorer/UserControls/NaomiEncryptDecryptTool.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/UserControls/NaomiEncryptDecryptTool.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/UserControls/PrimaryVolumeDescriptorViewer.cs b/Explorer/UserControls/PrimaryVolumeDescriptorViewer.cs new file mode 100644 index 0000000..6449413 --- /dev/null +++ b/Explorer/UserControls/PrimaryVolumeDescriptorViewer.cs @@ -0,0 +1,424 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.UserControls.PrimaryVolumeDescriptorViewer +// Assembly: GD-ROM Explorer, Version=1.6.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B7A7D10A-9A63-4E9E-9840-D297E5FC2219 +// Assembly location: GD-ROM Explorer.exe + +using GDRomExplorer.Resources; +using ImageReader.ISO9660.VolumeDescriptors; +using System; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace GDRomExplorer.UserControls +{ + public class PrimaryVolumeDescriptorViewer : UserControl + { + private IContainer components; + private TextBox tbVolumeSpaceSize; + private Label lbVolumeSpaceSize; + private TextBox tbVolumeNumber; + private Label lbVolumeNumber; + private TextBox tbVolumeSetId; + private Label lbVolumeSetId; + private TextBox tbVolumeCreationDate; + private Label lbVloumeCreationDate; + private TextBox tbVolumeModificationDate; + private Label lbVolumeModificationDate; + private TextBox tbVolumeExpirationDate; + private Label lbVolumeExpirationDate; + private TextBox tbVolumeEffectiveDate; + private Label lbVolumeEffectiveDate; + private TextBox tbSystemId; + private TextBox tbVolumeId; + private TextBox tbPublisherId; + private TextBox tbPreparerId; + private TextBox tbApplicationId; + private TextBox tbCopyrightFileId; + private TextBox tbAbstractFileId; + private TextBox tbBibliographicFileId; + private Label lbSystemId; + private Label lbVolumeId; + private Label nbPublisherId; + private Label lbPreparerId; + private Label lbApplicationId; + private Label lbCopyrightFileId; + private Label lbAbstractFileId; + private Label lbBibliographicFileId; + private TextBox tbLogicalBlockSize; + private Label lbLogicalBlockSize; + + public PrimaryVolumeDescriptorViewer() => this.InitializeComponent(); + + public void LoadPrimaryVolumeDescriptor(PrimaryVolumeDescriptor PrimaryVolumeDescriptor) + { + if (PrimaryVolumeDescriptor == null) + return; + this.tbSystemId.Text = PrimaryVolumeDescriptor.SystemIdentifier; + this.tbVolumeId.Text = PrimaryVolumeDescriptor.Identifier; + this.tbApplicationId.Text = PrimaryVolumeDescriptor.ApplicationIdentifier; + this.tbPublisherId.Text = PrimaryVolumeDescriptor.PublisherIdentifier; + this.tbPreparerId.Text = PrimaryVolumeDescriptor.PreparerIdentifier; + this.tbVolumeSetId.Text = PrimaryVolumeDescriptor.SetIdentifier; + this.tbVolumeSpaceSize.Text = string.Format("{0} blocks", (object) PrimaryVolumeDescriptor.SpaceSize); + this.tbVolumeNumber.Text = string.Format("{0}/{1}", (object) PrimaryVolumeDescriptor.SequenceNumber, (object) PrimaryVolumeDescriptor.SetSize); + this.tbLogicalBlockSize.Text = string.Format("{0} bytes", (object) PrimaryVolumeDescriptor.LogicalBlockSize); + this.UpdateDateTimeTextBox(this.tbVolumeCreationDate, PrimaryVolumeDescriptor.CreationDateTime); + this.UpdateDateTimeTextBox(this.tbVolumeModificationDate, PrimaryVolumeDescriptor.ModificationDateTime); + this.UpdateDateTimeTextBox(this.tbVolumeEffectiveDate, PrimaryVolumeDescriptor.EffectiveDateTime); + this.UpdateDateTimeTextBox(this.tbVolumeExpirationDate, PrimaryVolumeDescriptor.ExpirationDateTime); + this.tbAbstractFileId.Text = PrimaryVolumeDescriptor.AbstractFileIdentifier; + this.tbCopyrightFileId.Text = PrimaryVolumeDescriptor.CopyrightFileIdentifier; + this.tbBibliographicFileId.Text = PrimaryVolumeDescriptor.BibliographicFileIdentifier; + } + + private void UpdateDateTimeTextBox(TextBox dateTimeTextBox, DateTime? dateTime) + { + if (dateTime.HasValue) + dateTimeTextBox.Text = dateTime.Value.ToString(); + else + dateTimeTextBox.Text = Strings.InvalidDateTimeText; + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.tbVolumeSpaceSize = new TextBox(); + this.lbVolumeSpaceSize = new Label(); + this.tbVolumeNumber = new TextBox(); + this.lbVolumeNumber = new Label(); + this.tbVolumeSetId = new TextBox(); + this.lbVolumeSetId = new Label(); + this.tbVolumeCreationDate = new TextBox(); + this.lbVloumeCreationDate = new Label(); + this.tbVolumeModificationDate = new TextBox(); + this.lbVolumeModificationDate = new Label(); + this.tbVolumeExpirationDate = new TextBox(); + this.lbVolumeExpirationDate = new Label(); + this.tbVolumeEffectiveDate = new TextBox(); + this.lbVolumeEffectiveDate = new Label(); + this.tbSystemId = new TextBox(); + this.tbVolumeId = new TextBox(); + this.tbPublisherId = new TextBox(); + this.tbPreparerId = new TextBox(); + this.tbApplicationId = new TextBox(); + this.tbCopyrightFileId = new TextBox(); + this.tbAbstractFileId = new TextBox(); + this.tbBibliographicFileId = new TextBox(); + this.lbSystemId = new Label(); + this.lbVolumeId = new Label(); + this.nbPublisherId = new Label(); + this.lbPreparerId = new Label(); + this.lbApplicationId = new Label(); + this.lbCopyrightFileId = new Label(); + this.lbAbstractFileId = new Label(); + this.lbBibliographicFileId = new Label(); + this.tbLogicalBlockSize = new TextBox(); + this.lbLogicalBlockSize = new Label(); + this.SuspendLayout(); + this.tbVolumeSpaceSize.BackColor = SystemColors.Window; + this.tbVolumeSpaceSize.Location = new Point(414, 48); + this.tbVolumeSpaceSize.Margin = new Padding(2); + this.tbVolumeSpaceSize.Name = "tbVolumeSpaceSize"; + this.tbVolumeSpaceSize.ReadOnly = true; + this.tbVolumeSpaceSize.Size = new Size(155, 20); + this.tbVolumeSpaceSize.TabIndex = 9; + this.tbVolumeSpaceSize.TextAlign = HorizontalAlignment.Center; + this.lbVolumeSpaceSize.Location = new Point(277, 50); + this.lbVolumeSpaceSize.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeSpaceSize.MinimumSize = new Size(130, 13); + this.lbVolumeSpaceSize.Name = "lbVolumeSpaceSize"; + this.lbVolumeSpaceSize.Size = new Size(133, 13); + this.lbVolumeSpaceSize.TabIndex = 8; + this.lbVolumeSpaceSize.Text = "Volume Space Size:"; + this.lbVolumeSpaceSize.TextAlign = ContentAlignment.TopRight; + this.tbVolumeNumber.BackColor = SystemColors.Window; + this.tbVolumeNumber.Location = new Point(414, 26); + this.tbVolumeNumber.Margin = new Padding(2); + this.tbVolumeNumber.Name = "tbVolumeNumber"; + this.tbVolumeNumber.ReadOnly = true; + this.tbVolumeNumber.Size = new Size(155, 20); + this.tbVolumeNumber.TabIndex = 11; + this.tbVolumeNumber.TextAlign = HorizontalAlignment.Center; + this.lbVolumeNumber.Location = new Point(277, 28); + this.lbVolumeNumber.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeNumber.MinimumSize = new Size(130, 13); + this.lbVolumeNumber.Name = "lbVolumeNumber"; + this.lbVolumeNumber.Size = new Size(133, 13); + this.lbVolumeNumber.TabIndex = 10; + this.lbVolumeNumber.Text = "Volume Number:"; + this.lbVolumeNumber.TextAlign = ContentAlignment.TopRight; + this.tbVolumeSetId.BackColor = SystemColors.Window; + this.tbVolumeSetId.Location = new Point(414, 4); + this.tbVolumeSetId.Margin = new Padding(2); + this.tbVolumeSetId.Name = "tbVolumeSetId"; + this.tbVolumeSetId.ReadOnly = true; + this.tbVolumeSetId.Size = new Size(155, 20); + this.tbVolumeSetId.TabIndex = 23; + this.tbVolumeSetId.TextAlign = HorizontalAlignment.Center; + this.lbVolumeSetId.Location = new Point(277, 6); + this.lbVolumeSetId.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeSetId.MinimumSize = new Size(130, 13); + this.lbVolumeSetId.Name = "lbVolumeSetId"; + this.lbVolumeSetId.Size = new Size(133, 13); + this.lbVolumeSetId.TabIndex = 22; + this.lbVolumeSetId.Text = "Volume Set ID:"; + this.lbVolumeSetId.TextAlign = ContentAlignment.TopRight; + this.tbVolumeCreationDate.BackColor = SystemColors.Window; + this.tbVolumeCreationDate.Location = new Point(414, 114); + this.tbVolumeCreationDate.Margin = new Padding(2); + this.tbVolumeCreationDate.Name = "tbVolumeCreationDate"; + this.tbVolumeCreationDate.ReadOnly = true; + this.tbVolumeCreationDate.Size = new Size(155, 20); + this.tbVolumeCreationDate.TabIndex = 37; + this.tbVolumeCreationDate.TextAlign = HorizontalAlignment.Center; + this.lbVloumeCreationDate.Location = new Point(277, 116); + this.lbVloumeCreationDate.Margin = new Padding(2, 0, 2, 0); + this.lbVloumeCreationDate.MinimumSize = new Size(130, 13); + this.lbVloumeCreationDate.Name = "lbVloumeCreationDate"; + this.lbVloumeCreationDate.Size = new Size(133, 13); + this.lbVloumeCreationDate.TabIndex = 36; + this.lbVloumeCreationDate.Text = "Volume Creation Date:"; + this.lbVloumeCreationDate.TextAlign = ContentAlignment.TopRight; + this.tbVolumeModificationDate.BackColor = SystemColors.Window; + this.tbVolumeModificationDate.Location = new Point(414, 136); + this.tbVolumeModificationDate.Margin = new Padding(2); + this.tbVolumeModificationDate.Name = "tbVolumeModificationDate"; + this.tbVolumeModificationDate.ReadOnly = true; + this.tbVolumeModificationDate.Size = new Size(155, 20); + this.tbVolumeModificationDate.TabIndex = 39; + this.tbVolumeModificationDate.TextAlign = HorizontalAlignment.Center; + this.lbVolumeModificationDate.Location = new Point(277, 138); + this.lbVolumeModificationDate.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeModificationDate.MinimumSize = new Size(130, 13); + this.lbVolumeModificationDate.Name = "lbVolumeModificationDate"; + this.lbVolumeModificationDate.Size = new Size(133, 13); + this.lbVolumeModificationDate.TabIndex = 38; + this.lbVolumeModificationDate.Text = "Volume Modification Date:"; + this.lbVolumeModificationDate.TextAlign = ContentAlignment.TopRight; + this.tbVolumeExpirationDate.BackColor = SystemColors.Window; + this.tbVolumeExpirationDate.Location = new Point(414, 70); + this.tbVolumeExpirationDate.Margin = new Padding(2); + this.tbVolumeExpirationDate.Name = "tbVolumeExpirationDate"; + this.tbVolumeExpirationDate.ReadOnly = true; + this.tbVolumeExpirationDate.Size = new Size(155, 20); + this.tbVolumeExpirationDate.TabIndex = 41; + this.tbVolumeExpirationDate.TextAlign = HorizontalAlignment.Center; + this.lbVolumeExpirationDate.Location = new Point(277, 72); + this.lbVolumeExpirationDate.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeExpirationDate.MinimumSize = new Size(130, 13); + this.lbVolumeExpirationDate.Name = "lbVolumeExpirationDate"; + this.lbVolumeExpirationDate.Size = new Size(133, 13); + this.lbVolumeExpirationDate.TabIndex = 40; + this.lbVolumeExpirationDate.Text = "Volume Expiration Date:"; + this.lbVolumeExpirationDate.TextAlign = ContentAlignment.TopRight; + this.tbVolumeEffectiveDate.BackColor = SystemColors.Window; + this.tbVolumeEffectiveDate.Location = new Point(414, 92); + this.tbVolumeEffectiveDate.Margin = new Padding(2); + this.tbVolumeEffectiveDate.Name = "tbVolumeEffectiveDate"; + this.tbVolumeEffectiveDate.ReadOnly = true; + this.tbVolumeEffectiveDate.Size = new Size(155, 20); + this.tbVolumeEffectiveDate.TabIndex = 43; + this.tbVolumeEffectiveDate.TextAlign = HorizontalAlignment.Center; + this.lbVolumeEffectiveDate.Location = new Point(277, 94); + this.lbVolumeEffectiveDate.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeEffectiveDate.MinimumSize = new Size(130, 13); + this.lbVolumeEffectiveDate.Name = "lbVolumeEffectiveDate"; + this.lbVolumeEffectiveDate.Size = new Size(133, 13); + this.lbVolumeEffectiveDate.TabIndex = 42; + this.lbVolumeEffectiveDate.Text = "Volume Effective Date:"; + this.lbVolumeEffectiveDate.TextAlign = ContentAlignment.TopRight; + this.tbSystemId.BackColor = SystemColors.Window; + this.tbSystemId.Location = new Point(113, 4); + this.tbSystemId.Margin = new Padding(2); + this.tbSystemId.Name = "tbSystemId"; + this.tbSystemId.ReadOnly = true; + this.tbSystemId.Size = new Size(155, 20); + this.tbSystemId.TabIndex = 5; + this.tbSystemId.TextAlign = HorizontalAlignment.Center; + this.tbVolumeId.BackColor = SystemColors.Window; + this.tbVolumeId.Location = new Point(113, 26); + this.tbVolumeId.Margin = new Padding(2); + this.tbVolumeId.Name = "tbVolumeId"; + this.tbVolumeId.ReadOnly = true; + this.tbVolumeId.Size = new Size(155, 20); + this.tbVolumeId.TabIndex = 7; + this.tbVolumeId.TextAlign = HorizontalAlignment.Center; + this.tbPublisherId.BackColor = SystemColors.Window; + this.tbPublisherId.Location = new Point(113, 70); + this.tbPublisherId.Margin = new Padding(2); + this.tbPublisherId.Name = "tbPublisherId"; + this.tbPublisherId.ReadOnly = true; + this.tbPublisherId.Size = new Size(155, 20); + this.tbPublisherId.TabIndex = 25; + this.tbPublisherId.TextAlign = HorizontalAlignment.Center; + this.tbPreparerId.BackColor = SystemColors.Window; + this.tbPreparerId.Location = new Point(113, 92); + this.tbPreparerId.Margin = new Padding(2); + this.tbPreparerId.Name = "tbPreparerId"; + this.tbPreparerId.ReadOnly = true; + this.tbPreparerId.Size = new Size(155, 20); + this.tbPreparerId.TabIndex = 27; + this.tbPreparerId.TextAlign = HorizontalAlignment.Center; + this.tbApplicationId.BackColor = SystemColors.Window; + this.tbApplicationId.Location = new Point(113, 48); + this.tbApplicationId.Margin = new Padding(2); + this.tbApplicationId.Name = "tbApplicationId"; + this.tbApplicationId.ReadOnly = true; + this.tbApplicationId.Size = new Size(155, 20); + this.tbApplicationId.TabIndex = 29; + this.tbApplicationId.TextAlign = HorizontalAlignment.Center; + this.tbCopyrightFileId.BackColor = SystemColors.Window; + this.tbCopyrightFileId.Location = new Point(113, 114); + this.tbCopyrightFileId.Margin = new Padding(2); + this.tbCopyrightFileId.Name = "tbCopyrightFileId"; + this.tbCopyrightFileId.ReadOnly = true; + this.tbCopyrightFileId.Size = new Size(155, 20); + this.tbCopyrightFileId.TabIndex = 31; + this.tbCopyrightFileId.TextAlign = HorizontalAlignment.Center; + this.tbAbstractFileId.BackColor = SystemColors.Window; + this.tbAbstractFileId.Location = new Point(113, 136); + this.tbAbstractFileId.Margin = new Padding(2); + this.tbAbstractFileId.Name = "tbAbstractFileId"; + this.tbAbstractFileId.ReadOnly = true; + this.tbAbstractFileId.Size = new Size(155, 20); + this.tbAbstractFileId.TabIndex = 33; + this.tbAbstractFileId.TextAlign = HorizontalAlignment.Center; + this.tbBibliographicFileId.BackColor = SystemColors.Window; + this.tbBibliographicFileId.Location = new Point(113, 159); + this.tbBibliographicFileId.Margin = new Padding(2); + this.tbBibliographicFileId.Name = "tbBibliographicFileId"; + this.tbBibliographicFileId.ReadOnly = true; + this.tbBibliographicFileId.Size = new Size(155, 20); + this.tbBibliographicFileId.TabIndex = 35; + this.tbBibliographicFileId.TextAlign = HorizontalAlignment.Center; + this.lbSystemId.Location = new Point(2, 6); + this.lbSystemId.Margin = new Padding(2, 0, 2, 0); + this.lbSystemId.MinimumSize = new Size(107, 13); + this.lbSystemId.Name = "lbSystemId"; + this.lbSystemId.Size = new Size(107, 13); + this.lbSystemId.TabIndex = 4; + this.lbSystemId.Text = "System ID:"; + this.lbSystemId.TextAlign = ContentAlignment.TopRight; + this.lbVolumeId.Location = new Point(2, 28); + this.lbVolumeId.Margin = new Padding(2, 0, 2, 0); + this.lbVolumeId.MinimumSize = new Size(107, 13); + this.lbVolumeId.Name = "lbVolumeId"; + this.lbVolumeId.Size = new Size(107, 13); + this.lbVolumeId.TabIndex = 6; + this.lbVolumeId.Text = "Volume ID:"; + this.lbVolumeId.TextAlign = ContentAlignment.TopRight; + this.nbPublisherId.Location = new Point(2, 72); + this.nbPublisherId.Margin = new Padding(2, 0, 2, 0); + this.nbPublisherId.MinimumSize = new Size(107, 13); + this.nbPublisherId.Name = "nbPublisherId"; + this.nbPublisherId.Size = new Size(107, 13); + this.nbPublisherId.TabIndex = 24; + this.nbPublisherId.Text = "Publisher ID:"; + this.nbPublisherId.TextAlign = ContentAlignment.TopRight; + this.lbPreparerId.Location = new Point(2, 94); + this.lbPreparerId.Margin = new Padding(2, 0, 2, 0); + this.lbPreparerId.MinimumSize = new Size(107, 13); + this.lbPreparerId.Name = "lbPreparerId"; + this.lbPreparerId.Size = new Size(107, 13); + this.lbPreparerId.TabIndex = 26; + this.lbPreparerId.Text = "Preparer ID:"; + this.lbPreparerId.TextAlign = ContentAlignment.TopRight; + this.lbApplicationId.Location = new Point(2, 50); + this.lbApplicationId.Margin = new Padding(2, 0, 2, 0); + this.lbApplicationId.MinimumSize = new Size(107, 13); + this.lbApplicationId.Name = "lbApplicationId"; + this.lbApplicationId.Size = new Size(107, 13); + this.lbApplicationId.TabIndex = 28; + this.lbApplicationId.Text = "Application ID:"; + this.lbApplicationId.TextAlign = ContentAlignment.TopRight; + this.lbCopyrightFileId.Location = new Point(2, 116); + this.lbCopyrightFileId.Margin = new Padding(2, 0, 2, 0); + this.lbCopyrightFileId.MinimumSize = new Size(107, 13); + this.lbCopyrightFileId.Name = "lbCopyrightFileId"; + this.lbCopyrightFileId.Size = new Size(107, 13); + this.lbCopyrightFileId.TabIndex = 30; + this.lbCopyrightFileId.Text = "Copyright File ID:"; + this.lbCopyrightFileId.TextAlign = ContentAlignment.TopRight; + this.lbAbstractFileId.Location = new Point(2, 138); + this.lbAbstractFileId.Margin = new Padding(2, 0, 2, 0); + this.lbAbstractFileId.MinimumSize = new Size(107, 13); + this.lbAbstractFileId.Name = "lbAbstractFileId"; + this.lbAbstractFileId.Size = new Size(107, 13); + this.lbAbstractFileId.TabIndex = 32; + this.lbAbstractFileId.Text = "Abstract File ID:"; + this.lbAbstractFileId.TextAlign = ContentAlignment.TopRight; + this.lbBibliographicFileId.Location = new Point(2, 161); + this.lbBibliographicFileId.Margin = new Padding(2, 0, 2, 0); + this.lbBibliographicFileId.MinimumSize = new Size(107, 13); + this.lbBibliographicFileId.Name = "lbBibliographicFileId"; + this.lbBibliographicFileId.Size = new Size(107, 13); + this.lbBibliographicFileId.TabIndex = 34; + this.lbBibliographicFileId.Text = "Bibliographic File ID:"; + this.lbBibliographicFileId.TextAlign = ContentAlignment.TopRight; + this.tbLogicalBlockSize.BackColor = SystemColors.Window; + this.tbLogicalBlockSize.Location = new Point(414, 159); + this.tbLogicalBlockSize.Margin = new Padding(2); + this.tbLogicalBlockSize.Name = "tbLogicalBlockSize"; + this.tbLogicalBlockSize.ReadOnly = true; + this.tbLogicalBlockSize.Size = new Size(155, 20); + this.tbLogicalBlockSize.TabIndex = 45; + this.tbLogicalBlockSize.TextAlign = HorizontalAlignment.Center; + this.lbLogicalBlockSize.Location = new Point(277, 161); + this.lbLogicalBlockSize.Margin = new Padding(2, 0, 2, 0); + this.lbLogicalBlockSize.MinimumSize = new Size(130, 13); + this.lbLogicalBlockSize.Name = "lbLogicalBlockSize"; + this.lbLogicalBlockSize.Size = new Size(133, 13); + this.lbLogicalBlockSize.TabIndex = 44; + this.lbLogicalBlockSize.Text = "Logical Block Size:"; + this.lbLogicalBlockSize.TextAlign = ContentAlignment.TopRight; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.AutoSize = true; + this.Controls.Add((Control) this.tbLogicalBlockSize); + this.Controls.Add((Control) this.lbLogicalBlockSize); + this.Controls.Add((Control) this.tbVolumeEffectiveDate); + this.Controls.Add((Control) this.lbVolumeEffectiveDate); + this.Controls.Add((Control) this.tbVolumeExpirationDate); + this.Controls.Add((Control) this.lbVolumeExpirationDate); + this.Controls.Add((Control) this.tbVolumeModificationDate); + this.Controls.Add((Control) this.lbVolumeModificationDate); + this.Controls.Add((Control) this.tbVolumeCreationDate); + this.Controls.Add((Control) this.lbVloumeCreationDate); + this.Controls.Add((Control) this.tbBibliographicFileId); + this.Controls.Add((Control) this.lbBibliographicFileId); + this.Controls.Add((Control) this.tbAbstractFileId); + this.Controls.Add((Control) this.lbAbstractFileId); + this.Controls.Add((Control) this.tbCopyrightFileId); + this.Controls.Add((Control) this.lbCopyrightFileId); + this.Controls.Add((Control) this.tbApplicationId); + this.Controls.Add((Control) this.lbApplicationId); + this.Controls.Add((Control) this.tbPreparerId); + this.Controls.Add((Control) this.lbPreparerId); + this.Controls.Add((Control) this.tbPublisherId); + this.Controls.Add((Control) this.nbPublisherId); + this.Controls.Add((Control) this.tbVolumeSetId); + this.Controls.Add((Control) this.lbVolumeSetId); + this.Controls.Add((Control) this.tbVolumeNumber); + this.Controls.Add((Control) this.lbVolumeNumber); + this.Controls.Add((Control) this.tbVolumeSpaceSize); + this.Controls.Add((Control) this.lbVolumeSpaceSize); + this.Controls.Add((Control) this.tbVolumeId); + this.Controls.Add((Control) this.lbVolumeId); + this.Controls.Add((Control) this.tbSystemId); + this.Controls.Add((Control) this.lbSystemId); + this.Margin = new Padding(2); + this.Name = nameof (PrimaryVolumeDescriptorViewer); + this.Size = new Size(575, 181); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/Explorer/UserControls/PrimaryVolumeDescriptorViewer.resx b/Explorer/UserControls/PrimaryVolumeDescriptorViewer.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/Explorer/UserControls/PrimaryVolumeDescriptorViewer.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Explorer/app.config b/Explorer/app.config new file mode 100644 index 0000000..fb11b44 --- /dev/null +++ b/Explorer/app.config @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Explorer/log4net.config b/Explorer/log4net.config new file mode 100644 index 0000000..5cafcaf --- /dev/null +++ b/Explorer/log4net.config @@ -0,0 +1,56 @@ + + + + + +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Explorer/packages.config b/Explorer/packages.config new file mode 100644 index 0000000..7f6923a --- /dev/null +++ b/Explorer/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/Formats/BIN/AssemblyInfo.cs b/Formats/BIN/AssemblyInfo.cs new file mode 100644 index 0000000..3a4fd4d --- /dev/null +++ b/Formats/BIN/AssemblyInfo.cs @@ -0,0 +1,14 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("GD-ROM Explorer BIN File Format")] +[assembly: AssemblyDescription("BIN File Format Plugin")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyProduct("GD-ROM Explorer - BIN File Format Plugin")] +[assembly: AssemblyCopyright("2014 - 2016")] +[assembly: AssemblyTrademark("")] +[assembly: ComVisible(true)] +[assembly: Guid("47b79a6e-d9b7-483d-8013-ffcdab185e81")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: AssemblyVersion("1.0.0.0")] diff --git a/Formats/BIN/BIN.csproj b/Formats/BIN/BIN.csproj new file mode 100644 index 0000000..750a313 --- /dev/null +++ b/Formats/BIN/BIN.csproj @@ -0,0 +1,59 @@ + + + + + Debug + AnyCPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627} + Library + BIN + v3.5 + 1.0.0.0 + 512 + GDRomExplorer.ImageFileFormat.BIN + + + + + 3.5 + + + AnyCPU + true + full + false + ..\..\bin\Debug\Formats\ + DEBUG;TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + Auto + + + AnyCPU + pdbonly + true + ..\..\bin\Release\Formats\ + TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + False + + + {4d3ab913-88d2-4dd1-a403-ea46d14c98e6} + SEGATools + False + + + + \ No newline at end of file diff --git a/Formats/BIN/BIN.sln b/Formats/BIN/BIN.sln new file mode 100644 index 0000000..87f0258 --- /dev/null +++ b/Formats/BIN/BIN.sln @@ -0,0 +1,24 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31424.327 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BIN", "BIN.csproj", "{9BE87EC9-C89C-4521-BB87-5BBD997FA627}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {C79035C8-8C85-4D9F-B588-D7C8F12994ED} + EndGlobalSection +EndGlobal diff --git a/Formats/BIN/BinaryImageFormat.cs b/Formats/BIN/BinaryImageFormat.cs new file mode 100644 index 0000000..5af3e8b --- /dev/null +++ b/Formats/BIN/BinaryImageFormat.cs @@ -0,0 +1,27 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.BIN.BinaryImageFormat +// Assembly: BIN, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: 6DE81A29-0420-4189-8D61-5DDF40D77BD6 +// Assembly location: C:\Games\gdrom\Formats\BIN.dll + +using ImageReader.DiscSectors; +using SEGATools.DiscFileSystem; +using SEGATools.FileFormat; + +namespace GDRomExplorer.ImageFileFormat.BIN +{ + internal class BinaryImageFormat : AbstractImageFileFormat + { + public override string[] FileExtentions => new string[1] + { + ".bin" + }; + + public override string[] FileExtentionDescriptions => new string[1] + { + "Binary image file" + }; + + public override IDiscFileSystemConverter ImageFileConverter => (IDiscFileSystemConverter) new GenericImageConverter((IDiscSector) new CDROMMode1RawSector()); + } +} diff --git a/Formats/CDI/AssemblyInfo.cs b/Formats/CDI/AssemblyInfo.cs new file mode 100644 index 0000000..ce75e51 --- /dev/null +++ b/Formats/CDI/AssemblyInfo.cs @@ -0,0 +1,14 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyCopyright("2014 - 2016")] +[assembly: AssemblyTitle("GD-ROM Explorer CDI File Format")] +[assembly: AssemblyDescription("CDI File Format Plugin")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyProduct("GD-ROM Explorer - CDI File Format Plugin")] +[assembly: Guid("0dae2017-8888-4e40-a4aa-798856425b20")] +[assembly: AssemblyTrademark("")] +[assembly: ComVisible(true)] +[assembly: AssemblyFileVersion("1.0.1.0")] +[assembly: AssemblyVersion("1.0.1.0")] diff --git a/Formats/CDI/CDI.csproj b/Formats/CDI/CDI.csproj new file mode 100644 index 0000000..4516467 --- /dev/null +++ b/Formats/CDI/CDI.csproj @@ -0,0 +1,64 @@ + + + + + Debug + AnyCPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24} + Library + CDI + v3.5 + 1.0.1.0 + 512 + GDRomExplorer.ImageFileFormat.CDI + + + + + 3.5 + + + AnyCPU + true + full + false + ..\..\bin\Debug\Formats\ + DEBUG;TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + AnyCPU + pdbonly + true + ..\..\bin\Release\Formats\ + TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + + + + + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + False + + + {4d3ab913-88d2-4dd1-a403-ea46d14c98e6} + SEGATools + False + + + + \ No newline at end of file diff --git a/Formats/CDI/CDI.sln b/Formats/CDI/CDI.sln new file mode 100644 index 0000000..bc1ce41 --- /dev/null +++ b/Formats/CDI/CDI.sln @@ -0,0 +1,20 @@ + +Microsoft Visual Studio Solution File, Format Version 10.00 +# Visual Studio 2008 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CDI", "CDI.csproj", "{A3861387-BB2E-4C3A-9AB2-43B77C393C24}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Formats/CDI/CDIHeader.cs b/Formats/CDI/CDIHeader.cs new file mode 100644 index 0000000..5ce82b7 --- /dev/null +++ b/Formats/CDI/CDIHeader.cs @@ -0,0 +1,15 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIHeader +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal class CDIHeader + { + internal CDIVersion cdiVersion; + internal uint rawCdiVersion; + internal uint headerOffset; + } +} diff --git a/Formats/CDI/CDIHeaderConverter.cs b/Formats/CDI/CDIHeaderConverter.cs new file mode 100644 index 0000000..eab7e37 --- /dev/null +++ b/Formats/CDI/CDIHeaderConverter.cs @@ -0,0 +1,35 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIHeaderConverter +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +using SEGATools.DiscFileSystem; +using System; +using System.IO; + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal class CDIHeaderConverter + { + private static readonly byte HEADER_MIN_SIZE = 8; + private static readonly short HEADER_OFFSET = -8; + private static readonly short HEADER_SIZE = 8; + + internal static CDIHeader ToCDIHeader(Stream imageStream) + { + if (imageStream.Length < (long) CDIHeaderConverter.HEADER_MIN_SIZE) + throw new DiscFormatException("The stream is too small"); + CDIHeader cdiHeader = new CDIHeader(); + byte[] buffer = new byte[(int) CDIHeaderConverter.HEADER_SIZE]; + imageStream.Seek((long) CDIHeaderConverter.HEADER_OFFSET, SeekOrigin.End); + imageStream.Read(buffer, 0, (int) CDIHeaderConverter.HEADER_SIZE); + cdiHeader.rawCdiVersion = BitConverter.ToUInt32(buffer, 0); + cdiHeader.cdiVersion = cdiHeader.rawCdiVersion == 2147483652U || cdiHeader.rawCdiVersion == 2147483653U || cdiHeader.rawCdiVersion == 2147483654U ? (CDIVersion) cdiHeader.rawCdiVersion : CDIVersion.CDI_VERSION_UNKNOWN; + cdiHeader.headerOffset = BitConverter.ToUInt32(buffer, 4); + if (cdiHeader.cdiVersion > CDIVersion.CDI_VERSION_3) + cdiHeader.headerOffset = (uint) imageStream.Length - cdiHeader.headerOffset; + return cdiHeader; + } + } +} diff --git a/Formats/CDI/CDIImageBuilder.cs b/Formats/CDI/CDIImageBuilder.cs new file mode 100644 index 0000000..dffb709 --- /dev/null +++ b/Formats/CDI/CDIImageBuilder.cs @@ -0,0 +1,27 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIImageBuilder +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +using SEGATools.DiscFileSystem; +using System.IO; + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + public class CDIImageBuilder : IDiscFileSystemConverter + { + public IDiscFileSystem ToDiscFileSystem(string imageFileName) + { + CDIHeader cdiHeader; + using (FileStream fileStream = File.Open(imageFileName, FileMode.Open, FileAccess.Read, FileShare.Read)) + cdiHeader = CDIHeaderConverter.ToCDIHeader((Stream) fileStream); + if (cdiHeader.cdiVersion == CDIVersion.CDI_VERSION_UNKNOWN) + throw new DiscFormatException(string.Format("Unsupported CDI version 0x{0:X}", (object) cdiHeader.rawCdiVersion)); + CDIToc cdiToc = (CDIToc) null; + using (FileStream fileStream = File.Open(imageFileName, FileMode.Open, FileAccess.Read, FileShare.Read)) + cdiToc = CDITocConverter.ToCdiToc(cdiHeader, (Stream) fileStream, imageFileName); + return (IDiscFileSystem) new SEGATools.DiscFileSystem.DiscFileSystem(imageFileName, cdiToc.sessions, true, false); + } + } +} diff --git a/Formats/CDI/CDIImageFormat.cs b/Formats/CDI/CDIImageFormat.cs new file mode 100644 index 0000000..686a774 --- /dev/null +++ b/Formats/CDI/CDIImageFormat.cs @@ -0,0 +1,26 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIImageFormat +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +using SEGATools.DiscFileSystem; +using SEGATools.FileFormat; + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal class CDIImageFormat : AbstractImageFileFormat + { + public override string[] FileExtentions => new string[1] + { + ".cdi" + }; + + public override string[] FileExtentionDescriptions => new string[1] + { + "DiscJuggler image file" + }; + + public override IDiscFileSystemConverter ImageFileConverter => (IDiscFileSystemConverter) new CDIImageBuilder(); + } +} diff --git a/Formats/CDI/CDIToc.cs b/Formats/CDI/CDIToc.cs new file mode 100644 index 0000000..775f774 --- /dev/null +++ b/Formats/CDI/CDIToc.cs @@ -0,0 +1,25 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIToc +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +using SEGATools.DiscFileSystem; +using System.Collections.Generic; + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal class CDIToc + { + internal CDIHeader cdiHeader; + internal ushort numberOfSessions; + internal ushort[] numberOfTracks; + internal List sessions; + + internal CDIToc(CDIHeader cdiHeader) + { + this.cdiHeader = cdiHeader; + this.sessions = new List(); + } + } +} diff --git a/Formats/CDI/CDITocConverter.cs b/Formats/CDI/CDITocConverter.cs new file mode 100644 index 0000000..62330ea --- /dev/null +++ b/Formats/CDI/CDITocConverter.cs @@ -0,0 +1,245 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDITocConverter +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +using ImageReader.DiscSectors; +using SEGATools; +using SEGATools.DiscFileSystem; +using System; +using System.Collections.Generic; +using System.IO; + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal class CDITocConverter + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly int NUMBER_OF_SESSIONS_OFFSET = 0; + private static readonly int TRACK_INFO_LENGTH = 58; + private static readonly int TRACK_INFO_TRACK_PREGAP_OFFSET = 0; + private static readonly int TRACK_INFO_TRACK_LENGTH_OFFSET = 4; + private static readonly int TRACK_INFO_TRACK_MODE_OFFSET = 14; + private static readonly int TRACK_INFO_TRACK_LBA_OFFSET = 30; + private static readonly int TRACK_INFO_TRACK_TOTAL_LENGTH_OFFSET = 34; + private static readonly int TRACK_INFO_TRACK_SECTOR_SIZE_OFFSET = 54; + private static readonly byte[] TRACK_START_MARKER = new byte[10] + { + (byte) 0, + (byte) 0, + (byte) 1, + (byte) 0, + (byte) 0, + (byte) 0, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue + }; + private static readonly byte[] TRACK_END_MARKER = new byte[5] + { + (byte) 0, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue + }; + + internal static CDIToc ToCdiToc( + CDIHeader cdiHeader, + Stream imageStream, + string imageFileName) + { + CDIToc cdiToc = new CDIToc(cdiHeader); + imageStream.Seek((long) cdiHeader.headerOffset, SeekOrigin.Begin); + cdiToc.numberOfSessions = CDITocConverter.ReadNumberOfSessions(imageStream); + cdiToc.numberOfTracks = new ushort[(int) cdiToc.numberOfSessions]; + ushort num1 = 0; + uint startOffset = 0; + for (; imageStream.Position < imageStream.Length && (int) num1 < (int) cdiToc.numberOfSessions; ++num1) + { + cdiToc.numberOfTracks[(int) num1] = CDITocConverter.ReadNumberOfTracks(imageStream); + ushort trackIndex = 0; + List tracks = new List(); + byte[] buffer = new byte[4]; + for (; (int) trackIndex < (int) cdiToc.numberOfTracks[(int) num1]; ++trackIndex) + { + imageStream.Read(buffer, 0, buffer.Length); + if (BitConverter.ToUInt32(buffer, 0) != 0U) + imageStream.Seek(8L, SeekOrigin.Current); + if (!CDITocConverter.HasTrackStartMarkers(imageStream)) + throw new DiscFormatException("Invalid start-of-track marker"); + imageStream.Seek(4L, SeekOrigin.Current); + int num2 = imageStream.ReadByte(); + imageStream.Seek((long) (num2 + 1), SeekOrigin.Current); + imageStream.Seek(10L, SeekOrigin.Current); + imageStream.Read(buffer, 0, buffer.Length); + uint uint32 = BitConverter.ToUInt32(buffer, 0); + if (uint32 != 2U) + throw new DiscFormatException(string.Format("Invalid marker: {0}", (object) uint32)); + imageStream.Seek(4L, SeekOrigin.Current); + if (cdiHeader.cdiVersion > CDIVersion.CDI_VERSION_3) + { + imageStream.Read(buffer, 0, buffer.Length); + if (BitConverter.ToUInt32(buffer, 0) == 2147483648U) + imageStream.Seek(8L, SeekOrigin.Current); + } + else + imageStream.Seek(4L, SeekOrigin.Current); + imageStream.Seek(2L, SeekOrigin.Current); + uint totalLength; + DiscTrack discTrack = CDITocConverter.ReadTrackInfo(imageStream, imageFileName, trackIndex, startOffset, out totalLength); + tracks.Add((IDiscTrack) discTrack); + startOffset += totalLength; + imageStream.Seek(25L, SeekOrigin.Current); + imageStream.Seek(4L, SeekOrigin.Current); + if (cdiHeader.cdiVersion > CDIVersion.CDI_VERSION_2) + { + if (!CDITocConverter.CheckTrackEndMarkers(imageStream)) + throw new DiscFormatException("Invalid end-of-track marker"); + imageStream.Read(buffer, 0, buffer.Length); + if (BitConverter.ToUInt32(buffer, 0) == uint.MaxValue) + imageStream.Seek(78L, SeekOrigin.Current); + } + } + if (tracks.Count > 0) + cdiToc.sessions.Add((IDiscSession) new DiscSession((int) num1 + 1, string.Format(DiscSession.DEFAULT_SESSION_NAME_WITH_FORMAT, (object) ((int) num1 + 1)), tracks)); + imageStream.Seek(12L, SeekOrigin.Current); + if (cdiHeader.cdiVersion > CDIVersion.CDI_VERSION_2) + imageStream.Seek(1L, SeekOrigin.Current); + } + return cdiToc; + } + + private static ushort ReadNumberOfSessions(Stream imageStream) + { + byte[] buffer = new byte[2]; + imageStream.Read(buffer, 0, buffer.Length); + return BitConverter.ToUInt16(buffer, CDITocConverter.NUMBER_OF_SESSIONS_OFFSET); + } + + private static ushort ReadNumberOfTracks(Stream imageStream) + { + byte[] buffer = new byte[2]; + imageStream.Read(buffer, 0, buffer.Length); + ushort uint16 = BitConverter.ToUInt16(buffer, 0); + return uint16 <= (ushort) 99 ? uint16 : throw new DiscFormatException(string.Format("Too many tracks: maximum is 99, got {0}", (object) uint16)); + } + + private static DiscTrack ReadTrackInfo( + Stream imageStream, + string imageFileName, + ushort trackIndex, + uint startOffset, + out uint totalLength) + { + byte[] buffer1 = new byte[CDITocConverter.TRACK_INFO_LENGTH]; + imageStream.Read(buffer1, 0, buffer1.Length); + uint uint32_1 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_PREGAP_OFFSET); + uint uint32_2 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_LENGTH_OFFSET); + uint uint32_3 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_MODE_OFFSET); + uint uint32_4 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_LBA_OFFSET); + uint uint32_5 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_TOTAL_LENGTH_OFFSET); + uint uint32_6 = BitConverter.ToUInt32(buffer1, CDITocConverter.TRACK_INFO_TRACK_SECTOR_SIZE_OFFSET); + if ((int) uint32_1 + (int) uint32_2 != (int) uint32_5) + throw new DiscFormatException(string.Format("Truncated track {0}: expected {1} bytes, got {2} bytes", (object) ((int) trackIndex + 1), (object) uint32_5, (object) (uint) ((int) uint32_1 + (int) uint32_2))); + uint trackSectorSize = CDITocConverter.GetTrackSectorSize(uint32_6); + uint num = startOffset + uint32_1 * trackSectorSize; + totalLength = uint32_5 * trackSectorSize; + TrackModeType trackModeType = CDITocConverter.ValidateTrackMode(uint32_3); + IDiscSector trackSector = (IDiscSector) null; + try + { + using (FileStream fileStream = File.Open(imageFileName, FileMode.Open, FileAccess.Read, FileShare.Read)) + { + byte[] buffer2 = new byte[DiscSectorCommon.RawSectorSize]; + fileStream.Seek((long) num, SeekOrigin.Begin); + fileStream.Read(buffer2, 0, buffer2.Length); + trackSector = CDITocConverter.ValidateTrackSector(trackSectorSize, trackModeType, buffer2); + } + } + catch (Exception ex) + { + logger.Error(ex); + throw new DiscFormatException(string.Format("Unable to read the track {0} of the file {1}", (object) ((int) trackIndex + 1), (object) imageFileName)); + } + return new DiscTrack(imageFileName, (long) (int) num, (long) (uint32_2 * trackSectorSize), uint32_4, (int) trackIndex + 1, trackModeType, trackSector); + } + + private static TrackModeType ValidateTrackMode(uint trackMode) + { + switch (trackMode) + { + case 0: + return TrackModeType.Audio; + case 2: + return TrackModeType.Data; + default: + throw new DiscFormatException(string.Format("Invalid track mode: {0:X}", (object) trackMode)); + } + } + + private static uint GetTrackSectorSize(uint trackSectorType) + { + switch (trackSectorType) + { + case 0: + return 2048; + case 1: + return 2336; + case 2: + return 2352; + default: + throw new DiscFormatException(string.Format("Invalid track sector: {0:X}", (object) trackSectorType)); + } + } + + private static IDiscSector ValidateTrackSector( + uint trackSector, + TrackModeType trackModeType, + byte[] buffer) + { + switch (trackSector) + { + case 2048: + return (IDiscSector) new ISO9660Sector(); + case 2336: + return (IDiscSector) new CDROMXAMode2Form1Sector(); + case 2352: + if (trackModeType == TrackModeType.Audio) + return (IDiscSector) new RawSector(); + return CDROMFrameHeaderConverter.ToCDROMFrameHeader(buffer, 0) == CDROMDataModeType.MODE1_RAW ? (IDiscSector) new CDROMMode1RawSector() : (IDiscSector) new CDROMXAMode2Form1RawSector(); + default: + throw new DiscFormatException(string.Format("Invalid track sector size: {0:X}", (object) trackSector)); + } + } + + private static bool HasTrackStartMarkers(Stream imageStream) + { + byte[] buffer = new byte[CDITocConverter.TRACK_START_MARKER.Length]; + for (ushort index1 = 0; index1 < (ushort) 2; ++index1) + { + imageStream.Read(buffer, 0, buffer.Length); + for (ushort index2 = 0; (int) index2 < buffer.Length; ++index2) + { + if ((int) buffer[(int) index2] != (int) CDITocConverter.TRACK_START_MARKER[(int) index2]) + return false; + } + } + return true; + } + + private static bool CheckTrackEndMarkers(Stream imageStream) + { + byte[] buffer = new byte[CDITocConverter.TRACK_END_MARKER.Length]; + imageStream.Read(buffer, 0, buffer.Length); + for (ushort index = 0; (int) index < buffer.Length; ++index) + { + if ((int) buffer[(int) index] != (int) CDITocConverter.TRACK_END_MARKER[(int) index]) + return false; + } + return true; + } + } +} diff --git a/Formats/CDI/CDIVersion.cs b/Formats/CDI/CDIVersion.cs new file mode 100644 index 0000000..57f027a --- /dev/null +++ b/Formats/CDI/CDIVersion.cs @@ -0,0 +1,16 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.CDI.CDIVersion +// Assembly: CDI, Version=1.0.1.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: B71D3BB5-2FC4-43C2-853E-907E3A458120 +// Assembly location: Formats\CDI.dll + +namespace GDRomExplorer.ImageFileFormat.CDI +{ + internal enum CDIVersion : uint + { + CDI_VERSION_UNKNOWN = 0, + CDI_VERSION_2 = 2147483652, // 0x80000004 + CDI_VERSION_3 = 2147483653, // 0x80000005 + CDI_VERSION_35 = 2147483654, // 0x80000006 + } +} diff --git a/Formats/GDI/AssemblyInfo.cs b/Formats/GDI/AssemblyInfo.cs new file mode 100644 index 0000000..3b47c6d --- /dev/null +++ b/Formats/GDI/AssemblyInfo.cs @@ -0,0 +1,14 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyCopyright("2014 - 2016")] +[assembly: AssemblyTitle("GD-ROM Explorer GDI File Format")] +[assembly: AssemblyDescription("GDI File Format Plugin")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyProduct("GD-ROM Explorer - GDI File Format Plugin")] +[assembly: AssemblyTrademark("")] +[assembly: ComVisible(true)] +[assembly: Guid("d7bec06d-acf2-4d01-a319-8978bb4c951a")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: AssemblyVersion("1.0.0.0")] diff --git a/Formats/GDI/GDI.csproj b/Formats/GDI/GDI.csproj new file mode 100644 index 0000000..cc3777a --- /dev/null +++ b/Formats/GDI/GDI.csproj @@ -0,0 +1,67 @@ + + + + + Debug + AnyCPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA} + Library + GDI + v3.5 + 1.0.0.0 + 512 + GDRomExplorer.ImageFileFormat.GDI + + + + + 3.5 + + + AnyCPU + true + full + false + ..\..\bin\Debug\Formats\ + DEBUG;TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + AnyCPU + pdbonly + true + ..\..\bin\Release\Formats\ + TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + + + + + + + + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + False + + + {4d3ab913-88d2-4dd1-a403-ea46d14c98e6} + SEGATools + False + + + + \ No newline at end of file diff --git a/Formats/GDI/GDIFileSystemValidator.cs b/Formats/GDI/GDIFileSystemValidator.cs new file mode 100644 index 0000000..a694a61 --- /dev/null +++ b/Formats/GDI/GDIFileSystemValidator.cs @@ -0,0 +1,111 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.GDIFileSystemValidator +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + internal class GDIFileSystemValidator : IGDIFileSystemValidator + { + private static readonly int TRACK_MINIMUM_SIZE_IN_SECTORS = 300; + private IInitialProgramProvider IpProvider; + + public GDIFileSystemValidator(IInitialProgramProvider IpProvider) => this.IpProvider = IpProvider; + + public void CheckDiscFileSystem(IDiscFileSystem disc) + { + IDiscSession session1 = disc.Sessions[0]; + IDiscSession session2 = disc.Sessions[1]; + InitialProgram initialProgram = this.IpProvider.GetInitialProgram(session2.FirstDataTrack); + this.CheckInitialProgramAndHighDensityTracksMatch(initialProgram, session2); + this.CheckInitialProgramAndHighDensitySizesMatch(initialProgram, session2); + List list = session1.Tracks.Concat((IEnumerable) session2.Tracks).ToList(); + this.CheckTrackIndexesAreConsecutive((IList) list); + this.CheckTrackGapAndOverlap((IList) list); + } + + public void CheckDiscTrackSize(IDiscTrack track) + { + if (track.Length % (long) track.TrackSector.Size != 0L || track.Length / (long) track.TrackSector.Size < (long) GDIFileSystemValidator.TRACK_MINIMUM_SIZE_IN_SECTORS) + throw new DiscFormatException(string.Format("Invalid track size: {0} must be at least {1} bytes long and its size must a multiple of {2}.", (object) Path.GetFileName(track.FileName), (object) GDIFileSystemValidator.TRACK_MINIMUM_SIZE_IN_SECTORS, (object) track.TrackSector.Size)); + } + + private void CheckTrackIndexesAreConsecutive(IList tracks) + { + IDiscTrack discTrack = (IDiscTrack) null; + foreach (IDiscTrack track in (IEnumerable) tracks) + { + if (discTrack != null && discTrack.Index + 1 != track.Index) + throw new DiscFormatException(string.Format("Track indexes are not consecutive: track with index {0} is missing", (object) track.Index)); + discTrack = track; + } + } + + private void CheckTrackGapAndOverlap(IList tracks) + { + IDiscTrack discTrack = (IDiscTrack) null; + foreach (IDiscTrack track in (IEnumerable) tracks) + { + if (discTrack != null) + { + long num1 = (long) discTrack.LogicalBlockAddress + discTrack.Length / (long) discTrack.TrackSector.Size - 1L; + int num2 = discTrack.TrackData != track.TrackData ? 150 : 0; + if (this.AreTracksOverlapping(num1 + (long) num2, (long) track.LogicalBlockAddress)) + throw new DiscFormatException(string.Format("Tracks overlap detected: track {0} overlaps track {1}", (object) Path.GetFileName(discTrack.FileName), (object) Path.GetFileName(track.FileName))); + if (discTrack.Session == track.Session && !this.AreTracksContinuous(num1 + (long) num2, (long) track.LogicalBlockAddress)) + throw new DiscFormatException(string.Format("Gap between tracks: tracks {0} and {1} are not continuous", (object) Path.GetFileName(discTrack.FileName), (object) Path.GetFileName(track.FileName))); + } + discTrack = track; + } + } + + private void CheckInitialProgramAndHighDensityTracksMatch( + InitialProgram initialProgram, + IDiscSession highDensity) + { + this.CheckInitialProgramAndHighDensityTrackCountsMatch(initialProgram, highDensity); + for (int index = 0; index < initialProgram.TableOfContent.Tracks.Count; ++index) + { + InitialProgramTrackInfo track1 = initialProgram.TableOfContent.Tracks[index]; + IDiscTrack track2 = highDensity.Tracks[index]; + long track2size = track2.Length / (long)track2.TrackSector.Size; + if (track2size != (long) track1.Size) + throw new DiscFormatException(string.Format("Invalid track size: {0} must be {1} sectors long", (object) track2, (object) track1.Size)); + } + } + + private void CheckInitialProgramAndHighDensitySizesMatch( + InitialProgram initialProgram, + IDiscSession highDensity) + { + long num1 = 0; + foreach (IDiscTrack track in highDensity.Tracks) + num1 += track.Length / (long) track.TrackSector.Size; + long num2 = initialProgram.TableOfContent.Tracks.Sum((Func) (track => (long) track.Size)); + if (num1 != num2) + throw new DiscFormatException(string.Format("Invalid session size: the high density session must be {0} sectors long", (object) num2)); + } + + private void CheckInitialProgramAndHighDensityTrackCountsMatch( + InitialProgram initialProgram, + IDiscSession highDensity) + { + if (initialProgram.TableOfContent == null) + throw new DiscFormatException("Invalid boot sector: the boot sector does not contain a valid TOC"); + if (initialProgram.TableOfContent.Tracks.Count != highDensity.Tracks.Count) + throw new DiscFormatException(string.Format("Invalid number of tracks: the boot sector indicates {0} tracks whereas the {1} contains {2}", (object) initialProgram.TableOfContent.Tracks.Count, (object) highDensity.Name, (object) highDensity.Tracks.Count)); + } + + private bool AreTracksOverlapping(long firstTrackEndLBA, long secondTrackStartLBA) => firstTrackEndLBA >= secondTrackStartLBA; + + private bool AreTracksContinuous(long firstTrackEndLBA, long secondTrackStartLBA) => firstTrackEndLBA + 1L == secondTrackStartLBA; + } +} diff --git a/Formats/GDI/GDImageBuilder.cs b/Formats/GDI/GDImageBuilder.cs new file mode 100644 index 0000000..7f99b40 --- /dev/null +++ b/Formats/GDI/GDImageBuilder.cs @@ -0,0 +1,117 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.GDImageBuilder +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using ImageReader.DiscSectors; +using SEGATools.DiscFileSystem; +using System.Collections.Generic; +using System.IO; +using System.Text.RegularExpressions; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + public class GDImageBuilder : IDiscFileSystemConverter + { + private static readonly Regex gdiRegex = new Regex("^(?[1-9]|[1-9][0-9]?)[ \\t]+(?[0-9]{1,6}?)[ \\t]+(?0|4?)[ \\t]+(?2352|2048?)[ \\t]+(?\".+\\.\\S{1,4}\"|\\S+\\.\\S{1,4}?)[ \\t]+(?[+-]*[0-9]{1,6}?)[ \\t]*$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.CultureInvariant); + private static readonly string FIRST_SESSION_NAME = "Single Density"; + private static readonly string SECOND_SESSION_NAME = "High Density"; + private static readonly int HIGH_DENSITY_START_LBA = 45000; + private static readonly bool SUPPORT_DATA_EXTRACTION = true; + private static readonly bool SUPPORT_CUE_EXPORT = true; + private static readonly bool SUPPORT_GDI_EXPORT = true; + protected IGDIFileSystemValidator Validator; + protected IInitialProgramProvider IpProvider; + + public GDImageBuilder() + { + this.IpProvider = (IInitialProgramProvider) new InitialProgramProvider(); + this.Validator = (IGDIFileSystemValidator) new GDIFileSystemValidator(this.IpProvider); + } + + public IDiscFileSystem ToDiscFileSystem(string imageFileName) + { + short result1 = 0; + short num1 = 0; + List tracks1 = new List(); + List tracks2 = new List(); + short num2 = 1; + using (StreamReader streamReader = new StreamReader(imageFileName)) + { + if (!short.TryParse(streamReader.ReadLine().Trim(), out result1)) + throw new DiscFormatException(string.Format("Wrong track index at line {0}", (object) num2)); + short num3 = (short) ((int) num2 + 1); + if (result1 > (short) 99) + throw new DiscFormatException(string.Format("Too many tracks: maximum is 99, got {0}", (object) result1)); + while (!streamReader.EndOfStream) + { + string input = streamReader.ReadLine().Trim(); + if (string.IsNullOrEmpty(input)) + { + ++num3; + } + else + { + Match match = GDImageBuilder.gdiRegex.Match(input); + if (!match.Success) + throw new DiscFormatException(string.Format("Unable to parse track at line {0}", (object) num3)); + TrackModeType trackData; + if (match.Groups["type"].Value == "4") + { + trackData = TrackModeType.Data; + } + else + { + if (!(match.Groups["type"].Value == "0")) + throw new DiscFormatException(string.Format("Wrong track type: got {0} whereas 0 for audio or 4 for data was expected", (object) match.Groups["type"].Value)); + trackData = TrackModeType.Audio; + } + IDiscSector trackSector; + if (match.Groups["mode"].Value == "2352") + { + trackSector = trackData != TrackModeType.Data ? (IDiscSector) new RawSector() : (IDiscSector) new CDROMMode1RawSector(); + } + else + { + if (!(match.Groups["mode"].Value == "2048")) + throw new DiscFormatException(string.Format("Wrong track mode: got {0} whereas 2352 or 2048 was expected", (object) match.Groups["mode"].Value)); + trackSector = (IDiscSector) new ISO9660Sector(); + } + int result2; + if (!int.TryParse(match.Groups["index"].Value, out result2)) + throw new DiscFormatException(string.Format("Wrong track index: {0}", (object) match.Groups["index"].Value)); + uint result3; + if (!uint.TryParse(match.Groups["lba"].Value, out result3)) + throw new DiscFormatException(string.Format("Wrong logical block address: {0}", (object) match.Groups["lba"].Value)); + int result4; + if (!int.TryParse(match.Groups["offset"].Value, out result4)) + throw new DiscFormatException(string.Format("Wrong offset: {0}", (object) match.Groups["offset"].Value)); + string str = match.Groups["filename"].Value.Trim().Replace("\"", ""); + if (!Path.IsPathRooted(str)) + str = Path.Combine(Path.GetDirectoryName(imageFileName), str); + FileInfo fileInfo = File.Exists(str) ? new FileInfo(str) : throw new DiscFormatException(string.Format("File missing: {0}", (object) str)); + IDiscTrack track = (IDiscTrack) new DiscTrack(str, (long) result4, fileInfo.Length, result3, result2, trackData, trackSector); + this.Validator.CheckDiscTrackSize(track); + if ((long) track.LogicalBlockAddress < (long) GDImageBuilder.HIGH_DENSITY_START_LBA) + tracks1.Add(track); + else + tracks2.Add(track); + ++num1; + ++num3; + } + } + if ((int) result1 != (int) num1) + throw new DiscFormatException(string.Format("Number of tracks doesn't match: expected {0}, got {1}", (object) result1, (object) num1)); + } + List sessions = new List() + { + (IDiscSession) new DiscSession(1, GDImageBuilder.FIRST_SESSION_NAME, tracks1), + (IDiscSession) new DiscSession(2, GDImageBuilder.SECOND_SESSION_NAME, tracks2) + }; + SEGATools.DiscFileSystem.DiscFileSystem discFileSystem = new SEGATools.DiscFileSystem.DiscFileSystem(imageFileName, sessions, GDImageBuilder.SUPPORT_DATA_EXTRACTION, GDImageBuilder.SUPPORT_CUE_EXPORT, GDImageBuilder.SUPPORT_GDI_EXPORT); + this.Validator.CheckDiscFileSystem((IDiscFileSystem) discFileSystem); + return (IDiscFileSystem) discFileSystem; + } + } +} diff --git a/Formats/GDI/GDImageFormat.cs b/Formats/GDI/GDImageFormat.cs new file mode 100644 index 0000000..5793790 --- /dev/null +++ b/Formats/GDI/GDImageFormat.cs @@ -0,0 +1,26 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.GDImageFormat +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using SEGATools.DiscFileSystem; +using SEGATools.FileFormat; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + internal class GDImageFormat : AbstractImageFileFormat + { + public override string[] FileExtentions => new string[1] + { + ".gdi" + }; + + public override string[] FileExtentionDescriptions => new string[1] + { + "GDROM image file" + }; + + public override IDiscFileSystemConverter ImageFileConverter => (IDiscFileSystemConverter) new GDImageBuilder(); + } +} diff --git a/Formats/GDI/IGDIFileSystemValidator.cs b/Formats/GDI/IGDIFileSystemValidator.cs new file mode 100644 index 0000000..6aab1a1 --- /dev/null +++ b/Formats/GDI/IGDIFileSystemValidator.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.IGDIFileSystemValidator +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using SEGATools.DiscFileSystem; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + public interface IGDIFileSystemValidator + { + void CheckDiscTrackSize(IDiscTrack track); + + void CheckDiscFileSystem(IDiscFileSystem disc); + } +} diff --git a/Formats/GDI/IInitialProgramProvider.cs b/Formats/GDI/IInitialProgramProvider.cs new file mode 100644 index 0000000..3e7513a --- /dev/null +++ b/Formats/GDI/IInitialProgramProvider.cs @@ -0,0 +1,16 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.IInitialProgramProvider +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using SEGATools.DiscFileSystem; +using SEGATools.Security; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + public interface IInitialProgramProvider + { + InitialProgram GetInitialProgram(IDiscTrack track); + } +} diff --git a/Formats/GDI/InitialProgramProvider.cs b/Formats/GDI/InitialProgramProvider.cs new file mode 100644 index 0000000..4e48288 --- /dev/null +++ b/Formats/GDI/InitialProgramProvider.cs @@ -0,0 +1,34 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.GDI.InitialProgramProvider +// Assembly: GDI, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: F4295E7C-8421-4324-B5B1-F38932DD6235 +// Assembly location: Formats\GDI.dll + +using ImageReader.Stream; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using System; + +namespace GDRomExplorer.ImageFileFormat.GDI +{ + public class InitialProgramProvider : IInitialProgramProvider + { + public InitialProgram GetInitialProgram(IDiscTrack track) + { + try + { + byte[] buffer; + using (DiscSectorStream discSectorStream = new DiscSectorStream(track.FileInputStream, track.TrackSector)) + { + buffer = new byte[(int) InitialProgram.IP_FILESIZE]; + discSectorStream.Read(buffer, 0, buffer.Length); + } + return InitialProgramConverter.ToInitialProgram(buffer, 0); + } + catch (Exception ex) + { + throw new DiscFormatException(string.Format("Invalid boot sector: {0} does not contain a valid boot sector (IP)", (object) track), ex); + } + } + } +} diff --git a/Formats/ISO9660/AssemblyInfo.cs b/Formats/ISO9660/AssemblyInfo.cs new file mode 100644 index 0000000..8e72e35 --- /dev/null +++ b/Formats/ISO9660/AssemblyInfo.cs @@ -0,0 +1,14 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("GD-ROM Explorer ISO9660 File Format")] +[assembly: AssemblyDescription("ISO9660 File Format Plugin")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyProduct("GD-ROM Explorer - ISO9660 File Format Plugin")] +[assembly: AssemblyCopyright("2014 - 2016")] +[assembly: AssemblyTrademark("")] +[assembly: ComVisible(true)] +[assembly: Guid("f024f756-98ed-4ffa-b06b-baf386b755a5")] +[assembly: AssemblyFileVersion("1.0.0.0")] +[assembly: AssemblyVersion("1.0.0.0")] diff --git a/Formats/ISO9660/ISO9660.csproj b/Formats/ISO9660/ISO9660.csproj new file mode 100644 index 0000000..d3c894b --- /dev/null +++ b/Formats/ISO9660/ISO9660.csproj @@ -0,0 +1,58 @@ + + + + + Debug + AnyCPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49} + Library + ISO9660 + v3.5 + 1.0.0.0 + 512 + GDRomExplorer.ImageFileFormat.ISO9660 + + + + + 3.5 + + + AnyCPU + true + full + false + ..\..\bin\Debug\Formats\ + DEBUG;TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + AnyCPU + pdbonly + true + ..\..\bin\Release\Formats\ + TRACE + prompt + 4 + MinimumRecommendedRules.ruleset + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + False + + + {4d3ab913-88d2-4dd1-a403-ea46d14c98e6} + SEGATools + False + + + + \ No newline at end of file diff --git a/Formats/ISO9660/ISO9660ImageFormat.cs b/Formats/ISO9660/ISO9660ImageFormat.cs new file mode 100644 index 0000000..5ad811c --- /dev/null +++ b/Formats/ISO9660/ISO9660ImageFormat.cs @@ -0,0 +1,27 @@ +// Decompiled with JetBrains decompiler +// Type: GDRomExplorer.ImageFileFormat.ISO9660.ISO9660ImageFormat +// Assembly: ISO9660, Version=1.0.0.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: 05C13092-F2D8-4D43-9750-90851EBE12FD +// Assembly location: Formats\ISO9660.dll + +using ImageReader.DiscSectors; +using SEGATools.DiscFileSystem; +using SEGATools.FileFormat; + +namespace GDRomExplorer.ImageFileFormat.ISO9660 +{ + internal class ISO9660ImageFormat : AbstractImageFileFormat + { + public override string[] FileExtentions => new string[1] + { + ".iso" + }; + + public override string[] FileExtentionDescriptions => new string[1] + { + "ISO9660 image file" + }; + + public override IDiscFileSystemConverter ImageFileConverter => (IDiscFileSystemConverter) new GenericImageConverter((IDiscSector) new ISO9660Sector()); + } +} diff --git a/GD-ROM Explorer.sln b/GD-ROM Explorer.sln new file mode 100644 index 0000000..59bad6e --- /dev/null +++ b/GD-ROM Explorer.sln @@ -0,0 +1,79 @@ +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31424.327 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Explorer", "Explorer\Explorer.csproj", "{47780501-F392-43CA-A50C-9479421B4B55}" + ProjectSection(ProjectDependencies) = postProject + {A3861387-BB2E-4C3A-9AB2-43B77C393C24} = {A3861387-BB2E-4C3A-9AB2-43B77C393C24} + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA} = {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA} + {9BE87EC9-C89C-4521-BB87-5BBD997FA627} = {9BE87EC9-C89C-4521-BB87-5BBD997FA627} + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49} = {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49} + EndProjectSection +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ImageReader", "ImageReader\ImageReader.csproj", "{2185F55E-A4DA-486F-ACC8-3EE955205CE4}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SEGATools", "SEGATools\SEGATools.csproj", "{4D3AB913-88D2-4DD1-A403-EA46D14C98E6}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "BIN", "Formats\BIN\BIN.csproj", "{9BE87EC9-C89C-4521-BB87-5BBD997FA627}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CDI", "Formats\CDI\CDI.csproj", "{A3861387-BB2E-4C3A-9AB2-43B77C393C24}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GDI", "Formats\GDI\GDI.csproj", "{F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ISO9660", "Formats\ISO9660\ISO9660.csproj", "{A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Formats", "Formats", "{1FADE202-9C96-4560-B03E-4997F11A700D}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C70EE165-6677-45E7-A9BB-31C309151B4F}" + ProjectSection(SolutionItems) = preProject + .editorconfig = .editorconfig + EndProjectSection +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {47780501-F392-43CA-A50C-9479421B4B55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Debug|Any CPU.Build.0 = Debug|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Release|Any CPU.ActiveCfg = Release|Any CPU + {47780501-F392-43CA-A50C-9479421B4B55}.Release|Any CPU.Build.0 = Release|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4}.Release|Any CPU.Build.0 = Release|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6}.Release|Any CPU.Build.0 = Release|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9BE87EC9-C89C-4521-BB87-5BBD997FA627}.Release|Any CPU.Build.0 = Release|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A3861387-BB2E-4C3A-9AB2-43B77C393C24}.Release|Any CPU.Build.0 = Release|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Debug|Any CPU.Build.0 = Debug|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Release|Any CPU.ActiveCfg = Release|Any CPU + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA}.Release|Any CPU.Build.0 = Release|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Debug|Any CPU.Build.0 = Debug|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Release|Any CPU.ActiveCfg = Release|Any CPU + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(NestedProjects) = preSolution + {9BE87EC9-C89C-4521-BB87-5BBD997FA627} = {1FADE202-9C96-4560-B03E-4997F11A700D} + {A3861387-BB2E-4C3A-9AB2-43B77C393C24} = {1FADE202-9C96-4560-B03E-4997F11A700D} + {F2CB9EB0-0934-48B0-952F-8BFC5DC97BAA} = {1FADE202-9C96-4560-B03E-4997F11A700D} + {A0814BED-4F13-4C76-AAE6-BAA35F9EEB49} = {1FADE202-9C96-4560-B03E-4997F11A700D} + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {B500B1BD-BB99-4FFC-8B90-459648214A7E} + EndGlobalSection +EndGlobal diff --git a/ImageReader/AssemblyGitBuildBranch.cs b/ImageReader/AssemblyGitBuildBranch.cs new file mode 100644 index 0000000..d7e7543 --- /dev/null +++ b/ImageReader/AssemblyGitBuildBranch.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.AssemblyGitBuildBranch +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; + +namespace ImageReader +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildBranch : Attribute + { + public string GitBuildBranch { get; private set; } + + public AssemblyGitBuildBranch(string txt) => this.GitBuildBranch = txt; + } +} diff --git a/ImageReader/AssemblyGitBuildSHA1.cs b/ImageReader/AssemblyGitBuildSHA1.cs new file mode 100644 index 0000000..4cc0a8d --- /dev/null +++ b/ImageReader/AssemblyGitBuildSHA1.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.AssemblyGitBuildSHA1 +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; + +namespace ImageReader +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildSHA1 : Attribute + { + public string GitBuildSHA1 { get; private set; } + + public AssemblyGitBuildSHA1(string txt) => this.GitBuildSHA1 = txt; + } +} diff --git a/ImageReader/AssemblyInfo.cs b/ImageReader/AssemblyInfo.cs new file mode 100644 index 0000000..350337a --- /dev/null +++ b/ImageReader/AssemblyInfo.cs @@ -0,0 +1,17 @@ +using ImageReader; +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyGitBuildBranch("release_1.6.3")] +[assembly: AssemblyFileVersion("1.5.2")] +[assembly: AssemblyGitBuildSHA1("fd2eb45")] +[assembly: AssemblyTitle("Image Reader")] +[assembly: AssemblyDescription("ImageReader.dll")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyProduct("Image Reader")] +[assembly: AssemblyCopyright("2012-2016")] +[assembly: AssemblyTrademark("")] +[assembly: ComVisible(true)] +[assembly: Guid("d23954c0-4b76-497a-bcac-66de624f695f")] +[assembly: AssemblyVersion("1.5.2.0")] \ No newline at end of file diff --git a/ImageReader/AssemblyTest.cs b/ImageReader/AssemblyTest.cs new file mode 100644 index 0000000..66c448f --- /dev/null +++ b/ImageReader/AssemblyTest.cs @@ -0,0 +1,12 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.AssemblyTest +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader +{ + public class AssemblyTest + { + } +} diff --git a/ImageReader/DiscSectors/CDROMDataModeType.cs b/ImageReader/DiscSectors/CDROMDataModeType.cs new file mode 100644 index 0000000..463be66 --- /dev/null +++ b/ImageReader/DiscSectors/CDROMDataModeType.cs @@ -0,0 +1,14 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.CDROMDataModeType +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public enum CDROMDataModeType : byte + { + MODE1_RAW = 1, + MODE2_RAW = 2, + } +} diff --git a/ImageReader/DiscSectors/CDROMFrameHeaderConverter.cs b/ImageReader/DiscSectors/CDROMFrameHeaderConverter.cs new file mode 100644 index 0000000..022af47 --- /dev/null +++ b/ImageReader/DiscSectors/CDROMFrameHeaderConverter.cs @@ -0,0 +1,58 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.CDROMFrameHeaderConverter +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; + +namespace ImageReader.DiscSectors +{ + public class CDROMFrameHeaderConverter + { + public static readonly ushort CDROM_FRAME_HEADER_SIZE = 16; + private static readonly byte[] CDROM_FRAME_HEADER_SYNC = new byte[12] + { + (byte) 0, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + byte.MaxValue, + (byte) 0 + }; + + public static CDROMDataModeType ToCDROMFrameHeader( + byte[] buffer, + int startIndex) + { + if (buffer.Length < startIndex + (int) CDROMFrameHeaderConverter.CDROM_FRAME_HEADER_SIZE) + throw new ArgumentOutOfRangeException(); + GCHandle gcHandle = GCHandle.Alloc((object) buffer, GCHandleType.Pinned); + CDROMFrameHeaderConverter.CDROMFrameHeader structure = (CDROMFrameHeaderConverter.CDROMFrameHeader) Marshal.PtrToStructure(gcHandle.AddrOfPinnedObject(), typeof (CDROMFrameHeaderConverter.CDROMFrameHeader)); + gcHandle.Free(); + if (((IEnumerable) CDROMFrameHeaderConverter.CDROM_FRAME_HEADER_SYNC).Where((Func) ((t, i) => (int) t != (int) buffer[i])).Any()) + throw new FormatException(); + return Enum.IsDefined(typeof (CDROMDataModeType), (object) structure.Mode) ? structure.Mode : throw new FormatException(); + } + + [StructLayout(LayoutKind.Explicit, Size = 16)] + private struct CDROMFrameHeader + { + [FieldOffset(0)] + public byte Sync; + [FieldOffset(12)] + public byte Address; + [FieldOffset(15)] + public CDROMDataModeType Mode; + } + } +} diff --git a/ImageReader/DiscSectors/CDROMMode1RawSector.cs b/ImageReader/DiscSectors/CDROMMode1RawSector.cs new file mode 100644 index 0000000..003eaaa --- /dev/null +++ b/ImageReader/DiscSectors/CDROMMode1RawSector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.CDROMMode1RawSector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class CDROMMode1RawSector : DiscSectorBase + { + public override int Size => 2352; + + public override int DataOffset => 16; + + public override int DataLength => 2048; + } +} diff --git a/ImageReader/DiscSectors/CDROMXAMode2Form1RawSector.cs b/ImageReader/DiscSectors/CDROMXAMode2Form1RawSector.cs new file mode 100644 index 0000000..c0c8b24 --- /dev/null +++ b/ImageReader/DiscSectors/CDROMXAMode2Form1RawSector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.CDROMXAMode2Form1RawSector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class CDROMXAMode2Form1RawSector : DiscSectorBase + { + public override int Size => 2352; + + public override int DataOffset => 24; + + public override int DataLength => 2048; + } +} diff --git a/ImageReader/DiscSectors/CDROMXAMode2Form1Sector.cs b/ImageReader/DiscSectors/CDROMXAMode2Form1Sector.cs new file mode 100644 index 0000000..f000100 --- /dev/null +++ b/ImageReader/DiscSectors/CDROMXAMode2Form1Sector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.CDROMXAMode2Form1Sector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class CDROMXAMode2Form1Sector : DiscSectorBase + { + public override int Size => 2336; + + public override int DataOffset => 8; + + public override int DataLength => 2048; + } +} diff --git a/ImageReader/DiscSectors/DiscSectorBase.cs b/ImageReader/DiscSectors/DiscSectorBase.cs new file mode 100644 index 0000000..280b687 --- /dev/null +++ b/ImageReader/DiscSectors/DiscSectorBase.cs @@ -0,0 +1,33 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.DiscSectorBase +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; + +namespace ImageReader.DiscSectors +{ + public abstract class DiscSectorBase : IDiscSector + { + public override bool Equals(object obj) + { + if (obj == null) + return false; + if (this == obj) + return true; + if (!(obj is IDiscSector)) + return false; + IDiscSector discSector = obj as IDiscSector; + return this.Size == discSector.Size && this.DataOffset == discSector.DataOffset && this.DataLength == discSector.DataLength; + } + + public override int GetHashCode() => ((17 * 23 + this.Size) * 23 + this.DataOffset) * 23 + this.DataLength; + + public virtual int Size => throw new NotImplementedException(); + + public virtual int DataOffset => throw new NotImplementedException(); + + public virtual int DataLength => throw new NotImplementedException(); + } +} diff --git a/ImageReader/DiscSectors/DiscSectorCommon.cs b/ImageReader/DiscSectors/DiscSectorCommon.cs new file mode 100644 index 0000000..850f2b3 --- /dev/null +++ b/ImageReader/DiscSectors/DiscSectorCommon.cs @@ -0,0 +1,14 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.DiscSectorCommon +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class DiscSectorCommon + { + public static readonly int RawSectorSize = 2352; + public static readonly int LogicalSectorSize = 2048; + } +} diff --git a/ImageReader/DiscSectors/IDiscSector.cs b/ImageReader/DiscSectors/IDiscSector.cs new file mode 100644 index 0000000..43f107d --- /dev/null +++ b/ImageReader/DiscSectors/IDiscSector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.IDiscSector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public interface IDiscSector + { + int Size { get; } + + int DataOffset { get; } + + int DataLength { get; } + } +} diff --git a/ImageReader/DiscSectors/ISO9660Sector.cs b/ImageReader/DiscSectors/ISO9660Sector.cs new file mode 100644 index 0000000..ce7eafa --- /dev/null +++ b/ImageReader/DiscSectors/ISO9660Sector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.ISO9660Sector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class ISO9660Sector : DiscSectorBase + { + public override int Size => 2048; + + public override int DataOffset => 0; + + public override int DataLength => 2048; + } +} diff --git a/ImageReader/DiscSectors/RawSector.cs b/ImageReader/DiscSectors/RawSector.cs new file mode 100644 index 0000000..0572fe1 --- /dev/null +++ b/ImageReader/DiscSectors/RawSector.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscSectors.RawSector +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.DiscSectors +{ + public class RawSector : DiscSectorBase + { + public override int Size => 2352; + + public override int DataOffset => 0; + + public override int DataLength => 2352; + } +} diff --git a/ImageReader/ISO9660/DirectoryRecords/DirectoryRecord.cs b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecord.cs new file mode 100644 index 0000000..7b68751 --- /dev/null +++ b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecord.cs @@ -0,0 +1,199 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.DirectoryRecords.DirectoryRecord +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; + +namespace ImageReader.ISO9660.DirectoryRecords +{ + public class DirectoryRecord + { + public static readonly char DIRECTORY_SEPARATOR_CHAR = Path.DirectorySeparatorChar; + public static readonly string DIRECTORY_SEPARATOR = DirectoryRecord.DIRECTORY_SEPARATOR_CHAR.ToString(); + public static readonly string ROOT_DIRECTORY_NAME = DirectoryRecord.DIRECTORY_SEPARATOR_CHAR.ToString(); + public static readonly string SELF_DIRECTORY_NAME = "."; + public static readonly string PARENT_DIRECTORY_NAME = ".."; + internal static readonly byte ROOT_OR_SELF_DIRECTORY_FILE_IDENTIFIER = 0; + internal static readonly byte PARENT_DIRECTORY_FILE_IDENTIFIER = 1; + internal ushort extendAttributeLength; + internal uint extentTypeL; + internal uint extentTypeM; + internal uint extentSizeTypeL; + internal uint extentSizeTypeM; + internal ushort fileUnitSize; + internal ushort fileGapSize; + internal ushort volumeSequenceNumberTypeL; + internal ushort volumeSequenceNumberTypeM; + internal DirectoryRecord parent; + internal List children; + + public static string FindCommonPathPrefix(List directoryRecords) + { + if (directoryRecords.Count < 1) + return (string) null; + Dictionary source = new Dictionary(); + foreach (DirectoryRecord directoryRecord in directoryRecords) + source[directoryRecord] = directoryRecord.IsDirectory ? directoryRecord.FullPath : Path.GetDirectoryName(directoryRecord.FullPath); + int minDepth = source.Min>((Func, int>) (pkv => pkv.Value.Split(new char[1] + { + DirectoryRecord.DIRECTORY_SEPARATOR_CHAR + }, StringSplitOptions.RemoveEmptyEntries).Length)); + string pathPrefix = source.First>((Func, bool>) (pkv => pkv.Value.Split(new char[1] + { + DirectoryRecord.DIRECTORY_SEPARATOR_CHAR + }, StringSplitOptions.RemoveEmptyEntries).Length == minDepth)).Value; + for (int index = 0; index < minDepth && !directoryRecords.TrueForAll((Predicate) (dr => dr.FullPath.StartsWith(pathPrefix))); ++index) + pathPrefix = Path.GetDirectoryName(pathPrefix); + if (directoryRecords.Count == 1 && directoryRecords[0].IsDirectory && !directoryRecords[0].IsRoot) + pathPrefix = Path.GetDirectoryName(pathPrefix); + return pathPrefix; + } + + internal DirectoryRecord() => this.children = new List(); + + public byte RecordLength { get; internal set; } + + public string Name { get; internal set; } + + public uint Extent => !BitConverter.IsLittleEndian ? this.extentTypeM : this.extentTypeL; + + public uint ExtentSize => !BitConverter.IsLittleEndian ? this.extentSizeTypeM : this.extentSizeTypeL; + + public DateTime? RecordingDateTime { get; internal set; } + + public DirectoryRecordFlags Flags { get; internal set; } + + public bool HasValidFileIdentifier { get; internal set; } + + public ushort VolumeSequenceNumber => !BitConverter.IsLittleEndian ? this.volumeSequenceNumberTypeM : this.volumeSequenceNumberTypeL; + + public int Depth + { + get + { + if (this.IsRoot) + return 0; + return this.FullPath.Split(new char[1] + { + Path.DirectorySeparatorChar + }, StringSplitOptions.RemoveEmptyEntries).Length; + } + } + + public bool IsHidden => (this.Flags & DirectoryRecordFlags.HIDDEN_FILE) != DirectoryRecordFlags.NONE; + + public bool IsDirectory => (this.Flags & DirectoryRecordFlags.DIRECTORY) != DirectoryRecordFlags.NONE; + + public bool IsAssociated => (this.Flags & DirectoryRecordFlags.ASSOCIATED_FILE) != DirectoryRecordFlags.NONE; + + public bool HasExtentedAttributeRecord => (this.Flags & DirectoryRecordFlags.EXTENDED_ATTRIBUTE_RECORD) != DirectoryRecordFlags.NONE; + + public bool HasOwnerAndGroupPermissions => (this.Flags & DirectoryRecordFlags.OWNER_AND_GROUP_PERMISSIONS) != DirectoryRecordFlags.NONE; + + public bool HasReservedFlags => (this.Flags & DirectoryRecordFlags.RESERVED_FLAGS) != DirectoryRecordFlags.NONE; + + public bool IsNotFinalRecord => (this.Flags & DirectoryRecordFlags.NOT_FINAL_RECORD) != DirectoryRecordFlags.NONE; + + public bool IsFlagSet(DirectoryRecordFlags flags) => (this.Flags & flags) != DirectoryRecordFlags.NONE; + + public bool IsRoot => this.parent == null; + + public DirectoryRecord RootDirectory => this.IsRoot ? this : this.parent.RootDirectory; + + public DirectoryRecord ParentDirectory => this.parent; + + public List SubDirectories => this.children; + + public List GetAllSubFolder() + { + List list = new List(); + this.GetAllSubDirectoriesRec(list, true, false); + return list; + } + + public List GetAllSubFiles() + { + List list = new List(); + this.GetAllSubDirectoriesRec(list, false, true); + return list; + } + + public List GetAllSubDirectories() + { + List list = new List(); + this.GetAllSubDirectoriesRec(list, true, true); + return list; + } + + private void GetAllSubDirectoriesRec( + List list, + bool includeFolders, + bool includeFiles) + { + foreach (DirectoryRecord child in this.children) + { + if (includeFolders && child.IsDirectory) + list.Add(child); + if (includeFiles && !child.IsDirectory) + list.Add(child); + child.GetAllSubDirectoriesRec(list, includeFolders, includeFiles); + } + } + + public bool Contains(string directoryRecordName) => this.children.Find((Predicate) (directoryRecord => directoryRecord.Name.Equals(directoryRecordName))) != null; + + public DirectoryRecord Find(DirectoryRecord directoryRecord) + { + if (directoryRecord == this) + return this; + DirectoryRecord directoryRecord1 = (DirectoryRecord) null; + if (directoryRecord.FullPath.StartsWith(this.FullPath)) + { + foreach (DirectoryRecord child in this.children) + { + directoryRecord1 = child.Find(directoryRecord); + if (directoryRecord1 != null) + break; + } + } + return directoryRecord1; + } + + public DirectoryRecord Find(string path) + { + if (this.FullPath.Equals(path)) + return this; + DirectoryRecord directoryRecord = (DirectoryRecord) null; + if (path.StartsWith(this.FullPath)) + { + foreach (DirectoryRecord child in this.children) + { + directoryRecord = child.Find(path); + if (directoryRecord != null) + break; + } + } + return directoryRecord; + } + + public string FullPath => this.parent != null ? Path.Combine(this.parent.FullPath, this.Name) : this.Name; + + public uint UsedSpace + { + get + { + if (!this.IsDirectory) + return this.ExtentSize; + uint num = 0; + foreach (DirectoryRecord child in this.children) + num += child.UsedSpace; + return num; + } + } + } +} diff --git a/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordConverter.cs b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordConverter.cs new file mode 100644 index 0000000..2bd5442 --- /dev/null +++ b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordConverter.cs @@ -0,0 +1,114 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.DirectoryRecords.DirectoryRecordConverter +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; +using System.Text; +using System.Text.RegularExpressions; + +namespace ImageReader.ISO9660.DirectoryRecords +{ + public class DirectoryRecordConverter + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly byte DIRECTORY_RECORD_MIN_SIZE = 34; + private static readonly byte OFFSET_RECORD_LENGTH = 0; + private static readonly byte OFFSET_EXTENDED_ATTRIBUTE_LENGTH = 1; + private static readonly byte OFFSET_TYPE_L_EXTENT_LOCATION = 2; + private static readonly byte OFFSET_TYPE_M_EXTENT_LOCATION = 6; + private static readonly byte OFFSET_TYPE_L_EXTENT_SIZE = 10; + private static readonly byte OFFSET_TYPE_M_EXTENT_SIZE = 14; + private static readonly byte OFFSET_DATETIME = 18; + private static readonly byte OFFSET_FLAGS = 25; + private static readonly byte OFFSET_INTERLEAVED_FILE_UNIT_SIZE = 26; + private static readonly byte OFFSET_INTERLEAVED_FILE_GAP_SIZE = 27; + private static readonly byte OFFSET_TYPE_L_VOLUME_SEQUENCE_NUMBER = 28; + private static readonly byte OFFSET_TYPE_M_VOLUME_SEQUENCE_NUMBER = 30; + private static readonly byte OFFSET_FILE_IDENTIFIER_LENGTH = 32; + private static readonly byte OFFSET_FILE_IDENTIFIER = 33; + private static readonly Regex VALID_FILENAME = new Regex("[^A-Z0-9._]+", RegexOptions.IgnoreCase); + + public static DirectoryRecord ToDirectoryRecord(byte[] buffer, int startIndex) => DirectoryRecordConverter.ToDirectoryRecord(buffer, startIndex, false); + + public static DirectoryRecord ToRootDirectoryRecord( + byte[] buffer, + int startIndex) + { + return DirectoryRecordConverter.ToDirectoryRecord(buffer, startIndex, true); + } + + private static DirectoryRecord ToDirectoryRecord( + byte[] buffer, + int startIndex, + bool isForRootDirectory) + { + byte num1 = buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_RECORD_LENGTH]; + if (startIndex < 0 || buffer.Length - startIndex < (int) num1 || (int) num1 < (int) DirectoryRecordConverter.DIRECTORY_RECORD_MIN_SIZE) + throw new ArgumentOutOfRangeException(); + DirectoryRecord directoryRecord = new DirectoryRecord(); + directoryRecord.RecordLength = num1; + directoryRecord.extendAttributeLength = (ushort) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_EXTENDED_ATTRIBUTE_LENGTH]; + directoryRecord.extentTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_L_EXTENT_LOCATION); + directoryRecord.extentTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_M_EXTENT_LOCATION); + directoryRecord.extentSizeTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_L_EXTENT_SIZE); + directoryRecord.extentSizeTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_M_EXTENT_SIZE); + directoryRecord.RecordingDateTime = DirectoryRecordConverter.DirectoryRecordDateTimeConverter.ToDateTime(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_DATETIME); + directoryRecord.Flags = (DirectoryRecordFlags) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_FLAGS]; + directoryRecord.fileUnitSize = (ushort) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_INTERLEAVED_FILE_UNIT_SIZE]; + directoryRecord.fileGapSize = (ushort) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_INTERLEAVED_FILE_GAP_SIZE]; + directoryRecord.volumeSequenceNumberTypeL = BitConverter.ToUInt16(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_L_VOLUME_SEQUENCE_NUMBER); + directoryRecord.volumeSequenceNumberTypeM = BitConverter.ToUInt16(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_TYPE_M_VOLUME_SEQUENCE_NUMBER); + byte num2 = buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_FILE_IDENTIFIER_LENGTH]; + if ((int) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_FILE_IDENTIFIER] == (int) DirectoryRecord.ROOT_OR_SELF_DIRECTORY_FILE_IDENTIFIER) + directoryRecord.Name = !isForRootDirectory ? DirectoryRecord.SELF_DIRECTORY_NAME : DirectoryRecord.ROOT_DIRECTORY_NAME; + else if ((int) buffer[startIndex + (int) DirectoryRecordConverter.OFFSET_FILE_IDENTIFIER] == (int) DirectoryRecord.PARENT_DIRECTORY_FILE_IDENTIFIER) + { + directoryRecord.Name = DirectoryRecord.PARENT_DIRECTORY_NAME; + } + else + { + if (!directoryRecord.IsDirectory) + num2 -= (byte) 2; + string input = Encoding.Default.GetString(buffer, startIndex + (int) DirectoryRecordConverter.OFFSET_FILE_IDENTIFIER, (int) num2); + directoryRecord.Name = DirectoryRecordConverter.VALID_FILENAME.Replace(input, "_invalid_"); + directoryRecord.HasValidFileIdentifier = directoryRecord.Name.Equals(input); + } + return directoryRecord; + } + + private sealed class DirectoryRecordDateTimeConverter + { + private static readonly byte DATETIME_SIZE = 7; + private static readonly byte OFFSET_YEAR = 0; + private static readonly byte OFFSET_MONTH = 1; + private static readonly byte OFFSET_DAY = 2; + private static readonly byte OFFSET_HOUR = 3; + private static readonly byte OFFSET_MINUTE = 4; + private static readonly byte OFFSET_SECOND = 5; + private static readonly byte OFFSET_TIME_ZONE = 6; + + internal static DateTime? ToDateTime(byte[] buffer, int startIndex) + { + if (startIndex < 0 || buffer.Length - startIndex < (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.DATETIME_SIZE) + throw new ArgumentOutOfRangeException(); + byte num1 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_YEAR]; + byte num2 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_MONTH]; + byte num3 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_DAY]; + byte num4 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_HOUR]; + byte num5 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_MINUTE]; + byte num6 = buffer[startIndex + (int) DirectoryRecordConverter.DirectoryRecordDateTimeConverter.OFFSET_SECOND]; + try + { + return new DateTime?(new DateTime(1900 + (int) num1, (int) num2, (int) num3, (int) num4, (int) num5, (int) num6, DateTimeKind.Local)); + } + catch (Exception ex) + { + logger.Error(ex); + return new DateTime?(); + } + } + } + } +} diff --git a/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordFlags.cs b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordFlags.cs new file mode 100644 index 0000000..91c1fae --- /dev/null +++ b/ImageReader/ISO9660/DirectoryRecords/DirectoryRecordFlags.cs @@ -0,0 +1,24 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.DirectoryRecords.DirectoryRecordFlags +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; + +namespace ImageReader.ISO9660.DirectoryRecords +{ + [Flags] + public enum DirectoryRecordFlags : byte + { + NONE = 0, + HIDDEN_FILE = 1, + DIRECTORY = 2, + ASSOCIATED_FILE = 4, + EXTENDED_ATTRIBUTE_RECORD = 8, + OWNER_AND_GROUP_PERMISSIONS = EXTENDED_ATTRIBUTE_RECORD | ASSOCIATED_FILE | DIRECTORY | HIDDEN_FILE, // 0x0F + RESERVED_FLAGS = 48, // 0x30 + NOT_FINAL_RECORD = 64, // 0x40 + ANY = 255, // 0xFF + } +} diff --git a/ImageReader/ISO9660/PathTable/PathTableEntry.cs b/ImageReader/ISO9660/PathTable/PathTableEntry.cs new file mode 100644 index 0000000..c0940fa --- /dev/null +++ b/ImageReader/ISO9660/PathTable/PathTableEntry.cs @@ -0,0 +1,40 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.PathTable.PathTableEntry +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.ISO9660.PathTable +{ + public class PathTableEntry + { + private byte extentAttributeRecordLength; + private uint extent; + private ushort parentDirectoryIndex; + private string directoryIdentifier; + + public byte ExtentAttributeRecordLength + { + get => this.extentAttributeRecordLength; + internal set => this.extentAttributeRecordLength = value; + } + + public uint Extent + { + get => this.extent; + internal set => this.extent = value; + } + + public ushort ParentDirectoryIndex + { + get => this.parentDirectoryIndex; + internal set => this.parentDirectoryIndex = value; + } + + public string DirectoryIdentifier + { + get => this.directoryIdentifier; + internal set => this.directoryIdentifier = value; + } + } +} diff --git a/ImageReader/ISO9660/VolumeDescriptors/PrimaryVolumeDescriptor.cs b/ImageReader/ISO9660/VolumeDescriptors/PrimaryVolumeDescriptor.cs new file mode 100644 index 0000000..3ae33b5 --- /dev/null +++ b/ImageReader/ISO9660/VolumeDescriptors/PrimaryVolumeDescriptor.cs @@ -0,0 +1,82 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.VolumeDescriptors.PrimaryVolumeDescriptor +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using ImageReader.ISO9660.DirectoryRecords; +using System; + +namespace ImageReader.ISO9660.VolumeDescriptors +{ + public class PrimaryVolumeDescriptor + { + internal uint volumeSpaceSizeTypeL; + internal uint volumeSpaceSizeTypeM; + internal ushort volumeSetSizeTypeL; + internal ushort VolumeSetSizeTypeM; + internal ushort volumeSequenceNumberTypeL; + internal ushort volumeSequenceNumberTypeM; + internal ushort logicalBlockSizeTypeL; + internal ushort logicalBlockSizeTypeM; + internal uint pathTableSizeTypeL; + internal uint pathTableSizeTypeM; + internal uint pathTableLocationTypeL; + internal uint optionalPathTableLocationTypeL; + internal uint pathTableLocationTypeM; + internal uint optionalPathTableLocationTypeM; + internal DirectoryRecord rootDirectoryRecord; + + public VolumeDescriptorType Type { get; internal set; } + + public string StandardIdentifier { get; internal set; } + + public sbyte Version { get; internal set; } + + public string SystemIdentifier { get; internal set; } + + public string Identifier { get; internal set; } + + public uint SpaceSize => !BitConverter.IsLittleEndian ? this.volumeSpaceSizeTypeM : this.volumeSpaceSizeTypeL; + + public ushort SetSize => !BitConverter.IsLittleEndian ? this.VolumeSetSizeTypeM : this.volumeSetSizeTypeL; + + public ushort SequenceNumber => !BitConverter.IsLittleEndian ? this.volumeSequenceNumberTypeM : this.volumeSequenceNumberTypeL; + + public ushort LogicalBlockSize => !BitConverter.IsLittleEndian ? this.logicalBlockSizeTypeM : this.logicalBlockSizeTypeL; + + public uint PathTableSize => !BitConverter.IsLittleEndian ? this.pathTableSizeTypeM : this.pathTableSizeTypeL; + + public uint PathTableLocation => !BitConverter.IsLittleEndian ? this.pathTableLocationTypeM : this.pathTableLocationTypeL; + + public bool HasOptionalPathTable => (BitConverter.IsLittleEndian ? (int) this.optionalPathTableLocationTypeL : (int) this.optionalPathTableLocationTypeM) != 0; + + public uint OptionalPathTableLocation => !BitConverter.IsLittleEndian ? this.optionalPathTableLocationTypeM : this.optionalPathTableLocationTypeL; + + public DirectoryRecord RootDirectoryRecord => this.rootDirectoryRecord; + + public string SetIdentifier { get; internal set; } + + public string PublisherIdentifier { get; internal set; } + + public string PreparerIdentifier { get; internal set; } + + public string ApplicationIdentifier { get; internal set; } + + public string CopyrightFileIdentifier { get; internal set; } + + public string AbstractFileIdentifier { get; internal set; } + + public string BibliographicFileIdentifier { get; internal set; } + + public DateTime? CreationDateTime { get; internal set; } + + public DateTime? ModificationDateTime { get; internal set; } + + public DateTime? ExpirationDateTime { get; internal set; } + + public DateTime? EffectiveDateTime { get; internal set; } + + public sbyte FileStructureVersion { get; internal set; } + } +} diff --git a/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptor.cs b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptor.cs new file mode 100644 index 0000000..dfdffe6 --- /dev/null +++ b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptor.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.VolumeDescriptors.VolumeDescriptor +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System.Runtime.InteropServices; + +namespace ImageReader.ISO9660.VolumeDescriptors +{ + [StructLayout(LayoutKind.Sequential, Pack = 1)] + public struct VolumeDescriptor + { + public const string VolumeDescriptorIdentifier = "CD001"; + public static readonly ushort VolumeDescriptorStartLba = 16; + public static readonly ushort VolumeDescriptorSize = 2048; + public static readonly byte VolumeDescriptorVersion = 1; + public VolumeDescriptorType Type; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] + public byte[] StandardIdentifier; + public byte Version; + } +} diff --git a/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorConverter.cs b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorConverter.cs new file mode 100644 index 0000000..abe7dbd --- /dev/null +++ b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorConverter.cs @@ -0,0 +1,142 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.VolumeDescriptors.VolumeDescriptorConverter +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using ImageReader.ISO9660.DirectoryRecords; +using System; +using System.Text; + +namespace ImageReader.ISO9660.VolumeDescriptors +{ + public class VolumeDescriptorConverter + { + private static readonly string STANDARD_IDENTIFIER = "CD001"; + private static readonly byte VOLUME_DESCRIPTOR_VERSION = 1; + private static readonly byte FILE_STRUCTURE_VERSION = 1; + private static readonly ushort OFFSET_VOLUME_DESCRIPTOR_TYPE = 0; + private static readonly ushort OFFSET_STANDARD_IDENTIFIER = 1; + private static readonly ushort OFFSET_VOLUME_DESCRIPTOR_VERSION = 6; + private static readonly ushort OFFSET_SYSTEM_IDENTIFIER = 8; + private static readonly ushort OFFSET_VOLUME_IDENTIFIER = 40; + private static readonly ushort OFFSET_TYPE_L_VOLUME_SPACE_SIZE = 80; + private static readonly ushort OFFSET_TYPE_M_VOLUME_SPACE_SIZE = 84; + private static readonly ushort OFFSET_TYPE_L_VOLUME_SET_SIZE = 120; + private static readonly ushort OFFSET_TYPE_M_VOLUME_SET_SIZE = 122; + private static readonly ushort OFFSET_TYPE_L_VOLUME_SEQUENCE_NUMBER = 124; + private static readonly ushort OFFSET_TYPE_M_VOLUME_SEQUENCE_NUMBER = 126; + private static readonly ushort OFFSET_TYPE_L_LOGICAL_BLOCK_SIZE = 128; + private static readonly ushort OFFSET_TYPE_M_LOGICAL_BLOCK_SIZE = 130; + private static readonly ushort OFFSET_TYPE_L_PATH_TABLE_SIZE = 132; + private static readonly ushort OFFSET_TYPE_M_PATH_TABLE_SIZE = 136; + private static readonly ushort OFFSET_TYPE_L_PATH_TABLE = 140; + private static readonly ushort OFFSET_TYPE_L_OPTIONAL_PATH_TABLE = 144; + private static readonly ushort OFFSET_TYPE_M_PATH_TABLE = 148; + private static readonly ushort OFFSET_TYPE_M_OPTIONAL_PATH_TABLE = 152; + private static readonly ushort OFFSET_ROOT_DIRECTORY_RECORD = 156; + private static readonly ushort OFFSET_VOLUME_SET_IDENTIFIER = 190; + private static readonly ushort OFFSET_PUBLISHER_IDENTIFIER = 318; + private static readonly ushort OFFSET_PREPARER_IDENTIFIER = 446; + private static readonly ushort OFFSET_APPLICATION_IDENTIFIER = 574; + private static readonly ushort OFFSET_COPYRIGHT_FILE_IDENTIFIER = 702; + private static readonly ushort OFFSET_ABSTRACT_FILE_IDENTIFIER = 739; + private static readonly ushort OFFSET_BIBLIOGRAPHIC_FILE_IDENTIFIER = 776; + private static readonly ushort OFFSET_VOLUME_CREATION_DATE = 813; + private static readonly ushort OFFSET_VOLUME_MODIFICATION_DATE = 830; + private static readonly ushort OFFSET_VOLUME_EXPIRATION_DATE = 847; + private static readonly ushort OFFSET_VOLUME_EFFECTIVE_DATE = 864; + private static readonly ushort OFFSET_FILE_STRUCTURE_VERSION = 881; + + public static PrimaryVolumeDescriptor ToPrimaryVolumeDescriptor( + byte[] buffer, + int startIndex) + { + if (startIndex < 0 || buffer.Length - startIndex < (int) VolumeDescriptor.VolumeDescriptorSize) + throw new ArgumentOutOfRangeException(); + PrimaryVolumeDescriptor volumeDescriptor = new PrimaryVolumeDescriptor() + { + Type = (VolumeDescriptorType) buffer[startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_DESCRIPTOR_TYPE], + StandardIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_STANDARD_IDENTIFIER, 5), + Version = (sbyte) buffer[startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_DESCRIPTOR_VERSION], + SystemIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_SYSTEM_IDENTIFIER, 32).Trim(), + Identifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_IDENTIFIER, 32).Trim(), + volumeSpaceSizeTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_VOLUME_SPACE_SIZE), + volumeSpaceSizeTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_VOLUME_SPACE_SIZE), + volumeSetSizeTypeL = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_VOLUME_SET_SIZE), + VolumeSetSizeTypeM = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_VOLUME_SET_SIZE), + volumeSequenceNumberTypeL = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_VOLUME_SEQUENCE_NUMBER), + volumeSequenceNumberTypeM = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_VOLUME_SEQUENCE_NUMBER), + logicalBlockSizeTypeL = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_LOGICAL_BLOCK_SIZE), + logicalBlockSizeTypeM = BitConverter.ToUInt16(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_LOGICAL_BLOCK_SIZE), + pathTableSizeTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_PATH_TABLE_SIZE), + pathTableSizeTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_PATH_TABLE_SIZE), + pathTableLocationTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_PATH_TABLE), + optionalPathTableLocationTypeL = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_L_OPTIONAL_PATH_TABLE), + pathTableLocationTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_PATH_TABLE), + optionalPathTableLocationTypeM = BitConverter.ToUInt32(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_TYPE_M_OPTIONAL_PATH_TABLE), + SetIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_SET_IDENTIFIER, 128).Trim(), + PublisherIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_PUBLISHER_IDENTIFIER, 128).Trim(), + PreparerIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_PREPARER_IDENTIFIER, 128).Trim(), + ApplicationIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_APPLICATION_IDENTIFIER, 128).Trim(), + CopyrightFileIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_COPYRIGHT_FILE_IDENTIFIER, 37).Trim(), + AbstractFileIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_ABSTRACT_FILE_IDENTIFIER, 37).Trim(), + BibliographicFileIdentifier = Encoding.Default.GetString(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_BIBLIOGRAPHIC_FILE_IDENTIFIER, 37).Trim(), + CreationDateTime = VolumeDescriptorConverter.VolumeDescriptorDateTimeConverter.ToDateTime(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_CREATION_DATE), + ModificationDateTime = VolumeDescriptorConverter.VolumeDescriptorDateTimeConverter.ToDateTime(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_MODIFICATION_DATE), + ExpirationDateTime = VolumeDescriptorConverter.VolumeDescriptorDateTimeConverter.ToDateTime(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_EXPIRATION_DATE), + EffectiveDateTime = VolumeDescriptorConverter.VolumeDescriptorDateTimeConverter.ToDateTime(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_VOLUME_EFFECTIVE_DATE), + FileStructureVersion = (sbyte) buffer[startIndex + (int) VolumeDescriptorConverter.OFFSET_FILE_STRUCTURE_VERSION] + }; + volumeDescriptor.rootDirectoryRecord = DirectoryRecordConverter.ToRootDirectoryRecord(buffer, startIndex + (int) VolumeDescriptorConverter.OFFSET_ROOT_DIRECTORY_RECORD); + if (!VolumeDescriptorConverter.STANDARD_IDENTIFIER.Equals(volumeDescriptor.StandardIdentifier) || volumeDescriptor.Type != VolumeDescriptorType.PRIMARY_VOLUME_DESCRIPTOR || (int) volumeDescriptor.Version != (int) VolumeDescriptorConverter.VOLUME_DESCRIPTOR_VERSION) + throw new FormatException(); + return volumeDescriptor; + } + + private sealed class VolumeDescriptorDateTimeConverter + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + + private const int DATETIME_SIZE = 17; + private const int OFFSET_YEAR = 0; + private const int OFFSET_MONTH = 4; + private const int OFFSET_DAY = 6; + private const int OFFSET_HOUR = 8; + private const int OFFSET_MINUTE = 10; + private const int OFFSET_SECOND = 12; + private const int OFFSET_HUNDREDTHS_OF_SECOND = 14; + private const int OFFSET_TIME_ZONE = 16; + + internal static DateTime? ToDateTime(byte[] buffer, int startIndex) + { + if (startIndex < 0 || buffer.Length - startIndex < 17) + throw new ArgumentOutOfRangeException(); + string str = Encoding.Default.GetString(buffer, startIndex, 16); + ushort result1; + ushort.TryParse(str.Substring(0, 4), out result1); + byte result2; + byte.TryParse(str.Substring(4, 2), out result2); + byte result3; + byte.TryParse(str.Substring(6, 2), out result3); + byte result4; + byte.TryParse(str.Substring(8, 2), out result4); + byte result5; + byte.TryParse(str.Substring(10, 2), out result5); + byte result6; + byte.TryParse(str.Substring(12, 2), out result6); + byte result7; + byte.TryParse(str.Substring(14, 2), out result7); + try + { + return new DateTime?(new DateTime((int) result1, (int) result2, (int) result3, (int) result4, (int) result5, (int) result6, (int) result7 * 100, DateTimeKind.Local)); + } + catch (Exception ex) + { + logger.Warn(ex); + return new DateTime?(); + } + } + } + } +} diff --git a/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorType.cs b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorType.cs new file mode 100644 index 0000000..4a68506 --- /dev/null +++ b/ImageReader/ISO9660/VolumeDescriptors/VolumeDescriptorType.cs @@ -0,0 +1,17 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ISO9660.VolumeDescriptors.VolumeDescriptorType +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.ISO9660.VolumeDescriptors +{ + public enum VolumeDescriptorType : byte + { + BOOT_RECORD = 0, + PRIMARY_VOLUME_DESCRIPTOR = 1, + SUPPLEMENTARY_VOLUME_DESCRIPTOR = 2, + VOLUME_PARTITION_DESCRIPTOR = 3, + VOLUME_DESCRIPTION_SET_TERMINATOR = 255, // 0xFF + } +} diff --git a/ImageReader/ImageReader.csproj b/ImageReader/ImageReader.csproj new file mode 100644 index 0000000..d79d0ea --- /dev/null +++ b/ImageReader/ImageReader.csproj @@ -0,0 +1,85 @@ + + + + + Debug + AnyCPU + {2185F55E-A4DA-486F-ACC8-3EE955205CE4} + Library + ImageReader + v3.5 + 1.5.2.0 + 512 + ImageReader + + + + + 3.5 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\GD-ROM Explorer\packages\log4net.2.0.12\lib\net35\log4net.dll + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/ImageReader/ImageReader/DiscImageReader.cs b/ImageReader/ImageReader/DiscImageReader.cs new file mode 100644 index 0000000..ba59e90 --- /dev/null +++ b/ImageReader/ImageReader/DiscImageReader.cs @@ -0,0 +1,342 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ImageReader.DiscImageReader +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using ImageReader.DiscSectors; +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.ISO9660.VolumeDescriptors; +using ImageReader.Stream; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; + +namespace ImageReader.ImageReader +{ + public class DiscImageReader : IDisposable + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private bool disposed; + private IDiscSector discSector; + private System.IO.Stream image; + private uint numberOfFiles; + private Dictionary pathTable; + private uint preGap; + private PrimaryVolumeDescriptor primaryVolumeDescriptor; + private DiscImageReaderStatus status; + private uint totalFileSize; + + public uint NumberOfFiles + { + get + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return this.numberOfFiles; + } + } + + public List Paths + { + get + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return new List((IEnumerable) this.pathTable.Keys); + } + } + + public uint TotalFileSize + { + get + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return this.totalFileSize; + } + } + + public DiscImageReaderStatus Status => this.status; + + public PrimaryVolumeDescriptor PrimaryVolumeDescriptor + { + get + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return this.primaryVolumeDescriptor; + } + } + + public DirectoryRecord RootDirectoryRecord + { + get + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return this.primaryVolumeDescriptor.RootDirectoryRecord; + } + } + + public bool ParsePathTable { get; set; } + + public DiscImageReader() + { + this.disposed = false; + this.ParsePathTable = false; + this.status = DiscImageReaderStatus.CLOSED; + } + + public void Open(System.IO.Stream imageStream, uint imagePreGap, IDiscSector discSector) + { + this.ValidateStatus(DiscImageReaderStatus.CLOSED); + this.discSector = discSector; + this.image = this.ValidateImage(imageStream); + this.preGap = this.ValidatePreGap(imagePreGap); + this.ReadImageContent(); + } + + public void Close() + { + if (this.image != null) + { + this.image.Dispose(); + this.image = (System.IO.Stream) null; + } + this.discSector = (IDiscSector) null; + this.pathTable = (Dictionary) null; + this.primaryVolumeDescriptor = (PrimaryVolumeDescriptor) null; + this.numberOfFiles = 0U; + this.totalFileSize = 0U; + this.status = DiscImageReaderStatus.CLOSED; + } + + public bool PathExist(string Path) + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + return this.GetDirectoryRecord(Path) != null; + } + + public DirectoryRecord GetDirectoryRecord(string path) + { + this.ValidateStatus(DiscImageReaderStatus.OPENED); + if (string.IsNullOrEmpty(path)) + return (DirectoryRecord) null; + if (!Path.IsPathRooted(path)) + throw new NotSupportedException("relative path are not supported"); + if (DirectoryRecord.ROOT_DIRECTORY_NAME.Equals(path)) + return this.primaryVolumeDescriptor.RootDirectoryRecord; + if (this.pathTable.ContainsKey(path)) + return this.pathTable[path]; + string directoryName = Path.GetDirectoryName(path); + if (!this.pathTable.ContainsKey(directoryName)) + return (DirectoryRecord) null; + string FileName = Path.GetFileName(path); + return this.pathTable[directoryName].children.Find((Predicate) (directoryRecord => directoryRecord.Name.Equals(FileName))); + } + + private System.IO.Stream ValidateImage(System.IO.Stream imageStream) + { + if (imageStream == null || !imageStream.CanRead || !imageStream.CanSeek) + throw new DiscImageReaderException(string.Format("invalid image stream: {0}", (object) imageStream)); + if (imageStream.Length < (long) ((int) VolumeDescriptor.VolumeDescriptorStartLba * this.discSector.Size + (int) VolumeDescriptor.VolumeDescriptorSize)) + throw new DiscImageReaderException(string.Format("image stream too small: {0}", (object) imageStream)); + return imageStream; + } + + private uint ValidatePreGap(uint preGap) => preGap >= 0U ? preGap : throw new ArgumentOutOfRangeException(nameof (preGap), "must be positive"); + + private void ValidateStatus(DiscImageReaderStatus expectedStatus) + { + if (this.status != expectedStatus) + throw new ObjectDisposedException(this.GetType().FullName); + } + + private void ReadImageContent() + { + try + { + this.primaryVolumeDescriptor = this.ReadPrimaryVolumeDescriptor(); + this.numberOfFiles = 0U; + this.totalFileSize = 0U; + Dictionary> directories = this.ReadDirectories(this.primaryVolumeDescriptor, this.pathTable); + DiscImageReader.logger.DebugFormat("{0} {1} found in the file table", (object) this.numberOfFiles, this.numberOfFiles > 1U ? (object) "files" : (object) "file"); + this.pathTable = !this.ParsePathTable ? this.ComputePathTable(directories) : this.ReadPathTable(this.primaryVolumeDescriptor); + DiscImageReader.logger.DebugFormat("{0} {1} found in the path table", (object) this.pathTable.Count, this.pathTable.Count > 1 ? (object) "paths" : (object) "path"); + this.status = DiscImageReaderStatus.OPENED; + DiscImageReader.logger.Debug((object) "Image content successfully read"); + } + catch (Exception ex) + { + DiscImageReader.logger.DebugFormat("Unable to read the image content: {0}", (object) ex); + this.Close(); + throw new DiscImageReaderException("the image content is not valid", ex); + } + } + + private PrimaryVolumeDescriptor ReadPrimaryVolumeDescriptor() + { + byte[] buffer = new byte[(int) VolumeDescriptor.VolumeDescriptorSize]; + using (DiscSectorStream discSectorStream = new DiscSectorStream(this.image, this.discSector, (uint) VolumeDescriptor.VolumeDescriptorStartLba, (uint) VolumeDescriptor.VolumeDescriptorSize, false)) + { + discSectorStream.Read(buffer, 0, buffer.Length); + GCHandle gcHandle = GCHandle.Alloc((object) buffer, GCHandleType.Pinned); + VolumeDescriptor structure = (VolumeDescriptor) Marshal.PtrToStructure(gcHandle.AddrOfPinnedObject(), typeof (VolumeDescriptor)); + gcHandle.Free(); + string str; + try + { + str = Encoding.ASCII.GetString(structure.StandardIdentifier); + } + catch (DecoderFallbackException ex) + { + logger.Error("wrong standard identifer"); + logger.Error(ex); + throw new DiscImageReaderException("wrong standard identifer"); + } + if ("CD001".Equals(str) && (int) VolumeDescriptor.VolumeDescriptorVersion == (int) structure.Version) + { + if (structure.Type == VolumeDescriptorType.PRIMARY_VOLUME_DESCRIPTOR) + goto label_10; + } + throw new DiscImageReaderException("primary volume descriptor not found"); + } +label_10: + PrimaryVolumeDescriptor volumeDescriptor = VolumeDescriptorConverter.ToPrimaryVolumeDescriptor(buffer, 0); + if (volumeDescriptor.RootDirectoryRecord.Extent < this.preGap) + throw new DiscImageReaderException("the root directory record extent must be positive"); + return volumeDescriptor; + } + + private Dictionary ReadPathTable( + PrimaryVolumeDescriptor PrimVolDesc) + { + int index = 0; + string empty = string.Empty; + Dictionary dictionary = new Dictionary(); + List stringList = new List(); + int pathTableLocation = (int) PrimVolDesc.PathTableLocation; + int logicalBlockSize = (int) PrimVolDesc.LogicalBlockSize; + byte[] numArray = new byte[(int) PrimVolDesc.PathTableSize]; + new DiscSectorStream(this.image, this.discSector, PrimVolDesc.PathTableLocation - this.preGap, PrimVolDesc.PathTableSize, false).Read(numArray, 0, numArray.Length); + while ((long) index < (long) PrimVolDesc.PathTableSize) + { + int count = (int) numArray[index]; + ushort num = 0; + if (count > 0) + { + uint uint32 = BitConverter.ToUInt32(numArray, index + 2); + num = BitConverter.ToUInt16(numArray, index + 6); + string rootDirectoryName = Encoding.Default.GetString(numArray, index + 8, count); + if (!string.IsNullOrEmpty(rootDirectoryName)) + { + if ((int) DirectoryRecord.ROOT_OR_SELF_DIRECTORY_FILE_IDENTIFIER == (int) (byte) rootDirectoryName[0]) + rootDirectoryName = DirectoryRecord.ROOT_DIRECTORY_NAME; + string key = Path.Combine(num <= (ushort) 1 ? DirectoryRecord.ROOT_DIRECTORY_NAME : stringList[(int) num - 1], rootDirectoryName); + dictionary.Add(key, (DirectoryRecord) null); + stringList.Add(key); + DiscImageReader.logger.DebugFormat("Path {0} located at LBA {1}", (object) key, (object) uint32); + } + } + index += count + 8; + if (count % 2 > 0) + ++index; + if (count == 0) + ++index; + if (num == (ushort) 0) + ++index; + } + if (dictionary.Count == 0) + dictionary.Add(DirectoryRecord.ROOT_DIRECTORY_NAME, (DirectoryRecord) null); + return dictionary; + } + + private Dictionary> ReadDirectories( + PrimaryVolumeDescriptor pvd, + Dictionary pathTable) + { + Dictionary> directories = new Dictionary>(); + this.ReadDirectoriesRec(this.primaryVolumeDescriptor, this.primaryVolumeDescriptor.RootDirectoryRecord.Name, pvd.RootDirectoryRecord, directories); + return directories; + } + + private void ReadDirectoriesRec( + PrimaryVolumeDescriptor Pvd, + string parentPath, + DirectoryRecord directoryRecord, + Dictionary> directories) + { + byte[] buffer = new byte[(int) directoryRecord.ExtentSize]; + List directoryRecordList = new List(); + new DiscSectorStream(this.image, this.discSector, directoryRecord.Extent - this.preGap, directoryRecord.ExtentSize, false).Read(buffer, 0, (int) directoryRecord.ExtentSize); + int startIndex = 0; + while ((long) startIndex < (long) directoryRecord.ExtentSize) + { + ushort num = (ushort) buffer[startIndex]; + if (num > (ushort) 0) + { + DirectoryRecord directoryRecord1 = DirectoryRecordConverter.ToDirectoryRecord(buffer, startIndex); + if (!DirectoryRecord.SELF_DIRECTORY_NAME.Equals(directoryRecord1.Name) && !DirectoryRecord.PARENT_DIRECTORY_NAME.Equals(directoryRecord1.Name)) + { + if (directoryRecord1.IsDirectory) + { + string key = Path.Combine(parentPath, directoryRecord1.Name); + directoryRecordList.Add(directoryRecord1); + if (!directories.ContainsKey(key)) + directories.Add(key, new List()); + } + else + { + this.totalFileSize += directoryRecord1.ExtentSize; + ++this.numberOfFiles; + } + if (!directories.ContainsKey(parentPath)) + directories.Add(parentPath, new List()); + directories[parentPath].Add(directoryRecord1); + directoryRecord1.parent = directoryRecord; + directoryRecord.children.Add(directoryRecord1); + } + startIndex += (int) num; + } + else + ++startIndex; + } + foreach (DirectoryRecord directoryRecord1 in directoryRecordList) + { + string parentPath1 = Path.Combine(parentPath, directoryRecord1.Name); + this.ReadDirectoriesRec(Pvd, parentPath1, directoryRecord1, directories); + } + } + + private Dictionary ComputePathTable( + Dictionary> directories) + { + Dictionary dictionary = new Dictionary(); + foreach (KeyValuePair> directory in directories) + { + foreach (DirectoryRecord directoryRecord in directory.Value.FindAll((Predicate) (dr => dr.IsDirectory))) + { + if (!dictionary.Keys.Contains(directoryRecord.ParentDirectory.FullPath)) + dictionary.Add(directoryRecord.ParentDirectory.FullPath, directoryRecord.ParentDirectory); + if (!dictionary.Keys.Contains(directoryRecord.FullPath)) + dictionary.Add(directoryRecord.FullPath, directoryRecord); + } + } + return dictionary; + } + + public virtual void Dispose() + { + this.Dispose(true); + GC.SuppressFinalize((object) this); + } + + protected virtual void Dispose(bool disposing) + { + if (this.disposed) + return; + if (disposing) + this.Close(); + this.disposed = true; + } + } +} diff --git a/ImageReader/ImageReader/DiscImageReaderException.cs b/ImageReader/ImageReader/DiscImageReaderException.cs new file mode 100644 index 0000000..6b73a65 --- /dev/null +++ b/ImageReader/ImageReader/DiscImageReaderException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ImageReader.DiscImageReaderException +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System; + +namespace ImageReader.ImageReader +{ + public class DiscImageReaderException : Exception + { + public DiscImageReaderException(string message) + : base(string.Format("ISOReader Error: {0}", (object) message)) + { + } + + public DiscImageReaderException(string message, Exception innerException) + : base(string.Format("ISOReader Error: {0}", (object) message), innerException) + { + } + } +} diff --git a/ImageReader/ImageReader/DiscImageReaderStatus.cs b/ImageReader/ImageReader/DiscImageReaderStatus.cs new file mode 100644 index 0000000..6b9f6eb --- /dev/null +++ b/ImageReader/ImageReader/DiscImageReaderStatus.cs @@ -0,0 +1,14 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.ImageReader.DiscImageReaderStatus +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +namespace ImageReader.ImageReader +{ + public enum DiscImageReaderStatus + { + CLOSED, + OPENED, + } +} diff --git a/ImageReader/Logger.cs b/ImageReader/Logger.cs new file mode 100644 index 0000000..e51cf44 --- /dev/null +++ b/ImageReader/Logger.cs @@ -0,0 +1,475 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.Logger +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using log4net; +using log4net.Core; +using System; +using System.Diagnostics; +using System.Globalization; +using System.Reflection; + +namespace ImageReader +{ + internal static class Logger + { + private static readonly bool loggingIsOff = true; + + static Logger() + { + try + { + //Assembly.Load("log4net").GetType("log4net.Config.XmlConfigurator").GetMethod("Configure", new Type[0]).Invoke((object) null, (object[]) null); + Assembly.Load("log4net"); + //log4net.Config.XmlConfigurator.Configure(); + Logger.loggingIsOff = false; + } + catch + { + } + } + + public static Logger.ILog CreateLog() + { + Type declaringType = new StackFrame(1, false).GetMethod().DeclaringType; + return !Logger.loggingIsOff ? (Logger.ILog) new Logger.Log4NetLogger(declaringType) : (Logger.ILog) new Logger.NoLog(); + } + + internal interface ILog + { + bool IsDebugEnabled { get; } + + bool IsInfoEnabled { get; } + + bool IsWarnEnabled { get; } + + bool IsErrorEnabled { get; } + + bool IsFatalEnabled { get; } + + void Debug(object message); + + void Debug(object message, Exception exception); + + void DebugFormat(string format, params object[] args); + + void DebugFormat(string format, object arg0); + + void DebugFormat(string format, object arg0, object arg1); + + void DebugFormat(string format, object arg0, object arg1, object arg2); + + void DebugFormat(IFormatProvider provider, string format, params object[] args); + + void Info(object message); + + void Info(object message, Exception exception); + + void InfoFormat(string format, params object[] args); + + void InfoFormat(string format, object arg0); + + void InfoFormat(string format, object arg0, object arg1); + + void InfoFormat(string format, object arg0, object arg1, object arg2); + + void InfoFormat(IFormatProvider provider, string format, params object[] args); + + void Warn(object message); + + void Warn(object message, Exception exception); + + void WarnFormat(string format, params object[] args); + + void WarnFormat(string format, object arg0); + + void WarnFormat(string format, object arg0, object arg1); + + void WarnFormat(string format, object arg0, object arg1, object arg2); + + void WarnFormat(IFormatProvider provider, string format, params object[] args); + + void Error(object message); + + void Error(object message, Exception exception); + + void ErrorFormat(string format, params object[] args); + + void ErrorFormat(string format, object arg0); + + void ErrorFormat(string format, object arg0, object arg1); + + void ErrorFormat(string format, object arg0, object arg1, object arg2); + + void ErrorFormat(IFormatProvider provider, string format, params object[] args); + + void Fatal(object message); + + void Fatal(object message, Exception exception); + + void FatalFormat(string format, params object[] args); + + void FatalFormat(string format, object arg0); + + void FatalFormat(string format, object arg0, object arg1); + + void FatalFormat(string format, object arg0, object arg1, object arg2); + + void FatalFormat(IFormatProvider provider, string format, params object[] args); + } + + private class NoLog : Logger.ILog + { + public bool IsDebugEnabled => false; + + public bool IsInfoEnabled => false; + + public bool IsWarnEnabled => false; + + public bool IsErrorEnabled => false; + + public bool IsFatalEnabled => false; + + public void Debug(object message) + { + } + + public void Debug(object message, Exception exception) + { + } + + public void DebugFormat(string format, params object[] args) + { + } + + public void DebugFormat(string format, object arg0) + { + } + + public void DebugFormat(string format, object arg0, object arg1) + { + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Info(object message) + { + } + + public void Info(object message, Exception exception) + { + } + + public void InfoFormat(string format, params object[] args) + { + } + + public void InfoFormat(string format, object arg0) + { + } + + public void InfoFormat(string format, object arg0, object arg1) + { + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Warn(object message) + { + } + + public void Warn(object message, Exception exception) + { + } + + public void WarnFormat(string format, params object[] args) + { + } + + public void WarnFormat(string format, object arg0) + { + } + + public void WarnFormat(string format, object arg0, object arg1) + { + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Error(object message) + { + } + + public void Error(object message, Exception exception) + { + } + + public void ErrorFormat(string format, params object[] args) + { + } + + public void ErrorFormat(string format, object arg0) + { + } + + public void ErrorFormat(string format, object arg0, object arg1) + { + } + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Fatal(object message) + { + } + + public void Fatal(object message, Exception exception) + { + } + + public void FatalFormat(string format, params object[] args) + { + } + + public void FatalFormat(string format, object arg0) + { + } + + public void FatalFormat(string format, object arg0, object arg1) + { + } + + public void FatalFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) + { + } + } + + private class Log4NetLogger : Logger.ILog + { + private readonly log4net.ILog rootLogger; + private readonly Type loggingType; + private readonly ILogger logger; + + public Log4NetLogger(Type type) + { + this.loggingType = type; + this.rootLogger = LogManager.GetLogger(this.loggingType); + this.logger = ((ILoggerWrapper) this.rootLogger).Logger; + } + + public bool IsDebugEnabled => this.rootLogger.IsDebugEnabled; + + public bool IsInfoEnabled => this.rootLogger.IsInfoEnabled; + + public bool IsWarnEnabled => this.rootLogger.IsWarnEnabled; + + public bool IsErrorEnabled => this.rootLogger.IsErrorEnabled; + + public bool IsFatalEnabled => this.rootLogger.IsFatalEnabled; + + public void Debug(object message) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, (Exception) null); + } + + public void Debug(object message, Exception exception) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, exception); + } + + public void DebugFormat(string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void DebugFormat(string format, object arg0) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Info(object message) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, (Exception) null); + } + + public void Info(object message, Exception exception) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, exception); + } + + public void InfoFormat(string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void InfoFormat(string format, object arg0) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Warn(object message) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, (Exception) null); + } + + public void Warn(object message, Exception exception) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, exception); + } + + public void WarnFormat(string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void WarnFormat(string format, object arg0) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Error(object message) => this.logger.Log(this.loggingType, (Level) Level.Error, message, (Exception) null); + + public void Error(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Error, message, exception); + + public void ErrorFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void ErrorFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format(provider, format, args), (Exception) null); + + public void Fatal(object message) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, (Exception) null); + + public void Fatal(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, exception); + + public void FatalFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void FatalFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format(provider, format, args), (Exception) null); + } + } +} diff --git a/ImageReader/Properties/Resources.cs b/ImageReader/Properties/Resources.cs new file mode 100644 index 0000000..25b0088 --- /dev/null +++ b/ImageReader/Properties/Resources.cs @@ -0,0 +1,46 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.Properties.Resources +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace ImageReader.Properties +{ + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [DebuggerNonUserCode] + [CompilerGenerated] + internal class Resources + { + private static ResourceManager resourceMan; + private static CultureInfo resourceCulture; + + internal Resources() + { + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager + { + get + { + if (object.ReferenceEquals((object) Properties.Resources.resourceMan, (object) null)) + Properties.Resources.resourceMan = new ResourceManager("Properties.Resources", typeof (Properties.Resources).Assembly); + return Properties.Resources.resourceMan; + } + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture + { + get => Properties.Resources.resourceCulture; + set => Properties.Resources.resourceCulture = value; + } + } +} diff --git a/ImageReader/Properties/Resources.resx b/ImageReader/Properties/Resources.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/ImageReader/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/ImageReader/Stream/DiscSectorStream.cs b/ImageReader/Stream/DiscSectorStream.cs new file mode 100644 index 0000000..30ae298 --- /dev/null +++ b/ImageReader/Stream/DiscSectorStream.cs @@ -0,0 +1,211 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.Stream.DiscSectorStream +// Assembly: ImageReader, Version=1.5.2.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: E0717604-B50B-4CB4-B85C-C17F43D5C04B +// Assembly location: ImageReader.dll + +using ImageReader.DiscSectors; +using System; +using System.IO; + +namespace ImageReader.Stream +{ + public class DiscSectorStream : System.IO.Stream + { + private System.IO.Stream sourceStream; + private IDiscSector sector; + private long absStartAddress; + private long absEndAddress; + private bool disposed; + private bool disposeSourceStream; + + public DiscSectorStream( + System.IO.Stream source, + IDiscSector sector, + uint extent, + uint size, + bool autoReleaseSource) + { + this.disposed = false; + if (size > (uint) int.MaxValue) + throw new ArgumentException(string.Format("invalid size: files larger than {0} in size are not supported", (object) int.MaxValue), nameof (size)); + if (size > uint.MaxValue) + throw new ArgumentException(string.Format("invalid size: a file on an ISO 9660 formatted disc cannot be larger than {0} in size", (object) uint.MaxValue), nameof (size)); + if (!source.CanSeek) + throw new ArgumentException(string.Format("invalid base stream: only seekable streams are supported"), "baseStream"); + this.sector = sector; + this.sourceStream = source; + this.absStartAddress = (long) extent * (long) sector.Size; + this.absEndAddress = this.absStartAddress + this.LogicalToPhysical((long) size); + this.disposeSourceStream = autoReleaseSource; + this.Seek(0L, SeekOrigin.Begin); + } + + public DiscSectorStream(string isoFile, IDiscSector sector, uint extent, uint size) + : this((System.IO.Stream) new FileStream(isoFile, FileMode.Open, FileAccess.Read, FileShare.Read), sector, extent, size, true) + { + } + + public DiscSectorStream(System.IO.Stream source, IDiscSector sector) + : this(source, sector, 0U, 0U, true) + => this.absEndAddress = this.absStartAddress + source.Length; + + public override bool CanRead => !this.disposed && this.sourceStream.CanRead; + + public override bool CanTimeout => this.disposed || this.sourceStream.CanTimeout; + + public override bool CanSeek => !this.disposed && this.sourceStream.CanSeek; + + public override bool CanWrite => !this.disposed && this.sourceStream.CanWrite; + + public override long Length => this.PhysicalToLogical(this.absEndAddress - this.absStartAddress); + + public override long Position + { + get => this.PhysicalToLogical(this.sourceStream.Position - this.absStartAddress); + set => this.Seek(value, SeekOrigin.Begin); + } + + public override int Read(byte[] buffer, int offset, int count) + { + long logical = this.PhysicalToLogical(this.sourceStream.Position - this.absStartAddress); + long num1 = Math.Min((long) count, this.Length - logical); + long sectors = num1 / (long) this.sector.DataLength; + long num2 = num1 % (long) this.sector.DataLength; + int num3 = 0; + if ((long) (buffer.Length - offset) < sectors * (long) this.sector.DataLength + num2) + throw new ArgumentOutOfRangeException("buffer is too small"); + if (sectors > 0L) + num3 += this.ReadSector(buffer, offset, sectors); + if (num2 > 0L) + { + if (this.sourceStream.Position % (long) this.sector.Size == 0L) + this.sourceStream.Seek((long) this.sector.DataOffset, SeekOrigin.Current); + num3 += this.sourceStream.Read(buffer, Convert.ToInt32(sectors * (long) this.sector.DataLength), (int) num2); + } + return num3; + } + + public override void Write(byte[] buffer, int offset, int count) + { + if (buffer.Length - offset < count) + throw new ArgumentOutOfRangeException("buffer is too small"); + long logical = this.PhysicalToLogical(this.sourceStream.Position - this.absStartAddress); + long num1 = Math.Min((long) count, this.Length - logical); + long sectors = num1 / (long) this.sector.DataLength; + long num2 = num1 % (long) this.sector.DataLength; + long num3 = 0; + if (sectors > 0L) + num3 += (long) this.WriteSector(buffer, offset, sectors); + if (num2 <= 0L) + return; + if (sectors > 0L || this.sourceStream.Position == this.absStartAddress) + this.sourceStream.Seek((long) this.sector.DataOffset, SeekOrigin.Current); + this.sourceStream.Write(buffer, Convert.ToInt32(sectors * (long) this.sector.DataLength), (int) num2); + long num4 = num3 + num2; + } + + public override long Seek(long offset, SeekOrigin origin) + { + long offset1; + switch (origin) + { + case SeekOrigin.Begin: + if (offset < 0L || offset > this.Length) + throw new ArgumentException(string.Format("must be in range of (0, {0}) when seeking from {1}", (object) this.Length, (object) SeekOrigin.Begin), nameof (offset)); + offset1 = this.absStartAddress + this.LogicalToPhysical(offset); + break; + case SeekOrigin.Current: + long logical = this.PhysicalToLogical(this.sourceStream.Position - this.absStartAddress); + if ((offset > 0L || logical + offset < 0L) && (offset < 0L || logical + offset > this.Length)) + throw new ArgumentException(string.Format("must be in range of (0, {0}) or (-{0}, 0) when seeking from {1}", (object) this.Length, (object) SeekOrigin.Current), nameof (offset)); + offset1 = this.LogicalToPhysical(logical + offset) - (this.sourceStream.Position - this.absStartAddress); + break; + case SeekOrigin.End: + if (offset > 0L || this.Length + offset < 0L) + throw new ArgumentException(string.Format("must be in range of (-{0}, 0) when seeking from {1}", (object) this.Length, (object) SeekOrigin.End), nameof (offset)); + offset1 = this.absStartAddress + this.LogicalToPhysical(this.Length + offset); + origin = SeekOrigin.Begin; + break; + default: + throw new ArgumentException(); + } + return this.PhysicalToLogical(this.sourceStream.Seek(offset1, origin) - this.absStartAddress); + } + + public override void Close() + { + if (this.sourceStream == null || !this.disposeSourceStream) + return; + this.sourceStream.Close(); + } + + public override void SetLength(long value) => throw new NotSupportedException(); + + public override void WriteByte(byte value) => throw new NotSupportedException(); + + public override void Flush() => throw new NotSupportedException(); + + private long LogicalToPhysical(long logicalAddress) + { + long num1 = logicalAddress / (long) this.sector.DataLength; + long num2 = logicalAddress % (long) this.sector.DataLength; + if (num2 != 0L) + num2 += (long) this.sector.DataOffset; + return num1 * (long) this.sector.Size + num2; + } + + private long PhysicalToLogical(long physicalAddress) + { + long num1 = physicalAddress % (long) this.sector.Size; + long num2 = physicalAddress / (long) this.sector.Size; + if (num1 != 0L) + { + string.Format("the specified absolute address {0} is out of the stream's logical range", (object) physicalAddress); + num1 -= (long) this.sector.DataOffset; + } + return num2 * (long) this.sector.DataLength + num1; + } + + private int ReadSector(byte[] buffer, int offset, long sectors) + { + int num = 0; + byte[] buffer1 = new byte[this.sector.Size]; + for (int index = 0; (long) index < sectors; ++index) + { + this.sourceStream.Read(buffer1, 0, buffer1.Length); + Buffer.BlockCopy((Array) buffer1, this.sector.DataOffset, (Array) buffer, offset + index * this.sector.DataLength, this.sector.DataLength); + num += this.sector.DataLength; + } + return num; + } + + private int WriteSector(byte[] buffer, int offset, long sectors) + { + int num = 0; + for (int index = 0; (long) index < sectors; ++index) + { + this.sourceStream.Seek((long) this.sector.DataOffset, SeekOrigin.Current); + this.sourceStream.Write(buffer, offset + index * this.sector.DataLength, this.sector.DataLength); + this.sourceStream.Seek((long) (this.sector.Size - this.sector.DataOffset), SeekOrigin.Current); + num += this.sector.DataLength; + } + return num; + } + + public new virtual void Dispose() + { + this.Dispose(true); + GC.SuppressFinalize((object) this); + } + + protected new virtual void Dispose(bool disposing) + { + if (this.disposed) + return; + if (disposing) + this.Close(); + this.disposed = true; + } + } +} diff --git a/ImageReader/packages.config b/ImageReader/packages.config new file mode 100644 index 0000000..7f6923a --- /dev/null +++ b/ImageReader/packages.config @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..ea83ef4 --- /dev/null +++ b/README.md @@ -0,0 +1,5 @@ +# GD-Rom Explorer + +Decompiled source code for GD-ROM Explorer + +Created by japanese cake \ No newline at end of file diff --git a/SEGATools/AssemblyGitBuildBranch.cs b/SEGATools/AssemblyGitBuildBranch.cs new file mode 100644 index 0000000..5fffcdc --- /dev/null +++ b/SEGATools/AssemblyGitBuildBranch.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.AssemblyGitBuildBranch +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildBranch : Attribute + { + public string GitBuildBranch { get; private set; } + + public AssemblyGitBuildBranch(string txt) => this.GitBuildBranch = txt; + } +} diff --git a/SEGATools/AssemblyGitBuildSHA1.cs b/SEGATools/AssemblyGitBuildSHA1.cs new file mode 100644 index 0000000..170761b --- /dev/null +++ b/SEGATools/AssemblyGitBuildSHA1.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.AssemblyGitBuildSHA1 +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools +{ + [AttributeUsage(AttributeTargets.Assembly)] + public class AssemblyGitBuildSHA1 : Attribute + { + public string GitBuildSHA1 { get; private set; } + + public AssemblyGitBuildSHA1(string txt) => this.GitBuildSHA1 = txt; + } +} diff --git a/SEGATools/AssemblyInfo.cs b/SEGATools/AssemblyInfo.cs new file mode 100644 index 0000000..6779ab0 --- /dev/null +++ b/SEGATools/AssemblyInfo.cs @@ -0,0 +1,22 @@ +using SEGATools; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: InternalsVisibleTo("CDI")] +[assembly: InternalsVisibleTo("GDI")] +[assembly: AssemblyCompany("Japanese Cake")] +[assembly: AssemblyGitBuildBranch("release_1.6.3")] +[assembly: InternalsVisibleTo("ISO9660")] +[assembly: AssemblyProduct("SEGA Tools")] +[assembly: AssemblyTitle("SEGA Tools")] +[assembly: AssemblyDescription("SEGATools.dll")] +[assembly: AssemblyConfiguration("")] +[assembly: InternalsVisibleTo("BIN")] +[assembly: ComVisible(true)] +[assembly: AssemblyGitBuildSHA1("fd2eb45")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCopyright("2012-2016")] +[assembly: Guid("c48aeffd-e41a-403e-9c32-f376d63a4ae2")] +[assembly: AssemblyFileVersion("1.0.3")] +[assembly: AssemblyVersion("1.0.3.0")] \ No newline at end of file diff --git a/SEGATools/AssemblyTest.cs b/SEGATools/AssemblyTest.cs new file mode 100644 index 0000000..5bf2809 --- /dev/null +++ b/SEGATools/AssemblyTest.cs @@ -0,0 +1,12 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.AssemblyTest +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools +{ + public class AssemblyTest + { + } +} diff --git a/SEGATools/Audio/AudioConversionSettings.cs b/SEGATools/Audio/AudioConversionSettings.cs new file mode 100644 index 0000000..be53f0f --- /dev/null +++ b/SEGATools/Audio/AudioConversionSettings.cs @@ -0,0 +1,44 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Audio.AudioConversionSettings +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Audio +{ + public class AudioConversionSettings + { + public bool RemovePause { get; private set; } + + public short PauseDurationInSeconds => this.RemovePause ? (short) 2 : (short) 0; + + public int SamplingRate { get; private set; } + + public short BitsPerSample => 16; + + public short NumberOfChannels { get; private set; } + + private AudioConversionSettings(int SamplingRate, short NumberOfChannels, bool RemovePause) + { + this.SamplingRate = SamplingRate; + this.NumberOfChannels = NumberOfChannels; + this.RemovePause = RemovePause; + } + + public static AudioConversionSettings defaultAudioConvOptions() => new AudioConversionSettings(44100, (short) 2, false); + + public static AudioConversionSettings newStereoPCMSettings( + int SamplingRate, + bool RemovePause) + { + return new AudioConversionSettings(SamplingRate, (short) 2, RemovePause); + } + + public static AudioConversionSettings newMonoPCMSettings( + int SamplingRate, + bool RemovePause) + { + return new AudioConversionSettings(SamplingRate, (short) 1, RemovePause); + } + } +} diff --git a/SEGATools/Audio/AudioConversionSettingsViewer.cs b/SEGATools/Audio/AudioConversionSettingsViewer.cs new file mode 100644 index 0000000..0f54fb5 --- /dev/null +++ b/SEGATools/Audio/AudioConversionSettingsViewer.cs @@ -0,0 +1,151 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Audio.AudioConversionSettingsViewer +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Drawing; +using System.Windows.Forms; + +namespace SEGATools.Audio +{ + public class AudioConversionSettingsViewer : UserControl + { + private List samplingRates = new List(); + private IContainer components; + private FlowLayoutPanel flowLayoutPanel; + private Label lbSamplingRate; + private ComboBox cbSamplingRate; + private CheckBox cbRemovePause; + + [RefreshProperties(RefreshProperties.Repaint)] + [NotifyParentProperty(true)] + [Category("Appearance")] + [Description("Specifies whether the remove pause checkbox is visible.")] + [DefaultValue(typeof (bool), "true")] + public bool ShowRemovePause + { + get => this.cbRemovePause.Visible; + set => this.cbRemovePause.Visible = value; + } + + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public bool RemovePause => this.cbRemovePause.Checked; + + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + [Browsable(false)] + public int SamplingRate => int.Parse(this.cbSamplingRate.SelectedItem.ToString()); + + [Browsable(false)] + [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)] + public AudioConversionSettings AudioConversionSettings + { + get => AudioConversionSettings.newStereoPCMSettings((int) this.cbSamplingRate.SelectedValue, this.cbRemovePause.Checked); + set + { + this.cbSamplingRate.SelectedItem = (object) this.samplingRates.Find((Predicate) (samplingRate => samplingRate.Value == value.SamplingRate)); + this.cbRemovePause.Checked = value.RemovePause; + } + } + + public AudioConversionSettingsViewer() + { + this.InitializeComponent(); + this.samplingRates.Add(new AudioConversionSettingsViewer.SamplingRateItem(16000)); + this.samplingRates.Add(new AudioConversionSettingsViewer.SamplingRateItem(44100)); + this.samplingRates.Add(new AudioConversionSettingsViewer.SamplingRateItem(48000)); + this.cbSamplingRate.DataSource = (object) this.samplingRates; + this.cbSamplingRate.DisplayMember = AudioConversionSettingsViewer.SamplingRateItem.DisplayMember; + this.cbSamplingRate.ValueMember = AudioConversionSettingsViewer.SamplingRateItem.ValueMember; + this.cbSamplingRate.SelectedItem = (object) this.samplingRates.Find((Predicate) (samplingRate => samplingRate.Value == 44100)); + this.cbSamplingRate.Enabled = false; + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.flowLayoutPanel = new FlowLayoutPanel(); + this.lbSamplingRate = new Label(); + this.cbSamplingRate = new ComboBox(); + this.cbRemovePause = new CheckBox(); + this.flowLayoutPanel.SuspendLayout(); + this.SuspendLayout(); + this.flowLayoutPanel.AutoScroll = true; + this.flowLayoutPanel.AutoSize = true; + this.flowLayoutPanel.BackColor = Color.Transparent; + this.flowLayoutPanel.Controls.Add((Control) this.lbSamplingRate); + this.flowLayoutPanel.Controls.Add((Control) this.cbSamplingRate); + this.flowLayoutPanel.Controls.Add((Control) this.cbRemovePause); + this.flowLayoutPanel.Dock = DockStyle.Fill; + this.flowLayoutPanel.Location = new Point(0, 0); + this.flowLayoutPanel.Name = "flowLayoutPanel"; + this.flowLayoutPanel.Size = new Size(325, 28); + this.flowLayoutPanel.TabIndex = 0; + this.lbSamplingRate.AutoSize = true; + this.lbSamplingRate.Location = new Point(3, 3); + this.lbSamplingRate.Margin = new Padding(3); + this.lbSamplingRate.Name = "lbSamplingRate"; + this.lbSamplingRate.Size = new Size(79, 13); + this.lbSamplingRate.TabIndex = 9; + this.lbSamplingRate.Text = "Sampling Rate:"; + this.lbSamplingRate.TextAlign = ContentAlignment.BottomLeft; + this.cbSamplingRate.FormattingEnabled = true; + this.cbSamplingRate.Items.AddRange(new object[2] + { + (object) "44100", + (object) "48000" + }); + this.cbSamplingRate.Location = new Point(85, 0); + this.cbSamplingRate.Margin = new Padding(0); + this.cbSamplingRate.Name = "cbSamplingRate"; + this.cbSamplingRate.Size = new Size(75, 21); + this.cbSamplingRate.TabIndex = 10; + this.cbRemovePause.AutoSize = true; + this.cbRemovePause.CheckAlign = ContentAlignment.MiddleRight; + this.cbRemovePause.Enabled = false; + this.cbRemovePause.Location = new Point(163, 3); + this.cbRemovePause.Name = "cbRemovePause"; + this.cbRemovePause.Size = new Size(150, 17); + this.cbRemovePause.TabIndex = 11; + this.cbRemovePause.Text = "Remove 2-seconds pause"; + this.cbRemovePause.UseVisualStyleBackColor = true; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.BackColor = Color.Transparent; + this.Controls.Add((Control) this.flowLayoutPanel); + this.Name = nameof (AudioConversionSettingsViewer); + this.Size = new Size(325, 28); + this.flowLayoutPanel.ResumeLayout(false); + this.flowLayoutPanel.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + } + + internal sealed class SamplingRateItem + { + public static string DisplayMember => "Name"; + + public static string ValueMember => "Value"; + + public int Value { get; set; } + + public string Name { get; set; } + + public SamplingRateItem(int SamplingRate) + { + this.Name = SamplingRate.ToString() + "Hz"; + this.Value = SamplingRate; + } + } + } +} diff --git a/SEGATools/Audio/AudioConversionSettingsViewer.resx b/SEGATools/Audio/AudioConversionSettingsViewer.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/SEGATools/Audio/AudioConversionSettingsViewer.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SEGATools/Audio/CanonicalWaveHeader.cs b/SEGATools/Audio/CanonicalWaveHeader.cs new file mode 100644 index 0000000..a8ad7cd --- /dev/null +++ b/SEGATools/Audio/CanonicalWaveHeader.cs @@ -0,0 +1,98 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Audio.CanonicalWaveHeader +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Audio +{ + internal class CanonicalWaveHeader + { + private const short HEADERSIZE = 44; + private const int _chunkID = 1179011410; + private const int _remainingSize = 20; + private const int _format = 1163280727; + private const int _subChunk1ID = 544501094; + private const int _subChunk1Size = 16; + private const short _audioFormat = 1; + private const int _subChunk2ID = 1635017060; + private int _subChunk2Size; + private bool sampleDataInitialized; + + public short Size => 44; + + public int ChunkID => 1179011410; + + public int ChunkSize => 36 + this.SubChunk2Size; + + public int Format => 1163280727; + + public int SubChunk1ID => 544501094; + + public int SubChunk1Size => 16; + + public short AudioFormat => 1; + + public short NumberOfChannels { get; private set; } + + public int SampleRate { get; private set; } + + public int ByteRate => this.SampleRate * (int) this.NumberOfChannels * ((int) this.BitsPerSample / 8); + + public short BlockAlign => (short) ((int) this.NumberOfChannels * ((int) this.BitsPerSample / 8)); + + public short BitsPerSample { get; private set; } + + public int SubChunk2ID => 1635017060; + + public int SubChunk2Size + { + get => this._subChunk2Size; + set + { + this._subChunk2Size = value; + this.sampleDataInitialized = true; + } + } + + public CanonicalWaveHeader( + short numberOfChannels, + int sampleRate, + short bitsPerSample, + int? sampleDataSize) + { + this.NumberOfChannels = numberOfChannels; + this.SampleRate = sampleRate; + this.BitsPerSample = bitsPerSample; + if (!sampleDataSize.HasValue) + return; + this.sampleDataInitialized = true; + this.SubChunk2Size = sampleDataSize.Value; + } + + public byte[] ToByteArray() + { + if (!this.sampleDataInitialized) + throw new UninitialiedSampleDataSizeException("Sample data size (SubChunk2Size property) has not been initialied."); + byte[] numArray = new byte[44]; + BitConverter.GetBytes(this.ChunkID).CopyTo((Array) numArray, 0); + BitConverter.GetBytes(this.ChunkSize).CopyTo((Array) numArray, 4); + BitConverter.GetBytes(this.Format).CopyTo((Array) numArray, 8); + BitConverter.GetBytes(this.SubChunk1ID).CopyTo((Array) numArray, 12); + BitConverter.GetBytes(this.SubChunk1Size).CopyTo((Array) numArray, 16); + BitConverter.GetBytes(this.AudioFormat).CopyTo((Array) numArray, 20); + BitConverter.GetBytes(this.NumberOfChannels).CopyTo((Array) numArray, 22); + BitConverter.GetBytes(this.SampleRate).CopyTo((Array) numArray, 24); + BitConverter.GetBytes(this.ByteRate).CopyTo((Array) numArray, 28); + BitConverter.GetBytes(this.BlockAlign).CopyTo((Array) numArray, 32); + BitConverter.GetBytes(this.BitsPerSample).CopyTo((Array) numArray, 34); + BitConverter.GetBytes(this.SubChunk2ID).CopyTo((Array) numArray, 36); + BitConverter.GetBytes(this.SubChunk2Size).CopyTo((Array) numArray, 40); + return numArray; + } + + public static CanonicalWaveHeader FromByteArray(byte[] headerArray) => new CanonicalWaveHeader(BitConverter.ToInt16(headerArray, 22), BitConverter.ToInt32(headerArray, 24), BitConverter.ToInt16(headerArray, 34), new int?(BitConverter.ToInt32(headerArray, 40))); + } +} diff --git a/SEGATools/Audio/Raw2WavConverter.cs b/SEGATools/Audio/Raw2WavConverter.cs new file mode 100644 index 0000000..1894eb3 --- /dev/null +++ b/SEGATools/Audio/Raw2WavConverter.cs @@ -0,0 +1,142 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Audio.Raw2WavConverter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.UserProcess; +using SEGATools.VirtualFile; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; + +namespace SEGATools.Audio +{ + public class Raw2WavConverter : UserProcessBase + { + private static readonly int BUFFER_SIZE = 524288; + + public AudioConversionSettings AudioConversionSettings { get; set; } + + public event AsyncOperationProgressChangedEventHandler ConversionProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler ConversionCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public Raw2WavConverter() => this.AudioConversionSettings = AudioConversionSettings.defaultAudioConvOptions(); + + public Raw2WavConverter(IContainer container) + : base(container) + => this.AudioConversionSettings = AudioConversionSettings.defaultAudioConvOptions(); + + public void ConvertAsync(IList InputFiles, string outputPath, object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new Raw2WavConverter.WorkerEventHandler(this.ConvertRaw2WavWorker).BeginInvoke(InputFiles, outputPath, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void ConvertRaw2WavWorker( + IList inputFiles, + string outputPath, + AsyncOperation asyncOp) + { + long TotalNumberOfBytesToWrite = 0; + Exception exception = (Exception) null; + foreach (IVirtualFile inputFile in (IEnumerable) inputFiles) + TotalNumberOfBytesToWrite += this.ComputeAudioStreamLength(inputFile.FileInputStream, this.AudioConversionSettings.PauseDurationInSeconds); + long TotalNumberOfBytesRemainingToWrite = TotalNumberOfBytesToWrite; + try + { + foreach (IVirtualFile inputFile in (IEnumerable) inputFiles) + { + if (!this.TaskCanceled(asyncOp)) + { + IVirtualFile OutputFile = inputFiles.Count != 1 ? (IVirtualFile) VirtualFileFactory.createVirtualFile(Path.Combine(outputPath, Path.GetFileName(Path.ChangeExtension(inputFile.VirtualName, ".wav")))) : (IVirtualFile) VirtualFileFactory.createVirtualFile(outputPath); + TotalNumberOfBytesRemainingToWrite = this.ConvertStream(inputFile, OutputFile, TotalNumberOfBytesRemainingToWrite, TotalNumberOfBytesToWrite, asyncOp); + } + else + break; + } + } + catch (Exception ex) + { + exception = ex; + } + this.ReportCompletion(outputPath, exception, asyncOp); + } + + private long ComputeAudioStreamLength(System.IO.Stream AudioStream, short NumberOfSecondToSubtrack) => AudioStream.Length - (long) ((int) this.AudioConversionSettings.NumberOfChannels * this.AudioConversionSettings.SamplingRate * ((int) this.AudioConversionSettings.BitsPerSample / 8) * (int) NumberOfSecondToSubtrack); + + private void GenerateWaveHeader( + BinaryReader InputFileReader, + BinaryWriter OutputFileWriter, + out long BytesToWrite) + { + BytesToWrite = this.ComputeAudioStreamLength(InputFileReader.BaseStream, this.AudioConversionSettings.PauseDurationInSeconds); + CanonicalWaveHeader canonicalWaveHeader = new CanonicalWaveHeader(this.AudioConversionSettings.NumberOfChannels, this.AudioConversionSettings.SamplingRate, this.AudioConversionSettings.BitsPerSample, new int?((int) BytesToWrite)); + OutputFileWriter.Write(canonicalWaveHeader.ToByteArray()); + } + + private long ConvertStream( + IVirtualFile InputFile, + IVirtualFile OutputFile, + long TotalNumberOfBytesRemainingToWrite, + long TotalNumberOfBytesToWrite, + AsyncOperation asyncOp) + { + long num = 0; + long BytesToWrite = 0; + using (BinaryReader InputFileReader = new BinaryReader(InputFile.FileInputStream)) + { + using (BinaryWriter OutputFileWriter = new BinaryWriter(OutputFile.FileOutputStream)) + { + this.GenerateWaveHeader(InputFileReader, OutputFileWriter, out BytesToWrite); + num = BytesToWrite; + while (num > 0L) + { + if (!this.TaskCanceled(asyncOp)) + { + byte[] buffer = num <= (long) Raw2WavConverter.BUFFER_SIZE ? InputFileReader.ReadBytes((int) num) : InputFileReader.ReadBytes(Raw2WavConverter.BUFFER_SIZE); + OutputFileWriter.Write(buffer); + num -= (long) buffer.Length; + TotalNumberOfBytesRemainingToWrite -= (long) buffer.Length; + int progressPercentage = (int) ((double) (BytesToWrite - num) / (double) BytesToWrite * 100.0); + int totalProgressPercentage = (int) ((double) (TotalNumberOfBytesToWrite - TotalNumberOfBytesRemainingToWrite) / (double) TotalNumberOfBytesToWrite * 100.0); + this.ReportProgress(new UserProcessProgressChangedEventArgs(InputFile.VirtualName, OutputFile.OriginalFileName, progressPercentage, totalProgressPercentage, asyncOp.UserSuppliedState), asyncOp); + } + else + break; + } + } + } + if (num == 0L) + { + if (!this.TaskCanceled(asyncOp)) + goto label_16; + } + try + { + File.Delete(OutputFile.OriginalFileName); + } + catch (Exception ex) + { + UserProcessBase.logger.ErrorFormat("Unable to delete the file {0}: {1}", (object) OutputFile, (object) ex.Message); + } +label_16: + return TotalNumberOfBytesRemainingToWrite; + } + + private delegate void WorkerEventHandler( + IList InputFiles, + string OutputPath, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/Audio/UninitialiedSampleDataSizeException.cs b/SEGATools/Audio/UninitialiedSampleDataSizeException.cs new file mode 100644 index 0000000..a265d0a --- /dev/null +++ b/SEGATools/Audio/UninitialiedSampleDataSizeException.cs @@ -0,0 +1,18 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Audio.UninitialiedSampleDataSizeException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Audio +{ + internal class UninitialiedSampleDataSizeException : Exception + { + public UninitialiedSampleDataSizeException(string message) + : base(message) + { + } + } +} diff --git a/SEGATools/Binary/BinaryPatch.cs b/SEGATools/Binary/BinaryPatch.cs new file mode 100644 index 0000000..4616a0c --- /dev/null +++ b/SEGATools/Binary/BinaryPatch.cs @@ -0,0 +1,43 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.BinaryPatch +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Security.Cryptography; + +namespace SEGATools.Binary +{ + public class BinaryPatch + { + private static readonly System.Security.Cryptography.HashAlgorithm HashAlgorithm = (System.Security.Cryptography.HashAlgorithm) SHA1.Create(); + + public long Offset { get; private set; } + + public byte[] Data { get; private set; } + + public string Hash { get; private set; } + + internal BinaryPatch(long offset, byte[] data) + { + this.Offset = offset; + this.Data = data; + this.Hash = BitConverter.ToString(BinaryPatch.HashAlgorithm.ComputeHash(data)); + } + + public BinaryPatch Translate(long OffsetDelta) => new BinaryPatch(this.Offset + OffsetDelta, this.Data); + + public override string ToString() => string.Format("BinaryPatch [Offset=0x{0:X}, Hash=0x{1}]", (object) this.Offset, (object) this.Hash); + + public override int GetHashCode() => 1 + 17 * this.Offset.GetHashCode() + 31 * this.Hash.GetHashCode(); + + public override bool Equals(object obj) + { + if (obj == null || this.GetType() != obj.GetType()) + return false; + BinaryPatch binaryPatch = (BinaryPatch) obj; + return this.Offset == binaryPatch.Offset && this.Hash.Equals(binaryPatch.Hash); + } + } +} diff --git a/SEGATools/Binary/BinaryPatcher.cs b/SEGATools/Binary/BinaryPatcher.cs new file mode 100644 index 0000000..13b5fdb --- /dev/null +++ b/SEGATools/Binary/BinaryPatcher.cs @@ -0,0 +1,37 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.BinaryPatcher +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.UserProcess; +using System.ComponentModel; +using System.IO; + +namespace SEGATools.Binary +{ + public class BinaryPatcher : UserProcessBase + { + public BinaryPatcher() + { + } + + public BinaryPatcher(IContainer container) + : base(container) + { + } + + public void ApplyPatch(System.IO.Stream stream, BinaryPatch Patch) + { + UserProcessBase.logger.DebugFormat("Applying {0}", (object) Patch); + stream.Seek(Patch.Offset, SeekOrigin.Begin); + stream.Write(Patch.Data, 0, Patch.Data.Length); + } + + public void ApplyPatches(System.IO.Stream stream, BinaryPatch[] Patches) + { + foreach (BinaryPatch patch in Patches) + this.ApplyPatch(stream, patch); + } + } +} diff --git a/SEGATools/Binary/InitialProgramPatches.cs b/SEGATools/Binary/InitialProgramPatches.cs new file mode 100644 index 0000000..5ac7396 --- /dev/null +++ b/SEGATools/Binary/InitialProgramPatches.cs @@ -0,0 +1,170 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.InitialProgramPatches +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; + +namespace SEGATools.Binary +{ + public class InitialProgramPatches + { + private static int IP0000_REPEATED_TIME = 16; + + public static BinaryPatch[] RegionFreePatchesForTrack1 + { + get + { + BinaryPatch[] binaryPatchArray = new BinaryPatch[InitialProgramPatches.IP0000_REPEATED_TIME]; + for (int index = 0; index < binaryPatchArray.Length; ++index) + binaryPatchArray[index] = InitialProgramPatches.RegionFreeFlagsPatch.Translate((long) (index * DiscSectorCommon.LogicalSectorSize)); + return binaryPatchArray; + } + } + + public static BinaryPatch[] RegionFreePatchesForTrack3 => new BinaryPatch[4] + { + InitialProgramPatches.RegionFreeFlagsPatch, + InitialProgramPatches.RegionJapanAreaProtectionSymbolsPatch, + InitialProgramPatches.RegionUsaAreaProtectionSymbolsPatch, + InitialProgramPatches.RegionEuropeAreaProtectionSymbolsPatch + }; + + public static BinaryPatch[] VGAFlagPatchesForTrack1 + { + get + { + BinaryPatch[] binaryPatchArray = new BinaryPatch[InitialProgramPatches.IP0000_REPEATED_TIME]; + for (int index = 0; index < binaryPatchArray.Length; ++index) + binaryPatchArray[index] = InitialProgramPatches.VGAFlagPatch.Translate((long) (index * DiscSectorCommon.LogicalSectorSize)); + return binaryPatchArray; + } + } + + public static BinaryPatch[] VGAFlagPatchesForTrack3 => new BinaryPatch[1] + { + InitialProgramPatches.VGAFlagPatch + }; + + public static BinaryPatch VGAFlagPatch => new BinaryPatch(61L, new byte[1] + { + (byte) 49 + }); + + public static BinaryPatch RegionFreeFlagsPatch => new BinaryPatch(48L, new byte[3] + { + (byte) 74, + (byte) 85, + (byte) 69 + }); + + public static BinaryPatch RegionJapanAreaProtectionSymbolsPatch => new BinaryPatch(14080L, new byte[32] + { + (byte) 14, + (byte) 160, + (byte) 9, + (byte) 0, + (byte) 70, + (byte) 111, + (byte) 114, + (byte) 32, + (byte) 74, + (byte) 65, + (byte) 80, + (byte) 65, + (byte) 78, + (byte) 44, + (byte) 84, + (byte) 65, + (byte) 73, + (byte) 87, + (byte) 65, + (byte) 78, + (byte) 44, + (byte) 80, + (byte) 72, + (byte) 73, + (byte) 76, + (byte) 73, + (byte) 80, + (byte) 73, + (byte) 78, + (byte) 69, + (byte) 83, + (byte) 46 + }); + + public static BinaryPatch RegionUsaAreaProtectionSymbolsPatch => new BinaryPatch(14112L, new byte[32] + { + (byte) 14, + (byte) 160, + (byte) 9, + (byte) 0, + (byte) 70, + (byte) 111, + (byte) 114, + (byte) 32, + (byte) 85, + (byte) 83, + (byte) 65, + (byte) 32, + (byte) 97, + (byte) 110, + (byte) 100, + (byte) 32, + (byte) 67, + (byte) 65, + (byte) 78, + (byte) 65, + (byte) 68, + (byte) 65, + (byte) 46, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32 + }); + + public static BinaryPatch RegionEuropeAreaProtectionSymbolsPatch => new BinaryPatch(14144L, new byte[32] + { + (byte) 14, + (byte) 160, + (byte) 9, + (byte) 0, + (byte) 70, + (byte) 111, + (byte) 114, + (byte) 32, + (byte) 69, + (byte) 85, + (byte) 82, + (byte) 79, + (byte) 80, + (byte) 69, + (byte) 46, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32, + (byte) 32 + }); + } +} diff --git a/SEGATools/Binary/SEGALibrary.cs b/SEGATools/Binary/SEGALibrary.cs new file mode 100644 index 0000000..369a2a5 --- /dev/null +++ b/SEGATools/Binary/SEGALibrary.cs @@ -0,0 +1,59 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.SEGALibrary +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Binary +{ + public class SEGALibrary + { + public static readonly SEGALibrary AIP_103 = new SEGALibrary("AIP", new SEGALibraryVersion("1", "03")); + public static readonly SEGALibrary AIPf_105 = new SEGALibrary("AIPf", new SEGALibraryVersion("1", "05")); + public static readonly SEGALibrary SYTMR_053 = new SEGALibrary("syTmr", new SEGALibraryVersion("0", "53")); + public static readonly SEGALibrary FMMNG_103 = new SEGALibrary("fmMng", new SEGALibraryVersion("1", "03")); + + public string Name { get; private set; } + + public SEGALibraryVersion Version { get; private set; } + + public DateTime BuildDate { get; private set; } + + public SEGALibraryType GetLibraryType() => SEGALibrary.GetTypeFromName(this.Name); + + public SEGALibrary(string Name, SEGALibraryVersion Version) + : this(Name, Version, new DateTime()) + { + } + + public SEGALibrary(string Name, SEGALibraryVersion Version, DateTime BuildOn) + { + this.Name = Name; + this.Version = Version; + this.BuildDate = BuildOn; + } + + public override string ToString() => string.Format("[{0} v{1} build: {2}]", (object) this.Name, (object) this.Version, (object) this.BuildDate); + + public override bool Equals(object obj) + { + if (obj == null || this.GetType() != obj.GetType()) + return false; + SEGALibrary segaLibrary = (SEGALibrary) obj; + return this.GetLibraryType() == segaLibrary.GetLibraryType() && this.Version.Equals((object) segaLibrary.Version); + } + + public override int GetHashCode() => 1 + 17 * this.Name.GetHashCode() + 31 * this.Version.GetHashCode(); + + private static SEGALibraryType GetTypeFromName(string Name) + { + if (SEGALibrary.AIP_103.Name.Equals(Name, StringComparison.InvariantCultureIgnoreCase) || SEGALibrary.AIPf_105.Name.Equals(Name, StringComparison.InvariantCultureIgnoreCase)) + return SEGALibraryType.AIP; + if (SEGALibrary.SYTMR_053.Name.Equals(Name, StringComparison.InvariantCultureIgnoreCase)) + return SEGALibraryType.SYS_TIMER; + return SEGALibrary.FMMNG_103.Name.Equals(Name, StringComparison.InvariantCultureIgnoreCase) ? SEGALibraryType.FLASH_MEMORY_MANAGER : SEGALibraryType.UNKNOWN; + } + } +} diff --git a/SEGATools/Binary/SEGALibraryType.cs b/SEGATools/Binary/SEGALibraryType.cs new file mode 100644 index 0000000..8884b9a --- /dev/null +++ b/SEGATools/Binary/SEGALibraryType.cs @@ -0,0 +1,16 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.SEGALibraryType +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Binary +{ + public enum SEGALibraryType + { + UNKNOWN, + AIP, + SYS_TIMER, + FLASH_MEMORY_MANAGER, + } +} diff --git a/SEGATools/Binary/SEGALibraryVersion.cs b/SEGATools/Binary/SEGALibraryVersion.cs new file mode 100644 index 0000000..0f02706 --- /dev/null +++ b/SEGATools/Binary/SEGALibraryVersion.cs @@ -0,0 +1,35 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Binary.SEGALibraryVersion +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Binary +{ + public class SEGALibraryVersion : IComparable + { + public string Major { get; private set; } + + public string Minor { get; private set; } + + public SEGALibraryVersion(string major, string minor) + { + this.Major = major; + this.Minor = minor; + } + + public override bool Equals(object obj) => obj != null && this.GetType() == obj.GetType() && this.CompareTo((SEGALibraryVersion) obj) == 0; + + public override string ToString() => string.Format("{0}.{1}", (object) this.Major, (object) this.Minor); + + public override int GetHashCode() => 1 + 17 * this.Major.GetHashCode() + 31 * this.Minor.GetHashCode(); + + public int CompareTo(SEGALibraryVersion other) + { + int num = this.Major.CompareTo(other.Major); + return num != 0 ? num : this.Minor.CompareTo(other.Minor); + } + } +} diff --git a/SEGATools/CueSheet/CueSheetCreator.cs b/SEGATools/CueSheet/CueSheetCreator.cs new file mode 100644 index 0000000..e8c9b71 --- /dev/null +++ b/SEGATools/CueSheet/CueSheetCreator.cs @@ -0,0 +1,63 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.CueSheet.CueSheetCreator +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using SEGATools.DiscFileSystem; +using System; +using System.IO; +using System.Linq; + +namespace SEGATools.CueSheet +{ + public class CueSheetCreator + { + public static void CreateFromDiscSession(IDiscSession session, string FileName, string Title) + { + using (StreamWriter streamWriter = new StreamWriter(FileName)) + { + streamWriter.WriteLine(string.Format("TITLE \"{0}\"\n", (object) Title.ToUpper())); + if (session.Tracks.Count == 0) + return; + foreach (IDiscTrack track1 in session.Tracks) + { + IDiscTrack Track = track1; + streamWriter.WriteLine(string.Format("FILE \"{0}\" BINARY", (object) Path.GetFileName(Track.FileName))); + streamWriter.WriteLine(string.Format("TRACK {0:00} {1}", (object) Track.Index, (object) CueSheetCreator.GetCueSheetTrackModeFromTrack(Track))); + if (Track == session.Tracks[0]) + streamWriter.WriteLine("PREGAP " + CueSheetCreator.LogicalBlockAddressToMmSsFf(Track.LogicalBlockAddress)); + streamWriter.WriteLine("INDEX 01 00:00:00"); + if (!CueSheetCreator.IsTheLastTrack(Track, session) && CueSheetCreator.IsPostGapRequired(Track, session.Tracks.First((Func) (track => track.Index == Track.Index + 1)))) + streamWriter.WriteLine("POSTGAP 00:02:00"); + streamWriter.WriteLine(""); + } + } + } + + private static string LogicalBlockAddressToMmSsFf(uint lba) + { + uint num1 = lba / 75U; + uint num2 = num1 / 60U; + uint num3 = num1 % 60U; + uint num4 = lba - (uint) (((int) num2 * 60 + (int) num3) * 75); + return string.Format("{0:00}:{1:00}:{2:00}", (object) num2, (object) num3, (object) num4); + } + + private static string GetCueSheetTrackModeFromTrack(IDiscTrack Track) + { + if (Track.TrackData == TrackModeType.Audio) + return "AUDIO"; + if (Track.TrackSector is ISO9660Sector) + return "MODE1/2048"; + if (Track.TrackSector is CDROMMode1RawSector) + return "MODE1/2352"; + throw new FormatException(string.Format("Not supported track mode for {0}", (object) Track)); + } + + private static bool IsTheLastTrack(IDiscTrack Track, IDiscSession Session) => Track.Index == Session.Tracks[Session.Tracks.Count - 1].Index; + + private static bool IsPostGapRequired(IDiscTrack FirstTrack, IDiscTrack SecondTrack) => FirstTrack.Index + 1 == SecondTrack.Index && FirstTrack.TrackData != SecondTrack.TrackData; + } +} diff --git a/SEGATools/Disc/DiscExtractor.cs b/SEGATools/Disc/DiscExtractor.cs new file mode 100644 index 0000000..3b7ea8d --- /dev/null +++ b/SEGATools/Disc/DiscExtractor.cs @@ -0,0 +1,347 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Disc.DiscExtractor +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.Stream; +using SEGATools.DiscFileSystem; +using SEGATools.Security; +using SEGATools.UserProcess; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Threading; + +namespace SEGATools.Disc +{ + public class DiscExtractor : UserProcessBase + { + private static readonly int OutputFileStreamBuffer = 524288; + + public event AsyncOperationProgressChangedEventHandler ExtractionProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler ExtractionCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public IDiscFileSystem DiscFileSystem { get; set; } + + public DiscExtractor() + { + } + + public DiscExtractor(IContainer container) + : base(container) + { + } + + public void ExtractPathsAsync( + List directoryRecords, + string outputPath, + object taskId) + { + this.ExtractPathsAsync(directoryRecords, outputPath, (SendOrPostCallback) null, taskId); + } + + public void ExtractDirectoryRecordsAsync( + DirectoryRecord directoryRecord, + string outputPath, + object taskId) + { + this.ExtractPathsAsync(directoryRecord, outputPath, (SendOrPostCallback) null, taskId); + } + + public void ExtractDiscTracksAsync(IDiscTrack track, string outputFileName, object taskId) => this.ExtractDiscTracksAsync(new List() + { + track + }, outputFileName, taskId); + + public void ExtractBootStrap(InitialProgram ip, string outputFilename) + { + if (ip == null) + throw new ArgumentNullException(nameof (ip)); + if (string.IsNullOrEmpty(outputFilename)) + throw new ArgumentNullException(nameof (outputFilename)); + using (System.IO.Stream stream = ip.Stream) + { + byte[] buffer = new byte[stream.Length]; + using (FileStream fileStream = new FileStream(outputFilename, FileMode.OpenOrCreate)) + { + stream.Read(buffer, 0, buffer.Length); + fileStream.Write(buffer, 0, buffer.Length); + } + } + } + + private void ExtractPathsAsync( + DirectoryRecord directoryRecord, + string outputPath, + SendOrPostCallback callBack, + object taskId) + { + this.ExtractPathsAsync(new List() + { + directoryRecord + }, outputPath, callBack, taskId); + } + + private void ExtractPathsAsync( + List directoryRecords, + string outputPath, + SendOrPostCallback callBack, + object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new DiscExtractor.FileExtractorWorkerEventHandler(this.FileExtractorWorker).BeginInvoke(directoryRecords, outputPath, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void ExtractDiscTracksAsync(List tracks, string outputPath, object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new DiscExtractor.TrackExtractorWorkerEventHandler(this.TrackExtractorWorker).BeginInvoke(tracks, outputPath, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void FileExtractorWorker( + List directoryRecords, + string outputPath, + AsyncOperation asyncOp) + { + string lastFileName = string.Empty; + string Filename = string.Empty; + Exception exception = (Exception) null; + long num1 = 0; + List source = new List(); + foreach (DirectoryRecord directoryRecord in directoryRecords) + { + num1 += (long) directoryRecord.UsedSpace; + source.Add(directoryRecord); + source.AddRange((IEnumerable) directoryRecord.GetAllSubDirectories()); + } + List list = source.Distinct().ToList(); + long num2 = num1; + string commonPathPrefix = DirectoryRecord.FindCommonPathPrefix(directoryRecords); + UserProcessBase.logger.DebugFormat("The longest path prefix for all {0} files is {1}", (object) list.Count, (object) commonPathPrefix); + try + { + this.CheckForEnoughFreeDiscSpace(num1, outputPath); + foreach (DirectoryRecord directoryRecord in list) + { + if (!this.TaskCanceled(asyncOp)) + { + Filename = directoryRecord.FullPath; + string str1; + if (list.Count == 1 && !directoryRecord.IsDirectory) + { + str1 = outputPath; + } + else + { + if (!directoryRecord.FullPath.StartsWith(commonPathPrefix)) + throw new DiscExtractorException(string.Format("The path \"{0}\" was expected to have the prefix \"{1}\"", (object) directoryRecord.FullPath, (object) commonPathPrefix)); + string str2 = directoryRecord.FullPath.Remove(0, commonPathPrefix.Length); + if (Path.IsPathRooted(str2)) + str2 = str2.Substring(1); + str1 = Path.Combine(outputPath, str2); + } + UserProcessBase.logger.DebugFormat("Extract {0} to {1}", (object) Filename, (object) str1); + if (directoryRecord.IsDirectory) + { + UserProcessBase.logger.DebugFormat("Create output directory {0}", (object) str1); + DirectoryInfo directoryInfo = new DirectoryInfo(str1); + if (!directoryInfo.Exists) + { + Directory.CreateDirectory(directoryInfo.FullName); + DateTime dateTime = directoryRecord.RecordingDateTime.HasValue ? directoryRecord.RecordingDateTime.Value : DateTime.Now; + directoryInfo.CreationTime = dateTime; + directoryInfo.LastWriteTime = dateTime; + } + } + else + { + lastFileName = str1; + num2 = this.ExtractDirectoryRecord(directoryRecord, str1, num1, num2, asyncOp); + } + } + else + break; + } + } + catch (Exception ex) + { + exception = ex; + UserProcessBase.logger.ErrorFormat("Unable to extract the data: {0}", (object) exception); + } + this.DoExtractionCleanupIfNeeded(lastFileName, num2, exception, asyncOp); + this.ReportCompletion(Filename, exception, asyncOp); + } + + private long ExtractDirectoryRecord( + DirectoryRecord directoryRecord, + string FileOutputPath, + long totalNumberOfBytesToExtract, + long totalNumberOfBytesRemaining, + AsyncOperation asyncOp) + { + using (DiscSectorStream forDirectoryRecord = this.DiscFileSystem.GetDiscStreamForDirectoryRecord(directoryRecord)) + { + using (FileStream fileStream = new FileStream(FileOutputPath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, DiscExtractor.OutputFileStreamBuffer)) + { + long length = forDirectoryRecord.Length; + byte[] buffer = new byte[DiscExtractor.OutputFileStreamBuffer]; + while (length > 0L) + { + if (!this.TaskCanceled(asyncOp)) + { + int count = forDirectoryRecord.Read(buffer, 0, buffer.Length); + length -= (long) count; + totalNumberOfBytesRemaining -= (long) count; + fileStream.Write(buffer, 0, count); + this.ReportProgress(this.CreateProgressChangedEventArgs(directoryRecord.FullPath, FileOutputPath, forDirectoryRecord.Length, length, totalNumberOfBytesToExtract, totalNumberOfBytesRemaining, asyncOp), asyncOp); + } + else + break; + } + } + } + DateTime dateTime = directoryRecord.RecordingDateTime.HasValue ? directoryRecord.RecordingDateTime.Value : DateTime.Now; + File.SetCreationTime(FileOutputPath, dateTime); + File.SetLastWriteTime(FileOutputPath, dateTime); + return totalNumberOfBytesRemaining; + } + + private void TrackExtractorWorker( + List tracks, + string outputPath, + AsyncOperation asyncOp) + { + Exception exception = (Exception) null; + string lastFileName = string.Empty; + long ofBytesToExtract = this.ComputeNumberOfBytesToExtract(tracks); + this.CheckForEnoughFreeDiscSpace(ofBytesToExtract, outputPath); + long num = ofBytesToExtract; + try + { + foreach (IDiscTrack track in tracks) + { + if (!this.TaskCanceled(asyncOp)) + { + string outputFileName = tracks.Count > 1 ? Path.Combine(outputPath, Path.GetFileName(track.VirtualName)) : outputPath; + lastFileName = outputFileName; + num = this.ExtractDiscTrack(track, outputFileName, ofBytesToExtract, num, asyncOp); + } + else + break; + } + } + catch (Exception ex) + { + exception = ex; + UserProcessBase.logger.ErrorFormat("Unable to extract the track: {0}", (object) exception); + } + this.DoExtractionCleanupIfNeeded(lastFileName, num, exception, asyncOp); + this.ReportCompletion(outputPath, exception, asyncOp); + } + + private long ExtractDiscTrack( + IDiscTrack track, + string outputFileName, + long totalNumberOfBytesToExtract, + long totalNumberOfBytesRemaining, + AsyncOperation asyncOp) + { + using (System.IO.Stream fileInputStream = track.FileInputStream) + { + using (FileStream fileStream = new FileStream(outputFileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, DiscExtractor.OutputFileStreamBuffer)) + { + long length = fileInputStream.Length; + byte[] buffer = new byte[DiscExtractor.OutputFileStreamBuffer]; + while (length > 0L) + { + if (!this.TaskCanceled(asyncOp)) + { + int count = fileInputStream.Read(buffer, 0, buffer.Length); + length -= (long) count; + totalNumberOfBytesRemaining -= (long) count; + fileStream.Write(buffer, 0, count); + this.ReportProgress(this.CreateProgressChangedEventArgs(track.FileName, outputFileName, fileInputStream.Length, length, totalNumberOfBytesToExtract, totalNumberOfBytesRemaining, asyncOp), asyncOp); + } + else + break; + } + } + } + return totalNumberOfBytesRemaining; + } + + private long ComputeNumberOfBytesToExtract(List tracks) + { + long num = 0; + foreach (IDiscTrack track in tracks) + num += track.FileInputStream.Length; + return num; + } + + private void CheckForEnoughFreeDiscSpace(long requiredSpaceInBytes, string outputPath) + { + if (requiredSpaceInBytes > new DriveInfo(outputPath.Substring(0, 3)).AvailableFreeSpace) + { + UserProcessBase.logger.ErrorFormat("Extraction requires {0} bytes of free disc space in drive {1}", (object) requiredSpaceInBytes, (object) outputPath.Substring(0, 3)); + throw new IOException("Not enough free disc space!"); + } + } + + private UserProcessProgressChangedEventArgs CreateProgressChangedEventArgs( + string input, + string output, + long numberOfBytesToExtract, + long remainingBytesToExtract, + long totalNumberOfBytesToExtract, + long totalNumberOfBytesRemaining, + AsyncOperation asyncOp) + { + int progressPercentage = (int) ((double) (numberOfBytesToExtract - remainingBytesToExtract) / (double) numberOfBytesToExtract * 100.0); + int totalProgressPercentage = (int) ((double) (totalNumberOfBytesToExtract - totalNumberOfBytesRemaining) / (double) totalNumberOfBytesToExtract * 100.0); + return new UserProcessProgressChangedEventArgs(input, output, progressPercentage, totalProgressPercentage, asyncOp.UserSuppliedState); + } + + private void DoExtractionCleanupIfNeeded( + string lastFileName, + long remainingBytes, + Exception exception, + AsyncOperation asyncOp) + { + if (!this.TaskCanceled(asyncOp) && exception == null || remainingBytes <= 0L) + return; + if (!File.Exists(lastFileName)) + return; + try + { + File.Delete(lastFileName); + } + catch (Exception ex) + { + UserProcessBase.logger.ErrorFormat("Unable to delete the file {0}: {1}", (object) lastFileName, (object) ex.Message); + } + } + + private delegate void FileExtractorWorkerEventHandler( + List directoryRecords, + string outputPath, + AsyncOperation asyncOp); + + private delegate void TrackExtractorWorkerEventHandler( + List tracks, + string outputPath, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/Disc/DiscExtractorException.cs b/SEGATools/Disc/DiscExtractorException.cs new file mode 100644 index 0000000..9ca040b --- /dev/null +++ b/SEGATools/Disc/DiscExtractorException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Disc.DiscExtractorException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Disc +{ + public class DiscExtractorException : Exception + { + public DiscExtractorException(string message) + : base(string.Format("Disc Extractor Error: {0}", (object) message)) + { + } + + public DiscExtractorException(string message, Exception innerException) + : base(string.Format("Disc Extractor Error: {0}", (object) message), innerException) + { + } + } +} diff --git a/SEGATools/Disc/DiscFormatProvider.cs b/SEGATools/Disc/DiscFormatProvider.cs new file mode 100644 index 0000000..2d424ab --- /dev/null +++ b/SEGATools/Disc/DiscFormatProvider.cs @@ -0,0 +1,155 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Disc.DiscFormatProvider +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.FileFormat; +using SEGATools.Properties; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; +using System.Reflection; + +namespace SEGATools.Disc +{ + public class DiscFormatProvider : Component + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly string FILEFORMAT_NAMESPACE = "GDRomExplorer.ImageFileFormat"; + private static readonly string FILEFORMAT_PLUGIN_FOLDER = "Formats"; + private static List fileFormats; + private IContainer components; + + public List SupportedFileFormat => DiscFormatProvider.fileFormats.ToList(); + + public DiscFormatProvider() + { + this.InitializeComponent(); + if (DiscFormatProvider.fileFormats != null) + return; + DiscFormatProvider.LoadImageFileFormatAssemblies(); + } + + public DiscFormatProvider(IContainer container) + { + container.Add((IComponent) this); + this.InitializeComponent(); + if (DiscFormatProvider.fileFormats != null) + return; + DiscFormatProvider.LoadImageFileFormatAssemblies(); + } + + public string GetFileDialogFilters(params string[] fileExtensionFilters) + { + int num = 0; + List stringList1 = new List(); + List stringList2 = new List(); + foreach (IImageFileFormat fileFormat in DiscFormatProvider.fileFormats) + { + string[] strArray = fileFormat.FileExtentions; + if (fileExtensionFilters != null && fileExtensionFilters.Length > 0) + strArray = ((IEnumerable) fileFormat.FileExtentions).Where((Func) (extension => ((IEnumerable) fileExtensionFilters).Contains(extension))).ToArray(); + for (int index = 0; index < strArray.Length; ++index) + { + stringList1.Add(fileFormat.FileExtentionDescriptions[index]); + string str = string.Format("*{0}", (object) fileFormat.FileExtentions[index]); + stringList1.Add(str); + stringList2.Add(str); + ++num; + } + } + if (num > 1) + { + stringList1.Insert(0, string.Join(";", stringList2.ToArray())); + stringList1.Insert(0, Resources.DiscFormatProviderAllExtensions); + } + return string.Join("|", stringList1.ToArray()); + } + + public int GetFileFormatIndex(IImageFileFormat imageFileFormat) => DiscFormatProvider.fileFormats.IndexOf(imageFileFormat) + 2; + + public bool IsFileExtensionSupported(string fileExtension) => this.FindImageFileFormatForFileExtension(fileExtension) != null; + + public IImageFileFormat FindImageFileFormatForFileExtension(string fileExtension) => string.IsNullOrEmpty(fileExtension) ? (IImageFileFormat) null : DiscFormatProvider.fileFormats.Find((Predicate) (imageFileFormat => new List((IEnumerable) imageFileFormat.FileExtentions).Contains(fileExtension, (IEqualityComparer) StringComparer.InvariantCultureIgnoreCase))); + + public string GetDescriptionForFileExtension(string extension, IImageFileFormat imageFileFormat) + { + for (int index = 0; index < imageFileFormat.FileExtentions.Length; ++index) + { + if (imageFileFormat.FileExtentions[index].Equals(extension, StringComparison.InvariantCultureIgnoreCase)) + return imageFileFormat.FileExtentionDescriptions[index]; + } + return string.Empty; + } + + private static void LoadImageFileFormatAssemblies() + { + string path = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), DiscFormatProvider.FILEFORMAT_PLUGIN_FOLDER); + try + { + DiscFormatProvider.LoadImageFileFormatAssembliesFromPluginPath(path); + } + catch (DirectoryNotFoundException ex) + { + DiscFormatProvider.logger.ErrorFormat("Unable to find the plugin folder: {0}", (object) path); + logger.Error(ex); + } + } + + private static void LoadImageFileFormatAssembliesFromPluginPath(string path) + { + DiscFormatProvider.fileFormats = new List(); + List typeList = new List(); + Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); + foreach (string file in Directory.GetFiles(path, "*.dll")) + { + try + { + List list = ((IEnumerable) Assembly.LoadFile(file).GetTypes()).Where((Func) (t => t.IsClass && t.Namespace != null && t.Namespace.StartsWith("GDRomExplorer.ImageFileFormat") && typeof (IImageFileFormat).IsAssignableFrom(t))).ToList(); + typeList.AddRange((IEnumerable) list); + } + catch (ReflectionTypeLoadException ex) + { + DiscFormatProvider.logger.ErrorFormat("Unable to load types in namespace \"{0}\"", (object) DiscFormatProvider.FILEFORMAT_NAMESPACE); + logger.Error(ex); + return; + } + } + DiscFormatProvider.logger.InfoFormat("Found {0} file formats to load", (object) typeList.Count); + foreach (Type type in typeList) + { + try + { + IImageFileFormat instance = (IImageFileFormat) Activator.CreateInstance(type); + if (DiscFormatProvider.fileFormats.Contains(instance)) + { + DiscFormatProvider.logger.WarnFormat("File format {0} already loaded", (object) type.Name); + } + else + { + instance.PluginAssemblyFileName = type.Assembly.CodeBase; + DiscFormatProvider.fileFormats.Add(instance); + DiscFormatProvider.logger.InfoFormat("File format {0} loaded", (object) type.Name); + } + } + catch (Exception ex) + { + DiscFormatProvider.logger.ErrorFormat("Unable to load file format {0}: {1}", (object) type.Name, (object) ex); + } + } + DiscFormatProvider.fileFormats = DiscFormatProvider.fileFormats.Distinct().ToList(); + } + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() => this.components = (IContainer) new Container(); + } +} diff --git a/SEGATools/Disc/DiscOpener.cs b/SEGATools/Disc/DiscOpener.cs new file mode 100644 index 0000000..79b73bd --- /dev/null +++ b/SEGATools/Disc/DiscOpener.cs @@ -0,0 +1,119 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Disc.DiscOpener +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.Binary; +using SEGATools.DiscFileSystem; +using SEGATools.Scanner; +using SEGATools.UserProcess; +using SEGATools.VirtualFile; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; + +namespace SEGATools.Disc +{ + public class DiscOpener : UserProcessBase + { + private IDiscFileSystem disc; + private bool computePathTable; + + public event AsyncOperationProgressChangedEventHandler FileOpenerProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler FileOpenerCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public IDiscFileSystem DiscFileSystem => this.disc; + + public DiscOpener() + { + } + + public DiscOpener(IContainer container) + : base(container) + { + } + + public void OpenImageAsync( + string Filename, + IDiscFileSystemConverter ImageFileConverter, + bool ComputePathTable) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation((object) Guid.NewGuid()); + this.computePathTable = ComputePathTable; + new DiscOpener.FileOpenerWorkerEventHandler(this.FileOpenerWorker).BeginInvoke(Filename, ImageFileConverter, asyncOperation, (AsyncCallback) null, (object) null); + } + + public void OpenImage( + string Filename, + IDiscFileSystemConverter ImageFileConverter, + bool ComputePathTable) + { + this.computePathTable = ComputePathTable; + this.FileOpenerWorker(Filename, ImageFileConverter, (AsyncOperation) null); + } + + public void CloseImage() + { + if (this.disc == null) + return; + this.disc.Close(); + this.disc = (IDiscFileSystem) null; + } + + private void FileOpenerWorker( + string Filename, + IDiscFileSystemConverter ImageFileConverter, + AsyncOperation asyncOp) + { + Exception exception = (Exception) null; + if (asyncOp != null) + this.ReportProgress(new UserProcessProgressChangedEventArgs(Filename, 0, asyncOp.UserSuppliedState), asyncOp); + if (this.disc != null) + { + this.disc.Close(); + this.disc = (IDiscFileSystem) null; + } + try + { + this.disc = DiscFileSystemBuilder.ToDisc(Filename, ImageFileConverter, this.computePathTable); + foreach (IDiscSession discSession in this.disc.Sessions.FindAll((Predicate) (session => session.BootStrap != null))) + { + using (FileScanner fileScanner = new FileScanner()) + { + IVirtualFile virtualFile = VirtualFileFactory.createVirtualFile(discSession.BootStrap.Stream, this.disc.FileName); + List Libraries = fileScanner.ScanFile((IVirtualFile) virtualFile, FileScannerPattern.aPatternForSEGALibraries(), (IFileScannerResultConverter) new FileScannerResultConverterForSEGALibrary()); + this.disc.RegisterLibraries((object) discSession.BootStrap, Libraries); + } + } + } + catch (Exception ex) + { + exception = ex; + this.disc = (IDiscFileSystem) null; + UserProcessBase.logger.DebugFormat("Error while reading the image file: {0}", (object) ex); + } + if ((this.TaskCanceled(asyncOp) || exception != null) && this.disc != null) + { + this.disc.Close(); + this.disc = (IDiscFileSystem) null; + } + this.ReportCompletion(Filename, exception, asyncOp); + } + + private delegate void FileOpenerWorkerEventHandler( + string filename, + IDiscFileSystemConverter imageFileConverter, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/Disc/DiscSectorEncoder.cs b/SEGATools/Disc/DiscSectorEncoder.cs new file mode 100644 index 0000000..3a48f9a --- /dev/null +++ b/SEGATools/Disc/DiscSectorEncoder.cs @@ -0,0 +1,60 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Disc.DiscSectorEncoder +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using SEGATools.HashAlgorithm; +using SEGATools.UserProcess; +using System; +using System.ComponentModel; +using System.IO; + +namespace SEGATools.Disc +{ + public class DiscSectorEncoder : UserProcessBase + { + private EDC edcEncoder = new EDC(); + private ECC.ECCParityVectorAlgorithm eccPParityEncoder = (ECC.ECCParityVectorAlgorithm) new ECC.PParity(); + private ECC.ECCParityVectorAlgorithm eccQParityEncoder = (ECC.ECCParityVectorAlgorithm) new ECC.QParity(); + + public DiscSectorEncoder() + { + } + + public DiscSectorEncoder(IContainer container) + : base(container) + { + } + + public void EncodeMode1Sectors(System.IO.Stream stream, int[] sectors) + { + byte[] numArray = new byte[DiscSectorCommon.RawSectorSize]; + for (int index = 0; index < sectors.Length; ++index) + { + UserProcessBase.logger.DebugFormat("Patching EDC and ECC data of sector {0}", (object) sectors[index]); + stream.Seek((long) (sectors[index] * DiscSectorCommon.RawSectorSize), SeekOrigin.Begin); + stream.Read(numArray, 0, DiscSectorCommon.RawSectorSize); + this.ClearErrorDetectionAndCorrectionData(numArray); + this.GenerateEDC(numArray); + this.eccPParityEncoder.ComputeVectors(numArray); + this.eccQParityEncoder.ComputeVectors(numArray); + stream.Seek((long) -DiscSectorCommon.RawSectorSize, SeekOrigin.Current); + stream.Write(numArray, 0, numArray.Length); + } + } + + public void GenerateEDC(byte[] sector) + { + byte[] hash = this.edcEncoder.ComputeHash(sector, 0, EDC.SECTOR_DATA_LENGTH_FOR_EDC_COMPUTATION); + Buffer.BlockCopy((Array) hash, 0, (Array) sector, EDC.EDC_DATA_OFFSET, hash.Length); + } + + public void ClearErrorDetectionAndCorrectionData(byte[] sector) + { + for (int edcDataOffset = EDC.EDC_DATA_OFFSET; edcDataOffset < sector.Length; ++edcDataOffset) + sector[edcDataOffset] = (byte) 0; + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscFileSystem.cs b/SEGATools/DiscFileSystem/DiscFileSystem.cs new file mode 100644 index 0000000..455eabf --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscFileSystem.cs @@ -0,0 +1,113 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscFileSystem +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.Stream; +using SEGATools.Binary; +using SEGATools.Encrypt; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace SEGATools.DiscFileSystem +{ + internal sealed class DiscFileSystem : IDiscFileSystem + { + private readonly Dictionary> FileLibraries; + + public List Sessions { get; private set; } + + public string FileName { get; private set; } + + public bool CanExtractData { get; private set; } + + public bool CanBeExportedToCueSheet { get; private set; } + + public bool CanBeExportedToGdi { get; private set; } + + public string DiscName { get; set; } + + public DirectoryRecord MainBinary { get; set; } + + public DiscImageType DiscType { get; set; } + + public List AllTracks + { + get + { + List allTracks = new List(); + this.Sessions.ForEach((Action) (session => allTracks.AddRange((IEnumerable) session.Tracks))); + return allTracks.OrderBy((Func) (track => track.LogicalBlockAddress)).ToList(); + } + } + + public DESKey NaomiDESKey { get; set; } + + internal DiscFileSystem(string filename, List sessions) + : this(filename, sessions, false, false, false) + { + } + + internal DiscFileSystem( + string filename, + List sessions, + bool supportDataExtraction) + : this(filename, sessions, supportDataExtraction, false, false) + { + } + + internal DiscFileSystem( + string filename, + List sessions, + bool supportDataExtraction, + bool supportCueSheet) + : this(filename, sessions, supportDataExtraction, supportCueSheet, false) + { + } + + internal DiscFileSystem( + string filename, + List sessions, + bool supportDataExtraction, + bool supportCueSheet, + bool supportGdiExport) + { + this.FileName = filename; + this.DiscName = "N/A"; + sessions.ForEach((Action) (discSession => discSession.Disc = (IDiscFileSystem) this)); + this.Sessions = sessions.OrderBy((Func) (session => session.Index)).ToList(); + this.DiscType = DiscImageType.Unknown; + this.CanExtractData = supportDataExtraction; + this.CanBeExportedToCueSheet = supportCueSheet; + this.CanBeExportedToGdi = supportGdiExport; + this.FileLibraries = new Dictionary>(); + } + + public IDiscTrack GetTrackForLogicalBlockAddress(long lba) => this.AllTracks.LastOrDefault((Func) (track => (long) track.LogicalBlockAddress <= lba)); + + public DiscSectorStream GetDiscStreamForDirectoryRecord( + DirectoryRecord directoryRecord) + { + IDiscTrack logicalBlockAddress = this.GetTrackForLogicalBlockAddress((long) directoryRecord.Extent); + return logicalBlockAddress == null || directoryRecord.IsDirectory ? (DiscSectorStream) null : new DiscSectorStream(logicalBlockAddress.FileInputStream, logicalBlockAddress.TrackSector, directoryRecord.Extent - logicalBlockAddress.LogicalBlockAddress, directoryRecord.ExtentSize, true); + } + + public void RegisterLibraries(object file, List Libraries) => this.FileLibraries[file] = Libraries; + + public List GetSEGALibraries(object file) => !this.FileLibraries.Keys.Contains(file) ? (List) null : this.FileLibraries[file]; + + public void Close() + { + this.MainBinary = (DirectoryRecord) null; + if (this.Sessions == null) + return; + foreach (IDiscSession session in this.Sessions) + session.Close(); + this.Sessions.Clear(); + this.Sessions = (List) null; + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscFileSystemBuilder.cs b/SEGATools/DiscFileSystem/DiscFileSystemBuilder.cs new file mode 100644 index 0000000..26b123c --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscFileSystemBuilder.cs @@ -0,0 +1,161 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscFileSystemBuilder +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscFileSystem; +using ImageReader.ImageReader; +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.Stream; +using SEGATools.Encrypt; +using SEGATools.Security; +using System; +using System.IO; +using System.Linq; +using System.Text; +using System.Text.RegularExpressions; + +namespace SEGATools.DiscFileSystem +{ + public sealed class DiscFileSystemBuilder + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly string NAOMI_GD_BINARY_NAME = "NAOMIGD.BIN"; + private static readonly Regex NAOMI_PRODUCT_ID_PREFIX = new Regex("GD.+-.*", RegexOptions.IgnoreCase | RegexOptions.Compiled); + private static readonly string NAOMI_KEY_FILE_EXT = "key"; + private static readonly string NAOMI_KEY_FILE_NAME = "key.txt"; + + private static InitialProgram GetBootStrapFrom(IDiscTrack track) + { + byte[] buffer; + using (DiscSectorStream discSectorStream = new DiscSectorStream(track.FileInputStream, track.TrackSector, 0U, InitialProgram.IP_FILESIZE, true)) + { + buffer = new byte[discSectorStream.Length]; + discSectorStream.Read(buffer, 0, buffer.Length); + } + try + { + return InitialProgramConverter.ToInitialProgram(buffer, 0); + } + catch (InitialProgramInvalidHardwareIdException ex) + { + logger.Warn(ex); + return (InitialProgram) null; + } + finally + { + } + } + + private static InitialProgram GetBootStrapFrom(IDiscSession session) + { + foreach (IDiscTrack dataTrack in session.DataTracks) + { + InitialProgram bootStrapFrom = DiscFileSystemBuilder.GetBootStrapFrom(dataTrack); + if (bootStrapFrom != null) + return bootStrapFrom; + } + return (InitialProgram) null; + } + + private static DirectoryRecord GetMainBinary( + IDiscFileSystem discFileSystem, + DirectoryRecord rootDirectoryRecord, + InitialProgram ip) + { + if (rootDirectoryRecord.Contains(DiscFileSystemBuilder.NAOMI_GD_BINARY_NAME)) + { + DirectoryRecord directoryRecord1 = rootDirectoryRecord.SubDirectories.Find((Predicate) (directoryRecord => directoryRecord.ExtentSize.Equals(256U))); + DiscSectorStream forDirectoryRecord = discFileSystem.GetDiscStreamForDirectoryRecord(directoryRecord1); + forDirectoryRecord.Seek(192L, SeekOrigin.Begin); + byte[] numArray = new byte[64]; + forDirectoryRecord.Read(numArray, 0, numArray.Length); + int count = 0; + while (count < numArray.Length && numArray[count] != (byte) 0) + ++count; + string NaomiMainBinaryFileName = Encoding.Default.GetString(numArray, 0, count); + return rootDirectoryRecord.SubDirectories.Find((Predicate) (directoryRecord => directoryRecord.Name.Equals(NaomiMainBinaryFileName))); + } + string MainBinaryFileName = ip.MainBinary.Trim(); + return rootDirectoryRecord.Contains(MainBinaryFileName) ? rootDirectoryRecord.SubDirectories.Find((Predicate) (directoryRecord => directoryRecord.Name.Equals(MainBinaryFileName))) : (DirectoryRecord) null; + } + + private static DESKey TryGetDESKey(string FileName) + { + string[] strArray = new string[2] + { + Path.ChangeExtension(FileName, DiscFileSystemBuilder.NAOMI_KEY_FILE_EXT), + Path.Combine(Path.GetDirectoryName(FileName), DiscFileSystemBuilder.NAOMI_KEY_FILE_NAME) + }; + foreach (string path in strArray) + { + DiscFileSystemBuilder.logger.DebugFormat("Searching for DES key in {0}", (object) path); + if (File.Exists(path)) + { + using (StreamReader streamReader = new StreamReader(path)) + { + string key = streamReader.ReadLine(); + if (DESKey.TryParse(key)) + { + DESKey desKey = DESKey.Parse(key); + DiscFileSystemBuilder.logger.DebugFormat("DESKey found in {0}: {1}", (object) path, (object) desKey); + return desKey; + } + DiscFileSystemBuilder.logger.WarnFormat("Could not parse the DES key in {0}", (object) path); + } + } + } + DiscFileSystemBuilder.logger.Debug((object) "No DES key found"); + return (DESKey) null; + } + + public static IDiscFileSystem ToDisc( + string FileName, + IDiscFileSystemConverter DiscFileSystemConverter, + bool computePathTable) + { + IDiscFileSystem discFileSystem = DiscFileSystemConverter.ToDiscFileSystem(FileName); + foreach (IDiscSession session in discFileSystem.Sessions.FindAll((Predicate) (s => s.DataTracks.Count > 0))) + { + if (session.DataTracks.Count >= 1) + { + IDiscTrack dataTrack = session.DataTracks[0]; + try + { + using (DiscImageReader discImageReader = new DiscImageReader()) + { + discImageReader.ParsePathTable = !computePathTable; + discImageReader.Open(dataTrack.FileInputStream, dataTrack.LogicalBlockAddress, dataTrack.TrackSector); + session.PrimaryVolumeDescriptor = discImageReader.PrimaryVolumeDescriptor; + session.RootDirectoryRecord = discImageReader.PrimaryVolumeDescriptor.RootDirectoryRecord; + } + } + catch (DiscImageReaderException ex) + { + logger.Error(ex); + } + } + session.BootStrap = DiscFileSystemBuilder.GetBootStrapFrom(session); + } + IDiscSession discSession1 = discFileSystem.Sessions.LastOrDefault((Func) (session => session.RootDirectoryRecord != null)); + if (discSession1 == null) + throw DiscFileSystemException.noFileSystemFoundException(); + IDiscSession discSession2 = discFileSystem.Sessions.LastOrDefault((Func) (s => s.BootStrap != null)); + if (discSession2 != null && discSession2.BootStrap != null) + { + discFileSystem.DiscType = DiscImageType.Dreamcast; + InitialProgram bootStrap = discSession2.BootStrap; + discSession1.MainBinary = DiscFileSystemBuilder.GetMainBinary(discFileSystem, discSession1.RootDirectoryRecord, bootStrap); + if (DiscFileSystemBuilder.NAOMI_PRODUCT_ID_PREFIX.Match(bootStrap.ProductID).Success) + { + discFileSystem.DiscType = DiscImageType.Naomi; + discFileSystem.NaomiDESKey = DiscFileSystemBuilder.TryGetDESKey(FileName); + } + discFileSystem.DiscName = bootStrap.SoftwareName.Trim(); + discFileSystem.MainBinary = discSession1.MainBinary; + } + return discFileSystem; + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscFileUtils.cs b/SEGATools/DiscFileSystem/DiscFileUtils.cs new file mode 100644 index 0000000..af547ce --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscFileUtils.cs @@ -0,0 +1,20 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscFileUtils +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; + +namespace SEGATools.DiscFileSystem +{ + public class DiscFileUtils + { + public static string GetExtensionForDiscTrack(IDiscTrack DiscTrack) + { + if (DiscTrack.TrackData == TrackModeType.Audio) + return ".raw"; + return DiscTrack.TrackSector is ISO9660Sector ? ".iso" : ".bin"; + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscFormatException.cs b/SEGATools/DiscFileSystem/DiscFormatException.cs new file mode 100644 index 0000000..d1cdd60 --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscFormatException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscFormatException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.DiscFileSystem +{ + public class DiscFormatException : Exception + { + public DiscFormatException(string message) + : base(message) + { + } + + public DiscFormatException(string message, Exception innerException) + : base(message, innerException) + { + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscImageType.cs b/SEGATools/DiscFileSystem/DiscImageType.cs new file mode 100644 index 0000000..4c12260 --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscImageType.cs @@ -0,0 +1,15 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscImageType +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.DiscFileSystem +{ + public enum DiscImageType : short + { + Unknown, + Dreamcast, + Naomi, + } +} diff --git a/SEGATools/DiscFileSystem/DiscSession.cs b/SEGATools/DiscFileSystem/DiscSession.cs new file mode 100644 index 0000000..78ec819 --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscSession.cs @@ -0,0 +1,110 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscSession +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.ISO9660.VolumeDescriptors; +using SEGATools.Security; +using System; +using System.Collections.Generic; +using System.Linq; + +namespace SEGATools.DiscFileSystem +{ + internal sealed class DiscSession : IDiscSession + { + public static readonly string DEFAULT_SESSION_NAME_WITH_FORMAT = "Session {0}"; + private readonly string name; + private int index; + private InitialProgram ip; + private IDiscFileSystem disc; + private DirectoryRecord mainBinary; + private PrimaryVolumeDescriptor primaryVolumeDescriptor; + private DirectoryRecord rootDirectoryRecord; + private List tracks; + + public List Tracks => this.tracks.ToList(); + + public List DataTracks => this.tracks.FindAll((Predicate) (track => track.TrackData == TrackModeType.Data)); + + public IDiscTrack FirstDataTrack + { + get + { + List all = this.tracks.FindAll((Predicate) (track => track.TrackData == TrackModeType.Data)); + return all.Count <= 0 ? (IDiscTrack) null : all.OrderBy((Func) (track => track.Index)).First(); + } + } + + public IDiscTrack LastDataTrack + { + get + { + List all = this.tracks.FindAll((Predicate) (track => track.TrackData == TrackModeType.Data)); + return all.Count <= 0 ? (IDiscTrack) null : all.OrderBy((Func) (track => track.Index)).Last(); + } + } + + public List AudioTracks => this.tracks.FindAll((Predicate) (track => track.TrackData == TrackModeType.Audio)); + + public int Index => this.index; + + public string Name => this.name; + + public DirectoryRecord MainBinary + { + get => this.mainBinary; + set => this.mainBinary = value; + } + + public DirectoryRecord RootDirectoryRecord + { + get => this.rootDirectoryRecord; + set => this.rootDirectoryRecord = value; + } + + public InitialProgram BootStrap + { + get => this.ip; + set => this.ip = value; + } + + public PrimaryVolumeDescriptor PrimaryVolumeDescriptor + { + get => this.primaryVolumeDescriptor; + set => this.primaryVolumeDescriptor = value; + } + + public IDiscFileSystem Disc + { + get => this.disc; + set => this.disc = value; + } + + public DiscSession(int index, string name, List tracks) + { + this.index = index; + this.name = name; + this.tracks = tracks.OrderBy((Func) (track => track.LogicalBlockAddress)).ToList(); + this.tracks.ForEach((Action) (track => track.Session = (IDiscSession) this)); + } + + public void Close() + { + this.ip = (InitialProgram) null; + this.mainBinary = (DirectoryRecord) null; + this.rootDirectoryRecord = (DirectoryRecord) null; + this.primaryVolumeDescriptor = (PrimaryVolumeDescriptor) null; + if (this.tracks != null) + { + foreach (IDiscTrack track in this.tracks) + track.Close(); + this.tracks.Clear(); + this.tracks = (List) null; + } + this.disc = (IDiscFileSystem) null; + } + } +} diff --git a/SEGATools/DiscFileSystem/DiscTrack.cs b/SEGATools/DiscFileSystem/DiscTrack.cs new file mode 100644 index 0000000..1b7b913 --- /dev/null +++ b/SEGATools/DiscFileSystem/DiscTrack.cs @@ -0,0 +1,87 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.DiscTrack +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using SEGATools.Stream; +using SEGATools.VirtualFile; +using System; +using System.IO; + +namespace SEGATools.DiscFileSystem +{ + internal sealed class DiscTrack : IDiscTrack, IVirtualFile, IDisposable + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private bool disposed; + + public string FileName { get; private set; } + + public string Name => string.Format("Track {0:00}", (object) this.Index); + + public int Index { get; private set; } + + public uint LogicalBlockAddress { get; private set; } + + public long Length { get; private set; } + + public long Offset { get; private set; } + + public TrackModeType TrackData { get; private set; } + + public IDiscSector TrackSector { get; private set; } + + public IDiscSession Session { get; set; } + + public static IDiscTrack CreateCopyFrom(IDiscTrack source, string newFileName) => (IDiscTrack) new DiscTrack(newFileName, source.Offset, source.Length, source.LogicalBlockAddress, source.Index, source.TrackData, source.TrackSector); + + internal DiscTrack( + string fileName, + long offset, + long length, + uint logicalBlockAdress, + int index, + TrackModeType trackData, + IDiscSector trackSector) + { + this.disposed = false; + this.LogicalBlockAddress = logicalBlockAdress; + this.FileName = Path.GetFullPath(fileName); + this.OriginalFileName = fileName; + this.Index = index; + this.TrackData = trackData; + this.Offset = offset; + this.Length = length; + this.TrackSector = trackSector; + } + + public void Close() => this.Session = (IDiscSession) null; + + public override string ToString() => this.Name; + + public System.IO.Stream FileInputStream => (System.IO.Stream) new SubStream((System.IO.Stream) File.Open(this.FileName, FileMode.Open, FileAccess.Read, FileShare.Read), this.Offset, this.Length, true); + + public string OriginalFileName { get; set; } + + public System.IO.Stream FileOutputStream => (System.IO.Stream) new SubStream((System.IO.Stream) File.Open(this.FileName, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read), this.Offset, this.Length, true); + + public string VirtualName => Path.ChangeExtension(string.Format("track{0:00}", (object) this.Index), DiscFileUtils.GetExtensionForDiscTrack((IDiscTrack) this)); + + public void Dispose() + { + this.Dispose(true); + GC.SuppressFinalize((object) this); + } + + private void Dispose(bool disposing) + { + if (this.disposed) + return; + if (disposing) + this.Close(); + this.disposed = true; + } + } +} diff --git a/SEGATools/DiscFileSystem/GenericImageConverter.cs b/SEGATools/DiscFileSystem/GenericImageConverter.cs new file mode 100644 index 0000000..907a27f --- /dev/null +++ b/SEGATools/DiscFileSystem/GenericImageConverter.cs @@ -0,0 +1,149 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.GenericImageConverter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using ImageReader.ImageReader; +using ImageReader.Stream; +using SEGATools.Security; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Text.RegularExpressions; + +namespace SEGATools.DiscFileSystem +{ + public class GenericImageConverter : IDiscFileSystemConverter + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + private static readonly Regex FIND_NEXT_FILE = new Regex("^(?.*)(?[0-9]{2}?)$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.Singleline); + private static readonly int INVALID_FILE_INDEX = -1; + private static readonly int DEFAULT_FILE_INDEX = 1; + private IDiscSector discSector; + + public GenericImageConverter(IDiscSector discSector) => this.discSector = discSector; + + public IDiscFileSystem ToDiscFileSystem(string imageFileName) + { + InitialProgram initialProgram = this.GetInitialProgram(imageFileName, this.discSector); + List tracks = new List(); + int index = this.GetIndexFromFileName(imageFileName); + if (index == GenericImageConverter.INVALID_FILE_INDEX) + index = GenericImageConverter.DEFAULT_FILE_INDEX; + GenericImageConverter.TrackFile trackFile = new GenericImageConverter.TrackFile(index, imageFileName); + uint num = 0; + if (this.ContainsNonEmptyISO9660FileSystem(trackFile, num)) + { + IDiscTrack discTrack = (IDiscTrack) new DiscTrack(trackFile.FileName, 0L, trackFile.Length, num, trackFile.Index, TrackModeType.Data, this.discSector); + tracks.Add(discTrack); + } + else if (initialProgram != null && initialProgram.TableOfContent != null && this.ContainsNonEmptyISO9660FileSystem(trackFile, initialProgram.TableOfContent.FirstTrack.FrameAddress)) + { + uint frameAddress = initialProgram.TableOfContent.FirstTrack.FrameAddress; + IDiscTrack discTrack1 = (IDiscTrack) new DiscTrack(trackFile.FileName, 0L, trackFile.Length, frameAddress, trackFile.Index, TrackModeType.Data, this.discSector); + tracks.Add(discTrack1); + GenericImageConverter.TrackFile nextImageFile = this.FindNextImageFile(imageFileName); + if (initialProgram.TableOfContent.HasSplitedDataTracks && nextImageFile != null) + { + IDiscTrack discTrack2 = (IDiscTrack) new DiscTrack(nextImageFile.FileName, 0L, nextImageFile.Length, initialProgram.TableOfContent.LastTrack.FrameAddress, nextImageFile.Index, TrackModeType.Data, this.discSector); + tracks.Add(discTrack2); + } + } + IDiscSession discSession = (IDiscSession) new DiscSession(1, string.Format(DiscSession.DEFAULT_SESSION_NAME_WITH_FORMAT, (object) 1), tracks); + List sessions = new List(); + sessions.Add(discSession); + bool supportCueSheet = tracks.Count == 1; + return (IDiscFileSystem) new SEGATools.DiscFileSystem.DiscFileSystem(imageFileName, sessions, true, supportCueSheet); + } + + private bool ContainsNonEmptyISO9660FileSystem( + GenericImageConverter.TrackFile trackFile, + uint lba) + { + IDiscTrack discTrack = (IDiscTrack) new DiscTrack(trackFile.FileName, 0L, trackFile.Length, lba, trackFile.Index, TrackModeType.Data, this.discSector); + using (DiscImageReader discImageReader = new DiscImageReader()) + { + try + { + discImageReader.Open(discTrack.FileInputStream, discTrack.LogicalBlockAddress, this.discSector); + return discImageReader.RootDirectoryRecord.UsedSpace > 0U; + } + catch (DiscImageReaderException ex) + { + logger.Error(ex); + } + } + return false; + } + + private InitialProgram GetInitialProgram(string imageFileName, IDiscSector sector) + { + try + { + byte[] buffer; + using (DiscSectorStream discSectorStream = new DiscSectorStream(imageFileName, sector, 0U, InitialProgram.IP_FILESIZE)) + { + buffer = new byte[discSectorStream.Length]; + discSectorStream.Read(buffer, 0, buffer.Length); + } + return InitialProgramConverter.ToInitialProgram(buffer, 0); + } + catch (Exception ex) + { + Console.WriteLine(ex); + } + finally + { + } + return (InitialProgram) null; + } + + private GenericImageConverter.TrackFile FindNextImageFile(string fileName) + { + int startIndex = this.GetIndexFromFileName(fileName); + if (startIndex == GenericImageConverter.INVALID_FILE_INDEX) + return (GenericImageConverter.TrackFile) null; + string prefixFromFileName = this.GetFileNamePrefixFromFileName(fileName); + if (string.IsNullOrEmpty(prefixFromFileName)) + return (GenericImageConverter.TrackFile) null; + string[] array = ((IEnumerable) Directory.GetFiles(Path.GetDirectoryName(fileName), prefixFromFileName + "*" + Path.GetExtension(fileName))).Where((Func) (FilePath => this.GetIndexFromFileName(FilePath) > startIndex)).ToArray(); + if (array.Length <= 0) + return (GenericImageConverter.TrackFile) null; + string fileName1 = array[0]; + return new GenericImageConverter.TrackFile(this.GetIndexFromFileName(fileName1), fileName1); + } + + private string GetFileNamePrefixFromFileName(string fileName) + { + string withoutExtension = Path.GetFileNameWithoutExtension(fileName); + Match match = GenericImageConverter.FIND_NEXT_FILE.Match(withoutExtension); + return match.Success ? match.Groups["prefix"].Value : string.Empty; + } + + private int GetIndexFromFileName(string fileName) + { + string withoutExtension = Path.GetFileNameWithoutExtension(fileName); + Match match = GenericImageConverter.FIND_NEXT_FILE.Match(withoutExtension); + return match.Success ? int.Parse(match.Groups["index"].Value) : GenericImageConverter.INVALID_FILE_INDEX; + } + + private class TrackFile + { + public int Index { get; private set; } + + public long Length { get; private set; } + + public string FileName { get; private set; } + + public TrackFile(int index, string fileName) + { + this.Index = index; + this.FileName = fileName; + this.Length = new FileInfo(fileName).Length; + } + } + } +} diff --git a/SEGATools/DiscFileSystem/IDiscFileSystem.cs b/SEGATools/DiscFileSystem/IDiscFileSystem.cs new file mode 100644 index 0000000..4830cee --- /dev/null +++ b/SEGATools/DiscFileSystem/IDiscFileSystem.cs @@ -0,0 +1,45 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.IDiscFileSystem +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.Stream; +using SEGATools.Binary; +using SEGATools.Encrypt; +using System.Collections.Generic; + +namespace SEGATools.DiscFileSystem +{ + public interface IDiscFileSystem + { + bool CanExtractData { get; } + + bool CanBeExportedToCueSheet { get; } + + bool CanBeExportedToGdi { get; } + + List Sessions { get; } + + string FileName { get; } + + string DiscName { get; set; } + + DirectoryRecord MainBinary { get; set; } + + DiscImageType DiscType { get; set; } + + List AllTracks { get; } + + DiscSectorStream GetDiscStreamForDirectoryRecord(DirectoryRecord directoryRecord); + + void RegisterLibraries(object file, List Libraries); + + List GetSEGALibraries(object file); + + DESKey NaomiDESKey { get; set; } + + void Close(); + } +} diff --git a/SEGATools/DiscFileSystem/IDiscFileSystemConverter.cs b/SEGATools/DiscFileSystem/IDiscFileSystemConverter.cs new file mode 100644 index 0000000..cc39771 --- /dev/null +++ b/SEGATools/DiscFileSystem/IDiscFileSystemConverter.cs @@ -0,0 +1,13 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.IDiscFileSystemConverter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.DiscFileSystem +{ + public interface IDiscFileSystemConverter + { + IDiscFileSystem ToDiscFileSystem(string imageFileName); + } +} diff --git a/SEGATools/DiscFileSystem/IDiscSession.cs b/SEGATools/DiscFileSystem/IDiscSession.cs new file mode 100644 index 0000000..39e2e61 --- /dev/null +++ b/SEGATools/DiscFileSystem/IDiscSession.cs @@ -0,0 +1,42 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.IDiscSession +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.ISO9660.DirectoryRecords; +using ImageReader.ISO9660.VolumeDescriptors; +using SEGATools.Security; +using System.Collections.Generic; + +namespace SEGATools.DiscFileSystem +{ + public interface IDiscSession + { + List Tracks { get; } + + List DataTracks { get; } + + IDiscTrack FirstDataTrack { get; } + + IDiscTrack LastDataTrack { get; } + + List AudioTracks { get; } + + int Index { get; } + + string Name { get; } + + DirectoryRecord MainBinary { get; set; } + + InitialProgram BootStrap { get; set; } + + PrimaryVolumeDescriptor PrimaryVolumeDescriptor { get; set; } + + DirectoryRecord RootDirectoryRecord { get; set; } + + IDiscFileSystem Disc { get; set; } + + void Close(); + } +} diff --git a/SEGATools/DiscFileSystem/IDiscTrack.cs b/SEGATools/DiscFileSystem/IDiscTrack.cs new file mode 100644 index 0000000..951f64a --- /dev/null +++ b/SEGATools/DiscFileSystem/IDiscTrack.cs @@ -0,0 +1,35 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.IDiscTrack +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using SEGATools.VirtualFile; +using System; + +namespace SEGATools.DiscFileSystem +{ + public interface IDiscTrack : IVirtualFile, IDisposable + { + string FileName { get; } + + string Name { get; } + + int Index { get; } + + long Length { get; } + + uint LogicalBlockAddress { get; } + + long Offset { get; } + + TrackModeType TrackData { get; } + + IDiscSector TrackSector { get; } + + IDiscSession Session { get; set; } + + void Close(); + } +} diff --git a/SEGATools/DiscFileSystem/TrackModeType.cs b/SEGATools/DiscFileSystem/TrackModeType.cs new file mode 100644 index 0000000..425a5cd --- /dev/null +++ b/SEGATools/DiscFileSystem/TrackModeType.cs @@ -0,0 +1,14 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.DiscFileSystem.TrackModeType +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.DiscFileSystem +{ + public enum TrackModeType : short + { + Audio = 0, + Data = 4, + } +} diff --git a/SEGATools/Encrypt/DESKey.cs b/SEGATools/Encrypt/DESKey.cs new file mode 100644 index 0000000..b502ca0 --- /dev/null +++ b/SEGATools/Encrypt/DESKey.cs @@ -0,0 +1,80 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Encrypt.DESKey +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Security.Cryptography; +using System.Text.RegularExpressions; + +namespace SEGATools.Encrypt +{ + public class DESKey + { + private static readonly Logger.ILog logger = Logger.CreateLog(); + + private static readonly byte[] DEFAULT_NAOMI_IV = new byte[8]; + private static readonly Regex VALID_KEY_STRING = new Regex("[a-f0-9]{16}", RegexOptions.IgnoreCase | RegexOptions.Compiled); + + public byte[] Key { get; private set; } + + public byte[] IV => DESKey.DEFAULT_NAOMI_IV; + + public ICryptoTransform DecryptionCryptoTransform { get; private set; } + + public ICryptoTransform EncryptionCryptoTransform { get; private set; } + + private DESKey( + byte[] Key, + ICryptoTransform encryptionCryptoTransform, + ICryptoTransform decryptionCryptoTransform) + { + this.Key = Key; + this.EncryptionCryptoTransform = encryptionCryptoTransform; + this.DecryptionCryptoTransform = decryptionCryptoTransform; + } + + public string KeyString => string.Format("{7:X}{6:X}{5:X}{4:X}{3:X}{2:X}{1:X}{0:X}", (object) this.Key[0], (object) this.Key[1], (object) this.Key[2], (object) this.Key[3], (object) this.Key[4], (object) this.Key[5], (object) this.Key[6], (object) this.Key[7]); + + public override string ToString() => string.Format("DESKey: 0x{0}", (object) this.KeyString); + + public static DESKey Parse(string key) + { + byte[] numArray = new byte[key.Length / 2]; + for (int index = 0; index < numArray.Length; ++index) + { + numArray[index] = (byte) ((key[2 * index] > 'F' ? (int) key[2 * index] - 87 : (key[2 * index] > '9' ? (int) key[2 * index] - 55 : (int) key[2 * index] - 48)) << 4); + numArray[index] |= key[2 * index + 1] > 'F' ? (byte) ((int) key[2 * index + 1] - 87) : (key[2 * index + 1] > '9' ? (byte) ((int) key[2 * index + 1] - 55) : (byte) ((int) key[2 * index + 1] - 48)); + } + if (BitConverter.IsLittleEndian) + Array.Reverse((Array) numArray); + DES des = (DES) new DESCryptoServiceProvider(); + des.KeySize = 64; + des.Padding = PaddingMode.None; + des.Mode = CipherMode.ECB; + ICryptoTransform encryptor = des.CreateEncryptor(numArray, DESKey.DEFAULT_NAOMI_IV); + ICryptoTransform decryptor = des.CreateDecryptor(numArray, DESKey.DEFAULT_NAOMI_IV); + return new DESKey(numArray, encryptor, decryptor); + } + + public static bool TryParse(string key) + { + if (string.IsNullOrEmpty(key)) + return false; + string str = key.Trim(); + if (!DESKey.VALID_KEY_STRING.Match(str).Success) + return false; + try + { + DESKey.Parse(str); + return true; + } + catch (CryptographicException ex) + { + logger.Error(ex); + return false; + } + } + } +} diff --git a/SEGATools/Encrypt/DesEncryptDecryptTool.cs b/SEGATools/Encrypt/DesEncryptDecryptTool.cs new file mode 100644 index 0000000..7a6a64e --- /dev/null +++ b/SEGATools/Encrypt/DesEncryptDecryptTool.cs @@ -0,0 +1,133 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Encrypt.DesEncryptDecryptTool +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.UserProcess; +using SEGATools.VirtualFile; +using System; +using System.ComponentModel; +using System.IO; +using System.Security.Cryptography; + +namespace SEGATools.Encrypt +{ + public class DesEncryptDecryptTool : UserProcessBase + { + private const int BUFFER_SIZE = 65536; + + public event AsyncOperationProgressChangedEventHandler DecryptionProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler DecryptionCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public void EncryptAsync( + IVirtualFile inputFile, + IVirtualFile outputFile, + DESKey Key, + object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new DesEncryptDecryptTool.WorkerEventHandler(this.EncryptOrDecryptWorker).BeginInvoke(inputFile, outputFile, Key.EncryptionCryptoTransform, asyncOperation, (AsyncCallback) null, (object) null); + } + + public void DecryptAsync( + IVirtualFile inputFile, + IVirtualFile outputFile, + DESKey Key, + object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new DesEncryptDecryptTool.WorkerEventHandler(this.EncryptOrDecryptWorker).BeginInvoke(inputFile, outputFile, Key.DecryptionCryptoTransform, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void EncryptOrDecryptWorker( + IVirtualFile inputFile, + IVirtualFile outputFile, + ICryptoTransform CryptoTransform, + AsyncOperation asyncOp) + { + byte[] numArray = new byte[65536]; + Exception exception = (Exception) null; + try + { + using (System.IO.Stream fileInputStream = inputFile.FileInputStream) + { + using (System.IO.Stream fileOutputStream = outputFile.FileOutputStream) + { + fileInputStream.Seek(0L, SeekOrigin.Begin); + while (fileInputStream.Position < fileInputStream.Length) + { + if (!this.TaskCanceled(asyncOp)) + { + using (MemoryStream memoryStream = new MemoryStream(numArray)) + { + using (CryptoStream CryptoStream = new CryptoStream((System.IO.Stream) memoryStream, CryptoTransform, CryptoStreamMode.Write)) + this.EncryptOrDecryptBuffer(numArray, CryptoStream, fileInputStream, fileOutputStream); + } + int num = (int) ((double) fileInputStream.Position / (double) fileInputStream.Length * 100.0); + this.ReportProgress(new UserProcessProgressChangedEventArgs(inputFile.OriginalFileName, outputFile.OriginalFileName, num, num, asyncOp.UserSuppliedState), asyncOp); + } + else + break; + } + } + } + } + catch (Exception ex) + { + exception = ex; + } + if (!this.TaskCanceled(asyncOp)) + { + if (exception == null) + goto label_27; + } + try + { + File.Delete(outputFile.OriginalFileName); + } + catch (Exception ex) + { + UserProcessBase.logger.ErrorFormat("Unable to delete the file {0}: {1}", (object) outputFile.OriginalFileName, (object) ex.Message); + } +label_27: + this.ReportCompletion(outputFile.OriginalFileName, exception, asyncOp); + } + + private void EncryptOrDecryptBuffer( + byte[] Buffer, + CryptoStream CryptoStream, + System.IO.Stream InputStream, + System.IO.Stream OutputStream) + { + int num1 = 0; + int num2 = Buffer.Length / 8; + InputStream.Read(Buffer, 0, Buffer.Length); + while (num1 < num2) + { + int num3 = num1++ * 8; + if (BitConverter.IsLittleEndian) + Array.Reverse((Array) Buffer, num3, 8); + CryptoStream.Write(Buffer, num3, 8); + if (BitConverter.IsLittleEndian) + Array.Reverse((Array) Buffer, num3, 8); + } + OutputStream.Write(Buffer, 0, Buffer.Length); + } + + private delegate void WorkerEventHandler( + IVirtualFile inputFile, + IVirtualFile outputFile, + ICryptoTransform CryptoTransform, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/FileFormat/AbstractImageFileFormat.cs b/SEGATools/FileFormat/AbstractImageFileFormat.cs new file mode 100644 index 0000000..3ecb96f --- /dev/null +++ b/SEGATools/FileFormat/AbstractImageFileFormat.cs @@ -0,0 +1,33 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.FileFormat.AbstractImageFileFormat +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.DiscFileSystem; +using System.Collections.Generic; +using System.Linq; + +namespace SEGATools.FileFormat +{ + public abstract class AbstractImageFileFormat : IImageFileFormat + { + public abstract string[] FileExtentions { get; } + + public abstract string[] FileExtentionDescriptions { get; } + + public abstract IDiscFileSystemConverter ImageFileConverter { get; } + + public string PluginAssemblyFileName { get; set; } + + public override bool Equals(object obj) + { + if (obj == null || !typeof (IImageFileFormat).IsAssignableFrom(obj.GetType())) + return false; + IImageFileFormat imageFileFormat = (IImageFileFormat) obj; + return ((IEnumerable) this.FileExtentions).SequenceEqual((IEnumerable) imageFileFormat.FileExtentions) && ((IEnumerable) this.FileExtentionDescriptions).SequenceEqual((IEnumerable) imageFileFormat.FileExtentionDescriptions); + } + + public override int GetHashCode() => 1 + 17 * this.FileExtentions.GetHashCode() + 31 * this.FileExtentionDescriptions.GetHashCode(); + } +} diff --git a/SEGATools/FileFormat/IImageFileFormat.cs b/SEGATools/FileFormat/IImageFileFormat.cs new file mode 100644 index 0000000..12d7ee9 --- /dev/null +++ b/SEGATools/FileFormat/IImageFileFormat.cs @@ -0,0 +1,21 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.FileFormat.IImageFileFormat +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.DiscFileSystem; + +namespace SEGATools.FileFormat +{ + public interface IImageFileFormat + { + string[] FileExtentions { get; } + + string[] FileExtentionDescriptions { get; } + + IDiscFileSystemConverter ImageFileConverter { get; } + + string PluginAssemblyFileName { get; set; } + } +} diff --git a/SEGATools/Formater/SizeFormater.cs b/SEGATools/Formater/SizeFormater.cs new file mode 100644 index 0000000..0052bc3 --- /dev/null +++ b/SEGATools/Formater/SizeFormater.cs @@ -0,0 +1,27 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Formater.SizeFormater +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Formater +{ + public static class SizeFormater + { + public static string ToHumanReadableSize(long Size) + { + double num = Convert.ToDouble(Size); + if (num >= Math.Pow(1024.0, 4.0)) + return Math.Round(num / Math.Pow(1024.0, 4.0), 2).ToString() + " TB"; + if (num >= Math.Pow(1024.0, 3.0)) + return Math.Round(num / Math.Pow(1024.0, 3.0), 2).ToString() + " GB"; + if (num >= Math.Pow(1024.0, 2.0)) + return Math.Round(num / Math.Pow(1024.0, 2.0), 2).ToString() + " MB"; + if (num >= 1024.0) + return Math.Round(num / 1024.0, 2).ToString() + " KB"; + return num == 0.0 ? num.ToString() + " Byte" : num.ToString() + " Bytes"; + } + } +} diff --git a/SEGATools/GDEmu/DiscTrackCopyInfo.cs b/SEGATools/GDEmu/DiscTrackCopyInfo.cs new file mode 100644 index 0000000..6a0f540 --- /dev/null +++ b/SEGATools/GDEmu/DiscTrackCopyInfo.cs @@ -0,0 +1,55 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.GDEmu.DiscTrackCopyInfo +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using SEGATools.Binary; +using SEGATools.DiscFileSystem; +using System.Collections.Generic; +using System.Linq; + +namespace SEGATools.GDEmu +{ + internal class DiscTrackCopyInfo + { + private HashSet patchesApplied; + + public IDiscTrack SourceTrack { get; private set; } + + public IDiscTrack DestinationTrack { get; private set; } + + public int[] ModifiedSectors + { + get + { + HashSet source = new HashSet(); + foreach (BinaryPatch binaryPatch in this.patchesApplied) + { + int num1 = (int) binaryPatch.Offset / DiscSectorCommon.LogicalSectorSize; + int num2 = (int) (binaryPatch.Offset + (long) binaryPatch.Data.Length) / DiscSectorCommon.LogicalSectorSize; + for (int index = num1; index <= num2; ++index) + source.Add(index); + } + return source.ToArray(); + } + } + + public static DiscTrackCopyInfo CreateFrom( + IDiscTrack source, + string newFileName) + { + return new DiscTrackCopyInfo(source, DiscTrack.CreateCopyFrom(source, newFileName)); + } + + private DiscTrackCopyInfo(IDiscTrack source, IDiscTrack destination) + { + this.SourceTrack = source; + this.DestinationTrack = destination; + this.patchesApplied = new HashSet(); + } + + public void AddPatches(params BinaryPatch[] patches) => this.patchesApplied.UnionWith((IEnumerable) patches); + } +} diff --git a/SEGATools/GDEmu/GDEmuConverter.cs b/SEGATools/GDEmu/GDEmuConverter.cs new file mode 100644 index 0000000..fb4e550 --- /dev/null +++ b/SEGATools/GDEmu/GDEmuConverter.cs @@ -0,0 +1,328 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.GDEmu.GDEmuConverter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using ImageReader.Stream; +using SEGATools.Binary; +using SEGATools.Disc; +using SEGATools.DiscFileSystem; +using SEGATools.UserProcess; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Linq; + +namespace SEGATools.GDEmu +{ + public class GDEmuConverter : UserProcessBase + { + private static readonly int OutputFileStreamBuffer = 524288; + private static readonly string FileConflictQuestionTitle = "GDEmuExporterFileConflictQuestionTitle"; + private static readonly string FileConflictQuestionContent = "GDEmuExporterFileConflictQuestionContent"; + private static readonly string BinaryPatcherHint = "GDEmuExporterBinaryPatcherHint"; + private static readonly string DiscSectorEncoderHint = "GDEmuExporterDiscSectorEncoderHint"; + private BinaryPatcher binaryPatcher = new BinaryPatcher(); + private DiscSectorEncoder discSectorEncoder = new DiscSectorEncoder(); + + public event AsyncOperationProgressChangedEventHandler ConversionProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler ConversionCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public GDEmuConverter() + { + } + + public GDEmuConverter(IContainer container) + : base(container) + { + } + + public void ConvertAsync( + IDiscFileSystem GDIImageFile, + GDEmuExportOptions ExportOptions, + object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new GDEmuConverter.FileConverterWorkerEventHandler(this.FileConverterWorker).BeginInvoke(GDIImageFile, ExportOptions, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void FileConverterWorker( + IDiscFileSystem GDIImageFile, + GDEmuExportOptions ExportOption, + AsyncOperation asyncOp) + { + Exception exception = (Exception) null; + HashSet trackOutputFiles = this.GetTrackOutputFiles(GDIImageFile, ExportOption); + List stringList = new List(); + this.CheckForFileConflict(ExportOption, trackOutputFiles, asyncOp); + if (this.TaskCanceled(asyncOp)) + { + this.DoExtractionCleanupIfNeeded(stringList.ToArray(), exception, asyncOp); + this.ReportCompletion(ExportOption.OutputPath, exception, asyncOp); + } + else + { + long requiredSpaceInBytes = this.ComputeRequiredSpaceInBytes(trackOutputFiles); + long ofBytesToExtract = this.ComputeNumberOfBytesToExtract(trackOutputFiles); + long totalNumberOfBytesRemaining = ofBytesToExtract; + try + { + this.CheckForEnoughFreeDiscSpace(requiredSpaceInBytes, ExportOption.OutputPath); + GDICreator.CreateGDIFile(GDIImageFile.AllTracks, ExportOption.GetOutputGDIFilePath()); + stringList.Add(ExportOption.GetOutputGDIFilePath()); + foreach (DiscTrackCopyInfo track in trackOutputFiles) + { + if (!this.TaskCanceled(asyncOp)) + { + stringList.Add(track.DestinationTrack.FileName); + totalNumberOfBytesRemaining = this.CopyTrack(track, ofBytesToExtract, totalNumberOfBytesRemaining, asyncOp); + } + else + break; + } + if (!this.TaskCanceled(asyncOp)) + this.ApplyExportPatches(GDIImageFile, ExportOption, trackOutputFiles, asyncOp); + } + catch (Exception ex) + { + exception = ex; + UserProcessBase.logger.ErrorFormat("Unable to copy the track: {0}", (object) exception); + } + this.DoExtractionCleanupIfNeeded(stringList.ToArray(), exception, asyncOp); + this.ReportCompletion(ExportOption.OutputPath, exception, asyncOp); + } + } + + private long ComputeNumberOfBytesToExtract(HashSet tracks) + { + long num = 0; + foreach (DiscTrackCopyInfo track in tracks) + num += track.SourceTrack.Length; + return num; + } + + private long ComputeRequiredSpaceInBytes(HashSet tracks) + { + long num = 0; + foreach (DiscTrackCopyInfo track in tracks) + { + FileInfo fileInfo = new FileInfo(track.DestinationTrack.FileName); + num += track.SourceTrack.Length; + if (fileInfo.Exists) + num -= fileInfo.Length; + } + return num; + } + + private void CheckForEnoughFreeDiscSpace(long requiredSpaceInBytes, string outputPath) + { + if (requiredSpaceInBytes > new DriveInfo(outputPath.Substring(0, 3)).AvailableFreeSpace) + { + UserProcessBase.logger.ErrorFormat("Extraction requires {0} bytes of free disc space in drive {1}", (object) requiredSpaceInBytes, (object) outputPath.Substring(0, 3)); + throw new IOException("Not enough free disc space!"); + } + } + + private void CheckForFileConflict( + GDEmuExportOptions exportOptions, + HashSet inputFiles, + AsyncOperation asyncOp) + { + List stringList = new List(); + if (File.Exists(exportOptions.GetOutputGDIFilePath())) + stringList.Add(exportOptions.GetOutputGDIFilePath()); + foreach (DiscTrackCopyInfo inputFile in inputFiles) + { + if (File.Exists(inputFile.DestinationTrack.FileName)) + stringList.Add(inputFile.DestinationTrack.FileName); + } + if (stringList.Count == 0) + return; + this.AskForUserConsent(GDEmuConverter.GetNotifyFileConflictEventArgs(stringList.ToArray(), asyncOp), asyncOp); + } + + private long CopyTrack( + DiscTrackCopyInfo track, + long totalNumberOfBytesToExtract, + long totalNumberOfBytesRemaining, + AsyncOperation asyncOp) + { + using (System.IO.Stream fileInputStream = track.SourceTrack.FileInputStream) + { + using (System.IO.Stream fileOutputStream = track.DestinationTrack.FileOutputStream) + { + long length = fileInputStream.Length; + byte[] buffer = new byte[GDEmuConverter.OutputFileStreamBuffer]; + while (length > 0L) + { + if (!this.TaskCanceled(asyncOp)) + { + int count = fileInputStream.Read(buffer, 0, buffer.Length); + length -= (long) count; + totalNumberOfBytesRemaining -= (long) count; + fileOutputStream.Write(buffer, 0, count); + this.ReportProgress(GDEmuConverter.CreateProgressChangedEventArgs(track.SourceTrack.FileName, track.DestinationTrack.FileName, fileInputStream.Length, length, totalNumberOfBytesToExtract, totalNumberOfBytesRemaining, asyncOp), asyncOp); + } + else + break; + } + } + } + return totalNumberOfBytesRemaining; + } + + private void ApplyExportPatches( + IDiscFileSystem GDIImageFile, + GDEmuExportOptions ExportOption, + HashSet OutputTrackFiles, + AsyncOperation asyncOp) + { + if (!ExportOption.ForceVGA && !ExportOption.RegionFree) + { + UserProcessBase.logger.Info((object) "No patch to apply"); + } + else + { + this.UpdateViewForBinaryPatcherStep(asyncOp); + if (ExportOption.ForceVGA) + this.ApplyVGAPatch(OutputTrackFiles, asyncOp); + if (ExportOption.RegionFree) + this.ApplyRegionFreePatch(OutputTrackFiles, asyncOp); + if (this.TaskCanceled(asyncOp)) + return; + this.CorrectModifiedSectors(OutputTrackFiles, asyncOp); + } + } + + private void CorrectModifiedSectors(HashSet tracks, AsyncOperation asyncOp) + { + this.UpdateViewForDiscSectorEncoderStep(asyncOp); + foreach (DiscTrackCopyInfo track in tracks.Where((Func) (track => track.SourceTrack.TrackData == TrackModeType.Data && track.SourceTrack.TrackSector.GetType() == typeof (CDROMMode1RawSector)))) + { + this.ReportPatchOrErrorDataEncoderProgress(track, asyncOp); + if (this.TaskCanceled(asyncOp)) + break; + using (System.IO.Stream fileOutputStream = track.DestinationTrack.FileOutputStream) + this.discSectorEncoder.EncodeMode1Sectors(fileOutputStream, track.ModifiedSectors); + } + } + + private void ApplyPatches(DiscTrackCopyInfo track, BinaryPatch[] patches) + { + using (DiscSectorStream discSectorStream = new DiscSectorStream(track.DestinationTrack.FileOutputStream, track.DestinationTrack.TrackSector)) + this.binaryPatcher.ApplyPatches((System.IO.Stream) discSectorStream, patches); + track.AddPatches(patches); + } + + private void ApplyVGAPatch(HashSet OutputTrackFiles, AsyncOperation asyncOp) + { + DiscTrackCopyInfo track1 = OutputTrackFiles.First((Func) (track => track.SourceTrack.Index == 1)); + UserProcessBase.logger.InfoFormat("Applying VGA flag patches on {0}", (object) track1); + this.ReportPatchOrErrorDataEncoderProgress(track1, asyncOp); + this.ApplyPatches(track1, InitialProgramPatches.VGAFlagPatchesForTrack1); + DiscTrackCopyInfo track2 = OutputTrackFiles.First((Func) (track => track.SourceTrack.Index == 3)); + UserProcessBase.logger.InfoFormat("Applying VGA flag patches on {0}", (object) track2); + this.ReportPatchOrErrorDataEncoderProgress(track2, asyncOp); + this.ApplyPatches(track2, InitialProgramPatches.VGAFlagPatchesForTrack3); + } + + private void ApplyRegionFreePatch( + HashSet OutputTrackFiles, + AsyncOperation asyncOp) + { + DiscTrackCopyInfo track1 = OutputTrackFiles.First((Func) (track => track.SourceTrack.Index == 1)); + UserProcessBase.logger.InfoFormat("Applying region free patches on {0}", (object) track1); + this.ReportPatchOrErrorDataEncoderProgress(track1, asyncOp); + this.ApplyPatches(track1, InitialProgramPatches.RegionFreePatchesForTrack1); + DiscTrackCopyInfo track2 = OutputTrackFiles.First((Func) (track => track.SourceTrack.Index == 3)); + UserProcessBase.logger.InfoFormat("Applying region free patches on {0}", (object) track2); + this.ReportPatchOrErrorDataEncoderProgress(track2, asyncOp); + this.ApplyPatches(track2, InitialProgramPatches.RegionFreePatchesForTrack3); + } + + private HashSet GetTrackOutputFiles( + IDiscFileSystem GDIImageFile, + GDEmuExportOptions ExportOption) + { + HashSet discTrackCopyInfoSet = new HashSet(); + foreach (IDiscTrack allTrack in GDIImageFile.AllTracks) + { + string newFileName = Path.Combine(ExportOption.OutputPath, allTrack.VirtualName); + discTrackCopyInfoSet.Add(DiscTrackCopyInfo.CreateFrom(allTrack, newFileName)); + } + return discTrackCopyInfoSet; + } + + private void DoExtractionCleanupIfNeeded( + string[] fileToDelete, + Exception exception, + AsyncOperation asyncOp) + { + if (!this.TaskCanceled(asyncOp) && exception == null) + return; + foreach (string path in fileToDelete) + { + if (File.Exists(path)) + { + try + { + File.Delete(path); + } + catch (Exception ex) + { + UserProcessBase.logger.ErrorFormat("Unable to delete the file {0}: {1}", (object) path, (object) ex.Message); + } + } + } + } + + private static UserProcessProgressChangedEventArgs CreateProgressChangedEventArgs( + string input, + string output, + long numberOfBytesToExtract, + long remainingBytesToExtract, + long totalNumberOfBytesToExtract, + long totalNumberOfBytesRemaining, + AsyncOperation asyncOp) + { + int progressPercentage = (int) ((double) (numberOfBytesToExtract - remainingBytesToExtract) / (double) numberOfBytesToExtract * 100.0); + int totalProgressPercentage = (int) ((double) (totalNumberOfBytesToExtract - totalNumberOfBytesRemaining) / (double) totalNumberOfBytesToExtract * 100.0); + return new UserProcessProgressChangedEventArgs(input, output, progressPercentage, totalProgressPercentage, asyncOp.UserSuppliedState); + } + + private static UserProcessWaitingForUserConsentEventArgs GetNotifyFileConflictEventArgs( + string[] files, + AsyncOperation asyncOp) + { + return (UserProcessWaitingForUserConsentEventArgs) new UserProcessWaitingForUserConsentFileConflictEventArgs(GDEmuConverter.FileConflictQuestionTitle, GDEmuConverter.FileConflictQuestionContent, files, (object) asyncOp); + } + + private void ReportPatchOrErrorDataEncoderProgress( + DiscTrackCopyInfo track, + AsyncOperation asyncOp) + { + this.ReportProgress(new UserProcessProgressChangedEventArgs(track.SourceTrack.FileName, track.DestinationTrack.FileName, 100, 100, asyncOp.UserSuppliedState), asyncOp); + } + + private void UpdateViewForBinaryPatcherStep(AsyncOperation asyncOp) => this.UpdateUIView(UserProcessUpdateUIViewEventArgs.OneProgressBarWithoutPercentage(GDEmuConverter.BinaryPatcherHint, false), asyncOp); + + private void UpdateViewForDiscSectorEncoderStep(AsyncOperation asyncOp) => this.UpdateUIView(UserProcessUpdateUIViewEventArgs.OneProgressBarWithoutPercentage(GDEmuConverter.DiscSectorEncoderHint, false), asyncOp); + + private delegate void FileConverterWorkerEventHandler( + IDiscFileSystem imageFile, + GDEmuExportOptions ExportOption, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/GDEmu/GDEmuExportOptions.cs b/SEGATools/GDEmu/GDEmuExportOptions.cs new file mode 100644 index 0000000..f393bc4 --- /dev/null +++ b/SEGATools/GDEmu/GDEmuExportOptions.cs @@ -0,0 +1,22 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.GDEmu.GDEmuExportOptions +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System.IO; + +namespace SEGATools.GDEmu +{ + public class GDEmuExportOptions + { + private static readonly string GDEMU_DEFAULT_DISC_IMAGE_FILE_NAME = "disc.gdi"; + public bool RegionFree; + public bool ForceVGA; + public string OutputPath; + + public string GDIFileName => GDEmuExportOptions.GDEMU_DEFAULT_DISC_IMAGE_FILE_NAME; + + public string GetOutputGDIFilePath() => Path.Combine(this.OutputPath, this.GDIFileName); + } +} diff --git a/SEGATools/GDEmu/GDICreator.cs b/SEGATools/GDEmu/GDICreator.cs new file mode 100644 index 0000000..409af5c --- /dev/null +++ b/SEGATools/GDEmu/GDICreator.cs @@ -0,0 +1,31 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.GDEmu.GDICreator +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.DiscFileSystem; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; + +namespace SEGATools.GDEmu +{ + public class GDICreator + { + public static void CreateGDIFile(List Tracks, string OutputGDIFile) + { + List list = Tracks.OrderBy((Func) (track => track.LogicalBlockAddress)).ToList(); + using (StreamWriter streamWriter = new StreamWriter(OutputGDIFile)) + { + streamWriter.WriteLine(list.Count); + for (int index = 0; index < list.Count; ++index) + { + IDiscTrack discTrack = list[index]; + streamWriter.WriteLine("{0} {1} {2} {3} {4} {5}", (object) (index + 1), (object) discTrack.LogicalBlockAddress, (object) (short) discTrack.TrackData, (object) discTrack.TrackSector.Size, (object) discTrack.VirtualName, (object) discTrack.Offset); + } + } + } + } +} diff --git a/SEGATools/Graphics/MRImage.cs b/SEGATools/Graphics/MRImage.cs new file mode 100644 index 0000000..0b66e29 --- /dev/null +++ b/SEGATools/Graphics/MRImage.cs @@ -0,0 +1,74 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImage +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; + +namespace SEGATools.Graphics +{ + public class MRImage + { + private MRImageHeader header; + private Bitmap imageBitmap; + + public Size ImageSize => new Size(this.header.Width, this.header.Height); + + public int UncompressedSize => this.Pixels.Length; + + public int FileSize => this.header.Size; + + public int CompressedSize => this.header.Size - this.header.Offset; + + public float CompressionRatio => (float) this.UncompressedSize / (float) this.CompressedSize; + + public int Offset { get; private set; } + + public byte[] Pixels { get; private set; } + + public Color[] ColorPalette { get; private set; } + + private byte[] RawData { get; set; } + + public System.IO.Stream FileStream => (System.IO.Stream) new MemoryStream(this.RawData, 0, this.RawData.Length, false); + + internal MRImage( + MRImageHeader header, + Color[] colorPalette, + byte[] pixels, + int offset, + byte[] rawData) + { + this.header = header; + this.ColorPalette = colorPalette; + this.Pixels = pixels; + this.Offset = offset; + this.RawData = rawData; + this.ToBitmap(); + } + + private byte GetPixel(int x, int y) => this.Pixels[y * this.header.Width + x]; + + private Color GetColorForPixel(int x, int y) => this.ColorPalette[(int) this.GetPixel(x, y)]; + + public Bitmap ToBitmap() + { + if (this.imageBitmap != null) + return this.imageBitmap; + Bitmap bitmap = new Bitmap(this.ImageSize.Width, this.ImageSize.Height, PixelFormat.Format24bppRgb); + for (int y = 0; y < bitmap.Height; ++y) + { + for (int x = 0; x < bitmap.Width; ++x) + { + Color colorForPixel = this.GetColorForPixel(x, y); + bitmap.SetPixel(x, y, colorForPixel); + } + } + this.imageBitmap = bitmap; + return bitmap; + } + } +} diff --git a/SEGATools/Graphics/MRImageColor.cs b/SEGATools/Graphics/MRImageColor.cs new file mode 100644 index 0000000..a236873 --- /dev/null +++ b/SEGATools/Graphics/MRImageColor.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageColor +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System.Runtime.InteropServices; + +namespace SEGATools.Graphics +{ + [StructLayout(LayoutKind.Explicit, Size = 4, Pack = 1)] + internal struct MRImageColor + { + [FieldOffset(0)] + internal byte Blue; + [FieldOffset(1)] + internal byte Green; + [FieldOffset(2)] + internal byte Red; + [FieldOffset(3)] + internal byte Alpha; + } +} diff --git a/SEGATools/Graphics/MRImageConverter.cs b/SEGATools/Graphics/MRImageConverter.cs new file mode 100644 index 0000000..39c9d48 --- /dev/null +++ b/SEGATools/Graphics/MRImageConverter.cs @@ -0,0 +1,117 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageConverter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Text; + +namespace SEGATools.Graphics +{ + public class MRImageConverter + { + private static readonly string MR_ID = "MR"; + private static readonly int MR_HEADER_OFFSET = 2; + private static readonly int MR_COLOR_PALETTE_OFFSET = MRImageConverter.MR_HEADER_OFFSET + 28; + private static readonly int MR_HEADER_MINIMUM_SIZE = 30; + private static readonly int MR_COLOR_SIZE = 4; + + public static MRImage ToMRImage(byte[] buffer, int startIndex) + { + if (startIndex < 0 || buffer.Length - startIndex < MRImageConverter.MR_HEADER_MINIMUM_SIZE) + throw new ArgumentOutOfRangeException(); + string str = Encoding.ASCII.GetString(buffer, startIndex, MRImageConverter.MR_ID.Length); + if (!MRImageConverter.MR_ID.Equals(str)) + throw new MRImageIdentifierMissingException("Wrong MR file identifier"); + MRImageHeader structure1 = (MRImageHeader) Marshal.PtrToStructure(Marshal.UnsafeAddrOfPinnedArrayElement((Array) buffer, startIndex + MRImageConverter.MR_HEADER_OFFSET), typeof (MRImageHeader)); + if (structure1.NumberOfColors <= 0U || (long) (buffer.Length - startIndex - MRImageConverter.MR_COLOR_PALETTE_OFFSET) < (long) structure1.NumberOfColors * (long) MRImageConverter.MR_COLOR_SIZE) + throw new MRImageDecompressionException("Color palette too big"); + Color[] colorArray = new Color[(int) structure1.NumberOfColors]; + for (int index1 = 0; index1 < colorArray.Length; ++index1) + { + int index2 = startIndex + MRImageConverter.MR_COLOR_PALETTE_OFFSET + index1 * MRImageConverter.MR_COLOR_SIZE; + MRImageColor structure2 = (MRImageColor) Marshal.PtrToStructure(Marshal.UnsafeAddrOfPinnedArrayElement((Array) buffer, index2), typeof (MRImageColor)); + colorArray[index1] = Color.FromArgb((int) structure2.Alpha, (int) structure2.Red, (int) structure2.Green, (int) structure2.Blue); + } + int length = structure1.Size - structure1.Offset; + int startIndex1 = startIndex + structure1.Offset; + try + { + byte[] rawData = new byte[structure1.Size]; + Buffer.BlockCopy((Array) buffer, startIndex, (Array) rawData, 0, rawData.Length); + byte[] pixels = MRImageConverter.DecompressPixelData(structure1, colorArray, buffer, startIndex1, length); + return new MRImage(structure1, colorArray, pixels, startIndex, rawData); + } + catch (MRImageUnknownColorException ex) + { + throw new MRImageDecompressionException("Unable to decompress the image", (Exception) ex); + } + catch (Exception ex) + { + throw new MRImageDecompressionException("Unable to decompress the image", ex); + } + } + + private static byte[] DecompressPixelData( + MRImageHeader mrHeader, + Color[] palette, + byte[] buffer, + int startIndex, + int length) + { + int length1 = palette.Length; + int index1 = 0; + byte[] buffer1 = new byte[mrHeader.Width * mrHeader.Height]; + for (int index2 = startIndex; index2 < startIndex + length; ++index2) + { + if (buffer[index2] < (byte) 128) + { + byte colorNumber = buffer[index2]; + index1 = MRImageConverter.decodePixels(buffer1, index1, colorNumber, length1, 1); + } + else if (buffer[index2] == (byte) 129) + { + int numberOfPixels = (int) buffer[index2 + 1]; + byte colorNumber = buffer[index2 + 2]; + index1 = MRImageConverter.decodePixels(buffer1, index1, colorNumber, length1, numberOfPixels); + index2 += 2; + } + else if (buffer[index2] == (byte) 130 && buffer[index2 + 1] >= (byte) 128) + { + int numberOfPixels = (int) buffer[index2 + 1] - 128 + 256; + byte colorNumber = buffer[index2 + 2]; + index1 = MRImageConverter.decodePixels(buffer1, index1, colorNumber, length1, numberOfPixels); + index2 += 2; + } + else + { + int numberOfPixels = (int) buffer[index2] - 128; + byte colorNumber = buffer[index2 + 1]; + index1 = MRImageConverter.decodePixels(buffer1, index1, colorNumber, length1, numberOfPixels); + ++index2; + } + } + return buffer1; + } + + private static int decodePixels( + byte[] buffer, + int index, + byte colorNumber, + int numberOfColors, + int numberOfPixels) + { + for (int index1 = 0; index1 < numberOfPixels && index < buffer.Length; ++index1) + { + if ((int) colorNumber >= numberOfColors) + colorNumber = colorNumber == (byte) 154 ? (byte) 0 : throw MRImageUnknownColorException.anUnknownColor(colorNumber); + buffer[index] = colorNumber; + ++index; + } + return index; + } + } +} diff --git a/SEGATools/Graphics/MRImageDecompressionException.cs b/SEGATools/Graphics/MRImageDecompressionException.cs new file mode 100644 index 0000000..5060280 --- /dev/null +++ b/SEGATools/Graphics/MRImageDecompressionException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageDecompressionException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Graphics +{ + internal class MRImageDecompressionException : MRImageReadingException + { + public MRImageDecompressionException(string message) + : base(string.Format("MR Image Decompression Error: {0}", (object) message)) + { + } + + public MRImageDecompressionException(string message, Exception innerException) + : base(string.Format("MR Image Decompression Error: {0}", (object) message), innerException) + { + } + } +} diff --git a/SEGATools/Graphics/MRImageExporter.cs b/SEGATools/Graphics/MRImageExporter.cs new file mode 100644 index 0000000..93ae7ec --- /dev/null +++ b/SEGATools/Graphics/MRImageExporter.cs @@ -0,0 +1,99 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageExporter +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Collections.Generic; +using System.Drawing.Imaging; +using System.IO; + +namespace SEGATools.Graphics +{ + public class MRImageExporter + { + private static List supportedMRImageFormats; + + public MRImageExporter() + { + if (MRImageExporter.supportedMRImageFormats != null) + return; + MRImageExporter.supportedMRImageFormats = new List(); + MRImageExporter.supportedMRImageFormats.Add(new MRImageExporter.MRImageFormat(".mr", "MR image")); + MRImageExporter.supportedMRImageFormats.Add(new MRImageExporter.MRImageFormat(".bmp", "Bitmap image", ImageFormat.Bmp)); + MRImageExporter.supportedMRImageFormats.Add(new MRImageExporter.MRImageFormat(".png", "PNG image", ImageFormat.Png)); + MRImageExporter.supportedMRImageFormats.Add(new MRImageExporter.MRImageFormat(".jpeg", "JPEG image", ImageFormat.Jpeg)); + MRImageExporter.supportedMRImageFormats.Add(new MRImageExporter.MRImageFormat(".gif", "GIF image", ImageFormat.Gif)); + } + + public string CreateSaveFileDialogFilter() + { + string str = string.Empty; + foreach (MRImageExporter.MRImageFormat supportedMrImageFormat in MRImageExporter.supportedMRImageFormats) + str = str + "|" + supportedMrImageFormat.Description + "|*" + supportedMrImageFormat.Extension; + if (!string.IsNullOrEmpty(str)) + str = str.Substring(1); + return str; + } + + public MRImageExporter.MRImageFormat GetMRImageFormatFromFilterIndex(int index) => index < 1 || index > MRImageExporter.supportedMRImageFormats.Count ? (MRImageExporter.MRImageFormat) null : MRImageExporter.supportedMRImageFormats[index - 1]; + + public MRImageExporter.MRImageFormat FindMRImageFileFormatForFileExtension( + string fileExtension) + { + return string.IsNullOrEmpty(fileExtension) ? (MRImageExporter.MRImageFormat) null : MRImageExporter.supportedMRImageFormats.Find((Predicate) (mrImageFileFormat => mrImageFileFormat.Extension.Equals(fileExtension, StringComparison.InvariantCultureIgnoreCase))); + } + + public bool IsImageExtensionSupported(string fileExtension) => this.FindMRImageFileFormatForFileExtension(fileExtension) != null; + + public void Save( + MRImage mrImage, + string outputFileName, + MRImageExporter.MRImageFormat imageFormat) + { + if (imageFormat == null) + throw new ArgumentException(nameof (imageFormat)); + if (imageFormat.IsRawMR) + { + using (System.IO.Stream fileStream1 = mrImage.FileStream) + { + byte[] buffer = new byte[fileStream1.Length]; + using (FileStream fileStream2 = new FileStream(outputFileName, FileMode.OpenOrCreate)) + { + fileStream1.Read(buffer, 0, buffer.Length); + fileStream2.Write(buffer, 0, buffer.Length); + } + } + } + else + mrImage.ToBitmap().Save(outputFileName, imageFormat.Format); + } + + public class MRImageFormat + { + public bool IsRawMR { get; set; } + + public string Extension { get; set; } + + public string Description { get; set; } + + public ImageFormat Format { get; set; } + + public MRImageFormat(string extension, string description, ImageFormat imageFormat) + { + this.Extension = extension; + this.Description = description; + this.Format = imageFormat; + this.IsRawMR = false; + } + + public MRImageFormat(string extension, string description) + { + this.Extension = extension; + this.Description = description; + this.IsRawMR = true; + } + } + } +} diff --git a/SEGATools/Graphics/MRImageHeader.cs b/SEGATools/Graphics/MRImageHeader.cs new file mode 100644 index 0000000..4531782 --- /dev/null +++ b/SEGATools/Graphics/MRImageHeader.cs @@ -0,0 +1,25 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageHeader +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System.Runtime.InteropServices; + +namespace SEGATools.Graphics +{ + [StructLayout(LayoutKind.Explicit, Size = 28, Pack = 1)] + internal struct MRImageHeader + { + [FieldOffset(0)] + internal int Size; + [FieldOffset(8)] + internal int Offset; + [FieldOffset(12)] + internal int Width; + [FieldOffset(16)] + internal int Height; + [FieldOffset(24)] + internal uint NumberOfColors; + } +} diff --git a/SEGATools/Graphics/MRImageIdentifierMissingException.cs b/SEGATools/Graphics/MRImageIdentifierMissingException.cs new file mode 100644 index 0000000..2a7969f --- /dev/null +++ b/SEGATools/Graphics/MRImageIdentifierMissingException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageIdentifierMissingException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Graphics +{ + internal class MRImageIdentifierMissingException : MRImageReadingException + { + public MRImageIdentifierMissingException(string message) + : base(string.Format("MR Image Identifier Missing Error: {0}", (object) message)) + { + } + + public MRImageIdentifierMissingException(string message, Exception innerException) + : base(string.Format("MR Image Identifier Missing Error: {0}", (object) message), innerException) + { + } + } +} diff --git a/SEGATools/Graphics/MRImageReadingException.cs b/SEGATools/Graphics/MRImageReadingException.cs new file mode 100644 index 0000000..7fb5327 --- /dev/null +++ b/SEGATools/Graphics/MRImageReadingException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageReadingException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Graphics +{ + internal class MRImageReadingException : Exception + { + public MRImageReadingException(string message) + : base(message) + { + } + + public MRImageReadingException(string message, Exception innerException) + : base(message, innerException) + { + } + } +} diff --git a/SEGATools/Graphics/MRImageUnknownColorException.cs b/SEGATools/Graphics/MRImageUnknownColorException.cs new file mode 100644 index 0000000..3268808 --- /dev/null +++ b/SEGATools/Graphics/MRImageUnknownColorException.cs @@ -0,0 +1,22 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageUnknownColorException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Graphics +{ + internal class MRImageUnknownColorException : MRImageReadingException + { + public MRImageUnknownColorException(string message) + : base(string.Format("MR Image Unknown Color Error: {0}", (object) message)) + { + } + + public static MRImageUnknownColorException anUnknownColor( + byte colorNumber) + { + return new MRImageUnknownColorException(string.Format("color number {0} does not exist", (object) colorNumber)); + } + } +} diff --git a/SEGATools/Graphics/MRImageViewer.cs b/SEGATools/Graphics/MRImageViewer.cs new file mode 100644 index 0000000..14a4ef5 --- /dev/null +++ b/SEGATools/Graphics/MRImageViewer.cs @@ -0,0 +1,284 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Graphics.MRImageViewer +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.Formater; +using SEGATools.Properties; +using System; +using System.ComponentModel; +using System.Drawing; +using System.IO; +using System.Windows.Forms; + +namespace SEGATools.Graphics +{ + public class MRImageViewer : UserControl + { + private MRImageExporter mrImageExporter; + private string basePath; + private IContainer components; + private PictureBox pictureBox; + private GroupBox gbMRImageInfo; + private Label lbColors; + private Label lbImageSize; + private Label lbNumberOfColorsValue; + private Label lbImageSizeValue; + private Label lbFileSizeValue; + private Label lbFileSize; + private Label lbCompressedSizeValue; + private Label lbSize; + private Label lbUncompressedSizeValue; + private Label lbUncompressedSize; + private Label lbCompressionRatioValue; + private Label lbCompressionRatio; + private Button btExportMRImage; + private SaveFileDialog saveFileDialog; + private Label lbNoMrImage; + + public MRImage MRImage { get; private set; } + + public string BasePath + { + get => this.basePath; + set + { + if (string.IsNullOrEmpty(value)) + return; + this.basePath = value; + this.saveFileDialog.InitialDirectory = this.basePath; + } + } + + private bool DisplayNoImageMessage => true; + + public MRImageViewer() + { + this.InitializeComponent(); + this.pictureBox.Resize += new EventHandler(this.pictureBox_Resize); + this.mrImageExporter = new MRImageExporter(); + this.saveFileDialog.Title = Resources.SfdMRImageTitle; + this.saveFileDialog.Filter = this.mrImageExporter.CreateSaveFileDialogFilter(); + this.lbNoMrImage.Text = Resources.MRImageNoImageMessage; + this.CenterImageInDisplayArea((Control) this.lbNoMrImage); + this.UpdateViewAndDisplayNoImage(); + } + + public void LoadMRImage(MRImage mrImage, string imageName) + { + this.MRImage = mrImage; + this.saveFileDialog.FileName = imageName; + this.SetImageProperties(this.MRImage); + this.UpdateViewAndDisplayImages(); + } + + private void SetImageProperties(MRImage mrImage) + { + this.lbImageSizeValue.Text = string.Format("{0}x{1}", (object) mrImage.ImageSize.Width, (object) mrImage.ImageSize.Height); + this.lbNumberOfColorsValue.Text = string.Format("{0}", (object) mrImage.ColorPalette.Length); + this.lbFileSizeValue.Text = string.Format("{0} ({1} bytes)", (object) SizeFormater.ToHumanReadableSize((long) mrImage.FileSize), (object) mrImage.FileSize); + this.lbCompressedSizeValue.Text = string.Format("{0} bytes", (object) mrImage.CompressedSize); + this.lbUncompressedSizeValue.Text = string.Format("{0} bytes", (object) mrImage.UncompressedSize); + this.lbCompressionRatioValue.Text = string.Format("{0:0.0}:1", (object) mrImage.CompressionRatio); + this.pictureBox.Image = (Image) mrImage.ToBitmap(); + } + + private void CenterImageInDisplayArea(Control control) + { + int x = (this.Width - control.Size.Width) / 2; + int y = (this.gbMRImageInfo.Location.Y - control.Size.Height) / 2; + control.Location = new Point(x, y); + } + + private void OpenFileDialogAndExportImage(Image image) + { + if (this.saveFileDialog.ShowDialog((IWin32Window) this) != DialogResult.OK) + return; + this.mrImageExporter.Save(this.MRImage, this.saveFileDialog.FileName, this.mrImageExporter.GetMRImageFormatFromFilterIndex(this.saveFileDialog.FilterIndex)); + this.saveFileDialog.InitialDirectory = Path.GetDirectoryName(this.saveFileDialog.FileName); + this.saveFileDialog.FileName = Path.GetFileName(this.saveFileDialog.FileName); + } + + private void UpdateViewAndDisplayNoImage() + { + this.lbNoMrImage.Visible = this.DisplayNoImageMessage; + this.gbMRImageInfo.Visible = false; + this.btExportMRImage.Visible = false; + this.pictureBox.Visible = false; + } + + private void UpdateViewAndDisplayImages() + { + this.lbNoMrImage.Visible = false; + this.gbMRImageInfo.Visible = true; + this.btExportMRImage.Visible = true; + this.pictureBox.Visible = true; + } + + private void pictureBox_Resize(object sender, EventArgs e) => this.CenterImageInDisplayArea((Control) this.pictureBox); + + private void btExportMRImage_Click(object sender, EventArgs e) => this.OpenFileDialogAndExportImage(this.pictureBox.Image); + + protected override void Dispose(bool disposing) + { + if (disposing && this.components != null) + this.components.Dispose(); + base.Dispose(disposing); + } + + private void InitializeComponent() + { + this.pictureBox = new PictureBox(); + this.gbMRImageInfo = new GroupBox(); + this.lbCompressionRatioValue = new Label(); + this.lbCompressionRatio = new Label(); + this.lbUncompressedSizeValue = new Label(); + this.lbUncompressedSize = new Label(); + this.lbCompressedSizeValue = new Label(); + this.lbSize = new Label(); + this.lbFileSizeValue = new Label(); + this.lbFileSize = new Label(); + this.lbNumberOfColorsValue = new Label(); + this.lbImageSizeValue = new Label(); + this.lbColors = new Label(); + this.lbImageSize = new Label(); + this.btExportMRImage = new Button(); + this.saveFileDialog = new SaveFileDialog(); + this.lbNoMrImage = new Label(); + ((ISupportInitialize) this.pictureBox).BeginInit(); + this.gbMRImageInfo.SuspendLayout(); + this.SuspendLayout(); + this.pictureBox.Anchor = AnchorStyles.Top | AnchorStyles.Bottom; + this.pictureBox.BorderStyle = BorderStyle.FixedSingle; + this.pictureBox.Location = new Point(6, 3); + this.pictureBox.Name = "pictureBox"; + this.pictureBox.Size = new Size(448, 90); + this.pictureBox.SizeMode = PictureBoxSizeMode.AutoSize; + this.pictureBox.TabIndex = 0; + this.pictureBox.TabStop = false; + this.gbMRImageInfo.Controls.Add((Control) this.lbCompressionRatioValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbCompressionRatio); + this.gbMRImageInfo.Controls.Add((Control) this.lbUncompressedSizeValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbUncompressedSize); + this.gbMRImageInfo.Controls.Add((Control) this.lbCompressedSizeValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbSize); + this.gbMRImageInfo.Controls.Add((Control) this.lbFileSizeValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbFileSize); + this.gbMRImageInfo.Controls.Add((Control) this.lbNumberOfColorsValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbImageSizeValue); + this.gbMRImageInfo.Controls.Add((Control) this.lbColors); + this.gbMRImageInfo.Controls.Add((Control) this.lbImageSize); + this.gbMRImageInfo.Location = new Point(6, 99); + this.gbMRImageInfo.Name = "gbMRImageInfo"; + this.gbMRImageInfo.Size = new Size(448, 75); + this.gbMRImageInfo.TabIndex = 0; + this.gbMRImageInfo.TabStop = false; + this.gbMRImageInfo.Text = "Properties:"; + this.lbCompressionRatioValue.AutoSize = true; + this.lbCompressionRatioValue.Location = new Point(345, 54); + this.lbCompressionRatioValue.Name = "lbCompressionRatioValue"; + this.lbCompressionRatioValue.Size = new Size(89, 13); + this.lbCompressionRatioValue.TabIndex = 0; + this.lbCompressionRatioValue.Text = "compression ratio"; + this.lbCompressionRatio.AutoSize = true; + this.lbCompressionRatio.Location = new Point(235, 54); + this.lbCompressionRatio.Name = "lbCompressionRatio"; + this.lbCompressionRatio.Size = new Size(98, 13); + this.lbCompressionRatio.TabIndex = 0; + this.lbCompressionRatio.Text = "Compression Ratio:"; + this.lbUncompressedSizeValue.AutoSize = true; + this.lbUncompressedSizeValue.Location = new Point(345, 37); + this.lbUncompressedSizeValue.Name = "lbUncompressedSizeValue"; + this.lbUncompressedSizeValue.Size = new Size(97, 13); + this.lbUncompressedSizeValue.TabIndex = 0; + this.lbUncompressedSizeValue.Text = "uncompressed size"; + this.lbUncompressedSize.AutoSize = true; + this.lbUncompressedSize.Location = new Point(234, 37); + this.lbUncompressedSize.Name = "lbUncompressedSize"; + this.lbUncompressedSize.Size = new Size(104, 13); + this.lbUncompressedSize.TabIndex = 0; + this.lbUncompressedSize.Text = "Uncompressed Size:"; + this.lbCompressedSizeValue.AutoSize = true; + this.lbCompressedSizeValue.Location = new Point(345, 20); + this.lbCompressedSizeValue.Name = "lbCompressedSizeValue"; + this.lbCompressedSizeValue.Size = new Size(85, 13); + this.lbCompressedSizeValue.TabIndex = 0; + this.lbCompressedSizeValue.Text = "compressed size"; + this.lbSize.AutoSize = true; + this.lbSize.Location = new Point(235, 20); + this.lbSize.Name = "lbSize"; + this.lbSize.Size = new Size(91, 13); + this.lbSize.TabIndex = 0; + this.lbSize.Text = "Compressed Size:"; + this.lbFileSizeValue.AutoSize = true; + this.lbFileSizeValue.Location = new Point(106, 54); + this.lbFileSizeValue.Name = "lbFileSizeValue"; + this.lbFileSizeValue.Size = new Size(64, 13); + this.lbFileSizeValue.TabIndex = 0; + this.lbFileSizeValue.Text = "size in bytes"; + this.lbFileSize.AutoSize = true; + this.lbFileSize.Location = new Point(7, 54); + this.lbFileSize.Name = "lbFileSize"; + this.lbFileSize.Size = new Size(49, 13); + this.lbFileSize.TabIndex = 0; + this.lbFileSize.Text = "File Size:"; + this.lbNumberOfColorsValue.AutoSize = true; + this.lbNumberOfColorsValue.Location = new Point(103, 37); + this.lbNumberOfColorsValue.Name = "lbNumberOfColorsValue"; + this.lbNumberOfColorsValue.Size = new Size(13, 13); + this.lbNumberOfColorsValue.TabIndex = 0; + this.lbNumberOfColorsValue.Text = "0"; + this.lbImageSizeValue.AutoSize = true; + this.lbImageSizeValue.Location = new Point(103, 20); + this.lbImageSizeValue.Name = "lbImageSizeValue"; + this.lbImageSizeValue.Size = new Size(54, 13); + this.lbImageSizeValue.TabIndex = 0; + this.lbImageSizeValue.Text = "XXXxYYY"; + this.lbColors.AutoSize = true; + this.lbColors.Location = new Point(7, 37); + this.lbColors.Name = "lbColors"; + this.lbColors.Size = new Size(90, 13); + this.lbColors.TabIndex = 0; + this.lbColors.Text = "Number of colors:"; + this.lbImageSize.AutoSize = true; + this.lbImageSize.Location = new Point(7, 20); + this.lbImageSize.Name = "lbImageSize"; + this.lbImageSize.Size = new Size(62, 13); + this.lbImageSize.TabIndex = 0; + this.lbImageSize.Text = "Image Size:"; + this.btExportMRImage.CausesValidation = false; + this.btExportMRImage.FlatStyle = FlatStyle.Popup; + this.btExportMRImage.Font = new Font("Microsoft Sans Serif", 8.25f, FontStyle.Regular, GraphicsUnit.Point, (byte) 0); + this.btExportMRImage.ForeColor = Color.FromArgb(248, 48, 0); + this.btExportMRImage.Location = new Point(6, 180); + this.btExportMRImage.Name = "btExportMRImage"; + this.btExportMRImage.Size = new Size(108, 22); + this.btExportMRImage.TabIndex = 1; + this.btExportMRImage.Text = "Export Image..."; + this.btExportMRImage.UseVisualStyleBackColor = false; + this.btExportMRImage.Click += new EventHandler(this.btExportMRImage_Click); + this.lbNoMrImage.AutoSize = true; + this.lbNoMrImage.Font = new Font("Microsoft Sans Serif", 15.75f, FontStyle.Bold, GraphicsUnit.Point, (byte) 0); + this.lbNoMrImage.Location = new Point(117, 35); + this.lbNoMrImage.Name = "lbNoMrImage"; + this.lbNoMrImage.Size = new Size(226, 25); + this.lbNoMrImage.TabIndex = 2; + this.lbNoMrImage.Text = "No MR Image found!"; + this.lbNoMrImage.TextAlign = ContentAlignment.MiddleCenter; + this.AutoScaleDimensions = new SizeF(6f, 13f); + this.AutoScaleMode = AutoScaleMode.Font; + this.Controls.Add((Control) this.lbNoMrImage); + this.Controls.Add((Control) this.btExportMRImage); + this.Controls.Add((Control) this.gbMRImageInfo); + this.Controls.Add((Control) this.pictureBox); + this.Name = nameof (MRImageViewer); + this.Size = new Size(460, 209); + ((ISupportInitialize) this.pictureBox).EndInit(); + this.gbMRImageInfo.ResumeLayout(false); + this.gbMRImageInfo.PerformLayout(); + this.ResumeLayout(false); + this.PerformLayout(); + } + } +} diff --git a/SEGATools/Graphics/MRImageViewer.resx b/SEGATools/Graphics/MRImageViewer.resx new file mode 100644 index 0000000..d58980a --- /dev/null +++ b/SEGATools/Graphics/MRImageViewer.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/SEGATools/HashAlgorithm/ECC.cs b/SEGATools/HashAlgorithm/ECC.cs new file mode 100644 index 0000000..2565a51 --- /dev/null +++ b/SEGATools/HashAlgorithm/ECC.cs @@ -0,0 +1,607 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.HashAlgorithm.ECC +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using ImageReader.DiscSectors; +using System; + +namespace SEGATools.HashAlgorithm +{ + public static class ECC + { + private static readonly byte[] ECC_F_LOOKUP_TABLE = new byte[256] + { + (byte) 0, + (byte) 2, + (byte) 4, + (byte) 6, + (byte) 8, + (byte) 10, + (byte) 12, + (byte) 14, + (byte) 16, + (byte) 18, + (byte) 20, + (byte) 22, + (byte) 24, + (byte) 26, + (byte) 28, + (byte) 30, + (byte) 32, + (byte) 34, + (byte) 36, + (byte) 38, + (byte) 40, + (byte) 42, + (byte) 44, + (byte) 46, + (byte) 48, + (byte) 50, + (byte) 52, + (byte) 54, + (byte) 56, + (byte) 58, + (byte) 60, + (byte) 62, + (byte) 64, + (byte) 66, + (byte) 68, + (byte) 70, + (byte) 72, + (byte) 74, + (byte) 76, + (byte) 78, + (byte) 80, + (byte) 82, + (byte) 84, + (byte) 86, + (byte) 88, + (byte) 90, + (byte) 92, + (byte) 94, + (byte) 96, + (byte) 98, + (byte) 100, + (byte) 102, + (byte) 104, + (byte) 106, + (byte) 108, + (byte) 110, + (byte) 112, + (byte) 114, + (byte) 116, + (byte) 118, + (byte) 120, + (byte) 122, + (byte) 124, + (byte) 126, + (byte) 128, + (byte) 130, + (byte) 132, + (byte) 134, + (byte) 136, + (byte) 138, + (byte) 140, + (byte) 142, + (byte) 144, + (byte) 146, + (byte) 148, + (byte) 150, + (byte) 152, + (byte) 154, + (byte) 156, + (byte) 158, + (byte) 160, + (byte) 162, + (byte) 164, + (byte) 166, + (byte) 168, + (byte) 170, + (byte) 172, + (byte) 174, + (byte) 176, + (byte) 178, + (byte) 180, + (byte) 182, + (byte) 184, + (byte) 186, + (byte) 188, + (byte) 190, + (byte) 192, + (byte) 194, + (byte) 196, + (byte) 198, + (byte) 200, + (byte) 202, + (byte) 204, + (byte) 206, + (byte) 208, + (byte) 210, + (byte) 212, + (byte) 214, + (byte) 216, + (byte) 218, + (byte) 220, + (byte) 222, + (byte) 224, + (byte) 226, + (byte) 228, + (byte) 230, + (byte) 232, + (byte) 234, + (byte) 236, + (byte) 238, + (byte) 240, + (byte) 242, + (byte) 244, + (byte) 246, + (byte) 248, + (byte) 250, + (byte) 252, + (byte) 254, + (byte) 29, + (byte) 31, + (byte) 25, + (byte) 27, + (byte) 21, + (byte) 23, + (byte) 17, + (byte) 19, + (byte) 13, + (byte) 15, + (byte) 9, + (byte) 11, + (byte) 5, + (byte) 7, + (byte) 1, + (byte) 3, + (byte) 61, + (byte) 63, + (byte) 57, + (byte) 59, + (byte) 53, + (byte) 55, + (byte) 49, + (byte) 51, + (byte) 45, + (byte) 47, + (byte) 41, + (byte) 43, + (byte) 37, + (byte) 39, + (byte) 33, + (byte) 35, + (byte) 93, + (byte) 95, + (byte) 89, + (byte) 91, + (byte) 85, + (byte) 87, + (byte) 81, + (byte) 83, + (byte) 77, + (byte) 79, + (byte) 73, + (byte) 75, + (byte) 69, + (byte) 71, + (byte) 65, + (byte) 67, + (byte) 125, + (byte) 127, + (byte) 121, + (byte) 123, + (byte) 117, + (byte) 119, + (byte) 113, + (byte) 115, + (byte) 109, + (byte) 111, + (byte) 105, + (byte) 107, + (byte) 101, + (byte) 103, + (byte) 97, + (byte) 99, + (byte) 157, + (byte) 159, + (byte) 153, + (byte) 155, + (byte) 149, + (byte) 151, + (byte) 145, + (byte) 147, + (byte) 141, + (byte) 143, + (byte) 137, + (byte) 139, + (byte) 133, + (byte) 135, + (byte) 129, + (byte) 131, + (byte) 189, + (byte) 191, + (byte) 185, + (byte) 187, + (byte) 181, + (byte) 183, + (byte) 177, + (byte) 179, + (byte) 173, + (byte) 175, + (byte) 169, + (byte) 171, + (byte) 165, + (byte) 167, + (byte) 161, + (byte) 163, + (byte) 221, + (byte) 223, + (byte) 217, + (byte) 219, + (byte) 213, + (byte) 215, + (byte) 209, + (byte) 211, + (byte) 205, + (byte) 207, + (byte) 201, + (byte) 203, + (byte) 197, + (byte) 199, + (byte) 193, + (byte) 195, + (byte) 253, + byte.MaxValue, + (byte) 249, + (byte) 251, + (byte) 245, + (byte) 247, + (byte) 241, + (byte) 243, + (byte) 237, + (byte) 239, + (byte) 233, + (byte) 235, + (byte) 229, + (byte) 231, + (byte) 225, + (byte) 227 + }; + private static readonly byte[] ECC_B_LOOKUP_TABLE = new byte[256] + { + (byte) 0, + (byte) 244, + (byte) 245, + (byte) 1, + (byte) 247, + (byte) 3, + (byte) 2, + (byte) 246, + (byte) 243, + (byte) 7, + (byte) 6, + (byte) 242, + (byte) 4, + (byte) 240, + (byte) 241, + (byte) 5, + (byte) 251, + (byte) 15, + (byte) 14, + (byte) 250, + (byte) 12, + (byte) 248, + (byte) 249, + (byte) 13, + (byte) 8, + (byte) 252, + (byte) 253, + (byte) 9, + byte.MaxValue, + (byte) 11, + (byte) 10, + (byte) 254, + (byte) 235, + (byte) 31, + (byte) 30, + (byte) 234, + (byte) 28, + (byte) 232, + (byte) 233, + (byte) 29, + (byte) 24, + (byte) 236, + (byte) 237, + (byte) 25, + (byte) 239, + (byte) 27, + (byte) 26, + (byte) 238, + (byte) 16, + (byte) 228, + (byte) 229, + (byte) 17, + (byte) 231, + (byte) 19, + (byte) 18, + (byte) 230, + (byte) 227, + (byte) 23, + (byte) 22, + (byte) 226, + (byte) 20, + (byte) 224, + (byte) 225, + (byte) 21, + (byte) 203, + (byte) 63, + (byte) 62, + (byte) 202, + (byte) 60, + (byte) 200, + (byte) 201, + (byte) 61, + (byte) 56, + (byte) 204, + (byte) 205, + (byte) 57, + (byte) 207, + (byte) 59, + (byte) 58, + (byte) 206, + (byte) 48, + (byte) 196, + (byte) 197, + (byte) 49, + (byte) 199, + (byte) 51, + (byte) 50, + (byte) 198, + (byte) 195, + (byte) 55, + (byte) 54, + (byte) 194, + (byte) 52, + (byte) 192, + (byte) 193, + (byte) 53, + (byte) 32, + (byte) 212, + (byte) 213, + (byte) 33, + (byte) 215, + (byte) 35, + (byte) 34, + (byte) 214, + (byte) 211, + (byte) 39, + (byte) 38, + (byte) 210, + (byte) 36, + (byte) 208, + (byte) 209, + (byte) 37, + (byte) 219, + (byte) 47, + (byte) 46, + (byte) 218, + (byte) 44, + (byte) 216, + (byte) 217, + (byte) 45, + (byte) 40, + (byte) 220, + (byte) 221, + (byte) 41, + (byte) 223, + (byte) 43, + (byte) 42, + (byte) 222, + (byte) 139, + (byte) 127, + (byte) 126, + (byte) 138, + (byte) 124, + (byte) 136, + (byte) 137, + (byte) 125, + (byte) 120, + (byte) 140, + (byte) 141, + (byte) 121, + (byte) 143, + (byte) 123, + (byte) 122, + (byte) 142, + (byte) 112, + (byte) 132, + (byte) 133, + (byte) 113, + (byte) 135, + (byte) 115, + (byte) 114, + (byte) 134, + (byte) 131, + (byte) 119, + (byte) 118, + (byte) 130, + (byte) 116, + (byte) 128, + (byte) 129, + (byte) 117, + (byte) 96, + (byte) 148, + (byte) 149, + (byte) 97, + (byte) 151, + (byte) 99, + (byte) 98, + (byte) 150, + (byte) 147, + (byte) 103, + (byte) 102, + (byte) 146, + (byte) 100, + (byte) 144, + (byte) 145, + (byte) 101, + (byte) 155, + (byte) 111, + (byte) 110, + (byte) 154, + (byte) 108, + (byte) 152, + (byte) 153, + (byte) 109, + (byte) 104, + (byte) 156, + (byte) 157, + (byte) 105, + (byte) 159, + (byte) 107, + (byte) 106, + (byte) 158, + (byte) 64, + (byte) 180, + (byte) 181, + (byte) 65, + (byte) 183, + (byte) 67, + (byte) 66, + (byte) 182, + (byte) 179, + (byte) 71, + (byte) 70, + (byte) 178, + (byte) 68, + (byte) 176, + (byte) 177, + (byte) 69, + (byte) 187, + (byte) 79, + (byte) 78, + (byte) 186, + (byte) 76, + (byte) 184, + (byte) 185, + (byte) 77, + (byte) 72, + (byte) 188, + (byte) 189, + (byte) 73, + (byte) 191, + (byte) 75, + (byte) 74, + (byte) 190, + (byte) 171, + (byte) 95, + (byte) 94, + (byte) 170, + (byte) 92, + (byte) 168, + (byte) 169, + (byte) 93, + (byte) 88, + (byte) 172, + (byte) 173, + (byte) 89, + (byte) 175, + (byte) 91, + (byte) 90, + (byte) 174, + (byte) 80, + (byte) 164, + (byte) 165, + (byte) 81, + (byte) 167, + (byte) 83, + (byte) 82, + (byte) 166, + (byte) 163, + (byte) 87, + (byte) 86, + (byte) 162, + (byte) 84, + (byte) 160, + (byte) 161, + (byte) 85 + }; + + internal static int ComputeECCBlock( + byte[] src, + int srcOffset, + byte[] dest, + int destOffset, + uint majorCount, + uint minorCount, + uint majorMult, + uint minorInc) + { + uint num1 = majorCount * minorCount; + for (uint index1 = 0; index1 < majorCount; ++index1) + { + uint num2 = (uint) ((int) (index1 >> 1) * (int) majorMult + ((int) index1 & 1)); + byte num3 = 0; + byte num4 = 0; + for (uint index2 = 0; index2 < minorCount; ++index2) + { + byte num5 = src[(long) srcOffset + (long) num2]; + num2 += minorInc; + if (num2 >= num1) + num2 -= num1; + byte num6 = (byte) ((uint) num3 ^ (uint) num5); + num4 ^= num5; + num3 = ECC.ECC_F_LOOKUP_TABLE[(int) num6]; + } + byte num7 = ECC.ECC_B_LOOKUP_TABLE[(int) ECC.ECC_F_LOOKUP_TABLE[(int) num3] ^ (int) num4]; + dest[(long) destOffset + (long) index1] = num7; + dest[(long) destOffset + (long) index1 + (long) majorCount] = (byte) ((uint) num7 ^ (uint) num4); + } + return (int) majorCount * 2; + } + + internal static void CheckBufferSize(byte[] buffer) + { + if (buffer == null) + throw new ArgumentNullException(nameof (buffer)); + if (buffer.Length != DiscSectorCommon.RawSectorSize) + throw new ArgumentException(string.Format("length must be {0} bytes", (object) DiscSectorCommon.RawSectorSize), nameof (buffer)); + } + + public interface ECCParityVectorAlgorithm + { + void ComputeVectors(byte[] buffer); + } + + public class PParity : ECC.ECCParityVectorAlgorithm + { + public static readonly int P_PARITY_VECTOR_LENGTH = ECC.PParity.P_PARITY_VECTORS * 2 * 2; + public static readonly int P_PARITY_VECTOR_OFFSET = 2076; + private static readonly int P_PARITY_VECTORS = 43; + private static readonly int P_PARITY_DATA_OFFSET = 12; + + public void ComputeVectors(byte[] buffer) + { + ECC.CheckBufferSize(buffer); + ECC.ComputeECCBlock(buffer, ECC.PParity.P_PARITY_DATA_OFFSET, buffer, ECC.PParity.P_PARITY_VECTOR_OFFSET, (uint) (ECC.PParity.P_PARITY_VECTORS * 2), 24U, 2U, 86U); + } + } + + public class QParity : ECC.ECCParityVectorAlgorithm + { + public static readonly int Q_PARITY_VECTOR_LENGTH = ECC.QParity.Q_PARITY_VECTORS * 2 * 2; + public static readonly int Q_PARITY_VECTOR_OFFSET = 2248; + private static readonly int Q_PARITY_VECTORS = 26; + private static readonly int Q_PARITY_DATA_OFFSET = 12; + + public void ComputeVectors(byte[] buffer) + { + ECC.CheckBufferSize(buffer); + ECC.ComputeECCBlock(buffer, ECC.QParity.Q_PARITY_DATA_OFFSET, buffer, ECC.QParity.Q_PARITY_VECTOR_OFFSET, (uint) (ECC.QParity.Q_PARITY_VECTORS * 2), 43U, 86U, 88U); + } + } + } +} diff --git a/SEGATools/HashAlgorithm/EDC.cs b/SEGATools/HashAlgorithm/EDC.cs new file mode 100644 index 0000000..d9c9f6e --- /dev/null +++ b/SEGATools/HashAlgorithm/EDC.cs @@ -0,0 +1,322 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.HashAlgorithm.EDC +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.HashAlgorithm +{ + public class EDC : System.Security.Cryptography.HashAlgorithm + { + public static readonly int SECTOR_DATA_LENGTH_FOR_EDC_COMPUTATION = 2064; + public static readonly int EDC_DATA_OFFSET = EDC.SECTOR_DATA_LENGTH_FOR_EDC_COMPUTATION; + public static readonly int EDC_DATA_LENGTH = 4; + private static readonly uint EDC_POLYNOMIAL = 3623976961; + private static readonly uint[] EDC_CRC_LOOKUP_TABLE = new uint[256] + { + 0U, + 2425422081U, + 2434859521U, + 28312320U, + 2453734401U, + 47187200U, + 56624640U, + 2482046721U, + 2491484161U, + 68159744U, + 94374400U, + 2503019265U, + 113249280U, + 2521894145U, + 2548108801U, + 124784384U, + 2566983681U, + 160436480U, + 136319488U, + 2561741569U, + 188748800U, + 2614170881U, + 2590053889U, + 183506688U, + 226498560U, + 2635143425U, + 2627803649U, + 204479232U, + 2680232961U, + 256908544U, + 249568768U, + 2658213633U, + 2181111809U, + 311435520U, + 320872960U, + 2209424129U, + 272638976U, + 2161190145U, + 2170627585U, + 300951296U, + 377497600U, + 2249271553U, + 2275486209U, + 389032704U, + 2227252225U, + 340798720U, + 367013376U, + 2238787329U, + 452997120U, + 2341548289U, + 2317431297U, + 447755008U, + 2302751745U, + 433075456U, + 408958464U, + 2297509633U, + 2407610369U, + 521156864U, + 513817088U, + 2385591041U, + 499137536U, + 2370911489U, + 2363571713U, + 477118208U, + 3019980801U, + 613433600U, + 622871040U, + 3048293121U, + 641745920U, + 3067168001U, + 3076605441U, + 670058240U, + 545277952U, + 2953922817U, + 2980137473U, + 556813056U, + 2999012353U, + 575687936U, + 601902592U, + 3010547457U, + 754995200U, + 3180417281U, + 3156300289U, + 749753088U, + 3208729601U, + 802182400U, + 778065408U, + 3203487489U, + 3112261633U, + 688937216U, + 681597440U, + 3090242305U, + 734026752U, + 3142671617U, + 3135331841U, + 712007424U, + 905994240U, + 2794545409U, + 2803982849U, + 934306560U, + 2755748865U, + 886072576U, + 895510016U, + 2784061185U, + 2726389761U, + 839936256U, + 866150912U, + 2737924865U, + 817916928U, + 2689690881U, + 2715905537U, + 829452032U, + 2936107009U, + 1066430720U, + 1042313728U, + 2930864897U, + 1027634176U, + 2916185345U, + 2892068353U, + 1022392064U, + 998275072U, + 2870049025U, + 2862709249U, + 976255744U, + 2848029697U, + 961576192U, + 954236416U, + 2826010369U, + 3623976961U, + 1217429760U, + 1226867200U, + 3652289281U, + 1245742080U, + 3671164161U, + 3680601601U, + 1274054400U, + 1283491840U, + 3692136705U, + 3718351361U, + 1295026944U, + 3737226241U, + 1313901824U, + 1340116480U, + 3748761345U, + 1090555904U, + 3515977985U, + 3491860993U, + 1085313792U, + 3544290305U, + 1137743104U, + 1113626112U, + 3539048193U, + 3582040065U, + 1158715648U, + 1151375872U, + 3560020737U, + 1203805184U, + 3612450049U, + 3605110273U, + 1181785856U, + 1509990400U, + 3398541569U, + 3407979009U, + 1538302720U, + 3359745025U, + 1490068736U, + 1499506176U, + 3388057345U, + 3464603649U, + 1578150144U, + 1604364800U, + 3476138753U, + 1556130816U, + 3427904769U, + 3454119425U, + 1567665920U, + 3271667713U, + 1401991424U, + 1377874432U, + 3266425601U, + 1363194880U, + 3251746049U, + 3227629057U, + 1357952768U, + 1468053504U, + 3339827457U, + 3332487681U, + 1446034176U, + 3317808129U, + 1431354624U, + 1424014848U, + 3295788801U, + 1811988480U, + 4237410561U, + 4246848001U, + 1840300800U, + 4265722881U, + 1859175680U, + 1868613120U, + 4294035201U, + 4169254913U, + 1745930496U, + 1772145152U, + 4180790017U, + 1791020032U, + 4199664897U, + 4225879553U, + 1802555136U, + 4110536705U, + 1703989504U, + 1679872512U, + 4105294593U, + 1732301824U, + 4157723905U, + 4133606913U, + 1727059712U, + 1635833856U, + 4044478721U, + 4037138945U, + 1613814528U, + 4089568257U, + 1666243840U, + 1658904064U, + 4067548929U, + 3993100289U, + 2123424000U, + 2132861440U, + 4021412609U, + 2084627456U, + 3973178625U, + 3982616065U, + 2112939776U, + 2055268352U, + 3927042305U, + 3953256961U, + 2066803456U, + 3905022977U, + 2018569472U, + 2044784128U, + 3916558081U, + 1996550144U, + 3885101313U, + 3860984321U, + 1991308032U, + 3846304769U, + 1976628480U, + 1952511488U, + 3841062657U, + 3816945665U, + 1930492160U, + 1923152384U, + 3794926337U, + 1908472832U, + 3780246785U, + 3772907009U, + 1886453504U + }; + private uint hash; + + protected override void HashCore(byte[] array, int ibStart, int cbSize) + { + EDC.CheckBufferSize(array, ibStart, cbSize); + uint num1 = 0; + for (int index = ibStart; index < ibStart + cbSize; ++index) + { + uint num2 = (uint) (((int) num1 ^ (int) array[ibStart + index]) & (int) byte.MaxValue); + num1 = EDC.EDC_CRC_LOOKUP_TABLE[(int) num2] ^ num1 >> 8; + } + this.hash = num1; + } + + protected override byte[] HashFinal() => BitConverter.GetBytes(this.hash); + + public override void Initialize() + { + } + + private static uint[] GenerateCRCLookUpTable() + { + uint[] numArray = new uint[256]; + for (uint index1 = 0; (long) index1 < (long) numArray.Length; ++index1) + { + uint num = index1; + for (int index2 = 8; index2 > 0; --index2) + { + if (((int) num & 1) != 0) + num = num >> 1 ^ EDC.EDC_POLYNOMIAL; + else + num >>= 1; + } + numArray[(int) index1] = num; + } + return numArray; + } + + private static void CheckBufferSize(byte[] buffer, int ibStart, int cbSize) + { + if (buffer == null) + throw new ArgumentNullException(nameof (buffer)); + if (buffer.Length - ibStart < cbSize) + throw new ArgumentException("buffer too small"); + } + } +} diff --git a/SEGATools/ImageReader/DiscFileSystem/DiscFileSystemException.cs b/SEGATools/ImageReader/DiscFileSystem/DiscFileSystemException.cs new file mode 100644 index 0000000..e7332ee --- /dev/null +++ b/SEGATools/ImageReader/DiscFileSystem/DiscFileSystemException.cs @@ -0,0 +1,25 @@ +// Decompiled with JetBrains decompiler +// Type: ImageReader.DiscFileSystem.DiscFileSystemException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace ImageReader.DiscFileSystem +{ + public class DiscFileSystemException : Exception + { + public DiscFileSystemException(string message) + : base(string.Format("Disc File-System Error: {0}", (object) message)) + { + } + + public DiscFileSystemException(string message, Exception innerException) + : base(string.Format("Disc File-System Error: {0}", (object) message), innerException) + { + } + + public static DiscFileSystemException noFileSystemFoundException() => new DiscFileSystemException("no file-system found!"); + } +} diff --git a/SEGATools/Logger.cs b/SEGATools/Logger.cs new file mode 100644 index 0000000..f179cf5 --- /dev/null +++ b/SEGATools/Logger.cs @@ -0,0 +1,475 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Logger +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using log4net; +using log4net.Core; +using System; +using System.Diagnostics; +using System.Globalization; +using System.Reflection; + +namespace SEGATools +{ + public static class Logger + { + private static readonly bool loggingIsOff = true; + + static Logger() + { + try + { + //Assembly.Load("log4net").GetType("log4net.Config.XmlConfigurator").GetMethod("Configure", new Type[0]).Invoke((object) null, (object[]) null); + Assembly.Load("log4net"); + + Logger.loggingIsOff = false; + } + catch + { + } + } + + public static Logger.ILog CreateLog() + { + Type declaringType = new StackFrame(1, false).GetMethod().DeclaringType; + return !Logger.loggingIsOff ? (Logger.ILog) new Logger.Log4NetLogger(declaringType) : (Logger.ILog) new Logger.NoLog(); + } + + public interface ILog + { + bool IsDebugEnabled { get; } + + bool IsInfoEnabled { get; } + + bool IsWarnEnabled { get; } + + bool IsErrorEnabled { get; } + + bool IsFatalEnabled { get; } + + void Debug(object message); + + void Debug(object message, Exception exception); + + void DebugFormat(string format, params object[] args); + + void DebugFormat(string format, object arg0); + + void DebugFormat(string format, object arg0, object arg1); + + void DebugFormat(string format, object arg0, object arg1, object arg2); + + void DebugFormat(IFormatProvider provider, string format, params object[] args); + + void Info(object message); + + void Info(object message, Exception exception); + + void InfoFormat(string format, params object[] args); + + void InfoFormat(string format, object arg0); + + void InfoFormat(string format, object arg0, object arg1); + + void InfoFormat(string format, object arg0, object arg1, object arg2); + + void InfoFormat(IFormatProvider provider, string format, params object[] args); + + void Warn(object message); + + void Warn(object message, Exception exception); + + void WarnFormat(string format, params object[] args); + + void WarnFormat(string format, object arg0); + + void WarnFormat(string format, object arg0, object arg1); + + void WarnFormat(string format, object arg0, object arg1, object arg2); + + void WarnFormat(IFormatProvider provider, string format, params object[] args); + + void Error(object message); + + void Error(object message, Exception exception); + + void ErrorFormat(string format, params object[] args); + + void ErrorFormat(string format, object arg0); + + void ErrorFormat(string format, object arg0, object arg1); + + void ErrorFormat(string format, object arg0, object arg1, object arg2); + + void ErrorFormat(IFormatProvider provider, string format, params object[] args); + + void Fatal(object message); + + void Fatal(object message, Exception exception); + + void FatalFormat(string format, params object[] args); + + void FatalFormat(string format, object arg0); + + void FatalFormat(string format, object arg0, object arg1); + + void FatalFormat(string format, object arg0, object arg1, object arg2); + + void FatalFormat(IFormatProvider provider, string format, params object[] args); + } + + private class NoLog : Logger.ILog + { + public bool IsDebugEnabled => false; + + public bool IsInfoEnabled => false; + + public bool IsWarnEnabled => false; + + public bool IsErrorEnabled => false; + + public bool IsFatalEnabled => false; + + public void Debug(object message) + { + } + + public void Debug(object message, Exception exception) + { + } + + public void DebugFormat(string format, params object[] args) + { + } + + public void DebugFormat(string format, object arg0) + { + } + + public void DebugFormat(string format, object arg0, object arg1) + { + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Info(object message) + { + } + + public void Info(object message, Exception exception) + { + } + + public void InfoFormat(string format, params object[] args) + { + } + + public void InfoFormat(string format, object arg0) + { + } + + public void InfoFormat(string format, object arg0, object arg1) + { + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Warn(object message) + { + } + + public void Warn(object message, Exception exception) + { + } + + public void WarnFormat(string format, params object[] args) + { + } + + public void WarnFormat(string format, object arg0) + { + } + + public void WarnFormat(string format, object arg0, object arg1) + { + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Error(object message) + { + } + + public void Error(object message, Exception exception) + { + } + + public void ErrorFormat(string format, params object[] args) + { + } + + public void ErrorFormat(string format, object arg0) + { + } + + public void ErrorFormat(string format, object arg0, object arg1) + { + } + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) + { + } + + public void Fatal(object message) + { + } + + public void Fatal(object message, Exception exception) + { + } + + public void FatalFormat(string format, params object[] args) + { + } + + public void FatalFormat(string format, object arg0) + { + } + + public void FatalFormat(string format, object arg0, object arg1) + { + } + + public void FatalFormat(string format, object arg0, object arg1, object arg2) + { + } + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) + { + } + } + + private class Log4NetLogger : Logger.ILog + { + private readonly log4net.ILog rootLogger; + private readonly Type loggingType; + private readonly ILogger logger; + + public Log4NetLogger(Type type) + { + this.loggingType = type; + this.rootLogger = LogManager.GetLogger(this.loggingType); + this.logger = ((ILoggerWrapper) this.rootLogger).Logger; + } + + public bool IsDebugEnabled => this.rootLogger.IsDebugEnabled; + + public bool IsInfoEnabled => this.rootLogger.IsInfoEnabled; + + public bool IsWarnEnabled => this.rootLogger.IsWarnEnabled; + + public bool IsErrorEnabled => this.rootLogger.IsFatalEnabled; + + public bool IsFatalEnabled => this.rootLogger.IsFatalEnabled; + + public void Debug(object message) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, (Exception) null); + } + + public void Debug(object message, Exception exception) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, message, exception); + } + + public void DebugFormat(string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void DebugFormat(string format, object arg0) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void DebugFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void DebugFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsDebugEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Debug, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Info(object message) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, (Exception) null); + } + + public void Info(object message, Exception exception) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, message, exception); + } + + public void InfoFormat(string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void InfoFormat(string format, object arg0) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void InfoFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void InfoFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsInfoEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Info, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Warn(object message) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, (Exception) null); + } + + public void Warn(object message, Exception exception) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, message, exception); + } + + public void WarnFormat(string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + } + + public void WarnFormat(string format, object arg0) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + } + + public void WarnFormat(string format, object arg0, object arg1, object arg2) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + } + + public void WarnFormat(IFormatProvider provider, string format, params object[] args) + { + if (!this.IsWarnEnabled) + return; + this.logger.Log(this.loggingType, (Level) Level.Warn, (object) string.Format(provider, format, args), (Exception) null); + } + + public void Error(object message) => this.logger.Log(this.loggingType, (Level) Level.Error, message, (Exception) null); + + public void Error(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Error, message, exception); + + public void ErrorFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void ErrorFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void ErrorFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void ErrorFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Error, (object) string.Format(provider, format, args), (Exception) null); + + public void Fatal(object message) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, (Exception) null); + + public void Fatal(object message, Exception exception) => this.logger.Log(this.loggingType, (Level) Level.Fatal, message, exception); + + public void FatalFormat(string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, args), (Exception) null); + + public void FatalFormat(string format, object arg0) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1), (Exception) null); + + public void FatalFormat(string format, object arg0, object arg1, object arg2) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format((IFormatProvider) CultureInfo.InvariantCulture, format, arg0, arg1, arg2), (Exception) null); + + public void FatalFormat(IFormatProvider provider, string format, params object[] args) => this.logger.Log(this.loggingType, (Level) Level.Fatal, (object) string.Format(provider, format, args), (Exception) null); + } + } +} diff --git a/SEGATools/Properties/Resources.cs b/SEGATools/Properties/Resources.cs new file mode 100644 index 0000000..7598b5a --- /dev/null +++ b/SEGATools/Properties/Resources.cs @@ -0,0 +1,94 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Properties.Resources +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System.CodeDom.Compiler; +using System.ComponentModel; +using System.Diagnostics; +using System.Globalization; +using System.Resources; +using System.Runtime.CompilerServices; + +namespace SEGATools.Properties +{ + [GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [DebuggerNonUserCode] + [CompilerGenerated] + internal class Resources + { + private static ResourceManager resourceMan; + private static CultureInfo resourceCulture; + + internal Resources() + { + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static ResourceManager ResourceManager + { + get + { + if (object.ReferenceEquals((object) SEGATools.Properties.Resources.resourceMan, (object) null)) + SEGATools.Properties.Resources.resourceMan = new ResourceManager("SEGATools.Properties.Resources", typeof (SEGATools.Properties.Resources).Assembly); + return SEGATools.Properties.Resources.resourceMan; + } + } + + [EditorBrowsable(EditorBrowsableState.Advanced)] + internal static CultureInfo Culture + { + get => SEGATools.Properties.Resources.resourceCulture; + set => SEGATools.Properties.Resources.resourceCulture = value; + } + + internal static string DiscFormatProviderAllExtensions => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (DiscFormatProviderAllExtensions), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefColumnBuildDate => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefColumnBuildDate), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefColumnName => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefColumnName), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefColumnVersion => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefColumnVersion), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefHint => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefHint), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefNoLibFound => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefNoLibFound), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefNumberPlurial => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefNumberPlurial), SEGATools.Properties.Resources.resourceCulture); + + internal static string LibRefNumberSingle => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (LibRefNumberSingle), SEGATools.Properties.Resources.resourceCulture); + + internal static string MRImageNoImageMessage => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (MRImageNoImageMessage), SEGATools.Properties.Resources.resourceCulture); + + internal static string MRIpImageSegaCustomBranding => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (MRIpImageSegaCustomBranding), SEGATools.Properties.Resources.resourceCulture); + + internal static string MRIpImageSegaLicense => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (MRIpImageSegaLicense), SEGATools.Properties.Resources.resourceCulture); + + internal static string MRIpImageSegaTM => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (MRIpImageSegaTM), SEGATools.Properties.Resources.resourceCulture); + + internal static string SfdMRImageTitle => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (SfdMRImageTitle), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnDataType => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnDataType), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnEnd => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnEnd), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnName => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnName), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnSize => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnSize), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnSizeInBytes => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnSizeInBytes), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnSizeInSectors => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnSizeInSectors), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocColumnStart => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocColumnStart), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocHint => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocHint), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocNoTrackFound => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocNoTrackFound), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocTrackNumberPlurial => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocTrackNumberPlurial), SEGATools.Properties.Resources.resourceCulture); + + internal static string TocTrackNumberSingle => SEGATools.Properties.Resources.ResourceManager.GetString(nameof (TocTrackNumberSingle), SEGATools.Properties.Resources.resourceCulture); + } +} diff --git a/SEGATools/Properties/Resources.resx b/SEGATools/Properties/Resources.resx new file mode 100644 index 0000000..32c1ff3 --- /dev/null +++ b/SEGATools/Properties/Resources.resx @@ -0,0 +1,192 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Version + + + Library Name + + + SEGA Trademark Image + + + Track + + + Size + + + Start LBA + + + no library found + + + Tracks in the initial program file: {0} + + + No MR image found! + + + All supported image files + + + 1 library + + + Size (Bytes) + + + Libraries used by the initial program file: {0} + + + Save MR image as... + + + 1 track + + + End LBA + + + no track found + + + SEGA Custom Branding Image + + + SEGA License Image + + + Type + + + {0} tracks + + + Build Date + + + Size (Sectors) + + + {0} libraries + + \ No newline at end of file diff --git a/SEGATools/Registry/EditFlags.cs b/SEGATools/Registry/EditFlags.cs new file mode 100644 index 0000000..18e0d11 --- /dev/null +++ b/SEGATools/Registry/EditFlags.cs @@ -0,0 +1,35 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.EditFlags +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Registry +{ + [Flags] + public enum EditFlags : uint + { + None = 0, + Exclude = 1, + Show = 2, + HasExtension = 4, + NoEdit = 8, + NoRemove = 16, // 0x00000010 + NoNewVerb = 32, // 0x00000020 + NoEditVerb = 64, // 0x00000040 + NoRemoveVerb = 128, // 0x00000080 + NoEditDesc = 256, // 0x00000100 + NoEditIcon = 512, // 0x00000200 + NoEditDflt = 1024, // 0x00000400 + NoEditVerbCmd = 2048, // 0x00000800 + NoEditVerbExe = 4096, // 0x00001000 + NoDDE = 8192, // 0x00002000 + NoEditMIME = 32768, // 0x00008000 + OpenIsSafe = 65536, // 0x00010000 + AlwaysUnsafe = 131072, // 0x00020000 + AlwaysShowExtension = 262144, // 0x00040000 + NoRecentDocuments = 1048576, // 0x00100000 + } +} diff --git a/SEGATools/Registry/FileAssociationInfo.cs b/SEGATools/Registry/FileAssociationInfo.cs new file mode 100644 index 0000000..6ef4847 --- /dev/null +++ b/SEGATools/Registry/FileAssociationInfo.cs @@ -0,0 +1,249 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.FileAssociationInfo +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using Microsoft.Win32; +using System; +using System.Collections.Generic; +using System.Xml.Serialization; + +namespace SEGATools.Registry +{ + public class FileAssociationInfo + { + private RegistryWrapper registryWrapper = new RegistryWrapper(); + private string extension; + + public static string[] GetExtensions() + { + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + List stringList = new List(); + foreach (string subKeyName in classesRoot.GetSubKeyNames()) + { + if (subKeyName.StartsWith(".")) + stringList.Add(subKeyName); + } + return stringList.ToArray(); + } + + public string ContentType + { + get => this.GetContentType(this); + set => this.SetContentType(this, value); + } + + public bool Exists + { + get + { + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + try + { + if (classesRoot.OpenSubKey(this.extension) == null) + return false; + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + return false; + } + return true; + } + } + + public string Extension + { + get => this.extension; + set => this.extension = value; + } + + public string[] OpenWithList + { + get => this.GetOpenWithList(this); + set => this.SetOpenWithList(this, value); + } + + public PerceivedTypes PerceivedType + { + get => this.GetPerceivedType(this); + set => this.SetPerceivedType(this, value); + } + + public Guid PersistentHandler + { + get => this.GetPersistentHandler(this); + set => this.SetPersistentHandler(this, value); + } + + [XmlAttribute] + public string ProgID + { + get => this.GetProgID(this); + set => this.SetProgID(this, value); + } + + public void Create() => this.Create(this); + + public void Delete() => this.Delete(this); + + public bool IsValid(string extension, string progId) + { + FileAssociationInfo fileAssociationInfo = new FileAssociationInfo(extension); + return fileAssociationInfo.Exists && !(progId != fileAssociationInfo.ProgID); + } + + public FileAssociationInfo(string extension) => this.extension = extension; + + public FileAssociationInfo Create(string progId) => this.Create(progId, PerceivedTypes.None, string.Empty, (string[]) null); + + public FileAssociationInfo Create( + string progId, + PerceivedTypes perceivedType) + { + return this.Create(progId, perceivedType, string.Empty, (string[]) null); + } + + public FileAssociationInfo Create( + string progId, + PerceivedTypes perceivedType, + string contentType) + { + return this.Create(progId, PerceivedTypes.None, contentType, (string[]) null); + } + + public FileAssociationInfo Create( + string progId, + PerceivedTypes perceivedType, + string contentType, + string[] openwithList) + { + FileAssociationInfo fileAssociationInfo = new FileAssociationInfo(this.extension); + if (fileAssociationInfo.Exists) + fileAssociationInfo.Delete(); + fileAssociationInfo.Create(); + fileAssociationInfo.ProgID = progId; + if (perceivedType != PerceivedTypes.None) + fileAssociationInfo.PerceivedType = perceivedType; + if (contentType != string.Empty) + fileAssociationInfo.ContentType = contentType; + if (openwithList != null) + fileAssociationInfo.OpenWithList = openwithList; + return fileAssociationInfo; + } + + protected string[] GetOpenWithList(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(file.extension).OpenSubKey("OpenWithList"); + return registryKey == null ? new string[0] : registryKey.GetSubKeyNames(); + } + + protected void SetOpenWithList(FileAssociationInfo file, string[] programList) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(file.extension, true); + if (registryKey.OpenSubKey("OpenWithList", true) != null) + registryKey.DeleteSubKeyTree("OpenWithList"); + RegistryKey subKey = registryKey.CreateSubKey("OpenWithList"); + foreach (string program in programList) + subKey.CreateSubKey(program); + ShellNotification.NotifyOfChange(); + } + + protected PerceivedTypes GetPerceivedType(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(file.extension, "PerceivedType"); + PerceivedTypes perceivedTypes = PerceivedTypes.None; + if (obj == null) + return perceivedTypes; + try + { + perceivedTypes = (PerceivedTypes) Enum.Parse(typeof (PerceivedTypes), obj.ToString(), true); + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + } + return perceivedTypes; + } + + protected void SetPerceivedType(FileAssociationInfo file, PerceivedTypes type) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + this.registryWrapper.Write(file.extension, "PerceivedType", (object) type.ToString()); + ShellNotification.NotifyOfChange(); + } + + protected Guid GetPersistentHandler(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(file.extension + "\\PersistentHandler", string.Empty); + return obj == null ? new Guid() : new Guid(obj.ToString()); + } + + protected void SetPersistentHandler(FileAssociationInfo file, Guid persistentHandler) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + if (persistentHandler == Guid.Empty) + return; + this.registryWrapper.Write(file.extension + "\\" + (object) this.PersistentHandler, string.Empty, (object) persistentHandler); + ShellNotification.NotifyOfChange(); + } + + protected string GetContentType(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(file.extension, "Content Type"); + return obj == null ? string.Empty : obj.ToString(); + } + + protected void SetContentType(FileAssociationInfo file, string type) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + this.registryWrapper.Write(file.extension, "Content Type", (object) type); + ShellNotification.NotifyOfChange(); + } + + protected string GetProgID(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(file.extension, string.Empty); + return obj == null ? string.Empty : obj.ToString(); + } + + protected void SetProgID(FileAssociationInfo file, string progId) + { + if (!file.Exists) + throw new Exception("Extension does not exist"); + this.registryWrapper.Write(file.extension, string.Empty, (object) progId); + ShellNotification.NotifyOfChange(); + } + + protected void Create(FileAssociationInfo file) + { + if (file.Exists) + file.Delete(); + Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(file.extension); + } + + protected void Delete(FileAssociationInfo file) + { + if (!file.Exists) + throw new Exception("Key not found."); + Microsoft.Win32.Registry.ClassesRoot.DeleteSubKeyTree(file.extension); + ShellNotification.NotifyOfChange(); + } + } +} diff --git a/SEGATools/Registry/PerceivedTypes.cs b/SEGATools/Registry/PerceivedTypes.cs new file mode 100644 index 0000000..27f289d --- /dev/null +++ b/SEGATools/Registry/PerceivedTypes.cs @@ -0,0 +1,19 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.PerceivedTypes +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Registry +{ + public enum PerceivedTypes + { + None, + Image, + Text, + Audio, + Video, + Compressed, + System, + } +} diff --git a/SEGATools/Registry/ProgramAssociationInfo.cs b/SEGATools/Registry/ProgramAssociationInfo.cs new file mode 100644 index 0000000..9d56b98 --- /dev/null +++ b/SEGATools/Registry/ProgramAssociationInfo.cs @@ -0,0 +1,328 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.ProgramAssociationInfo +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using Microsoft.Win32; +using System; +using System.Collections.Generic; + +namespace SEGATools.Registry +{ + public class ProgramAssociationInfo + { + private RegistryWrapper registryWrapper = new RegistryWrapper(); + protected string progId; + + public bool AlwaysShowExtension + { + get => this.GetAlwaysShowExt(); + set => this.SetAlwaysShowExt(value); + } + + public string Description + { + get => this.GetDescription(); + set => this.SetDescription(value); + } + + public EditFlags EditFlags + { + get => this.GetEditFlags(); + set => this.SetEditFlags(value); + } + + public ProgramIcon DefaultIcon + { + get => this.GetDefaultIcon(); + set => this.SetDefaultIcon(value); + } + + public ProgramVerb[] Verbs + { + get => this.GetVerbs(); + set => this.SetVerbs(value); + } + + public string ProgID => this.progId; + + public bool Exists + { + get + { + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + try + { + if (this.progId == string.Empty) + return false; + if (classesRoot.OpenSubKey(this.progId) == null) + return false; + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + return false; + } + return true; + } + } + + public void Create() + { + if (this.Exists) + return; + Microsoft.Win32.Registry.ClassesRoot.CreateSubKey(this.progId); + } + + public ProgramAssociationInfo Create(ProgramVerb verb) => this.Create(string.Empty, EditFlags.None, new ProgramVerb[1] + { + verb + }); + + public ProgramAssociationInfo Create(ProgramVerb[] verbs) => this.Create(string.Empty, EditFlags.None, verbs); + + public ProgramAssociationInfo Create(string description, ProgramVerb verb) => this.Create(description, EditFlags.None, new ProgramVerb[1] + { + verb + }); + + public ProgramAssociationInfo Create( + string description, + ProgramVerb[] verbs) + { + return this.Create(description, EditFlags.None, verbs); + } + + public ProgramAssociationInfo Create( + string description, + EditFlags editFlags, + ProgramVerb verb) + { + return this.Create(description, editFlags, new ProgramVerb[1] + { + verb + }); + } + + public ProgramAssociationInfo Create( + string description, + EditFlags editFlags, + ProgramVerb[] verbs) + { + if (this.Exists) + this.Delete(); + this.Create(); + if (description != string.Empty) + this.Description = description; + if (editFlags != EditFlags.None) + this.EditFlags = editFlags; + this.Verbs = verbs; + return this; + } + + protected bool GetAlwaysShowExt() + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + return !(Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(this.progId).GetValue("AlwaysShowExt", (object) "ThisValueShouldNotExist").ToString() == "ThisValueShouldNotExist"); + } + + protected void SetAlwaysShowExt(bool value) + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + if (value) + this.registryWrapper.Write(this.progId, "AlwaysShowExt", (object) string.Empty); + else + this.registryWrapper.Delete(this.progId, "AlwaysShowExt"); + ShellNotification.NotifyOfChange(); + } + + protected string GetDescription() + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(this.progId, string.Empty); + return obj == null ? string.Empty : obj.ToString(); + } + + protected void SetDescription(string description) + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + this.registryWrapper.Write(this.progId, string.Empty, (object) description); + ShellNotification.NotifyOfChange(); + } + + protected EditFlags GetEditFlags() + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(this.progId, "EditFlags"); + if (obj == null) + return EditFlags.None; + if (obj is byte[]) + { + int val; + if (!this.TryGetInt(obj as byte[], out val)) + return EditFlags.None; + obj = (object) val; + } + try + { + return (EditFlags) Convert.ToUInt32(obj); + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + } + return EditFlags.None; + } + + protected void SetEditFlags(EditFlags flags) + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + this.registryWrapper.Write(this.progId, "EditFlags", (object) flags); + ShellNotification.NotifyOfChange(); + } + + protected ProgramIcon GetDefaultIcon() + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + object obj = this.registryWrapper.Read(this.progId + "\\DefaultIcon", ""); + return obj == null ? ProgramIcon.None : ProgramIcon.Parse(obj.ToString()); + } + + protected void SetDefaultIcon(ProgramIcon icon) + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + if (!(icon != ProgramIcon.None)) + return; + this.registryWrapper.Write(this.progId + "\\DefaultIcon", "", (object) icon.ToString()); + ShellNotification.NotifyOfChange(); + } + + protected ProgramVerb[] GetVerbs() + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + RegistryKey registryKey1 = classesRoot.OpenSubKey(this.progId); + List programVerbList = new List(); + RegistryKey registryKey2 = registryKey1.OpenSubKey("shell", false); + if (registryKey2 != null) + { + foreach (string subKeyName in registryKey2.GetSubKeyNames()) + { + RegistryKey registryKey3 = registryKey2.OpenSubKey(subKeyName); + if (registryKey3 != null) + { + RegistryKey registryKey4 = registryKey3.OpenSubKey("command"); + if (registryKey4 != null) + { + string command = (string) registryKey4.GetValue("", (object) "", RegistryValueOptions.DoNotExpandEnvironmentNames); + programVerbList.Add(new ProgramVerb(subKeyName, command)); + } + } + } + registryKey2.Close(); + } + classesRoot.Close(); + return programVerbList.ToArray(); + } + + protected void SetVerbs(ProgramVerb[] verbs) + { + if (!this.Exists) + throw new Exception("Extension does not exist"); + RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot.OpenSubKey(this.progId, true); + if (registryKey.OpenSubKey("shell", true) != null) + registryKey.DeleteSubKeyTree("shell"); + RegistryKey subKey1 = registryKey.CreateSubKey("shell"); + foreach (ProgramVerb verb in verbs) + { + RegistryKey subKey2 = subKey1.CreateSubKey(verb.Name.ToLower()); + RegistryKey subKey3 = subKey2.CreateSubKey("command"); + subKey3.SetValue(string.Empty, (object) verb.Command, RegistryValueKind.ExpandString); + subKey3.Close(); + subKey2.Close(); + } + ShellNotification.NotifyOfChange(); + } + + protected void AddVerbInternal(ProgramVerb verb) + { + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + RegistryKey registryKey1 = classesRoot.OpenSubKey(this.progId).OpenSubKey("shell", true) ?? classesRoot.OpenSubKey(this.progId, true).CreateSubKey("shell"); + RegistryKey registryKey2 = registryKey1.OpenSubKey(verb.Name, true) ?? registryKey1.CreateSubKey(verb.Name); + RegistryKey registryKey3 = registryKey2.OpenSubKey("command", true) ?? registryKey2.CreateSubKey("command"); + registryKey3.SetValue(string.Empty, (object) verb.Command, RegistryValueKind.ExpandString); + registryKey3.Close(); + registryKey2.Close(); + classesRoot.Close(); + ShellNotification.NotifyOfChange(); + } + + protected void RemoveVerbInternal(string name) + { + RegistryKey classesRoot = Microsoft.Win32.Registry.ClassesRoot; + RegistryKey registryKey = classesRoot.OpenSubKey(this.progId).OpenSubKey("shell", true); + if (registryKey == null) + throw new RegistryException("Shell key not found"); + foreach (string subKeyName in registryKey.GetSubKeyNames()) + { + if (subKeyName == name) + { + registryKey.DeleteSubKeyTree(name); + break; + } + } + registryKey.Close(); + classesRoot.Close(); + ShellNotification.NotifyOfChange(); + } + + public void Delete() + { + if (!this.Exists) + throw new Exception("Key not found."); + Microsoft.Win32.Registry.ClassesRoot.DeleteSubKeyTree(this.progId); + } + + public void AddVerb(ProgramVerb verb) => this.AddVerbInternal(verb); + + public void RemoveVerb(ProgramVerb verb) + { + if (verb == null) + throw new NullReferenceException(); + this.RemoveVerb(verb.Name); + } + + public void RemoveVerb(string name) => this.RemoveVerbInternal(name); + + public ProgramAssociationInfo(string progId) => this.progId = progId; + + private bool TryGetInt(byte[] arr, out int val) + { + try + { + if (arr.Length == 0) + { + val = -1; + return false; + } + val = arr.Length != 1 ? BitConverter.ToInt32(arr, 0) : (int) arr[0]; + return true; + } + catch + { + } + val = 0; + return false; + } + } +} diff --git a/SEGATools/Registry/ProgramIcon.cs b/SEGATools/Registry/ProgramIcon.cs new file mode 100644 index 0000000..f5dbb6f --- /dev/null +++ b/SEGATools/Registry/ProgramIcon.cs @@ -0,0 +1,70 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.ProgramIcon +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Registry +{ + public class ProgramIcon + { + public static readonly ProgramIcon None = new ProgramIcon(); + private string path; + private int index; + + public int Index + { + get => this.index; + set => this.index = value; + } + + public string Path + { + get => this.path; + set => this.path = value; + } + + public ProgramIcon(string path, int index) + { + this.path = path; + this.index = index; + } + + public ProgramIcon(string path) + { + this.path = path; + this.index = 0; + } + + public ProgramIcon() + { + this.path = string.Empty; + this.index = 0; + } + + public override string ToString() => this.path + "," + this.index.ToString(); + + public static ProgramIcon Parse(string regString) + { + if (regString == string.Empty) + return new ProgramIcon(""); + if (regString.StartsWith("\"") && regString.EndsWith("\"") && regString.Length > 3) + regString = regString.Substring(1, regString.Length - 2); + int index = 0; + int length = regString.IndexOf(","); + if (length == -1) + length = regString.Length; + else + index = int.Parse(regString.Substring(length + 1)); + return new ProgramIcon(regString.Substring(0, length), index); + } + + public static bool operator ==(ProgramIcon lv, ProgramIcon rv) => object.ReferenceEquals((object) lv, (object) null) && object.ReferenceEquals((object) rv, (object) null) || !object.ReferenceEquals((object) lv, (object) null) && !object.ReferenceEquals((object) rv, (object) null) && (lv.path == rv.path && lv.index == rv.index); + + public static bool operator !=(ProgramIcon lv, ProgramIcon rv) => !(lv == rv); + + public override bool Equals(object obj) => this == obj as ProgramIcon; + + public override int GetHashCode() => base.GetHashCode(); + } +} diff --git a/SEGATools/Registry/ProgramVerb.cs b/SEGATools/Registry/ProgramVerb.cs new file mode 100644 index 0000000..cd2883f --- /dev/null +++ b/SEGATools/Registry/ProgramVerb.cs @@ -0,0 +1,24 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.ProgramVerb +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +namespace SEGATools.Registry +{ + public class ProgramVerb + { + private string command; + private string name; + + public string Command => this.command; + + public string Name => this.name; + + public ProgramVerb(string name, string command) + { + this.name = name; + this.command = command; + } + } +} diff --git a/SEGATools/Registry/RegistryException.cs b/SEGATools/Registry/RegistryException.cs new file mode 100644 index 0000000..46e6e67 --- /dev/null +++ b/SEGATools/Registry/RegistryException.cs @@ -0,0 +1,27 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.RegistryException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Registry +{ + public class RegistryException : ApplicationException + { + public RegistryException() + { + } + + public RegistryException(string message) + : base(message) + { + } + + public RegistryException(string message, Exception innerException) + : base(message, innerException) + { + } + } +} diff --git a/SEGATools/Registry/RegistryWrapper.cs b/SEGATools/Registry/RegistryWrapper.cs new file mode 100644 index 0000000..cb70bf4 --- /dev/null +++ b/SEGATools/Registry/RegistryWrapper.cs @@ -0,0 +1,103 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.RegistryWrapper +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using Microsoft.Win32; +using System; + +namespace SEGATools.Registry +{ + internal class RegistryWrapper + { + public object Read(string path, string valueName) + { + RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot; + string[] strArray = path.Split('\\'); + if (strArray == null || strArray.Length == 0) + return (object) null; + for (int index = 0; index < strArray.Length; ++index) + { + registryKey = registryKey.OpenSubKey(strArray[index]); + if (registryKey == null) + return (object) null; + if (index == strArray.Length - 1) + return registryKey.GetValue(valueName, (object) null, RegistryValueOptions.DoNotExpandEnvironmentNames); + } + return (object) null; + } + + public void Write(string path, string valueName, object value) + { + RegistryKey registryKey1 = Microsoft.Win32.Registry.ClassesRoot; + RegistryKey registryKey2 = registryKey1; + string[] strArray = path.Split('\\'); + if (strArray == null || strArray.Length == 0) + return; + for (int index = 0; index < strArray.Length; ++index) + { + registryKey1 = registryKey1.OpenSubKey(strArray[index], true) ?? registryKey2.CreateSubKey(strArray[index]); + if (index == strArray.Length - 1) + { + if (value is string) + registryKey1.SetValue(valueName, (object) value.ToString()); + else if (value is uint || value.GetType().IsEnum) + { + if (registryKey1.GetValue(valueName, (object) null) == null) + { + registryKey1.SetValue(valueName, value, RegistryValueKind.DWord); + } + else + { + switch (registryKey1.GetValueKind(valueName)) + { + case RegistryValueKind.String: + registryKey1.SetValue(valueName, (object) ("x" + ((uint) value).ToString("X8"))); + break; + case RegistryValueKind.Binary: + uint num = (uint) value; + byte[] numArray = new byte[4] + { + (byte) (num & (uint) byte.MaxValue), + (byte) ((num & 65280U) >> 1), + (byte) ((num & 16711680U) >> 2), + (byte) ((num & 4278190080U) >> 3) + }; + numArray[0] = (byte) (num & (uint) byte.MaxValue); + numArray[1] = (byte) ((num & 65280U) >> 8); + numArray[2] = (byte) ((num & 16711680U) >> 16); + numArray[3] = (byte) ((num & 4278190080U) >> 24); + registryKey1.SetValue(valueName, (object) numArray, RegistryValueKind.Binary); + break; + case RegistryValueKind.DWord: + registryKey1.SetValue(valueName, value, RegistryValueKind.DWord); + break; + } + } + } + else if (value is Guid guid) + registryKey1.SetValue(valueName, (object) guid.ToString("B")); + } + registryKey2 = registryKey1; + } + registryKey1?.Close(); + } + + public void Delete(string path, string valueName) + { + RegistryKey registryKey = Microsoft.Win32.Registry.ClassesRoot; + string[] strArray = path.Split('\\'); + if (strArray == null || strArray.Length == 0) + return; + for (int index = 0; index < strArray.Length; ++index) + { + registryKey = registryKey.OpenSubKey(strArray[index], true); + if (registryKey == null) + break; + if (index == strArray.Length - 1) + registryKey.DeleteValue(valueName, false); + } + } + } +} diff --git a/SEGATools/Registry/ShellNotification.cs b/SEGATools/Registry/ShellNotification.cs new file mode 100644 index 0000000..d07f217 --- /dev/null +++ b/SEGATools/Registry/ShellNotification.cs @@ -0,0 +1,66 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Registry.ShellNotification +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; +using System.Runtime.InteropServices; + +namespace SEGATools.Registry +{ + internal class ShellNotification + { + [DllImport("shell32.dll")] + private static extern void SHChangeNotify( + uint wEventId, + uint uFlags, + IntPtr dwItem1, + IntPtr dwItem2); + + public static void NotifyOfChange() => ShellNotification.SHChangeNotify(134217728U, 8192U, IntPtr.Zero, IntPtr.Zero); + + [Flags] + private enum ShellChangeNotificationEvents : uint + { + SHCNE_RENAMEITEM = 1, + SHCNE_CREATE = 2, + SHCNE_DELETE = 4, + SHCNE_MKDIR = 8, + SHCNE_RMDIR = 16, // 0x00000010 + SHCNE_MEDIAINSERTED = 32, // 0x00000020 + SHCNE_MEDIAREMOVED = 64, // 0x00000040 + SHCNE_DRIVEREMOVED = 128, // 0x00000080 + SHCNE_DRIVEADD = 256, // 0x00000100 + SHCNE_NETSHARE = 512, // 0x00000200 + SHCNE_NETUNSHARE = 1024, // 0x00000400 + SHCNE_ATTRIBUTES = 2048, // 0x00000800 + SHCNE_UPDATEDIR = 4096, // 0x00001000 + SHCNE_UPDATEITEM = 8192, // 0x00002000 + SHCNE_SERVERDISCONNECT = 16384, // 0x00004000 + SHCNE_UPDATEIMAGE = 32768, // 0x00008000 + SHCNE_DRIVEADDGUI = 65536, // 0x00010000 + SHCNE_RENAMEFOLDER = 131072, // 0x00020000 + SHCNE_FREESPACE = 262144, // 0x00040000 + SHCNE_EXTENDED_EVENT = 67108864, // 0x04000000 + SHCNE_ASSOCCHANGED = 134217728, // 0x08000000 + SHCNE_DISKEVENTS = SHCNE_RENAMEFOLDER | SHCNE_UPDATEITEM | SHCNE_UPDATEDIR | SHCNE_ATTRIBUTES | SHCNE_RMDIR | SHCNE_MKDIR | SHCNE_DELETE | SHCNE_CREATE | SHCNE_RENAMEITEM, // 0x0002381F + SHCNE_GLOBALEVENTS = SHCNE_ASSOCCHANGED | SHCNE_EXTENDED_EVENT | SHCNE_FREESPACE | SHCNE_DRIVEADDGUI | SHCNE_UPDATEIMAGE | SHCNE_DRIVEADD | SHCNE_DRIVEREMOVED | SHCNE_MEDIAREMOVED | SHCNE_MEDIAINSERTED, // 0x0C0581E0 + SHCNE_ALLEVENTS = 2147483647, // 0x7FFFFFFF + SHCNE_INTERRUPT = 2147483648, // 0x80000000 + } + + private enum ShellChangeNotificationFlags + { + SHCNF_IDLIST = 0, + SHCNF_PATHA = 1, + SHCNF_PRINTERA = 2, + SHCNF_DWORD = 3, + SHCNF_PATHW = 5, + SHCNF_PRINTERW = 6, + SHCNF_TYPE = 255, // 0x000000FF + SHCNF_FLUSH = 4096, // 0x00001000 + SHCNF_FLUSHNOWAIT = 8192, // 0x00002000 + } + } +} diff --git a/SEGATools/SEGATools.csproj b/SEGATools/SEGATools.csproj new file mode 100644 index 0000000..e97ed10 --- /dev/null +++ b/SEGATools/SEGATools.csproj @@ -0,0 +1,229 @@ + + + + + Debug + AnyCPU + {4D3AB913-88D2-4DD1-A403-EA46D14C98E6} + Library + SEGATools + v3.5 + 1.0.3.0 + 512 + SEGATools + + + + + 3.5 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\GD-ROM Explorer\packages\log4net.2.0.12\lib\net35\log4net.dll + + + + + + + + + + + + + + + + + + UserControl + + + Component + + + + + Component + + + + + + + + + + + + + Component + + + + + + + Component + + + Component + + + Component + + + + Component + + + + Component + + + + + + + + Component + + + + + + + + + + + + + + UserControl + + + UserControl + + + UserControl + + + + UserControl + + + + + + + + + + + + + + + UserControl + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Component + + + + + + + + + + + + + UserControl + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {2185f55e-a4da-486f-acc8-3ee955205ce4} + ImageReader + + + + \ No newline at end of file diff --git a/SEGATools/Scanner/FileScanner.cs b/SEGATools/Scanner/FileScanner.cs new file mode 100644 index 0000000..6309fda --- /dev/null +++ b/SEGATools/Scanner/FileScanner.cs @@ -0,0 +1,175 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Scanner.FileScanner +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.UserProcess; +using SEGATools.VirtualFile; +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; + +namespace SEGATools.Scanner +{ + public class FileScanner : UserProcessBase + { + private static readonly int MAX_ASCII_STRING_LENGTH = 128; + + public event AsyncOperationProgressChangedEventHandler FileScanningProgressChanged + { + add => this.AsyncOperationProgressChanged += value; + remove => this.AsyncOperationProgressChanged -= value; + } + + public event AsyncOperationCompletedEventHandler FileScanningCompleted + { + add => this.AsyncOperationCompleted += value; + remove => this.AsyncOperationCompleted -= value; + } + + public FileScanner() + { + } + + public FileScanner(IContainer container) + : base(container) + { + } + + public List ScanFile( + IVirtualFile file, + FileScannerPattern pattern, + IFileScannerResultConverter resultConverter) + { + return this.DoFileScanning(file, new List() + { + pattern + }, resultConverter, (AsyncOperation) null)[pattern]; + } + + public void ScanFileAsync( + IVirtualFile file, + FileScannerPattern pattern, + IFileScannerResultConverter resultConverter, + object taskId) + { + this.ScanFilesAsync(file, new List() + { + pattern + }, resultConverter, taskId); + } + + public void ScanFileAsync( + IVirtualFile file, + List patterns, + IFileScannerResultConverter resultConverter, + object taskId) + { + this.ScanFilesAsync(file, patterns, resultConverter, taskId); + } + + public void ScanFilesAsync( + IVirtualFile file, + List patterns, + IFileScannerResultConverter resultConverter, + object taskId) + { + AsyncOperation asyncOperation = this.CreateAsyncOperation(taskId); + new FileScanner.FileScannerWorkerEventHandler(this.FileScannerWorker).BeginInvoke(file, patterns, resultConverter, asyncOperation, (AsyncCallback) null, (object) null); + } + + private void FileScannerWorker( + IVirtualFile file, + List patterns, + IFileScannerResultConverter resultConverter, + AsyncOperation asyncOp) + { + Exception exception = (Exception) null; + try + { + this.CheckArguments(file, patterns); + this.DoFileScanning(file, patterns, resultConverter, asyncOp); + } + catch (Exception ex) + { + exception = ex; + UserProcessBase.logger.DebugFormat("Unable to scan file {0}: {1}", (object) file.VirtualName, (object) ex); + } + if (!this.TaskCanceled(asyncOp)) + ; + this.ReportCompletion(string.Empty, exception, asyncOp); + } + + private void CheckArguments(IVirtualFile file, List patterns) + { + if (patterns == null || patterns.Count == 0) + throw FileScannerWrongArgumentsException.aNotValidArgument(nameof (patterns)); + if (file == null || file.FileInputStream == null) + throw FileScannerWrongArgumentsException.aNotValidArgument(nameof (file)); + } + + private Dictionary> DoFileScanning( + IVirtualFile file, + List patterns, + IFileScannerResultConverter resultConverter, + AsyncOperation asyncOp) + { + Dictionary> dictionary = new Dictionary>(patterns.Count); + foreach (FileScannerPattern pattern in patterns) + dictionary[pattern] = new List(); + UserProcessBase.logger.DebugFormat("Scanning {0}...", (object) file.VirtualName); + foreach (FileScannerPattern pattern in patterns) + { + using (BinaryReader binaryReader = new BinaryReader(file.FileInputStream, Encoding.ASCII)) + { + binaryReader.BaseStream.Seek(0L, SeekOrigin.Begin); + while (binaryReader.BaseStream.Position < binaryReader.BaseStream.Length) + { + try + { + int count = Math.Min(Convert.ToInt32(binaryReader.BaseStream.Length - binaryReader.BaseStream.Position), FileScanner.MAX_ASCII_STRING_LENGTH); + string input = new string(binaryReader.ReadChars(count)); + if (pattern.Match(input)) + { + UserProcessBase.logger.DebugFormat("Found string for pattern {0}: {1}", (object) pattern, (object) pattern.CapturedString); + T obj = this.ConvertResult(pattern.MatchResult, resultConverter); + if ((object) obj != null) + dictionary[pattern].Add(obj); + } + else if (count > 0) + binaryReader.BaseStream.Seek((long) (-count + 1), SeekOrigin.Current); + } + catch (OverflowException ex) + { + UserProcessBase.logger.ErrorFormat("Unable to compute the number of remaining bytes in the stream: {0}", (object) ex); + } + } + } + } + return dictionary; + } + + private T ConvertResult(Match match, IFileScannerResultConverter resultConverter) + { + try + { + return resultConverter.ToResult(match); + } + catch (FileScannerResultConverterException ex) + { + UserProcessBase.logger.ErrorFormat("Unable to convert match result with to {0}: {1}", (object) resultConverter.GetType().AssemblyQualifiedName, (object) ex); + } + return default (T); + } + + private delegate void FileScannerWorkerEventHandler( + IVirtualFile file, + List patterns, + IFileScannerResultConverter resultConverter, + AsyncOperation asyncOp); + } +} diff --git a/SEGATools/Scanner/FileScannerException.cs b/SEGATools/Scanner/FileScannerException.cs new file mode 100644 index 0000000..3a22ce9 --- /dev/null +++ b/SEGATools/Scanner/FileScannerException.cs @@ -0,0 +1,23 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Scanner.FileScannerException +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using System; + +namespace SEGATools.Scanner +{ + public class FileScannerException : Exception + { + protected FileScannerException(string message) + : base(message) + { + } + + protected FileScannerException(string message, Exception innerException) + : base(message, innerException) + { + } + } +} diff --git a/SEGATools/Scanner/FileScannerPattern.cs b/SEGATools/Scanner/FileScannerPattern.cs new file mode 100644 index 0000000..fcb4837 --- /dev/null +++ b/SEGATools/Scanner/FileScannerPattern.cs @@ -0,0 +1,46 @@ +// Decompiled with JetBrains decompiler +// Type: SEGATools.Scanner.FileScannerPattern +// Assembly: SEGATools, Version=1.0.3.0, Culture=neutral, PublicKeyToken=611be24fdeb07e08 +// MVID: D631183F-57B1-40A1-B502-5364D288307A +// Assembly location: SEGATools.dll + +using SEGATools.Binary; +using System; +using System.Text.RegularExpressions; + +namespace SEGATools.Scanner +{ + public sealed class FileScannerPattern + { + private static readonly string SEGA_IP_LIBRARIES = "^(?\\w+)\\s(ver|version:)\\s(?\\d+)(\\.)(?\\d+)(\\s|\\x00\\k\\s)(build:)(?\\w{3}\\s\\d{2}\\s\\d{4})\\s?(?

CZuB#njG2pmfATvEcViSW zBFr;qU>Ng<{bnse(^hR!tau5-{~XHqKh0d;H(l{spLu9Gd>Y10nhYP`*(MIJe7^E3 zs>uIue}%FQ9Y4 zdFBAl(Fce^|9z3P|0Br%Q{?|iqx;A2<~(g;3NekCN%-tOg*iND!M+H}fe5T%UGZx6 z6s-?Bjm^Ok_#^lfc7&XwEQr9KL#MIla3uE7&fb0W9A^*Hhdq9YJ^PojJ3JP9PQ_s_ zdv^D;Z|}gl1O&5}=g`HgMg|;@roN*MAQ=!DmxQzQ0hI5*%y^&t{ls*S-lzG`d6S?W z;E@4L1t5WTKpcGm^=7C)>n|~ZtBeUGupWT2Xu^`U__2K#6fME{U*3Gk&l;c?C<{LP zsvf>>*&g3AH}F-9_W1Cd@A1a_A5#vzXkr3)G3NaMZG%@TeuNtB`=I-p{TO>9nRABH zp&0|ysSjpQ){a}a3hg@niW0At^w|E?|MwJn9*@;%j(56@MaSV>ACECL^-s$7SKYMq zy!?I3Bgp_kK9hPYrGMpji_fYDk`C7#2IcbPBU>Ix7Ko3({PK(8tn&HF8_JiL9U#c( zSKLqhtyQa*nK`a&NQX-XsaIQd2$Bto^UDUXuXolZDHkc3U)?(SFJI^k zYeB*&lMZL{KOi&z=j4AK>i^2r|HMD9|LF)a7n8%)d07cp)3Nnj{ddfB%}q&qW^G3L z2aE%19=L4KQ@p=+(jS<@`=GUWPy9met3Jelyl*X#^9JO7Yw|q{v>jU0er(O$q6Zn= zrW2_|GI5oNC*p`0v^gG4u)m*ZM~<~4|J#%Q9mxNV0?%P1?Tk%)&&?qh;dkf~ws0obR?4bBIIHJR&gj_5Uj5zd z*WJgSJ%92)korI5IvGGeAT|jRS5go~QlDp%HJSo8mcD*Gl|D;=Ox}g!02BuX+Ru^! zeBN6In3w=<0nKgrGc*d5m##$<@&6U({}`Vy@&fDZYt%-!u`@7n!!Atr^T(KVyU>qy z0?qpWj*2zDM&V+w82{kDJP+W>qOUMV*cct?=Z_BIyusrs#ui-8oY2}6m#}F4R`lU4 zgi>#n!JYIga@|GaCtq8(zie*V?TY1#|4zui*IWg~@5Ei{ zUDXMz?pF2uvJdn+%Qwvo6CV}FlfG6yUmO!-a$!Eoy#DB$|mhm1?KB$AZPVQ^n z0Of_+@jL@Q*G?e!+mZ8GAn)6qu*l$k8j(tH4T}?rL_85k#1PSF&-<*yiHqn+{&!;R zPxzJb|IW<+bz%O$%fXB2N^}e6T7aAZ*dvg0fQX))2h@vmL3;aNKp$ej{__~J_bf*2 ziNxq#r!ackas0k11S8i4V8qHj7`|)=hA!TQAq%!*$b3Hxp1TQyXKyeVGJ7M2aDS-p z1`P9AkKsP+FoN5WzUwiH$4AfIh%pN`WBlSRtbyN(Nh|)ql$BdCb=6kPShE#A>;Ayp zjelaH-!3fQz7K162QtoZ6uUXEJS6fG`+XP-pmTL0*^SH8>B_fA)>;{0>;TFD>kDMb z0G=lqa9vz5iN6nJ!0xapOk1`VKXvf%KR@&T#i;wgYTO(X*KqBVh&XJDyoxm^<4mo< zkR_Y()z2MKyli>oRW6V5fJdGxg0j`VLYt{eG3LNIOgf%qX8S50xqsCV7kcGQRIK?ey7um8e01g2?W`Z^UB&SgLld;G8ePpzu)e(XzBp)W zffYN{>!i0W-(%STyc7 z6b(A`#W$_Gp$_Y0zx<&!YJT4eHCf+Mqd`klulEzGF*g2b?eDYj+1EetSYv$gT~pL* z)B<1q&=R#9x8$}tYBg+%+TZ_#Z<@3~!RVVWTl}`fT{F+K3JN*k?!? zpgRAvtns;+Oinvw089U_*#X)30xS!@J~zPEpQa4h7aoO~%h#cK$1W(w+MEIfA4Bm{ zZ{geKZQ!$o>mOW7#SZonZo80*O$_W#{UZ?Hcj=2aDt(BD9xdqM|C3Ln?5AI%&E!QG z#~$mMEIwMpdq6oy^(Y;PIFHH8)}dUDZ*WI}C*is`x5+O&RPYIuD*Fz8Y17vD^s4n! zj$b^N-W886|E0%e8z{!7IvvI7#aroZ_3KE#>v^lUEqBC!$rbhW$bJ`Zov`@>_3&v{ zlY9@w4D9P=$BTEeJGAzbt@m?YL;K>tuCIP!{12o3e?+}M z9{=By|G(z{|GVvf{=NFAxnQ|ml^fM`4c;}4GQeN;fR$JeIFPzqv)!bRlyg?Esp3H$ zsPj9L`<==8F66uc`QAk!=M5M;?qZO^t&m2f5XnR$kwCGdo-fPTMXFS7sj-8J$jh_U*5CV@n6@laXYQ=qW6^SvAng{ksQ%X5XBJ{ zYqWabUQgFif3ao&Xx4~*{jIk4`p&KX1}BnO%a}|*;4(j#;u)djzh+kl|L^kOGZ(1z z=cQf0%=pp6d8j~hOW{V6A<-eA?8&ti{27xG@*?@I1>Bj>x3^H~Vx zzJVLv!i01pjYuJqh^s^b!F8;{VhGNwBJaBq-H9ILe-HBiH}bzH`QMA&?@ja}|ND~v z{m6ZxKlwj^{2xf}3xml2!Q}ry+Wh_gJcV}ix8b`1lTo!rSCsvt9$sawYtc8~VQuW| zjC&PBLDs-O%-WcItb@&)zW^S{$DB}J*2OYzmPepno11a*-1LicF^--qcP6w?n z5A$j|FAwW#@{&XOsYeSx{~~2cIlN!32I~CS0xi4uMelJ_89U=#u`OH=F8Bljqhi_P zmx>7TUpZFg_-`fy(%qhTfaHMWf@FYfG9v>h2RI@C!Kcn*?#lJ}<=1W~&iGtj>ea`e zDvZ+Q-$UcJ^vy?3K(BGr(PhL0{M4;4KL4&UUVfttb-(fe_p)B_A-wd~+o;*RJqE7a zfu&3`{Bbc2hp78iixA0L#CfOF(cJGeiuPUr*JnQ?$5Suk4*J}xD|mqVTl|x6-MMpT zQ>&wz9M$<~?vA)CZg=R=!T9Hj`AO%?|CSA)_`Tu*I#=9v@<#jOtzwF*)e%1}U+q@5 zymWfEZrzOiVCxMmZ!IqsQ_yEpFOlK|l0S+Y*z3p-Q4CUjOZv?A^|#vE>pQpl+|HPX zp3`-r`57W)N@6jt57?VLSH4O7 zS1dq2!C=||y~KHPzdN@*$oDLe^F1uWGteVEjYuJqh^s_AafOH_IG2k2?-6zhzmfYr z>HGH*7+3Gj96+C=m(cgfCG;cuAHIYEjJpjy=)s^6)~W?xVy@bQ!T#qlXwMn+SQ~_2 zX0At_9-~mcc4NF$t}+TfTa^8<>^o)6+r8wm>SFG^>+Y;tIR5onzyB@w<#W2&lwrOb7eamJQanxE7qV@$If_} z`ad^g+p5nm{Ot26_x=a?^s8@B{o984gxj+3e~1@Llw_aoqsH!+@Bes_XYqcmZ}9Wr zahUYyVQl71zu>qG^Z6uaRA-5sh9%Z}Pu4`QL}! z?@R9YBl?s71IYgYb~J0|F?0+9d}ZG+{3!sCrmEA{O4bxHsfe5`j0~Q z$#WS`T#Iq5{=kea`>|l}5v*eV&@Ys^!qc&w>zBZp9-Q$LmyQ$c=?f?SRck33p!%M_ zBLgHCXp$qIh~@8c=wu{jFIj;WZQ7$KYvAsoPS45u9@*yd1sd3Xcxhgp&1I z%uVTvVNn{AktSN}tNsR^DB;H}+iR>6N?Jj8M(%k=-wD*qR$} z{>yhzy`Gc*(%p(5>iUumvL6(8xDo$#P30q%UsR4j^8=KBu=j#Ko35|e^QG$ zdm~%^v!+;mp`l*<&x-%ICjT4MMxAOOpz^!_A^y8uT5J4%SEYuvTmyDYcTGO+?^>Lm zR&l%A-S?Q=tzL7*p~HEKyzfKa_u;w}9%OKvMx+u+#8o1mxI%DF z-O08k4}FA!Pe03^nz!)w zr!`TdSvxczI0k*@tit%s`!SbuNtV-ZS;xO|b7TUxlhC^_rNRHQ8-cN`*{2SbJ*{|} zW-O?;PqBOD@nm0F8KC&SZ0;;OfL#BJ9pLu(0!9Xq|Hn>8VbQ9!=-BNylzq3n>C2aH zeux}s$i6AqrY3QI#G@aNeCuoTm9U$%w% z4ae~}F8?RjgIu13C+D8U>*IEyR@Y(pu0cb*#~hw&@(LF&Z0hf1&&#&=hGc_m1kL`D zd{FO>cqX0gtP>PxoIH}=R6am41=$nI87lX$e81jHH9V>#&~+4NuycE}lL6wbt}h=$ z=c}GreAj2yH6@dDeOo(dd7ji?bX$^RMte|3%j z@BRn$zsq$8`G1$|t!i(%T1{`}8oGa}Yo4hG$WT3i`hs*%>fV&jTF6vz{1<*F|3{PmW61xp0{Q>j^4<7;z$Co;Wdl6SzPEes%gxx%HNVcv z_rJY0_Wqr$qbrE#O1^~(wK$u#>i~3^G#^7&?ZBj+N1@*PC5&UP=A7;gH0J%zr83T* zX5#Id-L;>(^Z+@eehS&qhsl4{@T;Fkb$s%#tPJ3|PgC!!*q**`#rm%E1t<%$;sKNa z)((g`cM+Sm@5G2P6Yx#_hIseAN+@0K9h53vmMDYQxqZFN+bGHHtIXe*dix!`Q~5(E zKG?4RaMlj5!;%AGCdPM^Z>pGrOo}(YVEIli>{#5%n;O`v<}_I&BPG$QU1Q2 z$*CB=;(E&Ei|>l3NvDcmw%$&&w#0j_v7nf~bg}$<>3-Sg-n-DqazK)5<;-O@Oa+I1KAiqS{QQwbZ7`mS1jGnjW>orc;<4!r{ z{kgp#U(bKVL}~w%|LXq>;H)ac|DK-tA1xdF$N5ic@ZXQWKS{jf>g_kgH8VQwfyGI& zPjQ{#HX*DD<~=O#8$W>eu`g=^MsqC+%l(0;GBD^=8o?g2Q^`akkw9D_;)oc7!KW@` zF!?`3pdT@sW3FJt(L%NTLogORKO9(D9GerKJHF#7Oij3LHq9ZX^zX9108jmm^z z54tbfj&HjT#Ty?~XYbpCS@s z0KZ$s16AWEn_DtK_P3D%lmpWBf3X8(8}RtWm@5c6d>qTyvTkA2Xmsq_1FabgXxXkK znz!wMW(FP6v`t4eY0byXO)4+ZckDFG+OPxbS>LFcFa+t6XkB8>G}VCsFOM-|&sUQO{m@kw#Oci(;2=+?6I0V-CkXl8OrPRNGW zYhzn+cYK_!4;N-mbes=oaes*!+etvsQ=j$35FJ7SiPyX}$4gU{c zPk2hmz+iHJNCbPwI1hd(Z|I>B3B(nG>sA}YU>IeP9ME(ntDFb?QCRL+eV^Fs0SB&%JH?NOWJg8Kbrz!F1LhYdx+dk*Qq&DueuYoAr}6kpEgkQS&%7mqWR; z-Gq86)Tb*uS~h_E0OeDSA3(nGQl`er$^h#Jn4Ex>0pz1}d=5Hz7DnTBpCkBb>S~Of>VsKx=bM@wyY89vrE2ap-(UPz zjNPuAB0a0Tn_}vk@1eSU)doth+ZqA!-zfu}{LyjA3B~TD=QZa?^+39wW`4=%mrl1F z^X97eW1Xk>RgHjNufIX{KDw^@7E~von4`{fUeiAI*6rSW*JpSBJ$l~0R)4ep_U!rJ z)x&@G|Cson{Qv(T{~3qL!5-{8Tm!aMbah?!n`>n7dintgTqhu{&VILhI&DGqqe(}| zf87}E#<(+FkCtmwiTlII{SnL?kDx6)g7xqtPR9{396vz_?>=$Fq-S#jbvl6?~D zl~7(}J^8|hli6p?eq+uTJrjG?%osj-IRRmpnRj3>g8C8Emvr