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();

        }

    }

}