/*******************************************************************************
 * Copyright (c) 2007 IBM Corporation and Others
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Hisashi MIYASHITA - initial API and implementation
 *******************************************************************************/
package org.eclipse.actf.ai.navigator.impl;

import java.awt.Toolkit;
import java.io.File;
import java.net.URL;

import org.eclipse.actf.ai.audio.io.AudioFactory;
import org.eclipse.actf.ai.audio.io.IAudioPipe;
import org.eclipse.actf.ai.audio.io.IAudioReader;
import org.eclipse.actf.ai.audio.io.IAudioWriter;
import org.eclipse.actf.ai.fennec.IFennecEntry;
import org.eclipse.actf.ai.fennec.IFennecMediator;
import org.eclipse.actf.ai.fennec.treemanager.IAccessKeyList;
import org.eclipse.actf.ai.fennec.treemanager.ILocation;
import org.eclipse.actf.ai.fennec.treemanager.IMediaSyncEventListener;
import org.eclipse.actf.ai.fennec.treemanager.ISoundControl;
import org.eclipse.actf.ai.fennec.treemanager.ITreeItem;
import org.eclipse.actf.ai.fennec.treemanager.ITreeManager;
import org.eclipse.actf.ai.fennec.treemanager.IVideoControl;
import org.eclipse.actf.ai.fennec.treemanager.TreeManagerException;
import org.eclipse.actf.ai.fennec.treemanager.TreeManagerInterruptedException;
import org.eclipse.actf.ai.fennec.treemanager.ISoundControl.VolumeState;
import org.eclipse.actf.ai.fennec.treemanager.IVideoControl.VideoState;
import org.eclipse.actf.ai.internal.navigator.NavigatorPlugin;
import org.eclipse.actf.ai.navigator.IManipulator;
import org.eclipse.actf.ai.navigator.IMediaControl;
import org.eclipse.actf.ai.navigator.INavigatorUI;
import org.eclipse.actf.ai.navigator.IMediaControl.IHandle;
import org.eclipse.actf.ai.navigator.extension.ManipulatorExtension;
import org.eclipse.actf.ai.navigator.extension.MediaControlExtension;
import org.eclipse.actf.ai.navigator.extension.ScreenReaderExtension;
import org.eclipse.actf.ai.navigator.util.MessageFormatter;
import org.eclipse.actf.ai.navigator.views.NavigatorTreeView;
import org.eclipse.actf.ai.navigator.voice.VoiceManager;
import org.eclipse.actf.ai.voice.IVoice;
import org.eclipse.actf.ai.voice.IVoiceEventListener;
import org.eclipse.actf.model.ui.IModelServiceHolder;
import org.eclipse.actf.model.ui.editor.browser.IWebBrowserACTF;
import org.eclipse.actf.ui.util.BrowserLaunch;
import org.eclipse.actf.ui.util.PlatformUIUtil;
import org.eclipse.actf.util.ApplicationArgumentUtil;
import org.eclipse.actf.util.vocab.IProposition;
import org.eclipse.actf.util.vocab.Vocabulary;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;


public abstract class NavigatorImpl implements INavigatorUI, IVoiceEventListener {
    private static boolean isDemo = ApplicationArgumentUtil.isAvailable("-demo");

    // private final WebEventListener webEventListener;

    private IWebBrowserACTF webBrowser;

    private IFennecMediator fennecMediator;

    private ITreeManager treeManager;

    private final int maxRetry;

    private final int retryInterval;

    private Display display;

    private IManipulator.Mode mode;
    

    public NavigatorImpl(WebEventListener webEventListener, IWebBrowserACTF webBrowser, int maxRetry, int retryInterval) {
        // this.webEventListener = webEventListener;
        this.webBrowser = webBrowser;
        this.maxRetry = maxRetry;
        this.retryInterval = retryInterval;
        this.display = Display.getCurrent();
    }

    public ITreeManager getTreeManager() {
        return treeManager;
    }

    private NavigatorTreeView getNavigatorTreeView() {
        return NavigatorPlugin.getDefault().getNavigatorTreeView();
    }

    private void sleep(int interval) {
        long startTime = System.currentTimeMillis();
        while (true) {
            boolean busy = display.readAndDispatch();
            if (!busy)
                display.sleep();
            if ((System.currentTimeMillis() - startTime) > interval)
                break;
        }
    }
    
    // -----------------------------------------------------------------------
    // Sound Util
    // -----------------------------------------------------------------------
    
    private void beep() {
        Toolkit.getDefaultToolkit().beep();
    }

    private static IAudioPipe audio;

    static {
        if (true) {
            // TODO replace audio file
            URL url = NavigatorPlugin.getDefault().getBundle().getResource("waiting.wav");
            IAudioReader reader = AudioFactory.createAudioReader(url);
            IAudioWriter writer = AudioFactory.createDefaultWriter();
            audio = AudioFactory.createLoopedAudioPipe(reader, writer);
            audio.setBufferSize(100);
            audio.setInterval(1);
            audio.prepare();
        }
    }
    
    private void startProgress() {
        startProgress(2000);
    }
    private void startProgress(int msec) {
        audio.start(msec);
    }
    
    private void endProgress() {
        audio.stop();
    }

    // -----------------------------------------------------------------------
    // Voice
    // -----------------------------------------------------------------------

    private final VoiceManager voiceManager = new VoiceManager(this);

    protected MessageFormatter getMessageFormatter() {
        return voiceManager.getMessageFormatter();
    }

    private VoiceManager getVoiceManager() {
        return voiceManager;
    }

    public void indexReceived(int index) {
        if (speakAllMode && (index == -1)) {
            display.asyncExec(new Runnable() {
                public void run() {
                    traverseDownAll();
                }
            });
        } else if (index == -2) {
            display.asyncExec(new Runnable() {
                public void run() {
                    stopSpeak();
                }
            });
        }
    }
    
    // -----------------------------------------------------------------------
    // Speak basic
    // -----------------------------------------------------------------------

    protected void speakWithFormat(String str) {
        speakWithFormat(str, false);
    }
    
    protected void speakWithFormat(String str, boolean flush) {
        speak(getMessageFormatter().mes(str), flush, true);
    }

    protected void speak(String str, boolean flush) {
        speak(str, flush, true);
    }
    
    protected void speak(String str, boolean flush, boolean maleVoice) {
        if (speakAllMode) {
            getVoiceManager().speakWithCallback(str, flush, maleVoice);
        } else {
            getVoiceManager().speak(str, flush, maleVoice);
        }
    }
    
    private boolean speakAllMode = false;

    private void stopSpeakAll() {
        speakAllMode = false;
    }

    public void speakAll() {
        speakAllMode = true;
        try {
            speakActiveItem(true, false, JumpMode.NONE);
        } catch (TreeManagerException e) {
            e.printStackTrace();
        }
    }

    public void traverseDownAll() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.traverse(false);
            }

            public void after(int st) throws TreeManagerException {
                afterMoveForSpeakAll(st, "Navigator.BOTTOM");
            }
        });
    }

    private void afterMoveForSpeakAll(int st, String notMoved) throws TreeManagerException {
        if ((st & ITreeManager.CLICKED) != 0) {
            speakWithFormat("Navigator.CLICK");
        }
        if ((st & ITreeManager.MOVED) != 0) {
            speakActiveItem(true, false, JumpMode.NONE);
            sayLevel();
        } else {
            speakAllMode = false;
            sayLevel(notMoved);
        }
    }

    public void stopSpeak() {
        endProgress();
        stopSpeakAll();
        getVoiceManager().stop();
    }


    // -----------------------------------------------------------------------
    // Say, speak
    // -----------------------------------------------------------------------
    
    private void sayMode(IManipulator.Mode mode) {
        speakWithFormat(mode.name + " mode");
    }
    
    private void sayLevel(String prefix) throws TreeManagerException {
        String mes = getMessageFormatter().mes(prefix);
        speak(mes + " " + getLevelMessage(), true, true);
    }
    
    private String getLevelMessage() throws TreeManagerException {
        int level = treeManager.getLevel();
        String mesLv;
        if (level > 0) {
            mesLv = getMessageFormatter().mes("Navigator.LEVEL", new Object[] { new Integer(level) });
        } else {
            mesLv = getMessageFormatter().mes("Navigator.TOP_LEVEL");
        }
        return mesLv;
    }

    private void sayLevel() throws TreeManagerException {
        // speak(getLevelMessage(), false, true);
    }

    private void sayRetrial() {
        speak(getMessageFormatter().mes("Navigator.UNDONE"), true, true);
    }

    private void speakVideoInfo(boolean flag) throws TreeManagerException {
        IVideoControl vc = treeManager.getVideoControl();
        if (flag || vcCount != vc.getCount()) {
            vcCount = vc.getCount();
            if (vcCount == 0) {
                speakWithFormat("Navigator.NOVIDEO");
            } else if (vcCount == 1) {
                speakWithFormat("Navigator.SINGLEVIDEO");
            } else {
                String text = getMessageFormatter().mes("Navigator.VIDEOCOUNT", new Object[] { vcCount });
                speak(text, false, false);
            }
        }
    }

    private void speakSoundInfo(boolean flag) throws TreeManagerException {
        ISoundControl sc = treeManager.getSoundControl();
        if (flag || scCount != sc.getCount()) {
            scCount = sc.getCount();
            if (scCount == 0) {
                speakWithFormat("Navigator.NOSOUND");
            } else if (scCount == 1) {
                speakWithFormat("Navigator.SINGLESOUND");
            } else {
                String text = getMessageFormatter().mes("Navigator.SOUNDCOUNT", new Object[] { scCount });
                speak(text, false, false);
            }
        }
    }

    private int vcCount, scCount;

    //private boolean mcAvailable = false;

    private void speakMediaInfo() throws TreeManagerException {
        IVideoControl vc = treeManager.getVideoControl();

        StringBuffer buf = new StringBuffer();
        if (vc.getCount() > 0) {
            buf.append(getMessageFormatter().mes("Navigator.VIDEO_AT", 
                    formatTime(vc.getCurrentPosition())));
        }
        if (vc.getTotalLength() > 0) {
            buf.append(getMessageFormatter().mes("Navigator.VIDEO_TOTAL", 
                    formatTime(vc.getTotalLength())));
        }

        vcCount = vc.getCount();
        if (vcCount == 0) {
            speakWithFormat("Navigator.NOVIDEO");
        } else if (vcCount == 1) {
            speakWithFormat("Navigator.SINGLEVIDEO");
        } else {
            int index = vc.getIndex();
            String text = getMessageFormatter().mes("Navigator.VIDEOINDEX", new Object[] { index, vcCount });
            speak(text, false, false);
        }

        speak(buf.toString(), false, false);
    }

    private String formatTime(double currentPosition) {
        int s = (int) currentPosition;
        int m = s / 60;
        s %= 60;
        int h = s / 60;
        m %= 60;
        
        if (h > 0) {
            return getMessageFormatter().mes("Navigator.HH_MM_SS", new Object[] { s, m, h });
        } else if (m > 0) {
            return getMessageFormatter().mes("Navigator.MM_SS", new Object[] { s, m });
        }
        return getMessageFormatter().mes("Navigator.SS", new Object[] { s });
    }
    
    private void speakPageInfo() {
        try {
            speakVideoInfo(false);
            speakSoundInfo(false);

            MediaControlExtension.speakInfo(false);
            
            /*
            if (!mcAvailable && MediaControlExtension.isAvailable()) {
                speakWithFormat("AudioDescription.available");
                mcAvailable = true;
            }*/

        } catch (TreeManagerException e) {
        }
    }

    private void sayFennecName(String fennecName, boolean flag) {
        String text = getMessageFormatter().mes("Navigator.FENNEC_NAME",
                                           new Object[] { fennecName });
        speak(text, flag, true);
    }

    private void sayNoFennec(boolean flag) {
        speakWithFormat("Navigator.NO_FENNEC", flag);
    }

    public void speakCurrentStatus() {
        sayMode(mode);
        try {
            speakActiveItem(false, true, JumpMode.NONE);
            speakPageInfo();
        } catch (TreeManagerException e) {
        }
    }

    public void speakMediaStatus() {
        try {
            speakMediaInfo();
        } catch (TreeManagerException e) {
        }
    }

    public void speakTab(boolean flush) {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorPart editor = page.getActiveEditor();

        IEditorReference[] erefs = page.getEditorReferences();
        boolean found = false;
        int index = 0, total = 0;
        for (int i = 0; i < erefs.length; i++) {
            if (!found)
                index++;
            total++;
            if (erefs[i].getEditor(false).equals(editor)) {
                found = true;
            }
        }

        String buf = "";
        if (total == 1)
            buf = editor.getTitle();
        else
            buf = getMessageFormatter().mes("Navigator.MOVE_TAB", editor.getTitle(), index, total);

        speak(buf, flush, false);
        stopSpeakAll();
    }
    

    private ITreeItem lastHighlighted;

    private void highlight(ITreeItem item) {
        if (lastHighlighted != null) {
            try {
                lastHighlighted.unhighlight();
            } catch (TreeManagerException e) {
            }
        }
        try {
            item.highlight();
        } catch (TreeManagerException e) {
        }
        lastHighlighted = item;
        sleep(1);
    }
    
    protected enum JumpMode {
        HEADING, 
        LISTITEM_TOP, 
        LINK, 
        OBJECT, 
        BLOCK, 
        INPUT, 
        LISTITEM_BOTTOM, 
        ACCESSKEY, 
        MEDIA,
        ALTALABLE,
        NONE,
    }

    private boolean listJumping = false;

    private void speakActiveItem(boolean flush, boolean verbose, JumpMode jumpMode) throws TreeManagerException {
        endProgress();
        ITreeItem item = treeManager.getActiveItem();
        ITreeItem[] siblings = treeManager.getSiblings();

        final MessageFormatter mf = getMessageFormatter();
        if (item == null)
            return;
        // update view
        highlight(item);
        getNavigatorTreeView().showItem(item);

        // get item's UI string
        int idx = item.getNth();
        int st = intervalStart(siblings, idx);
        int end = intervalEnd(siblings, idx);
        StringBuffer bufUIStr = new StringBuffer();
        for (int i = st; i <= end; i++) {
            if (i < siblings.length)
                bufUIStr.append(siblings[i].getUIString());
            else
                System.err.println("st " + st + ", end " + end + ", siblings.length " + siblings.length);
        }
        char accessKey = item.getAccessKey();

        String uiStr = bufUIStr.toString();
        String label = item.getFormLabel();
        String speak = uiStr;

        boolean isLink = Vocabulary.isLink().eval(item);
        int hl = item.getHeadingLevel();
        boolean isHeading = hl > 0;
        boolean isListItem = Vocabulary.isListItem().eval(item);
        boolean isListTop = Vocabulary.isListTop().eval(item);
        boolean isCheckbox = Vocabulary.isCheckbox().eval(item);
        boolean isRadio = Vocabulary.isRadio().eval(item);
        boolean isCombobox = Vocabulary.isCombobox().eval(item);
        //boolean isMultiSelectable = Vocabulary.isMultiSelectable().eval(item);
        boolean isButton = Vocabulary.isButton().eval(item);
        boolean isPassword = Vocabulary.isPassword().eval(item);
        boolean isTextbox = Vocabulary.isTextbox().eval(item);
        boolean isTextarea = Vocabulary.isMultilineEdit().eval(item);
        boolean isFileEdit = Vocabulary.isFileEdit().eval(item);
        boolean isChecked = Vocabulary.isChecked().eval(item);
        boolean isClickable = Vocabulary.isClickable().eval(item);
        boolean isFlashTopNode = Vocabulary.isFlashTopNode().eval(item);
        boolean isFlashLastNode = Vocabulary.isFlashLastNode().eval(item);
        boolean isMedia = Vocabulary.isMedia().eval(item);
        
        
        if (isButton) {
            String widget = mf.mes("Navigator.BUTTON");
            if (uiStr.matches("[0-9]+")) {
                speak = mf.concat(widget, uiStr);
            } else {
                speak = mf.concat(uiStr, widget);
            }
        } else if (isLink) {
            boolean isVisitedLink = Vocabulary.isVisitedLink().eval(item);
            String widget = mf.mes(isVisitedLink ? "Navigator.VISITED_LINK" : "Navigator.LINK");
            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(uiStr, widget);
            } else {
                speak = mf.concat(widget, uiStr);
            }
        } else if (isPassword) {
            if (uiStr.length() > 0)
                uiStr = mf.mes("Navigator.PASSWORD_STAR3");
            String widget = mf.mes("Navigator.PASSWORD");
            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget, uiStr);
            } else {
                speak = mf.concat(uiStr, widget);
            }
        } else if (isFileEdit) {
            String widget = mf.mes("Navigator.FILE_UPLOAD");
            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget, uiStr);
            } else {
                speak = mf.concat(widget, uiStr);
            }
        } else if (isTextarea) {
            String widget = mf.mes((uiStr.length() == 0) ? "Navigator.TEXTAREA_EMPTY" : "Navigator.TEXTAREA");
            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget);
            } else {
                speak = widget;
            }
        } else if (isTextbox) {
            String widget = mf.mes("Navigator.TEXTBOX");

            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget, uiStr);
            } else {
                speak = mf.concat(widget, uiStr);
            }
        } else if (isCheckbox) {
            String widget = mf.mes("Navigator.CHECKBOX");
            String checked = mf.mes(isChecked ? "Navigator.CHECKED" : "Navigator.NOT_CHECKED");

            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget, checked);
            } else {
                speak = mf.concat(widget, checked, label);
            }
        } else if (isRadio) {
            String widget = mf.mes("Navigator.RADIO");
            String checked = mf.mes(isChecked ? "Navigator.CHECKED" : "Navigator.NOT_CHECKED");

            int index = item.getRadioIndex();
            int total = item.getRadioTotal();
            String nm = "";
            if (index != 0 && total != 0) {
                nm = mf.mes("Navigator.N_OF_M", index, total);
            }

            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, widget, checked, nm);
            } else {
                speak = mf.concat(widget, checked, nm, label);
            }
        } else if (isCombobox) {
            int[] indices = item.getSelectedIndices();
            int total = item.getOptionsCount();

            if (indices.length > 0) {
                StringBuffer sb = new StringBuffer();
                for (int i = 0; i < indices.length; i++) {
                    sb.append(mf.mes("Navigator.COMBO_BOX") + " ");
                    sb.append(item.getOptionTextAt(indices[i]));
                    sb.append(" " + mf.mes("Navigator.N_OF_M", indices[i] + 1, total) + " ");
                }
                speak = mf.concat(uiStr, sb.toString());
            } else {
                speak = mf.concat(uiStr, mf.mes("Navigator.NO_SELECTION"));
            }
            if (jumpMode == JumpMode.LINK) {
                speak = mf.concat(label, uiStr);
            }
        } else if (isFlashTopNode) {
            boolean isMSAAFlash = Vocabulary.isMSAAFlash().eval(item);
            if (isMSAAFlash)
                speak = mf.concat(speak, mf.mes("Navigator.MSAA_FLASH_CONTENT"));
            else
                speak = mf.concat(speak, mf.mes("Navigator.FLASH_CONTENT"));
        } else if (isFlashLastNode) {
            speak = mf.mes("Navigator.FLASH_END");
        }
        if (speak.length() == 0) {
            if (isClickable) {
                speak = "Clickable";
            }
        }
        if (isHeading) {
            String widget = mf.mes("Navigator.HEADING");
            String level = mf.mes("Navigator.LEVEL", hl);

            if (jumpMode == JumpMode.HEADING) {
                speak = mf.concat(speak, widget, level);
            } else {
                speak = mf.concat(widget, level, speak);
            }
        }

        if (isMedia) {
            String media = mf.mes("Navigator.MEDIA");
            speak = mf.concat(media, speak);
        }

        if (isListItem) {
            int index = item.getListIndex();
            int total = item.getListTotal();
            if (total > 1) {
                String nm = mf.mes("Navigator.N_OF_M", index, total);
                speak = mf.concat(speak, nm);
                if (listJumping && ((jumpMode == JumpMode.LISTITEM_TOP && index == 1) //
                        || (jumpMode == JumpMode.LISTITEM_BOTTOM && index == total))) {
                    beep();
                }
                listJumping = true;
            }
        } else {
            listJumping = false;
        }
        if (isListTop) {
            ITreeItem[] children = item.getChildItems();
            int n = 0;
            for (int i = 0; i < children.length; i++) {
                if (Vocabulary.isListItem().eval(children[i])) {
                    n++;
                }
            }
            speak = mf.concat(speak, uiStr, mf.mes("Navigator.LIST_TOP", n));
        }
        
        if (accessKey != 0) {
            speak = mf.concat(speak, mf.mes("Navigator.ACCESSKEY_GUIDE", accessKey));
        }

        if (verbose) {
            String desc = item.getDescription();
            if ((desc != null) && (desc.length() > 0)) {
                speak = mf.concat(speak, desc);
            }
        }

        speak(speak, flush, !isLink);
    }

    private int intervalStart(ITreeItem[] siblings, int st) {
        if (siblings == null)
            return 0;
        for (st = st - 1;; st--) {
            if (st < 0 || siblings.length <= st)
                return 0;
            if (!Vocabulary.isConnectable().eval(siblings[st]))
                return st + 1;
        }
    }

    private int intervalEnd(ITreeItem[] siblings, int end) {
        if (siblings == null)
            return 0;
        for (; end < siblings.length; end++) {
            if (!Vocabulary.isConnectable().eval(siblings[end]))
                return end;
        }
        return end - 1;
    }

    // ---------------------------------------------------------------------
    // Mode Control
    // ---------------------------------------------------------------------
    
    // Used by NavigatorImplExSub
    protected void setMode(IManipulator.Mode mode) {
        if (this.mode == mode)
            return;
        if (this.mode != null) {
            //sayMode(mode);
        }
        this.mode = mode;
        ManipulatorExtension.setMode(mode);
        getNavigatorTreeView().setMode(mode);
        switch (mode.code) {
        case IManipulator.TREE_NAVIGATION_MODE_CODE:
            ScreenReaderExtension.screenReaderOff();
            if (ScreenReaderExtension.isAvailable()) {
                webBrowser.showAddressText(false);
            }
            break;
        case IManipulator.FORM_INPUT_MODE_CODE:
        default:
            ScreenReaderExtension.screenReaderOn();
            break;
        }
    }

    private void enterFormInputMode(ITreeItem item) {
        setMode(IManipulator.FORM_INPUT_MODE);
        item.setFocus();
    }

    private void enterFormInputMode() {
        setMode(IManipulator.FORM_INPUT_MODE);
    }

    // --------------------------------------------------------------------------------
    // Fennec Control
    // --------------------------------------------------------------------------------

    private int currentFennecIdx = 1;
    
    private IFennecEntry currentEntry = null;
    
    protected IFennecEntry getCurrentEntry() {
        return currentEntry;
    }

    private void selectFennec(boolean next, boolean flush) {
        selectFennec(next, flush, true);
    }
    private void selectFennec(boolean next, boolean flush, boolean sayFlag) {
        if (lastHighlighted != null) {
            try {
                lastHighlighted.unhighlight();
            } catch (TreeManagerException e1) {
            }
        }

        IFennecEntry[] entries = fennecMediator.getFennecEntries();
        if (next) {
            if (entries.length == 0) {
                speakWithFormat("Navigator.NO_OTHER_FENNEC", true);
                return;
            }
            currentFennecIdx++;
        }
        if (currentFennecIdx > entries.length)
            currentFennecIdx = 0;
        try {
            restoreLocation(getLocation());
            if (currentFennecIdx == 0) {
                initFennec(null, flush, sayFlag);
            } else {
                initFennec(entries[currentFennecIdx - 1], flush, sayFlag);
            }
            speakActiveItem(false, false, JumpMode.NONE);
        } catch (TreeManagerException e) {
        }
    }

    protected void selectUserFennec() {
        if (lastHighlighted != null) {
            try {
                lastHighlighted.unhighlight();
            } catch (TreeManagerException e1) {
            }
        }

        IFennecEntry[] entries = fennecMediator.getFennecEntries();
        for (int i = 0; i < entries.length; i++) {
            if (entries[i].isUserEntry()) {
                try {
                    restoreLocation(getLocation());
                    initFennec(entries[i], true, true);
                    speakActiveItem(false, false, JumpMode.NONE);
                } catch (TreeManagerException e) {
                }
                return;
            }
        }
        speakWithFormat("Navigator.NO_OTHER_FENNEC", true);
        return;
    }

    public void selectNextFennec() {
        selectFennec(true, true);
    }
    
    void setFennecMediator(IFennecMediator fennecMediator) {
        if (this.fennecMediator != null) {
            this.fennecMediator.release();
        }
        this.fennecMediator = fennecMediator;
        // TODO
        this.treeManager = null;
        this.lastHighlighted = null;
        getNavigatorTreeView().clearItem();
    }


    private String getFennecName(IFennecEntry entry) {
        if (entry == null)
            return getMessageFormatter().mes("Navigator.NO_FENNEC_MESSAGE");
        String text = entry.getDocumentation();
        if ((text != null) && (text.length() > 0))
            return text;
        return getMessageFormatter().mes("Navigator.NO_FENNEC_NAME");
    }

    private void initFennec(IFennecEntry entry, boolean flag, boolean sayFlag) throws TreeManagerException {
        currentEntry = entry;
        treeManager = fennecMediator.newTreeManager(entry);
        String fennecName = getFennecName(entry);
        if (sayFlag) {
            if (entry == null) {
                sayNoFennec(flag);
            } else {
                sayFennecName(fennecName, flag);
            }
        }
        getNavigatorTreeView().showFennecName(fennecName);
        setMode(IManipulator.TREE_NAVIGATION_MODE);
        try {
            treeManager.initialize();
            if (sayFlag)
                speakPageInfo();
        } catch (TreeManagerException e) {
            if (sayFlag)
                speakWithFormat(e.getMessage());
        }

        if (!skipToAnchor(webBrowser.getURL())) {
            if (locationToBeRestored != null) {
                try {
                    treeManager.moveToLocation(locationToBeRestored);
                } catch (TreeManagerException e) {
                }
                locationToBeRestored = null;
            }
        }
    }

    public void startNavigation(IWebBrowserACTF webBrowser) {
        startNavigation(webBrowser, true);
    }

    public void startNavigation(IWebBrowserACTF webBrowser, boolean sayFlag) {
        endProgress();
        if (ScreenReaderExtension.isAvailable() && isLeftViewsShown() && !isDemo) {
            toggleLeftViewsShowing();
        }

        if (sayFlag)
            speakWithFormat("Navigator.STARTNAVIGATION");

        try {
            initFennec(fennecMediator.getDefaultFennecEntry(), false, sayFlag);
            currentFennecIdx = 1;
            if (sayFlag) {
                speakActiveItem(false, false, JumpMode.NONE);
            }
        } catch (Exception e) {
            // TODO Retry
            e.printStackTrace();
        }
        ManipulatorExtension.setNavigator(this);
        initializeMovieStartListener();
    }

    public void endNavigation() {
        // TODO
        ManipulatorExtension.disposeExtensions();
    }

    // --------------------------------------------------------------------------------
    // Media Control
    // --------------------------------------------------------------------------------

    private ISoundControl prepareSoundControl() throws TreeManagerException {
        ISoundControl sc = treeManager.getSoundControl();
        if (sc.getCount() == 0) {
            // say("Retry to control sound");
            treeManager.analyze();
            sc = treeManager.getSoundControl();
        }
        return sc;
    }

    private IVideoControl prepareVideoControl() throws TreeManagerException {
        IVideoControl vc = treeManager.getVideoControl();
        if (vc.getCount() == 0) {
            // say("Retry to control video");
            treeManager.analyze();
            vc = treeManager.getVideoControl();
        }
        return vc;
    }

    public void muteMedia() {
        ISoundControl sc;
        try {
            sc = prepareSoundControl();
        } catch (TreeManagerException e) {
            return;
        }
        if (sc == null)
            return;
        if (sc.getCount() == 0) {
            speakWithFormat("Navigator.NOSOUND", true);
            return;
        }
        sc.muteMedia();
        if (sc.getVolumeState() == VolumeState.MUTE) {
            speakWithFormat("Navigator.MUTEON", true);
        } else {
            speakWithFormat("Navigator.MUTEOFF", true);
        }
    }

    public void volumeDownMedia() {
        ISoundControl sc;
        try {
            sc = prepareSoundControl();
        } catch (TreeManagerException e) {
            return;
        }
        if (sc == null)
            return;
        if (sc.getCount() == 0) {
            speakWithFormat("Navigator.NOSOUND", true);
            return;
        }
        sc.volumeDownMedia();
        if (sc.getVolumeState() == VolumeState.MIN || sc.getVolumeState() == VolumeState.MUTE) {
            speakWithFormat("Navigator.VOLUMEMIN", true);
        } else {
            speakWithFormat("Navigator.VOLUMEDOWN", true);
        }
    }

    public void minimalVolumeDownMedia() {
        ISoundControl sc;
        try {
            sc = prepareSoundControl();
        } catch (TreeManagerException e) {
            return;
        }
        if (sc == null)
            return;
        if (sc.getCount() == 0) {
            speakWithFormat("Navigator.NOSOUND", true);
            return;
        }
        sc.minimalVolumeDownMedia();
        if (sc.getVolumeState() == VolumeState.MIN || sc.getVolumeState() == VolumeState.MUTE) {
            speakWithFormat("Navigator.VOLUMEMIN", true);
        } else {
            speakWithFormat("Navigator.VOLUMEDOWN", true);
        }
    }

    public void volumeUpMedia() {
        ISoundControl sc;
        try {
            sc = prepareSoundControl();
        } catch (TreeManagerException e) {
            return;
        }
        if (sc == null)
            return;
        if (sc.getCount() == 0) {
            speakWithFormat("Navigator.NOSOUND", true);
            return;
        }
        sc.volumeUpMedia();
        if (sc.getVolumeState() == VolumeState.MAX) {
            speakWithFormat("Navigator.VOLUMEMAX", true);
        } else {
            speakWithFormat("Navigator.VOLUMEUP", true);
        }
    }

    public void minimalVolumeUpMedia() {
        ISoundControl sc;
        try {
            sc = prepareSoundControl();
        } catch (TreeManagerException e) {
            return;
        }
        if (sc == null)
            return;
        if (sc.getCount() == 0) {
            speakWithFormat("Navigator.NOSOUND", true);
            return;
        }
        sc.minimalVolumeUpMedia();
        if (sc.getVolumeState() == VolumeState.MAX) {
            speakWithFormat("Navigator.VOLUMEMAX", true);
        } else {
            speakWithFormat("Navigator.VOLUMEUP", true);
        }
    }

    private void sayVideoState(IVideoControl vc, boolean doPause, VideoState oldSt) {
        VideoState st = vc.getVideoState();
        switch (st) {
        case STATE_PLAY:
            if (doPause) {
                if (oldSt == VideoState.STATE_PAUSE) {
                    speakWithFormat("Navigator.RESUMEMEDIA");
                } else if (oldSt == VideoState.STATE_PLAY) {
                    speakWithFormat("Navigator.CANNOT_PAUSE");
                }
            } else {
                speakWithFormat("Navigator.PLAYMEDIA");
            }
            break;
        case STATE_STOP:
            speakWithFormat("Navigator.STOPMEDIA");
            break;
        case STATE_PAUSE:
            speakWithFormat("Navigator.PAUSEMEDIA");
            break;
        case STATE_WAITING:
            speakWithFormat("Navigator.WAITINGMEDIA");
            break;
        case STATE_FASTFORWARD:
            speakWithFormat("Navigator.FASTFORWARDMEDIA");
            break;
        case STATE_FASTREVERSE:
            speakWithFormat("Navigator.FASTREVERSEMEDIA");
            break;
        case STATE_OTHER:
            speakWithFormat("Navigator.NOT_AVAILABEL");
            break;
        }
    }

    public void previousTrack() {
        // TODO Auto-generated method stub

    }

    public void nextTrack() {
        // TODO Auto-generated method stub

    }

    public void stopMedia() {
        try {
            IVideoControl vc = prepareVideoControl();
            VideoState st = vc.getVideoState();
            vc.stopMedia();
            sayVideoState(vc, false, st);
        } catch (TreeManagerException e) {
        }
    }

    public void playMedia() {
        try {
            IVideoControl vc = prepareVideoControl();
            VideoState st = vc.getVideoState();
            vc.playMedia();
            sayVideoState(vc, false, st);
        } catch (TreeManagerException e) {
        }
    }

    public void pauseMedia() {
        try {
            IVideoControl vc = prepareVideoControl();
            VideoState st = vc.getVideoState();
            vc.pauseMedia();
            sayVideoState(vc, true, st);
        } catch (TreeManagerException e) {
        }
    }

    public void fastReverse() {
        // TODO Auto-generated method stub

    }

    public void fastForward() {
        // TODO Auto-generated method stub

    }

    // --------------------------------------------------------------------------------
    // Tree Navigation
    // --------------------------------------------------------------------------------


    interface Command {
        int run(int retry) throws TreeManagerException;
        void after(int st) throws TreeManagerException;
    }
    
    private void afterMove(int st, String notMoved) throws TreeManagerException {
        afterMove(st, notMoved, null);
    }

    private void afterMove(int st, String notMoved, JumpMode jumpMode) throws TreeManagerException {
        if ((st & ITreeManager.CLICKED) != 0) {
            speakWithFormat("Navigator.CLICK");
        }
        else if ((st & ITreeManager.MOVED) != 0) {
            speakActiveItem(true, false, jumpMode);
            sayLevel();
        } else {
            sayLevel(notMoved);
        }
        speakAllMode = false;
    }

    private void moveCmd(Command cmd) {
        if (treeManager == null)
            return;
        for (int i = 0; i < maxRetry; i++) {
            try {
                int st = cmd.run(i);
                cmd.after(st);
                return;
            } catch (TreeManagerInterruptedException e) {
                sayRetrial();
                sleep(retryInterval);
            } catch (TreeManagerException e) {
            }
        }
        // navigationThread.sendCmd(cmd);
    }
    
    private boolean skipToAnchor(String url) throws TreeManagerException {
        int hashIdx = url.lastIndexOf('#');
        if (hashIdx < 0)
            return false;
        hashIdx++;
        if (hashIdx >= url.length())
            return false;
        String target = url.substring(hashIdx);
        treeManager.skipToAnchor(target);
        return true;
    }

    public void treeLeft() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoParent();
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.TOP");
            }
        });
    }

    public void treeRight() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoFirstChild();
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.NO_SUBITEMS");
            }
        });
    }

    public void treeUp() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoPreviousSibling();
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.TOP");
            }
        });
    }

    public void treeDown() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoNextSibling();
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.BOTTOM");
            }
        });
    }

    public void treeTop() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoStartOfPage();
            }

            public void after(int st) throws TreeManagerException {
                speakTab();
                listJumping = false;
                //afterMove(st, "Navigator.TOP");
            }
        });
    }

    public void treeBottom() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.gotoEndOfPage();
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.BOTTOM");
            }
        });
    }

    public void traverseNodeDown() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                int moved;
                int rFlag = 0;
                do {
                    moved = treeManager.traverse(false);
                    rFlag |= moved;
                } while (((moved & ITreeManager.LEVEL_CHANGED) == 0) && ((moved & ITreeManager.MOVED) != 0));
                return moved | rFlag;
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.BOTTOM");
            }
        });
    }

    public void traverseNodeUp() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                int moved;
                int rFlag = 0;
                do {
                    moved = treeManager.traverse(true);
                    rFlag |= moved;
                } while (((moved & ITreeManager.LEVEL_CHANGED) == 0) && ((moved & ITreeManager.MOVED) != 0));
                return moved | rFlag;
            }

            public void after(int st) throws TreeManagerException {
                afterMove(st, "Navigator.TOP");
            }
        });
    }

    public void traverseDown() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.traverse(false);
            }

            public void after(int st) throws TreeManagerException {
                if ((st & ITreeManager.MOVED) == 0) {
                    beep();
                    speak(getMessageFormatter().mes("Navigator.BOTTOM"), true, false);
                    speakActiveItem(false, false, JumpMode.NONE);
                } else {
                    afterMove(st, "Navigator.BOTTOM");
                }
            }
        });
    }

    public void traverseUp() {
        moveCmd(new Command() {
            public int run(int r) throws TreeManagerException {
                return treeManager.traverse(true);
            }

            public void after(int st) throws TreeManagerException {
                if ((st & ITreeManager.MOVED) == 0) {
                    beep();
                    speak(getMessageFormatter().mes("Navigator.TOP"), true, false);
                    speakTab(false);
                } else {
                    afterMove(st, "Navigator.TOP");
                }
            }
        });
    }

    public void click() {
        try {
            ITreeItem item = treeManager.getActiveItem();
            if (item == null)
                return;

            // for restoring the class name of the item
            item.unhighlight();

            if (Vocabulary.isFileEdit().eval(item) || //
                    Vocabulary.isCheckbox().eval(item) || //
                    Vocabulary.isRadio().eval(item) || //
                    !(Vocabulary.isInputable().eval(item) || Vocabulary.isSelectable().eval(item)) //
            ) {
                moveCmd(new Command() {
                    public int run(int r) throws TreeManagerException {
                        if (r == 0) {
                            return treeManager.click(true);
                        } else {
                            return treeManager.click(false);
                        }
                    }

                    public void after(int st) throws TreeManagerException {
                        afterMove(st, "Navigator.CLICK");
                    }
                });
                return;
            }

            if (false) {
                enterFormInputMode(item);
            } else {
                setMode(IManipulator.KEYHOOK_DISABLED_MODE);
                //item.setFocus();
                Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
                boolean combo = Vocabulary.isCombobox().eval(item);

                if (combo) {
                    boolean multiple = Vocabulary.isMultiSelectable().eval(item);
                    FormSelectDialog dialog = new FormSelectDialog(shell, item, multiple);

                    if (dialog.open() == InputDialog.OK) {
                        int[] indices = dialog.getSelectedIndices();
                        int total = dialog.getLength();
                        if (indices != null) {
                            item.setSelectedIndices(indices);
                            if (indices.length > 0) {
                                StringBuffer sb = new StringBuffer();
                                for (int i = 0; i < indices.length; i++) {
                                    String text = dialog.getTextAt(indices[i]);
                                    sb.append(text + " " + getMessageFormatter().mes("Navigator.N_OF_M", indices[i] + 1, total)
                                              + " ");
                                }
                                speak(sb.toString(), true);
                            } else {
                                speakWithFormat("Navigator.COMBO_BOX_NOSELECTION");
                            }
                        }
                    }
                } else {
                    boolean multiline = Vocabulary.isMultilineEdit().eval(item);
                    boolean pass = Vocabulary.isPassword().eval(item);
                    FormInputDialog dialog = new FormInputDialog(shell, item.getText(), multiline, pass);

                    if (dialog.open() == InputDialog.OK) {
                        String result = dialog.getResult();
                        if (result != null) {
                            item.setText(dialog.getResult());
                            if (pass) {
                                if (item.getText().length() > 0) {
                                    speakWithFormat(getMessageFormatter().mes("Navigator.PASSWORD_STAR3"));
                                }
                            } else {
                                speakWithFormat(item.getText());
                            }
                        }
                    }
                }
                //item.setFocus();
                setMode(IManipulator.TREE_NAVIGATION_MODE);
            }

            // for restoring the class name of the item
            item.highlight();
        } catch (TreeManagerException e) {
            e.printStackTrace();
        }
    }

    // --------------------------------------------------------------------------------
    // Skip Navigation
    // --------------------------------------------------------------------------------

    // Used by NavigatorImplExSub
    protected void findNext(final IProposition p, final JumpMode jumpMode) {
        moveCmd(new Command() {
            ILocation current;
            public int run(int r) throws TreeManagerException {
                startProgress();
                current = getLocation();
                return treeManager.findNext(p);
            }

            public void after(int st) throws TreeManagerException {
                if ((st & ITreeManager.MOVED) == 0) {
                    if (jumpMode != JumpMode.LISTITEM_TOP)
                        beep();
                    speak(getMessageFormatter().mes("Navigator.WRAPPING_TO_TOP"), true, false);
                    moveCmd(new Command() {
                        public int run(int r) throws TreeManagerException {
                            treeManager.gotoStartOfPage();
                            return treeManager.findNext(p);
                        }

                        public void after(int st) throws TreeManagerException {
                            if ((st & ITreeManager.MOVED) == 0)
                                treeManager.moveToLocation(current);
                            afterFind(st, jumpMode);
                            endProgress();
                        }
                    });
                } else {
                    afterMove(st, "Navigator.BOTTOM", jumpMode);
                    endProgress();
                }
            }
        });
    }

    private void afterFind(int st, JumpMode jumpMode) throws TreeManagerException {
        afterFind(st, jumpMode, null);
    }

    private void afterFind(int st, JumpMode jumpMode, Object arg) throws TreeManagerException {
        if ((st & ITreeManager.MOVED) != 0) {
            speakActiveItem(false, false, jumpMode);
        } else {
            String buf = "";
            if (jumpMode == JumpMode.HEADING)
                buf = getMessageFormatter().mes("Navigator.NO_HEADING");
            else if (jumpMode == JumpMode.BLOCK)
                buf = getMessageFormatter().mes("Navigator.NO_BLOCK");
            else if (jumpMode == JumpMode.INPUT)
                buf = getMessageFormatter().mes("Navigator.NO_INPUT");
            else if (jumpMode == JumpMode.LINK)
                buf = getMessageFormatter().mes("Navigator.NO_LINK");
            else if (jumpMode == JumpMode.LISTITEM_TOP || jumpMode == JumpMode.LISTITEM_BOTTOM)
                buf = getMessageFormatter().mes("Navigator.NO_LISTITEM");
            else if (jumpMode == JumpMode.OBJECT)
                buf = getMessageFormatter().mes("Navigator.NO_OBJECT");
            else if (jumpMode == JumpMode.MEDIA)
                buf = getMessageFormatter().mes("Navigator.NO_MEDIA");
            else if (jumpMode == JumpMode.ACCESSKEY)
                buf = getMessageFormatter().mes("Navigator.NO_ACCESSKEY", arg);
            else if (jumpMode == JumpMode.ALTALABLE)
                buf = getMessageFormatter().mes("Navigator.NO_ALTALABLE");
                

            speak(buf, true, false);
        }
        speakAllMode = false;
    }

    // Used by NavigatorImplExSub
    protected void findPrevious(final IProposition p, final JumpMode jumpMode) {
        moveCmd(new Command() {
            private ILocation current;
            public int run(int r) throws TreeManagerException {
                startProgress();
                current = getLocation();
                return treeManager.findPrevious(p);
            }

            public void after(int st) throws TreeManagerException {
                if ((st & ITreeManager.MOVED) == 0) {
                    if (jumpMode != JumpMode.LISTITEM_BOTTOM)
                        beep();
                    speak(getMessageFormatter().mes("Navigator.WRAPPING_TO_BOTTOM"), true, false);
                    moveCmd(new Command() {
                        public int run(int r) throws TreeManagerException {
                            treeManager.gotoEndOfPageForFind();
                            return treeManager.findPrevious(p);
                        }

                        public void after(int st) throws TreeManagerException {
                            if ((st & ITreeManager.MOVED) == 0)
                                treeManager.moveToLocation(current);
                            afterFind(st, jumpMode);
                            endProgress();
                        }
                    });
                } else {
                    afterMove(st, "Navigator.TOP", jumpMode);
                    endProgress();
                }
            }
        });
    }

    public void nextHeader() {
        findNext(Vocabulary.isHeading(), JumpMode.HEADING);
    }

    public void previousHeader() {
        findPrevious(Vocabulary.isHeading(), JumpMode.HEADING);
    }

    public void nextInputable() {
        findNext(Vocabulary.or(Vocabulary.isInputable(), Vocabulary.isSelectable()), JumpMode.INPUT);
    }

    public void previousInputable() {
        findPrevious(Vocabulary.or(Vocabulary.isInputable(), Vocabulary.isSelectable()), JumpMode.INPUT);
    }

    public void nextLink() {
        findNext(Vocabulary.or(Vocabulary.isClickable(), Vocabulary.isInputable(), Vocabulary.isSelectable()),
                JumpMode.LINK);
    }

    public void previousLink() {
        findPrevious(Vocabulary.or(Vocabulary.isClickable(), Vocabulary.isInputable(), Vocabulary.isSelectable()),
                JumpMode.LINK);
    }

    public void nextObject() {
        findNext(Vocabulary.isEmbeddedObject(), JumpMode.OBJECT);
    }

    public void previousObject() {
        findPrevious(Vocabulary.isEmbeddedObject(), JumpMode.OBJECT);
    }

    public void nextListItem() {
        findNext(Vocabulary.isListItem(), JumpMode.LISTITEM_TOP);
    }

    public void previousListItem() {
        findPrevious(Vocabulary.isListItem(), JumpMode.LISTITEM_BOTTOM);
    }

    public void nextBlock() {
        findNext(Vocabulary.isBlockJumpPointF(), JumpMode.BLOCK);
    }

    public void previousBlock() {
        findPrevious(Vocabulary.isBlockJumpPointB(), JumpMode.BLOCK);
    }

    public void nextMedia() {
        findNext(Vocabulary.isMedia(), JumpMode.MEDIA);
    }

    public void previousMedia() {
        findPrevious(Vocabulary.isMedia(), JumpMode.MEDIA);
    }

    public void nextHeader1() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading1()), JumpMode.HEADING);
    }

    public void nextHeader2() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading2()), JumpMode.HEADING);
    }

    public void nextHeader3() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading3()), JumpMode.HEADING);
    }

    public void nextHeader4() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading4()), JumpMode.HEADING);
    }

    public void nextHeader5() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading5()), JumpMode.HEADING);
    }

    public void nextHeader6() {
        findNext(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading6()), JumpMode.HEADING);
    }

    public void previousHeader1() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading1()), JumpMode.HEADING);
    }

    public void previousHeader2() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading2()), JumpMode.HEADING);
    }

    public void previousHeader3() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading3()), JumpMode.HEADING);
    }

    public void previousHeader4() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading4()), JumpMode.HEADING);
    }

    public void previousHeader5() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading5()), JumpMode.HEADING);
    }

    public void previousHeader6() {
        findPrevious(Vocabulary.and(Vocabulary.isHeading(), Vocabulary.isHeading6()), JumpMode.HEADING);
    }
    
    public void jumpToAccessKey(final char key) {
        moveCmd(new Command() {
            ILocation current;
            public int run(int r) throws TreeManagerException {
                startProgress();
                current = getLocation();
                return treeManager.findNext(Vocabulary.isAccessKey(key));
            }

            public void after(int st) throws TreeManagerException {
                if ((st & ITreeManager.MOVED) == 0) {
                    moveCmd(new Command() {
                        public int run(int r) throws TreeManagerException {
                            treeManager.gotoStartOfPage();
                            return treeManager.findNext(Vocabulary.isAccessKey(key));
                        }

                        public void after(int st) throws TreeManagerException {
                            if ((st & ITreeManager.MOVED) == 0){
                                treeManager.moveToLocation(current);
                                afterFind(st, JumpMode.ACCESSKEY, key);
                            }
                            else
                                afterAccessKeyJump(st);
                            endProgress();
                        }
                    });
                } else {
                    afterAccessKeyJump(st);
                    endProgress();
                }
            }
        });
    }

    private void afterAccessKeyJump(int st) throws TreeManagerException {
        ITreeItem item = treeManager.getActiveItem();

        boolean isCheckbox = Vocabulary.isCheckbox().eval(item);
        boolean isRadio = Vocabulary.isRadio().eval(item);

        if (isRadio || isCheckbox) {
            click();
            speakActiveItem(true, false, JumpMode.NONE);
        } else {
            afterMove(st, "Navigator.BOTTOM", JumpMode.ACCESSKEY);
        }
    }

    public void showAccessKeyList() {
        try {
            setMode(IManipulator.KEYHOOK_DISABLED_MODE);
            IAccessKeyList list = treeManager.getAccessKeyList();
            Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();

            AccessKeyListDialog dialog = new AccessKeyListDialog(shell, list);

            if (dialog.open() == InputDialog.OK) {
                char key = dialog.getSelectedKey();
                if (key != 0)
                    jumpToAccessKey(key);
            }
            setMode(IManipulator.TREE_NAVIGATION_MODE);
        } catch (TreeManagerException e) {
            e.printStackTrace();
        }
    }
    

    public void searchNext() {
        Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
        SearchDialog dialog = new SearchDialog(shell);
        dialog.setForward(true);
        if (dialog.open() == Window.CANCEL || dialog.getString() == null || dialog.getString().length() == 0)
            return;

        moveCmd(new FindCommand(dialog.getString(), dialog.isForward(), dialog.isExact()));
    }

    public void searchPrevious() {
        Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
        SearchDialog dialog = new SearchDialog(shell);
        dialog.setForward(false);
        if (dialog.open() == Window.CANCEL || dialog.getString() == null || dialog.getString().length() == 0)
            return;

        moveCmd(new FindCommand(dialog.getString(), dialog.isForward(), dialog.isExact()));
    }

    class FindCommand implements Command {
        private String str;

        private boolean direction;

        private boolean exact;

        FindCommand(String str, boolean direction, boolean exact) {
            this.str = str;
            this.direction = direction;
            this.exact = exact;
        }

        public int run(int r) throws TreeManagerException {
            if (direction)
                return treeManager.findNext(Vocabulary.find(str, exact));
            else
                return treeManager.findPrevious(Vocabulary.find(str, exact));
        }

        public void after(int st) throws TreeManagerException {
            if (direction)
                afterMove(st, "Navigator.BOTTOM");
            else
                afterMove(st, "Navigator.TOP");
        }
    }

    // --------------------------------------------------------------------------------
    // Table Navigation
    // --------------------------------------------------------------------------------

    public void cellLeft() {
        // TODO Auto-generated method stub

    }

    public void cellRight() {
        // TODO Auto-generated method stub

    }

    public void cellUp() {
        // TODO Auto-generated method stub

    }

    public void cellDown() {
        // TODO Auto-generated method stub

    }

    // --------------------------------------------------------------------------------
    // Speech Speed Control
    // --------------------------------------------------------------------------------

    private void saySpeechSpeed(int speed) {
        String mes = getMessageFormatter().mes("Navigator.SPEECHSPEED",
                                          new Object[] { new Integer(speed) });
        speakWithFormat(mes, true);
    }

    public void speechSpeedUp() {
        int nextSpeed = getVoiceManager().getSpeed() + 10;
        if (IVoice.SPEED_MAX < nextSpeed) {
            speakWithFormat("Navigator.SPEECHSPEEDMAX", true);
        } else {
            getVoiceManager().setSpeed(nextSpeed);
            saySpeechSpeed(nextSpeed);
        }
    }

    public void speechSpeedDown() {
        int nextSpeed = getVoiceManager().getSpeed() - 10;
        if (IVoice.SPEED_MIN > nextSpeed) {
            speakWithFormat("Navigator.SPEECHSPEEDMIN", true);
        } else {
            getVoiceManager().setSpeed(nextSpeed);
            saySpeechSpeed(nextSpeed);
        }
    }

    // --------------------------------------------------------------------------------
    // Form input mode.
    // --------------------------------------------------------------------------------

    public void exitFormMode() {
        setMode(IManipulator.TREE_NAVIGATION_MODE);
    }

    public void submitForm() {
        // TODO Auto-generated method stub
    }


    // --------------------------------------------------------------------------------
    // Location Management
    // --------------------------------------------------------------------------------

    public ILocation getLocation() {
        if (treeManager == null)
            return null;
        try {
            return treeManager.getCurrentLocation();
        } catch (TreeManagerException e) {
            return null;
        }
    }

    private ILocation locationToBeRestored;

    public void restoreLocation(ILocation location) {
        locationToBeRestored = location;
    }

    // --------------------------------------------------------------------------------
    // IMediaControl.IHandle delegation class
    // --------------------------------------------------------------------------------
    private class MediaControlHandle implements IMediaControl.IHandle {
        public ISoundControl getSoundControl() {
            if (treeManager == null)
                return null;
            try {
                return treeManager.getSoundControl();
            } catch (TreeManagerException e) {
                return null;
            }
        }

        public IVideoControl getVideoControl() {
            if (treeManager == null)
                return null;
            try {
                return treeManager.getVideoControl();
            } catch (TreeManagerException e) {
                return null;
            }
        }

        public IVoice getVoice() {
            return NavigatorImpl.this.getVoiceManager();
        }

        public IWebBrowserACTF getWebBrowser() {
            return webBrowser;
        }
    }

    private MediaControlHandle handle = new MediaControlHandle();

    IMediaControl.IHandle getMediaControlHandle() {
        return handle;
    }

    public void toggleDescriptionEnable() {
        int result = MediaControlExtension.toggleEnable();
        switch (result) {
        case IMediaControl.TOGGLE_FAIL:
            speakWithFormat("AudioDescription.noExtension");
            break;
        case IMediaControl.STATUS_ON:
            speakWithFormat("AudioDescription.on");
            break;
        case IMediaControl.STATUS_OFF:
            speakWithFormat("AudioDescription.off");
            break;
        case IMediaControl.STATUS_NOT_AVAILABLE:
            speakWithFormat("AudioDescription.notAvailable");
            break;
        }
    }

    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TODO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    MovieStartListener listener = null;

    private void initializeMovieStartListener() {
        IHandle mediaControlHandle = getMediaControlHandle();
        final IVideoControl video = mediaControlHandle.getVideoControl();
        if (listener != null) {
            listener.stop();
        }
        listener = new MovieStartListener(video);
        if (video != null) {
            video.addEventListener(listener);
        }
    }

    class MovieStartListener implements IMediaSyncEventListener {
        IVideoControl video;

        public MovieStartListener(IVideoControl video) {
            this.video = video;
        }

        private boolean stopFlag = false;

        public void stop() {
            stopFlag = true;
        }

        public double getInterval() {
            return 0.1;
        }

        private boolean topFlag = true;

        public void run() {
            if (stopFlag)
                return;
            double time = video.getCurrentPosition();
            if (topFlag) {
                // Heuristic solution.
                // "stop" operation might locates nearly 0.001?. 0.1 avoids this situnation.
                // 3.0 is a sentinel for waiting the completion of reloading and analyzing page content.
                if (0.1 < time && time < 3.0) {
                    speakWithFormat("Navigator.MOVIE_START");
                    topFlag = false;
                }
            } else {
                if (time < 0.1) {
                    topFlag = true;
                }
            }
        }
    }

    // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! TODO !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

    public enum FocusTabResult {
        STAY, CHANGED, NOTFOUND
    }

    public FocusTabResult focusTab() {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorReference[] erefs = page.getEditorReferences();
        IEditorPart editor = page.getActiveEditor();

        for (int i = 0; i < erefs.length; i++) {
            IEditorPart part = erefs[i].getEditor(false);
            IModelServiceHolder modelServiceHolder = (IModelServiceHolder) part;
            IWebBrowserACTF wb = (IWebBrowserACTF) modelServiceHolder.getModelService();
            if (wb == webBrowser) {
                if (editor != part) {
                    page.activate(part);
                    return FocusTabResult.CHANGED;
                }
                return FocusTabResult.STAY;
            }
        }
        return FocusTabResult.NOTFOUND;
    }

    public boolean isFocused() {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorReference[] erefs = page.getEditorReferences();
        IEditorPart editor = page.getActiveEditor();

        for (int i = 0; i < erefs.length; i++) {
            IEditorPart part = erefs[i].getEditor(false);
            IModelServiceHolder modelServiceHolder = (IModelServiceHolder) part;
            IWebBrowserACTF wb = (IWebBrowserACTF) modelServiceHolder.getModelService();
            if (wb == webBrowser) {
                if (editor != part) {
                    return false;
                }
                return true;
            }
        }
        // Should be regarded as an error.
        System.err.println("Internal Error: WebBrowser:" + webBrowser + " is not managed in the editor");
        return false;
    }

    public String getCurrentURL() {
        return webBrowser.getURL();
    }

    // ----------------------------------------------------------------
    // Browser Control 
    // ----------------------------------------------------------------

    public void enterBrowserAddress() {
        if (PlatformUIUtil.getActiveEditor() == null) {
            speakWithFormat("Navigator.THERE_ARE_NO_TAB");
            return;
        }
        
        webBrowser.setFocusAddressText(true);
        speakWithFormat("Navigator.ENTERBROWSERADDRESS", false);
        enterFormInputMode();
    }
    
    public void forceRestart(boolean flush) {
        selectFennec(false, flush);
        
        // TODO
        MediaControlExtension.doDispose(getMediaControlHandle());
        MediaControlExtension.start(getMediaControlHandle());
        initializeMovieStartListener();
    }

    public void forceRestart() {
        forceRestart(true);
    }
    
    public void navigateRefresh() {
        startProgress();
        String buf = getMessageFormatter().mes("Navigator.REFRESH");
        speak(buf, true, false);
        webBrowser.navigateRefresh();
    }

    public void closeTab() {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorPart editor = page.getActiveEditor();

        if (editor != null && editor instanceof IModelServiceHolder) {
            ManipulatorExtension.setNavigator(null);
            page.closeEditor(editor, false);
        }
    }

    public void nextTab() {
        gotoTab(1);
    }

    public void prevTab() {
        gotoTab(-1);
    }

    private void gotoTab(int n) {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        IWorkbenchPage page = window.getActivePage();
        IEditorReference[] erefs = page.getEditorReferences();
        IEditorPart editor = page.getActiveEditor();

        for (int i = 0; i < erefs.length; i++) {
            if (erefs[i].getEditor(false).equals(editor)) {
                n += i;

                IEditorPart part;
                if (n >= erefs.length) {
                    part = erefs[0].getEditor(false);
                } else if (n < 0) {
                    part = erefs[erefs.length - 1].getEditor(false);
                } else {
                    part = erefs[n].getEditor(false);
                }
                if (part != null) {
                    page.activate(part);
                }
            }
        }
        speakTab();
    }


    public void goBackward() {
        webBrowser.goBackward();
    }

    public void goForward() {
        webBrowser.goForward();
    }

    // It is used by the bridge.
    public boolean gotoUrl(String url) {
        webBrowser.navigate(url);
        return true;
    }
    
    public void launchBrowser() {
        BrowserLaunch.launch(webBrowser.getURL());
        String buf = getMessageFormatter().mes("Navigator.LAUNCH_DEFAULT_BROWSER", webBrowser.getURL());
        speak(buf, true, false);
    }

    public boolean isLeftViewsShown() {
        return getNavigatorTreeView().isShown();
    }

    public void toggleLeftViewsShowing() {
        boolean result = getNavigatorTreeView().toggleViewShowing();
        boolean result2 = MediaControlExtension.toggleViewShowing();
        while (result != result2)
            result2 = MediaControlExtension.toggleViewShowing();

        if (result)
            speakWithFormat("Navigator.VIEWS_ARE_OPEND", true);
        else
            speakWithFormat("Navigator.VIEWS_ARE_CLOSED", true);
    }
    
    public void exportMetadata() {
        if (getCurrentEntry() == null) {
            speakWithFormat("Navigator.NO_ANNOTATION");
            return;
        }
        
        String[] ext = { "*.fnc" };
        speakWithFormat("Navigator.EXPORT_ANNOTATION");
        Shell shell = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell();
        FileDialog fileDialog = new FileDialog(shell, SWT.OPEN);
        fileDialog.setFilterExtensions(ext);
        String path = fileDialog.open();

        if (path != null) {
            if (!path.endsWith(".fnc")) {
                path = path+".fnc";
            }
            File dest = new File(path);
            if (dest.exists()) {
                String title = getMessageFormatter().mes("Navigator.OVERWRITE_CONFIRM");
                String message = getMessageFormatter().mes("Navigator.OVERWRITE_MESSAGE", dest.getName());
                boolean ret = MessageDialog.openQuestion(shell, title, message);
                if (!ret)
                    return;
            }
            if (getCurrentEntry().isUserEntry()) {
                if (getCurrentEntry().export(dest)) {
                    speakWithFormat("Navigator.EXPORT_IS_SUCCEEDED");
                } else {
                    speakWithFormat("Navigator.EXPORT_IS_FAILED");
                }
            }
        }
    }
    
    public void repairFlash() {
        startProgress(0);
        try {
            treeManager.repairFlash();
            speakWithFormat("Navigator.REPAIR_FINISHED");
            restoreLocation(getLocation());
            selectFennec(false, false, false);
        } catch (TreeManagerException e) {
            e.printStackTrace();
        }
        endProgress();
    }
    
    // ---------------------------------------------------------------
    // Web Event
    // ---------------------------------------------------------------
    
    public void speakTitle(String title) {
        try {
           speak(title, true, true);
        } catch (Exception e) {
        }
    }
    
    public void speakTab() {
        speakTab(true);
    }

    public void speakOpenTab() {
        speakWithFormat(getMessageFormatter().mes("Navigator.NEW_TAB"));
    }

    public void navigateComplete() {
        startProgress();
    }

    public void speakCloseTab(String title) {
        speak(getMessageFormatter().mes("Navigator.CLOSE_TAB", title), true, true);
    }

    private long progressTimer = 0;

    private static final int progressInterval = 2000;

    private int prevPercent = -4;

    void beforeNavigation(String uri) {
        prevPercent = -4;
    }

    void progressChange(int progress, int progressMax) {
        if (progressMax == 0)
            return;
        if (progress == -1) {
            progressTimer = 0;
            return;
        }
        long current = System.currentTimeMillis();

        if (current - progressTimer > progressInterval * 5) {
            prevPercent = -4;
        }

        if (progressMax < 10000) {
            progressMax = 1000;
        }
        progressMax = (int) Math.pow(10, ((int) Math.log10(progressMax)) + 1);

        int percent = (progress * 100) / progressMax;
        if (progress * 10 == progressMax) {
            percent = 100;
        }

        if ((progressTimer == 0) || ((current - progressTimer) >= progressInterval)) {
            if (5 < percent && percent < 100) {
                if (percent - prevPercent >= 5 || (prevPercent - percent > 10)) { // && prevPercent - percent < 50)) {
                    sayProgress(percent);

                    // System.out.println("Say " + percent);
                    prevPercent = percent;
                    progressTimer = current;
                }
            }
        }
        // System.out.println(progress + " / " + progressMax + ", " + percent + ", " + prevPercent);
    }

    private void sayProgress(int percent) {
        if (percent < 0)
            percent = 0;
        else if (percent > 100)
            percent = 100;
        String mes = getMessageFormatter().mes("Navigator.PROGRESS", new Object[] { new Integer(percent) });
        speak(mes, true, true);
    }
}