| /******************************************************************************* |
| * Copyright (c) 2003, 2012 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| package org.eclipse.swt.browser; |
| |
| import java.util.*; |
| |
| import org.eclipse.swt.*; |
| import org.eclipse.swt.widgets.*; |
| |
| abstract class WebBrowser { |
| Browser browser; |
| Hashtable functions = new Hashtable (); |
| AuthenticationListener[] authenticationListeners = new AuthenticationListener[0]; |
| CloseWindowListener[] closeWindowListeners = new CloseWindowListener[0]; |
| LocationListener[] locationListeners = new LocationListener[0]; |
| OpenWindowListener[] openWindowListeners = new OpenWindowListener[0]; |
| ProgressListener[] progressListeners = new ProgressListener[0]; |
| StatusTextListener[] statusTextListeners = new StatusTextListener[0]; |
| TitleListener[] titleListeners = new TitleListener[0]; |
| VisibilityWindowListener[] visibilityWindowListeners = new VisibilityWindowListener[0]; |
| boolean jsEnabledOnNextPage = true, jsEnabled = true; |
| int nextFunctionIndex = 1; |
| Object evaluateResult; |
| |
| static final String ERROR_ID = "org.eclipse.swt.browser.error"; // $NON-NLS-1$ |
| static final String EXECUTE_ID = "SWTExecuteTemporaryFunction"; // $NON-NLS-1$ |
| |
| static Vector NativePendingCookies = new Vector (); |
| static Vector MozillaPendingCookies = new Vector (); |
| static String CookieName, CookieValue, CookieUrl; |
| static boolean CookieResult; |
| static Runnable MozillaClearSessions, NativeClearSessions; |
| static Runnable MozillaGetCookie, NativeGetCookie; |
| static Runnable MozillaSetCookie, NativeSetCookie; |
| |
| /* Key Mappings */ |
| static final int [][] KeyTable = { |
| /* Keyboard and Mouse Masks */ |
| {18, SWT.ALT}, |
| {16, SWT.SHIFT}, |
| {17, SWT.CONTROL}, |
| {224, SWT.COMMAND}, |
| |
| /* Literal Keys */ |
| {65, 'a'}, |
| {66, 'b'}, |
| {67, 'c'}, |
| {68, 'd'}, |
| {69, 'e'}, |
| {70, 'f'}, |
| {71, 'g'}, |
| {72, 'h'}, |
| {73, 'i'}, |
| {74, 'j'}, |
| {75, 'k'}, |
| {76, 'l'}, |
| {77, 'm'}, |
| {78, 'n'}, |
| {79, 'o'}, |
| {80, 'p'}, |
| {81, 'q'}, |
| {82, 'r'}, |
| {83, 's'}, |
| {84, 't'}, |
| {85, 'u'}, |
| {86, 'v'}, |
| {87, 'w'}, |
| {88, 'x'}, |
| {89, 'y'}, |
| {90, 'z'}, |
| {48, '0'}, |
| {49, '1'}, |
| {50, '2'}, |
| {51, '3'}, |
| {52, '4'}, |
| {53, '5'}, |
| {54, '6'}, |
| {55, '7'}, |
| {56, '8'}, |
| {57, '9'}, |
| {32, ' '}, |
| {59, ';'}, |
| {61, '='}, |
| {188, ','}, |
| {190, '.'}, |
| {191, '/'}, |
| {219, '['}, |
| {221, ']'}, |
| {222, '\''}, |
| {192, '`'}, |
| {220, '\\'}, |
| {108, '|'}, |
| |
| /* Non-Numeric Keypad Keys */ |
| {37, SWT.ARROW_LEFT}, |
| {39, SWT.ARROW_RIGHT}, |
| {38, SWT.ARROW_UP}, |
| {40, SWT.ARROW_DOWN}, |
| {45, SWT.INSERT}, |
| {36, SWT.HOME}, |
| {35, SWT.END}, |
| {46, SWT.DEL}, |
| {33, SWT.PAGE_UP}, |
| {34, SWT.PAGE_DOWN}, |
| |
| /* Virtual and Ascii Keys */ |
| {8, SWT.BS}, |
| {13, SWT.CR}, |
| {9, SWT.TAB}, |
| {27, SWT.ESC}, |
| {12, SWT.DEL}, |
| |
| /* Functions Keys */ |
| {112, SWT.F1}, |
| {113, SWT.F2}, |
| {114, SWT.F3}, |
| {115, SWT.F4}, |
| {116, SWT.F5}, |
| {117, SWT.F6}, |
| {118, SWT.F7}, |
| {119, SWT.F8}, |
| {120, SWT.F9}, |
| {121, SWT.F10}, |
| {122, SWT.F11}, |
| {123, SWT.F12}, |
| {124, SWT.F13}, |
| {125, SWT.F14}, |
| {126, SWT.F15}, |
| {127, 0}, |
| {128, 0}, |
| {129, 0}, |
| {130, 0}, |
| {131, 0}, |
| {132, 0}, |
| {133, 0}, |
| {134, 0}, |
| {135, 0}, |
| |
| /* Numeric Keypad Keys */ |
| {96, SWT.KEYPAD_0}, |
| {97, SWT.KEYPAD_1}, |
| {98, SWT.KEYPAD_2}, |
| {99, SWT.KEYPAD_3}, |
| {100, SWT.KEYPAD_4}, |
| {101, SWT.KEYPAD_5}, |
| {102, SWT.KEYPAD_6}, |
| {103, SWT.KEYPAD_7}, |
| {104, SWT.KEYPAD_8}, |
| {105, SWT.KEYPAD_9}, |
| {14, SWT.KEYPAD_CR}, |
| {107, SWT.KEYPAD_ADD}, |
| {109, SWT.KEYPAD_SUBTRACT}, |
| {106, SWT.KEYPAD_MULTIPLY}, |
| {111, SWT.KEYPAD_DIVIDE}, |
| {110, SWT.KEYPAD_DECIMAL}, |
| |
| /* Other keys */ |
| {20, SWT.CAPS_LOCK}, |
| {144, SWT.NUM_LOCK}, |
| {145, SWT.SCROLL_LOCK}, |
| {44, SWT.PRINT_SCREEN}, |
| {6, SWT.HELP}, |
| {19, SWT.PAUSE}, |
| {3, SWT.BREAK}, |
| |
| /* WebKit-specific */ |
| {186, ';'}, |
| {187, '='}, |
| {189, '-'}, |
| }; |
| |
| public class EvaluateFunction extends BrowserFunction { |
| public EvaluateFunction (Browser browser, String name) { |
| super (browser, name, true, new String[0], false); |
| } |
| public Object function (Object[] arguments) { |
| if (arguments[0] instanceof String) { |
| String string = (String)arguments[0]; |
| if (string.startsWith (ERROR_ID)) { |
| String errorString = ExtractError (string); |
| if (errorString.length () > 0) { |
| evaluateResult = new SWTException (SWT.ERROR_FAILED_EVALUATE, errorString); |
| } else { |
| evaluateResult = new SWTException (SWT.ERROR_FAILED_EVALUATE); |
| } |
| return null; |
| } |
| } |
| evaluateResult = arguments[0]; |
| return null; |
| } |
| } |
| |
| public void addAuthenticationListener (AuthenticationListener listener) { |
| AuthenticationListener[] newAuthenticationListeners = new AuthenticationListener[authenticationListeners.length + 1]; |
| System.arraycopy(authenticationListeners, 0, newAuthenticationListeners, 0, authenticationListeners.length); |
| authenticationListeners = newAuthenticationListeners; |
| authenticationListeners[authenticationListeners.length - 1] = listener; |
| } |
| |
| public void addCloseWindowListener (CloseWindowListener listener) { |
| CloseWindowListener[] newCloseWindowListeners = new CloseWindowListener[closeWindowListeners.length + 1]; |
| System.arraycopy(closeWindowListeners, 0, newCloseWindowListeners, 0, closeWindowListeners.length); |
| closeWindowListeners = newCloseWindowListeners; |
| closeWindowListeners[closeWindowListeners.length - 1] = listener; |
| } |
| |
| public void addLocationListener (LocationListener listener) { |
| LocationListener[] newLocationListeners = new LocationListener[locationListeners.length + 1]; |
| System.arraycopy(locationListeners, 0, newLocationListeners, 0, locationListeners.length); |
| locationListeners = newLocationListeners; |
| locationListeners[locationListeners.length - 1] = listener; |
| } |
| |
| public void addOpenWindowListener (OpenWindowListener listener) { |
| OpenWindowListener[] newOpenWindowListeners = new OpenWindowListener[openWindowListeners.length + 1]; |
| System.arraycopy(openWindowListeners, 0, newOpenWindowListeners, 0, openWindowListeners.length); |
| openWindowListeners = newOpenWindowListeners; |
| openWindowListeners[openWindowListeners.length - 1] = listener; |
| } |
| |
| public void addProgressListener (ProgressListener listener) { |
| ProgressListener[] newProgressListeners = new ProgressListener[progressListeners.length + 1]; |
| System.arraycopy(progressListeners, 0, newProgressListeners, 0, progressListeners.length); |
| progressListeners = newProgressListeners; |
| progressListeners[progressListeners.length - 1] = listener; |
| } |
| |
| public void addStatusTextListener (StatusTextListener listener) { |
| StatusTextListener[] newStatusTextListeners = new StatusTextListener[statusTextListeners.length + 1]; |
| System.arraycopy(statusTextListeners, 0, newStatusTextListeners, 0, statusTextListeners.length); |
| statusTextListeners = newStatusTextListeners; |
| statusTextListeners[statusTextListeners.length - 1] = listener; |
| } |
| |
| public void addTitleListener (TitleListener listener) { |
| TitleListener[] newTitleListeners = new TitleListener[titleListeners.length + 1]; |
| System.arraycopy(titleListeners, 0, newTitleListeners, 0, titleListeners.length); |
| titleListeners = newTitleListeners; |
| titleListeners[titleListeners.length - 1] = listener; |
| } |
| |
| public void addVisibilityWindowListener (VisibilityWindowListener listener) { |
| VisibilityWindowListener[] newVisibilityWindowListeners = new VisibilityWindowListener[visibilityWindowListeners.length + 1]; |
| System.arraycopy(visibilityWindowListeners, 0, newVisibilityWindowListeners, 0, visibilityWindowListeners.length); |
| visibilityWindowListeners = newVisibilityWindowListeners; |
| visibilityWindowListeners[visibilityWindowListeners.length - 1] = listener; |
| } |
| |
| public abstract boolean back (); |
| |
| public static void clearSessions () { |
| if (NativeClearSessions != null) NativeClearSessions.run (); |
| if (MozillaClearSessions != null) MozillaClearSessions.run (); |
| } |
| |
| public static String GetCookie (String name, String url) { |
| CookieName = name; CookieUrl = url; CookieValue = null; |
| if (NativeGetCookie != null) NativeGetCookie.run (); |
| if (CookieValue == null && MozillaGetCookie != null) MozillaGetCookie.run (); |
| String result = CookieValue; |
| CookieName = CookieValue = CookieUrl = null; |
| return result; |
| } |
| |
| public static boolean SetCookie (String value, String url, boolean addToPending) { |
| CookieValue = value; CookieUrl = url; |
| CookieResult = false; |
| if (NativeSetCookie != null) { |
| NativeSetCookie.run (); |
| } else { |
| if (addToPending && NativePendingCookies != null) { |
| NativePendingCookies.add (new String[] {value, url}); |
| } |
| } |
| if (MozillaSetCookie != null) { |
| MozillaSetCookie.run (); |
| } else { |
| if (addToPending && MozillaPendingCookies != null) { |
| MozillaPendingCookies.add (new String[] {value, url}); |
| } |
| } |
| CookieValue = CookieUrl = null; |
| return CookieResult; |
| } |
| |
| static void SetPendingCookies (Vector pendingCookies) { |
| Enumeration elements = pendingCookies.elements (); |
| while (elements.hasMoreElements ()) { |
| String[] current = (String[])elements.nextElement (); |
| SetCookie (current[0], current[1], false); |
| } |
| } |
| |
| public abstract void create (Composite parent, int style); |
| |
| static String CreateErrorString (String error) { |
| return ERROR_ID + error; |
| } |
| |
| static String ExtractError (String error) { |
| return error.substring (ERROR_ID.length ()); |
| } |
| |
| public boolean close () { |
| return true; |
| } |
| |
| public void createFunction (BrowserFunction function) { |
| /* |
| * If an existing function with the same name is found then |
| * remove it so that it is not recreated on subsequent pages |
| * (the new function overwrites the old one). |
| */ |
| Enumeration keys = functions.keys (); |
| while (keys.hasMoreElements ()) { |
| Object key = keys.nextElement (); |
| BrowserFunction current = (BrowserFunction)functions.get (key); |
| if (current.name.equals (function.name)) { |
| deregisterFunction (current); |
| break; |
| } |
| } |
| |
| function.index = getNextFunctionIndex (); |
| registerFunction (function); |
| |
| StringBuffer functionBuffer = new StringBuffer (function.name); |
| functionBuffer.append (" = function "); //$NON-NLS-1$ |
| functionBuffer.append (function.name); |
| functionBuffer.append ("() {var result = callJava("); //$NON-NLS-1$ |
| functionBuffer.append (function.index); |
| functionBuffer.append (",'"); //$NON-NLS-1$ |
| functionBuffer.append (function.token); |
| functionBuffer.append ("',Array.prototype.slice.call(arguments)); if (typeof result == 'string' && result.indexOf('"); //$NON-NLS-1$ |
| functionBuffer.append (ERROR_ID); |
| functionBuffer.append ("') == 0) {var error = new Error(result.substring("); //$NON-NLS-1$ |
| functionBuffer.append (ERROR_ID.length ()); |
| functionBuffer.append (")); throw error;} return result;};"); //$NON-NLS-1$ |
| |
| StringBuffer buffer = new StringBuffer ("if (!window.callJava) {window.callJava = function callJava(index, token, args) {"); //$NON-NLS-1$ |
| buffer.append ("return external.callJava(index,token,args);}};"); //$NON-NLS-1$ |
| if (function.top) { |
| buffer.append (functionBuffer.toString ()); |
| } |
| |
| buffer.append ("var frameIds = null;"); //$NON-NLS-1$ |
| if (function.frameNames != null) { |
| buffer.append ("frameIds = {"); //$NON-NLS-1$ |
| for (int i = 0; i < function.frameNames.length; i++) { |
| buffer.append ('\''); |
| buffer.append (function.frameNames[i]); |
| buffer.append ("':1,"); //$NON-NLS-1$ |
| } |
| if (function.frameNames.length > 0) { |
| buffer.deleteCharAt(buffer.length () - 1); |
| } |
| buffer.append ("};"); //$NON-NLS-1$ |
| } |
| |
| buffer.append ("for (var i = 0; i < frames.length; i++) {try {if (!frameIds || (frames[i].name && frameIds[frames[i].name])) {"); //$NON-NLS-1$ |
| buffer.append ("if (!frames[i].callJava) {frames[i].callJava = window.callJava;} frames[i]."); //$NON-NLS-1$ |
| buffer.append (functionBuffer.toString ()); |
| buffer.append ("}} catch(e) {}};"); //$NON-NLS-1$ |
| |
| function.functionString = buffer.toString (); |
| execute (function.functionString); |
| } |
| |
| void deregisterFunction (BrowserFunction function) { |
| functions.remove (new Integer (function.index)); |
| } |
| |
| public void destroyFunction (BrowserFunction function) { |
| String deleteString = getDeleteFunctionString (function.name); |
| StringBuffer buffer = new StringBuffer ("for (var i = 0; i < frames.length; i++) {try {frames[i].eval(\""); //$NON-NLS-1$ |
| buffer.append (deleteString); |
| buffer.append ("\");} catch (e) {}}"); //$NON-NLS-1$ |
| execute (buffer.toString ()); |
| execute (deleteString); |
| deregisterFunction (function); |
| } |
| |
| public abstract boolean execute (String script); |
| |
| public Object evaluate (String script) throws SWTException { |
| BrowserFunction function = new EvaluateFunction (browser, ""); // $NON-NLS-1$ |
| int index = getNextFunctionIndex (); |
| function.index = index; |
| function.isEvaluate = true; |
| registerFunction (function); |
| String functionName = EXECUTE_ID + index; |
| |
| StringBuffer buffer = new StringBuffer ("window."); // $NON-NLS-1$ |
| buffer.append (functionName); |
| buffer.append (" = function "); // $NON-NLS-1$ |
| buffer.append (functionName); |
| buffer.append ("() {\n"); // $NON-NLS-1$ |
| buffer.append (script); |
| buffer.append ("\n};"); // $NON-NLS-1$ |
| execute (buffer.toString ()); |
| |
| buffer = new StringBuffer ("if (window."); // $NON-NLS-1$ |
| buffer.append (functionName); |
| buffer.append (" == undefined) {window.external.callJava("); // $NON-NLS-1$ |
| buffer.append (index); |
| buffer.append (",'"); //$NON-NLS-1$ |
| buffer.append (function.token); |
| buffer.append ("', ['"); // $NON-NLS-1$ |
| buffer.append (ERROR_ID); |
| buffer.append ("']);} else {try {var result = "); // $NON-NLS-1$ |
| buffer.append (functionName); |
| buffer.append ("(); window.external.callJava("); // $NON-NLS-1$ |
| buffer.append (index); |
| buffer.append (",'"); //$NON-NLS-1$ |
| buffer.append (function.token); |
| buffer.append ("', [result]);} catch (e) {window.external.callJava("); // $NON-NLS-1$ |
| buffer.append (index); |
| buffer.append (",'"); //$NON-NLS-1$ |
| buffer.append (function.token); |
| buffer.append ("', ['"); // $NON-NLS-1$ |
| buffer.append (ERROR_ID); |
| buffer.append ("' + e.message]);}}"); // $NON-NLS-1$ |
| execute (buffer.toString ()); |
| execute (getDeleteFunctionString (functionName)); |
| deregisterFunction (function); |
| |
| Object result = evaluateResult; |
| evaluateResult = null; |
| if (result instanceof SWTException) throw (SWTException)result; |
| return result; |
| } |
| |
| public abstract boolean forward (); |
| |
| public abstract String getBrowserType (); |
| |
| String getDeleteFunctionString (String functionName) { |
| return "delete window." + functionName; //$NON-NLS-1$ |
| } |
| |
| int getNextFunctionIndex () { |
| return nextFunctionIndex++; |
| } |
| |
| public abstract String getText (); |
| |
| public abstract String getUrl (); |
| |
| public Object getWebBrowser () { |
| return null; |
| } |
| |
| public abstract boolean isBackEnabled (); |
| |
| public boolean isFocusControl () { |
| return false; |
| } |
| |
| public abstract boolean isForwardEnabled (); |
| |
| public abstract void refresh (); |
| |
| void registerFunction (BrowserFunction function) { |
| functions.put (new Integer (function.index), function); |
| } |
| |
| public void removeAuthenticationListener (AuthenticationListener listener) { |
| if (authenticationListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < authenticationListeners.length; i++) { |
| if (listener == authenticationListeners[i]) { |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (authenticationListeners.length == 1) { |
| authenticationListeners = new AuthenticationListener[0]; |
| return; |
| } |
| AuthenticationListener[] newAuthenticationListeners = new AuthenticationListener[authenticationListeners.length - 1]; |
| System.arraycopy (authenticationListeners, 0, newAuthenticationListeners, 0, index); |
| System.arraycopy (authenticationListeners, index + 1, newAuthenticationListeners, index, authenticationListeners.length - index - 1); |
| authenticationListeners = newAuthenticationListeners; |
| } |
| |
| public void removeCloseWindowListener (CloseWindowListener listener) { |
| if (closeWindowListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < closeWindowListeners.length; i++) { |
| if (listener == closeWindowListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (closeWindowListeners.length == 1) { |
| closeWindowListeners = new CloseWindowListener[0]; |
| return; |
| } |
| CloseWindowListener[] newCloseWindowListeners = new CloseWindowListener[closeWindowListeners.length - 1]; |
| System.arraycopy (closeWindowListeners, 0, newCloseWindowListeners, 0, index); |
| System.arraycopy (closeWindowListeners, index + 1, newCloseWindowListeners, index, closeWindowListeners.length - index - 1); |
| closeWindowListeners = newCloseWindowListeners; |
| } |
| |
| public void removeLocationListener (LocationListener listener) { |
| if (locationListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < locationListeners.length; i++) { |
| if (listener == locationListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (locationListeners.length == 1) { |
| locationListeners = new LocationListener[0]; |
| return; |
| } |
| LocationListener[] newLocationListeners = new LocationListener[locationListeners.length - 1]; |
| System.arraycopy (locationListeners, 0, newLocationListeners, 0, index); |
| System.arraycopy (locationListeners, index + 1, newLocationListeners, index, locationListeners.length - index - 1); |
| locationListeners = newLocationListeners; |
| } |
| |
| public void removeOpenWindowListener (OpenWindowListener listener) { |
| if (openWindowListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < openWindowListeners.length; i++) { |
| if (listener == openWindowListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (openWindowListeners.length == 1) { |
| openWindowListeners = new OpenWindowListener[0]; |
| return; |
| } |
| OpenWindowListener[] newOpenWindowListeners = new OpenWindowListener[openWindowListeners.length - 1]; |
| System.arraycopy (openWindowListeners, 0, newOpenWindowListeners, 0, index); |
| System.arraycopy (openWindowListeners, index + 1, newOpenWindowListeners, index, openWindowListeners.length - index - 1); |
| openWindowListeners = newOpenWindowListeners; |
| } |
| |
| public void removeProgressListener (ProgressListener listener) { |
| if (progressListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < progressListeners.length; i++) { |
| if (listener == progressListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (progressListeners.length == 1) { |
| progressListeners = new ProgressListener[0]; |
| return; |
| } |
| ProgressListener[] newProgressListeners = new ProgressListener[progressListeners.length - 1]; |
| System.arraycopy (progressListeners, 0, newProgressListeners, 0, index); |
| System.arraycopy (progressListeners, index + 1, newProgressListeners, index, progressListeners.length - index - 1); |
| progressListeners = newProgressListeners; |
| } |
| |
| public void removeStatusTextListener (StatusTextListener listener) { |
| if (statusTextListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < statusTextListeners.length; i++) { |
| if (listener == statusTextListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (statusTextListeners.length == 1) { |
| statusTextListeners = new StatusTextListener[0]; |
| return; |
| } |
| StatusTextListener[] newStatusTextListeners = new StatusTextListener[statusTextListeners.length - 1]; |
| System.arraycopy (statusTextListeners, 0, newStatusTextListeners, 0, index); |
| System.arraycopy (statusTextListeners, index + 1, newStatusTextListeners, index, statusTextListeners.length - index - 1); |
| statusTextListeners = newStatusTextListeners; |
| } |
| |
| public void removeTitleListener (TitleListener listener) { |
| if (titleListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < titleListeners.length; i++) { |
| if (listener == titleListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (titleListeners.length == 1) { |
| titleListeners = new TitleListener[0]; |
| return; |
| } |
| TitleListener[] newTitleListeners = new TitleListener[titleListeners.length - 1]; |
| System.arraycopy (titleListeners, 0, newTitleListeners, 0, index); |
| System.arraycopy (titleListeners, index + 1, newTitleListeners, index, titleListeners.length - index - 1); |
| titleListeners = newTitleListeners; |
| } |
| |
| public void removeVisibilityWindowListener (VisibilityWindowListener listener) { |
| if (visibilityWindowListeners.length == 0) return; |
| int index = -1; |
| for (int i = 0; i < visibilityWindowListeners.length; i++) { |
| if (listener == visibilityWindowListeners[i]){ |
| index = i; |
| break; |
| } |
| } |
| if (index == -1) return; |
| if (visibilityWindowListeners.length == 1) { |
| visibilityWindowListeners = new VisibilityWindowListener[0]; |
| return; |
| } |
| VisibilityWindowListener[] newVisibilityWindowListeners = new VisibilityWindowListener[visibilityWindowListeners.length - 1]; |
| System.arraycopy (visibilityWindowListeners, 0, newVisibilityWindowListeners, 0, index); |
| System.arraycopy (visibilityWindowListeners, index + 1, newVisibilityWindowListeners, index, visibilityWindowListeners.length - index - 1); |
| visibilityWindowListeners = newVisibilityWindowListeners; |
| } |
| |
| boolean sendKeyEvent (Event event) { |
| int traversal = SWT.TRAVERSE_NONE; |
| boolean traverseDoit = true; |
| switch (event.keyCode) { |
| case SWT.ESC: { |
| traversal = SWT.TRAVERSE_ESCAPE; |
| traverseDoit = true; |
| break; |
| } |
| case SWT.CR: { |
| traversal = SWT.TRAVERSE_RETURN; |
| traverseDoit = false; |
| break; |
| } |
| case SWT.ARROW_DOWN: |
| case SWT.ARROW_RIGHT: { |
| traversal = SWT.TRAVERSE_ARROW_NEXT; |
| traverseDoit = false; |
| break; |
| } |
| case SWT.ARROW_UP: |
| case SWT.ARROW_LEFT: { |
| traversal = SWT.TRAVERSE_ARROW_PREVIOUS; |
| traverseDoit = false; |
| break; |
| } |
| case SWT.TAB: { |
| traversal = (event.stateMask & SWT.SHIFT) != 0 ? SWT.TRAVERSE_TAB_PREVIOUS : SWT.TRAVERSE_TAB_NEXT; |
| traverseDoit = (event.stateMask & SWT.CTRL) != 0; |
| break; |
| } |
| case SWT.PAGE_DOWN: { |
| if ((event.stateMask & SWT.CTRL) != 0) { |
| traversal = SWT.TRAVERSE_PAGE_NEXT; |
| traverseDoit = true; |
| } |
| break; |
| } |
| case SWT.PAGE_UP: { |
| if ((event.stateMask & SWT.CTRL) != 0) { |
| traversal = SWT.TRAVERSE_PAGE_PREVIOUS; |
| traverseDoit = true; |
| } |
| break; |
| } |
| default: { |
| if (translateMnemonics ()) { |
| if (event.character != 0 && (event.stateMask & (SWT.ALT | SWT.CTRL)) == SWT.ALT) { |
| traversal = SWT.TRAVERSE_MNEMONIC; |
| traverseDoit = true; |
| } |
| } |
| break; |
| } |
| } |
| |
| boolean doit = true; |
| if (traversal != SWT.TRAVERSE_NONE) { |
| boolean oldEventDoit = event.doit; |
| event.doit = traverseDoit; |
| doit = !browser.traverse (traversal, event); |
| event.doit = oldEventDoit; |
| } |
| if (doit) { |
| browser.notifyListeners (event.type, event); |
| doit = event.doit; |
| } |
| return doit; |
| } |
| |
| public void setBrowser (Browser browser) { |
| this.browser = browser; |
| } |
| |
| public abstract boolean setText (String html, boolean trusted); |
| |
| public abstract boolean setUrl (String url, String postData, String[] headers); |
| |
| public abstract void stop (); |
| |
| int translateKey (int key) { |
| for (int i = 0; i < KeyTable.length; i++) { |
| if (KeyTable[i][0] == key) return KeyTable[i][1]; |
| } |
| return 0; |
| } |
| |
| boolean translateMnemonics () { |
| return true; |
| } |
| |
| } |