Examples of com.google.gwt.core.client.JsArrayString

com.google.gwt.core.client.JsArrayString
A simple wrapper around a homogeneous native array of string values. This class may not be directly instantiated, and can only be returned from a native method. For example, native JsArrayString getNativeArray() /*-{ return ['foo', 'bar', 'baz']; }-* /;

    }
    else {
      int index = responseText.lastIndexOf(SEPARATOR);
      if (index > read) {
        List<Serializable> messages = new ArrayList<Serializable>();
        JsArrayString data = AtmosphereClient.split(responseText.substring(read, index), SEPARATOR);
        int length = data.length();
        for (int i = 0; i < length; i++) {
          if (aborted) {
            return;
          }
          parse(data.get(i), messages);
        }
        read = index + 1;
        if (!messages.isEmpty()) {
          listener.onMessage(messages);
        }

View Full Code Here

  public JavaScriptObject wrap(String[] type) {
    if (!GWT.isScript()) {
      if (type == null) {
        return null;
      }
      JsArrayString wrapperArray =  JavaScriptObject.createArray().cast();
      for (int i = 0; i < type.length; i++) {
        wrapperArray.set(i, type[i]);
      }
      return wrapperArray;
    } else {
      return reinterpretCast(type);
    }

View Full Code Here

        }
        if (statePropertyHandlerManagers != null
                && event instanceof StateChangeEvent) {
            Profiler.enter("AbstractConnector.fireEvent statePropertyHandlerManagers");
            StateChangeEvent stateChangeEvent = (StateChangeEvent) event;
            JsArrayString keys = statePropertyHandlerManagers.getKeys();
            for (int i = 0; i < keys.length(); i++) {
                String property = keys.get(i);
                if (stateChangeEvent.hasPropertyChanged(property)) {
                    statePropertyHandlerManagers.get(property).fireEvent(event);
                }
            }
            Profiler.leave("AbstractConnector.fireEvent statePropertyHandlerManagers");

View Full Code Here

        if (handlers != null) {
            Profiler.enter("AbstractConnector.onStateChanged @OnStateChange");


            HashSet<OnStateChangeMethod> invokedMethods = new HashSet<OnStateChangeMethod>();


            JsArrayString propertyNames = handlers.getKeys();
            for (int i = 0; i < propertyNames.length(); i++) {
                String propertyName = propertyNames.get(i);


                if (stateChangeEvent.hasPropertyChanged(propertyName)) {
                    JsArrayObject<OnStateChangeMethod> propertyMethods = handlers
                            .get(propertyName);

View Full Code Here

     *            the name of the variable
     * @return the value of the variable
     */
    public Set<String> getStringArrayVariableAsSet(final String name) {
        final HashSet<String> s = new HashSet<String>();
        JsArrayString a = var().getJSStringArray(name);
        for (int i = 0; i < a.length(); i++) {
            s.add(a.get(i));
        }
        return s;
    }

View Full Code Here

    // this is a very inefficient implementation for getting all the identifiers
    // for a class
    public FastStringSet findIdentifiersFor(Class<?> type) {
        FastStringSet result = FastStringSet.create();


        JsArrayString keys = identifiers.getKeys();
        for (int i = 0; i < keys.length(); i++) {
            String key = keys.get(i);
            if (identifiers.get(key) == type) {
                result.add(key);
            }
        }

View Full Code Here

    public void setDelegateToWidget(Class<?> clazz, String propertyName,
            String delegateValue) {
        Type type = getType(clazz);
        delegateToWidget.put(new Property(type, propertyName).getLookupKey(),
                delegateValue);
        JsArrayString typeProperties = delegateToWidgetProperties.get(type
                .getBaseTypeName());
        if (typeProperties == null) {
            typeProperties = JavaScriptObject.createArray().cast();
            delegateToWidgetProperties.put(type.getBaseTypeName(),
                    typeProperties);
        }
        typeProperties.push(propertyName);
    }

View Full Code Here

        int passes = 0;
        Duration totalDuration = new Duration();


        ConnectorMap connectorMap = ConnectorMap.get(connection);


        JsArrayString dump = needsHorizontalLayout.dump();
        int dumpLength = dump.length();
        for (int i = 0; i < dumpLength; i++) {
            String layoutId = dump.get(i);
            currentDependencyTree.setNeedsHorizontalLayout(layoutId, true);
        }


        dump = needsVerticalLayout.dump();
        dumpLength = dump.length();
        for (int i = 0; i < dumpLength; i++) {
            String layoutId = dump.get(i);
            currentDependencyTree.setNeedsVerticalLayout(layoutId, true);
        }
        needsHorizontalLayout = FastStringSet.create();
        needsVerticalLayout = FastStringSet.create();


        dump = needsMeasure.dump();
        dumpLength = dump.length();
        for (int i = 0; i < dumpLength; i++) {
            String layoutId = dump.get(i);
            currentDependencyTree.setNeedsMeasure(layoutId, true);
        }
        needsMeasure = FastStringSet.create();


        measureNonConnectors();


        Profiler.leave("LayoutManager phase init");


        while (true) {
            Profiler.enter("Layout pass");
            passes++;


            performBrowserLayoutHacks();


            Profiler.enter("Layout measure connectors");
            int measuredConnectorCount = measureConnectors(
                    currentDependencyTree, everythingNeedsMeasure);
            Profiler.leave("Layout measure connectors");


            everythingNeedsMeasure = false;
            if (measuredConnectorCount == 0) {
                VConsole.log("No more changes in pass " + passes);
                Profiler.leave("Layout pass");
                break;
            }


            int firedListeners = 0;
            if (!listenersToFire.isEmpty()) {
                firedListeners = listenersToFire.size();
                Profiler.enter("Layout fire resize events");
                for (Element element : listenersToFire) {
                    Collection<ElementResizeListener> listeners = elementResizeListeners
                            .get(element);
                    if (listeners != null) {
                        Profiler.enter("Layout fire resize events - listeners not null");
                        Profiler.enter("ElementResizeListener.onElementResize copy list");
                        ElementResizeListener[] array = listeners
                                .toArray(new ElementResizeListener[listeners
                                        .size()]);
                        Profiler.leave("ElementResizeListener.onElementResize copy list");
                        ElementResizeEvent event = new ElementResizeEvent(this,
                                element);
                        for (ElementResizeListener listener : array) {
                            try {
                                String key = null;
                                if (Profiler.isEnabled()) {
                                    Profiler.enter("ElementResizeListener.onElementResize construct profiler key");
                                    key = "ElementResizeListener.onElementResize for "
                                            + Util.getSimpleName(listener);
                                    Profiler.leave("ElementResizeListener.onElementResize construct profiler key");
                                    Profiler.enter(key);
                                }


                                listener.onElementResize(event);
                                if (Profiler.isEnabled()) {
                                    Profiler.leave(key);
                                }
                            } catch (RuntimeException e) {
                                VConsole.error(e);
                            }
                        }
                        Profiler.leave("Layout fire resize events - listeners not null");
                    }
                }
                listenersToFire.clear();


                Profiler.leave("Layout fire resize events");
            }


            Profiler.enter("LayoutManager handle ManagedLayout");


            FastStringSet updatedSet = FastStringSet.create();


            int layoutCount = 0;
            while (currentDependencyTree.hasHorizontalConnectorToLayout()
                    || currentDependencyTree.hasVerticaConnectorToLayout()) {


                JsArrayString layoutTargets = currentDependencyTree
                        .getHorizontalLayoutTargetsJsArray();
                int length = layoutTargets.length();
                for (int i = 0; i < length; i++) {
                    ManagedLayout layout = (ManagedLayout) connectorMap
                            .getConnector(layoutTargets.get(i));
                    if (layout instanceof DirectionalManagedLayout) {
                        currentDependencyTree
                                .markAsHorizontallyLayouted(layout);
                        DirectionalManagedLayout cl = (DirectionalManagedLayout) layout;
                        try {
                            String key = null;
                            if (Profiler.isEnabled()) {
                                key = "layoutHorizontally() for "
                                        + Util.getSimpleName(cl);
                                Profiler.enter(key);
                            }


                            cl.layoutHorizontally();
                            layoutCount++;


                            if (Profiler.isEnabled()) {
                                Profiler.leave(key);
                            }
                        } catch (RuntimeException e) {
                            VConsole.error(e);
                        }
                        countLayout(layoutCounts, cl);
                    } else {
                        currentDependencyTree
                                .markAsHorizontallyLayouted(layout);
                        currentDependencyTree.markAsVerticallyLayouted(layout);
                        SimpleManagedLayout rr = (SimpleManagedLayout) layout;
                        try {
                            String key = null;
                            if (Profiler.isEnabled()) {
                                key = "layout() for " + Util.getSimpleName(rr);
                                Profiler.enter(key);
                            }


                            rr.layout();
                            layoutCount++;


                            if (Profiler.isEnabled()) {
                                Profiler.leave(key);
                            }
                        } catch (RuntimeException e) {
                            VConsole.error(e);
                        }
                        countLayout(layoutCounts, rr);
                    }
                    if (debugLogging) {
                        updatedSet.add(layout.getConnectorId());
                    }
                }


                layoutTargets = currentDependencyTree
                        .getVerticalLayoutTargetsJsArray();
                length = layoutTargets.length();
                for (int i = 0; i < length; i++) {
                    ManagedLayout layout = (ManagedLayout) connectorMap
                            .getConnector(layoutTargets.get(i));
                    if (layout instanceof DirectionalManagedLayout) {
                        currentDependencyTree.markAsVerticallyLayouted(layout);
                        DirectionalManagedLayout cl = (DirectionalManagedLayout) layout;
                        try {
                            String key = null;
                            if (Profiler.isEnabled()) {
                                key = "layoutHorizontally() for "
                                        + Util.getSimpleName(cl);
                                Profiler.enter(key);
                            }


                            cl.layoutVertically();
                            layoutCount++;


                            if (Profiler.isEnabled()) {
                                Profiler.leave(key);
                            }
                        } catch (RuntimeException e) {
                            VConsole.error(e);
                        }
                        countLayout(layoutCounts, cl);
                    } else {
                        currentDependencyTree
                                .markAsHorizontallyLayouted(layout);
                        currentDependencyTree.markAsVerticallyLayouted(layout);
                        SimpleManagedLayout rr = (SimpleManagedLayout) layout;
                        try {
                            String key = null;
                            if (Profiler.isEnabled()) {
                                key = "layout() for " + Util.getSimpleName(rr);
                                Profiler.enter(key);
                            }


                            rr.layout();
                            layoutCount++;


                            if (Profiler.isEnabled()) {
                                Profiler.leave(key);
                            }
                        } catch (RuntimeException e) {
                            VConsole.error(e);
                        }
                        countLayout(layoutCounts, rr);
                    }
                    if (debugLogging) {
                        updatedSet.add(layout.getConnectorId());
                    }
                }
            }


            Profiler.leave("LayoutManager handle ManagedLayout");


            if (debugLogging) {
                JsArrayString changedCids = updatedSet.dump();


                StringBuilder b = new StringBuilder("  ");
                b.append(changedCids.length());
                b.append(" requestLayout invocations ");
                if (changedCids.length() < 30) {
                    for (int i = 0; i < changedCids.length(); i++) {
                        if (i != 0) {
                            b.append(", ");
                        } else {
                            b.append(": ");
                        }
                        String connectorString = changedCids.get(i);
                        if (changedCids.length() < 10) {
                            ServerConnector connector = ConnectorMap.get(
                                    connection).getConnector(connectorString);
                            connectorString = Util
                                    .getConnectorString(connector);
                        }

View Full Code Here

    }


    private int measureConnectors(LayoutDependencyTree layoutDependencyTree,
            boolean measureAll) {
        Profiler.enter("Layout overflow fix handling");
        JsArrayString pendingOverflowConnectorsIds = pendingOverflowFixes
                .dump();
        int pendingOverflowCount = pendingOverflowConnectorsIds.length();
        ConnectorMap connectorMap = ConnectorMap.get(connection);
        if (pendingOverflowCount > 0) {
            HashMap<Element, String> originalOverflows = new HashMap<Element, String>();


            FastStringSet delayedOverflowFixes = FastStringSet.create();


            // First set overflow to hidden (and save previous value so it can
            // be restored later)
            for (int i = 0; i < pendingOverflowCount; i++) {
                String connectorId = pendingOverflowConnectorsIds.get(i);
                ComponentConnector componentConnector = (ComponentConnector) connectorMap
                        .getConnector(connectorId);


                // Delay the overflow fix if the involved connectors might still
                // change
                boolean connectorChangesExpected = !currentDependencyTree
                        .noMoreChangesExpected(componentConnector);
                boolean parentChangesExcpected = componentConnector.getParent() instanceof ComponentConnector
                        && !currentDependencyTree
                                .noMoreChangesExpected((ComponentConnector) componentConnector
                                        .getParent());
                if (connectorChangesExpected || parentChangesExcpected) {
                    delayedOverflowFixes.add(connectorId);
                    continue;
                }


                if (debugLogging) {
                    VConsole.log("Doing overflow fix for "
                            + Util.getConnectorString(componentConnector)
                            + " in "
                            + Util.getConnectorString(componentConnector
                                    .getParent()));
                }
                Profiler.enter("Overflow fix apply");


                Element parentElement = componentConnector.getWidget()
                        .getElement().getParentElement();
                Style style = parentElement.getStyle();
                String originalOverflow = style.getOverflow();


                if (originalOverflow != null
                        && !originalOverflows.containsKey(parentElement)) {
                    // Store original value for restore, but only the first time
                    // the value is changed
                    originalOverflows.put(parentElement, originalOverflow);
                }


                style.setOverflow(Overflow.HIDDEN);
                Profiler.leave("Overflow fix apply");
            }


            pendingOverflowFixes.removeAll(delayedOverflowFixes);


            JsArrayString remainingOverflowFixIds = pendingOverflowFixes.dump();
            int remainingCount = remainingOverflowFixIds.length();


            Profiler.enter("Overflow fix reflow");
            // Then ensure all scrolling elements are reflowed by measuring
            for (int i = 0; i < remainingCount; i++) {
                ComponentConnector componentConnector = (ComponentConnector) connectorMap
                        .getConnector(remainingOverflowFixIds.get(i));
                componentConnector.getWidget().getElement().getParentElement()
                        .getOffsetHeight();
            }
            Profiler.leave("Overflow fix reflow");


            Profiler.enter("Overflow fix restore");
            // Finally restore old overflow value and update bookkeeping
            for (int i = 0; i < remainingCount; i++) {
                String connectorId = remainingOverflowFixIds.get(i);
                ComponentConnector componentConnector = (ComponentConnector) connectorMap
                        .getConnector(connectorId);
                Element parentElement = componentConnector.getWidget()
                        .getElement().getParentElement();
                parentElement.getStyle().setProperty("overflow",
                        originalOverflows.get(parentElement));


                layoutDependencyTree.setNeedsMeasure(connectorId, true);
            }
            Profiler.leave("Overflow fix restore");


            if (!pendingOverflowFixes.isEmpty()) {
                VConsole.log("Did overflow fix for " + remainingCount
                        + " elements");
            }
            pendingOverflowFixes = delayedOverflowFixes;
        }
        Profiler.leave("Layout overflow fix handling");


        int measureCount = 0;
        if (measureAll) {
            Profiler.enter("Layout measureAll");
            JsArrayObject<ComponentConnector> allConnectors = connectorMap
                    .getComponentConnectorsAsJsArray();
            int size = allConnectors.size();


            // Find connectors that should actually be measured
            JsArrayObject<ComponentConnector> connectors = JsArrayObject
                    .createArray().cast();
            for (int i = 0; i < size; i++) {
                ComponentConnector candidate = allConnectors.get(i);
                if (needsMeasure(candidate.getWidget().getElement())) {
                    connectors.add(candidate);
                }
            }


            int connectorCount = connectors.size();
            for (int i = 0; i < connectorCount; i++) {
                measureConnector(connectors.get(i));
            }
            for (int i = 0; i < connectorCount; i++) {
                layoutDependencyTree.setNeedsMeasure(connectors.get(i)
                        .getConnectorId(), false);
            }
            measureCount += connectorCount;


            Profiler.leave("Layout measureAll");
        }


        Profiler.enter("Layout measure from tree");
        while (layoutDependencyTree.hasConnectorsToMeasure()) {
            JsArrayString measureTargets = layoutDependencyTree
                    .getMeasureTargetsJsArray();
            int length = measureTargets.length();
            for (int i = 0; i < length; i++) {
                ComponentConnector connector = (ComponentConnector) connectorMap
                        .getConnector(measureTargets.get(i));
                measureConnector(connector);
                measureCount++;
            }
            for (int i = 0; i < length; i++) {
                String connectorId = measureTargets.get(i);
                layoutDependencyTree.setNeedsMeasure(connectorId, false);
            }
        }
        Profiler.leave("Layout measure from tree");

View Full Code Here

        assert widthChanged || heightChanged;


        Profiler.enter("LayoutManager.notifyListenersAndDepdendents");


        MeasuredSize measuredSize = getMeasuredSize(element, nullSize);
        JsArrayString dependents = measuredSize.getDependents();
        for (int i = 0; i < dependents.length(); i++) {
            String pid = dependents.get(i);
            if (pid != null) {
                if (heightChanged) {
                    currentDependencyTree.setNeedsVerticalLayout(pid, true);
                }
                if (widthChanged) {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.google.gwt.core.client.JsArrayString

com.alkacon.vie.client.Entity

com.bramosystems.oss.player.playlist.client.spf.SPFPlaylist

com.bramosystems.oss.player.youtube.client.YouTubeBasePlayer

com.changestuffs.client.widget.texteditor.TextEditorView

com.denisk.appengine.nl.client.ui.parts.net.elitecoderz.blog.RichTextToolbar

com.denormans.facebookgwt.gwtutil.client.js.EnhancedJSObject

com.emitrom.touch4j.charts.client.AbstractChart

com.emitrom.touch4j.charts.client.axis.AbstractAxis

com.emitrom.touch4j.charts.client.series.AbstractSeries

com.emitrom.touch4j.charts.client.series.CartesianSeries

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.