private bool[,] ProcessImage(Func <bool[, ], bool[, ]> imageDataProcessor, FirmwareImageMetadata imageMetadata, bool rebuildCache = false)
{
var processedData = imageDataProcessor(ImagePixelGrid.Data);
var processedImageSize = processedData.GetSize();
var imageSizeChanged = imageMetadata.Width != processedImageSize.Width || imageMetadata.Height != processedImageSize.Height;
imageMetadata.Width = (byte)processedImageSize.Width;
imageMetadata.Height = (byte)processedImageSize.Height;
m_firmware.WriteImage(processedData, imageMetadata);
if (imageSizeChanged || rebuildCache)
{
ImageCacheManager.RebuildImageCache(m_firmware);
ImageListBox.Invalidate();
}
else
{
var cachedImage = FirmwareImageProcessor.CreateBitmap(processedData);
ImageCacheManager.SetImage(imageMetadata.Index, imageMetadata.BlockType, cachedImage);
var updateCache = new Action(() =>
{
ImageListBox.Invoke(new Action(() =>
{
var itemRect = ImageListBox.GetItemRectangle(imageMetadata.Index - 1);
ImageListBox.Invalidate(itemRect);
}));
});
updateCache.BeginInvoke(null, null);
}
return(processedData);
}
public PreviewResourcePackWindow
(
Firmware firmware,
IList <int> originalImageIndices,
IList <bool[, ]> importedImages,
bool resourceImport = false,
BlockType?defaultImportBlock = null
) : this()
{
if (originalImageIndices.Count != importedImages.Count)
{
throw new InvalidOperationException("Source and imported images count does not match.");
}
m_firmware = firmware;
if (m_firmware.Block2Images.Any())
{
ImportModeComboBox.Items.Add("Block 1 & 2");
ImportModeComboBox.Items.Add("Block 1");
ImportModeComboBox.Items.Add("Block 2");
if (defaultImportBlock.HasValue)
{
ImportModeComboBox.SelectedIndex = defaultImportBlock == BlockType.Block1 ? 1 : 2;
}
else
{
ImportModeComboBox.SelectedIndex = 0;
}
}
else
{
ImportModeComboBox.Items.Add("Block 1");
ImportModeComboBox.SelectedIndex = 0;
}
OptionsGroupBox.Enabled = !resourceImport;
LeftLayoutPanel.SuspendLayout();
RightLayoutPanel.SuspendLayout();
for (var i = 0; i < originalImageIndices.Count; i++)
{
var originalImageIndex = originalImageIndices[i];
var originalImage = GetImageByIndex(originalImageIndex);
if (originalImage == null)
{
continue;
}
var importedImage = importedImages[i];
var croppedImportedImage = FirmwareImageProcessor.PasteImage(originalImage, importedImage);
m_originalImportedImages[i] = importedImage;
m_croppedImportedImages[i] = croppedImportedImage;
LeftLayoutPanel.Controls.Add(CreateGrid(originalImage));
RightLayoutPanel.Controls.Add(CreateGrid(croppedImportedImage));
}
LeftLayoutPanel.ResumeLayout();
RightLayoutPanel.ResumeLayout();
}
private void RotateAntiClockwiseButton_Click(object sender, EventArgs e)
{
if (LastSelectedImageMetadata == null)
{
return;
}
ImagePixelGrid.Data = ImagePreviewPixelGrid.Data = ProcessImage(x => FirmwareImageProcessor.Rotate(x, false), LastSelectedImageMetadata);
}
internal static Size GetSize([NotNull] this bool[,] imageData)
{
if (imageData == null)
{
throw new ArgumentNullException("imageData");
}
return(FirmwareImageProcessor.GetImageSize(imageData));
}
private void ImportBlockImage(IDictionary <int, FirmwareImageMetadata> blockMetadataDictionary, int imageIndex, bool[,] importedImage, bool allowResizeOriginalImages)
{
FirmwareImageMetadata imageMetadata;
if (!blockMetadataDictionary.TryGetValue(imageIndex, out imageMetadata))
{
return;
}
if (allowResizeOriginalImages)
{
ProcessImage(x => importedImage, imageMetadata);
}
else
{
ProcessImage(x => FirmwareImageProcessor.PasteImage(imageMetadata.CreateImage(), importedImage), imageMetadata);
}
}
private void ImportResourcePack([NotNull] IList <int> originalImageIndices, [NotNull] IList <bool[, ]> importedImages)
{
if (importedImages == null)
{
throw new ArgumentNullException("importedImages");
}
if (originalImageIndices == null)
{
throw new ArgumentNullException("originalImageIndices");
}
if (importedImages.Count == 0)
{
return;
}
for (var i = 0; i < originalImageIndices.Count; i++)
{
var originalImageIndex = originalImageIndices[i];
var importedImage = importedImages[i];
if (m_firmware.Block1Images.Count > 0)
{
FirmwareImageMetadata block1ImageMetadata;
if (m_firmware.Block1Images.TryGetValue(originalImageIndex, out block1ImageMetadata))
{
var block1Image = FirmwareImageProcessor.PasteImage(block1ImageMetadata.CreateImage(), importedImage);
m_firmware.WriteImage(block1Image, block1ImageMetadata);
}
}
if (m_firmware.Block2Images.Count > 0)
{
FirmwareImageMetadata block2ImageMetadata;
if (m_firmware.Block2Images.TryGetValue(originalImageIndex, out block2ImageMetadata))
{
var block2Image = FirmwareImageProcessor.PasteImage(block2ImageMetadata.CreateImage(), importedImage);
m_firmware.WriteImage(block2Image, block2ImageMetadata);
}
}
}
IsDirty = true;
ImageCacheManager.RebuildCache(m_firmware);
}
private void ResizeButton_Click(object sender, EventArgs e)
{
if (LastSelectedImageMetadata == null)
{
return;
}
using (var rw = new ResizeImageWindow(LastSelectedImageMetadata.Width, LastSelectedImageMetadata.Height))
{
if (rw.ShowDialog() != DialogResult.OK)
{
return;
}
var newSize = rw.NewSize;
ProcessImage(x => FirmwareImageProcessor.ResizeImage(x, newSize), LastSelectedImageMetadata, true);
ImageListBox_SelectedValueChanged(ImageListBox, EventArgs.Empty);
}
}
private void UpdateStringPreview()
{
if (LastSelectedStringMetadata == null)
{
return;
}
var stringData = m_firmware.ReadString(LastSelectedStringMetadata);
var charsData = new Dictionary <int, bool[, ]>();
foreach (var b in stringData)
{
if (charsData.ContainsKey(b))
{
continue;
}
FirmwareImageMetadata imageMetadata;
if (!CurrentImageBlockForStrings.TryGetValue(b, out imageMetadata))
{
continue;
}
charsData[b] = m_firmware.ReadImage(imageMetadata);
}
var imageData = FirmwareImageProcessor.GetStringImageData(stringData, charsData,
m_firmware.Definition.StringsPreviewCorrection != null ? m_firmware.Definition.StringsPreviewCorrection.ForGlyphs : null);
var imageDataSize = imageData.GetSize();
StringPrewviewPixelGrid.Data = imageData;
StringStatusLabel.Text = string.Format
(
"String: 0x{0:X2}, Size: {1}x{2}, Data: 0x{3:X4}, Length: {4} bytes",
LastSelectedStringMetadata.Index,
imageDataSize.Width,
imageDataSize.Height,
LastSelectedStringMetadata.DataOffset,
LastSelectedStringMetadata.DataLength
);
}
public IList <Tuple <FirmwareImageMetadata, bool[, ]> > GetImportedData()
{
var result = new List <Tuple <FirmwareImageMetadata, bool[, ]> >();
using (var surface = DrawSurfaceInRealScale())
{
foreach (var letterBox in m_letters)
{
var metadata = letterBox.Metadata;
var rect = letterBox.Rect;
var cropRect = new Rectangle(rect.X + 1, rect.Y + 1, rect.Width - 1, rect.Height - 1);
using (var croppedLetter = FirmwareImageProcessor.CropImage(surface, cropRect))
{
var imageData = croppedLetter.CreateRawFromBitmap(0x00);
result.Add(new Tuple <FirmwareImageMetadata, bool[, ]>(metadata, imageData));
}
}
}
return(result);
}
private void ImportResourcePack([NotNull] IList <int> originalImageIndices, [NotNull] IList <bool[, ]> importedImages)
{
if (importedImages == null)
{
throw new ArgumentNullException("importedImages");
}
if (originalImageIndices == null)
{
throw new ArgumentNullException("originalImageIndices");
}
if (importedImages.Count == 0)
{
return;
}
var block1MetadataDictionary = m_firmware.Block1Images.ToDictionary(x => x.Index, x => x);
var block2MetadataDictionary = m_firmware.Block2Images.ToDictionary(x => x.Index, x => x);
for (var i = 0; i < originalImageIndices.Count; i++)
{
var originalImageIndex = originalImageIndices[i];
var importedImage = importedImages[i];
if (block1MetadataDictionary.Count > 0)
{
var block1ImageMetadata = block1MetadataDictionary[originalImageIndex];
var block1Image = FirmwareImageProcessor.PasteImage(block1ImageMetadata.CreateImage(), importedImage);
m_firmware.WriteImage(block1Image, block1ImageMetadata);
}
if (block2MetadataDictionary.Count > 0)
{
var block2ImageMetadata = block2MetadataDictionary[originalImageIndex];
var block2Image = FirmwareImageProcessor.PasteImage(block2ImageMetadata.CreateImage(), importedImage);
m_firmware.WriteImage(block2Image, block2ImageMetadata);
}
}
ImageCacheManager.RebuildImageCache(m_firmware);
}
private void UpdateStringPreview()
{
if (LastSelectedStringMetadata == null)
{
return;
}
var firmwareString = m_firmware.ReadString(LastSelectedStringMetadata);
var charMetadatas = new List <FirmwareImageMetadata>();
foreach (var charIndex in firmwareString)
{
var metadata = CurrentImageBlockForStrings.FirstOrDefault(x => x.Index == charIndex);
if (metadata != null)
{
charMetadatas.Add(metadata);
}
}
var images = new List <bool[, ]>();
foreach (var charMetadata in charMetadatas)
{
var image = m_firmware.ReadImage(charMetadata);
if (m_firmware.Definition.CharsToCorrect != null && m_firmware.Definition.CharsToCorrect.Contains((byte)charMetadata.Index))
{
var imageSize = image.GetSize();
image = FirmwareImageProcessor.ResizeImage(image, new Size(imageSize.Width, imageSize.Height + 2));
image = FirmwareImageProcessor.ShiftDown(image);
image = FirmwareImageProcessor.ShiftDown(image);
}
images.Add(image);
}
var data = FirmwareImageProcessor.MergeImages(images);
var dataSize = data.GetSize();
StringPreviewImageSizeLabel.Text = dataSize.Width + @"x" + dataSize.Height;
StringPrewviewPixelGrid.Data = data;
}
private void BitmapImportButton_Click(object sender, EventArgs eventArgs)
{
if (LastSelectedImageMetadata == null)
{
return;
}
using (var op = new OpenFileDialog {
Filter = Consts.BitmapImportFilter
})
{
if (op.ShowDialog() != DialogResult.OK)
{
return;
}
try
{
var bitmapFile = op.FileName;
using (var bitmap = (Bitmap)Image.FromFile(bitmapFile, true))
{
if (bitmap.Width > Consts.MaximumImageWidthAndHeight || bitmap.Height > Consts.MaximumImageWidthAndHeight)
{
InfoBox.Show("Image is too big. Image width and height must be lower or equals to {0} pixels.", Consts.MaximumImageWidthAndHeight);
return;
}
var imageData = FirmwareImageProcessor.ImportBitmap(bitmap);
ProcessImage(x => imageData, LastSelectedImageMetadata, true);
ImageListBox_SelectedValueChanged(ImageListBox, EventArgs.Empty);
}
}
catch (Exception ex)
{
InfoBox.Show("Unable to import bitmap image.\n" + ex.Message);
}
}
}
private void ImportImages([NotNull] IList <int> originalImageIndices, [NotNull] IList <bool[, ]> importedImages)
{
if (importedImages == null)
{
throw new ArgumentNullException("importedImages");
}
if (originalImageIndices == null)
{
throw new ArgumentNullException("originalImageIndices");
}
if (importedImages.Count == 0)
{
return;
}
var minimumImagesCount = Math.Min(originalImageIndices.Count, importedImages.Count);
originalImageIndices = originalImageIndices.Take(minimumImagesCount).ToList();
importedImages = importedImages.Take(minimumImagesCount).ToList();
ImageImportMode importMode;
bool allowResizeOriginalImages;
using (var importWindow = new PreviewResourcePackWindow(m_firmware, originalImageIndices, importedImages, false, m_currentBlock))
{
importWindow.Text = Consts.ApplicationTitleWoVersion + @" - Paste image(s)";
importWindow.ImportButtonText = "Paste";
if (importWindow.ShowDialog() != DialogResult.OK)
{
return;
}
importMode = importWindow.GetImportMode();
allowResizeOriginalImages = importWindow.AllowResizeOriginalImages;
}
for (var i = 0; i < minimumImagesCount; i++)
{
var index = i;
var originalImageIndex = originalImageIndices[index];
var importedImage = importedImages[index];
if (importMode == ImageImportMode.Block1)
{
var block1ImageMetadata = m_firmware.Block1Images.First(x => x.Index == originalImageIndex);
if (allowResizeOriginalImages)
{
ProcessImage(x => importedImage, block1ImageMetadata);
}
else
{
ProcessImage(x => FirmwareImageProcessor.PasteImage(block1ImageMetadata.CreateImage(), importedImage), block1ImageMetadata);
}
}
else if (importMode == ImageImportMode.Block2)
{
var block2ImageMetadata = m_firmware.Block2Images.First(x => x.Index == originalImageIndex);
if (allowResizeOriginalImages)
{
ProcessImage(x => importedImage, block2ImageMetadata);
}
else
{
ProcessImage(x => FirmwareImageProcessor.PasteImage(block2ImageMetadata.CreateImage(), importedImage), block2ImageMetadata);
}
}
else
{
var block1ImageMetadata = m_firmware.Block1Images.First(x => x.Index == originalImageIndex);
var block2ImageMetadata = m_firmware.Block2Images.First(x => x.Index == originalImageIndex);
if (allowResizeOriginalImages)
{
ProcessImage(x => importedImage, block1ImageMetadata);
ProcessImage(x => importedImage, block2ImageMetadata);
}
else
{
ProcessImage(x => FirmwareImageProcessor.PasteImage(block1ImageMetadata.CreateImage(), importedImage), block1ImageMetadata);
ProcessImage(x => FirmwareImageProcessor.PasteImage(block2ImageMetadata.CreateImage(), importedImage), block2ImageMetadata);
}
}
}
ImageCacheManager.RebuildImageCache(m_firmware);
ImageListBox.Invalidate();
ImageListBox_SelectedValueChanged(ImageListBox, EventArgs.Empty);
}
private void BitmapImportButton_Click(object sender, EventArgs eventArgs)
{
if (LastSelectedImageMetadata == null)
{
return;
}
try
{
using (var imageConverterWindow = new ImageConverterWindow(true, LastSelectedImageMetadata.Width, LastSelectedImageMetadata.Height))
{
if (imageConverterWindow.ShowDialog() != DialogResult.OK)
{
return;
}
using (var monochrome = imageConverterWindow.GetConvertedImage())
{
var imageData = BitmapProcessor.CreateRawFromBitmap(monochrome);
ImagePixelGrid.CreateUndo();
ImagePixelGrid.Data = ImagePreviewPixelGrid.Data = ProcessImage(x => FirmwareImageProcessor.PasteImage(x, imageData), LastSelectedImageMetadata, true);
}
}
}
catch (Exception ex)
{
InfoBox.Show("Unable to import bitmap image.\n" + ex.Message);
}
}
private void BitmapImportButton_Click(object sender, EventArgs eventArgs)
{
if (LastSelectedImageMetadata == null)
{
return;
}
using (var op = new OpenFileDialog {
Filter = Consts.BitmapImportFilter
})
{
if (op.ShowDialog() != DialogResult.OK)
{
return;
}
try
{
var bitmapFile = op.FileName;
using (var bitmap = (Bitmap)Image.FromFile(bitmapFile))
{
if (bitmap.Width > 2048 || bitmap.Height > 2048)
{
InfoBox.Show("Selected images is too big. Choose an image that has dimension lower than 2048x2048.");
return;
}
using (var scaledBitmap = BitmapProcessor.ScaleBitmapIfNecessary(bitmap, new Size(LastSelectedImageMetadata.Width, LastSelectedImageMetadata.Height)))
using (var monochrome = BitmapProcessor.ConvertTo1Bit(scaledBitmap))
{
var imageData = BitmapProcessor.CreateRawFromBitmap(monochrome);
ImagePixelGrid.CreateUndo();
ImagePixelGrid.Data = ImagePreviewPixelGrid.Data = ProcessImage(x => FirmwareImageProcessor.PasteImage(x, imageData), LastSelectedImageMetadata, true);
}
}
}
catch (Exception ex)
{
InfoBox.Show("Unable to import bitmap image.\n" + ex.Message);
}
}
}
