trunk/visLU/Gui/MainWindow.cs

Go to the documentation of this file.

#region using statemens
using System;
using System.IO;
using System.Reflection;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using visLU2.Gui;
#endregion

namespace visLU2.Gui
{
   
    public partial class MainWindow : Form
    {
        #region interactive tranfer function variables
        Pen penGray = new Pen(Color.Gray);
        Pen penLightGray = new Pen(Color.LightSlateGray);
        Pen penBlack = new Pen(Color.Black);
        Pen penBlue = new Pen(Color.Blue);
        Size controlPointSize = new Size(9, 9);
        Size colorBarSize = new Size(1, 30);

        //channel tab
        List<SortedDictionary<int, TransferControlPoint>> channelControlPoints;
        List<Color[]> channelColorArray;
        int tfStepsize = 1;
        public bool updateChannelControlPoints = false;
        int currChannelIdx;

        //arrow plot tab
        SortedDictionary<int, TransferControlPoint> arrowControlPoints;
        Color[] arrowColorArray;
        //int arrowTFStepsize = 1;
        bool updateArrowControlPoints = false;

        bool dataLoaded = false;
        bool tfPanelMouseDown = false;
        Point tfPanelMouseDownPos = new Point();
        #endregion

        #region other variables
        string assemblyLocation = Assembly.GetExecutingAssembly().Location;
        InputManager inputManager;
        #endregion

        public MainWindow()
        {
            InitializeComponent();
            SetStyle(ControlStyles.OptimizedDoubleBuffer |
                        ControlStyles.UserPaint |
                        ControlStyles.AllPaintingInWmPaint, true);

            inputManager = new InputManager();
            //init control points -> one dictionary for each channel
            channelControlPoints = new List<SortedDictionary<int, TransferControlPoint>>();
            //init color array list
            channelColorArray = new List<Color[]>();

            arrowControlPoints = new SortedDictionary<int, TransferControlPoint>();
            arrowColorArray = new Color[256];
        }

        #region XNA drawing area





        public IntPtr getDrawSurface()
        {
            return XNADrawSurface.Handle;
        }

        public void setXNADrawSurfaceDimensions()
        {
            GameProperties.Instance.XNADrawSurfaceWidth = XNADrawSurface.Size.Width;
            GameProperties.Instance.XNADrawSurfaceHeight = XNADrawSurface.Size.Height;
        }

        public int XNADrawWidth()
        {
            return XNADrawSurface.Size.Width;
        }

        public int XNADrawHeight()
        {
            return XNADrawSurface.Size.Height;
        }

        #endregion

        #region update controls
        public void updateChannelControl(List<string> channelNames, int currChannelIdx)
        {
            //this.SettingsPanel.SelectedTab = ChannelsTab;
            this.EnableChannelsCheckbox.Checked = GameProperties.Instance.enableChannels;
            this.ChannelsCompoBox.Items.Clear();
            foreach (string item in channelNames)
            {
                this.ChannelsCompoBox.Items.Add(item);
            }

            this.ChannelsCompoBox.SelectedIndex = currChannelIdx;
            this.currChannelIdx = currChannelIdx;
            this.transferfunctionCheckBox.Checked = GameProperties.Instance.enableChannelTransferFunction;
            this.ComposeChannelsCheckBox.Checked = GameProperties.Instance.composeChannels;
            this.updateChannelControlPoints = true;
            this.dataLoaded = GameProperties.Instance.dataLoaded;
            TransferFunctionPanel.Invalidate();
            
        }

        public void updateArrowPlotControl()
        {
            this.EnableArrowPlotCheckBox.Checked = GameProperties.Instance.enableArrowPlot;
            if (GameProperties.Instance.scaleArrowLength)
            {
                this.UniformArrowRadio.Checked = false;
                this.ScaledArrowRadio.Checked = true;
            }
            else 
            {
                this.UniformArrowRadio.Checked = true;
                this.ScaledArrowRadio.Checked = false;
            }
            this.ArrowStepsizeScrollbar.Value = (int)GameProperties.Instance.apStepsize;
            this.ArrowDensityLabel.Text = this.ArrowStepsizeScrollbar.Value.ToString();
            this.ArrowPlotEnableColor.Checked = GameProperties.Instance.enableArrowTransferFunction;
            this.ArrowAlphaScrollBar.Value = (int)(GameProperties.Instance.apAlpha * 255);
            this.ArrowAlphaLabel.Text = this.ArrowAlphaScrollBar.Value.ToString();
            this.updateArrowControlPoints = true;
            this.dataLoaded = GameProperties.Instance.dataLoaded;
            ArrowPlotColorPanel.Invalidate();
        }

        public void updateStreamlineControl(float maxLineLength)
        {
            this.EnableStreamlinesCheckBox.Checked = GameProperties.Instance.enableStreamlines;
            if (GameProperties.Instance.enableRungeKutta)
            {
                this.EulerRadioButton.Checked = false;
                this.RungeKuttaRadioButton.Checked = true;
            }
            else 
            {
                this.EulerRadioButton.Checked = true;
                this.RungeKuttaRadioButton.Checked = false;
            }
            //dt
            this.StreamlineDtNumUpDown.Value = (decimal)GameProperties.Instance.Dt;
            //dsep
            float dsep = GameProperties.Instance.Dsep / GameProperties.Instance.maxDsep;
            this.StreamlineDsepSlider.Value = (int)(dsep * (this.StreamlineDsepSlider.Maximum - (this.StreamlineDsepSlider.LargeChange - 1)));
            this.StreamlineDsepLabel.Text = dsep.ToString();
            //dtest
            float dtest = GameProperties.Instance.Dtest / GameProperties.Instance.Dsep;
            this.StreamlineDtestSlider.Value = (int)(dtest * (this.StreamlineDtestSlider.Maximum - (this.StreamlineDtestSlider.LargeChange - 1)));
            this.StreamlineDtestLabel.Text = dtest.ToString();
            this.StreamlineStyleRadio1.Checked = false;
            this.StreamlineStyleRadio2.Checked = false;
            this.StreamlineStyleRadio3.Checked = false;
            this.StreamlineStyleRadio4.Checked = false;
            if (GameProperties.Instance.enableTapering)
            {
                this.StreamlineStyleRadio2.Checked = true;
            }
            else if (GameProperties.Instance.enableGlyphMapping)
            {
                this.StreamlineStyleRadio3.Checked = true;
            }
            else if (GameProperties.Instance.enableTextureGeneration)
            {
                this.StreamlineStyleRadio4.Checked = true;
            }
            else 
            {
                this.StreamlineStyleRadio1.Checked = true;
            }
            this.StreamlineLengthUpDown.Value = (decimal)GameProperties.Instance.lineLength;
            this.StreamlineLengthUpDown.Maximum = (decimal)maxLineLength;
            this.StreamlineWidthUpDown.Value = (decimal)(GameProperties.Instance.lineWidth / GameProperties.Instance.Dtest);
        }
       
        #endregion

        #region event handler

        #region main menu handler

        #region file menu





        private void handleOpenFileMenu(object sender, EventArgs e)
        {
            // Default to the directory which contains our content files.
            //string assemblyLocation = Assembly.GetExecutingAssembly().Location;
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data");
            string contentPath = Path.GetFullPath(relativePath);

            this.openFileDialog.InitialDirectory = contentPath;

            this.openFileDialog.Title = "Load Data Set";

            this.openFileDialog.Filter = "Data Files (*.gri)|*.gri";

            if (this.openFileDialog.ShowDialog() == DialogResult.OK)
            {
                if (GameProperties.Instance.relativePath)
                {
                    String[] splitName = openFileDialog.FileName.Split('\\');
                    String dataFileName = openFileDialog.FileName.Substring(openFileDialog.FileName.LastIndexOf(splitName[splitName.Length - 2]));
                    GameProperties.Instance.dataDir = "Data\\";
                    GameProperties.Instance.dataFilename = dataFileName;
                }
                else 
                {
                    GameProperties.Instance.dataDir = "";
                    GameProperties.Instance.dataFilename = openFileDialog.FileName;
                }

                inputManager.updateXnaEngineState(true, true, true, true);
                transferfunctionToolStripMenuItem.Enabled = true;
               
            }
        }

        private void handleSaveFileMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Screenshots");
            string contentPath = Path.GetFullPath(relativePath);

            this.saveFileDialog.InitialDirectory = contentPath;

            this.saveFileDialog.Title = "Save Image as";

            this.saveFileDialog.Filter = "JPG Files (*.jpg)|*.jpg";

            if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                GameProperties.Instance.saveFilename = saveFileDialog.FileName;
                GameProperties.Instance.saveView = true;
                GameProperties.Instance.engineState.drawData = true;
            }
        }

        private void handleExitMenu(object sender, EventArgs e)
        {
            GameProperties.Instance.exitGame = true;

        }

        private void MainWindow_FormClosing(object sender, FormClosingEventArgs e)
        {
            GameProperties.Instance.exitGame = true;
        }
        #endregion

        #region functions menu
      
        private void handlePerspProjMenu(object sender, EventArgs e)
        {
            if (perspectiveProjectionToolStripMenuItem.Checked)
            {
                perspectiveProjectionToolStripMenuItem.Checked = false;
                orthogonalProjectionToolStripMenuItem.Checked = true;
                UniformArrowRadio.Checked = false;
                ScaledArrowRadio.Checked = true;
            }
            else
            {
                perspectiveProjectionToolStripMenuItem.Checked = true;
                orthogonalProjectionToolStripMenuItem.Checked = false;
                UniformArrowRadio.Checked = true;
                ScaledArrowRadio.Checked = false;
            }
            inputManager.enablePerspProjection(UniformArrowRadio.Checked);
        }

        private void handleOrthProjMenu(object sender, EventArgs e)
        {
            if (orthogonalProjectionToolStripMenuItem.Checked)
            {
                perspectiveProjectionToolStripMenuItem.Checked = true;
                orthogonalProjectionToolStripMenuItem.Checked = false;
                UniformArrowRadio.Checked = true;
                ScaledArrowRadio.Checked = false;
            }
            else
            {
                perspectiveProjectionToolStripMenuItem.Checked = false;
                orthogonalProjectionToolStripMenuItem.Checked = true;
                UniformArrowRadio.Checked = false;
                ScaledArrowRadio.Checked = true;
            }
            inputManager.enablePerspProjection(UniformArrowRadio.Checked);
        }

        //Blending
        private void handleBlendModeMenu(object sender, EventArgs e)
        {
            if (sender == frontToBackBlendingToolStripMenuItem)
            {
                if (frontToBackBlendingToolStripMenuItem.Checked)
                {
                    frontToBackBlendingToolStripMenuItem.Checked = false;
                    backToFrontBlendingToolStripMenuItem.Checked = true;
                }
                else
                {
                    frontToBackBlendingToolStripMenuItem.Checked = true;
                    backToFrontBlendingToolStripMenuItem.Checked = false;
                }

            }
            else if (sender == backToFrontBlendingToolStripMenuItem)
            {
                if (backToFrontBlendingToolStripMenuItem.Checked)
                {
                    frontToBackBlendingToolStripMenuItem.Checked = true;
                    backToFrontBlendingToolStripMenuItem.Checked = false;
                }
                else
                {
                    frontToBackBlendingToolStripMenuItem.Checked = false;
                    backToFrontBlendingToolStripMenuItem.Checked = true;
                }
 
            }
            inputManager.enableFrontToBackBlending(frontToBackBlendingToolStripMenuItem.Checked);
        }

        //Shading on/off
        private void handleShadingMenu(object sender, EventArgs e)
        {
            if (shadingToolStripMenuItem.Checked)
            {
                shadingToolStripMenuItem.Checked = false;
            }
            else
            {
                shadingToolStripMenuItem.Checked = true;
            }
            
            inputManager.enableShading(shadingToolStripMenuItem.Checked);
        }

        //transfer function

        private void handleLoadTransferFunctionMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Transferfunction");
            string contentPath = Path.GetFullPath(relativePath);

            this.openFileDialog.InitialDirectory = contentPath;

            this.openFileDialog.Title = "Load Transferfunction";

            this.openFileDialog.Filter = "XML Files (*.xml)|*.xml";

            if (this.openFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.inputManager.loadTransferFunction(openFileDialog.FileName);
                this.inputManager.updateXnaEngineState(false, false, true, true);
                this.inputManager.updateXnaTF(false, true);
                updateGuiTF(false, false, true, true);
            }
        }

       

        private void handleSaveTransferFunctionMenu(object sender, EventArgs e)
        {
            string relativePath = Path.Combine(assemblyLocation, "../../../../Data/Transferfunction");
            string contentPath = Path.GetFullPath(relativePath);

            this.saveFileDialog.InitialDirectory = contentPath;

            this.saveFileDialog.Title = "Save Transferfunction as";

            this.saveFileDialog.Filter = "XML Files (*.xml)|*.xml";

            if (this.saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                this.inputManager.saveTransferFunction(saveFileDialog.FileName);
            }
        }


        private void handleEditTransferFunctionMenu(object sender, EventArgs e)
        {
            TransferfunctionForm transferFunctionDialog = new TransferfunctionForm();
            transferFunctionDialog.Show();
        }



        #endregion

        #region help menu
        //
        #endregion

        #endregion

        #region settings panel (right tab panel)

        #region arrow plot tab
        private void handleArrowRadioButt(object sender, EventArgs e)
        {
            if (UniformArrowRadio.Checked)
            {
                inputManager.enableScaledArrowLength(false);
            }
            else 
            {
                inputManager.enableScaledArrowLength(true);
            }
        }

        private void handleArrowPlotScrollbar(object sender, EventArgs e)
        {
            if (sender == ArrowStepsizeScrollbar)
            {
                this.ArrowDensityLabel.Text = ArrowStepsizeScrollbar.Value.ToString();
                inputManager.setArrowPlotParam(1, (float)ArrowStepsizeScrollbar.Value);

            }
            else if (sender == ArrowAlphaScrollBar)
            {
               this.ArrowAlphaLabel.Text = ArrowAlphaScrollBar.Value.ToString();
               inputManager.setArrowPlotParam(2, (float)((float)ArrowAlphaScrollBar.Value / 255));

            }
          

        }

        private void handleArrowPlotTransFunctionCheckbox(object sender, EventArgs e)
        {
            inputManager.enableArrowPlotTransferFunction(this.ArrowPlotEnableColor.Checked);
        }

        private void handleArrowPlotCheckbox(object sender, EventArgs e)
        {
            inputManager.enableArrowPlot(this.EnableArrowPlotCheckBox.Checked);
        }
        #endregion

        #region channel tab

        private void handleEnableChannelsCheckBox(object sender, EventArgs e)
        {
            inputManager.enableChannels(EnableChannelsCheckbox.Checked);
        }

        private void handleChannelComboBoxSelect(object sender, EventArgs e)
        {
            GameProperties.Instance.currentChannelIdx = this.ChannelsCompoBox.SelectedIndex;
            currChannelIdx = this.ChannelsCompoBox.SelectedIndex;
            if (GameProperties.Instance.enableChannelTransferFunction)
            {
                TransferFunctionPanel.Refresh();
            }
            this.inputManager.updateXnaEngineState(false, false, true, true);
            this.updateChannelControlPoints = true;
            TransferFunctionPanel.Refresh();
        }

        private void handleComposeChannelsCheckBox(object sender, EventArgs e)
        {
            if (this.ComposeChannelsCheckBox.Checked)
            {
                //maximumIntensityProjectionToolStripMenuItem.Checked = true;
                //todo in the file menu
            }
            else
            {
                //maximumIntensityProjectionToolStripMenuItem.Checked = false;
                //todo in the file menu
            }
            inputManager.enableComposeChannels(this.ComposeChannelsCheckBox.Checked);
        }
        #endregion

        #region  transfer function panel





        private void handleTransferFunctionCheckbox(object sender, EventArgs e)
        {
            if (!transferfunctionCheckBox.Checked) 
            enableTransferfunctionToolStripMenuItem.Checked = transferfunctionCheckBox.Checked;
            inputManager.enableTransferFunction(transferfunctionCheckBox.Checked);
            TransferFunctionPanel.Refresh();
        }

        private void TransferFunctionPanel_Paint(object sender, PaintEventArgs e)
        {
          
            Graphics grobj = e.Graphics;
            //grobj.Clear(System.Drawing.SystemColors.Control);
            grobj.PageUnit = GraphicsUnit.Pixel;
            grobj.PageScale = 1;
            grobj.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias;

            int width = TransferFunctionPanel.Width;
            int height = TransferFunctionPanel.Height;
            grobj.DrawRectangle(penGray, new Rectangle(0, 0, width - 1, height - 1));

            if (!dataLoaded) return;

            #region arrow plot 
            if (sender == this.ArrowPlotColorPanel)//arrow plot color coding
            {
                width = ArrowPlotColorPanel.Width;
                height = ArrowPlotColorPanel.Height;

                //update control points
                if (updateArrowControlPoints)
                {
                    updateArrowControlPointsData();
                }

                //draw control points
                if (arrowControlPoints.Count() > 0)
                {

                    List<Point> pList = new List<Point>();
                    Color c1 = XNAToWindowsFormsColor(arrowControlPoints.First().Value.color);
                    Point p1 = new Point(arrowControlPoints.First().Key, 255 - c1.A);
                    pList.Add(p1);
                    p1.X -= controlPointSize.Width / 2;
                    p1.Y -= controlPointSize.Height / 2;

                    Rectangle rect = new Rectangle(p1, controlPointSize);
                    grobj.DrawRectangle(penBlack, rect); //border
                    grobj.FillRectangle(new SolidBrush(c1), rect);

                    IEnumerable<KeyValuePair<int, TransferControlPoint>> controlPointsTmp = arrowControlPoints.Skip(1);
                    foreach (KeyValuePair<int, TransferControlPoint> cp in controlPointsTmp)
                    {
                        //get first control point
                        Color c2 = XNAToWindowsFormsColor(cp.Value.color);
                        Point p2 = new Point(cp.Key, 255 - c2.A);
                        pList.Add(p2);
                        //get second control point if any
                        p2.X -= controlPointSize.Width / 2;
                        p2.Y -= controlPointSize.Height / 2;

                        rect = new Rectangle(p2, controlPointSize);
                        grobj.DrawRectangle(penBlack, rect); //border
                        grobj.FillRectangle(new SolidBrush(c2), rect);

                        p1 = p2;

                    }
                    grobj.DrawLines(penBlack, pList.ToArray());

                }

                //update colorbar
                if (GameProperties.Instance.updateArrowColor)
                {
                    updateArrowColorArrayData();
                }

                //draw colorbar
                if (arrowColorArray.Length > 0)
                {
                    Rectangle rect1;
                    colorBarSize.Width = tfStepsize; //draw color bar in correct stepsite too -> TODO
                    {
                        for (int i = 0; i < arrowColorArray.Length; i++)
                        {
                            grobj.FillRectangle(new SolidBrush(arrowColorArray[i]), new Rectangle(new Point(i, 0), new Size(1, height)));
                        }
                    }
                }
            }
            #endregion

            #region channels

            if (sender == this.TransferFunctionPanel) //channel color coding
            {
                width = TransferFunctionPanel.Width;
                height = TransferFunctionPanel.Height;

                //update control points
                if (updateChannelControlPoints)
                {
                    updateChannelControlPointsData();
                }

                //draw control points
                if (channelControlPoints.Count() > 0 && channelControlPoints[currChannelIdx].Count() > 0)
                {

                    List<Point> pList = new List<Point>();
                    Color c1 = XNAToWindowsFormsColor(channelControlPoints[currChannelIdx].First().Value.color);
                    Point p1 = new Point(channelControlPoints[currChannelIdx].First().Key, 255 - c1.A);
                    pList.Add(p1);
                    p1.X -= controlPointSize.Width / 2;
                    p1.Y -= controlPointSize.Height / 2;

                    Rectangle rect = new Rectangle(p1, controlPointSize);
                    grobj.DrawRectangle(penBlack, rect); //border
                    grobj.FillRectangle(new SolidBrush(c1), rect);

                    IEnumerable<KeyValuePair<int, TransferControlPoint>> controlPointsTmp = channelControlPoints[currChannelIdx].Skip(1);
                    foreach (KeyValuePair<int, TransferControlPoint> cp in controlPointsTmp)
                    {
                        //get first control point
                        Color c2 = XNAToWindowsFormsColor(cp.Value.color);
                        Point p2 = new Point(cp.Key, 255 - c2.A);
                        pList.Add(p2);
                        //get second control point if any
                        p2.X -= controlPointSize.Width / 2;
                        p2.Y -= controlPointSize.Height / 2;

                        rect = new Rectangle(p2, controlPointSize);
                        grobj.DrawRectangle(penBlack, rect); //border
                        grobj.FillRectangle(new SolidBrush(c2), rect);

                        p1 = p2;

                    }
                    grobj.DrawLines(penBlack, pList.ToArray());

                }

                //update colorbar
                if (GameProperties.Instance.updateChannelColor)
                {
                    updateChannelColorArrayData();
                }

                //draw colorbar
                if (channelColorArray.Count() > 0 && channelColorArray[currChannelIdx].Length > 0)
                {
                    Rectangle rect1;
                    colorBarSize.Width = tfStepsize; //draw color bar in correct stepsite too
                    {
                        for (int i = 0; i < channelColorArray[currChannelIdx].Length; i++)
                        {
                          grobj.FillRectangle(new SolidBrush(channelColorArray[currChannelIdx][i]), new Rectangle(new Point(i, 0), new Size(1, height)));
                        }
                    }
                }

            }
            #endregion

        }



        private void TransferFunctionPanel_MouseDown(object sender, MouseEventArgs e)
        {
            if (!dataLoaded) return;

            Point newPos = clampToPanelDimensions(e.X, e.Y, sender);

            if (e.Button == MouseButtons.Left) //select control point to move
            {
                tfPanelMouseDown = true;
                tfPanelMouseDownPos = newPos;
            }

            #region arrow plot control points
            if (sender == this.ArrowPlotColorPanel) 
            {
               
                #region create new control point or edit one
                if (e.Button == MouseButtons.Right) //create new control point or edit one
                {
                    ColorDialog colorPicker = new ColorDialog();
                    colorPicker.Color = XNAToWindowsFormsColor(GameProperties.Instance.arrowColorArray[newPos.X]);

                    //if user pick new color
                    if (colorPicker.ShowDialog() == DialogResult.OK)
                    {
                        Color color = colorPicker.Color;

                        int r = color.R;
                        int g = color.G;
                        int b = color.B;
                        float a = (float)((255.0f - newPos.Y) / 255.0f);

                        int key = getControlPointKey(newPos, sender);

                        if (key == -1) //add new control point
                        {
                            GameProperties.Instance.arrowControlPoints.Add(new TransferControlPoint(r, g, b, (int)(newPos.X / tfStepsize)));
                            GameProperties.Instance.arrowControlPoints.Last().color.W = a;
                            TransferControlPoint cpNew = new TransferControlPoint(r, g, b, (int)(newPos.X / tfStepsize));
                            cpNew.color.W = a;
                            arrowControlPoints.Add(newPos.X, cpNew);
                        }
                        else //edit color for the current one 
                        {
                            arrowControlPoints[key].color.X = r;
                            arrowControlPoints[key].color.Y = g;
                            arrowControlPoints[key].color.Z = b;
                            arrowControlPoints[key].color.W = a;

                            int currIsoValue = arrowControlPoints[key].isoValue;

                            for (int i = 0; i < GameProperties.Instance.arrowControlPoints.Count(); i++)
                            {
                                if (GameProperties.Instance.arrowControlPoints[i].isoValue == currIsoValue)
                                {
                                    GameProperties.Instance.arrowControlPoints[i].color.X = r;
                                    GameProperties.Instance.arrowControlPoints[i].color.Y = g;
                                    GameProperties.Instance.arrowControlPoints[i].color.Z = b;
                                    GameProperties.Instance.arrowControlPoints[i].color.W = a;
                                    i = GameProperties.Instance.arrowControlPoints.Count();
                                }
                            }

                        }

                        //debug
                        //Console.WriteLine("color piker value:" + "{" + r + ", " + g + ", " + b + "; " + a );

                        //refresh xna
                        inputManager.updateXnaEngineState(false, false, true, true);
                        //refresh graphic
                        //GameProperties.Instance.updateArrowColor = true;
                        ArrowPlotColorPanel.Refresh();

                    }
                }
                #endregion
            }
            #endregion

            #region channel control points
            if (sender == this.TransferFunctionPanel) 
            {

                #region create new control point or edit one
                if (e.Button == MouseButtons.Right) //create new control point or edit one
                {
                    ColorDialog colorPicker = new ColorDialog();
                    colorPicker.Color = XNAToWindowsFormsColor(GameProperties.Instance.colorArray[currChannelIdx][newPos.X]);

                    //if user pick new color
                    if (colorPicker.ShowDialog() == DialogResult.OK)
                    {
                        Color color = colorPicker.Color;

                        int r = color.R;
                        int g = color.G;
                        int b = color.B;
                        float a = (float)((255.0f - newPos.Y) / 255.0f);

                        int key = getControlPointKey(newPos, sender);

                        if (key == -1) //add new control point
                        {
                            GameProperties.Instance.channelControlPoints[currChannelIdx].Add(new TransferControlPoint(r, g, b, (int)(newPos.X / tfStepsize)));
                            GameProperties.Instance.channelControlPoints[currChannelIdx].Last().color.W = a;
                            TransferControlPoint cpNew = new TransferControlPoint(r, g, b, (int)(newPos.X / tfStepsize));
                            cpNew.color.W = a;
                            channelControlPoints[currChannelIdx].Add(newPos.X, cpNew);
                        }
                        else //edit color for the current one 
                        {
                            channelControlPoints[currChannelIdx][key].color.X = r;
                            channelControlPoints[currChannelIdx][key].color.Y = g;
                            channelControlPoints[currChannelIdx][key].color.Z = b;
                            channelControlPoints[currChannelIdx][key].color.W = a;

                            int currIsoValue = channelControlPoints[currChannelIdx][key].isoValue;

                            for (int i = 0; i < GameProperties.Instance.channelControlPoints[currChannelIdx].Count(); i++)
                            {
                                if (GameProperties.Instance.channelControlPoints[currChannelIdx][i].isoValue == currIsoValue)
                                {
                                    GameProperties.Instance.channelControlPoints[currChannelIdx][i].color.X = r;
                                    GameProperties.Instance.channelControlPoints[currChannelIdx][i].color.Y = g;
                                    GameProperties.Instance.channelControlPoints[currChannelIdx][i].color.Z = b;
                                    GameProperties.Instance.channelControlPoints[currChannelIdx][i].color.W = a;
                                    i = GameProperties.Instance.channelControlPoints[currChannelIdx].Count();
                                }
                            }

                        }

                        //debug
                        //Console.WriteLine("color piker value:" + "{" + r + ", " + g + ", " + b + "; " + a );

                        //refresh xna
                        inputManager.updateXnaEngineState(false, false, true, true);

                        //refresh graphic
                        GameProperties.Instance.updateChannelColor = true;
                        TransferFunctionPanel.Invalidate();

                    }
                }
                #endregion

            }
            #endregion

        }

        private void TransferFunctionPanel_MouseMove(object sender, MouseEventArgs e)
        {
            if (!dataLoaded) return;

            #region arrow plot control points
            if (sender == this.ArrowPlotColorPanel && tfPanelMouseDown)
            {
                int key = getControlPointKey(tfPanelMouseDownPos, sender); //old mouse pos
                if (key != -1)
                {
                    tfPanelMouseDownPos.X = key;
                    Point newPos = clampToPanelDimensions(e.X, e.Y, sender); //new mouse pos

                    int oldIsoValue = (tfPanelMouseDownPos.X / tfStepsize);
                    int newIsoValue = (newPos.X / tfStepsize);
                    float newAlpaValue = (float)((255 - newPos.Y) / 255.0f);

                    if (newIsoValue == oldIsoValue)//only alpha changed
                    {
                        arrowControlPoints[newPos.X].color.W = newAlpaValue;
                    }
                    else
                    {
                        //

                        TransferControlPoint cp = arrowControlPoints[tfPanelMouseDownPos.X];
                        cp.isoValue = newIsoValue;
                        cp.color.W = newAlpaValue;
                        arrowControlPoints.Remove(tfPanelMouseDownPos.X);
                        if (arrowControlPoints.ContainsKey(newPos.X)) //cp for this iso value already exists so override it
                            arrowControlPoints[newPos.X] = cp;
                        else arrowControlPoints.Add(newPos.X, cp);

                    }



                    for (int i = 0; i < GameProperties.Instance.arrowControlPoints.Count(); i++)
                    {
                        if (GameProperties.Instance.arrowControlPoints[i].isoValue == oldIsoValue)
                        {
                            GameProperties.Instance.arrowControlPoints[i].isoValue = newIsoValue;
                            GameProperties.Instance.arrowControlPoints[i].color.W = newAlpaValue;
                            i = GameProperties.Instance.arrowControlPoints.Count();
                        }
                    }


                    //update start pos for this control point
                    tfPanelMouseDownPos = newPos;

                    //refresh xna
                    inputManager.updateXnaEngineState(false, false, true, true);

                    //refresh graphic
                    //GameProperties.Instance.updateArrowColor = true;
                    ArrowPlotColorPanel.Refresh();
                }
            }

            #endregion

            #region channel control points
            if (sender == this.TransferFunctionPanel && tfPanelMouseDown) //channel plot control points
            {
               int key = getControlPointKey(tfPanelMouseDownPos, sender); //old mouse pos
                    if (key != -1)
                    {
                        tfPanelMouseDownPos.X = key;
                        Point newPos = clampToPanelDimensions(e.X, e.Y, sender); //new mouse pos

                        int oldIsoValue = (tfPanelMouseDownPos.X / tfStepsize);
                        int newIsoValue = (newPos.X / tfStepsize);
                        float newAlpaValue = (float)((255 - newPos.Y) / 255.0f);

                        if (newIsoValue == oldIsoValue)//only alpha changed
                        {
                            channelControlPoints[currChannelIdx][newPos.X].color.W = newAlpaValue;
                        }
                        else
                        {
                            //

                            TransferControlPoint cp = channelControlPoints[currChannelIdx][tfPanelMouseDownPos.X];
                            cp.isoValue = newIsoValue;
                            cp.color.W = newAlpaValue;
                            channelControlPoints[currChannelIdx].Remove(tfPanelMouseDownPos.X);
                            if (channelControlPoints[currChannelIdx].ContainsKey(newPos.X)) //cp for this iso value already exists so override it
                                channelControlPoints[currChannelIdx][newPos.X] = cp;
                            else channelControlPoints[currChannelIdx].Add(newPos.X, cp);

                        }



                        for (int i = 0; i < GameProperties.Instance.channelControlPoints[currChannelIdx].Count(); i++)
                        {
                            if (GameProperties.Instance.channelControlPoints[currChannelIdx][i].isoValue == oldIsoValue)
                            {
                                GameProperties.Instance.channelControlPoints[currChannelIdx][i].isoValue = newIsoValue;
                                GameProperties.Instance.channelControlPoints[currChannelIdx][i].color.W = newAlpaValue;
                                i = GameProperties.Instance.channelControlPoints[currChannelIdx].Count();
                            }
                        }


                        //update start pos for this control point
                        tfPanelMouseDownPos = newPos;

                        //refresh xna
                        inputManager.updateXnaEngineState(false, false, true, true);

                        //refresh graphic
                        GameProperties.Instance.updateChannelColor = true;
                        TransferFunctionPanel.Invalidate();
                    }
                
            }
            #endregion

        }

        private void TransferFunctionPanel_MouseUp(object sender, MouseEventArgs e)
        {
            tfPanelMouseDown = false;
        }

        #endregion

        #region streamline tab

        private void handleStreamlinesCheckBox(object sender, EventArgs e)
        {
            if (GameProperties.Instance.enableStreamlines == false)
            {
                GameProperties.Instance.enableStreamlines = true;
            }
            else
            {
                GameProperties.Instance.enableStreamlines = false;
            }

            inputManager.updateXnaEngineState(false, false, true, true);
        }


        private void handleStreamlineTab(object sender, EventArgs e)
        {
            if (sender == this.StreamlineDtNumUpDown)
            {
                inputManager.setStreamlineParam(1,(float)StreamlineDtNumUpDown.Value);
            }
            
            if (sender == this.StreamlineDsepSlider)
            {
                float newVal = ((float)StreamlineDsepSlider.Value )/ (StreamlineDsepSlider.Maximum - (StreamlineDsepSlider.LargeChange - 1));
                StreamlineDsepLabel.Text = newVal.ToString();
                inputManager.setStreamlineParam(2,newVal);

            }
            
            if (sender == this.StreamlineDtestSlider)
            {
                float newVal = ((float)StreamlineDtestSlider.Value) / (StreamlineDtestSlider.Maximum - (StreamlineDtestSlider.LargeChange - 1));
                StreamlineDtestLabel.Text = newVal.ToString();
                //set relative to dsep
                newVal *= ((float)StreamlineDsepSlider.Value )/ (StreamlineDsepSlider.Maximum - (StreamlineDsepSlider.LargeChange - 1));
                inputManager.setStreamlineParam(3, newVal);

            }
            
            if (sender == StreamlineStyleRadio1 || sender == StreamlineStyleRadio2
                || sender == StreamlineStyleRadio3 || sender == StreamlineStyleRadio4)
            {
                if (StreamlineStyleRadio1.Checked)
                {
                    inputManager.setStreamlineParam(5, false);
                }
                if (StreamlineStyleRadio2.Checked) //tapering
                {
                    inputManager.setStreamlineParam(2, true);
                }
                if (StreamlineStyleRadio3.Checked)//glyph mapping
                {
                    inputManager.setStreamlineParam(3, true);
                }
                if (StreamlineStyleRadio4.Checked)//texture generation
                {
                    inputManager.setStreamlineParam(4, true);
                }

            }
            if (sender == EulerRadioButton || sender == RungeKuttaRadioButton)
            {
                if (EulerRadioButton.Checked)
                    inputManager.setStreamlineParam(1, false); //runge kutta off
                else
                    inputManager.setStreamlineParam(1, true); //runge kutta on
            }

            if (sender == StreamlineLengthUpDown)
            {
                inputManager.setStreamlineParam(4, (float)StreamlineLengthUpDown.Value);
            }

            if (sender == StreamlineWidthUpDown)
            {
                inputManager.setStreamlineParam(5, (float)StreamlineWidthUpDown.Value * GameProperties.Instance.Dtest);
            }
            
        }
        #endregion

        #region extended features
        private void handleChangeActiveTab(object sender, TabControlCancelEventArgs e)
        {
            if (sender == SettingsPanel)
            {
                if(SettingsPanel.SelectedTab.Equals(ArrowPlotTab))
                {
                    GameProperties.Instance.activeTab = ActiveTab.ArrowTab;
                }
                if (SettingsPanel.SelectedTab.Equals(ChannelsTab))
                {
                    GameProperties.Instance.activeTab = ActiveTab.ChannelsTab;
                }
                if (SettingsPanel.SelectedTab.Equals(StreamlinesTab))
                {
                    GameProperties.Instance.activeTab = ActiveTab.StreamlinesTab;
                }
            }

        }

        private void handleActiveTabChange(object sender, EventArgs e)
        {
            if (sender == this.XNADrawSurface)
            {
                GameProperties.Instance.activeTab = ActiveTab.XnaDrawSurface;
            }
            if (sender == this.MainMenu)
            {
                GameProperties.Instance.activeTab = ActiveTab.MainMenu;
            }
            if (sender == ArrowPlotTab)
            {
                GameProperties.Instance.activeTab = ActiveTab.ArrowTab;
            }
            if (sender == ChannelsTab)
            {
                GameProperties.Instance.activeTab = ActiveTab.ChannelsTab;
            }
            if (sender == StreamlinesTab)
            {
                GameProperties.Instance.activeTab = ActiveTab.StreamlinesTab;
            }
        }


        private void handlePerspProjRadioButt(object sender, EventArgs e)
        {
            perspectiveProjectionToolStripMenuItem.Checked = true;
            orthogonalProjectionToolStripMenuItem.Checked = false;
            inputManager.enablePerspProjection(true);
        }

        private void handleOrthProjRadioButt(object sender, EventArgs e)
        {
            perspectiveProjectionToolStripMenuItem.Checked = false;
            orthogonalProjectionToolStripMenuItem.Checked = true;
            inputManager.enablePerspProjection(false);
        }

        private void handleBlendRadioButt1(object sender, EventArgs e)
        {
            frontToBackBlendingToolStripMenuItem.Checked = true;
            backToFrontBlendingToolStripMenuItem.Checked = false;
            inputManager.enableFrontToBackBlending(true);
        }

        private void handleBlendRadioButt2(object sender, EventArgs e)
        {
            frontToBackBlendingToolStripMenuItem.Checked = false;
            backToFrontBlendingToolStripMenuItem.Checked = true;
            inputManager.enableFrontToBackBlending(false);
        }

        #endregion

        #endregion

        #endregion

        #region helper functions

        #region arrow plot
        private void updateArrowControlPointsData()
        {
            //load initial control points or from a xml file defintion, and channel count information
            if (GameProperties.Instance.arrowControlPoints != null && GameProperties.Instance.arrowControlPoints.Count() > 0)
            {
                arrowControlPoints.Clear();
                for (int i = 0; i < GameProperties.Instance.arrowControlPoints.Count(); i++)
                {
                   int cpValue = GameProperties.Instance.arrowControlPoints[i].isoValue;
                   TransferControlPoint cpNext = GameProperties.Instance.arrowControlPoints[i];
                   arrowControlPoints.Add(cpValue, cpNext);
                }

            }
            updateArrowControlPoints = false;
        }

        private void updateArrowColorArrayData()
        {
            if (GameProperties.Instance.arrowColorArray != null && GameProperties.Instance.arrowColorArray.Count() > 0)
            {

                for (int i = 0; i < GameProperties.Instance.arrowColorArray.Count(); i++)
                {
                    this.arrowColorArray[i] = Color.FromArgb(GameProperties.Instance.arrowColorArray[i].A,
                                                    GameProperties.Instance.arrowColorArray[i].R,
                                                    GameProperties.Instance.arrowColorArray[i].G,
                                                    GameProperties.Instance.arrowColorArray[i].B);

                }

               //updateArrowColorArray = false;
               GameProperties.Instance.updateArrowColor = false;
               
            }
        }
        #endregion

        #region channels
        private void updateChannelControlPointsData()
        {

            //load initial control points or from a xml file defintion, and channel count information
            if (GameProperties.Instance.channelControlPoints != null && GameProperties.Instance.channelControlPoints.Count() > 0)
            {
                channelControlPoints.Clear();
                channelColorArray.Clear();
                for (int i = 0; i < GameProperties.Instance.channelControlPoints.Count(); i++)
                {
                    SortedDictionary<int, TransferControlPoint> cpList = new SortedDictionary<int,TransferControlPoint>();
                    for (int j = 0; j < GameProperties.Instance.channelControlPoints[i].Count(); j++)
                    {
                        int cpValue = GameProperties.Instance.channelControlPoints[i][j].isoValue;
                        TransferControlPoint cpNext = GameProperties.Instance.channelControlPoints[i][j];
                        cpList.Add(cpValue, cpNext);
                    }
                    channelControlPoints.Add(cpList);
                    channelColorArray.Add(new Color[256]);
                    
                }

            }
            
            
            updateChannelControlPoints = false;
        }

        private void updateChannelColorArrayData()
        {
            if (GameProperties.Instance.colorArray != null && GameProperties.Instance.colorArray.Count() > 0)
            {
                
                for (int i = 0; i < GameProperties.Instance.colorArray[currChannelIdx].Count(); i++)
                {
                    this.channelColorArray[currChannelIdx][i] = Color.FromArgb(GameProperties.Instance.colorArray[currChannelIdx][i].A, 
                                                    GameProperties.Instance.colorArray[currChannelIdx][i].R, 
                                                    GameProperties.Instance.colorArray[currChannelIdx][i].G, 
                                                    GameProperties.Instance.colorArray[currChannelIdx][i].B);
                    
                }

                //updateChannelColorArray = false;
                GameProperties.Instance.updateChannelColor = false;
            }
        }
        #endregion

        private void updateGuiTF(bool updateArrowControlPoints, bool updateArrowColor, bool updateChannelControlPoints, bool updateChannelColor)
        {
            this.updateArrowControlPoints = updateArrowControlPoints;
            
            this.updateChannelControlPoints = updateChannelControlPoints;

            if (this.updateArrowControlPoints)
            {
                ArrowPlotColorPanel.Invalidate();

            }
            if (this.updateChannelControlPoints)
            {
                TransferFunctionPanel.Invalidate();

            }

        }
        private Color XNAToWindowsFormsColor(Microsoft.Xna.Framework.Vector4 xnaColor)
        {
            int r = (int)(xnaColor.X);
            int g = (int)(xnaColor.Y);
            int b = (int)(xnaColor.Z);
            int a = (int)(xnaColor.W * 255);

            Color color = Color.FromArgb(a, r, g, b);
            return color;
        }

        private Color XNAToWindowsFormsColor(Microsoft.Xna.Framework.Graphics.Color xnaColor)
        {
            Color color = Color.FromArgb((int)xnaColor.A, (int)xnaColor.R, (int)xnaColor.G, (int)xnaColor.B);
            return color;
        }


        private Color lerpColor(Color c1, Color c2, float amount)
        {
            int r = (int)(c1.R + amount * (c2.R - c1.R));
            int g = (int)(c1.G + amount * (c2.G - c1.G));
            int b = (int)(c1.B + amount * (c2.B - c1.B));
            int a = (int)(c1.A + amount * (c2.A - c1.A));
            Color lerpColor = Color.FromArgb(a, r, g, b);
            lerpColor = Color.FromArgb(255, lerpColor);

            return lerpColor;
        }

       
        private int getControlPointKey(Point mousePos, Object sender)
        {
            if (sender == this.ArrowPlotColorPanel)
            {
                if (arrowControlPoints.ContainsKey(mousePos.X)) return mousePos.X;
                else
                {
                    foreach (int key in arrowControlPoints.Keys)
                    {
                        if (mousePos.X >= (key - (controlPointSize.Width / 2)) &&
                            mousePos.X <= (key + (controlPointSize.Width / 2)))
                        {
                            return key;
                        }
                    }
                }
            }

            if (sender == this.TransferFunctionPanel)
            {
                if (channelControlPoints[currChannelIdx].ContainsKey(mousePos.X)) return mousePos.X;
                else
                {
                    foreach (int key in channelControlPoints[currChannelIdx].Keys)
                    {
                        if (mousePos.X >= (key - (controlPointSize.Width / 2)) &&
                            mousePos.X <= (key + (controlPointSize.Width / 2)))
                        {
                            return key;
                        }
                    }
                }
            }
            return -1;
        }

        private Point clampToPanelDimensions(int posX, int posY, Object sender)
        {
            int width = 256;
            int height = 256;

            if (sender == this.TransferFunctionPanel)
            {
                width = this.TransferFunctionPanel.Width;
                height = this.TransferFunctionPanel.Height;
            }

            if (sender == this.ArrowPlotColorPanel)
            {
                width = this.ArrowPlotColorPanel.Width;
                height = this.ArrowPlotColorPanel.Height;
            }

            Point p = new Point(posX, posY);
            if (p.X < 0) { p.X = 0; }
            else if (p.X > width - 1)
            { p.X = width - 1; }
            if (p.Y < 0) { p.Y = 0; }
            else if (p.Y > height - 1)
            { p.Y = height - 1; }

            return p;
        }
        #endregion

        #region handle xna draw surface events


        private void handleXNADrawSurface_MouseDown(object sender, MouseEventArgs e)
        {
            inputManager.XnaDrawSurface_MouseDownEvent = true;
            inputManager.MouseDownPosX = e.X;
            inputManager.MouseDownPosY = e.Y;
        
        }

        private void handleXNADrawSurface_MouseUp(object sender, MouseEventArgs e)
        {
            inputManager.XnaDrawSurface_MouseDownEvent = false;
        }

        private void handleXNADrawSurface_MouseMove(object sender, MouseEventArgs e)
        {
            if (inputManager.XnaDrawSurface_MouseDownEvent)
            {
                inputManager.updateMousePos(e.X, e.Y);
                inputManager.updateXnaEngineState(true, false, true, true);
            }
        }

        private void handleXNADrawSurface_MouseScroll(object sender, MouseEventArgs e)
        {
            if (inputManager.XnaDrawSurface_MouseDownEvent)
            {
                inputManager.updateMouseScroll(e.Delta / SystemInformation.MouseWheelScrollDelta);
                inputManager.updateXnaEngineState(true, false, true, true);
            }
        }
        #endregion

        

       



    }
}