wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

backout changeset 3734bebc9bfb, because bad commit message and missed nit

Browse Source
This commit is contained in:
Tom Schuster 2013-09-13 11:41:47 -04:00
parent 4b1a1455ae
commit 0292702a68
8 changed files with 827 additions and 737 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
browser/base/content/tabbrowser.xml
View File

@ -2753,10 +2753,6 @@
onget="return this.mCurrentBrowser.currentURI;"
readonly="true"/>
<property name="finder"
onget="return this.mCurrentBrowser.finder"
readonly="true"/>
<property name="docShell"
onget="return this.mCurrentBrowser.docShell"
readonly="true"/>

6
browser/base/content/test/browser_zbug569342.js
View File

@ -41,11 +41,7 @@ function nextTest() {
testFindDisabled(url, nextTest);
} else {
// Make sure the find bar is re-enabled after disabled page is closed.
testFindEnabled("about:blank", function () {
EventUtils.synthesizeKey("VK_ESCAPE", { });
ok(gFindBar.hidden, "Find bar should now be hidden");
finish();
});
testFindEnabled("about:blank", finish);
}
}

10
toolkit/components/typeaheadfind/nsTypeAheadFind.cpp
View File

@ -919,17 +919,15 @@ nsTypeAheadFind::Find(const nsAString& aSearchString, bool aLinksOnly,
*aResult = FIND_NOTFOUND;
nsCOMPtr<nsIPresShell> presShell (GetPresShell());
if (!presShell) {
if (!presShell) {
nsCOMPtr<nsIDocShell> ds (do_QueryReferent(mDocShell));
NS_ENSURE_TRUE(ds, NS_ERROR_FAILURE);
presShell = ds->GetPresShell();
NS_ENSURE_TRUE(presShell, NS_ERROR_FAILURE);
mPresShell = do_GetWeakReference(presShell);
}
mPresShell = do_GetWeakReference(presShell);
}
nsCOMPtr<nsISelection> selection;
nsCOMPtr<nsISelectionController> selectionController =
nsCOMPtr<nsISelectionController> selectionController =
do_QueryReferent(mSelectionController);
if (!selectionController) {
GetSelection(presShell, getter_AddRefs(selectionController),

3
toolkit/content/tests/chrome/findbar_window.xul
View File

@ -300,8 +300,7 @@
var searchStr = "Link Test";
enterStringIntoFindField(searchStr);
ok(gBrowser.contentWindow.getSelection() == searchStr,
"testQuickFindLink: failed to find sample link");
ok(gFindBar._foundLink, "testQuickFindLink: failed to find sample link");
}
function testQuickFindText() {

26
toolkit/content/widgets/browser.xml
View File

@ -296,25 +296,11 @@
</body>
</method>
<field name="_finder">null</field>
<property name="finder" readonly="true">
<getter><![CDATA[
if (!this._finder) {
if (!this.docShell)
return null;
let Finder = Components.utils.import("resource://gre/modules/Finder.jsm", {}).Finder;
this._finder = new Finder(this.docShell);
}
return this._finder;
]]></getter>
</property>
<field name="_fastFind">null</field>
<property name="fastFind"
readonly="true">
<getter><![CDATA[
readonly="true">
<getter>
<![CDATA[
if (!this._fastFind) {
if (!("@mozilla.org/typeaheadfind;1" in Components.classes))
return null;
@ -331,12 +317,10 @@
this._fastFind.init(this.docShell);
}
return this._fastFind;
]]></getter>
]]>
</getter>
</property>
<field name="_lastSearchString">null</field>
<field name="_lastSearchHighlight">false</field>
<property name="webProgress"
readonly="true"
onget="return this.docShell.QueryInterface(Components.interfaces.nsIInterfaceRequestor).getInterface(Components.interfaces.nsIWebProgress);"/>

936
toolkit/content/widgets/findbar.xml
View File

File diff suppressed because it is too large Load Diff

578
toolkit/modules/Finder.jsm
View File

@ -1,578 +0,0 @@
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
this.EXPORTED_SYMBOLS = ["Finder"];
const Ci = Components.interfaces;
const Cc = Components.classes;
const Cu = Components.utils;
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
const Services = Cu.import("resource://gre/modules/Services.jsm").Services;
function Finder(docShell) {
this._fastFind = Cc["@mozilla.org/typeaheadfind;1"].createInstance(Ci.nsITypeAheadFind);
this._fastFind.init(docShell);
this._docShell = docShell;
this._document = docShell.getInterface(Ci.nsIDOMWindow).document;
this._listeners = [];
this._previousLink = null;
this._drewOutline = false;
this._searchString = null;
}
Finder.prototype = {
addResultListener: function (aListener) {
if (this._listeners.indexOf(aListener) === -1)
this._listeners.push(aListener);
},
removeResultListener: function (aListener) {
this._listeners = this._listeners.filter(l => l != aListener);
},
_notify: function (aResult, aFindBackwards, aLinksOnly) {
this._outlineLink(aLinksOnly);
let foundLink = this._fastFind.foundLink;
let linkURL = null;
if (aLinksOnly && foundLink) {
let docCharset = null;
let ownerDoc = foundLink.ownerDocument;
if (ownerDoc)
docCharset = ownerDoc.characterSet;
if (!this._textToSubURIService) {
this._textToSubURIService = Cc["@mozilla.org/intl/texttosuburi;1"]
.getService(Ci.nsITextToSubURI);
}
linkURL = this._textToSubURIService.unEscapeURIForUI(docCharset, foundLink.href);
}
for (let l of this._listeners) {
l.onFindResult(aResult, aFindBackwards, linkURL);
}
},
get searchString() {
return this._fastFind.searchString;
},
set caseSensitive(aSensitive) {
this._fastFind.caseSensitive = aSensitive;
},
fastFind: function (aSearchString, aLinksOnly) {
let result = this._fastFind.find(aSearchString, aLinksOnly);
this._notify(result, false, aLinksOnly);
},
findAgain: function (aFindBackwards, aLinksOnly) {
let result = this._fastFind.findAgain(aFindBackwards, aLinksOnly);
this._notify(result, aFindBackwards, aLinksOnly);
},
highlight: function (aHighlight, aWord) {
this._searchString = aWord;
this._highlight(aHighlight, aWord, null);
},
removeSelection: function() {
let fastFind = this._fastFind;
fastFind.collapseSelection();
fastFind.setSelectionModeAndRepaint(Ci.nsISelectionController.SELECTION_ON);
// We also drew our own outline, remove that as well.
if (this._previousLink && this._drewOutline) {
this._previousLink.style.outline = this._tmpOutline;
this._previousLink.style.outlineOffset = this._tmpOutlineOffset;
}
},
focusContent: function() {
let fastFind = this._fastFind;
try {
// Try to find the best possible match that should receive focus.
if (fastFind.foundLink) {
fastFind.foundLink.focus();
} else if (fastFind.foundEditable) {
fastFind.foundEditable.focus();
fastFind.collapseSelection();
} else {
this._getWindow().focus()
}
} catch (e) {}
},
keyPress: function (aEvent) {
let controller = this._getSelectionController(this._getWindow());
switch (aEvent.keyCode) {
case Ci.nsIDOMKeyEvent.DOM_VK_RETURN:
if (this._fastFind.foundLink) // Todo: Handle ctrl click.
this._fastFind.foundLink.click();
break;
case Ci.nsIDOMKeyEvent.DOM_VK_TAB:
if (aEvent.shiftKey)
this._document.commandDispatcher.rewindFocus();
else
this._document.commandDispatcher.advanceFocus();
break;
case Ci.nsIDOMKeyEvent.DOM_VK_PAGE_UP:
controller.scrollPage(false);
break;
case Ci.nsIDOMKeyEvent.DOM_VK_PAGE_DOWN:
controller.scrollPage(true);
break;
case Ci.nsIDOMKeyEvent.DOM_VK_UP:
controller.scrollLine(false);
break;
case Ci.nsIDOMKeyEvent.DOM_VK_DOWN:
controller.scrollLine(true);
break;
}
},
_getWindow: function () {
return this._docShell.QueryInterface(Ci.nsIInterfaceRequestor).getInterface(Ci.nsIDOMWindow);
},
_outlineLink: function (aLinksOnly) {
let foundLink = this._fastFind.foundLink;
if (foundLink == this._previousLink)
return;
if (this._previousLink && this._drewOutline) {
// restore original outline
this._previousLink.style.outline = this._tmpOutline;
this._previousLink.style.outlineOffset = this._tmpOutlineOffset;
}
this._drewOutline = (foundLink && aLinksOnly);
if (this._drewOutline) {
// Backup original outline
this._tmpOutline = foundLink.style.outline;
this._tmpOutlineOffset = foundLink.style.outlineOffset;
// Draw pseudo focus rect
// XXX Should we change the following style for FAYT pseudo focus?
// XXX Shouldn't we change default design if outline is visible
// already?
// Don't set the outline-color, we should always use initial value.
foundLink.style.outline = "1px dotted";
foundLink.style.outlineOffset = "0";
}
this._previousLink = foundLink;
},
_highlight: function (aHighlight, aWord, aWindow) {
let win = aWindow || this._getWindow();
let result = Ci.nsITypeAheadFind.FIND_NOTFOUND;
for (let i = 0; win.frames && i < win.frames.length; i++) {
if (this._highlight(aHighlight, aWord, win.frames[i]))
result = Ci.nsITypeAheadFind.FIND_FOUND;
}
let controller = this._getSelectionController(win);
let doc = win.document;
if (!controller || !doc || !doc.documentElement) {
// Without the selection controller,
// we are unable to (un)highlight any matches
this._notify(result)
return;
}
let body = (doc instanceof Ci.nsIDOMHTMLDocument && doc.body) ?
doc.body : doc.documentElement;
if (aHighlight) {
let searchRange = doc.createRange();
searchRange.selectNodeContents(body);
let startPt = searchRange.cloneRange();
startPt.collapse(true);
let endPt = searchRange.cloneRange();
endPt.collapse(false);
let retRange = null;
let finder = Cc["@mozilla.org/embedcomp/rangefind;1"]
.createInstance()
.QueryInterface(Ci.nsIFind);
finder.caseSensitive = this._fastFind.caseSensitive;
while ((retRange = finder.Find(aWord, searchRange,
startPt, endPt))) {
this._highlightRange(retRange, controller);
startPt = retRange.cloneRange();
startPt.collapse(false);
result = Ci.nsITypeAheadFind.FIND_FOUND;
}
} else {
// First, attempt to remove highlighting from main document
let sel = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
sel.removeAllRanges();
// Next, check our editor cache, for editors belonging to this
// document
if (this._editors) {
for (let x = this._editors.length - 1; x >= 0; --x) {
if (this._editors[x].document == doc) {
sel = this._editors[x].selectionController
.getSelection(Ci.nsISelectionController.SELECTION_FIND);
sel.removeAllRanges();
// We don't need to listen to this editor any more
this._unhookListenersAtIndex(x);
}
}
}
return true;
}
this._notify(result);
},
_highlightRange: function(aRange, aController) {
let node = aRange.startContainer;
let controller = aController;
let editableNode = this._getEditableNode(node);
if (editableNode)
controller = editableNode.editor.selectionController;
let findSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
findSelection.addRange(aRange);
if (editableNode) {
// Highlighting added, so cache this editor, and hook up listeners
// to ensure we deal properly with edits within the highlighting
if (!this._editors) {
this._editors = [];
this._stateListeners = [];
}
let existingIndex = this._editors.indexOf(editableNode.editor);
if (existingIndex == -1) {
let x = this._editors.length;
this._editors[x] = editableNode.editor;
this._stateListeners[x] = this._createStateListener();
this._editors[x].addEditActionListener(this);
this._editors[x].addDocumentStateListener(this._stateListeners[x]);
}
}
},
_getSelectionController: function(aWindow) {
// display: none iframes don't have a selection controller, see bug 493658
if (!aWindow.innerWidth || !aWindow.innerHeight)
return null;
// Yuck. See bug 138068.
let docShell = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsIWebNavigation)
.QueryInterface(Ci.nsIDocShell);
let controller = docShell.QueryInterface(Ci.nsIInterfaceRequestor)
.getInterface(Ci.nsISelectionDisplay)
.QueryInterface(Ci.nsISelectionController);
return controller;
},
_getEditableNode: function (aNode) {
while (aNode) {
if (aNode instanceof Ci.nsIDOMNSEditableElement)
return aNode.editor ? aNode : null;
aNode = aNode.parentNode;
}
return null;
},
/*
* Helper method to unhook listeners, remove cached editors
* and keep the relevant arrays in sync
*
* @param aIndex the index into the array of editors/state listeners
* we wish to remove
*/
_unhookListenersAtIndex: function (aIndex) {
this._editors[aIndex].removeEditActionListener(this);
this._editors[aIndex]
.removeDocumentStateListener(this._stateListeners[aIndex]);
this._editors.splice(aIndex, 1);
this._stateListeners.splice(aIndex, 1);
if (!this._editors.length) {
delete this._editors;
delete this._stateListeners;
}
},
/*
* Remove ourselves as an nsIEditActionListener and
* nsIDocumentStateListener from a given cached editor
*
* @param aEditor the editor we no longer wish to listen to
*/
_removeEditorListeners: function (aEditor) {
// aEditor is an editor that we listen to, so therefore must be
// cached. Find the index of this editor
let idx = this._editors.indexOf(aEditor);
if (idx == -1)
return;
// Now unhook ourselves, and remove our cached copy
this._unhookListenersAtIndex(idx);
},
/*
* nsIEditActionListener logic follows
*
* We implement this interface to allow us to catch the case where
* the findbar found a match in a HTML <input> or <textarea>. If the
* user adjusts the text in some way, it will no longer match, so we
* want to remove the highlight, rather than have it expand/contract
* when letters are added or removed.
*/
/*
* Helper method used to check whether a selection intersects with
* some highlighting
*
* @param aSelectionRange the range from the selection to check
* @param aFindRange the highlighted range to check against
* @returns true if they intersect, false otherwise
*/
_checkOverlap: function (aSelectionRange, aFindRange) {
// The ranges overlap if one of the following is true:
// 1) At least one of the endpoints of the deleted selection
// is in the find selection
// 2) At least one of the endpoints of the find selection
// is in the deleted selection
if (aFindRange.isPointInRange(aSelectionRange.startContainer,
aSelectionRange.startOffset))
return true;
if (aFindRange.isPointInRange(aSelectionRange.endContainer,
aSelectionRange.endOffset))
return true;
if (aSelectionRange.isPointInRange(aFindRange.startContainer,
aFindRange.startOffset))
return true;
if (aSelectionRange.isPointInRange(aFindRange.endContainer,
aFindRange.endOffset))
return true;
return false;
},
/*
* Helper method to determine if an edit occurred within a highlight
*
* @param aSelection the selection we wish to check
* @param aNode the node we want to check is contained in aSelection
* @param aOffset the offset into aNode that we want to check
* @returns the range containing (aNode, aOffset) or null if no ranges
* in the selection contain it
*/
_findRange: function (aSelection, aNode, aOffset) {
let rangeCount = aSelection.rangeCount;
let rangeidx = 0;
let foundContainingRange = false;
let range = null;
// Check to see if this node is inside one of the selection's ranges
while (!foundContainingRange && rangeidx < rangeCount) {
range = aSelection.getRangeAt(rangeidx);
if (range.isPointInRange(aNode, aOffset)) {
foundContainingRange = true;
break;
}
rangeidx++;
}
if (foundContainingRange)
return range;
return null;
},
// Start of nsIEditActionListener implementations
WillDeleteText: function (aTextNode, aOffset, aLength) {
let editor = this._getEditableNode(aTextNode).editor;
let controller = editor.selectionController;
let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
let range = this._findRange(fSelection, aTextNode, aOffset);
if (range) {
// Don't remove the highlighting if the deleted text is at the
// end of the range
if (aTextNode != range.endContainer ||
aOffset != range.endOffset) {
// Text within the highlight is being removed - the text can
// no longer be a match, so remove the highlighting
fSelection.removeRange(range);
if (fSelection.rangeCount == 0)
this._removeEditorListeners(editor);
}
}
},
DidInsertText: function (aTextNode, aOffset, aString) {
let editor = this._getEditableNode(aTextNode).editor;
let controller = editor.selectionController;
let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
let range = this._findRange(fSelection, aTextNode, aOffset);
if (range) {
// If the text was inserted before the highlight
// adjust the highlight's bounds accordingly
if (aTextNode == range.startContainer &&
aOffset == range.startOffset) {
range.setStart(range.startContainer,
range.startOffset+aString.length);
} else if (aTextNode != range.endContainer ||
aOffset != range.endOffset) {
// The edit occurred within the highlight - any addition of text
// will result in the text no longer being a match,
// so remove the highlighting
fSelection.removeRange(range);
if (fSelection.rangeCount == 0)
this._removeEditorListeners(editor);
}
}
},
WillDeleteSelection: function (aSelection) {
let editor = this._getEditableNode(aSelection.getRangeAt(0)
.startContainer).editor;
let controller = editor.selectionController;
let fSelection = controller.getSelection(Ci.nsISelectionController.SELECTION_FIND);
let selectionIndex = 0;
let findSelectionIndex = 0;
let shouldDelete = {};
let numberOfDeletedSelections = 0;
let numberOfMatches = fSelection.rangeCount;
// We need to test if any ranges in the deleted selection (aSelection)
// are in any of the ranges of the find selection
// Usually both selections will only contain one range, however
// either may contain more than one.
for (let fIndex = 0; fIndex < numberOfMatches; fIndex++) {
shouldDelete[fIndex] = false;
let fRange = fSelection.getRangeAt(fIndex);
for (let index = 0; index < aSelection.rangeCount; index++) {
if (shouldDelete[fIndex])
continue;
let selRange = aSelection.getRangeAt(index);
let doesOverlap = this._checkOverlap(selRange, fRange);
if (doesOverlap) {
shouldDelete[fIndex] = true;
numberOfDeletedSelections++;
}
}
}
// OK, so now we know what matches (if any) are in the selection
// that is being deleted. Time to remove them.
if (numberOfDeletedSelections == 0)
return;
for (let i = numberOfMatches - 1; i >= 0; i--) {
if (shouldDelete[i])
fSelection.removeRange(fSelection.getRangeAt(i));
}
// Remove listeners if no more highlights left
if (fSelection.rangeCount == 0)
this._removeEditorListeners(editor);
},
/*
* nsIDocumentStateListener logic follows
*
* When attaching nsIEditActionListeners, there are no guarantees
* as to whether the findbar or the documents in the browser will get
* destructed first. This leads to the potential to either leak, or to
* hold on to a reference an editable element's editor for too long,
* preventing it from being destructed.
*
* However, when an editor's owning node is being destroyed, the editor
* sends out a DocumentWillBeDestroyed notification. We can use this to
* clean up our references to the object, to allow it to be destroyed in a
* timely fashion.
*/
/*
* Unhook ourselves when one of our state listeners has been called.
* This can happen in 4 cases:
* 1) The document the editor belongs to is navigated away from, and
* the document is not being cached
*
* 2) The document the editor belongs to is expired from the cache
*
* 3) The tab containing the owning document is closed
*
* 4) The <input> or <textarea> that owns the editor is explicitly
* removed from the DOM
*
* @param the listener that was invoked
*/
_onEditorDestruction: function (aListener) {
// First find the index of the editor the given listener listens to.
// The listeners and editors arrays must always be in sync.
// The listener will be in our array of cached listeners, as this
// method could not have been called otherwise.
let idx = 0;
while (this._stateListeners[idx] != aListener)
idx++;
// Unhook both listeners
this._unhookListenersAtIndex(idx);
},
/*
* Creates a unique document state listener for an editor.
*
* It is not possible to simply have the findbar implement the
* listener interface itself, as it wouldn't have sufficient information
* to work out which editor was being destroyed. Therefore, we create new
* listeners on the fly, and cache them in sync with the editors they
* listen to.
*/
_createStateListener: function () {
return {
findbar: this,
QueryInterface: function(aIID) {
if (aIID.equals(Ci.nsIDocumentStateListener) ||
aIID.equals(Ci.nsISupports))
return this;
throw Components.results.NS_ERROR_NO_INTERFACE;
},
NotifyDocumentWillBeDestroyed: function() {
this.findbar._onEditorDestruction(this);
},
// Unimplemented
notifyDocumentCreated: function() {},
notifyDocumentStateChanged: function(aDirty) {}
};
}
};

1
toolkit/modules/moz.build
View File

@ -11,7 +11,6 @@ EXTRA_JS_MODULES += [
'Deprecated.jsm',
'Dict.jsm',
'FileUtils.jsm',
'Finder.jsm',
'Geometry.jsm',
'Http.jsm',
'InlineSpellChecker.jsm',