精华内容
下载资源
问答
  • WPF 命令库

    2020-08-24 10:56:38
    命令库包括以下类:ApplicationCommands、NavigationCommands、MediaCommands、EditingCommands和ComponentCommands。这些类提供诸如Cut、BrowseBack、BrowseForward、Play、Stop和Pause的命令。 许多这些命令都...

    简介:

            WPF 提供一组预定义命令。 命令库包括以下类:ApplicationCommandsNavigationCommandsMediaCommandsEditingCommands 和 ComponentCommands。 这些类提供诸如 CutBrowseBackBrowseForwardPlayStop 和 Pause 的命令。

            许多这些命令都包含一组默认输入绑定。 例如,如果指定应用程序处理 "复制" 命令,则会自动获取键盘绑定 "Ctrl + C"。

            使用 XAML 引用各个命令库中的命令时,通常可省略公开静态命令属性的库类的类名。 一般来说,命令名称是明确作为字符串的,且存在所属类型来提供命令的逻辑分组,不过对于消除二义性这并不必要。 例如,可指定 Command="Cut" 等价于Command="ApplicationCommands.Cut"。 

          ApplicationCommands 类中的命令以及其他命令库类中的命令,例如 ComponentCommands 和 NavigationCommands,旨在表示应用程序程序员经常遇到的一组常见命令。 命令仅表示 RoutedCommand 的实例,而不表示命令的实现逻辑。 实现逻辑绑定到带有 CommandBinding的命令。 例如,如果对某个控件执行 Close 命令,则该控件可能不会提供执行 Close 命令的逻辑,因此,应用程序编写器将负责编写确定控件如何处理命令的逻辑。

         大部分只是预定义命令,具体的实现是要自己编写实现。快捷键会有默认的,例如ApplicationCommands.Open默认对应"Ctrl + O"。如果需要自定义命令,参考:自定义命令

     

    介绍:

    ApplicationCommands 提供一组与应用程序相关的标准命令。
    MediaCommands 提供媒体相关命令的标准集。

    NavigationCommands

    一组标准的与导航相关的命令,包括浏览器和文档导航。

    ComponentCommands

    提供一组与组件相关的标准命令,这些命令具有预定义的按键输入笔势和 Text 属性。
    EditingCommands 提供一组标准的与编辑相关的命令。

     

    ApplicationCommands Properties
    CancelPrint

    获取表示“取消打印”命令的值。

    Close

    获取表示“关闭”命令的值。

    ContextMenu

    获取表示上下文菜单命令的值。

    Copy

    获取表示“复制”命令的值。

    CorrectionList

    获取表示“更正列表”命令的值。

    Cut

    获取表示“剪切”命令的值。

    Delete

    获取表示“删除”命令的值。

    Find

    获取表示 Find 命令的值。

    Help

    获取表示 Help 命令的值。

    New

    获取表示 New 命令的值。

    NotACommand

    表示始终被忽略的命令。

    Open

    获取表示“打开”命令的值。

    Paste

    获取表示“粘贴”命令的值。

    Print

    获取表示“打印”命令的值。

    PrintPreview

    获取表示“打印预览”命令的值。

    Properties

    获取表示“属性”命令的值。

    Redo

    获取表示“重做”命令的值。

    Replace

    获取表示“替换”命令的值。

    Save

    获取表示“保存”命令的值。

    SaveAs

    获取表示“另存为”命令的值。

    SelectAll

    获取表示“全选”命令的值。

    Stop

    获取表示“停止”命令的值。

    Undo

    获取表示“撤销”命令的值。

     

    MediaCommands Properties
    BoostBass

    获取表示“提升基础”命令的值。

    ChannelDown

    获取表示 Channel Down 命令的值。

    ChannelUp

    获取表示“频道递增”命令的值。

    DecreaseBass

    获取表示“降低低音”命令的值。

    DecreaseMicrophoneVolume

    获取表示 Decrease Microphone Volume 命令的值。

    DecreaseTreble

    获取表示“降低高音”命令的值。

    DecreaseVolume

    获取表示“降低音量”命令的值。

    FastForward

    获取表示 Fast Forward 命令的值。

    IncreaseBass

    获取表示“提高低音”命令的值。

    IncreaseMicrophoneVolume

    获取表示“提高麦克风音量”命令的值。

    IncreaseTreble

    获取表示“提高高音”命令的值。

    IncreaseVolume

    获取表示“提高音量”命令的值。

    MuteMicrophoneVolume

    获取表示“将麦克风静音”命令的值。

    MuteVolume

    获取表示“静音”命令的值。

    NextTrack

    获取表示“下一曲目”命令的值。

    Pause

    获取表示“暂停”命令的值。

    Play

    获取表示“播放”命令的值。

    PreviousTrack

    获取表示 Previous Track 命令的值。

    Record

    获取表示“记录”命令的值。

    Rewind

    获取表示“后退”命令的值。

    Select

    获取表示“选择”命令的值。

    Stop

    获取表示“停止”命令的值。

    ToggleMicrophoneOnOff

    获取表示“打开/关闭麦克风”命令的值。

    TogglePlayPause

    获取表示“切换播放暂停”命令的值。

     

    NavigationCommands Properties
    BrowseBack

    获取表示 Browse Back 命令的值。

    BrowseForward

    获取表示 Browse Forward 命令的值。

    BrowseHome

    获取表示 Browse Home 命令的值。

    BrowseStop

    获取表示 Browse Stop 命令的值。

    DecreaseZoom

    获取表示 Decrease Zoom 命令的值。

    Favorites

    获取表示 Favorites 命令的值。

    FirstPage

    获取表示 First Page 命令的值。

    GoToPage

    获取表示 Go To Page 命令的值。

    IncreaseZoom

    获取表示 Increase Zoom 命令的值。

    LastPage

    获取表示 Last Page 命令的值。

    NavigateJournal

    获取表示 Navigate Journal 命令的值。

    NextPage

    获取表示 Next Page 命令的值。

    PreviousPage

    获取表示 Previous Page 命令的值。

    Refresh

    获取表示 Refresh 命令的值。

    Search

    获取表示 Search 命令的值。

    Zoom

    获取表示 Zoom 命令的值。

     

    ComponentCommands Properties
    ExtendSelectionDown

    获取表示“向下扩展选择”命令的值。

    ExtendSelectionLeft

    获取表示 Extend Selection Left 命令的值。

    ExtendSelectionRight

    获取表示 Extend Selection Right 命令的值。

    ExtendSelectionUp

    获取表示 Extend Selection Up 命令的值。

    MoveDown

    获取表示“下移”命令的值。

    MoveFocusBack

    获取表示“焦点后移”命令的值。

    MoveFocusDown

    获取表示“焦点下移”命令的值。

    MoveFocusForward

    获取表示 Move Focus Forward 命令的值。

    MoveFocusPageDown

    获取表示“焦点页下移”命令的值。

    MoveFocusPageUp

    获取表示“焦点页上移”命令的值。

    MoveFocusUp

    获取表示“焦点上移”命令的值。

    MoveLeft

    获取表示“左移”命令的值。

    MoveRight

    获取表示“右移”命令的值。

    MoveToEnd

    获取表示“移动到末尾”命令的值。

    MoveToHome

    获取表示“移动到开头”命令的值。

    MoveToPageDown

    获取表示“移到下一页”命令的值。

    MoveToPageUp

    获取表示“移动到上一页”命令的值。

    MoveUp

    获取表示“向上移动”命令的值。

    ScrollByLine

    获取表示“按行滚动”命令的值。

    ScrollPageDown

    获取表示 Scroll Page Down 命令的值。

    ScrollPageLeft

    获取表示“向左滚动一页”命令的值。

    ScrollPageRight

    获取表示“向右滚动一页”命令的值。

    ScrollPageUp

    获取表示“向上滚动页面”命令的值。

    SelectToEnd

    获取表示“选择到末尾”命令的值。

    SelectToHome

    获取表示“选择到开头”命令的值。

    SelectToPageDown

    获取表示“选择下一页”命令的值。

    SelectToPageUp

    获取表示“选择上一页”命令的值。

     

    EditingCommands Properties
    AlignCenter

    表示 AlignCenter 命令,该命令请求将当前段落或选中的段落居中。

    AlignJustify

    表示 AlignJustify 命令,该命令请求将当前段落或选中的段落两端对齐。

    AlignLeft

    表示 AlignLeft 命令,该命令请求将所选内容左对齐。

    AlignRight

    表示 AlignRight 命令,该命令请求将所选内容右对齐。

    Backspace

    表示 Backspace 命令,该命令请求在当前位置或当前所选内容上输入一个退格。

    CorrectSpellingError

    表示 CorrectSpellingError 命令,该命令请求更正当前位置任何拼写错误的单词。

    DecreaseFontSize

    表示 DecreaseFontSize 命令,该命令请求将当前所选内容的字号缩小 1 磅。

    DecreaseIndentation

    表示 DecreaseIndentation 命令,该命令请求将当前段落的缩进减少一个制表位。

    Delete

    表示 Delete 命令,该命令请求删除当前所选内容。

    DeleteNextWord

    表示 DeleteNextWord 命令,该命令请求删除下一单词(相对于当前位置而言)。

    DeletePreviousWord

    表示 DeletePreviousWord 命令,该命令请求删除上一单词(相对于当前位置而言)。

    EnterLineBreak

    表示 EnterLineBreak 命令,该命令请求在当前位置或当前所选内容上插入一个换行符。

    EnterParagraphBreak

    表示 EnterParagraphBreak 命令,该命令请求在当前位置或当前所选内容上插入一个分段符。

    IgnoreSpellingError

    表示 IgnoreSpellingError 命令,该命令请求忽略当前位置或当前所选内容中任何拼写错误的单词的实例。

    IncreaseFontSize

    表示 IncreaseFontSize 命令,该命令请求将当前所选内容的字号增加 1 磅。

    IncreaseIndentation

    表示 IncreaseIndentation 命令,该命令请求将当前段落的缩进增加一个制表位。

    MoveDownByLine

    表示 MoveDownByLine 命令,该命令请求将插入符号向下移动一行。

    MoveDownByPage

    表示 MoveDownByPage 命令,该命令请求将插入符号向下移动一页。

    MoveDownByParagraph

    表示 MoveDownByParagraph 命令,该命令请求将插入符号向下移动一个段落。

    MoveLeftByCharacter

    表示 MoveLeftByCharacter 命令,该命令请求将插入符号向左移动一个字符。

    MoveLeftByWord

    表示 MoveLeftByWord 命令,该命令请求将插入符号向左移动一个单词。

    MoveRightByCharacter

    表示 MoveRightByCharacter 命令,该命令请求将插入符号向右移动一个字符。

    MoveRightByWord

    表示 MoveRightByWord 命令,该命令请求将插入符号向右移动一个单词。

    MoveToDocumentEnd

    表示 MoveToDocumentEnd 命令,该命令请求将插入符号移至内容的末尾。

    MoveToDocumentStart

    表示 MoveToDocumentStart 命令,该命令请求将插入符号移至内容的开头。

    MoveToLineEnd

    表示 MoveToLineEnd 命令,该命令请求将插入符号移至当前行的末尾。

    MoveToLineStart

    表示 MoveToLineStart 命令,该命令请求将插入符号移至当前行的开头。

    MoveUpByLine

    表示 MoveUpByLine 命令,该命令请求将插入符号向上移动一行。

    MoveUpByPage

    表示 MoveUpByPage 命令,该命令请求将插入符号向上移动一页。

    MoveUpByParagraph

    表示 MoveUpByParagraph 命令,该命令请求将插入符号向上移动一个段落。

    SelectDownByLine

    表示 SelectDownByLine 命令,该命令请求将当前选择范围向下扩展一行。

    SelectDownByPage

    表示 SelectDownByPage 命令,该命令请求将当前选择范围向下扩展一页。

    SelectDownByParagraph

    表示 SelectDownByParagraph 命令,该命令请求将当前选择范围向下扩展一段。

    SelectLeftByCharacter

    表示 SelectLeftByCharacter 命令,该命令请求将当前选择范围向左扩展一个字符。

    SelectLeftByWord

    表示 SelectLeftByWord 命令,该命令请求将当前选择范围向左扩展一个单词。

    SelectRightByCharacter

    表示 SelectRightByCharacter 命令,该命令请求将当前选择范围向右扩展一个字符。

    SelectRightByWord

    表示 SelectRightByWord 命令,该命令请求将当前选择范围向右扩展一个单词。

    SelectToDocumentEnd

    表示 SelectToDocumentEnd 命令,该命令请求将当前选择范围扩展到内容末尾处。

    SelectToDocumentStart

    表示 SelectToDocumentStart 命令,该命令请求将当前选择范围扩展到内容开头处。

    SelectToLineEnd

    表示 SelectToLineEnd 命令,该命令请求将当前选择范围扩展到当前行的末尾。

    SelectToLineStart

    表示 SelectToLineStart 命令,该命令请求将当前选择范围扩展到当前行的开头。

    SelectUpByLine

    表示 SelectUpByLine 命令,该命令请求将当前选择范围向上扩展一行。

    SelectUpByPage

    表示 SelectUpByPage 命令,该命令请求将当前选择范围向上扩展一页。

    SelectUpByParagraph

    表示 SelectUpByParagraph 命令,该命令请求将当前选择范围向上扩展一段。

    TabBackward

    表示 TabBackward 命令。

    TabForward

    表示 TabForward 命令。

    ToggleBold

    表示 ToggleBold 命令,该命令请求对当前所选内容进行 Bold 格式切换。

    ToggleBullets

    表示 ToggleBullets 命令,该命令请求对当前所选内容进行无序列表(也称为项目符号列表)格式切换。

    ToggleInsert

    表示 ToggleInsert 命令,该命令用于切换“插入”和“改写”键入模式。

    ToggleItalic

    表示 ToggleItalic 命令,该命令请求对当前所选内容进行 Italic 格式切换。

    ToggleNumbering

    表示 ToggleNumbering 命令,该命令请求对当前所选内容进行排序列表(也称为编号列表)格式切换。

    ToggleSubscript

    表示 ToggleSubscript 命令,该命令请求对当前所选内容进行下标格式切换。

    ToggleSuperscript

    表示 ToggleSuperscript 命令,该命令请求对当前所选内容进行上标格式切换。

    ToggleUnderline

    表示 ToggleUnderline 命令,该命令请求对当前所选内容进行 Underline 格式切换。

     

    EditingCommands Key and ModifierKeys
    编辑命令 默认键笔势
    AlignCenter Ctrl+E
    AlignJustify Ctrl+J
    AlignLeft Ctrl+L
    AlignRight Ctrl+R
    Backspace Backspace
    CorrectSpellingError 无默认键笔势
    DecreaseFontSize Ctrl+OemOpenBrackets
    DecreaseIndentation Ctrl+Shift+T
    Delete Delete
    DeleteNextWord Ctrl+Delete
    DeletePreviousWord Ctrl+Backspace
    EnterLineBreak Shift+Enter
    EnterParagraphBreak Enter
    IgnoreSpellingError 无默认键笔势
    IncreaseFontSize Ctrl+OemCloseBrackets
    IncreaseIndentation Ctrl+T
    MoveDownByLine Down
    MoveDownByPage PageDown
    MoveDownByParagraph Ctrl+Down
    MoveLeftByCharacter Left
    MoveLeftByWord Ctrl+Left
    MoveRightByCharacter Right
    MoveRightByWord Ctrl+Right
    MoveToDocumentEnd Ctrl+End
    MoveToDocumentStart Ctrl+Home
    MoveToLineEnd End
    MoveToLineStart Home
    MoveUpByLine Up
    MoveUpByPage PageUp
    MoveUpByParagraph Ctrl+Up
    SelectDownByLine Shift+Down
    SelectDownByPage Shift+PageDown
    SelectDownByParagraph Ctrl+Shift+Down
    SelectLeftByCharacter Shift+Left
    SelectLeftByWord Ctrl+Shift+Left
    SelectRightByCharacter Shift+Right
    SelectRightByWord Ctrl+Shift+Right
    SelectToDocumentEnd Ctrl+Shift+End
    SelectToDocumentStart Ctrl+Shift+Home
    SelectToLineEnd Shift+End
    SelectToLineStart Shift+Home
    SelectUpByLine Shift+Up
    SelectUpByPage Shift+PageUp
    SelectUpByParagraph Ctrl+Shift+Up
    TabBackward Shift+Tab
    TabForward Tab
    ToggleBold Ctrl+B
    ToggleBullets Ctrl+Shift+L
    ToggleInsert Insert
    ToggleItalic Ctrl+I
    ToggleNumbering Ctrl+Shift+N
    ToggleSubscript Ctrl+OemPlus
    ToggleSuperscript Ctrl+Shift+OemPlus
    ToggleUnderline Ctrl+U

     

    使用:

    1.ApplicationCommands

    使用ApplicationCommands.Open

        <Window.CommandBindings>
            <CommandBinding Command="ApplicationCommands.Open" Executed="command_Execute" CanExecute="command_CanExecute"/>
        </Window.CommandBindings>
        <Grid>
            <StackPanel >
                <Button Height="20"  Command="ApplicationCommands.Open" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button>
            </StackPanel>
        </Grid>

     

    快捷键设置"Ctrl + O" 

        <Window.InputBindings>
            <KeyBinding Key="O" Modifiers="Ctrl" Command="ApplicationCommands.Open"></KeyBinding>
        </Window.InputBindings>
        <Window.CommandBindings>
            <CommandBinding Command="ApplicationCommands.Open" Executed="command_Execute" CanExecute="command_CanExecute"/>
        </Window.CommandBindings>
        <Grid>
            <StackPanel >
                <Button Height="20"  Command="ApplicationCommands.Open" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button>
            </StackPanel>
        </Grid>

     

    等价替换 

                KeyGesture key = new KeyGesture(Key.O, ModifierKeys.Control);
                KeyBinding bindingkey = new KeyBinding(ApplicationCommands.Open, key);
                this.InputBindings.Add(bindingkey);
    
                CommandBinding bindingCmd = new CommandBinding(ApplicationCommands.Open, command_Execute, command_CanExecute);
                this.CommandBindings.Add(bindingCmd);

     

    命令实现 

            public void command_Execute(object sender, ExecutedRoutedEventArgs e)
            {    
                MessageBox.Show(e.Source.ToString());
                e.Handled = true; //停止路由事件传播
            }
    
            public void command_CanExecute(object sender, CanExecuteRoutedEventArgs e)
            {
                e.CanExecute = true;
                e.Handled = true;
            }

     

     ApplicationCommands的命令本质上是RoutedUICommand

     

    2.MediaCommands

    使用Play命令

        <Window.CommandBindings>
            <CommandBinding Command="MediaCommands.Play" Executed="command_Execute" CanExecute="command_CanExecute"></CommandBinding>
        </Window.CommandBindings>
    
        <Grid>
            <StackPanel>
                <Button Command="MediaCommands.Play" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"  Height="20"></Button>
            </StackPanel>
        </Grid>

     

            public void command_Execute(object sender, ExecutedRoutedEventArgs e)
            {    
                MessageBox.Show(e.Source.ToString());
                e.Handled = true; //停止路由事件传播
            }
    
            public void command_CanExecute(object sender, CanExecuteRoutedEventArgs e)
            {
                e.CanExecute = true;
                e.Handled = true;
            }

     

     

    3.NavigationCommands

     通过Frame使两个Page切换,将 Refresh命令 与 Frame结合使用。 

        <Window.CommandBindings>
            <CommandBinding Command="NavigationCommands.Refresh" Executed="command_Execute" CanExecute="command_CanExecute"></CommandBinding>
        </Window.CommandBindings>
    
        <Grid>
            <StackPanel>
                <MenuItem Command="NavigationCommands.Refresh" CommandTarget="{Binding ElementName=frame}"></MenuItem>
                <Frame x:Name="frame" NavigationUIVisibility="Hidden" Source="Page1.xaml" Height="200" ></Frame>
            </StackPanel>
        </Grid>
            public void command_Execute(object sender, ExecutedRoutedEventArgs e)
            {
                this.frame.NavigationUIVisibility = NavigationUIVisibility.Visible;
                this.frame.Source = new Uri("Page2.xaml",UriKind.Relative);
            }

     

     Page添加

     

    Page的背景色设置 

        <Grid>
            <Border Background="Blue"></Border>
        </Grid>

     

     

    4.ComponentCommands

    按钮下移动画

        <Window.CommandBindings>
            <CommandBinding Command="ComponentCommands.MoveDown" Executed="command_Execute" CanExecute="command_CanExecute"></CommandBinding>
        </Window.CommandBindings>
    
        <Canvas>
           <Button x:Name="btn" Command="ComponentCommands.MoveDown" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"  Height="20" Width="50"></Button>
        </Canvas>
            public void command_Execute(object sender, ExecutedRoutedEventArgs e)
            {
                DoubleAnimation doubleAnimation = new DoubleAnimation(0, 300, new Duration(TimeSpan.FromSeconds(1)));
                Storyboard.SetTarget(doubleAnimation, this.btn);
                Storyboard.SetTargetProperty(doubleAnimation, new PropertyPath(Canvas.TopProperty));
                Storyboard story = new Storyboard();
                story.Completed += Story_Completed;
                story.Children.Add(doubleAnimation);
                story.Begin();       
            }
    
            private void Story_Completed(object sender, EventArgs e)
            {
                //完成后
            }

     

    5.EditingCommands

    1. Execute 方法的第一个参数是命令参数。 大多数编辑命令忽略 command 参数;通常为null。第二个参数指定要将命令路由到的对象。 此对象必须实现 IInputElement 接口,并包括指定命令的处理程序。 
    2. RichTextBox支持此命令。如果在不处理命令的对象上调用命令时,不会执行。

     

    如下表示 AlignCenter 命令,该命令请求将当前段落或选中的段落居中。此命令的默认键为 Ctrl+E

        <Grid>
            <StackPanel>
                <RichTextBox x:Name="rtbx"></RichTextBox>
                <Button Content="Align Center" Click="Button_Click"></Button>
            </StackPanel>
        </Grid>
            public void Button_Click(object sender, RoutedEventArgs e)
            {
                EditingCommands.AlignCenter.Execute(null, this.rtbx);//居中
            }

     

     

    展开全文
  • wpf笔记--wpf命令库

    2013-07-19 11:16:56
    WPF命令库 WPF提供常用应用程序所用的命令集,常用的命令集包括:ApplicationCommands, ComponentCommands, NavigationCommands, MediaCommands和EditingCommands。  ApplicationCommands(应用程序命令):  ...
    WPF的命令库


    WPF提供常用应用程序所用的命令集,常用的命令集包括:ApplicationCommands, ComponentCommands, NavigationCommands, MediaCommands和EditingCommands。 
    ApplicationCommands(应用程序命令): 
    CancelPrint:取消打印 
    Close:关闭 
    ContextMenu:上下文菜单 
    Copy:复制 
    CorrectionList: Gets the value that represents the Correction List command. 
    Cut:剪切 
    Delete:删除 
    Find:查找 
    Help:帮助 
    New:新建 
    NotACommand:不是命令,被忽略 
    Open:打开 
    Paste:粘贴 
    Print:打印 
    PrintPreview:打印预览 
    Properties:属性 
    Redo:重做 
    Replace:取代 
    Save:保存 
    SaveAs:另存为 
    SelectAll:选择所有的 
    Stop:停止 
    Undo:撤消 
    ComponentCommands(组件命令): 
    ExtendSelection:后接Down/Left/Right/Up, 比如:ExtendSelectionDown(Shift+Down,Extend Selection Down),ExtendSelectionLeft等 
    Move:后接Down/Left/Right/Up, 如:MoveDown 
    MoveFocus:后接Down/Forward/Back/Up, 如:MoveFocusDown 
    MoveFocusPage:后接Down/Up,如:MoveFocusPageUp 
    MoveTo:后接End/Home/PageDown/PageUp,比如:MoveToPageDown 
    ScrollByLine 
    ScrollPage:后接Down/Left/Right/Up,比如:ScrollPageLeft 
    SelectTo:End/Home/PageDown/PageUp,比如:SelectToEnd 
    NavigationCommands(导航命令): 
    Browse浏览: 后接Back/Forward/Home/Stop, 比如:BrowseBack 
    缩放显示:DecreaseZoom, IncreaseZoom, Zoom 
    Favorites(收藏) 
    页面:FirstPage, LastPage, PreviousPage, NextPage,GoToPage 
    NavigateJournal 
    Refresh(刷新) 
    Search(搜索) 
    MediaCommands(多媒体控制命令): 
    Treble高音:DecreaseTreble,IncreaseTreble 
    Bass低音:BoostBass,DecreaseBass,IncreaseBass 
    Channel频道:ChannelDown,ChannelUp 
    MicrophoneVolume麦克风音量调节:DecreaseMicrophoneVolume,IncreaseMicrophoneVolume,MuteMicrophoneVolume 
    ToggleMicrophoneOnOff:麦克风开关 
    Volume音量: DecreaseVolume,IncreaseVolume,MuteVolume 
    Rewind, FastForward(回放,快进) 
    Track轨道:PreviousTrack,NextTrack [上一段(节)] 
    Play,Pause,Stop,Record(播放,暂停,停止,录制) 
    TogglePlayPause 
    Select选择 
    EditingCommands(编辑/排版类命令): 
    Align对齐:AlignCenter,AlignJustify,AlignLeft,AlignRight(居中,撑满,左对齐,右对齐) 
    Backspace退格 
    TabForward,TabBackward(Tab前缩,Tab向后) 
    FontSize字体大小:DecreaseFontSize,IncreaseFontSize 
    Indentation缩排:DecreaseIndentation, IncreaseIndentation 
    Delete删除: Delete选中部分,DeleteNextWord:删除后一字,DeletePreviousWord:删除前一字 
    EnterLineBreak:换行 
    EnterParagraphBreak:换段 
    CorrectSpellingError/IgnoreSpellingError:纠正/忽略拼写错误 
    MoveUpByLine,MoveDownByLine: 上/下移一行, 
    MoveUpByPage,MoveDownByPage: 上/下移一页 
    MoveUpByParagraph,MoveDownByParagraph: 上/下移一段 
    MoveLeftByCharacter/MoveRightByCharacter:左/右移一字符 
    MoveLeftByWord/MoveRightByWord 左/右移一词 
    MoveToDocumentStart/MoveToDocumentEnd:到文章开头/结尾 
    MoveToLineStart/MoveToLineEnd:到一行的开头/结尾 
    SelectUpByLine,SelectDownByLine:向上/下选一行 
    SelectUpByPage,SelectDownByPage:向上/下选一页 
    SelectUpByParagraph,SelectDownByParagraph:向上/下选一段 
    SelectLeftByCharacter,SelectRightByCharacter:向左/右选中一字 
    SelectLeftByWord,SelectRightByWord:向左/右选中一词 
    SelectToDocumentStart,SelectToDocumentEnd: 选中到篇头/篇尾 
    SelectToLineStart/SelectToLineEnd:选中到行首/行尾 
    ToggleBold, ToggleItalic, ToggleUnderline(加粗,斜体,下划线) 
    ToggleBullets, ToggleNumbering(列表:加点,加数字) 
    ToggleInsert:插入 

    ToggleSuperscript,ToggleSubscript(上标字,下标字)


    wpf学习网址(有事例)http://www.cnblogs.com/l6098627/archive/2009/12/03/1616023.html

    http://www.cnblogs.com/zcttxs/archive/2012/04/01/2428527.html

    展开全文
  • WPF 命令

    2018-02-22 17:19:00
    WPF命令模型ICommand接口WPF命令模型的核心是System.Windows.Input.ICommand接口,该接口定义了命令的工作原理,它包含了两个方法和一个事件: public interface ICommand { void Execute(object parameter)...
    1. WPF命令模型 
      ICommand接口 
      WPF命令模型的核心是System.Windows.Input.ICommand接口,该接口定义了命令的工作原理,它包含了两个方法和一个事件: 
      复制代码
      public interface ICommand
      {
          void Execute(object parameter);         //定义在调用此命令时调用的方法。
          bool CanExecute(object parameter);      //此方法返回命令的状态,如果命令可用则返回true,否则返回false.
          event EventHandler CanExecuteChanged;   //当命令状态改变时,引发该事件。
      }
      复制代码

      RoutedCommand类 
      当创建自己的命令时,不会直接实现ICommand接口,而是使用System.Windows.Input.RoutedCommand类。它是WPF中唯一实例了ICommand接口的类,它为事件冒泡和隧道添加了一些额外的基础结构。为了支持路由事件,RoutedCommand类私有地实现了ICommand接口,并且添加了ICommand接口方法的一些不同的版本,最明显的变化是,Execute()和CanExecute()方法使用了一个额外参数。代码示例如下:

      复制代码
      public void Execute(object parameter, IInputElement target)
      { 
      }
      public bool CanExecute(object parameter, IInputElement target) { }
      复制代码

      参数target是开始处理事件的元素,事件从target元素开始,然后冒泡至高层的容器,直到应用程序为了执行合适的任务而处理了事件。 
      RoutedCommand类还引入了三个属性:Name(命令名称)、OwnerType(包含命令的类)及InputGestures集合(可以被用于触发命令的按键或鼠标操作)。

      RoutedUICommand类 
      RoutedUICommand类只增加了一个属性 Text,它是命令显示的文本。在程序中处理的大部分命令不是RoutedCommand对象,而是RoutedUICommand类的实例,RoutedUICommand类继承自RoutedCommand类。而WPF提供的所有预先构建好的命令都是RoutedUICommand对象。RoutedUICommand类用于具有文本的命令,这些文本显示在用户界面中的某些地方(如菜单项文本,工具栏按钮的工具提示)。 
      命令库 
      因为每个应用程序可能都有大量的命令,且对于许多不同的应用程序,很多命令是通用的,为了减少创建这些命令所需要的工作,WPF提供了一个基本命令库,这些命令通过以下5个专门的静态类的静态属性提供: 
      QQ图片20140805000636 
      许多命令对象都是有一个额外的特征:默认输入绑定,例如,ApplicationCommands.Open命令被映射到Ctrl+O组合键,只要将命令绑定到一个命令源,并为窗口添加该命令源,这个组合键就会被激活,即使没有在用户界面的任何地方显示该命令也同样如此。
    2. 命令源 
      命令源是一个实现了ICommandSource接口的控件,它定义了三个属性: 
      QQ图片20140805002559 
      例如,下面的按钮使用Command属性连接到ApplicationCommands.New命令:
      <Button Command="New">New</Button>

      此时,会看到按钮是被禁用的状态,这是因为按钮查询到命令还没有进行操作绑定,命令的状态为不可用,所以按钮也设置为不可用。

    3. 为命令进行操作绑定 
      下在的代码片段为New命令创建绑定,可将这些代码添加到窗口的构造函数中:

      复制代码
      CommandBinding binding = new CommandBinding(ApplicationCommands.New);
      binding.Executed += new ExecutedRoutedEventHandler(binding_Executed);
      this.CommandBindings.Add(binding);
      
      void binding_Executed(object sender, ExecutedRoutedEventArgs e)
      {
          MessageBox.Show("New command triggered by " + e.Source.ToString());
      }
      复制代码

      尽管习惯上为窗口创建所有绑定,但CommandBindings属性实际上是在UIElement基类中定义的,所以任何元素都支持该属性,但为了得到最大的灵活性,命令绑定通常被添加到顶级窗口,如果希望在多个窗口中使用相同的命令,就需要在这些窗口中分别创建命令绑定。 

      以上的命令绑定是使用代码生成的,但,如果希望精简代码隐藏文件,使用XAML以声明方式关联命令也很容易,如下所示:

      <Window.CommandBindings>
          <CommandBinding Command="ApplicationCommands.New" Executed="binding_Executed"></CommandBinding>
      </Window.CommandBindings>
      <Button Command="ApplicationCommands.New">New</Button>
    4. 使用多命令源,如下是为命令New创建了一个MenuItem的命令源:

      <Menu>
          <MenuItem Header="File">
              <MenuItem Command="New"></MenuItem>
          </MenuItem>
      </Menu>

      注意,没有为New命令的MenuItem对象设置Header属性,这是因为MenuItem类足够智能,如果没有设置Header属性,它将从命令中提取文本(Button不具有此特性)。虽然该特性带来的便利看起来很小,但是如果计划使用不同的语言本地化应用程序,这一特性就很重要了。MunuItem类还有另一个功能,它能够自动提取Command.InputBindings集合中的第一个快捷键,对于以上的New命令,在菜单旁边会显示快捷键:Ctrl+N。

    5. 使Button这种不能自动提取命令文本的控件来提取命令文本,有两种技术来重用命令文本,一种是直接从静态的命令对象中提取文本,XAML可以使用Static标记扩展完成这一任务,该方法的问题在于它只是调用命令对象的ToString()方法,因此,得到的是命令的名称,而不是命令的文本。最好的方法是使用数据绑定表达式,以下第二条代码示例绑定表达式绑定到当前元素,获取正在使用的Command对象,并且提取其Text属性:

      <Button Command="ApplicationCommands.New" Content="{x:Static ApplicationCommands.New}"></Button>
      <Button Command="ApplicationCommands.New" Content="{Binding RelativeSource={RelativeSource Mode=Self}, Path=Command.Text}"></Button>
    6. 直接调用命令
      不是只有实现了ICommandSource接口的类才能触发命令的执行,也可以使用Execute()方法直接调用来自任何事件处理程序的方法:

      ApplicationCommands.New.Execute(null,targetElement);

      targetElement是WPF开始查找命令绑定的地方。可以使用包含窗口(具有命令绑定)或嵌套的元素(实际引发事件的元素)。也可以在关联的CommandBinding对象中调用Execute()方法,对于这种情况,不需要提供目标元素,因为会自动公开正在使用的CommandBindings集合的元素设置为目标元素:this.CommandBindings[0].Command.Execute(null);

    7. 禁用命令 
      例如有一个由菜单、工具栏及一个大的文本框构成的文本编辑器的应用程序,该应用程序可以打开文件,创建新的文档以及保存所进行的操作。在应用程序中,只有文本框中的内容发生了变化才启用Save命令,我们可以在代码中使用一个Boolean变量isUpdate来跟踪是否发生了变化。当文本发生了变化时设置标志。

      private bool isUpdate = false;
      private void txt_TextChanged(object sender, TextChangedEventArgs e)
      {
          isUpdate = true;
      }

      现在需要从窗口向命令绑定传递信息,从而使连接的控件可以根据需要进行更新,技巧是处理命令绑定的CanExecute事件,代码如下:

      CommandBinding binding = new CommandBinding(ApplicationCommands.Save); 
      binding.Executed += new ExecutedRoutedEventHandler(binding_Executed); 
      binding.CanExecute += new CanExecuteRoutedEventHandler(binding_CanExecute); 
      this.CommandBindings.Add(binding); 

      或者使用声明方式:

      <CommandBinding Command="Save" Executed="CommandBinding_Executed_1" CanExecute="binding_CanExecute"></CommandBinding>

      在事件处理程序中,只需要检查isUpdate变量,并设置CanExecuteRoutedEventArgs.CanExecute属性:

      void binding_CanExecute(object sender, CanExecuteRoutedEventArgs e) 
      { 
          e.CanExecute = isUpdate; 
      } 

      如果isUpdate的值为false,就会禁用Save命令,否则会启用Save命令。
      当使用CanExecute事件时,是由WPF负责调用RoutedCommand.CanExecute()方法触发事件处理程序,并且确定命令的状态。当WPF命令管理器探测到一个确信是重要的变化时,例如,当焦点从一个控件移动到另一个控件,或者执行了一个命令之后,WPF命令管理器就会完成该工作。控件还能引发CanExecuteChanged事件以通知WPF重新评估命令,例如,当用户在文本框中按下一个键时就会发生该事件,总之,CanExecute事件会被频繁的触发,所以不应当在该事件的处理程序中使用耗时的代码。 然而,其化因素有可能会影响命令的状态,在以上的示例中,为了响应其它操作,isUpdate标志可能会被修改,如果注意到命令状态没有在正确的时间更新,可以强制WPF为所有正在使用的命令调用CanExecute()方法,通过调用静态的CommandManager.InvalidateRequerySuggested()方法完成该工作。然后命令管理器触发RequerySuggested事件,通知窗口中的命令源。然后命令源会查询它们连接的命令并相应地更新它们的状态。

    8. 具有内置命令的控件 
      一些输入控件自身可以处理命令事件,如TextBox类的Cut、Copy及Paste命令,以及一些来自EditingCommand类的用于选择文本以及将光标移到不同位置的命令,把此类命令绑定到命令源会自动获取对应命令的功能,而不需要再为命令绑定操作。如:

      <ToolBar>    
          <Button Command="Cut" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
          <Button Command="Copy" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
          <Button Command="Paste" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
      </ToolBar> 

      此外,文本框还处理了CanExecute事件,如果在文本框中当前没有选中任何内容,剪切和复制命令就会被禁用,当焦点改变到其他不支持这些命令的控件时,这些命令都会被禁用。 
      在以上代码中使用了ToolBar控件,它提供了一些内置逻辑,可以将它的子元素的CommandTarget属性自动设置为具有焦点的控件。但如果在不同的容器(不是ToolBar或Menu控件)中放置按钮,就不会得到这一优点而按钮不能正常工作,此时就需要手动设置CommandTarget属性,为此,必须使用命名目标元素的绑定表达式。如:

      复制代码
      <StackPanel Grid.Row="1"> 
          <Button Command="Cut" CommandTarget="{Binding ElementName=txt}" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"/> 
          <Button Command="Copy" CommandTarget="{Binding ElementName=txt}" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"/> 
          <Button Command="Paste" CommandTarget="{Binding ElementName=txt}" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"/> 
      </StackPanel>
      复制代码

      另一个较简单的选择是使用FocusManager.IsFocusScope附加属性创建新的焦点范围,当命令触发时,该焦点范围会通知WPF在父元素的焦点范围中查找元素:

      <StackPanel FocusManager.IsFocusScope="True" Grid.Row="1"> 
          <Button Command="Cut" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
          <Button Command="Copy" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
          <Button Command="Paste" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}"></Button> 
      </StackPanel> 

      在有些情况下,可能发现控件支持内置命令,但不想启用它,此时有三种方法可以禁用命令:

      1. 理想情况下,控件会提供用于关闭命令支持的属性,例如TextBox控件的IsUndoEnabled属性。

      2. 如果控件没有提供关闭命令支持的属性,还可以为希望禁用的命令添加一个新的命令绑定,然后该命令绑定可以提供新的事件处理程序。且总是将CanExecute属性设置为false,下面是一个使用该技术删除文本框Cut特性支持的示例:

        复制代码
        CommandBinding binding = new CommandBinding(ApplicationCommands.Cut, null, SuppressCommand); 
        this.CommandBindings.Add(binding); 
        private void SuppressCommand(object sender, CanExecuteRoutedEventArgs e) 
        { 
            e.CanExecute= false; 
            e.Handled= true; 
        } 
        复制代码

        上面的代码设置了Handled标志,以阻止文本框自我执行计算,而文本框可能将CanExecute属性设置为true.

      3. 使用InputBinding集合删除触发命令的输入,例如,可以使用代码禁用触发TextBox控件中Cut命令的Ctrl+X组合键,如下所示:

        KeyBinding keyBinding = new KeyBinding(ApplicationCommands.NotACommand, Key.X, ModifierKeys.Control); 
        txt.InputBindings.Add(keyBinding); 

        ApplicationCommands.NotACommand命令不做任何事件,它专门用于禁用输入绑定。 
        文本框默认显示上下文菜单,可以通过将ContextMenu属性设置为null删除上下文本菜单

        <TextBoxGrid.Row="3" Name="txt" ContextMenu="{x:Null}" TextWrapping="Wrap" TextChanged="txt_TextChanged" />
    9. 自定义命令 
      下面的示例定义了一个Requery的命令:

      复制代码
      public class DataCommands 
      { 
         private static RoutedUICommand requery; 
         static DataCommands() 
          { 
              InputGestureCollection inputs= new InputGestureCollection(); 
              inputs.Add(new KeyGesture(Key.R, ModifierKeys.Control, "Ctrl+R")); 
              requery= new RoutedUICommand("查询", "Requery", typeof(DataCommands), inputs); 
          } 
         public static RoutedUICommand Requery   //通过静态属性提供自定义的命令 
          { 
             get { return requery; } 
          } 
      } 
      复制代码

      使用Requery命令时需要将它的.Net名称空间映射为一个XML名称空间,XAML代码如下:  

      复制代码
      <Window x:Class="WpfApplication1.Test4" 
              xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
              xmlns:local="clr-namespace:WpfApplication1" 
              Title="Test4" Height="300" Width="300"> 
          <Window.CommandBindings> 
              <CommandBinding Command="local:DataCommands.Requery" Executed="Requery_Executed"></CommandBinding> 
          </Window.CommandBindings> 
          <Grid> 
              <Button Command="local:DataCommands.Requery" CommandParameter="ai" Content="{Binding RelativeSource={RelativeSource Mode=Self},Path=Command.Text}" /> 
          </Grid> 
      </Window>
      复制代码

      在以上代码中使用CommandParameter为命令传递了参数,命令的事件处理方法中就可以使用Parameter属性获取该参数:

      private void Requery_Executed(object sender, ExecutedRoutedEventArgs e) 
      { 
          string parameters = e.Parameter.ToString(); 
      }  
    10. 在不同的位置使用相同的命令 
      在WPF命令模型中,一个重要的思想是Scope。尽管每个命令只有一个副本,但是使用命令的效果却会根据触发命令位置而不同,例如,如果有两个文本框,它们都支持Cut、Copy、Paste命令,操作只会在当前具有焦点的文本框中发生。但是对于自定实现的命令如New、Open、Requery及Save命令就区分不出是哪一个文本框触发的命令,尽管ExecuteRoutedEventArgs对象提供了Source属性,但是该属性反映的是具有命令绑定的元素,也就是容器窗口。此问题的解决方法是使用文本框的CommandBindings集合为每个文本框分别绑定命令。

    11. 跟踪和翻转命令
      创建自己的用于支持命令翻转的数据结构,示例中定义一个名为CommandHistoryItem的类用于存储命令状态: 

      复制代码
      public class CommandHistoryItem 
      { 
          public string CommandName { get; set; }             //命令名称 
          public UIElement ElementActedOn { get; set; }       //执行命令的元素 
          public string PropertyActedOn { get; set; }         //在目标元素中被改变了的属性 
          public object PreviousState { get; set; }           //用于保存受影响元素以前状态的对象
          public CommandHistoryItem(string commandName) 
              : this(commandName, null, "", null) 
          {
          }
      
          public CommandHistoryItem(string commandName, UIElement elementActedOn, string propertyActed, object previousState) 
          { 
              this.CommandName = commandName; 
              this.ElementActedOn = elementActedOn; 
              this.PropertyActedOn = propertyActed; 
              this.PreviousState = previousState; 
          }
      
          public bool CanUndo 
          { 
              get { return (ElementActedOn != null && PropertyActedOn != ""); } 
          }
      
          /// <summary> 
          /// 使用反射为修改过的属性应用以前的值 
          /// </summary> 
          public void Undo() 
          { 
              Type elementType = ElementActedOn.GetType(); 
              PropertyInfo property = elementType.GetProperty(PropertyActedOn); 
              property.SetValue(ElementActedOn, PreviousState, null); 
          } 
      }
      复制代码

      需要自定义一个执行应用程序范围内翻转操作的命令,如下所示:

      复制代码
      private static RoutedUICommand applicationUndo;
      public static RoutedUICommand ApplicationUndo 
      { 
          get { return applicationUndo; } 
      }
      
      static ApplicationUndoDemo() 
      { 
          applicationUndo = new RoutedUICommand("Applicaion Undo", "ApplicationUndo", typeof(ApplicationUndoDemo)); 
      }
      复制代码

      可以使用CommandManager类来跟踪任何命令的执行情况,它提供了几个静态事件:Executed及PreviewExecuted,无论何时,当执行任何一个命令时都会触发它们。 尽管CommandManager类挂起了Executed事件,但是仍然可以使用UIElement.AddHandler()方法关联事件处理程序,并且为可选的第三个参数传递true值,从而允许接收事件。下面的代码在窗口的构造函数中关联PreviewExecuted事件处理程序,且在关闭窗口时解除关联: 

      复制代码
      public ApplicationUndoDemo()
      {
          InitializeComponent();
          this.AddHandler(CommandManager.PreviewExecutedEvent, new ExecutedRoutedEventHandler(CommandPreviewExecute),true);
      }
      
      private void Window_Unloaded(object sender, RoutedEventArgs e)
      {
          this.RemoveHandler(CommandManager.PreviewExecutedEvent, new ExecutedRoutedEventHandler(CommandPreviewExecute));
      }
      复制代码

      当触发PreviewExecute事件时,需要确定准备执行的命令是否是我们所关心的,如果是就创建CommandHistoryItem对象,且将其添加到历史命令集合中。

      复制代码
      private void CommandExecuted(object sender, ExecutedRoutedEventArgs e)
      {
          // Ignore menu button source.
          if (e.Source is ICommandSource) return;
      
          // Ignore the ApplicationUndo command.
          if (e.Command == MonitorCommands.ApplicationUndo) return;
      
          // Could filter for commands you want to add to the stack
          // (for example, not selection events).
      
          TextBox txt = e.Source as TextBox;
          if (txt != null)
          {
              RoutedCommand cmd = (RoutedCommand)e.Command;
                      
              CommandHistoryItem historyItem = new CommandHistoryItem(
                  cmd.Name, txt, "Text", txt.Text);
      
              ListBoxItem item = new ListBoxItem();
              item.Content = historyItem;
              lstHistory.Items.Add(historyItem);
      
              // CommandManager.InvalidateRequerySuggested();
          }
      }
      复制代码

      使用CanExecute事件处理程序,确保只有当Undo历史中有一项时,才能执行翻转操作: 

      <Window.CommandBindings>
          <CommandBinding Command="local:ApplicationUndoDemo.ApplicationUndo" Executed="CommandBinding_Executed" CanExecute="CommandBinding_CanExecute"></CommandBinding>
      </Window.CommandBindings>
      复制代码
      private void CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e) 
      { 
          //不知lstHistory.Items[lstHistory.Items.Count - 1]为什么强制转化不成CommandHistoryItem,有待解决 
          CommandHistoryItem historyItem = (CommandHistoryItem)lstHistory.Items[lstHistory.Items.Count - 1]; 
          if (historyItem.CanUndo) 
              historyItem.Undo(); 
          lstHistory.Items.Remove(historyItem); 
      }
      
      private void CommandBinding_CanExecute(object sender, CanExecuteRoutedEventArgs e) 
      { 
          if (lstHistory == null || lstHistory.Items.Count == 0) 
              e.CanExecute = false; 
          else 
              e.CanExecute = true; 
      }
      复制代码
       
      https://www.cnblogs.com/jiao1855/p/3891229.html

    转载于:https://www.cnblogs.com/sjqq/p/8459549.html

    展开全文
  • WPF命令

    2018-08-15 00:23:00
    WPF命令 原文:WPF命令“有了路由事件为什么还需要命令系统呢?”。事件的作用是发布、传播一些消息,消息传达到了接收者,事件的指令也就算完成了,至于如何响应事件送来的消息事件并不做任何限制,每...
    原文:WPF命令

    “有了路由事件为什么还需要命令系统呢?”。事件的作用是发布、传播一些消息,消息传达到了接收者,事件的指令也就算完成了,至于如何响应事件送来的消息事件并不做任何限制,每个接收者可已用自己的行为来响应事件。也就是说,事件不具有约束力。命令和事件的区别就在于命令具有约束力。

    命令是为了解除UI和交互逻辑代码间耦合,以前winform的时候,界面控件通过事件绑定代码,这样界面和代码就无法拆开。

    1、WPF命令模型。

    WPF命令模型是由许多可变的部分组成,但主要的部分有以下4个重要元素。

    1.1)、命令。

    命令表示应用程序任务,并且跟踪任务是否能够被执行,然而,命令实际上不包含执行应用程序任务的代码。

    1.2)、命令绑定。

    每个命令绑定针对用户界面的具体区域,将命令连接到相关的应用程序逻辑。

    1.3)、命令源。

    命令源触发命令,例如MenuItem和Button都是源对象,单击他们都会执行绑定命令。

    1.4)、命令目标。

    命令目标是在其中执行命令的元素。

    2、ICommand接口。

     WPF命令模型的核心是System.WIndows.Input.ICommand接口,该接口中包含了两个方法和一个事件。

    public interface ICommand
    {  
        event EventHandler CanExecuteChanged; //当命令状态改变时,引发该事件。
        
        bool CanExecute(object parameter); //此方法返回命令状态,如果命令可用则返回true,不可用则返回false。
        
        void Execute(object parameter); //定义在调用此命令时要调用的方法。
    }

    3、RoutedCommand类。

    当创建自己的命令时,不会直接实现ICommand接口,而是使用System.Windows.Input.RoutedCommand类,该类自动实现了ICommand接口,RoutedEvent类是WPF中唯一实现了ICommand接口的类,换句话说,所有WPF命令都是RoutedCommand类及其派生类的实例。为支持路由事件,RoutedCommand类私有地实现了ICommand接口,并添加了ICommand接口方法的一些不同版本,最大的变化就是Excute()方法和CanExcute()方法使用了一个额外的参数

    public bool CanExecute(object parameter, IInputElement target); //如果可以对当前命令目标执行此命令,则为 true;否则为 false。
            
    public void Execute(object parameter, IInputElement target); //定义在调用此命令时要调用的方法。

    4、RouteCommand类。 

    public class RoutedCommand : ICommand
    {    
        public RoutedCommand();
           
        public RoutedCommand(string name, Type ownerType);
            
        public RoutedCommand(string name, Type ownerType, InputGestureCollection inputGestures);
    
        public InputGestureCollection InputGestures { get; }
        
        //除了Excute()和CanExecute()修改外,还引入了三个属性:Name、OwnerType和触发命令的鼠标操作。
            
        public string Name { get; } // 获取命令的名称。
           
        public Type OwnerType { get; } //获取使用命令注册的类型。
            
        public event EventHandler CanExecuteChanged;    
        //参数Target是处理事件的元素,事件从Target元素开始,然后冒泡至最高层的容器,知道应用程序为了执行合适的任务而处理了事件(为了处理Executed事件,元素还需要借助于另一个类Commanding类的对象)。    
        public bool CanExecute(object parameter, IInputElement target);
           
         public void Execute(object parameter, IInputElement target);
    }

    5、RoutedUICommand类。

    在程序中处理的大部分命令不是RoutedCommand对象,而是RoutedUICommand类的实例,RoutedUICommand类继承自RoutedCOmmand类,RoutedUIElement类只增加了Text属性,该属性是为命令显示的文本。

    6、命令库。

    每个应用程序可能有大量命令,所有基于文档的应用程序都有他们自己的版本的 New、Open以及Save命令,WPF提供了基本的命令库,而这些命令库通过5个专门的静态类的静态属性提供。

    a)、ApplicationCommands:该类提供了通用命令,包括剪贴板命令(如Copy、Open、New、Delete、SelectAll、Stop)。

    b)、NavigationCommands:该类提供了用于导航的命令。

    c)、EditingCommands:该类提供了许多重要的文档编辑命令。

    d)、ComponentCommands:该类提供了由用户界面组建使用的命令。

    e)、MediaCommands:该类提供了一组用于处理多媒体的命令。

    7、执行命令。

    RoutedUICommands类没有任何硬编码的功能,而只是表示命令,为触发命令,需要有命令源,为响应命令,需要有命令绑定,命令绑定将执行转发给普通的事件处理程序。

    7.1)命令源。

    命令库中的命令始终可用,触发他们的最简单方法是将他们关联到实现了ICommandSource接口的控件,其中包括继承自ButtonBase类的控件(如Button、CheckBox)、单独的ListBoxItem对象和MenuItem。

    ICommandSource接口的属性

    名称

    说明

    Command

    指向连接的命令,这是唯一必须的细节

    CommandParameter

    提供其他希望随命令发送的数据

    CommandTarget

    确定将在其中执行命令的元素

     

     

     

     

     

     

     

     

    <!--使用Command属性连接到ApplicationCommands.New命令-->
    <Button Margin="50" Command="ApplicationCommands.New">命令</Button>

     7.2)、命令绑定。 

    <!--使用Command属性连接到ApplicationCommands.New命令-->
    <Button Margin="50" Command="ApplicationCommands.New">命令</Button>

    当将命令关联到命令源时,会看到一些有趣的现象,命令源会被自动禁用。这是因为按钮已经查询了命令的状态,而且由于命令还没有与其关联的绑定,所以按钮被认为是禁用的。

    为改变这种状态,需要明确做以下三件事:

    a)、当命令被触发时执行什么操作。

    b)、如何确定命令是否能够被执行 (这是可选的,只要提供了关联的事件处理程序,命令总是可用的)。

    c)、命令在何处起作用。

    Xaml代码: 

    <!--使用Command属性连接到ApplicationCommands.New命令-->
    <Button Name="btn1" Margin="50" Command="ApplicationCommands.New">命令测试</Button>

    后台代码: 

    private void MainWindow_Loaded(object sender, RoutedEventArgs e)
    {
        //CommandBinding binding = new CommandBinding(ApplicationCommands.New);
        //CommandBinding:绑定到实现该命令的事件处理程序。
        CommandBinding binding = new CommandBinding();
        //Command属性:关联到ICommand。
        binding.Command = ApplicationCommands.New;
        //关联事件处理程序。
        binding.Executed += Binding_Executed; 
        //将创建的CommandBinding对象添加到包含窗口的CommandBindings集合中,当单机按钮时,CommandBinding.Executed事件从按钮冒泡到包含元素。
        this.CommandBindings.Add(binding);
    }
            
    private void Binding_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        MessageBox.Show(e.Source.ToString());
    }

     单机按钮,就会触发Excuted事件,该事件冒泡至窗口,并被上面给出的NewCommand()事件处理程序处理。

    在Xaml中创建命令,绑定处理程序:

     Xaml代码:

    <Window x:Class="命令测试2.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:命令测试2"
            mc:Ignorable="d"
            Title="MainWindow" Height="350" Width="525">
        <Window.CommandBindings>
            <CommandBinding Command="ApplicationCommands.New" Executed="CommandBinding_Executed"></CommandBinding>
        </Window.CommandBindings>
    
        <StackPanel Margin="10">
            <Button Command="ApplicationCommands.New">Xaml测试</Button>
        </StackPanel>
    </Window>

    后台代码:

    private void CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
    {
        MessageBox.Show(e.Source.ToString());
    }

    8、使用多命令源。

    <Window.CommandBindings>
        <CommandBinding Command="ApplicationCommands.New" Executed="CommandBinding_Executed"></CommandBinding>
    </Window.CommandBindings>    
       
    <StackPanel Margin="10">        
        <Menu>
            <MenuItem Header="File">
                <MenuItem Command="New"></MenuItem>
            </MenuItem>
        </Menu>        
    </StackPanel>

    MenuItem类足够智能,如果没有设置Header属性,他将从命令中提取文本,如上面Xaml中提取了"新建",MenuItem类还会自动提取Commad.InputBindings集合中的第一个快捷键(如果存在快捷键的话)。

     9、微调命令文本。

    说白了就是提取命令中的字体。

     <Button Margin="5" Command="New" Content="{Binding RelativeSource={RelativeSource Self},Path=Command.Text}" Height="40"></Button>

    10、直接调用命令。

     并且只能使用实现了ICommandSource接口的类来触发执行的命令,也可以使用Execute()方法直接调用来自任何事件处理程序的方法,这时需要传递参数值(或null引用),和目标元素的引用。

    语法:ApplicationCommands.New.Execute(null, targetElement);

     Xaml代码:

    <Window.CommandBindings>
        <CommandBinding Command="ApplicationCommands.New" Executed="CommandBinding_Executed"></CommandBinding>
     </Window.CommandBindings>
    
    <StackPanel Margin="10">
        <Button Name="btn2" Height="50">Hello,Test</Button>
    </StackPanel>

    后台代码: 

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += new RoutedEventHandler(Command_Test);
        }
    
        private void Command_Test(object sender, RoutedEventArgs e)
        {
            //也可在关联的CommandBinding对象中调用Excute()方法,这种情况下不需要提供目标元素,
            //会自动将公开正在使用CommandBinding集合的元素设置为目标元素。
            this.CommandBindings[0].Command.Execute(null); 
            
             ApplicationCommands.New.Execute(null, btn2); //目标元素是WPF开始查找命令的地方(实际引发事件的元素)
        }
    
        private void CommandBinding_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            MessageBox.Show(e.Source.ToString());
        }
    }

    11、禁用命令(通过设置CanExecute属性来更改按钮状态)。

    如果想要创建状态在启动和禁用之间变化的命令,将会体会到命令模型的真正优势。

    Xaml代码:

    <Grid>
        <Grid.RowDefinitions>
            <RowDefinition></RowDefinition>
            <RowDefinition></RowDefinition>
        </Grid.RowDefinitions>
        <TextBox TextChanged="textBox1_TextChanged" Name="textBox1" Margin="10"></TextBox>
        <Button Command="Save" Grid.Row="1" Width="250" Height="60">当TextBox值改变时,此按钮才可以点击</Button>        
    </Grid>

    后台代码:

    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
            this.Loaded += MainWindow_Loaded;
        }
    
        private void MainWindow_Loaded(object sender, RoutedEventArgs e)
        {
            //创建命令对象。
            CommandBinding binding = new CommandBinding();
            //设置关联的命令。
            binding.Command = ApplicationCommands.Save;
            //命令处理程序。
            binding.Executed += Binding_Executed;
            //检查是否可用,true:可用,false:不可用。
            binding.CanExecute += Binding_CanExecute;
            //将命令加入到CommandBindings集合中。
            this.CommandBindings.Add(binding);
        }
    
        //设置状态标志。
        bool drag = false;
        private void Binding_CanExecute(object sender, CanExecuteRoutedEventArgs e)
        {
            e.CanExecute = drag;
        }
    
        private void Binding_Executed(object sender, ExecutedRoutedEventArgs e)
        {
            MessageBox.Show("保存成功!");   
        }
    
        private void textBox1_TextChanged(object sender, TextChangedEventArgs e)
        {
            //如果文本框中的值改变了,就设置为可用状态。
            drag = true;
        }
    }

    12、具有内置命令的控件(主要用于Menu控件或ToolBar控件)。

    <TextBox  Name="textBox1" Margin="10"></TextBox>
    <ToolBar Grid.Row="1" Margin="10,-23,-9.6,22">
        <Button Command="Copy">复制</Button>
        <Button Command="Paste">粘贴</Button>
        <Button Command="Cut">剪切</Button>
    </ToolBar>

    如果不是Menu控件和ToolBar控件,需要借助FocusManager.IsFocusScope属性。

    <TextBox  Name="textBox1" Margin="10"></TextBox>
    <StackPanel Grid.Row="1" FocusManager.IsFocusScope="True">
        <Button  Command="Copy" Height="30">复制</Button>
        <Button  Command="Paste" Height="30">粘贴</Button>
        <Button  Command="Cut" Height="30">剪切</Button>
    </StackPanel>

     

    posted on 2018-08-15 00:23 NET未来之路 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/lonelyxmas/p/9479034.html

    展开全文
  • 描述了开源Nito.MVVM(WPF中的ViewModel命令类,并提供了用法说明。
  • 八,WPF 命令

    2014-08-04 23:09:00
    WPF命令模型 ICommand接口 WPF命令模型的核心是System.Windows.Input.ICommand接口,该接口定义了命令的工作原理,它包含了两个方法和一个事件: public interface ICommand { void Execute(object parameter...
  • WPFWPF 命令

    2008-04-22 15:11:00
    命令将操作的语义和发起方与其逻辑分开。 这使得多个完全不同的源可以调用...WPF 中的路由命令模型可以分为四个主要概念:命令命令源、命令目标以及命令绑定: 命令是要执行的操作。 命令源是调用...
  • WPF Commend 命令

    千次阅读 2015-04-09 06:38:14
    WPF为我们准备了完善的命令系统,你可能会问:“有了路由事件为什么还需要命令系统呢?”。事件的作用是发布、传播一些消息,消息传达到了接收者,事件的指令也就算完成了,至于如何响应事件送来的消息事件并不做...
  • 目录基础知识命令的基本要素命令的使用步骤实例:有内容时清空TextBox否则不可用wpf命令库 基础知识 命令具有约束性,事件没有。 命令可以约束代码,约束步骤逻辑,方便debug。 命令的基本要素 命令Command:wpf的...
  • 我们已经知道WPF里已经有了路由事件,可以发布及传播一些消息,那为什么还需要命令呢?这是因为事件指负责发送消息,对消息如何处理则不管,而命令是有约束力,每个接收者对命令执行统一的行为,比如菜单上的保存,...
  • 分别由5个专门的静态类的静态属性提供:ApplicationCommands、...1、ApplicationCommands:该类提供了通用的命令,包括剪贴板命令(copy、cut等)、以及文档命令(new、open、save等); 2、NavigationC...
  • 近段时间正在学习关于wpf框架的知识,学完关于命令的章节之后觉得有些困惑,在查阅了一些资料并做了一些试验后总结了一点对于命令的理解,在这里记录下来。   一、什么是命令 命令是对一系列鼠标和键盘动作的...
  • 虽然说微软提供了WPF命令库,但是处理函数还是要我们自己去写的。一般我们在窗体中编写命令绑定,这样窗体中的所有元素都可以通过命令调用窗体命令绑定的处理函数。 二、使用命令库中的命令有两种方式:XAML代码和
  • WPF自定义命令

    2012-12-04 19:01:00
    在实际的编程工作中,我们可以只是用事件,不用命令,程序的逻辑也一样被驱动的很好,但我们不能阻止程序员按照自己的习惯去写代码。比如保存事件的处理器,程序员们可以写Save()...WPF命令简介 WPF的命令是实现了...
  • WPF C# 命令 学习

    2015-12-05 21:20:00
    1.1 WPF C# 命令的本质 命令WPF 中的输入机制,它提供的输入处理比设备输入具有更高的语义级别。例如,在许多应用程序中都能找到的“复制”、“剪切”和“粘贴”操作就是命令WPF 中的命令是通过实现...
  • WPF-命令

    2014-04-30 16:19:00
    一、WPF为何需要命令 我们已经知道WPF里已经有了路由事件,可以发布及传播一些消息,那为什么还需要命令呢?这是因为事件指负责发送消息,对消息如何处理则不管,而命令是有约束力,每个接收者对命令执行统一的行为...
  • WPF:命令

    2016-08-07 11:40:22
    1、理解命令 在设计良好的Windows应用程序中,应用程序逻辑不应该位于事件处理程序中,而应在更高层的方法中编写代码。其中的每个方法都代表单独的应用程序“任务”。每个任务可能依赖其他(例如,单独编译的封装...
  • WPF学习—命令

    2018-10-16 21:00:00
    WPF命令系统基本要素: 1.命令(Command):WPF命令实际上就是实现ICommand接口的类,用的最多的是RoutedCommand类 2.命令源(Command Source):命令发送者,是实现了ICommandSource接口的类 3.命令目标...
  • WPF控件之Menu控件

    2015-06-29 16:28:00
    WPF控件之Menu(1) Menu 是一个控件,使用该控件可以对那些与命令或事件处理程序相关联的元素以分层方式进行组织。每个 Menu 可以包含多个 MenuItem 控件。每个 MenuItem 都可调用命令或调用 Click 事件...
  • WPF C# 命令的运行机制

    2019-03-18 10:17:00
    1.1 WPF C# 命令的本质 命令WPF 中的输入机制,它提供的输入处理比设备输入具有更高的语义级别。例如,在许多应用程序中都能找到的“复制”、“剪切”和“粘贴”操作就是命令WPF 中的命令是通过实现...
  • 美了哭了,AduSkin是我见过最好看的WPF控件

    万次阅读 多人点赞 2020-02-22 20:25:10
    文章通过dotnet9授权首发原创,一款简单漂亮的WPF UI,融合部分开源框架的组件
  • WPF控件之Toolbar

    千次阅读 2010-04-19 10:26:00
    ToolBar 控件是一组通常在功能上相关的命令或控件的容器。下面的插图显示垂直和水平 ToolBar 控件。水平 Toolbar垂直 Toolbar ToolBar 控件 ToolBar 控件因其按钮或其他控件像条形栏一样排列成一行或一列而得名。...
  • WPF中的命令简介

    2017-08-10 08:26:00
    使用Prism委托命令Demo:WPF委托命令DelegateCommand的传参方式 在WPF中使用命令的步骤很简单 1.创建命令 2.绑定命令 3.设置命令源 4.设置命令目标 WPF命令的核心是System.Windows.Input.ICommand接口,所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,376
精华内容 1,350
关键字:

wpf的命令库