Beispiel #1
0
        private void Edit_Keys_Load( object sender, EventArgs e )
        {
            WavesToolbar = ( Token_Toolbar )this.Owner;

            // Make sure nothing gets edited when the DataViewGrid gets populated
            lockKeys = true;

            // Create a second copy of our list of KeyCommand.  Since when the DataListGrid is edited, it also actually
            //   edits the "DataSource" (which will be KeyCommand), we need this second copy in case the user makes a
            //   mistake in selecting a shortcut key for a menu.  If this validation fails, the backup will be a fallback.
            for ( int i = 0; i < Token_Toolbar.KeyCommand.Count(); i++ ) {
                keyCommandsBackup[ i ] = new KeyCombo();
                keyCommandsBackup[ i ]._alt = Token_Toolbar.KeyCommand[ i ]._alt;
                keyCommandsBackup[ i ]._ctrl = Token_Toolbar.KeyCommand[ i ]._ctrl;
                keyCommandsBackup[ i ]._mainKey = Token_Toolbar.KeyCommand[ i ]._mainKey;
            }

            // Initialize the DataGridView control.
            DATAGRID_Keys.DataSource = Token_Toolbar.KeyCommand;
            DATAGRID_Keys.RowHeadersWidth = 225;
            SetHeaders();
            DATAGRID_Keys.AutoResizeColumns();
            DATAGRID_Keys.Columns[ 2 ].Width = 75;

            // This makes the 4th column invisible
            DATAGRID_Keys.Columns[ 3 ].Visible = false;

            // Set the form's color scheme appropriately
            SetFormColors();

            // Set whether this window will be on top of all other windows
            this.TopMost = WavesToolbar.MENU_View_AlwaysOnTop.Checked;

            // Everything is alright to go!
            lockKeys = false;
        }
Beispiel #2
0
        /// <summary>
        /// This function tests the currently edited shortcut key to make sure it is a valid shortcut combination
        /// </summary>
        /// <param name="dgv">A handle to the Key Combination DataGridView</param>
        private void TestShortcutKey( DataGridView dgv )
        {
            // First, get the keycode for the currently edited row
            int row = dgv.CurrentCellAddress.Y;
            KeyCombo com = new KeyCombo( ( bool )dgv[ 0, row ].EditedFormattedValue, ( bool )dgv[ 1, row ].EditedFormattedValue, ( string )dgv[ 2, row ].EditedFormattedValue );

            // If this combo is the same as the backup version... it never changed
            if ( ( com._mainKey == keyCommandsBackup[ row ]._mainKey ) &&
                 ( com._alt == keyCommandsBackup[ row ]._alt ) &&
                 ( com._ctrl == keyCommandsBackup[ row ]._ctrl ) )                 return;

            // The function "IsValidShortcut" does the heavy lifting for this operation
            if ( com.IsValidShortcut() ) {
                // These assignments are automatic and are not explicitly needed!
                //   KeyCommand[row].Ctrl = (bool)dgv[0, row].Value;
                //   KeyCommand[row].Alt = (bool)dgv[1, row].Value;
                //   KeyCommand[row].mainKey = (string)dgv[2, row].Value;

                anyChangesMade = true;
            }
            else
            {
                // The user entered invalid data.  Restore the originally backed up combo (although this might be Keys.None)!
                dgv[ 0, row ].Value = keyCommandsBackup[ row ]._ctrl;
                dgv[ 1, row ].Value = keyCommandsBackup[ row ]._alt;
                dgv[ 2, row ].Value = keyCommandsBackup[ row ]._mainKey;
            }
        }
        // *******************************************************************************************************************
        //   The following functions provide the user with speech prompting when a control is entered.
        //       Most controls may be entered by [TAB] or by arrow key, or by entering it's location via mouse.
        // *******************************************************************************************************************
        /// <summary>
        /// Bind to both "Enter" and "MouseEnter" events for dynamic token/element buttons to allow voice prompting.
        /// </summary>
        /// <param name="sender">The object (castable to "Button") that raised the event</param>
        /// <param name="e">Event data pertinent to Enter and MouseEnter events</param>
        private void Button_Dynamic_Enter( object sender, EventArgs e )
        {
            // This event is bound to both "Enter" and "MouseEnter" events.
            //   Its purpose is to provide a speech prompt and visible prompt for what the dynamic button represents

            Button button = sender as Button;

            string saySpeech = "";                  // This will be the speech to be spoken
            string showSymbol = "";
            //string typeSymbol = "token";

            KeyCombo showShortcut = new KeyCombo( true, false, "" );

            if( button != null ) {
                // Check master token list for this button's speech text

                // First, check <mo> tags
                foreach( Token tok in MasterToken._mo ) {
                    if( tok != null )
                        if( tok._symbol == ( string )button.Text ) {
                            saySpeech = tok._speech;
                            showSymbol = tok._symbol;

                            showShortcut.GetWavesTokenShortcut( this, button, false );
                        }
                }

                // Then, check <mi> tags if not yet found
                if( saySpeech == "" ) {
                    foreach( Token tok in MasterToken._mi ) {
                        if( tok != null )
                            if( tok._symbol == ( string )button.Text ) {
                                saySpeech = tok._speech;
                                showSymbol = tok._symbol;

                                showShortcut.GetWavesTokenShortcut( this, button, false );
                            }
                    }
                }

                // Then, check element tags if not yet found
                if( saySpeech == "" ) {
                    foreach( Token tok in MasterToken._mathMLelement ) {
                        if( tok._symbol == ( string )button.Name ) {
                            saySpeech = tok._speech;
                            showSymbol = tok._symbol;
                            //typeSymbol = "element";

                            showShortcut.GetWavesTokenShortcut( this, button, true );
                        }
                    }
                }

                // And so, we should now have speech to say... flush the Speaker buffer and initialize the current sound byte
                if( MENU_Options_VoicePrompting.Checked ) {
                    Speaker.SpeakAsyncCancelAll();
                    Speaker.SpeakAsync( saySpeech );
                }

                string tooltipMessage = "Add \"" + showSymbol + "\" to formula (" + showShortcut.GetKeyCombo() + ")";
                TOOLTIP_Display.SetToolTip( button, tooltipMessage );
            }

            // Log the control on the form that has been entered
            //for( int i = 0; i < Controls.Count; i++ ) {
            //	if( Controls[ i ] == button )
            //		DynamicSelected = i;
            //}
        }
        private void Token_Toolbar_KeyUp( object sender, KeyEventArgs e )
        {
            // This event determines what to do when a key has been released.  Because of the argument difference between
            //   the KeyPress event and this KeyUp event, the KeyUp event is actually the more versatile of the two events.
            //   This function used to deal with key-combos and keycodes that are important to the overall working of the
            //   toolbar.

            // It is now a shadow of what it once was.  It only drives the selection of excerpts, via up/down arrow presses.

            // The Down key selects the next excerpt in the List
            if( e.KeyData == Keys.Down ) {
                if( LISTBOX_ShowExcerpts.SelectedIndex < ( LISTBOX_ShowExcerpts.Items.Count - 1 ) )
                    LISTBOX_ShowExcerpts.SelectedIndex += 1;
            }

            // The Up Arrow key selects the last excerpt in the List, and activates the List
            if( e.KeyData == Keys.Up ) {
                if( LISTBOX_ShowExcerpts.SelectedIndex > 0 )
                    LISTBOX_ShowExcerpts.SelectedIndex -= 1;
            }

            // Test the particular keyboard shortcut that fired this event, and
            //   test the keyboard state against the shortcuts that fire dynamic button clicks
            KeyCombo keysPressed = new KeyCombo( e.Control, e.Alt, GetLeastSignificantBits( ( int )e.KeyData ).ToString() );

            Button button = GetButtonFromShortcut( keysPressed );

            if( button != null ) {
                if( !TEXTBOX_MathExpression.Focused )
                    TEXTBOX_MathExpression.SelectionStart = TEXTBOX_MathExpression.Text.Length;
                button.PerformClick();
            }
            //showShortcut.GetWavesTokenShortcut( this, button, false );
        }
        /// <summary>
        /// Assigns a keystoke combination to an existing ToolStripMenuItem, if possible.
        /// </summary>
        /// <param name="key">Keystroke combination to assign</param>
        /// <param name="menu">Menu item to which to assign the keystroke combination</param>
        public void AssignKeyToMenu( KeyCombo key, ToolStripMenuItem menu )
        {
            Keys newCombo = new Keys();
            KeysConverter kc = new KeysConverter();

            //menu.ShortcutKeys = Keys.None;
            try {
                // This command can throw an exception if mainKey is not set.
                // This, however, is fine; it just means there is no keyboard shortcut for this item.
                newCombo = ( Keys )kc.ConvertFromString( key._mainKey );
                if( key._ctrl )
                    newCombo = newCombo | Keys.Control;
                if( key._alt )
                    newCombo = newCombo | Keys.Alt;

                menu.ShortcutKeys = ( Keys )newCombo;
            }
            catch //(Exception ex)
            {
                menu.ShortcutKeys = Keys.None;
                //MessageBox.Show(ex.ToString());
            }
        }
        /// <summary>
        /// Loads all Keystroke combinations for various editor commands from an external XML file.
        /// </summary>
        /// <param name="filename">The XML document to parse</param>
        /// <returns>0 if successful, -1 if failed</returns>
        private int ParseKeyMappingDOM( string filename )
        {
            // First of all, we test to see if the XML file we are going to be parsing exists...
            if( System.IO.File.Exists( filename ) ) {
                // Load the XML document
                XmlDocument keyXML = new XmlDocument();
                keyXML.Load( filename );

                int id = 0;

                // Parse the document, looking for only direct children of the "/all" node.
                //   Note:  This will work so long as the direct children aren't called "control", "alt", or "key"!
                //foreach (XmlNode node in keyXML.SelectNodes("/all/*"))
                foreach( XmlNode node in keyXML.DocumentElement.ChildNodes ) {
                    //                    if (node.Name.ToLower() != "control" && node.Name.ToLower() != "alt" && node.Name.ToLower() != "key")
                    //                    {
                    // This is a shortcut key.  Add it into our data structure.
                    // id is used, and then increment after the execution of the next statement
                    KeyCommand[ id++ ] = new KeyCombo( node.Name, node.ChildNodes[ 0 ].InnerText, node.ChildNodes[ 1 ].InnerText, node.ChildNodes[ 2 ].InnerText );
                    //id++;
                    //                    }
                }

                // Assign the shortcut keys to the menus
                AssignKeyToMenu( KeyCommand[ 0 ], MENU_Formula_New );
                AssignKeyToMenu( KeyCommand[ 1 ], MENU_Formula_ImportMathML );
                AssignKeyToMenu( KeyCommand[ 2 ], MENU_Formula_Undo );
                AssignKeyToMenu( KeyCommand[ 3 ], MENU_Formula_ClearExcerpt );
                AssignKeyToMenu( KeyCommand[ 4 ], MENU_Formula_Read );
                AssignKeyToMenu( KeyCommand[ 5 ], MENU_Formula_CopyClipboard );
                AssignKeyToMenu( KeyCommand[ 6 ], MENU_Formula_ExportMathML );
                AssignKeyToMenu( KeyCommand[ 7 ], MENU_Formula_ExportGraphic );
                AssignKeyToMenu( KeyCommand[ 8 ], MENU_Formula_Close );
                AssignKeyToMenu( KeyCommand[ 9 ], MENU_View_AlwaysOnTop );
                AssignKeyToMenu( KeyCommand[ 10 ], MENU_View_HideMenu );
                AssignKeyToMenu( KeyCommand[ 11 ], MENU_View_MathJax );
                AssignKeyToMenu( KeyCommand[ 12 ], MENU_View_Level2 );
                AssignKeyToMenu( KeyCommand[ 13 ], MENU_View_Repository );
                AssignKeyToMenu( KeyCommand[ 14 ], MENU_View_Autotune );
                AssignKeyToMenu( KeyCommand[ 15 ], MENU_Options_EnglishExcerpts );
                AssignKeyToMenu( KeyCommand[ 16 ], MENU_Options_HighContrast );
                AssignKeyToMenu( KeyCommand[ 17 ], MENU_Options_ReadAsPower );
                AssignKeyToMenu( KeyCommand[ 18 ], MENU_Options_VoicePrompting );
                AssignKeyToMenu( KeyCommand[ 19 ], MENU_Options_EditKeyboard );
                AssignKeyToMenu( KeyCommand[ 20 ], MENU_Options_EditMasterTokenList );
                AssignKeyToMenu( KeyCommand[ 21 ], MENU_Help_Index );
                AssignKeyToMenu( KeyCommand[ 22 ], MENU_Help_About );
                //                AssignKeyToMenu(KeyCommand[20], MENU_Help_Shortcuts);
                //                AssignKeyToMenu(KeyCommand[21], MENU_Help_About);

                // Alert calling function of success
                return 0;
            }
            else {
                // Show error and alert calling function of FAILURE

                Token_Toolbar.ShowError( 4 );
                return -1;
            }
        }
        /// <summary>
        /// This returns the Button to activate, if necessary, from a Shortcut.
        /// </summary>
        /// <param name="keys">The keystroke combination being tried</param>
        /// <returns>The Button to click, or null if the shortcut didn't click any button</returns>
        private Button GetButtonFromShortcut( KeyCombo keys )
        {
            // As written, there are twenty possible shortcuts to fire dynamic buttons:
            //   Ctrl + [ 1 through 5 ]			→	Add MathML Element 1-5
            //	 Ctrl + [ 6 through 0 ]			→	Add Level 1 Token 1-5
            //	 Ctrl + Alt + [ 1 through 0]	→	And Level 2 Token 1-10
            int butIndex = 0;
            int buttonNum = Convert.ToInt32( keys._mainKey );

            if ( ( buttonNum < 48 ) | ( buttonNum > 57 ) )
                return null;

            buttonNum -= 48;
            if( buttonNum == 0 )
                buttonNum = 10;
            buttonNum--;

            if ( keys._ctrl == true ) {
                if( keys._alt == true ) {
                    // This will be a level 2 token
                    butIndex = NUM_CONTROLS + ( NumElements + NumLevel1 ) + buttonNum;
                }
                else {
                    if( buttonNum < 5 ) {
                        // This is an element
                        butIndex = NUM_CONTROLS + buttonNum;
                        if( butIndex >= ( NUM_CONTROLS + NumElements ) )
                            butIndex = 0;
                    }
                    else {
                        // This is a level 1 token
                        butIndex = NUM_CONTROLS + buttonNum + NumElements - 5;
                        if( butIndex >= ( NUM_CONTROLS + NumElements + NumLevel1 ) )
                            butIndex = 0;
                    }
                }
            }

            if( butIndex == 0 )
                return null;

            if( butIndex < Controls.Count )
                return ( Button )Controls[ butIndex ];
            else
                return null;
        }