Merge remote-tracking branch 'origin/5.5' into 5.6

Conflicts:
	qmake/doc/src/qmake-manual.qdoc
	src/corelib/tools/qstring.h
	src/gui/image/qimagereader.cpp
	src/network/access/qnetworkaccessmanager.cpp
	src/tools/qdoc/doc/examples/examples.qdoc
	src/widgets/accessible/qaccessiblewidgetfactory_p.h
	src/widgets/doc/qtwidgets.qdocconf

Change-Id: I8fae62283aebefe24e5ca4b4abd97386560c0fcb

5 files changed, 224 insertions, 17 deletions

diff --git a/src/plugins/platforms/ios/qiosmenu.h b/src/plugins/platforms/ios/qiosmenu.h
index 4fa0416df7..ec23b55507 100644
--- a/src/plugins/platforms/ios/qiosmenu.h
+++ b/src/plugins/platforms/ios/qiosmenu.h
@@ -62,7 +62,7 @@ public:
     void setRole(MenuRole role) Q_DECL_OVERRIDE;
     void setCheckable(bool) Q_DECL_OVERRIDE {}
     void setChecked(bool) Q_DECL_OVERRIDE {}
-    void setShortcut(const QKeySequence&) Q_DECL_OVERRIDE {}
+    void setShortcut(const QKeySequence&) Q_DECL_OVERRIDE;
     void setEnabled(bool enabled) Q_DECL_OVERRIDE;
     void setIconSize(int) Q_DECL_OVERRIDE {}
 
@@ -73,6 +73,7 @@ public:
     bool m_enabled;
     bool m_separator;
     QIOSMenu *m_menu;
+    QKeySequence m_shortcut;
 
 private:
     QString removeMnemonics(const QString &original);
@@ -134,6 +135,7 @@ private:
     void toggleShowUsingUIMenuController(bool show);
     void toggleShowUsingUIPickerView(bool show);
     QIOSMenuItemList visibleMenuItems() const;
+    QIOSMenuItemList filterFirstResponderActions(const QIOSMenuItemList &menuItems);
     void repositionMenu();
 };
 
diff --git a/src/plugins/platforms/ios/qiosmenu.mm b/src/plugins/platforms/ios/qiosmenu.mm
index 045d39e328..7aea3729fd 100644
--- a/src/plugins/platforms/ios/qiosmenu.mm
+++ b/src/plugins/platforms/ios/qiosmenu.mm
@@ -277,6 +277,11 @@ void QIOSMenuItem::setRole(QPlatformMenuItem::MenuRole role)
     m_role = role;
 }
 
+void QIOSMenuItem::setShortcut(const QKeySequence &sequence)
+{
+    m_shortcut = sequence;
+}
+
 void QIOSMenuItem::setEnabled(bool enabled)
 {
     m_enabled = enabled;
@@ -364,7 +369,7 @@ void QIOSMenu::syncMenuItem(QPlatformMenuItem *)
 
     switch (m_effectiveMenuType) {
     case EditMenu:
-        [m_menuController setVisibleMenuItems:visibleMenuItems()];
+        [m_menuController setVisibleMenuItems:filterFirstResponderActions(visibleMenuItems())];
         break;
     default:
         [m_pickerView setVisibleMenuItems:visibleMenuItems() selectItem:m_targetItem];
@@ -469,7 +474,7 @@ void QIOSMenu::toggleShowUsingUIMenuController(bool show)
 {
     if (show) {
         Q_ASSERT(!m_menuController);
-        m_menuController = [[QUIMenuController alloc] initWithVisibleMenuItems:visibleMenuItems()];
+        m_menuController = [[QUIMenuController alloc] initWithVisibleMenuItems:filterFirstResponderActions(visibleMenuItems())];
         repositionMenu();
         connect(qGuiApp->inputMethod(), &QInputMethod::keyboardRectangleChanged, this, &QIOSMenu::repositionMenu);
     } else {
@@ -542,6 +547,36 @@ QIOSMenuItemList QIOSMenu::visibleMenuItems() const
     return visibleMenuItems;
 }
 
+QIOSMenuItemList QIOSMenu::filterFirstResponderActions(const QIOSMenuItemList &menuItems)
+{
+    // UIResponderStandardEditActions found in first responder will be prepended to the edit
+    // menu automatically (or e.g made available as buttons on the virtual keyboard). So we
+    // filter them out to avoid duplicates, and let first responder handle the actions instead.
+    // In case of QIOSTextResponder, edit actions will be converted to key events that ends up
+    // triggering the shortcuts of the filtered menu items.
+    QIOSMenuItemList filteredMenuItems;
+    UIResponder *responder = [UIResponder currentFirstResponder];
+
+    for (int i = 0; i < menuItems.count(); ++i) {
+        QIOSMenuItem *menuItem = menuItems.at(i);
+        QKeySequence shortcut = menuItem->m_shortcut;
+        if ((shortcut == QKeySequence::Cut && [responder canPerformAction:@selector(cut:) withSender:nil])
+                || (shortcut == QKeySequence::Copy && [responder canPerformAction:@selector(copy:) withSender:nil])
+                || (shortcut == QKeySequence::Paste && [responder canPerformAction:@selector(paste:) withSender:nil])
+                || (shortcut == QKeySequence::Delete && [responder canPerformAction:@selector(delete:) withSender:nil])
+                || (shortcut == QKeySequence::SelectAll && [responder canPerformAction:@selector(selectAll:) withSender:nil])
+                || (shortcut == QKeySequence::Undo && [responder canPerformAction:@selector(undo:) withSender:nil])
+                || (shortcut == QKeySequence::Redo && [responder canPerformAction:@selector(redo:) withSender:nil])
+                || (shortcut == QKeySequence::Bold && [responder canPerformAction:@selector(toggleBoldface:) withSender:nil])
+                || (shortcut == QKeySequence::Italic && [responder canPerformAction:@selector(toggleItalics:) withSender:nil])
+                || (shortcut == QKeySequence::Underline && [responder canPerformAction:@selector(toggleUnderline:) withSender:nil])) {
+            continue;
+        }
+        filteredMenuItems.append(menuItem);
+    }
+    return filteredMenuItems;
+}
+
 void QIOSMenu::repositionMenu()
 {
     switch (m_effectiveMenuType) {
diff --git a/src/plugins/platforms/ios/qiostextresponder.mm b/src/plugins/platforms/ios/qiostextresponder.mm
index e4917593db..b95be7a883 100644
--- a/src/plugins/platforms/ios/qiostextresponder.mm
+++ b/src/plugins/platforms/ios/qiostextresponder.mm
@@ -231,6 +231,9 @@
     if (UIView *accessoryView = static_cast<UIView *>(platformData.value(kImePlatformDataInputAccessoryView).value<void *>()))
         self.inputAccessoryView = [[[WrapperView alloc] initWithView:accessoryView] autorelease];
 
+    self.undoManager.groupsByEvent = NO;
+    [self rebuildUndoStack];
+
     return self;
 }
 
@@ -346,44 +349,183 @@
 
 - (void)sendKeyPressRelease:(Qt::Key)key modifiers:(Qt::KeyboardModifiers)modifiers
 {
-    QKeyEvent press(QEvent::KeyPress, key, modifiers);
-    QKeyEvent release(QEvent::KeyRelease, key, modifiers);
-    [self sendEventToFocusObject:press];
-    [self sendEventToFocusObject:release];
+    QWindowSystemInterface::handleKeyEvent(qApp->focusWindow(), QEvent::KeyPress, key, modifiers);
+    QWindowSystemInterface::handleKeyEvent(qApp->focusWindow(), QEvent::KeyRelease, key, modifiers);
+}
+
+#ifndef QT_NO_SHORTCUT
+
+- (void)sendShortcut:(QKeySequence::StandardKey)standardKey
+{
+    const int keys = QKeySequence(standardKey)[0];
+    Qt::Key key = Qt::Key(keys & 0x0000FFFF);
+    Qt::KeyboardModifiers modifiers = Qt::KeyboardModifiers(keys & 0xFFFF0000);
+    [self sendKeyPressRelease:key modifiers:modifiers];
 }
 
 - (void)cut:(id)sender
 {
     Q_UNUSED(sender);
-    [self sendKeyPressRelease:Qt::Key_X modifiers:Qt::ControlModifier];
+    [self sendShortcut:QKeySequence::Cut];
 }
 
 - (void)copy:(id)sender
 {
     Q_UNUSED(sender);
-    [self sendKeyPressRelease:Qt::Key_C modifiers:Qt::ControlModifier];
+    [self sendShortcut:QKeySequence::Copy];
 }
 
 - (void)paste:(id)sender
 {
     Q_UNUSED(sender);
-    [self sendKeyPressRelease:Qt::Key_V modifiers:Qt::ControlModifier];
+    [self sendShortcut:QKeySequence::Paste];
 }
 
 - (void)selectAll:(id)sender
 {
     Q_UNUSED(sender);
-    [self sendKeyPressRelease:Qt::Key_A modifiers:Qt::ControlModifier];
+    [self sendShortcut:QKeySequence::SelectAll];
 }
 
 - (void)delete:(id)sender
 {
     Q_UNUSED(sender);
-    [self sendKeyPressRelease:Qt::Key_Delete modifiers:Qt::ControlModifier];
+    [self sendShortcut:QKeySequence::Delete];
+}
+
+- (void)toggleBoldface:(id)sender
+{
+    Q_UNUSED(sender);
+    [self sendShortcut:QKeySequence::Bold];
+}
+
+- (void)toggleItalics:(id)sender
+{
+    Q_UNUSED(sender);
+    [self sendShortcut:QKeySequence::Italic];
+}
+
+- (void)toggleUnderline:(id)sender
+{
+    Q_UNUSED(sender);
+    [self sendShortcut:QKeySequence::Underline];
+}
+
+// -------------------------------------------------------------------------
+
+- (void)undo
+{
+    [self sendShortcut:QKeySequence::Undo];
+    [self rebuildUndoStack];
+}
+
+- (void)redo
+{
+    [self sendShortcut:QKeySequence::Redo];
+    [self rebuildUndoStack];
+}
+
+- (void)registerRedo
+{
+    NSUndoManager *undoMgr = self.undoManager;
+    [undoMgr beginUndoGrouping];
+    [undoMgr registerUndoWithTarget:self selector:@selector(redo) object:nil];
+    [undoMgr endUndoGrouping];
+}
+
+- (void)rebuildUndoStack
+{
+    dispatch_async(dispatch_get_main_queue (), ^{
+        // Register dummy undo/redo operations to enable Cmd-Z and Cmd-Shift-Z
+        // Ensure we do this outside any undo/redo callback since NSUndoManager
+        // will treat registerUndoWithTarget as registering a redo when called
+        // from within a undo callback.
+        NSUndoManager *undoMgr = self.undoManager;
+        [undoMgr removeAllActions];
+        [undoMgr beginUndoGrouping];
+        [undoMgr registerUndoWithTarget:self selector:@selector(undo) object:nil];
+        [undoMgr endUndoGrouping];
+
+        // Schedule an operation that we immediately pop off to be able to schedule a redo
+        [undoMgr beginUndoGrouping];
+        [undoMgr registerUndoWithTarget:self selector:@selector(registerRedo) object:nil];
+        [undoMgr endUndoGrouping];
+        [undoMgr undo];
+
+        // Note that, perhaps because of a bug in UIKit, the buttons on the shortcuts bar ends up
+        // disabled if a undo/redo callback doesn't lead to a [UITextInputDelegate textDidChange].
+        // And we only call that method if Qt made changes to the text. The effect is that the buttons
+        // become disabled when there is nothing more to undo (Qt didn't change anything upon receiving
+        // an undo request). This seems to be OK behavior, so we let it stay like that unless it shows
+        // to cause problems.
+    });
 }
 
 // -------------------------------------------------------------------------
 
+- (void)keyCommandTriggered:(UIKeyCommand *)keyCommand
+{
+    Qt::Key key = Qt::Key_unknown;
+    Qt::KeyboardModifiers modifiers = Qt::NoModifier;
+
+    if (keyCommand.input == UIKeyInputLeftArrow)
+        key = Qt::Key_Left;
+    else if (keyCommand.input == UIKeyInputRightArrow)
+        key = Qt::Key_Right;
+    else if (keyCommand.input == UIKeyInputUpArrow)
+        key = Qt::Key_Up;
+    else if (keyCommand.input == UIKeyInputDownArrow)
+        key = Qt::Key_Down;
+    else
+        Q_UNREACHABLE();
+
+    if (keyCommand.modifierFlags & UIKeyModifierAlternate)
+        modifiers |= Qt::AltModifier;
+    if (keyCommand.modifierFlags & UIKeyModifierShift)
+        modifiers |= Qt::ShiftModifier;
+    if (keyCommand.modifierFlags & UIKeyModifierCommand)
+        modifiers |= Qt::ControlModifier;
+
+    [self sendKeyPressRelease:key modifiers:modifiers];
+}
+
+- (void)addKeyCommandsToArray:(NSMutableArray *)array key:(NSString *)key
+{
+    SEL s = @selector(keyCommandTriggered:);
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:0 action:s]];
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:UIKeyModifierShift action:s]];
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:UIKeyModifierAlternate action:s]];
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:UIKeyModifierAlternate|UIKeyModifierShift action:s]];
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:UIKeyModifierCommand action:s]];
+    [array addObject:[UIKeyCommand keyCommandWithInput:key modifierFlags:UIKeyModifierCommand|UIKeyModifierShift action:s]];
+}
+
+- (NSArray *)keyCommands
+{
+    // Since keyCommands is called for every key
+    // press/release, we cache the result
+    static dispatch_once_t once;
+    static NSMutableArray *array;
+
+    dispatch_once(&once, ^{
+        // We let Qt move the cursor around when the arrow keys are being used. This
+        // is normally implemented through UITextInput, but since IM in Qt have poor
+        // support for moving the cursor vertically, and even less support for selecting
+        // text across multiple paragraphs, we do this through key events.
+        array = [NSMutableArray new];
+        [self addKeyCommandsToArray:array key:UIKeyInputUpArrow];
+        [self addKeyCommandsToArray:array key:UIKeyInputDownArrow];
+        [self addKeyCommandsToArray:array key:UIKeyInputLeftArrow];
+        [self addKeyCommandsToArray:array key:UIKeyInputRightArrow];
+    });
+
+    return array;
+}
+
+#endif // QT_NO_SHORTCUT
+
+// -------------------------------------------------------------------------
+
 - (void)notifyInputDelegate:(Qt::InputMethodQueries)updatedProperties
 {
     // As documented, we should not report textWillChange/textDidChange unless the text
@@ -540,7 +682,17 @@
 - (UITextPosition *)positionFromPosition:(UITextPosition *)position inDirection:(UITextLayoutDirection)direction offset:(NSInteger)offset
 {
     int p = static_cast<QUITextPosition *>(position).index;
-    return [QUITextPosition positionWithIndex:(direction == UITextLayoutDirectionRight ? p + offset : p - offset)];
+
+    switch (direction) {
+    case UITextLayoutDirectionLeft:
+        return [QUITextPosition positionWithIndex:p - offset];
+    case UITextLayoutDirectionRight:
+        return [QUITextPosition positionWithIndex:p + offset];
+    default:
+        // Qt doesn't support getting the position above or below the current position, so
+        // for those cases we just return the current position, making it a no-op.
+        return position;
+    }
 }
 
 - (UITextPosition *)positionWithinRange:(UITextRange *)range farthestInDirection:(UITextLayoutDirection)direction
@@ -608,6 +760,15 @@
     return toCGRect(startRect.united(endRect));
 }
 
+- (NSArray *)selectionRectsForRange:(UITextRange *)range
+{
+    Q_UNUSED(range);
+    // This method is supposed to return a rectangle for each line with selection. Since we don't
+    // expose an API in Qt/IM for getting this information, and since we never seems to be getting
+    // a call from UIKit for this, we return an empty array until a need arise.
+    return [[NSArray new] autorelease];
+}
+
 - (CGRect)caretRectForPosition:(UITextPosition *)position
 {
     Q_UNUSED(position);
@@ -734,10 +895,10 @@
 
 - (void)deleteBackward
 {
-    // Since we're posting im events directly to the focus object, we should do the
-    // same for key events. Otherwise they might end up in a different place or out
-    // of sync with im events.
+    // UITextInput selects the text to be deleted before calling this method. To avoid
+    // drawing the selection, we flush after posting the key press/release.
     [self sendKeyPressRelease:Qt::Key_Backspace modifiers:Qt::NoModifier];
+    QWindowSystemInterface::flushWindowSystemEvents();
 }
 
 @end
diff --git a/src/plugins/platforms/ios/qiostheme.mm b/src/plugins/platforms/ios/qiostheme.mm
index edeabf66dc..bc40069670 100644
--- a/src/plugins/platforms/ios/qiostheme.mm
+++ b/src/plugins/platforms/ios/qiostheme.mm
@@ -107,6 +107,8 @@ QVariant QIOSTheme::themeHint(ThemeHint hint) const
     switch (hint) {
     case QPlatformTheme::StyleNames:
         return QStringList(QStringLiteral("fusion"));
+    case KeyboardScheme:
+        return QVariant(int(MacKeyboardScheme));
     default:
         return QPlatformTheme::themeHint(hint);
     }
diff --git a/src/plugins/platforms/ios/qiosviewcontroller.mm b/src/plugins/platforms/ios/qiosviewcontroller.mm
index 67b33ce235..94d894bba7 100644
--- a/src/plugins/platforms/ios/qiosviewcontroller.mm
+++ b/src/plugins/platforms/ios/qiosviewcontroller.mm
@@ -185,7 +185,14 @@
 
 - (void)setFrame:(CGRect)newFrame
 {
-    [super setFrame:CGRectMake(0, 0, CGRectGetWidth(newFrame), CGRectGetHeight(self.window.bounds))];
+    Q_UNUSED(newFrame);
+    Q_ASSERT(!self.window || self.window.rootViewController.view == self);
+
+    // When presenting view controllers our view may be temporarily reparented into a UITransitionView
+    // instead of the UIWindow, and the UITransitionView may have a transform set, so we need to do a
+    // mapping even if we still expect to always be the root view-controller.
+    CGRect transformedWindowBounds = [self.superview convertRect:self.window.bounds fromView:self.window];
+    [super setFrame:transformedWindowBounds];
 }
 
 - (void)setBounds:(CGRect)newBounds