path: root/SpriteEd/AppDelegate.cs

//    SpriteEd - Simple sprite editor
//    Copyright 2020 Ian Cowburn
//
//    This program is free software: you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation, either version 3 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
//
using System;
using System.IO;
using AppKit;
using Foundation;

namespace SpriteEd
{
    [Register("AppDelegate")]
    public class AppDelegate : NSApplicationDelegate
    {
        private Sprite m_copy;

        /// <summary>
        /// Default constructor.
        /// </summary>
        public AppDelegate()
        {
        }

        /// <summary>
        /// Initialise the application/
        /// </summary>
        /// <param name="notification">The notification.</param>
        public override void DidFinishLaunching(NSNotification notification)
        {
        }

        /// <summary>
        /// Tear-down the application.
        /// </summary>
        /// <param name="notification">The notification.</param>
        public override void WillTerminate(NSNotification notification)
        {
        }

        /// <summary>
        /// Called to see if the app should terminate.
        /// </summary>
        /// <param name="sender">The sending application.</param>
        /// <returns></returns>
        public override NSApplicationTerminateReply ApplicationShouldTerminate(NSApplication sender)
        {
            NSApplicationTerminateReply reply = NSApplicationTerminateReply.Cancel;
            bool changed = false;

            foreach (NSWindow window in NSApplication.SharedApplication.DangerousWindows)
            {
                changed = changed || window.DocumentEdited;
            }

            if (changed)
            {
                NSAlert alert = new NSAlert ()
                {
                    AlertStyle = NSAlertStyle.Critical,
                    InformativeText = "Save changes to document(s) before closing window?",
                    MessageText = "Save Document",
                };

                alert.AddButton ("Save");
                alert.AddButton ("Delete");
                alert.AddButton ("Cancel");

                switch (alert.RunModal())
                {
                    case 1000:
                        bool saved = true;

                        foreach (NSWindow window in NSApplication.SharedApplication.DangerousWindows)
                        {
                            if (window.DocumentEdited)
                            {
                                ViewController view = window.ContentViewController as ViewController;

                                if (view.Untitled)
                                {
                                    saved = saved && view.SaveAs();
                                }
                                else
                                {
                                    saved = saved && view.Save();
                                }
                            }
                        }

                        if (saved)
                        {
                            reply = NSApplicationTerminateReply.Now;
                        }
                        break;

                    case 1001:
                        reply = NSApplicationTerminateReply.Now;
                        break;

                    default:
                        break;
                }
            }
            else
            {
                reply = NSApplicationTerminateReply.Now;
            }

            return reply;
        }

        /// <summary>
        /// Get the current view controller.
        /// </summary>
        private ViewController ViewController
        {
            get
            {
                return NSApplication.SharedApplication.KeyWindow.ContentViewController as ViewController;
            }
        }

        /// <summary>
        /// Handle Save Document As.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("saveDocumentAs:")]
        private void OnSaveDocumentAs(NSObject sender)
        {
            ViewController.SaveAs();
        }

        /// <summary>
        /// Handle Save Document.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("saveDocument:")]
        private void OnSaveDocument(NSObject sender)
        {
            ViewController view = ViewController;

            if (view.Untitled)
            {
                view.SaveAs();
            }
            else
            {
                view.Save();
            }
        }

        /// <summary>
        /// Handle Open Document.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("openDocument:")]
        private void OnOpenDocument(NSObject sender)
        {
            NSOpenPanel fsel = new NSOpenPanel();

            fsel.Title = "Open Sprite Set";
            fsel.AllowedFileTypes = new string[] {"sprset"};

            if (fsel.RunModal() == 1)
            {
                try
                {
                    FileStream stream = File.OpenRead(fsel.Url.Path);
                    SpriteSet set = SpriteSet.Load(stream);
                    stream.Close();

                    NSStoryboard storyboard = NSStoryboard.FromName("Main", null);
                    NSWindowController controller = storyboard.InstantiateInitialController() as NSWindowController;

                    controller.ShowWindow(this);

                    ViewController view = controller.ContentViewController as ViewController;

                    view.SpriteSet = set;
                    view.Url = fsel.Url;
                }
                catch (Exception e)
                {
                    Util.DisplayAlert("Error loading sprite set", e.Message);
                }
            }
        }

        /// <summary>
        /// Handle Revert Document To Saved.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("revertDocumentToSaved:")]
        private void OnRevertDocumentToSaved(NSObject sender)
        {
            ViewController view = ViewController;

            try
            {
                FileStream stream = File.OpenRead(view.Url.Path);
                SpriteSet set = SpriteSet.Load(stream);
                stream.Close();

                view.SpriteSet = set;
            }
            catch (Exception e)
            {
                Util.DisplayAlert("Error reverting sprite set", e.Message);
            }
        }

        /// <summary>
        /// Handle Cut.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("cut:")]
        private void OnCut(NSObject sender)
        {
            m_copy = ViewController.CutOrCopy(true);
        }

        /// <summary>
        /// Handle Copy.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("copy:")]
        private void OnCopy(NSObject sender)
        {
            m_copy = ViewController.CutOrCopy(false);
        }

        /// <summary>
        /// Handle Paste.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("paste:")]
        private void OnPaste(NSObject sender)
        {
            if (m_copy != null)
            {
                ViewController.Paste(m_copy);
            }
        }

        /// <summary>
        /// Is a sprite blank (all background colour).
        /// </summary>
        /// <param name="s">The sprite.</param>
        /// <returns>True if the sprite is blank.</returns>
        private bool IsSpriteBlank(Sprite s)
        {
            for(uint x = 0; x < s.Width; x++)
            {
                for(uint y = 0; y < s.Height; y++)
                {
                    if (s[x, y] != 0)
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        /// <summary>
        /// Convert a sprite set into a stream of bytes.
        /// </summary>
        /// <param name="write">The action to call with each byte.</param>
        /// <param name="set">The sprite set.</param>
        /// <param name="export_blank">Export blank sprites.</param>
        private void StreamSpriteSet(Action<byte> write, SpriteSet set, bool export_blank)
        {
            int bits_per_pixel = 1;

            switch(set.Palette.Size)
            {
                case 4:
                    bits_per_pixel = 2;
                    break;
                case 16:
                    bits_per_pixel = 4;
                    break;
                case 256:
                    bits_per_pixel = 8;
                    break;
            }

            for(uint f = 0; f < 256; f++)
            {
                Sprite sprite = set[(byte)f];

                if (export_blank || !IsSpriteBlank(sprite))
                {
                    for(uint y = 0; y < sprite.Height; y++)
                    {
                        switch(bits_per_pixel)
                        {
                            case 1:
                                for(uint x = 0; x < sprite.Width; x += 8)
                                {
                                    uint bit = 128;
                                    uint b = 0;

                                    for(uint sx = 0; sx < 8; sx++)
                                    {
                                        if ((x + sx) < sprite.Width)
                                        {
                                            if (sprite[x + sx,y] != 0)
                                            {
                                                b |= bit;
                                            }
                                        }

                                        bit /= 2;
                                    }

                                    write((byte)b);
                                }
                                break;

                            case 2:
                                for(uint x = 0; x < sprite.Width; x += 4)
                                {
                                    uint b = sprite[x, y] << 6;

                                    if ((x + 1) < sprite.Width)
                                    {
                                        b |= sprite[x + 1, y] << 4;
                                    }

                                    if ((x + 2) < sprite.Width)
                                    {
                                        b |= sprite[x + 2, y] << 2;
                                    }

                                    if ((x + 3) < sprite.Width)
                                    {
                                        b |= sprite[x + 3, y];
                                    }

                                    write((byte)b);
                                }
                                break;

                            case 4:
                                for(uint x = 0; x < sprite.Width; x += 2)
                                {
                                    uint b = sprite[x, y] << 4;

                                    if ((x + 1) < sprite.Width)
                                    {
                                        b |= sprite[x + 1, y];
                                    }

                                    write((byte)b);
                                }
                                break;

                            case 8:
                                for(uint x = 0; x < sprite.Width; x++)
                                {
                                    write((byte)sprite[x,y]);
                                }
                                break;
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Handle export binary.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("exportBinary:")]
        private void ExportBinary(NSObject sender)
        {
            if (NSApplication.SharedApplication.KeyWindow == null)
            {
                return;
            }

            NSSavePanel fsel = new NSSavePanel();

            fsel.Title = "Export binary";
            fsel.ShowsTagField = false;

            if (fsel.RunModal() == 1)
            {
                try
                {
                    ViewController view = ViewController;

                    bool export_blank = view.SpriteSet.Type == SpriteSet.SetType.C64CharacterSet ||
                                        view.SpriteSet.Type == SpriteSet.SetType.MonoCharacterSet;

                    FileStream stream = File.Create(fsel.Url.Path);

                    StreamSpriteSet
                        (delegate (byte b)
                        {
                            stream.WriteByte(b);
                        },
                        view.SpriteSet, export_blank);

                    stream.Close();
                }
                catch (Exception e)
                {
                    Util.DisplayAlert("Error exporting sprite set", e.Message);
                }
            }
        }

        /// <summary>
        /// Handle export assembly.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("exportAssembly:")]
        private void ExportAssembly(NSObject sender)
        {
            if (NSApplication.SharedApplication.KeyWindow == null)
            {
                return;
            }

            NSSavePanel fsel = new NSSavePanel();

            fsel.Title = "Export assembly";
            fsel.AllowedFileTypes = new string[] {"asm"};
            fsel.ShowsTagField = false;

            if (fsel.RunModal() == 1)
            {
                try
                {
                    ViewController view = ViewController;

                    bool export_blank = view.SpriteSet.Type == SpriteSet.SetType.C64CharacterSet ||
                                        view.SpriteSet.Type == SpriteSet.SetType.MonoCharacterSet;

                    StreamWriter stream = File.CreateText(fsel.Url.Path);

                    stream.Write("sprite_data:");

                    int col = 0;

                    StreamSpriteSet
                        (delegate (byte b)
                        {
                            if (col == 0)
                            {
                                stream.Write("\n\tbyte\t");
                            }
                            else
                            {
                                stream.Write(",");
                            }

                            stream.Write("{0}", b);

                            if (++col == 8)
                            {
                                col = 0;
                            }
                        },
                        view.SpriteSet, export_blank);

                    stream.Close();
                }
                catch (Exception e)
                {
                    Util.DisplayAlert("Error exporting sprite set", e.Message);
                }
            }
        }

        /// <summary>
        /// Handle export C.
        /// </summary>
        /// <param name="sender">The event sender.</param>
        [Export("exportC:")]
        private void ExportC(NSObject sender)
        {
            if (NSApplication.SharedApplication.KeyWindow == null)
            {
                return;
            }

            NSSavePanel fsel = new NSSavePanel();

            fsel.Title = "Export C";
            fsel.AllowedFileTypes = new string[] {"c"};
            fsel.ShowsTagField = false;

            if (fsel.RunModal() == 1)
            {
                try
                {
                    ViewController view = ViewController;

                    bool export_blank = view.SpriteSet.Type == SpriteSet.SetType.C64CharacterSet ||
                                        view.SpriteSet.Type == SpriteSet.SetType.MonoCharacterSet;

                    StreamWriter stream = File.CreateText(fsel.Url.Path);

                    stream.Write("unsigned char sprite_data[] =\n{");

                    int col = 0;
                    bool first_line = true;

                    StreamSpriteSet
                        (delegate (byte b)
                        {
                            if (col == 0)
                            {
                                if (first_line)
                                {
                                    stream.Write("\n\t");
                                }
                                else
                                {
                                    stream.Write(",\n\t");
                                }

                                first_line = false;
                            }
                            else
                            {
                                stream.Write(",");
                            }

                            stream.Write("{0}", b);

                            if (++col == 8)
                            {
                                col = 0;
                            }
                        },
                        view.SpriteSet, export_blank);

                    stream.Write("\n};");

                    stream.Close();
                }
                catch (Exception e)
                {
                    Util.DisplayAlert("Error exporting sprite set", e.Message);
                }
            }
        }
    }
}