+

+ if (ua.indexOf('MSIE') == -1 && ua.indexOf('Trident') != -1) { return 'yes'; }

+ * Sets the selection range of an input element.

+ *

+ * We need this JSNI function to set selection range so that we can use the

+ * optional direction attribute to set the anchor to the end and the focus

+ * to the start. This makes Firefox work the same way as other browsers

+ * (#13477)

+ *

+ * @param elem

+ * the html input element.

+ * @param pos

+ * the index of the first selected character.

+ * @param length

+ * the selection length.

+ * @param direction

+ * a string indicating the direction in which the selection was

+ * performed. This may be "forward" or "backward", or "none" if

+ * the direction is unknown or irrelevant.

+ *

+ * @since

+ */

+ public native static void setSelectionRange(Element elem, int pos,

+ int length, String direction)

+ /*-{

+ try {

+ elem.setSelectionRange(pos, pos + length, direction);

+ } catch (e) {

+ // Firefox throws exception if TextBox is not visible, even if attached

+ }

+ }-*/;

+

+ /**

+ return CssSize.fromString(cssSize1).equals(

+ CssSize.fromString(cssSize2));

+ if (dragStartMode == WRAPPER || dragStartMode == COMPONENT

+ || dragStartMode == COMPONENT_OTHER) {

+ } else if (dragStartMode == COMPONENT_OTHER

+ && getDragImageWidget() != null) {

+ dragEvent.createDragImage(getDragImageWidget().getElement(),

+ true);

+ protected final static int COMPONENT_OTHER = 4;

+ private Widget dragImageWidget;

+ /**

+ * Set the widget that will be used as the drag image when using

+ * DragStartMode {@link COMPONENT_OTHER} .

+ *

+ * @param widget

+ */

+ public void setDragAndDropWidget(Widget widget) {

+ dragImageWidget = widget;

+ }

+

+ /**

+ * @return the widget used as drag image. Returns <code>null</code> if no

+ * widget is set.

+ */

+ public Widget getDragImageWidget() {

+ return dragImageWidget;

+ }

+

+ *

+ *

+ *

+ *

+ *

+ *

+ *

+ /*

+ * set selection range with a backwards direction: anchor at the

+ * back, focus at the front. This means that items that are too

+ * long to display will display from the start and not the end

+ * even on Firefox.

+ *

+ * We need the JSNI function to set selection range so that we

+ * can use the optional direction attribute to set the anchor to

+ * the end and the focus to the start. This makes Firefox work

+ * the same way as other browsers (#13477)

+ */

+ Util.setSelectionRange(getElement(), pos, length, "backward");

+

+ /*

+ * Setting the selectionrange for an uneditable textbox leads to

+ * unwanted behaviour when the width of the textbox is narrower

+ * than the width of the entry: the end of the entry is shown

+ * instead of the beginning. (see #13477)

+ *

+ * To avoid this, we set the caret to the beginning of the line.

+ */

+

+ super.setSelectionRange(0, 0);

+

+ * To leave caret in the beginning of the line. SetSelectionRange

+ * wouldn't work on IE (see #13477)

+ * suggestion, select that. If there is more than one

+ * suggestion Enter key should work as Escape key. Otherwise

+ * do nothing.

+ } else if (currentSuggestions.size() > 1) {

+ reset();

+ *

+ *

+ *

+import com.google.gwt.event.dom.client.HasMouseDownHandlers;

+import com.google.gwt.event.dom.client.MouseDownEvent;

+import com.google.gwt.event.dom.client.MouseDownHandler;

+ SubPartAware,

+ // TODO: These listeners are due to be removed in 7.3

+ FocusHandler, BlurHandler, KeyDownHandler {

+ *

+ HasBlurHandlers, HasMouseDownHandlers, HasKeyDownHandlers {

+ *

+ public HandlerRegistration addMouseDownHandler(MouseDownHandler handler) {

+ return addDomHandler(handler, MouseDownEvent.getType());

+ }

+

+ @Override

+ static class TabBar extends ComplexPanel implements VCloseHandler {

+

+ /**

+ * Gets the number of tabs from the tab bar.

+ *

+ * @return the number of tabs from the tab bar.

+ */

+ /**

+ * Adds a tab to the tab bar.

+ *

+ * @return the added tab.

+ */

+ getTabsheet().selectionHandler.registerTab(t);

+

+ /**

+ * Gets the tab sheet instance where the tab bar is attached to.

+ *

+ * @return the tab sheet instance where the tab bar is attached to.

+ */

+ public Tab navigateTab(int fromIndex, int toIndex) {

+

+ return newNavigated;

+ *

+ *

+ *

+

+ *

+ *

+ * @return true if the specified sheet gets loaded, otherwise false.

+ public boolean loadTabSheet(int tabIndex) {

+

+ return true;

+

+ return false;

+ *

+ *

+ *

+ *

+

+ DOM.sinkEvents(scrollerPrev, Event.ONCLICK | Event.ONMOUSEDOWN);

+

+ DOM.sinkEvents(scrollerNext, Event.ONCLICK | Event.ONMOUSEDOWN);

+

+ com.google.gwt.dom.client.Element eventTarget = DOM

+ .eventGetTarget(event);

+

+

+ if (eventTarget == scrollerPrev || eventTarget == scrollerNext) {

+ scrollAccordingToScrollTarget(eventTarget);

+ }

+

+ } else if (event.getTypeInt() == Event.ONMOUSEDOWN) {

+

+ if (eventTarget == scrollerPrev || eventTarget == scrollerNext) {

+ // In case the focus was previously on a Tab, we need to cancel

+ // the upcoming blur on the Tab which will follow this mouse

+ // down event.

+ focusBlurManager.cancelNextBlurSchedule();

+

+

+ /*

+ * Scroll the tab bar according to the last scrollTarget (the scroll button

+ * pressed).

+ */

+ private void scrollAccordingToScrollTarget(

+ com.google.gwt.dom.client.Element scrollTarget) {

+ if (scrollTarget == null) {

+ return;

+ }

+

+ int newFirstIndex = -1;

+

+ // Scroll left.

+ if (isScrolledTabs() && scrollTarget == scrollerPrev) {

+ newFirstIndex = tb.scrollLeft(scrollerIndex);

+

+ // Scroll right.

+ } else if (isClippedTabs() && scrollTarget == scrollerNext) {

+ newFirstIndex = tb.scrollRight(scrollerIndex);

+ }

+

+ if (newFirstIndex != -1) {

+ scrollerIndex = newFirstIndex;

+ updateTabScroller();

+ }

+

+ // For this to work well, make sure the method gets called only from

+ // user events.

+ selectionHandler.focusTabAtIndex(scrollerIndex);

+ }

+

+ *

+ *

+ public void focus() {

+ getActiveTab().focus();

+ }

+ public void blur() {

+ getActiveTab().blur();

+ }

+

+ /*

+ * Gets the active tab.

+ */

+ private Tab getActiveTab() {

+ return tb.getTab(activeTabIndex);

+ public void setConnector(AbstractComponentConnector connector) {

+ super.setConnector(connector);

+

+ focusBlurManager.connector = connector;

+ }

+

+ /*

+ * The focus and blur manager instance.

+ */

+ private FocusBlurManager focusBlurManager = new FocusBlurManager();

+

+ /*

+ * Generate the correct focus/blur events for the main TabSheet component

+ * (#14304).

+ *

+ * The TabSheet must fire one focus event when the user clicks on the tab

+ * bar (i.e. inner TabBar class) containing the Tabs or when the focus is

+ * provided to the TabSheet by any means. Also one blur event should be

+ * fired only when the user leaves the tab bar. After the user focus on the

+ * tab bar and before leaving it, no matter how many times he's pressing the

+ * Tabs or the scroll buttons, the TabSheet component should not fire any of

+ * those blur/focus events.

+ *

+ * The only focusable elements contained in the tab bar are the Tabs (see

+ * inner class Tab). The reason is the accessibility support.

+ *

+ * Having this in mind, the chosen solution path for our problem is to match

+ * a sequence of focus/blur events on the tabs, choose only the first focus

+ * and last blur events and pass only those further to the main component.

+ * Any consecutive blur/focus events on 2 Tabs must be ignored.

+ *

+ * Because in a blur event we don't know whether or not a focus will follow,

+ * we just defer a command initiated on the blur event to wait and see if

+ * any focus will appear. The command will be executed after the next focus,

+ * so if no focus was triggered in the mean while it'll submit the blur

+ * event to the main component, otherwise it'll do nothing, so the main

+ * component will not generate the blur..

+ */

+ private static class FocusBlurManager {

+

+ // The real tab with focus on it. If the focus goes to another element

+ // in the page this will be null.

+ private Tab focusedTab;

+

+ /*

+ * Gets the focused tab.

+ */

+ private Tab getFocusedTab() {

+ return focusedTab;

+ }

+

+ /*

+ * Sets the local field tracking the focused tab.

+ */

+ private void setFocusedTab(Tab focusedTab) {

+ this.focusedTab = focusedTab;

+ }

+

+ /*

+ * The ultimate focus/blur event dispatcher.

+ */

+ private AbstractComponentConnector connector;

+

+ /**

+ * Delegate method for the onFocus event occurring on Tab.

+ *

+ * @since

+ * @param newFocusTab

+ * the new focused tab.

+ * @see #onBlur(Tab)

+ */

+ public void onFocus(Tab newFocusTab) {

+

+

+ // Send the focus event only first time when we focus on any

+ // tab. The focused tab will be reseted on the last blur.

+ if (focusedTab == null) {

+ connector.getRpcProxy(FocusAndBlurServerRpc.class).focus();

+ }

+ }

+

+ cancelLastBlurSchedule();

+

+ setFocusedTab(newFocusTab);

+ }

+

+ /**

+ * Delegate method for the onBlur event occurring on Tab.

+ *

+ * @param blurSource

+ * the source of the blur.

+ *

+ * @see #onFocus(Tab)

+ */

+ public void onBlur(Tab blurSource) {

+ if (focusedTab != null && focusedTab == blurSource) {

+

+ if (connector.hasEventListener(EventId.BLUR)) {

+ scheduleBlur(focusedTab);

+ }

+ }

+ }

+

+ /*

+ * The last blur command to be executed.

+ */

+ private BlurCommand blurCommand;

+

+ /*

+ * Execute the final blur command.

+ */

+ private class BlurCommand implements Command {

+

+ /*

+ * The blur source.

+ */

+ private Tab blurSource;

+

+ /**

+ * Create the blur command using the blur source.

+ *

+ * @param blurSource

+ * the source.

+ * @param focusedTabProvider

+ * provides the current focused tab.

+ */

+ public BlurCommand(Tab blurSource) {

+ this.blurSource = blurSource;

+ }

+

+ /**

+ * Stop the command from being executed.

+ *

+ * @since

+ */

+ public void stopSchedule() {

+ blurSource = null;

+ /**

+ * Schedule the command for a deferred execution.

+ *

+ * @since

+ */

+ public void scheduleDeferred() {

+ Scheduler.get().scheduleDeferred(this);

+ }

+

+ @Override

+ public void execute() {

+

+ Tab focusedTab = getFocusedTab();

+

+ if (blurSource == null) {

+ return;

+ }

+

+ // The focus didn't change since this blur triggered, so

+ // the new focused element is not a tab.

+ if (focusedTab == blurSource) {

+

+ // We're certain there's no focus anymore.

+ focusedTab.removeAssistiveDescription();

+ setFocusedTab(null);

+

+ connector.getRpcProxy(FocusAndBlurServerRpc.class).blur();

+ }

+

+ // Call this to set it to null and be consistent.

+ cancelLastBlurSchedule();

+

+ /*

+ * Schedule a new blur event for a deferred execution.

+ */

+ private void scheduleBlur(Tab blurSource) {

+

+ if (nextBlurScheduleCancelled) {

+

+ // This will set the stopNextBlurCommand back to false as well.

+ cancelLastBlurSchedule();

+

+ // Reset the status.

+ nextBlurScheduleCancelled = false;

+ return;

+ }

+

+ cancelLastBlurSchedule();

+

+ blurCommand = new BlurCommand(blurSource);

+ blurCommand.scheduleDeferred();

+ }

+

+ /**

+ * Remove the last blur deferred command from execution.

+ */

+ public void cancelLastBlurSchedule() {

+ if (blurCommand != null) {

+ blurCommand.stopSchedule();

+ blurCommand = null;

+ }

+

+ // We really want to make sure this flag gets reseted at any time

+ // when something interact with the blur manager and ther's no blur

+ // command scheduled (as we just canceled it).

+ nextBlurScheduleCancelled = false;

+ }

+

+ /**

+ * Cancel the next scheduled execution. This method must be called only

+ * from an event occurring before the onBlur event. It's the case of IE

+ * which doesn't trigger the focus event, so we're using this approach

+ * to cancel the next blur event prior it's execution, calling the

+ * method from mouse down event.

+ */

+ public void cancelNextBlurSchedule() {

+

+ // Make sure there's still no other command to be executed.

+ cancelLastBlurSchedule();

+

+ nextBlurScheduleCancelled = true;

+ }

+

+ /*

+ * Flag that the next deferred command won't get executed. This is

+ * useful in case of IE where the user focus event don't fire and we're

+ * using the mouse down event to track the focus. But the mouse down

+ * event triggers before the blur, so we need to cancel the deferred

+ * execution in advance.

+ */

+ private boolean nextBlurScheduleCancelled = false;

+

+ public void onBlur(BlurEvent event) {

+ selectionHandler.onBlur(event);

+ @Override

+ public void onFocus(FocusEvent event) {

+ selectionHandler.onFocus(event);

+ selectionHandler.onKeyDown(event);

+ }

+

+ /*

+ * The tabs selection handler instance.

+ */

+ private final TabSelectionHandler selectionHandler = new TabSelectionHandler();

+

+ /*

+ * Handle the events for selecting the tabs.

+ */

+ private class TabSelectionHandler implements FocusHandler, BlurHandler,

+ KeyDownHandler, ClickHandler, MouseDownHandler {

+

+ /** For internal use only. May be removed or replaced in the future. */

+ // The current visible focused index.

+ private int focusedTabIndex = 0;

+

+ /**

+ * Register the tab to the selection handler.

+ *

+ * @param tab

+ * the tab to register.

+ */

+ public void registerTab(Tab tab) {

+

+ // TODO: change VTabsheet.this to this in 7.3

+ tab.addBlurHandler(VTabsheet.this);

+ tab.addFocusHandler(VTabsheet.this);

+ tab.addKeyDownHandler(VTabsheet.this);

+

+ tab.addClickHandler(this);

+ tab.addMouseDownHandler(this);

+ }

+

+ @Override

+ public void onBlur(final BlurEvent event) {

+

+ getVTooltip().hideTooltip();

+

+ Object blurSource = event.getSource();

+

+ if (blurSource instanceof Tab) {

+ focusBlurManager.onBlur((Tab) blurSource);

+ }

+ }

+

+ @Override

+ public void onFocus(FocusEvent event) {

+

+ if (event.getSource() instanceof Tab) {

+ Tab focusSource = (Tab) event.getSource();

+ focusBlurManager.onFocus(focusSource);

+

+ if (focusSource.hasTooltip()) {

+ focusSource.setAssistiveDescription(getVTooltip()

+ .getUniqueId());

+ getVTooltip().showAssistive(focusSource.getTooltipInfo());

+ }

+

+ }

+ }

+

+ @Override

+ public void onClick(ClickEvent event) {

+

+ // IE doesn't trigger focus when click, so we need to make sure

+ // the previous blur deferred command will get killed.

+ focusBlurManager.cancelLastBlurSchedule();

+

+ TabCaption caption = (TabCaption) event.getSource();

+ Element targetElement = event.getNativeEvent().getEventTarget()

+ .cast();

+ // the tab should not be focused if the close button was clicked

+ if (targetElement == caption.getCloseButton()) {

+ return;

+ }

+

+ int index = tb.getWidgetIndex(caption.getParent());

+

+ tb.navigateTab(focusedTabIndex, index);

+

+ focusedTabIndex = index;

+

+ if (!loadTabSheet(index)) {

+

+ // This needs to be called at the end, as the activeTabIndex

+ // is set in the loadTabSheet.

+ focus();

+ }

+ }

+

+ @Override

+ public void onMouseDown(MouseDownEvent event) {

+

+ if (event.getSource() instanceof Tab) {

+

+ // IE doesn't trigger focus when click, so we need to make sure

+ // the

+ // next blur deferred command will get killed.

+ focusBlurManager.cancelNextBlurSchedule();

+ }

+ }

+

+ @Override

+ public void onKeyDown(KeyDownEvent event) {

+ if (event.getSource() instanceof Tab) {

+ int keycode = event.getNativeEvent().getKeyCode();

+

+ if (!event.isAnyModifierKeyDown()) {

+ if (keycode == getPreviousTabKey()) {

+ selectPreviousTab();

+ event.stopPropagation();

+

+ } else if (keycode == getNextTabKey()) {

+ selectNextTab();

+ event.stopPropagation();

+

+ } else if (keycode == getCloseTabKey()) {

+ Tab tab = tb.getTab(activeTabIndex);

+ if (tab.isClosable()) {

+ tab.onClose();

+ }

+

+ } else if (keycode == getSelectTabKey()) {

+ loadTabSheet(focusedTabIndex);

+

+ // Prevent the page from scrolling when hitting space

+ // (select key) to select the current tab.

+ event.preventDefault();

+

+ /*

+ * Left arrow key selection.

+ */

+ private void selectPreviousTab() {

+ int newTabIndex = focusedTabIndex;

+ // Find the previous visible and enabled tab if any.

+ do {

+ newTabIndex--;

+ } while (newTabIndex >= 0 && !canSelectTab(newTabIndex));

+

+ if (newTabIndex >= 0) {

+ keySelectTab(newTabIndex);

+ }

+ }

+

+ /*

+ * Right arrow key selection.

+ */

+ private void selectNextTab() {

+ int newTabIndex = focusedTabIndex;

+ // Find the next visible and enabled tab if any.

+ do {

+ newTabIndex++;

+ } while (newTabIndex < getTabCount() && !canSelectTab(newTabIndex));

+

+ if (newTabIndex < getTabCount()) {

+ keySelectTab(newTabIndex);

+ }

+ }

+

+ /*

+ * Select the specified tab using left/right key.

+ */

+ private void keySelectTab(int newTabIndex) {

+ Tab tab = tb.getTab(newTabIndex);

+ if (tab == null) {

+ return;

+ }

+

+ // Focus the tab, otherwise the selected one will loose focus and

+ // TabSheet will get blurred.

+ focusTabAtIndex(newTabIndex);

+

+ tb.navigateTab(focusedTabIndex, newTabIndex);

+

+ focusedTabIndex = newTabIndex;

+ }

+

+ /**

+ * Focus the specified tab. Make sure to call this only from user

+ * events, otherwise will break things.

+ *

+ * @param tabIndex

+ * the index of the tab to set.

+ */

+ void focusTabAtIndex(int tabIndex) {

+ Tab tabToFocus = tb.getTab(tabIndex);

+ if (tabToFocus != null) {

+ tabToFocus.focus();

+ }

+ }

+

+ /**

+ * Gets the key to activate the selected tab when navigating using

+ * previous/next (left/right) keys.

+ *

+ * @return the key to activate the selected tab.

+ *

+ * @see #getNextTabKey()

+ * @see #getPreviousTabKey()

+ */

+ return KeyCodes.KEY_SPACE;

+ private void scrollIntoView(Tab tab) {

+ if (!tab.isHiddenOnServer()) {

+ // Check for visibility first as clipped tabs to the right are

+ // always visible.

+ // On IE8 a tab with false visibility would have the bounds of the

+ // full TabBar.

+ if (!tab.isVisible()) {

+ while (!tab.isVisible()) {

+ scrollerIndex = tb.scrollLeft(scrollerIndex);

+ }

+ updateTabScroller();

+ } else if (isClipped(tab)) {

+ *

+ *

+

+ // Fix for #14413. Any pseudo elements inside these elements are not

+ // visible on initial render unless we shake the DOM.

+ if (BrowserInfo.get().isIE8()) {

+ closeBox.getStyle().setDisplay(Display.NONE);

+ maximizeRestoreBox.getStyle().setDisplay(Display.NONE);

+ Scheduler.get().scheduleFinally(new Command() {

+ @Override

+ public void execute() {

+ closeBox.getStyle().clearDisplay();

+ maximizeRestoreBox.getStyle().clearDisplay();

+ }

+ });

+ }

+import java.util.logging.Level;

+import java.util.logging.Logger;

+import com.vaadin.client.ComponentConnector;

+import com.vaadin.client.ConnectorMap;

+

+ String dragImageComponentConnectorId = uidl

+ .getStringAttribute(DragAndDropWrapperConstants.DRAG_START_COMPONENT_ATTRIBUTE);

+

+ ComponentConnector connector = null;

+ if (dragImageComponentConnectorId != null) {

+ connector = (ComponentConnector) ConnectorMap.get(client)

+ .getConnector(dragImageComponentConnectorId);

+

+ if (connector == null) {

+ getLogger().log(

+ Level.WARNING,

+ "DragAndDropWrapper drag image component"

+ + " connector now found. Make sure the"

+ + " component is attached.");

+ } else {

+ getWidget().setDragAndDropWidget(connector.getWidget());

+ }

+ }

+ private static Logger getLogger() {

+ return Logger.getLogger(DragAndDropWrapperConnector.class.getName());

+ }

+ private static final String IE11_WINDOWS_PHONE_8_1_UPDATE = "Mozilla/5.0 (Mobile; Windows Phone 8.1; Android 4.0; ARM; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; NOKIA; Lumia 920) Like iPhone OS 7_0_3 Mac OS X AppleWebKit/537 (KHTML, like Gecko) Mobile Safari/537";

+ public void testIE11WindowsPhone81Update() {

+ VBrowserDetails bd = new VBrowserDetails(IE11_WINDOWS_PHONE_8_1_UPDATE);

+ assertTrident(bd);

+ assertEngineVersion(bd, 7);

+ assertIE(bd);

+ assertBrowserMajorVersion(bd, 11);

+ assertBrowserMinorVersion(bd, 0);

+ assertWindows(bd);

+ }

+