McBitFont/McBitFont/FontTester.cs

using MessagePack;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace McBitFont {
    public partial class FontTester : Form {

        private int codepage = 1251;
        private int height;
        private List<MainForm.FrameMiniature> frames;
        private int baseline;
        private readonly int absentWidth = 5;
        private readonly int pixelOffset = 5;

        private int baselineThickness = 1;
        private byte[] encoded = [];
        private int cellSize;
        private int width;

        private readonly DataFormats.Format clpbFormat = DataFormats.GetFormat("McBitFontFrame");

        public FontTester(int codepage, int height, int baseline, List<MainForm.FrameMiniature> frames) {
            InitializeComponent();
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
            this.codepage = codepage;
            this.height = height;
            this.baseline = baseline;
            this.frames = frames;
        }

        private void FontTester_Load(object sender, EventArgs e) {
            cbZoom.SelectedIndex = 2;
            //cbZoom.SelectedIndexChanged += ZoomChanged;
            dotPanel.MouseWheel += new MouseEventHandler(DotPanel_MouseWheel);
        }

        private void PaintPixels(object sender, PaintEventArgs e) {
            Graphics g = dotPanel.CreateGraphics();
            SolidBrush sbb = new SolidBrush(Color.Black);
            SolidBrush sbw = new SolidBrush(Color.White);
            SolidBrush sbp = new SolidBrush(Color.LightPink);
            SolidBrush sb;
            Pen blackPen = new(Color.Black);
            Pen bluePen = new(Color.FromArgb(100, 20, 20, 200), baselineThickness);
            int x, y, i, j;

            // Sycle through ecoded bytes of test text
            int space = (int)nudSpace.Value;
            int index = 0;
            for (int c = 0; c < encoded.Length; c++) {
                // Check if we have such symbol
                var f = frames.FindAll(x => x.code == encoded[c]);
                if (f.Count == 1) {
                    // Draw the symbol
                    for (i = 0; i < f[0].width; i++) {
                        x = pixelOffset + (index + i) * cellSize - hScroll.Value;
                        for (j = 0; j < f[0].height; j++) {
                            y = pixelOffset + j * cellSize - vScroll.Value;
                            // Fill the cell with color
                            if (f[0].data[i, j]) sb = sbb;
                            else sb = sbw;
                            g.FillRectangle(sb, x, y, cellSize, cellSize);
                        }
                    }
                    index += (f[0].width > 0 ? f[0].width + space : 0);
                } else {
                    blackPen.Width = cellSize;
                    blackPen.Alignment = System.Drawing.Drawing2D.PenAlignment.Inset;
                    x = pixelOffset + index * cellSize - hScroll.Value;
                    y = pixelOffset - vScroll.Value;
                    g.DrawRectangle(blackPen, x, y + cellSize, absentWidth * cellSize, (height - 2) * cellSize);
                    g.FillRectangle(sbp, x + cellSize, y + 2 * cellSize, (absentWidth - 2) * cellSize, (height - 4) * cellSize);
                    index += 5 + space;
                }
            }

            // Draw baseline
            if (chkBaseline.Checked && baseline > 0) {
                x = pixelOffset - hScroll.Value;
                y = pixelOffset + baseline * cellSize - vScroll.Value;
                g.DrawLine(bluePen, x, y, dotPanel.Width - 2 * pixelOffset, y);
            }
        }

        private void Text_Changed(object sender, EventArgs e) {
            int space = (int)nudSpace.Value;

            encoded = Encoding.GetEncoding(codepage).GetBytes(tbText.Text);

            width = space > 0 ? space : 1;
            for (int c = 0; c < encoded.Length; c++) {
                var f = frames.FindAll(x => x.code == encoded[c]);
                width += (f.Count == 1 ? f[0].width : absentWidth) + space;
            }
            dotPanel.Invalidate();
        }

        private void ZoomChanged(object sender, EventArgs e) {
            cellSize = Convert.ToInt32(cbZoom.Text);

            int w = pixelOffset + width * cellSize;
            int h = pixelOffset + height * cellSize;

            if (w <= dotPanel.Width) {
                hScroll.Enabled = false;
                hScroll.Value = 0;
            } else {
                hScroll.Maximum = w - dotPanel.Width + 12;
                hScroll.Minimum = 0;
                hScroll.Enabled = true;
            }

            if (h <= dotPanel.Height) {
                vScroll.Enabled = false;
                vScroll.Value = 0;
            } else {
                vScroll.Maximum = h - dotPanel.Height + 12;
                vScroll.Minimum = 0;
                vScroll.Enabled = true;
            }

            // Baseline thickness calc
            baselineThickness = cellSize / 5;
            if (baselineThickness > 5) baselineThickness = 5;
            if (baselineThickness < 1) baselineThickness = 1;

            dotPanel.Refresh();
        }

        private void DotPanel_MouseWheel(object sender, MouseEventArgs e) {
            int t = e.Delta / 120;
            if (e.Delta == 0) return;
            if (ModifierKeys.HasFlag(Keys.Control)) {
                t += cbZoom.SelectedIndex;
                if (t > cbZoom.Items.Count - 1) return;
                if (t < 0) return;
                cbZoom.SelectedIndex = t;
            } else if (ModifierKeys.HasFlag(Keys.Shift)) {
                if (hScroll.Enabled) {
                    t = t * -1 * cellSize + hScroll.Value;
                    if (t < hScroll.Minimum) t = hScroll.Minimum;
                    if (t > hScroll.Maximum) t = hScroll.Maximum;
                    hScroll.Value = t;
                }
            } else {
                if (vScroll.Enabled) {
                    t = t * -1 * cellSize + vScroll.Value;
                    if (t < vScroll.Minimum) t = vScroll.Minimum;
                    if (t > vScroll.Maximum) t = vScroll.Maximum;
                    vScroll.Value = t;
                }
            }
        }

        private void Scrolling(object sender, EventArgs e) {
            dotPanel.Invalidate();
        }

        private void Form_Resize(object sender, EventArgs e) {
            btnCopy.Left = this.Width / 2 - 40;
        }

        private void Copy_Click(object sender, MouseEventArgs e) {
            if (encoded.Length < 1) {
                MessageBox.Show("Nothing to copy! Type some symbols first.", "Error!", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            // Sycle through ecoded bytes of test text
            int space = (int)nudSpace.Value;
            int index = 0;
            int i, j;
            MainForm.FrameMiniature ff = new(0, width, frames[0].height);
            for (int c = 0; c < encoded.Length; c++) {
                // Check if we have such symbol
                var f = frames.FindAll(x => x.code == encoded[c]);
                if (f.Count == 1) {
                    // Draw the symbol
                    for (i = 0; i < f[0].width; i++) {
                        for (j = 0; j < f[0].height; j++) {
                            // Fill the frame with data
                            ff.data[index + i, j] = f[0].data[i, j];
                        }
                    }
                    index += (f[0].width > 0 ? f[0].width + space : 0);
                } else {
                    index += 5 + space;
                }
            }
            // Copy the frame we made into Clipboard
            var bb = MessagePackSerializer.Serialize(ChangeHistory.CopyFrameSimple(ff));
            DataObject clpbObj = new DataObject(clpbFormat.Name, bb);
            Clipboard.SetDataObject(clpbObj, true);
        }
    }


}