private void btnOpenFile_ClickClear(object sender, RoutedEventArgs e)
 {
     MainPlot.plt.Clear();
     MainPlot.Render();
     //Resets our datagrid size since the user may want to look at the graph
     DGrid.Margin      = new System.Windows.Thickness(0, 369, 0, 0);
     DGrid.DataContext = null;
     PopOut.IsEnabled  = false;
     dgrab             = null;
 }
 private void YOffsetBox_TextChanged(object sender, System.Windows.Controls.TextChangedEventArgs e)
 {
     Double.TryParse(YOffsetBox.Text, out yOffset);
     if (dgrab != null)
     {
         MainPlot.plt.Clear();
         createScatterPlot();
         MainPlot.Render();
     }
 }
        private void Button_Click(object sender, RoutedEventArgs e)
        {
            if (_isExist)
            {
                _isExist = false;
                MainPlot.DestroyGraph();
            }
            else
            {
                _isExist             = true;
                Mouse.OverrideCursor = Cursors.Wait;

                //1. Call Matlab to draw plot.
                _matlabController.matlab_plot();

                //2. Build plot in your WPF Window.
                MainPlot.BuildGraph("Figure 1");

                Mouse.OverrideCursor = null;
            }
        }
        private void btnOpenFile_Click(object sender, RoutedEventArgs e)
        {
            OpenFileDialog openFileDialog = new OpenFileDialog();

            if (openFileDialog.ShowDialog() == true)
            {
                btnOpenFile_ClickClear(sender, e);
                dgrab = new DataGrabber(openFileDialog.FileName);

                PopOut.IsEnabled = true;

                //Resets our datagrid size since the user may want to look at the graph
                DGrid.Margin = new System.Windows.Thickness(0, 369, 0, 0);

                createScatterPlot();
                MainPlot.Render();

                dtb = dgrab.df.ToDataTable();
                DGrid.DataContext = dtb;
            }
        }
        private void plotMouseDoubleClick(object sender, MouseEventArgs e)
        {
            (double mouseX, double mouseY) = MainPlot.GetMouseCoordinates();
            sph.HighlightClear();
            var(trackerX, trackerY, index) = sph.HighlightPointNearest(mouseX, mouseY);

            for (int i = 0; i < dtb.Rows.Count; i++)
            {
                DataTable curTable = (DataTable)DGrid.DataContext;
                DataRow   curRow   = curTable.Rows[i];

                string cellContent = String.Join(", ", curRow.ItemArray);

                if (cellContent.Contains(trackerX.ToString()) && cellContent.Contains(trackerY.ToString()))
                {
                    DGrid.ScrollIntoView(DGrid.Items[i]);
                    DGrid.SelectedIndex = i;
                    DGrid.UpdateLayout();
                }
            }
            MainPlot.Render();
        }
        public override bool ProcessUserEvent(InputEvent evt)
        {
            switch (evt.Type)
            {
            case eInputEventType.MouseClick:
                if (evt.MouseButtons == System.Windows.Forms.MouseButtons.Right)
                {
                    ContextMenu contextMenu = new ContextMenu();
                    MenuItem    menuItem1   = new MenuItem("FFT Area Selection");
                    MenuItem    menuItem2   = new MenuItem("-");
                    MenuItem    menuItem3   = new MenuItem("Dragable");
                    MenuItem    menuItem4   = new MenuItem("-");
                    MenuItem    menuItem5   = new MenuItem("Area mode");
                    MenuItem    menuItem6   = new MenuItem("Carrier mode");

                    menuItem1.Enabled = false;
                    menuItem3.Checked = Selection.Draggable;
                    menuItem5.Checked = (Mode == FFTAreaSelection.eOperationMode.Area);
                    menuItem6.Checked = (Mode == FFTAreaSelection.eOperationMode.Carriers);

                    contextMenu.MenuItems.AddRange(new MenuItem[] { menuItem1, menuItem2, menuItem3, menuItem4, menuItem5, menuItem6 });

                    menuItem3.Click += new EventHandler(delegate(object sender, EventArgs e)
                    {
                        Selection.Draggable = !Selection.Draggable;
                    });

                    menuItem5.Click += new EventHandler(delegate(object sender, EventArgs e)
                    {
                        Mode = FFTAreaSelection.eOperationMode.Area;
                    });

                    menuItem6.Click += new EventHandler(delegate(object sender, EventArgs e)
                    {
                        Mode = FFTAreaSelection.eOperationMode.Carriers;
                    });


                    System.Drawing.Point mousePos = new System.Drawing.Point();
                    mousePos.X = (int)Form.MousePosition.X;
                    mousePos.Y = (int)Form.MousePosition.Y;

                    System.Drawing.Point popupPos = MainPlot.PointToClient(mousePos);

                    popupPos.X -= 2;
                    popupPos.Y -= 2;

                    contextMenu.Show(MainPlot, popupPos);
                    return(true);
                }
                break;

            case eInputEventType.MouseButtonDown:
            case eInputEventType.MouseButtonUp:
            case eInputEventType.KeyDown:
            case eInputEventType.MouseMoved:
                return(true);

            case eInputEventType.MouseWheel:
                if (Mode == FFTAreaSelection.eOperationMode.Carriers)
                {
                    Selection.Carriers += Math.Sign(evt.MouseWheelDelta);
                    Selection.Carriers  = Math.Max(0, Math.Min(256, Selection.Carriers));

                    Selection.UpdatePositions();
                    PositionUpdated = true;
                }
                return(true);
            }

            return(base.ProcessUserEvent(evt));
        }
Exemple #7
0
        public override bool ProcessInputEvent(InputEvent evt)
        {
            bool docksChanged = false;

            if (!HasDocks)
            {
                DocksChanged = false;
                return(false);
            }

            bool  defaultCursor = false;
            bool  handled       = false;
            Point mousePos      = evt.MousePosition;

            /* update alpha */
            if (FadeOutByDistance)
            {
                switch (evt.Type)
                {
                case eInputEventType.MouseLeave:
                    WantedTitleBarAlpha = 0;
                    docksChanged        = true;
                    break;

                case eInputEventType.MouseMoved:
                    double distance;

                    switch (Orientation)
                    {
                    case eOrientation.RightBorder:
                        distance = LeftMostPosition - mousePos.X;
                        break;

                    case eOrientation.LeftBorder:
                        distance = RightMostPosition - mousePos.X;
                        break;

                    case eOrientation.TopBorder:
                        distance = BottomMostPosition - mousePos.Y;
                        break;

                    case eOrientation.BottomBorder:
                        distance = TopMostPosition - mousePos.Y;
                        break;

                    default:
                        distance = 0;
                        break;
                    }

                    /* calculate alpha value by distance */
                    distance = Math.Min(1, (Math.Max(0, distance)) / FadeOutDistance);
                    double newAlpha = (1 - distance);

                    if (newAlpha != WantedTitleBarAlpha)
                    {
                        WantedTitleBarAlpha = newAlpha;
                        docksChanged        = true;
                    }
                    break;
                }
            }

            lock (Docks)
            {
                foreach (Dock dock in Docks)
                {
                    DockPanelPrivate priv = dock.Private;

                    if (priv.TitleHighlighted)
                    {
                        docksChanged = true;
                    }

                    priv.TitleHighlighted = false;

                    bool hoveringTitle     = (mousePos.X > priv.TitleHitRect.X && mousePos.X < priv.TitleHitRect.X + priv.TitleHitRect.Width) && (mousePos.Y > priv.TitleHitRect.Y && mousePos.Y < priv.TitleHitRect.Y + priv.TitleHitRect.Height);
                    bool hoveringBackTitle = (mousePos.X > priv.BackTitleHitRect.X && mousePos.X < priv.BackTitleHitRect.X + priv.BackTitleHitRect.Width) && (mousePos.Y > priv.BackTitleHitRect.Y && mousePos.Y < priv.BackTitleHitRect.Y + priv.BackTitleHitRect.Height);

                    /* check if hovering over title bar */
                    if (hoveringTitle || hoveringBackTitle)
                    {
                        //defaultCursor = true;
                        priv.TitleHighlighted = true;
                        docksChanged          = true;
                        handled = true;

                        /* in case of a click */
                        if (evt.Type == eInputEventType.MouseClick && evt.MouseButtons == MouseButtons.Left)
                        {
                            ToggleDock(dock);
                        }
                    }
                }
            }

            if (!handled)
            {
                lock (Docks)
                {
                    foreach (Dock dock in Docks)
                    {
                        switch (dock.State)
                        {
                        case eDockState.Expanded:
                        {
                            if (mousePos.X > dock.XPosition && mousePos.X < (dock.XPosition + dock.Width) &&
                                mousePos.Y > dock.YPosition && mousePos.Y < (dock.YPosition + dock.Height))
                            {
                                handled = dock.ProcessUserEvent(evt);

                                /* dock handled the event, also rerender now */
                                docksChanged |= handled;
                            }
                        }
                        break;

                        case eDockState.Expanding:
                        case eDockState.Collapsing:
                            docksChanged = true;
                            break;
                        }
                    }
                }
            }

            if (handled)
            {
                defaultCursor = true;
            }

            /* need to set default cursor? */
            if (defaultCursor)
            {
                /* do that, if not already done */
                if (!SetDefaultCursor)
                {
                    SetDefaultCursor = true;
                    MainPlot.CursorType(true);
                }
            }
            else if (SetDefaultCursor)
            {
                /* set before, but do not need anymore */
                MainPlot.CursorType(false);
                SetDefaultCursor = false;
            }

            DocksChanged = docksChanged;
            return(handled);
        }