MacViews: Merge single-character edits, map (and validate) undo and redo

ui/views/cocoa/bridged_content_view.mm

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "ui/views/cocoa/bridged_content_view.h"
 
 #include "base/logging.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ui/base/ime/text_input_client.h"
@@ skipping 49 matching lines @@
 // Note: default key bindings in Mac can be read from StandardKeyBinding.dict
 // which lives in /System/Library/Frameworks/AppKit.framework/Resources. Do
 // `plutil -convert xml1 -o StandardKeyBinding.xml StandardKeyBinding.dict` to
 // get something readable.
 - (void)handleAction:(int)commandId
              keyCode:(ui::KeyboardCode)keyCode
              domCode:(ui::DomCode)domCode
           eventFlags:(int)eventFlags;
 
 // Menu action handlers.
+- (void)undo:(id)sender;
+- (void)redo:(id)sender;
 - (void)cut:(id)sender;
 - (void)copy:(id)sender;
 - (void)paste:(id)sender;
 - (void)selectAll:(id)sender;
 
 @end
 
 @implementation BridgedContentView
 
 @synthesize hostedView = hostedView_;
@@ skipping 78 matching lines @@
   // performed.
   if (commandId && textInputClient_ &&
       textInputClient_->IsEditCommandEnabled(commandId))
     textInputClient_->SetEditCommandForNextKeyEvent(commandId);
 
   // Generate a synthetic event with the keycode toolkit-views expects.
   ui::KeyEvent event(ui::ET_KEY_PRESSED, keyCode, domCode, eventFlags);
   hostedView_->GetWidget()->GetInputMethod()->DispatchKeyEvent(event);
 }
 
+- (void)undo:(id)sender {
+  // This DCHECK is more strict than a similar check in handleAction:. It can be
+  // done here because the actors sending these actions should be calling
+  // validateUserInterfaceItem: before enabling UI that allows these messages to
+  // be sent. Checking it here would be too late to provide correct UI feedback
+  // (e.g. there will be no "beep").
+  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_UNDO));
+  [self handleAction:IDS_APP_UNDO
+             keyCode:ui::VKEY_Z
+             domCode:ui::DomCode::KEY_Z
+          eventFlags:ui::EF_CONTROL_DOWN];
+}
+
+- (void)redo:(id)sender {
+  DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_REDO));
+  [self handleAction:IDS_APP_REDO
+             keyCode:ui::VKEY_Z
+             domCode:ui::DomCode::KEY_Z
+          eventFlags:ui::EF_CONTROL_DOWN | ui::EF_SHIFT_DOWN];
+}
+
 - (void)cut:(id)sender {
   DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_CUT));
   [self handleAction:IDS_APP_CUT
              keyCode:ui::VKEY_X
              domCode:ui::DomCode::KEY_X
           eventFlags:ui::EF_CONTROL_DOWN];
 }
 
 - (void)copy:(id)sender {
   DCHECK(textInputClient_->IsEditCommandEnabled(IDS_APP_COPY));
@@ skipping 58 matching lines @@
   if (menuController && menuController->owner() == hostedView_->GetWidget())
     return nil;
 
   return [super inputContext];
 }
 
 // NSResponder implementation.
 
 - (void)keyDown:(NSEvent*)theEvent {
   // Convert the event into an action message, according to OSX key mappings.
+  inKeyDown_ = YES;
   [self interpretKeyEvents:@[ theEvent ]];
+  inKeyDown_ = NO;
 }
 
 - (void)mouseDown:(NSEvent*)theEvent {
   [self handleMouseEvent:theEvent];
 }
 
 - (void)rightMouseDown:(NSEvent*)theEvent {
   [self handleMouseEvent:theEvent];
 }
 
@@ skipping 304 matching lines @@
       swallowedAny = true;
       // Ensure the menu remains active.
       menuController = MenuController::GetActiveInstance();
     }
   }
 
   if (!textInputClient_)
     return;
 
   textInputClient_->DeleteRange(gfx::Range(replacementRange));
-  textInputClient_->InsertText(base::SysNSStringToUTF16(text));
+
+  // If a single character is inserted by keyDown's call to interpretKeyEvents:
+  // then use InsertChar() to allow editing events to be merged. Never send the
+  // key modifier flags to InsertChar since interpretKeyEvents: will filter out
+  // things that are actually commands, and 'Alt' on Mac actually inserts
+  // alternate characters (e.g. Alt+S is ß), so shouldn't be ignored.

[msw, 2015/02/18 19:10:42]

nit: This comment is worded a little confusingly... I assume if the user presses
Alt+S, |text| already contains "ß" instead of "s"? Can you make that a little
clearer, if so? Otherwise it sounds like the key modifier flags *shouldn't* be
ignored here, but that conflicts "Never send" above.

[tapted, 2015/02/19 03:19:10]

Done.

(now says

If a single character is inserted by keyDown's call to interpretKeyEvents: then
use InsertChar() to allow editing events to be merged. The second argument is
the key modifier, which interpretKeyEvents: will have already processed, so
don't send it to InsertChar() as well. E.g. Alt+S puts 'ß' in |text| but sending
'Alt' to InsertChar would filter it out since it thinks it's a command. Actual
commands (e.g. Cmd+S) won't go through insertText:.

+  if (inKeyDown_ && [text length] == 1)
+    textInputClient_->InsertChar([text characterAtIndex:0], 0);
+  else
+    textInputClient_->InsertText(base::SysNSStringToUTF16(text));
 }
 
 - (NSRange)markedRange {
   if (!textInputClient_)
     return NSMakeRange(NSNotFound, 0);
 
   gfx::Range range;
   textInputClient_->GetCompositionTextRange(&range);
   return range.ToNSRange();
 }
@@ skipping 31 matching lines @@
 }
 
 // NSUserInterfaceValidations protocol implementation.
 
 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
   if (!textInputClient_)
     return NO;
 
   SEL action = [item action];
 
+  if (action == @selector(undo:))
+    return textInputClient_->IsEditCommandEnabled(IDS_APP_UNDO);
+  if (action == @selector(redo:))
+    return textInputClient_->IsEditCommandEnabled(IDS_APP_REDO);
   if (action == @selector(cut:))
     return textInputClient_->IsEditCommandEnabled(IDS_APP_CUT);
   if (action == @selector(copy:))
     return textInputClient_->IsEditCommandEnabled(IDS_APP_COPY);
   if (action == @selector(paste:))
     return textInputClient_->IsEditCommandEnabled(IDS_APP_PASTE);
   if (action == @selector(selectAll:))
     return textInputClient_->IsEditCommandEnabled(IDS_APP_SELECT_ALL);
 
   return NO;
 }
 
 // NSAccessibility informal protocol implementation.
 
 - (id)accessibilityAttributeValue:(NSString*)attribute {
   if ([attribute isEqualToString:NSAccessibilityChildrenAttribute]) {
     return @[ hostedView_->GetNativeViewAccessible() ];
   }
 
   return [super accessibilityAttributeValue:attribute];
 }
 
 - (id)accessibilityHitTest:(NSPoint)point {
   return [hostedView_->GetNativeViewAccessible() accessibilityHitTest:point];
 }
 
 @end