Comportamento copia/incolla personalizzato con C# winforms mentre consente la modifica del testo copia/incolla

Question

Attualmente ho un'applicazione C# winforms con Ctrl + C e Ctrl + V vincolata come scorciatoie da tastiera nel menu principale Modifica. Esiste un comportamento di copia/incolla personalizzato all'interno del codice che risponde a queste voci di menu, come ad esempio copiare e incollare righe in listview.

Tuttavia, il mio problema è che è possibile modificare il testo all'interno di una riga, e quando si esegue questa operazione, desidero Ctrl + C e Ctrl + V per non attivare il comando del menu di modifica e preferire la normale copia di testo /incolla.

Una cosa che ho provato è l'attivazione degli eventi BeforeLabelEdit e AfterLabelEdit e la disabilitazione/riattivazione manuale degli elementi del menu dall'interno. Sfortunatamente, sembra che una scorciatoia da tastiera su una voce di menu disabilitata attiva ancora l'evento menu_Popup, che è attualmente utilizzato per decidere quali voci di menu devono essere abilitate/disabilitate. (Ad esempio, "Incolla" è attivo solo se c'è un testo negli Appunti). Quindi, anche se disattivo la voce di menu, la scorciatoia da tastiera attiverà comunque l'evento Popup, che riabiliterà la voce di menu. (Si tratta di un bug?)

Non riesco a trovare alcun metodo per disabilitare temporaneamente una scorciatoia da tastiera di voci di menu senza memorizzare manualmente la vecchia scorciatoia, impostare il collegamento su null, quindi copiarlo quando devo riattivarlo (che si sente sporco).

Sicuramente ignorare il comportamento di copia/incolla o aggiungervi, è una cosa comune da fare? C'è un modello migliore da usare qui?

Answer 1

Sembra che sia necessario utilizzare un livello inferiore rispetto a C# se si desidera sostituire il comportamento predefinito di copia/incolla (vedere Clipboard event C# e Detect & Differentiate Clipboard Events (Cut,Copy and Paste)). Tuttavia, forse potresti mettere la tua logica dietro una "guardia" che sa come indirizzare una richiesta di azione (come la "Copia") e poi ridirigerla come approprite.

Ecco una lezione di prova:

namespace Your.App 
{ 
    public class GuardedCommand 
    { 
     public bool CurrentlyEditing { get; set; } 
     public GuardedCommand() 
     { 
      CurrentlyEditing = false; 
     } 
     public void DoCopy() 
     { 
      if(CurrentlyEditing) 
       StandardCopyCommand(); 
      else 
       ShortcutCopyCommand(); 
     } 
     void ShortcutCopyCommand() { /*menu work here (or delegate to another class)*/ } 
     void StandardCopyCommand() { /*"normal" work here (or delegate again)*/ } 
    } 
} 

Per utilizzare si dovrebbe creare la classe, quindi impostare è guardedCommand.CurrentlyEditing proprietà come appropriato nei BeforeLabelEdit e AfterLabelEdit eventi. Quindi, ogni volta che prendi la scorciatoia CTRL + C, invoca semplicemente guardedCommand.DoCopy() e si occuperà del resto.

Se stai cercando di leggere un modello per quello che stai cercando di fare, controlla lo State Pattern, che il codice precedente è una sorta di implementazione e di. Per essere un modello di stato (o strategia) reale, è necessario disporre di classi concrete separate che implementino DoCopy() e DoPaste() anziché utilizzare solo if/else o switch. Quindi, quando viene modificato CurrentlyEditing, l'implementazione concreta corretta viene impostata come classe corrente utilizzata per gestire il metodo DoCopy().

E solo perché mi c'è voluto più tempo per scrivere che il paragrafo di quello che avrebbe dovuto solo dare un codice, ecco qualche codice:

namespace Your.App 
{ 
//correct implementation of the State Pattern 
    interface IClipboard 
    { 
     void Copy(); 
     void Paste(); 
    } 
    class MyCustomClipboard : IClipboard 
    { 
     public void Copy() { /*your special code*/ } 
     public void Paste() { /*your code again*/ } 
    } 
    class DefaultClipboard : IClipboard 
    { 
     public void Copy() { /*default code*/ } 
     public void Paste() { /*default code again*/ } 
    } 
    public class StateClass 
    { 
     IClipboard State { get; set; } 
     public StateClass() 
     { 
      CurrentlyEditing = false; 
     } 
     bool _currentlyEditing; 
     public bool CurrentlyEditing 
     { 
      get { return _currentlyEditing; } 
      set 
      { 
       _currentlyEditing = value; 
       if(_currentlyEditing) 
        State = new DefaultClipboard(); 
       else 
        State = new MyCustomClipboard(); 
      } 
     } 
     public void Copy() 
     { 
      State.Copy(); 
     } 
     public void Paste() 
     { 
      State.Paste(); 
     } 
    } 
} 

Come si può vedere, questo può essere un po 'eccessivo quando c'è sono solo due stati (e il numero di stati probabilmente non aumenterà).