Subversion Repositories AndroidProjects

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Reflection;

using Tao.OpenGl;

using BauzoidNET.app;

using BurutaruEditor.file;
using BurutaruEditor.file.elements;
using BurutaruEditor.view;
using BurutaruEditor.interaction;

namespace BurutaruEditor
{
    public partial class MainForm : Form
    {
        public enum InteractionMode
        {
            SELECT,
            CREATE
        }

        public enum ObjectMode
        {
            CHECKPOINTS,
            SPAWNERS,
            ELEMENTS
        }

        //===============================================================================================================

        public static BauzoidApp App = null;

        private Document mDocument = null;
        public Document Doc { get { return mDocument; } }

        private DocumentView mView = null;
        public DocumentView View { get { return mView; } }

        private InteractionMode mInteractionMode = InteractionMode.SELECT;
        public InteractionMode CurrentInteraction
        {
            get { return mInteractionMode; }
            set
            {
                if (value == InteractionMode.SELECT)
                {
                    EnableCreateButton(false);
                }
                else if (value == InteractionMode.CREATE)
                {
                    EnableCreateButton(true);
                }
                mInteractionMode = value;
                UpdateStatusBar();
            }
        }

        private ObjectMode mObjectMode = ObjectMode.CHECKPOINTS;
        public ObjectMode CurrentObjectMode
        {
            get { return mObjectMode; }
            set
            {
                switch (value)
                {
                    case ObjectMode.CHECKPOINTS:
                        tbcObjects.SelectedTab = tabCheckPoints;
                        break;
                    case ObjectMode.SPAWNERS:
                        tbcObjects.SelectedTab = tabSpawners;
                        break;
                    case ObjectMode.ELEMENTS:
                        tbcObjects.SelectedTab = tabElements;
                        break;
                }
                mObjectMode = value;
                UpdateStatusBar();
            }
        }

#pragma warning disable 0618
        public Tao.Platform.Windows.SimpleOpenGlControl GlView { get { return mGlView; } }
#pragma warning restore 0618
        public ListBox CheckPoints { get { return lbCheckPoints; } }
        public ListBox Spawners { get { return lbSpawners; } }
        public ListBox LevelElements { get { return lbElements; } }
        public PropertyGrid Properties { get { return pgProperties; } }
        public Label PropertiesLabel { get { return lblProperties; } }

        public string CurrentSpawnerType { get { return cbSpawnerTypes.Items[cbSpawnerTypes.SelectedIndex].ToString(); } }
        public string CurrentElementType { get { return cbElementTypes.Items[cbElementTypes.SelectedIndex].ToString(); } }

        public bool ViewCheckPointPath { get { return mnuViewCheckPointPath.Checked; } set { mnuViewCheckPointPath.Checked = value; } }
        public bool ViewCheckPointFrames { get { return mnuViewCheckPointFrames.Checked; } set { mnuViewCheckPointFrames.Checked = value; } }
        public bool ViewBgLayer1 { get { return mnuViewBgLayer1.Checked; } set { mnuViewBgLayer1.Checked = value; } }
        public bool ViewBgLayer2 { get { return mnuViewBgLayer2.Checked; } set { mnuViewBgLayer2.Checked = value; } }
        public bool ViewMainLayer { get { return mnuViewMainLayer.Checked; } set { mnuViewMainLayer.Checked = value; } }
        public bool ViewFgLayer { get { return mnuViewFgLayer.Checked; } set { mnuViewFgLayer.Checked = value; } }
        public bool ViewEnemySpawners { get { return mnuViewEnemySpawners.Checked; } set { mnuViewEnemySpawners.Checked = value; } }

        public bool SnapToPath { get; set; }

        private Panning mPanning = null;
        private SelectMove mSelectMode = null;
        private CreateObject mCreateObjectMode = null;

        private Bitmap[] mLayerBitmaps = new Bitmap[LevelElement.NUM_LAYERS];

        //===============================================================================================================

        public MainForm()
        {
            InitializeComponent();

            mGlView.MouseWheel += new MouseEventHandler(GlView_MouseWheel);
            lbCheckPoints.DisplayMember = "Name";
            lbSpawners.DisplayMember = "DisplayName";
            SetSnapToPath(false);
            CurrentObjectMode = ObjectMode.CHECKPOINTS;

            cbSpawnerTypes.SelectedIndex = 0;
            cbElementTypes.SelectedIndex = 0;
        }

        private void MainForm_Load(object sender, EventArgs e)
        {
            App = new BauzoidApp();
            App.init(mGlView.Width, mGlView.Height);

            String s = Path.Combine(Application.StartupPath, @"..\\..\\..\\..\\..\\BauzoidApps\\BurutaruZ_v2\\burutaru-android\\assets\\data");
            openFileDialog.InitialDirectory = Path.GetFullPath(s) + "\\levels";
            saveFileDialog.InitialDirectory = Path.GetFullPath(s) + "\\levels";
            openSpriteDialog.InitialDirectory = Path.GetFullPath(s) + "\\textures";

            mDocument = new Document(this);
            mView = new DocumentView(this);
            mView.Init();

            mLayerBitmaps[LevelElement.BACKGROUND_LAYER1] = new Bitmap(BurutaruEditor.Properties.Resources.layerBG1);
            mLayerBitmaps[LevelElement.BACKGROUND_LAYER2] = new Bitmap(BurutaruEditor.Properties.Resources.layerBG2);
            mLayerBitmaps[LevelElement.MAIN_LAYER] = new Bitmap(BurutaruEditor.Properties.Resources.layerMain);
            mLayerBitmaps[LevelElement.FOREGROUND_LAYER] = new Bitmap(BurutaruEditor.Properties.Resources.layerFG);

            pgProperties.SelectedObject = Doc;
            pgProperties.ExpandAllGridItems();

            mPanning = new Panning(this);
            mSelectMode = new SelectMove(this);
            mCreateObjectMode = new CreateObject(this);

            Doc.NewDocument();
        }

        private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
        {
            if (!CheckDocumentModifiedAndSave())
            {
                e.Cancel = true;
                return;
            }

            if (mView != null)
            {
                mView.Exit();
                mView = null;
            }

            if (mDocument != null)
            {
                mDocument.Exit();
                mDocument = null;
            }

            mCreateObjectMode.Destroy();

            if (App != null)
                App.exit();
        }

        private void GlView_Paint(object sender, PaintEventArgs e)
        {
            App.getGraphics().clear(0.3f, 0.3f, 0.35f, 0);
            App.getRenderStates().projection.setOrtho(
                    0.0f,
                    App.getGraphics().getWidth(),
                    App.getGraphics().getHeight(),
                    0.0f,
                    0.0f,
                    1.0f
                );

            mView.Render();
        }

        public void RenderInteraction()
        {
            if ((CurrentInteraction == InteractionMode.SELECT) && (mSelectMode != null))
                mSelectMode.Render();
            else if ((CurrentInteraction == InteractionMode.CREATE) && (mCreateObjectMode != null))
                mCreateObjectMode.Render();

            if (mPanning != null)
                mPanning.Render();
        }

        private void GlView_Resize(object sender, EventArgs e)
        {
            if (App != null)
                App.getGraphics().updateSurfaceDimensions(mGlView.Width, mGlView.Height);
        }

        private void FileNew_Click(object sender, EventArgs e)
        {
            if (!CheckDocumentModifiedAndSave())
                return;

            // new file
            mDocument.NewDocument();
        }

        private void FileOpen_Click(object sender, EventArgs e)
        {
            if (!CheckDocumentModifiedAndSave())
                return;

            // open file
            PerformFileOpen();
        }

        /** Check if the document has been modified, and if yes, ask for saving.
         * Returns true if everything is ok and the operation should be continued, or false when Cancel has been pressed. */
        private bool CheckDocumentModifiedAndSave()
        {
            if (mDocument.IsDirty())
            {
                switch (MessageBox.Show("File has been modified. Save?", "New File", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question))
                {
                    case DialogResult.Yes:
                        if (!PerformFileSave())                        
                            return false;
                        break;
                    case DialogResult.No:
                        break;
                    case DialogResult.Cancel:
                        return false;
                }
            }

            return true;
        }

        /** Perform a file save operation with a file save dialog.
         * Returns false if the operation has been canceled. */
        private bool PerformFileSave(bool alwaysShowDialog = false)
        {
            if (alwaysShowDialog || !mDocument.IsFilenameSet())
            {
                if (saveFileDialog.ShowDialog() == DialogResult.Cancel)
                    return false;

                mDocument.SetFilename(saveFileDialog.FileName);
            }

            return mDocument.SaveDocument();
        }

        /** Perform a file open operation.
         * Return false if the operation was canceled. */
        private bool PerformFileOpen()
        {
            if (openFileDialog.ShowDialog() == DialogResult.Cancel)
                return false;

            return mDocument.LoadDocument(openFileDialog.FileName);
        }

        private void FileSave_Click(object sender, EventArgs e)
        {
            PerformFileSave();
        }

        private void FileSaveAs_Click(object sender, EventArgs e)
        {
            PerformFileSave(true);
        }

        private void FileExit_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void GlView_MouseDown(object sender, MouseEventArgs e)
        {
            Doc.SetDirty(true);

            if (CurrentInteraction == InteractionMode.SELECT)
                mSelectMode.MouseDown(e);
            else if (CurrentInteraction == InteractionMode.CREATE)
                mCreateObjectMode.MouseDown(e);

            mPanning.MouseDown(e);

            mGlView.Refresh();
        }

        private void GlView_MouseMove(object sender, MouseEventArgs e)
        {
            if (CurrentInteraction == InteractionMode.SELECT)
                mSelectMode.MouseMove(e);
            else if (CurrentInteraction == InteractionMode.CREATE)
                mCreateObjectMode.MouseMove(e);

            mPanning.MouseMove(e);

            mGlView.Refresh();
        }

        private void GlView_MouseUp(object sender, MouseEventArgs e)
        {
            if (CurrentInteraction == InteractionMode.SELECT)
                mSelectMode.MouseUp(e);
            else if (CurrentInteraction == InteractionMode.CREATE)
                mCreateObjectMode.MouseUp(e);

            mPanning.MouseUp(e);

            mGlView.Refresh();
        }

        private void GlView_MouseEnter(object sender, EventArgs e)
        {
            if (CurrentInteraction == InteractionMode.SELECT)
                mSelectMode.MouseEnter(e);
            else if (CurrentInteraction == InteractionMode.CREATE)
                mCreateObjectMode.MouseEnter(e);
        }

        private void GlView_MouseLeave(object sender, EventArgs e)
        {
            if (CurrentInteraction == InteractionMode.SELECT)
                mSelectMode.MouseLeave(e);
            else if (CurrentInteraction == InteractionMode.CREATE)
                mCreateObjectMode.MouseLeave(e);
        }

        private void GlView_MouseWheel(object sender, MouseEventArgs e)
        {
            if (e.Delta > 0)
            {
                View.ZoomFactor *= 1.2f;
            }
            else if (e.Delta < 0)
            {
                View.ZoomFactor *= 0.8f;
            }
        }

        private void ObjectsList_SelIndexChanged(object sender, EventArgs e)
        {
            ListBox lb = null;

            switch (CurrentObjectMode)
            {
                case ObjectMode.CHECKPOINTS:
                    lb = lbCheckPoints;
                    break;
                case ObjectMode.SPAWNERS:
                    lb = lbSpawners;
                    break;
                case ObjectMode.ELEMENTS:
                    lb = lbElements;
                    break;
            }

            if (lb.SelectedIndex == -1)
                return;

            pgProperties.SelectedObject = lb.SelectedItem;
            View.SelectedObject = (LevelObject)lb.SelectedItem;
            View.SelectedObjectPart = SelectMove.MOVE_ALL;
            pgProperties.ExpandAllGridItems();

            mGlView.Refresh();
        }

        private void Properties_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
        {
            mGlView.Refresh();

            Doc.SetDirty(true);

            typeof(ListBox).InvokeMember("RefreshItems", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null,
                CheckPoints, new object[] { });
            typeof(ListBox).InvokeMember("RefreshItems", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null,
                Spawners, new object[] { });
            typeof(ListBox).InvokeMember("RefreshItems", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.InvokeMethod, null,
                LevelElements, new object[] { });
        }

        public void SetSnapToPath(bool snap = true)
        {
            SnapToPath = snap;
            tbSnapToPath.Checked = snap;
            mnuSnapToPath.Checked = snap;
        }

        private void SnapToPath_Click(object sender, EventArgs e)
        {
            SetSnapToPath(!SnapToPath);
            mGlView.Refresh();
        }

        private void EnableCreateButton(bool enable)
        {
            btnCreateCheckPoint.Checked = enable && (CurrentObjectMode == ObjectMode.CHECKPOINTS);
            btnCreateSpawner.Checked = enable && (CurrentObjectMode == ObjectMode.SPAWNERS);
            btnCreateElement.Checked = enable && (CurrentObjectMode == ObjectMode.ELEMENTS);
        }

        private void Create_Click(object sender, EventArgs e)
        {
            if (((CheckBox)sender).Checked)
            {
                if (sender == btnCreateElement)
                {
                    // TODO: check cbElementTypes for whether a OpenFileDialog is even needed

                    if (openSpriteDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
                    {
                        if (!mCreateObjectMode.Load(openSpriteDialog.FileName))
                        {
                            ((CheckBox)sender).Checked = false;
                            return;
                        }
                    }
                    else
                    {
                        ((CheckBox)sender).Checked = false;
                        return;
                    }
                }
                else if (sender == btnCreateSpawner)
                {

                }

                CurrentInteraction = InteractionMode.CREATE;
            }
            else
                CurrentInteraction = InteractionMode.SELECT;
        }

        public void UpdateStatusBar()
        {
            string text = "";
            switch (CurrentInteraction)
            {
                case InteractionMode.SELECT:
                    text = "Select ";
                    break;
                case InteractionMode.CREATE:
                    text = "Create ";
                    break;
            }
            switch (CurrentObjectMode)
            {
                case ObjectMode.CHECKPOINTS:
                    text += "CheckPoint";
                    break;
                case ObjectMode.SPAWNERS:
                    text += "EnemySpawner";
                    break;
                case ObjectMode.ELEMENTS:
                    text += "LevelElement";
                    break;
            }
            stInteractionObjectMode.Text = text;
            if (View != null)
                stZoom.Text = ((int)Math.Floor(View.ZoomFactor * 100)) + "%";
            mStatusStrip.Refresh();
        }

        private void Objects_SelectedTabChanged(object sender, EventArgs e)
        {
            mObjectMode = (ObjectMode)tbcObjects.SelectedIndex;
            CurrentInteraction = InteractionMode.SELECT;

            switch (CurrentObjectMode)
            {
                case ObjectMode.CHECKPOINTS:
                    ObjectsList_SelIndexChanged(lbCheckPoints, new EventArgs());
                    break;
                case ObjectMode.SPAWNERS:
                    ObjectsList_SelIndexChanged(lbSpawners, new EventArgs());
                    break;
                case ObjectMode.ELEMENTS:
                    ObjectsList_SelIndexChanged(lbElements, new EventArgs());
                    break;
            }
        }

        private void MainForm_KeyDown(object sender, KeyEventArgs e)
        {

        }

        private void MoveUp_Click(object sender, EventArgs e)
        {
            Doc.MoveObjectUp();
            mGlView.Refresh();
        }

        private void MoveDown_Click(object sender, EventArgs e)
        {
            Doc.MoveObjectDown();
            mGlView.Refresh();
        }

        private void Elements_DrawItem(object sender, DrawItemEventArgs e)
        {
            e.DrawBackground();

            LevelElement element = (LevelElement)LevelElements.Items[e.Index];

            Bitmap bm = null;
            switch (element.Layer)
            {
                case LevelElement.BACKGROUND_LAYER1:
                case LevelElement.BACKGROUND_LAYER2:
                case LevelElement.MAIN_LAYER:
                case LevelElement.FOREGROUND_LAYER:
                    bm = mLayerBitmaps[element.Layer];
                    break;
            }
            Rectangle r = e.Bounds;

            r.X += 2;
            r.Width = 16;
            r.Height = 16;
            e.Graphics.DrawImageUnscaled(bm, r);


            r = e.Bounds;
            r.X += 20;
            Font fn = new Font(e.Font, FontStyle.Bold);
            e.Graphics.DrawString(element.Name, fn, SystemBrushes.ControlText, r, StringFormat.GenericDefault);

            SizeF s = e.Graphics.MeasureString(element.Name, fn);
            r.X += (int)s.Width;
            e.Graphics.DrawString(element.GetPropertiesType(), e.Font, SystemBrushes.ControlText, r, StringFormat.GenericDefault);
            // If the ListBox has focus, draw a focus rectangle around the selected item.
            e.DrawFocusRectangle();
        }

        private void Properties_SelectedObjectChange(object sender, EventArgs e)
        {
            if (pgProperties.SelectedObject is Document)
            {
                lblProperties.Text = ((Document)pgProperties.SelectedObject).GetPropertiesTitle();
                lblType.Text = ((Document)pgProperties.SelectedObject).GetPropertiesType();
            }
            else if (pgProperties.SelectedObject is LevelObject)
            {
                lblProperties.Text = ((LevelObject)pgProperties.SelectedObject).Name;
                lblType.Text = ((LevelObject)pgProperties.SelectedObject).GetPropertiesType();
            }
        }

        private void About_Click(object sender, EventArgs e)
        {
            AboutBox dlg = new AboutBox();
            dlg.ShowDialog();
        }

        private void GlView_KeyDown(object sender, KeyEventArgs e)
        {
            // implement shortcut keys
            if (e.KeyCode == Keys.S)
            {
                // snap
                SetSnapToPath(!SnapToPath);
                mGlView.Refresh();
            }
            if (e.KeyCode == Keys.Escape)
            {
                // exit create mode
                CurrentInteraction = InteractionMode.SELECT;
                mGlView.Refresh();
            }
        }

        private void EditCut_Click(object sender, EventArgs e)
        {
            Doc.Cut();
        }

        private void EditCopy_Click(object sender, EventArgs e)
        {
            Doc.Copy();
        }

        private void EditPaste_Click(object sender, EventArgs e)
        {
            Doc.Paste();
        }

        private void ViewObjectLayer_Click(object sender, EventArgs e)
        {
            if (sender is ToolStripMenuItem)
                ((ToolStripMenuItem)sender).Checked = !((ToolStripMenuItem)sender).Checked;
            mGlView.Refresh();
        }

        private void Delete_Click(object sender, EventArgs e)
        {
            Doc.DeleteCurrentObject();
            mGlView.Refresh();
        }



    }
}