Attachment #73847 for bug #114044

View | Details | Raw Unified | Return to bug 114044
Collapse All | Expand All

Lines 31-37 Link Here

(-)extensions/typeaheadfind/Makefile.in (-1 / +1 lines)
31		31
32	include $(DEPTH)/config/autoconf.mk	32	include $(DEPTH)/config/autoconf.mk
33		33
34	MODULE = typeaheadfind	34	MODULE = typeaheadfindsea
35	DIRS = public src resources	35	DIRS = public src resources
36		36
37	include $(topsrcdir)/config/rules.mk	37	include $(topsrcdir)/config/rules.mk

Lines 31-41 Link Here

(-)extensions/typeaheadfind/public/Makefile.in (-3 / +3 lines)
31		31
32	include $(DEPTH)/config/autoconf.mk	32	include $(DEPTH)/config/autoconf.mk
33		33
34	MODULE=typeaheadfind	34	MODULE=typeaheadfindsea
35	XPIDL_MODULE=typeaheadfind	35	XPIDL_MODULE=typeaheadfindsea
36	GRE_MODULE = 1	36	GRE_MODULE = 1
37		37
38	XPIDLSRCS= ./nsITypeAheadFind.idl \	38	XPIDLSRCS= ./nsITypeAheadFindSea.idl \
39	$(NULL)	39	$(NULL)
40		40
41		41




/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: NPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is 
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * Original Author: Aaron Leventhal (aaronl@netscape.com)
 * Contributors:    
 *
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the NPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the NPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsISupports.idl"
#include "domstubs.idl"
#include "nsISupportsPrimitives.idl"

%{ C++
  #include "nsIDOMEvent.h"

  #define NS_TYPEAHEADFIND_CID \
    {0x46590685, 0xbc00, 0x4aac, {0xab, 0xed, 0x2c, 0x10, 0xa5, 0xb9, 0x45, 0xa4}}

  #define NS_TYPEAHEADFIND_CONTRACTID "@mozilla.org/typeaheadfind;1"
%}

interface nsIDOMEvent;

[scriptable, uuid(AD1C62CC-72F4-4c5b-BE78-503854F9E0D8)]
interface nsITypeAheadFind : nsISupports
{
  /** Is type ahead find mode currently on? */
  readonly attribute boolean isActive;

  /** Manually start type ahead find mode */
  void startNewFind(in nsIDOMWindow aWindow, in boolean aLinksOnly);

  /** Manually cancel type ahead find mode */
  void cancelFind();

  /**
    * Will find as you type start automatically if the user
    * types with the focus on page content other than a textfield or select?
    * If autostart is off, the startNewFind() method can be used to enact
    * type ahead find, as well as cmd_findTypeLinks or cmd_findTypeText.
    */
  void setAutoStart(in nsIDOMWindow aWindow, in boolean aIsAutoStartOn);
  boolean getAutoStart(in nsIDOMWindow aWindow);  

  /**
    * Find next recurrence if typeaheadfind was the last used find, 
    * as opposed to regular find. Returns false in nsISupportsPRBool if we
    * don't handle the request.
    */
  void findNext(in boolean aReverse, in nsISupportsInterfacePointer aCallerWindowSupports);

  /*
   * Go back and remove one character from find string
   * Returns true if backspace used
   */
  boolean backOneChar();
};





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: NPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is 
 * Netscape Communications Corporation.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 * Original Author: Aaron Leventhal (aaronl@netscape.com)
 * Contributors:    
 *
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the NPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the NPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#include "nsISupports.idl"
#include "domstubs.idl"
#include "nsISupportsPrimitives.idl"

%{ C++
  #include "nsIDOMEvent.h"

  #define NS_TYPEAHEADFINDSEA_CID \
    {0x46590685, 0xbc00, 0x4aac, {0xab, 0xed, 0x2c, 0x10, 0xa5, 0xb9, 0x45, 0xa4}}

  #define NS_TYPEAHEADFINDSEA_CONTRACTID "@mozilla.org/typeaheadfindsea;1"
%}

interface nsIDOMEvent;

[scriptable, uuid(AD1C62CC-72F4-4c5b-BE78-503854F9E0D8)]
interface nsITypeAheadFindSea : nsISupports
{
  /** Is type ahead find mode currently on? */
  readonly attribute boolean isActive;

  /** Manually start type ahead find mode */
  void startNewFind(in nsIDOMWindow aWindow, in boolean aLinksOnly);

  /** Manually cancel type ahead find mode */
  void cancelFind();

  /**
    * Will find as you type start automatically if the user
    * types with the focus on page content other than a textfield or select?
    * If autostart is off, the startNewFind() method can be used to enact
    * type ahead find, as well as cmd_findTypeLinks or cmd_findTypeText.
    */
  void setAutoStart(in nsIDOMWindow aWindow, in boolean aIsAutoStartOn);
  boolean getAutoStart(in nsIDOMWindow aWindow);  

  /**
    * Find next recurrence if typeaheadfindsea was the last used find, 
    * as opposed to regular find. Returns false in nsISupportsPRBool if we
    * don't handle the request.
    */
  void findNext(in boolean aReverse, in nsISupportsInterfacePointer aCallerWindowSupports);

  /*
   * Go back and remove one character from find string
   * Returns true if backspace used
   */
  boolean backOneChar();
};


Lines 36-42 Link Here

(-)extensions/typeaheadfind/resources/content/prefs/typeaheadfind.js (-4 / +4 lines)
36	*	36	*
37	* *** END LICENSE BLOCK *** */	37	* *** END LICENSE BLOCK *** */
38		38
39	pref("accessibility.typeaheadfind", true);	39	pref("accessibility.typeaheadfindsea", true);
40	pref("accessibility.typeaheadfind.linksonly", true);	40	pref("accessibility.typeaheadfindsea.linksonly", true);
41	pref("accessibility.typeaheadfind.startlinksonly", false);	41	pref("accessibility.typeaheadfindsea.startlinksonly", false);
42	pref("accessibility.typeaheadfind.timeout", 5000);	42	pref("accessibility.typeaheadfindsea.timeout", 5000);

Lines 1-5 Link Here

(-)extensions/typeaheadfind/resources/jar.mn (-1 / +1 lines)
1	en-US.jar:	1	en-US.jar:
2	locale/en-US/global/typeaheadfind.properties (locale/en-US/typeaheadfind.properties)	2	locale/en-US/global/typeaheadfindsea.properties (locale/en-US/typeaheadfindsea.properties)
3		3
4	toolkit.jar:	4	toolkit.jar:
5	content/global/notfound.wav (content/notfound.wav)	5	content/global/notfound.wav (content/notfound.wav)




openparen     = (
closeparen    = )
textfound     = Text found: "
textnotfound  = Text not found: "
linkfound     = Link found: "
linknotfound  = Link not found: "
closequote    = "
stopfind      = Find stopped.
starttextfind = Starting -- find text as you type
startlinkfind = Starting -- find links as you type
repeated      = repeated
nextmatch     = - next match
prevmatch     = - previous match




openparen     = (
closeparen    = )
textfound     = Text found: "
textnotfound  = Text not found: "
linkfound     = Link found: "
linknotfound  = Link not found: "
closequote    = "
stopfind      = Find stopped.
starttextfind = Starting -- find text as you type
startlinkfind = Starting -- find links as you type
repeated      = repeated
nextmatch     = - next match
prevmatch     = - previous match





include $(DEPTH)/config/autoconf.mk

MODULE = typeaheadfindsea
LIBRARY_NAME = typeaheadfindsea
ifneq ($(OS_ARCH),WINNT)
SHORT_LIBNAME = typaheadsea
endif
GRE_MODULE	= 1

PACKAGE_FILE = typeaheadfindsea.pkg

REQUIRES	= appcomps \
		  embedcomponents \


EXPORT_LIBRARY = 1
IS_COMPONENT = 1
MODULE_NAME	= nsTypeAheadFindSea

CPPSRCS =   \
  nsTypeAheadFind.cpp	   \




////////////////////////////////////////////////////////////////////////


NS_INTERFACE_MAP_BEGIN(nsTypeAheadFindSea)
  NS_INTERFACE_MAP_ENTRY(nsITypeAheadFindSea)
  NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
  NS_INTERFACE_MAP_ENTRY(nsITimerCallback)
  NS_INTERFACE_MAP_ENTRY(nsIScrollPositionListener)

  NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsIDOMEventListener, nsIDOMKeyListener)
NS_INTERFACE_MAP_END

NS_IMPL_ADDREF(nsTypeAheadFindSea)
NS_IMPL_RELEASE(nsTypeAheadFindSea)

static NS_DEFINE_IID(kRangeCID, NS_RANGE_CID);
static NS_DEFINE_CID(kStringBundleServiceCID,  NS_STRINGBUNDLESERVICE_CID);


#define NS_FIND_CONTRACTID "@mozilla.org/embedcomp/rangefind;1"

nsTypeAheadFindSea* nsTypeAheadFindSea::sInstance = nsnull;
PRInt32 nsTypeAheadFindSea::sAccelKey = -1;  // magic value of -1 when unitialized


nsTypeAheadFindSea::nsTypeAheadFindSea():
  mIsFindAllowedInWindow(PR_FALSE), mAutoStartPref(PR_FALSE),
  mLinksOnlyPref(PR_FALSE), mStartLinksOnlyPref(PR_FALSE),
  mLinksOnly(PR_FALSE), mIsTypeAheadOn(PR_FALSE), mCaretBrowsingOn(PR_FALSE),

  static PRInt32 gInstanceCount;
  ++gInstanceCount;
  NS_ASSERTION(gInstanceCount == 1,
    "There should be only 1 instance of nsTypeAheadFindSea!");
#endif
}


nsTypeAheadFindSea::~nsTypeAheadFindSea()
{
  RemoveDocListeners();
  mTimer = nsnull;

  nsCOMPtr<nsIPrefBranchInternal> prefInternal(do_GetService(NS_PREFSERVICE_CONTRACTID));
  if (prefInternal) {
    prefInternal->RemoveObserver("accessibility.typeaheadfindsea", this);
    prefInternal->RemoveObserver("accessibility.browsewithcaret", this);
  }
}

nsresult
nsTypeAheadFindSea::Init()
{
  nsresult rv = NS_NewISupportsArray(getter_AddRefs(mManualFindWindows));
  NS_ENSURE_SUCCESS(rv, rv);

  }

  // ----------- Listen to prefs ------------------
  rv = prefInternal->AddObserver("accessibility.typeaheadfindsea", this, PR_FALSE);
  NS_ENSURE_SUCCESS(rv, rv);

  rv = prefInternal->AddObserver("accessibility.browsewithcaret", this, PR_FALSE);

  return rv;
}

nsTypeAheadFindSea *
nsTypeAheadFindSea::GetInstance()
{
  if (!sInstance) {
    sInstance = new nsTypeAheadFindSea();
    if (!sInstance)
      return nsnull;




void
nsTypeAheadFindSea::ReleaseInstance()
{
  NS_IF_RELEASE(sInstance);
}


void 
nsTypeAheadFindSea::Shutdown()
{
  // Application shutdown 
  mTimer = nsnull;

// ------- Pref Callbacks (2) ---------------

nsresult
nsTypeAheadFindSea::PrefsReset()
{
  nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID));
  NS_ENSURE_TRUE(prefBranch, NS_ERROR_FAILURE);

  PRBool wasTypeAheadOn = mIsTypeAheadOn;

  prefBranch->GetBoolPref("accessibility.typeaheadfindsea", &mIsTypeAheadOn);

  if (mIsTypeAheadOn != wasTypeAheadOn) {
    if (!mIsTypeAheadOn) {

        do_GetService(kStringBundleServiceCID);

      if (stringBundleService)
        stringBundleService->CreateBundle(TYPEAHEADFINDSEA_BUNDLE_URL,
                                          getter_AddRefs(mStringBundle));

      // Observe find again commands. We'll handle them if we were the last find

  }

  PRBool oldAutoStartPref = mAutoStartPref;
  prefBranch->GetBoolPref("accessibility.typeaheadfindsea.autostart",
                           &mAutoStartPref);
  if (mAutoStartPref != oldAutoStartPref) {
    ResetGlobalAutoStart(mAutoStartPref);
  }
 
  prefBranch->GetBoolPref("accessibility.typeaheadfindsea.linksonly",
                          &mLinksOnlyPref);

  prefBranch->GetBoolPref("accessibility.typeaheadfindsea.startlinksonly",
                          &mStartLinksOnlyPref);

  PRBool isSoundEnabled = PR_TRUE;
  prefBranch->GetBoolPref("accessibility.typeaheadfindsea.enablesound",
                           &isSoundEnabled);
  nsXPIDLCString soundStr;
  if (isSoundEnabled) {
    prefBranch->GetCharPref("accessibility.typeaheadfindsea.soundURL",
                             getter_Copies(soundStr));
  }
  mNotFoundSoundURL = soundStr;

  PRBool isTimeoutEnabled;
  prefBranch->GetBoolPref("accessibility.typeaheadfindsea.enabletimeout",
                          &isTimeoutEnabled);
  PRInt32 timeoutLength = 0;
  if (isTimeoutEnabled) {
    prefBranch->GetIntPref("accessibility.typeaheadfindsea.timeout",
                           &timeoutLength);
  }
  mTimeoutLength = timeoutLength;

// ------- nsITimer Methods (1) ---------------

NS_IMETHODIMP
nsTypeAheadFindSea::Notify(nsITimer *timer)
{
  CancelFind();
  return NS_OK;

// ----------- nsIObserver Methods (1) -------------------

NS_IMETHODIMP
nsTypeAheadFindSea::Observe(nsISupports *aSubject, const char *aTopic,
                         const PRUnichar *aData)
{
  PRBool isOpening;



nsresult
nsTypeAheadFindSea::UseInWindow(nsIDOMWindow *aDOMWin)
{
  NS_ENSURE_ARG_POINTER(aDOMWin);


// ------- nsIDOMEventListener Methods (1) ---------------

NS_IMETHODIMP
nsTypeAheadFindSea::HandleEvent(nsIDOMEvent* aEvent)
{
  nsAutoString eventType;
  aEvent->GetType(eventType);

// ------- nsIDOMKeyListener Methods (3) ---------------

NS_IMETHODIMP
nsTypeAheadFindSea::KeyDown(nsIDOMEvent* aEvent)
{
  return NS_OK;
}


NS_IMETHODIMP
nsTypeAheadFindSea::KeyUp(nsIDOMEvent* aEvent)
{
  return NS_OK;
}


NS_IMETHODIMP
nsTypeAheadFindSea::KeyPress(nsIDOMEvent* aEvent)
{
  if (!mIsTypeAheadOn || mIsMenuBarActive || mIsMenuPopupActive) {
    return NS_OK;



NS_IMETHODIMP
nsTypeAheadFindSea::BackOneChar(PRBool *aIsBackspaceUsed)
{
  if (!mFocusedDocSelection) {
    *aIsBackspaceUsed = PR_FALSE;



nsresult
nsTypeAheadFindSea::HandleChar(PRUnichar aChar)
{
  // Add a printable char to mTypeAheadBuffer, then search for buffer contents




void
nsTypeAheadFindSea::SaveFind()
{
  // Store find string for find-next
  mFindNextBuffer = mTypeAheadBuffer;

    mFindService->SetSearchString(mFindNextBuffer);
  }

  // --- If accessibility.typeaheadfindsea.timeout is set,
  //     cancel find after specified # milliseconds ---
  StartTimeout();
}


void
nsTypeAheadFindSea::PlayNotFoundSound()
{
  if (mNotFoundSoundURL.IsEmpty())    // no sound
    return;



NS_IMETHODIMP
nsTypeAheadFindSea::HandleText(nsIDOMEvent* aTextEvent)
{
  // This is called multiple times in the middle of an 
  // IME composition



NS_IMETHODIMP
nsTypeAheadFindSea::HandleStartComposition(nsIDOMEvent* aCompositionEvent)
{
  // This is called once at the start of an IME composition




NS_IMETHODIMP
nsTypeAheadFindSea::HandleEndComposition(nsIDOMEvent* aCompositionEvent)
{
  // This is called once at the end of an IME composition




NS_IMETHODIMP
nsTypeAheadFindSea::HandleQueryComposition(nsIDOMEvent* aCompositionEvent)
{
  return NS_OK;
}


NS_IMETHODIMP
nsTypeAheadFindSea::HandleQueryReconversion(nsIDOMEvent* aCompositionEvent)
{
  return NS_OK;
}


nsresult
nsTypeAheadFindSea::FindItNow(nsIPresShell *aPresShell,
                           PRBool aIsRepeatingSameChar, PRBool aIsLinksOnly,
                           PRBool aIsFirstVisiblePreferred)
{


  nsCOMPtr<nsISupports> startingContainer = presContext->GetContainer();
  nsCOMPtr<nsIDocShellTreeItem> treeItem(do_QueryInterface(startingContainer));
  NS_ASSERTION(treeItem, "Bug 175321 Crashes with Type Ahead Find [@ nsTypeAheadFindSea::FindItNow]");
  if (!treeItem) {
    return NS_ERROR_FAILURE;
  }



nsresult
nsTypeAheadFindSea::GetSearchContainers(nsISupports *aContainer,
                                     PRBool aIsRepeatingSameChar,
                                     PRBool aIsFirstVisiblePreferred,
                                     PRBool aCanUseDocSelection,



void
nsTypeAheadFindSea::RangeStartsInsideLink(nsIDOMRange *aRange,
                                       nsIPresShell *aPresShell,
                                       PRBool *aIsInsideLink,
                                       PRBool *aIsStartingLink)



NS_IMETHODIMP
nsTypeAheadFindSea::ScrollPositionWillChange(nsIScrollableView *aView,
                                          nscoord aX, nscoord aY)
{
  return NS_OK;



NS_IMETHODIMP
nsTypeAheadFindSea::ScrollPositionDidChange(nsIScrollableView *aScrollableView,
                                         nscoord aX, nscoord aY)
{
  if (!mIsFindingText)



NS_IMETHODIMP
nsTypeAheadFindSea::NotifySelectionChanged(nsIDOMDocument *aDoc,
                                        nsISelection *aSel, short aReason)
{
  if (!mIsFindingText) {

}


// ---------------- nsITypeAheadFindSea --------------------

NS_IMETHODIMP
nsTypeAheadFindSea::FindNext(PRBool aFindBackwards, nsISupportsInterfacePointer *aCallerWindowSupports)
{
  NS_ENSURE_TRUE(aCallerWindowSupports, NS_ERROR_FAILURE);


    return NS_OK;
  }

  // Compare the top level content pres shell of typeaheadfindsea
  // with the top level content pres shell window where find next is happening
  // If they're different, exit so that webbrowswerfind can handle FindNext()


  NS_ENSURE_TRUE(callerPresShell, NS_OK);

  if (callerPresShell != typeAheadPresShell) {
    // This means typeaheadfindsea is active in a different window or doc
    // So it's not appropriate to find next for the current window
    mFindNextBuffer.Truncate();
    return NS_OK;

    webBrowserFind->GetSearchString(getter_Copies(webBrowserFindString));
    if (!webBrowserFindString.Equals(mFindNextBuffer)) {
      // If they're not equal, then the find dialog was used last,
      // not typeaheadfindsea. Typeaheadfind applies to the last find,
      // so we should let nsIWebBrowserFind::FindNext() do it.
      mFindNextBuffer.Truncate();
      return NS_OK;



NS_IMETHODIMP
nsTypeAheadFindSea::GetIsActive(PRBool *aIsActive)
{
  *aIsActive = mLinksOnlyManuallySet || !mTypeAheadBuffer.IsEmpty();


 */

NS_IMETHODIMP
nsTypeAheadFindSea::StartNewFind(nsIDOMWindow *aWindow, PRBool aLinksOnly)
{
  if (!mFind || !mIsTypeAheadOn || !aWindow)
    return NS_ERROR_FAILURE;  // Type Ahead Find not correctly initialized

}

void
nsTypeAheadFindSea::ResetGlobalAutoStart(PRBool aAutoStart)
{
  // Enumerate through the current top level windows
  // and either attach or remove window listeners



NS_IMETHODIMP
nsTypeAheadFindSea::SetAutoStart(nsIDOMWindow *aDOMWin, PRBool aAutoStartOn)
{
  if (!aDOMWin) {
    return NS_ERROR_FAILURE;



NS_IMETHODIMP
nsTypeAheadFindSea::GetAutoStart(nsIDOMWindow *aDOMWin, PRBool *aIsAutoStartOn)
{
  *aIsAutoStartOn = PR_FALSE;




NS_IMETHODIMP
nsTypeAheadFindSea::CancelFind()
{
  // Stop current find if:
  //   1. Escape pressed

// ------- Helper Methods ---------------

void 
nsTypeAheadFindSea::GetTopContentPresShell(nsIDocShellTreeItem *aDocShellTreeItem, 
                                        nsIPresShell **aPresShell)
{
  *aPresShell = nsnull;

}

void 
nsTypeAheadFindSea::GetStartWindow(nsIDOMWindow *aWindow, nsIDOMWindow **aStartWindow)
{
  // Return the root ancestor content window of aWindow


}

nsresult
nsTypeAheadFindSea::GetWebBrowserFind(nsIDOMWindow *aWin, 
                                   nsIWebBrowserFind **aWebBrowserFind)
{
  NS_ENSURE_ARG_POINTER(aWin);



void
nsTypeAheadFindSea::StartTimeout()
{
  if (mTimeoutLength) {
    if (!mTimer) {

}

void
nsTypeAheadFindSea::SetSelectionLook(nsIPresShell *aPresShell, 
                                  PRBool aChangeColor, 
                                  PRBool aEnabled)
{

    return;

  // Show caret when type ahead find is on
  // Also paint selection bright (typeaheadfindsea on) or normal
  // (typeaheadfindsea off)

  if (aChangeColor) {
    mFocusedDocSelCon->SetDisplaySelection(nsISelectionController::SELECTION_ATTENTION);



void
nsTypeAheadFindSea::RemoveDocListeners()
{
  nsCOMPtr<nsIPresShell> presShell(do_QueryReferent(mFocusedWeakShell));
  nsIViewManager* vm = nsnull;



void
nsTypeAheadFindSea::AttachDocListeners(nsIPresShell *aPresShell)
{
  if (!aPresShell) {
    return;



void
nsTypeAheadFindSea::RemoveWindowListeners(nsIDOMWindow *aDOMWin)
{
  nsCOMPtr<nsIDOMEventTarget> chromeEventHandler;
  GetChromeEventHandler(aDOMWin, getter_AddRefs(chromeEventHandler));



void
nsTypeAheadFindSea::AttachWindowListeners(nsIDOMWindow *aDOMWin)
{
  nsCOMPtr<nsIDOMEventTarget> chromeEventHandler;
  GetChromeEventHandler(aDOMWin, getter_AddRefs(chromeEventHandler));



void
nsTypeAheadFindSea::GetChromeEventHandler(nsIDOMWindow *aDOMWin,
                                       nsIDOMEventTarget **aChromeTarget)
{
  nsCOMPtr<nsPIDOMWindow> privateDOMWindow(do_QueryInterface(aDOMWin));

}

PRBool
nsTypeAheadFindSea::IsTargetContentOkay(nsIContent *aContent)
{
  if (!aContent) {
    return PR_FALSE;



nsresult
nsTypeAheadFindSea::GetTargetIfTypeAheadOkay(nsIDOMEvent *aEvent, 
                                          nsIContent **aTargetContent,
                                          nsIPresShell **aTargetPresShell)
{



void
nsTypeAheadFindSea::GetSelection(nsIPresShell *aPresShell,
                              nsISelectionController **aSelCon,
                              nsISelection **aDOMSel)
{



PRBool
nsTypeAheadFindSea::IsRangeVisible(nsIPresShell *aPresShell,
                                nsIPresContext *aPresContext,
                                nsIDOMRange *aRange, PRBool aMustBeInViewPort,
                                PRBool aGetTopVisibleLeaf,



nsresult
nsTypeAheadFindSea::GetTranslatedString(const nsAString& aKey,
                                     nsAString& aStringOut)
{
  nsXPIDLString xsValue;



void
nsTypeAheadFindSea::DisplayStatus(PRBool aSuccess, nsIContent *aFocusedContent,
                               PRBool aClearStatus, const PRUnichar *aText)
{
  // pres shell -> pres context -> container -> tree item ->

  // Make sure we're not focused on a text field, listbox
  // or other form control that needs typeahead keystrokes
  if (focusedContent) {
    *aResult = nsTypeAheadFindSea::IsTargetContentOkay(focusedContent);
    return NS_OK;
  }


  EnsureContentWindow(domWinInternal, getter_AddRefs(startContentWin));
  NS_ENSURE_TRUE(startContentWin, NS_ERROR_FAILURE);

  nsCOMPtr<nsITypeAheadFindSea> typeAhead = 
    do_GetService(NS_TYPEAHEADFINDSEA_CONTRACTID);
  NS_ENSURE_TRUE(typeAhead, NS_ERROR_FAILURE);

  return typeAhead->StartNewFind(startContentWin, isLinkSearch);




#include "nsIDOMRange.h"
#include "nsIDOMWindow.h"
#include "nsIDocShellTreeItem.h"
#include "nsITypeAheadFindSea.h"
#include "nsIStringBundle.h"
#include "nsISupportsArray.h"
#include "nsISound.h"

#define TYPEAHEADFINDSEA_BUNDLE_URL \
        "chrome://global/locale/typeaheadfindsea.properties"
#define TYPEAHEADFIND_NOTFOUND_WAV_URL \
        "chrome://global/content/notfound.wav"



const int kMaxBadCharsBeforeCancel = 3;

class nsTypeAheadFindSea : public nsITypeAheadFindSea,
                        public nsIDOMKeyListener,
                        public nsIDOMTextListener,
                        public nsIDOMCompositionListener,

                        public nsSupportsWeakReference
{
public:
  nsTypeAheadFindSea();
  virtual ~nsTypeAheadFindSea();

  NS_DEFINE_STATIC_CID_ACCESSOR(NS_TYPEAHEADFINDSEA_CID);

  NS_DECL_ISUPPORTS
  NS_DECL_NSITYPEAHEADFINDSEA
  NS_DECL_NSIOBSERVER
  NS_DECL_NSIDOMEVENTLISTENER
  NS_DECL_NSISELECTIONLISTENER

  // ----- nsITimerCallback -----------------------------
  NS_DECL_NSITIMERCALLBACK

  static nsTypeAheadFindSea *GetInstance();
  static void ReleaseInstance(void);
  static PRBool IsTargetContentOkay(nsIContent *aContent);


  nsresult GetTranslatedString(const nsAString& aKey, nsAString& aStringOut);

  // Used by GetInstance and ReleaseInstance
  static nsTypeAheadFindSea *sInstance;

  // Current find state
  nsString mTypeAheadBuffer;


  // PRBool's are used instead of PRPackedBool's where the address of the
  // boolean variable is getting passed into a method. For example:
  // GetBoolPref("accessibility.typeaheadfindsea.linksonly", &mLinksOnlyPref);
  PRBool mIsFindAllowedInWindow;
  PRBool mAutoStartPref;
  PRBool mLinksOnlyPref;

  nsCOMPtr<nsIDOMWindow> mFocusedWindow;
  nsCOMPtr<nsIWeakReference> mFocusedWeakShell;

  // Windows where typeaheadfindsea doesn't auto start as the user types
  nsCOMPtr<nsISupportsArray> mManualFindWindows;
};






// This function is called at component registration time
static NS_METHOD
nsTypeAheadFindSeaRegistrationProc(nsIComponentManager *aCompMgr, nsIFile *aPath,
                                const char *registryLocation,
                                const char *componentType,
                                const nsModuleComponentInfo *info)

  // an application component. This makes sure that we're
  // initialized on application startup.

  // Register nsTypeAheadFindSea to be instantiated on startup.
  // XXX This is needed on linux, but for some reason not needed on win32.
  nsresult rv;
  nsCOMPtr<nsICategoryManager> categoryManager =

    rv = categoryManager->AddCategoryEntry(APPSTARTUP_CATEGORY,
                                           "Type Ahead Find Sea", 
                                           "service,"
                                           NS_TYPEAHEADFINDSEA_CONTRACTID,
                                           PR_TRUE, PR_TRUE, nsnull);
  }


}


NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsTypeAheadFindSea,
                                         nsTypeAheadFindSea::GetInstance)

static void PR_CALLBACK
TypeAheadFindSeaModuleDtor(nsIModule* self)
{
  nsTypeAheadFindSea::ReleaseInstance();
}

static const nsModuleComponentInfo components[] =
{
  { "TypeAheadFindSea Component", NS_TYPEAHEADFINDSEA_CID,
    NS_TYPEAHEADFINDSEA_CONTRACTID, nsTypeAheadFindSeaConstructor,
    nsTypeAheadFindSeaRegistrationProc, nsnull  // Unregistration proc
  }
};

NS_IMPL_NSGETMODULE_WITH_DTOR(nsTypeAheadFindSea, components,
                              TypeAheadFindSeaModuleDtor)

Lines 1-9 Link Here

(-)extensions/typeaheadfind/src/typeaheadfind.pkg (-9 lines)
1	# why not ship this with GRE/embedding, if we're building it?
2
3	[xpfe-browser browser]
4	#if SHARED_LIBRARY
5	dist/bin/components/@SHARED_LIBRARY@
6	#else
7	!staticcomp @LIBRARY@ @MODULE_NAME@
8	#endif
9	!xpt dist/bin/components/typeaheadfind.xpt




# why not ship this with GRE/embedding, if we're building it?

[xpfe-browser browser]
#if SHARED_LIBRARY
dist/bin/components/@SHARED_LIBRARY@
#else
!staticcomp @LIBRARY@ @MODULE_NAME@
#endif
!xpt dist/bin/components/typeaheadfindsea.xpt

# why not ship this with GRE/embedding, if we're building it?

[xpfe-browser browser]
#if SHARED_LIBRARY
dist/bin/components/@SHARED_LIBRARY@
#else
!staticcomp @LIBRARY@ @MODULE_NAME@
#endif
!xpt dist/bin/components/typeaheadfindsea.xpt

Return to bug 114044

Lines 62-74 Link Here

(-)extensions/typeaheadfind/src/nsTypeAheadFind.h (-12 / +12 lines)
62	#include "nsIDOMRange.h"	62	#include "nsIDOMRange.h"
63	#include "nsIDOMWindow.h"	63	#include "nsIDOMWindow.h"
64	#include "nsIDocShellTreeItem.h"	64	#include "nsIDocShellTreeItem.h"
65	#include "nsITypeAheadFind.h"	65	#include "nsITypeAheadFindSea.h"
66	#include "nsIStringBundle.h"	66	#include "nsIStringBundle.h"
67	#include "nsISupportsArray.h"	67	#include "nsISupportsArray.h"
68	#include "nsISound.h"	68	#include "nsISound.h"
69		69
70	#define TYPEAHEADFIND_BUNDLE_URL \	70	#define TYPEAHEADFINDSEA_BUNDLE_URL \
71	"chrome://global/locale/typeaheadfind.properties"	71	"chrome://global/locale/typeaheadfindsea.properties"
72	#define TYPEAHEADFIND_NOTFOUND_WAV_URL \	72	#define TYPEAHEADFIND_NOTFOUND_WAV_URL \
73	"chrome://global/content/notfound.wav"	73	"chrome://global/content/notfound.wav"
74		74
Lines 82-88 Link Here
82		82
83	const int kMaxBadCharsBeforeCancel = 3;	83	const int kMaxBadCharsBeforeCancel = 3;
84		84
85	class nsTypeAheadFind : public nsITypeAheadFind,	85	class nsTypeAheadFindSea : public nsITypeAheadFindSea,
86	public nsIDOMKeyListener,	86	public nsIDOMKeyListener,
87	public nsIDOMTextListener,	87	public nsIDOMTextListener,
88	public nsIDOMCompositionListener,	88	public nsIDOMCompositionListener,
Lines 93-105 Link Here
93	public nsSupportsWeakReference	93	public nsSupportsWeakReference
94	{	94	{
95	public:	95	public:
96	nsTypeAheadFind();	96	nsTypeAheadFindSea();
97	virtual ~nsTypeAheadFind();	97	virtual ~nsTypeAheadFindSea();
98		98
99	NS_DEFINE_STATIC_CID_ACCESSOR(NS_TYPEAHEADFIND_CID);	99	NS_DEFINE_STATIC_CID_ACCESSOR(NS_TYPEAHEADFINDSEA_CID);
100		100
101	NS_DECL_ISUPPORTS	101	NS_DECL_ISUPPORTS
102	NS_DECL_NSITYPEAHEADFIND	102	NS_DECL_NSITYPEAHEADFINDSEA
103	NS_DECL_NSIOBSERVER	103	NS_DECL_NSIOBSERVER
104	NS_DECL_NSIDOMEVENTLISTENER	104	NS_DECL_NSIDOMEVENTLISTENER
105	NS_DECL_NSISELECTIONLISTENER	105	NS_DECL_NSISELECTIONLISTENER
Lines 127-133 Link Here
127	// ----- nsITimerCallback -----------------------------	127	// ----- nsITimerCallback -----------------------------
128	NS_DECL_NSITIMERCALLBACK	128	NS_DECL_NSITIMERCALLBACK
129		129
130	static nsTypeAheadFind *GetInstance();	130	static nsTypeAheadFindSea *GetInstance();
131	static void ReleaseInstance(void);	131	static void ReleaseInstance(void);
132	static PRBool IsTargetContentOkay(nsIContent *aContent);	132	static PRBool IsTargetContentOkay(nsIContent *aContent);
133		133
Lines 185-191 Link Here
185	nsresult GetTranslatedString(const nsAString& aKey, nsAString& aStringOut);	185	nsresult GetTranslatedString(const nsAString& aKey, nsAString& aStringOut);
186		186
187	// Used by GetInstance and ReleaseInstance	187	// Used by GetInstance and ReleaseInstance
188	static nsTypeAheadFind *sInstance;	188	static nsTypeAheadFindSea *sInstance;
189		189
190	// Current find state	190	// Current find state
191	nsString mTypeAheadBuffer;	191	nsString mTypeAheadBuffer;
Lines 196-202 Link Here
196		196
197	// PRBool's are used instead of PRPackedBool's where the address of the	197	// PRBool's are used instead of PRPackedBool's where the address of the
198	// boolean variable is getting passed into a method. For example:	198	// boolean variable is getting passed into a method. For example:
199	// GetBoolPref("accessibility.typeaheadfind.linksonly", &mLinksOnlyPref);	199	// GetBoolPref("accessibility.typeaheadfindsea.linksonly", &mLinksOnlyPref);
200	PRBool mIsFindAllowedInWindow;	200	PRBool mIsFindAllowedInWindow;
201	PRBool mAutoStartPref;	201	PRBool mAutoStartPref;
202	PRBool mLinksOnlyPref;	202	PRBool mLinksOnlyPref;
Lines 251-257 Link Here
251	nsCOMPtr<nsIDOMWindow> mFocusedWindow;	251	nsCOMPtr<nsIDOMWindow> mFocusedWindow;
252	nsCOMPtr<nsIWeakReference> mFocusedWeakShell;	252	nsCOMPtr<nsIWeakReference> mFocusedWeakShell;
253		253
254	// Windows where typeaheadfind doesn't auto start as the user types	254	// Windows where typeaheadfindsea doesn't auto start as the user types
255	nsCOMPtr<nsISupportsArray> mManualFindWindows;	255	nsCOMPtr<nsISupportsArray> mManualFindWindows;
256	};	256	};
257		257

Lines 55-61 Link Here

(-)extensions/typeaheadfind/src/nsTypeAheadFindRegistration.cpp (-13 / +13 lines)
55		55
56	// This function is called at component registration time	56	// This function is called at component registration time
57	static NS_METHOD	57	static NS_METHOD
58	nsTypeAheadFindRegistrationProc(nsIComponentManager aCompMgr, nsIFile aPath,	58	nsTypeAheadFindSeaRegistrationProc(nsIComponentManager aCompMgr, nsIFile aPath,
59	const char *registryLocation,	59	const char *registryLocation,
60	const char *componentType,	60	const char *componentType,
61	const nsModuleComponentInfo *info)	61	const nsModuleComponentInfo *info)
Lines 64-70 Link Here
64	// an application component. This makes sure that we're	64	// an application component. This makes sure that we're
65	// initialized on application startup.	65	// initialized on application startup.
66		66
67	// Register nsTypeAheadFind to be instantiated on startup.	67	// Register nsTypeAheadFindSea to be instantiated on startup.
68	// XXX This is needed on linux, but for some reason not needed on win32.	68	// XXX This is needed on linux, but for some reason not needed on win32.
69	nsresult rv;	69	nsresult rv;
70	nsCOMPtr<nsICategoryManager> categoryManager =	70	nsCOMPtr<nsICategoryManager> categoryManager =
Lines 74-80 Link Here
74	rv = categoryManager->AddCategoryEntry(APPSTARTUP_CATEGORY,	74	rv = categoryManager->AddCategoryEntry(APPSTARTUP_CATEGORY,
75	"Type Ahead Find",	75	"Type Ahead Find Sea",
76	"service,"	76	"service,"
77	NS_TYPEAHEADFIND_CONTRACTID,	77	NS_TYPEAHEADFINDSEA_CONTRACTID,
78	PR_TRUE, PR_TRUE, nsnull);	78	PR_TRUE, PR_TRUE, nsnull);
79	}	79	}
80		80
Lines 82-103 Link Here
82	}	82	}
83		83
84		84
85	NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsTypeAheadFind,	85	NS_GENERIC_FACTORY_SINGLETON_CONSTRUCTOR(nsTypeAheadFindSea,
86	nsTypeAheadFind::GetInstance)	86	nsTypeAheadFindSea::GetInstance)
87		87
88	static void PR_CALLBACK	88	static void PR_CALLBACK
89	TypeAheadFindModuleDtor(nsIModule* self)	89	TypeAheadFindSeaModuleDtor(nsIModule* self)
90	{	90	{
91	nsTypeAheadFind::ReleaseInstance();	91	nsTypeAheadFindSea::ReleaseInstance();
92	}	92	}
93		93
94	static const nsModuleComponentInfo components[] =	94	static const nsModuleComponentInfo components[] =
95	{	95	{
96	{ "TypeAheadFind Component", NS_TYPEAHEADFIND_CID,	96	{ "TypeAheadFindSea Component", NS_TYPEAHEADFINDSEA_CID,
97	NS_TYPEAHEADFIND_CONTRACTID, nsTypeAheadFindConstructor,	97	NS_TYPEAHEADFINDSEA_CONTRACTID, nsTypeAheadFindSeaConstructor,
98	nsTypeAheadFindRegistrationProc, nsnull // Unregistration proc	98	nsTypeAheadFindSeaRegistrationProc, nsnull // Unregistration proc
99	}	99	}
100	};	100	};
101		101
102	NS_IMPL_NSGETMODULE_WITH_DTOR(nsTypeAheadFind, components,	102	NS_IMPL_NSGETMODULE_WITH_DTOR(nsTypeAheadFindSea, components,
103	TypeAheadFindModuleDtor)	103	TypeAheadFindSeaModuleDtor)

Lines 1-90 Link Here

(-)extensions/typeaheadfind/public/nsITypeAheadFind.idl (-90 lines)
1	/* -- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -- */
2	/* *** BEGIN LICENSE BLOCK ***
3	* Version: NPL 1.1/GPL 2.0/LGPL 2.1
4	*
5	* The contents of this file are subject to the Netscape Public License
6	* Version 1.1 (the "License"); you may not use this file except in
7	* compliance with the License. You may obtain a copy of the License at
8	* http://www.mozilla.org/NPL/
9	*
10	* Software distributed under the License is distributed on an "AS IS" basis,
11	* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
12	* for the specific language governing rights and limitations under the
13	* License.
14	*
15	* The Original Code is mozilla.org code.
16	*
17	* The Initial Developer of the Original Code is
18	* Netscape Communications Corporation.
19	* Portions created by the Initial Developer are Copyright (C) 1998
20	* the Initial Developer. All Rights Reserved.
21	*
22	* Contributor(s):
23	* Original Author: Aaron Leventhal (aaronl@netscape.com)
24	* Contributors:
25	*
26	*
27	* Alternatively, the contents of this file may be used under the terms of
28	* either the GNU General Public License Version 2 or later (the "GPL"), or
29	* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
30	* in which case the provisions of the GPL or the LGPL are applicable instead
31	* of those above. If you wish to allow use of your version of this file only
32	* under the terms of either the GPL or the LGPL, and not to allow others to
33	* use your version of this file under the terms of the NPL, indicate your
34	* decision by deleting the provisions above and replace them with the notice
35	* and other provisions required by the GPL or the LGPL. If you do not delete
36	* the provisions above, a recipient may use your version of this file under
37	* the terms of any one of the NPL, the GPL or the LGPL.
38	*
39	* *** END LICENSE BLOCK *** */
40
41	#include "nsISupports.idl"
42	#include "domstubs.idl"
43	#include "nsISupportsPrimitives.idl"
44
45	%{ C++
46	#include "nsIDOMEvent.h"
47
48	#define NS_TYPEAHEADFIND_CID \
49	{0x46590685, 0xbc00, 0x4aac, {0xab, 0xed, 0x2c, 0x10, 0xa5, 0xb9, 0x45, 0xa4}}
50
51	#define NS_TYPEAHEADFIND_CONTRACTID "@mozilla.org/typeaheadfind;1"
52	%}
53
54	interface nsIDOMEvent;
55
56	[scriptable, uuid(AD1C62CC-72F4-4c5b-BE78-503854F9E0D8)]
57	interface nsITypeAheadFind : nsISupports
58	{
59	/** Is type ahead find mode currently on? */
60	readonly attribute boolean isActive;
61
62	/** Manually start type ahead find mode */
63	void startNewFind(in nsIDOMWindow aWindow, in boolean aLinksOnly);
64
65	/** Manually cancel type ahead find mode */
66	void cancelFind();
67
68	/**
69	* Will find as you type start automatically if the user
70	* types with the focus on page content other than a textfield or select?
71	* If autostart is off, the startNewFind() method can be used to enact
72	* type ahead find, as well as cmd_findTypeLinks or cmd_findTypeText.
73	*/
74	void setAutoStart(in nsIDOMWindow aWindow, in boolean aIsAutoStartOn);
75	boolean getAutoStart(in nsIDOMWindow aWindow);
76
77	/**
78	* Find next recurrence if typeaheadfind was the last used find,
79	* as opposed to regular find. Returns false in nsISupportsPRBool if we
80	* don't handle the request.
81	*/
82	void findNext(in boolean aReverse, in nsISupportsInterfacePointer aCallerWindowSupports);
83
84	/*
85	* Go back and remove one character from find string
86	* Returns true if backspace used
87	*/
88	boolean backOneChar();
89	};
90

Lines 1-13 Link Here

(-)extensions/typeaheadfind/resources/locale/en-US/typeaheadfind.properties (-13 lines)
1	openparen = (
2	closeparen = )
3	textfound = Text found: "
4	textnotfound = Text not found: "
5	linkfound = Link found: "
6	linknotfound = Link not found: "
7	closequote = "
8	stopfind = Find stopped.
9	starttextfind = Starting -- find text as you type
10	startlinkfind = Starting -- find links as you type
11	repeated = repeated
12	nextmatch = - next match
13	prevmatch = - previous match

Lines 31-44 Link Here

(-)extensions/typeaheadfind/src/Makefile.in (-5 / +5 lines)
31		31
32	include $(DEPTH)/config/autoconf.mk	32	include $(DEPTH)/config/autoconf.mk
33		33
34	MODULE = typeaheadfind	34	MODULE = typeaheadfindsea
35	LIBRARY_NAME = typeaheadfind	35	LIBRARY_NAME = typeaheadfindsea
36	ifneq ($(OS_ARCH),WINNT)	36	ifneq ($(OS_ARCH),WINNT)
37	SHORT_LIBNAME = typahead	37	SHORT_LIBNAME = typaheadsea
38	endif	38	endif
39	GRE_MODULE = 1	39	GRE_MODULE = 1
40		40
41	PACKAGE_FILE = typeaheadfind.pkg	41	PACKAGE_FILE = typeaheadfindsea.pkg
42		42
43	REQUIRES = appcomps \	43	REQUIRES = appcomps \
44	embedcomponents \	44	embedcomponents \
Lines 66-72 Link Here
66		66
67	EXPORT_LIBRARY = 1	67	EXPORT_LIBRARY = 1
68	IS_COMPONENT = 1	68	IS_COMPONENT = 1
69	MODULE_NAME = nsTypeAheadFind	69	MODULE_NAME = nsTypeAheadFindSea
70		70
71	CPPSRCS = \	71	CPPSRCS = \
72	nsTypeAheadFind.cpp \	72	nsTypeAheadFind.cpp \