WebCore:
authorsullivan <sullivan@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 5 Dec 2006 18:36:06 +0000 (18:36 +0000)
committersullivan <sullivan@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 5 Dec 2006 18:36:06 +0000 (18:36 +0000)
        Reviewed by Darin

        WebCore part of fix for:
        <rdar://problem/4817188> Context menu for bad grammar should include suggestions and "Ignore Grammar"

        The context menu mechanism is currently in flux; the old mechanism is still in place, but an
        up-and-coming new mechanism is waiting in the wings. I updated both of them, but couldn't
        test the new mechanism because it doesn't work well enough yet. Also, some of this code
        should move from Frame to Editor, but that will wait for another checkin.

        * page/Frame.h:
        added pure virtual function declarations for isSelectionUngrammatical() and guessesForUngrammaticalSelection()

        * bridge/mac/FrameMac.h:
        added virtual functions declarations for isSelectionUngrammatical() and guessesForUngrammaticalSelection()

        * bridge/mac/FrameMac.mm:
        (WebCore::FrameMac::isSelectionMisspelled):
        now updates spelling panel (whether or not it's showing), since this is now needed to make -[NSSSpellChecker
        ignoreWord:inSpellDocumentWithTag:] work correctly
        (WebCore::isRangeUngrammatical):
        new function, helper used by both isSelectionUngrammatical() and guessesForUngrammaticalSelection()
        (WebCore::FrameMac::isSelectionUngrammatical):
        new function, calls isRangeUngrammatical
        (WebCore::FrameMac::guessesForUngrammaticalSelection):
        ditto

        * platform/ContextMenu.cpp:
        (WebCore::ContextMenu::populate):
        now considers bad grammar as well as misspellings

        * platform/ContextMenuItem.h:
        added ContextMenuItemTagIgnoreGrammar

WebKit:

        Reviewed by Darin

        WebKit part of fix for:
        <rdar://problem/4817188> Context menu for bad grammar should include suggestions and "Ignore Grammar"

        The context menu mechanism is currently in flux; the old mechanism is still in place, but an
        up-and-coming new mechanism is waiting in the wings. I updated both of them, but couldn't
        test the new mechanism because it doesn't work well enough yet. Most of this WebKit code
        can be deleted when the new mechanism is in place.

        * WebView/WebUIDelegatePrivate.h:
        added WebMenuItemTagIgnoreGrammar

        * DefaultDelegates/WebDefaultContextMenuDelegate.m:
        (-[WebDefaultUIDelegate menuItemWithTag:target:representedObject:]):
        added case for WebMenuItemTagIgnoreGrammar
        (-[WebDefaultUIDelegate editingContextMenuItemsForElement:defaultMenuItems:]):
        now considers adding grammar-related items as well as spelling-related items

        * WebView/WebHTMLViewPrivate.h:
        declared _isSelectionUngrammatical

        * WebView/WebHTMLView.m:
        (-[WebHTMLView _isSelectionUngrammatical]):
        new method, calls through to WebCore
        (-[WebHTMLView _ignoreGrammarFromMenu:]):
        new method, calls _ignoreSpellingFromMenu: since NSSpellChecker has one method for both

        * English.lproj/Localizable.strings:
        updated for "Ignore Grammar" menu item title

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@18021 268f45cc-cd09-0410-ab3c-d52691b4dbfc

14 files changed:
WebCore/ChangeLog
WebCore/WebCore.xcodeproj/project.pbxproj
WebCore/bridge/mac/FrameMac.h
WebCore/bridge/mac/FrameMac.mm
WebCore/page/Frame.h
WebCore/platform/ContextMenu.cpp
WebCore/platform/ContextMenuItem.h
WebKit/ChangeLog
WebKit/DefaultDelegates/WebDefaultContextMenuDelegate.m
WebKit/English.lproj/Localizable.strings
WebKit/WebKit.xcodeproj/project.pbxproj
WebKit/WebView/WebHTMLView.m
WebKit/WebView/WebHTMLViewPrivate.h
WebKit/WebView/WebUIDelegatePrivate.h

index f187cf68d24dd25ecea36f4ccb86ce203d8a05df..5289b3961215e283b48bf1c13c3001c25e7e6082 100644 (file)
@@ -1,3 +1,39 @@
+2006-12-04  John Sullivan  <sullivan@apple.com>
+
+        Reviewed by Darin
+
+        WebCore part of fix for:
+        <rdar://problem/4817188> Context menu for bad grammar should include suggestions and "Ignore Grammar"
+
+        The context menu mechanism is currently in flux; the old mechanism is still in place, but an
+        up-and-coming new mechanism is waiting in the wings. I updated both of them, but couldn't
+        test the new mechanism because it doesn't work well enough yet. Also, some of this code 
+        should move from Frame to Editor, but that will wait for another checkin.
+
+        * page/Frame.h:
+        added pure virtual function declarations for isSelectionUngrammatical() and guessesForUngrammaticalSelection()
+
+        * bridge/mac/FrameMac.h:
+        added virtual functions declarations for isSelectionUngrammatical() and guessesForUngrammaticalSelection()
+
+        * bridge/mac/FrameMac.mm:
+        (WebCore::FrameMac::isSelectionMisspelled):
+        now updates spelling panel (whether or not it's showing), since this is now needed to make -[NSSSpellChecker
+        ignoreWord:inSpellDocumentWithTag:] work correctly
+        (WebCore::isRangeUngrammatical):
+        new function, helper used by both isSelectionUngrammatical() and guessesForUngrammaticalSelection()
+        (WebCore::FrameMac::isSelectionUngrammatical):
+        new function, calls isRangeUngrammatical
+        (WebCore::FrameMac::guessesForUngrammaticalSelection):
+        ditto
+
+        * platform/ContextMenu.cpp:
+        (WebCore::ContextMenu::populate):
+        now considers bad grammar as well as misspellings
+        
+        * platform/ContextMenuItem.h:
+        added ContextMenuItemTagIgnoreGrammar
+        
 2006-12-05  Kirby White  <KWhiteRight@gmail.com>
 
         Reviewed, tweaked and landed by Alexey.
index a31ea7acbe0842f547ecbcc3a980802838093358..93cd4dceaab8457768d846dea38a65de6d70d7a6 100644 (file)
                0867D690FE84028FC02AAC07 /* Project object */ = {
                        isa = PBXProject;
                        buildConfigurationList = 149C284308902B11008A9EFC /* Build configuration list for PBXProject "WebCore" */;
+                       compatibilityVersion = "Xcode 2.4";
                        hasScannedForEncodings = 1;
                        knownRegions = (
                                English,
                        mainGroup = 0867D691FE84028FC02AAC07 /* WebKit */;
                        productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
                        projectDirPath = "";
+                       projectRoot = "";
+                       shouldCheckCompatibility = 1;
                        targets = (
                                93F198A508245E59001E9ABC /* WebCore */,
                                DD041FBE09D9DDBE0010AF2A /* Derived Sources */,
index bad30bf3b9db0da72fc361cf8aa2e52d1b3556c6..7f33bbee4ffe787e16fd28178412c15afa2f9f65 100644 (file)
@@ -167,8 +167,10 @@ public:
 
     virtual void ignoreSpelling();
     virtual void learnSpelling();
+    virtual bool isSelectionUngrammatical();
     virtual bool isSelectionMisspelled();
     virtual Vector<String> guessesForMisspelledSelection();
+    virtual Vector<String> guessesForUngrammaticalSelection();
     virtual void markMisspellingsInAdjacentWords(const VisiblePosition&);
     virtual void markMisspellings(const Selection&);
 
index 8ffa5c9355cade9a8a25a9d1ef7b9979a6785737..36fcc1e9e65dabeca39810c235ca54b1173ed2fa 100644 (file)
@@ -1228,13 +1228,102 @@ bool FrameMac::isSelectionMisspelled()
     unsigned length = selectedString.length();
     if (length == 0)
         return false;
-    NSRange range = [[NSSpellChecker sharedSpellChecker] checkSpellingOfString:selectedString
-                                                                    startingAt:0
-                                                                      language:nil
-                                                                          wrap:NO 
-                                                        inSpellDocumentWithTag:editor()->spellCheckerDocumentTag() 
-                                                                     wordCount:NULL];
-    return range.length == length;
+    
+    NSSpellChecker *checker = [NSSpellChecker sharedSpellChecker];
+    if (!checker)
+        return false;
+    
+    NSRange range = [checker checkSpellingOfString:selectedString
+                                        startingAt:0
+                                          language:nil
+                                              wrap:NO 
+                            inSpellDocumentWithTag:editor()->spellCheckerDocumentTag() 
+                                         wordCount:NULL];
+    
+    // The selection only counts as misspelled if the selected text is exactly one misspelled word
+    if (range.length != length)
+        return false;
+    
+    // Update the spelling panel to be displaying this error (whether or not the spelling panel is on screen).
+    // This is necessary to make a subsequent call to [NSSpellChecker ignoreWord:inSpellDocumentWithTag:] work
+    // correctly; that call behaves differently based on whether the spelling panel is displaying a misspelling
+    // or a grammar error.
+    [checker updateSpellingPanelWithMisspelledWord:selectedString];
+    
+    return true;
+}
+    
+#ifndef BUILDING_ON_TIGER
+static bool isRangeUngrammatical(int tag, Range *range, Vector<String>& guessesVector)
+{
+    // Returns true only if the passed range exactly corresponds to a bad grammar detail range. This is analogous
+    // to isSelectionMisspelled. It's not good enough for there to be some bad grammar somewhere in the range,
+    // or overlapping the range; the ranges must exactly match.
+    guessesVector.clear();
+    NSDictionary *grammarDetail;
+    int grammarPhraseOffset;
+    NSSpellChecker *checker = [NSSpellChecker sharedSpellChecker];
+    if (!checker)
+        return false;
+    
+    NSString *badGrammarPhrase = findFirstBadGrammarInRange(checker, tag, range, grammarDetail, grammarPhraseOffset, false);    
+    
+    // No bad grammar in these parts at all.
+    if (!badGrammarPhrase)
+        return false;
+    
+    // Bad grammar, but phrase (e.g. sentence) starts beyond start of range.
+    if (grammarPhraseOffset > 0)
+        return false;
+    
+    ASSERT(grammarDetail);
+    NSValue *detailRangeAsNSValue = [grammarDetail objectForKey:NSGrammarRange];
+    ASSERT(detailRangeAsNSValue);
+    NSRange detailNSRange = [detailRangeAsNSValue rangeValue];
+    ASSERT(detailNSRange.location != NSNotFound && detailNSRange.length > 0);
+    
+    // Bad grammar, but start of detail (e.g. ungrammatical word) doesn't match start of range
+    if (detailNSRange.location + grammarPhraseOffset != 0)
+        return false;
+    
+    // Bad grammar at start of range, but end of bad grammar is before or after end of range
+    if ((int)detailNSRange.length != TextIterator::rangeLength(range))
+        return false;
+    
+    NSArray *guesses = [grammarDetail objectForKey:NSGrammarCorrections];
+    for (NSString *guess in guesses)
+        guessesVector.append(guess);
+
+    // Update the spelling panel to be displaying this error (whether or not the spelling panel is on screen).
+    // This is necessary to make a subsequent call to [NSSpellChecker ignoreWord:inSpellDocumentWithTag:] work
+    // correctly; that call behaves differently based on whether the spelling panel is displaying a misspelling
+    // or a grammar error.
+    [checker updateSpellingPanelWithGrammarString:badGrammarPhrase detail:grammarDetail];
+
+    return true;
+}
+#endif
+    
+bool FrameMac::isSelectionUngrammatical()
+{
+#ifdef BUILDING_ON_TIGER
+    return false;
+#else
+    Vector<String> ignoredGuesses;
+    return isRangeUngrammatical(editor()->spellCheckerDocumentTag(), selectionController()->toRange().get(), ignoredGuesses);
+#endif
+}
+
+Vector<String> FrameMac::guessesForUngrammaticalSelection()
+{
+#ifdef BUILDING_ON_TIGER
+    return Vector<String>();
+#else
+    Vector<String> guesses;
+    // Ignore the result of isRangeUngrammatical; we just want the guesses, whether or not there are any
+    isRangeUngrammatical(editor()->spellCheckerDocumentTag(), selectionController()->toRange().get(), guesses);
+    return guesses;
+#endif
 }
 
 static Vector<String> core(NSArray* stringsArray)
index 16d2e22424b9bf8dccdae7ba7586c7b1cc6ea4e9..47e85124fec5916163c25db5911a3e58aff631ad 100644 (file)
@@ -258,8 +258,10 @@ public:
 
     virtual void ignoreSpelling() = 0;
     virtual void learnSpelling() = 0;
+    virtual bool isSelectionUngrammatical() = 0;
     virtual bool isSelectionMisspelled() = 0;
     virtual Vector<String> guessesForMisspelledSelection() = 0;
+    virtual Vector<String> guessesForUngrammaticalSelection() = 0;
     virtual void markMisspellingsInAdjacentWords(const VisiblePosition&) = 0;
     virtual void markMisspellings(const Selection&) = 0;
     virtual Range* markedTextRange() const = 0;
index 89f5b4a5b4a6289c31afdff04d6acde991fb4f27..416a7a4aa55d6c2b8cd017f913ab37be5abf4905 100644 (file)
@@ -28,6 +28,7 @@
 
 #include "ContextMenuController.h"
 #include "Document.h"
+#include "Editor.h"
 #include "Frame.h"
 #include "FrameLoader.h"
 #include "KURL.h"
@@ -150,6 +151,7 @@ void ContextMenu::populate()
     MENU_ACTION_ITEM(SpellingGuess, "");
     MENU_ACTION_ITEM(NoGuessesFound, "No Guesses Found");
     MENU_ACTION_ITEM(IgnoreSpelling, "Ignore Spelling");
+    MENU_ACTION_ITEM(IgnoreGrammar, "Ignore Grammar");
     MENU_ACTION_ITEM(LearnSpelling, "Learn Spelling");
 #if PLATFORM(MAC)
     MENU_ACTION_ITEM(SearchInSpotlight, "Search in Spotlight");
@@ -219,27 +221,36 @@ void ContextMenu::populate()
     } else { // Make an editing context menu
         SelectionController* selectionController = frame->selectionController();
         bool inPasswordField = selectionController->isInPasswordField();
-
-        // Add spelling-related context menu items.
-        if (frame->isSelectionMisspelled() && !inPasswordField) {
-            Vector<String> guesses = frame->guessesForMisspelledSelection();
-            unsigned size = guesses.size();
-            if (size == 0)
-                appendItem(NoGuessesFoundItem);
-            else {
-                for (unsigned i = 0; i < size; i++) {
-                    String guess = guesses[i];
-                    if (!guess.isNull()) {
-                        ContextMenuItem item(ActionType, ContextMenuItemTagSpellingGuess, guess);
-                        appendItem(item);
+        
+        if (!inPasswordField) {
+            // Consider adding spelling-related or grammar-related context menu items (never both, since a single selected range
+            // is never considered a misspelling and bad grammar at the same time)
+            bool misspelling = frame->isSelectionMisspelled();
+            bool badGrammar = !misspelling && (frame->editor()->client()->isGrammarCheckingEnabled() && frame->isSelectionUngrammatical());
+            
+            if (misspelling || badGrammar) {
+                Vector<String> guesses = misspelling ? frame->guessesForMisspelledSelection() : frame->guessesForUngrammaticalSelection();
+                size_t size = guesses.size();
+                if (size == 0)
+                    appendItem(NoGuessesFoundItem);
+                else {
+                    for (unsigned i = 0; i < size; i++) {
+                        const String &guess = guesses[i];
+                        if (!guess.isEmpty()) {
+                            ContextMenuItem item(ActionType, ContextMenuItemTagSpellingGuess, guess);
+                            appendItem(item);
+                        }
                     }
                 }
-            }                
-
-            appendItem(SeparatorItem);
-            appendItem(IgnoreSpellingItem);
-            appendItem(LearnSpellingItem);
-            appendItem(SeparatorItem);
+                
+                appendItem(SeparatorItem);
+                if (misspelling) {
+                    appendItem(IgnoreSpellingItem);
+                    appendItem(LearnSpellingItem);
+                } else
+                    appendItem(IgnoreGrammarItem);
+                appendItem(SeparatorItem);
+            }
         }
 
         if (result.isSelected() && !inPasswordField) {
index cd073d31ecf3013ac8c827a84df4c3690a1815eb..845dfc255b27d9f90bcc3e045156a7ce53670d91 100644 (file)
@@ -93,6 +93,7 @@ namespace WebCore {
         ContextMenuItemPDFPreviousPage,
         // These are new tags! Not a part of API!!!!
         ContextMenuItemTagOpenLink = 1000,
+        ContextMenuItemTagIgnoreGrammar,
 #ifndef BUILDING_ON_TIGER
         ContextMenuItemTagSpellingAndGrammarMenu, // Spelling sub-menu
         ContextMenuItemTagShowSpellingAndGrammar,
index 6a0d2c2b10bf6724883fabf395b8d51330d88325..82ea309f38f5967ce43f8bc86c8181e7e02c736a 100644 (file)
@@ -1,3 +1,36 @@
+2006-12-04  John Sullivan  <sullivan@apple.com>
+
+        Reviewed by Darin
+
+        WebKit part of fix for:
+        <rdar://problem/4817188> Context menu for bad grammar should include suggestions and "Ignore Grammar"
+
+        The context menu mechanism is currently in flux; the old mechanism is still in place, but an
+        up-and-coming new mechanism is waiting in the wings. I updated both of them, but couldn't
+        test the new mechanism because it doesn't work well enough yet. Most of this WebKit code
+        can be deleted when the new mechanism is in place.
+
+        * WebView/WebUIDelegatePrivate.h:
+        added WebMenuItemTagIgnoreGrammar
+
+        * DefaultDelegates/WebDefaultContextMenuDelegate.m:
+        (-[WebDefaultUIDelegate menuItemWithTag:target:representedObject:]):
+        added case for WebMenuItemTagIgnoreGrammar
+        (-[WebDefaultUIDelegate editingContextMenuItemsForElement:defaultMenuItems:]):
+        now considers adding grammar-related items as well as spelling-related items
+        
+        * WebView/WebHTMLViewPrivate.h:
+        declared _isSelectionUngrammatical
+
+        * WebView/WebHTMLView.m:
+        (-[WebHTMLView _isSelectionUngrammatical]):
+        new method, calls through to WebCore
+        (-[WebHTMLView _ignoreGrammarFromMenu:]):
+        new method, calls _ignoreSpellingFromMenu: since NSSpellChecker has one method for both
+
+        * English.lproj/Localizable.strings:
+        updated for "Ignore Grammar" menu item title
+
 2006-12-04  Darin Adler  <darin@apple.com>
 
         Reviewed by Adele.
index 30069f9e228372ff88947f6c866a1072c9486ce6..052df9f4c38f89708dfd74d6d2be6eed0de27edd 100644 (file)
@@ -147,6 +147,12 @@ static NSString *localizedMenuTitleFromAppKit(NSString *key, NSString *comment)
             title = UI_STRING("Ignore Spelling", "Ignore Spelling context menu item");
             action = @selector(_ignoreSpellingFromMenu:);
             break;
+#ifndef BUILDING_ON_TIGER
+        case WebMenuItemTagIgnoreGrammar:
+            title = UI_STRING("Ignore Grammar", "Ignore Grammar context menu item");
+            action = @selector(_ignoreGrammarFromMenu:);
+            break;
+#endif
         case WebMenuItemTagLearnSpelling:
             title = UI_STRING("Learn Spelling", "Learn Spelling context menu item");
             action = @selector(_learnSpellingFromMenu:);
@@ -272,29 +278,55 @@ static NSString *localizedMenuTitleFromAppKit(NSString *key, NSString *comment)
 {
     NSMutableArray *menuItems = [NSMutableArray array];
     NSMenuItem *item;
-    WebHTMLView *HTMLView = (WebHTMLView *)[[[element objectForKey:WebElementFrameKey] frameView] documentView];
+    WebFrame *webFrame = [element objectForKey:WebElementFrameKey];
+    WebHTMLView *HTMLView = (WebHTMLView *)[[webFrame frameView] documentView];
     ASSERT([HTMLView isKindOfClass:[WebHTMLView class]]);
     BOOL inPasswordField = [HTMLView _isSelectionInPasswordField];
 
-    // Add spelling-related context menu items.
-    if ([HTMLView _isSelectionMisspelled] && !inPasswordField) {
-        NSArray *guesses = [HTMLView _guessesForMisspelledSelection];
-        unsigned count = [guesses count];
-        if (count > 0) {
-            NSEnumerator *enumerator = [guesses objectEnumerator];
-            NSString *guess;
-            while ((guess = [enumerator nextObject]) != nil) {
-                item = [self menuItemWithTag:WebMenuItemTagSpellingGuess target:nil representedObject:element];
-                [item setTitle:guess];
-                [menuItems addObject:item];
+    if (!inPasswordField) {
+        // Consider adding spelling-related or grammar-related context menu items (never both)
+        if ([HTMLView _isSelectionMisspelled]) {
+            NSArray *guesses = [HTMLView _guessesForMisspelledSelection];
+            unsigned count = [guesses count];
+            if (count > 0) {
+                NSEnumerator *enumerator = [guesses objectEnumerator];
+                NSString *guess;
+                while ((guess = [enumerator nextObject]) != nil) {
+                    item = [self menuItemWithTag:WebMenuItemTagSpellingGuess target:nil representedObject:element];
+                    [item setTitle:guess];
+                    [menuItems addObject:item];
+                }
+            } else {
+                [menuItems addObject:[self menuItemWithTag:WebMenuItemTagNoGuessesFound target:nil representedObject:element]];
             }
-        } else {
-            [menuItems addObject:[self menuItemWithTag:WebMenuItemTagNoGuessesFound target:nil representedObject:element]];
+            [menuItems addObject:[NSMenuItem separatorItem]];
+            [menuItems addObject:[self menuItemWithTag:WebMenuItemTagIgnoreSpelling target:nil representedObject:element]];
+            [menuItems addObject:[self menuItemWithTag:WebMenuItemTagLearnSpelling target:nil representedObject:element]];
+            [menuItems addObject:[NSMenuItem separatorItem]];
+        } else if ([[webFrame webView] isGrammarCheckingEnabled] && [HTMLView _isSelectionUngrammatical]) {
+#ifdef BUILDING_ON_TIGER
+            ASSERT_NOT_REACHED();
+#else
+            // These strings are being converted from NSString to WebCore::String and back again, which
+            // would offend our sensibilities something awful except that we're moving all the context menu code
+            // to WebCore soon where we won't have to do this.
+            Vector<WebCore::String> guesses = core(webFrame)->guessesForUngrammaticalSelection();
+            size_t count = guesses.size();
+            if (count > 0) {
+                for (unsigned i = 0; i < count; ++i) {
+                    NSString *string = guesses.at(i);
+                    item = [self menuItemWithTag:WebMenuItemTagSpellingGuess target:nil representedObject:element];
+                    [item setTitle:string];
+                    [menuItems addObject:item];
+                }
+            } else {
+                [menuItems addObject:[self menuItemWithTag:WebMenuItemTagNoGuessesFound target:nil representedObject:element]];
+            }
+            [menuItems addObject:[NSMenuItem separatorItem]];
+            [menuItems addObject:[self menuItemWithTag:WebMenuItemTagIgnoreGrammar target:nil representedObject:element]];
+            [menuItems addObject:[NSMenuItem separatorItem]];
+#endif
         }
-        [menuItems addObject:[NSMenuItem separatorItem]];
-        [menuItems addObject:[self menuItemWithTag:WebMenuItemTagIgnoreSpelling target:nil representedObject:element]];
-        [menuItems addObject:[self menuItemWithTag:WebMenuItemTagLearnSpelling target:nil representedObject:element]];
-        [menuItems addObject:[NSMenuItem separatorItem]];
     }
 
     NSURL *linkURL = [element objectForKey:WebElementLinkURLKey];
index 734f079eb6bc2d2590339d2fe87adbb843f2decf..7bc717eea9185b311a6853745dce54e8b33f5aa0 100644 (file)
Binary files a/WebKit/English.lproj/Localizable.strings and b/WebKit/English.lproj/Localizable.strings differ
index 83e7dfc6cd54ddf2478d6b70f18bddab8b211444..70721131a0f35d80c9e6f9cc329eb84f4e9ea4c7 100644 (file)
                0867D690FE84028FC02AAC07 /* Project object */ = {
                        isa = PBXProject;
                        buildConfigurationList = 149C283208902B0F008A9EFC /* Build configuration list for PBXProject "WebKit" */;
+                       compatibilityVersion = "Xcode 2.4";
                        hasScannedForEncodings = 1;
                        knownRegions = (
                                English,
                        productRefGroup = 034768DFFF38A50411DB9C8B /* Products */;
                        projectDirPath = "";
                        projectRoot = "";
+                       shouldCheckCompatibility = 1;
                        targets = (
                                9398100A0824BF01008DF038 /* WebKit */,
                        );
index 09a3579ddf8e69b24e33001dae3509925b869d45..40340b88956f819b0d9a11ff29c0423d49c5bbc5 100644 (file)
@@ -1711,6 +1711,13 @@ static WebHTMLView *lastHitView = nil;
     return coreFrame->selectionController()->isInPasswordField();
 }
 
+- (BOOL)_isSelectionUngrammatical
+{
+    if (Frame* coreFrame = core([self _frame]))
+        return coreFrame->isSelectionUngrammatical();
+    return NO;
+}
+
 - (BOOL)_isSelectionMisspelled
 {
     if (Frame* coreFrame = core([self _frame]))
@@ -1738,6 +1745,12 @@ static WebHTMLView *lastHitView = nil;
     [[NSSpellChecker sharedSpellChecker] ignoreWord:[self selectedString] inSpellDocumentWithTag:[[self _webView] spellCheckerDocumentTag]];
 }
 
+- (void)_ignoreGrammarFromMenu:(id)sender
+{
+    // NSSpellChecker uses the same API for ignoring grammar as for ignoring spelling
+    [self _ignoreSpellingFromMenu:(id)sender];
+}
+
 - (void)_learnSpellingFromMenu:(id)sender
 {
     ASSERT([[self selectedString] length] != 0);
index bcfc9ac2d35fff507d55ddad21fb30e050b952b2..bb203a7f913d064d070e91d2782a9b820e1d1101 100644 (file)
@@ -90,6 +90,7 @@
 - (BOOL)_isEditable;
 
 - (BOOL)_isSelectionInPasswordField;
+- (BOOL)_isSelectionUngrammatical;
 - (BOOL)_isSelectionMisspelled;
 - (NSArray *)_guessesForMisspelledSelection;
 
index 26c0c8872d35709cf5919684218c19ab3baace93..eddfb3e301aee41fab70315fcc150efa8e9e0dd7 100644 (file)
@@ -31,6 +31,7 @@
 // FIXME: These should move to WebUIDelegate.h as part of the WebMenuItemTag enum there, when we're not in API freeze 
 enum { 
     WebMenuItemTagOpenLink = 1000,
+    WebMenuItemTagIgnoreGrammar,
 #ifndef BUILDING_ON_TIGER
     WebMenuItemTagSpellingAndGrammarMenu,
     WebMenuItemTagShowSpellingAndGrammar,