import com.codename1.ui.Component; //导入依赖的package包/类
private static void selectListOffset(Component c, int offset) {
    assertBool(c != null, "List not found");
    if(c instanceof List) {
        ((List)c).setSelectedIndex(offset);
        return;
    }
    if(c instanceof ContainerList) {
        ((ContainerList)c).setSelectedIndex(offset);
        return;
    }
    if(c instanceof GenericSpinner) {
        ((GenericSpinner)c).getModel().setSelectedIndex(offset);
        return;
    }
    assertBool(false, "Unsupported list type: " + c.getName());
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
private void calcPreferredValues(Component cmp) {
    if (tmpLaidOut.contains(cmp)) {
        return;
    }
    tmpLaidOut.add(cmp);
    LayeredLayoutConstraint constraint = (LayeredLayoutConstraint) getComponentConstraint(cmp);
    if (constraint != null) {
        constraint.fixDependencies(cmp.getParent());
        for (LayeredLayoutConstraint.Inset inset : constraint.insets) {
            if (inset.referenceComponent != null && inset.referenceComponent.getParent() == cmp.getParent()) {
                calcPreferredValues(inset.referenceComponent);
            }
            inset.calcPreferredValue(cmp.getParent(), cmp);
        }
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Called when the form is created to set the current state.
 */
public void setState(Form f, Map state) {
    List list = getList(f);

    f.putClientProperty(list.getName()+"ScrollY", state.get(list.getName()+"ScrollY"));

    /**
     * On loading the view for the list, it animates a scroll to the selected position.
     * This position will overwrite the previous ScrollY position if the element is out-of-scope.
     *
     * @see UIBuilder.setContainerStateImpl(Container cnt, Hashtable state)
     */
    String cmpName = (String)state.get(StateMachine.FORM_STATE_KEY_FOCUS);
    if(cmpName != null) {
        Component c = ui.findByName(cmpName, f);
        if(c != null) {
            c.requestFocus();
            if(c instanceof List) {
                Integer i = (Integer)state.get(StateMachine.FORM_STATE_KEY_SELECTION);
                if(i != null) {
                    ((List)c).setSelectedIndex(i.intValue());
                }
            }
        }
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Removes an existing component replacing it with the specified component.
 *
 * @param existingComponent the Component that should be removed and
 *        replaced with newComponent
 * @param newComponent the Component to put in existingComponents place
 * @throws IllegalArgumentException is either of the Components are null or
 *         if existingComponent is not being managed by this layout manager
 */
public void replace(Component existingComponent, Component newComponent) {
    if (existingComponent == null || newComponent == null) {
        throw new IllegalArgumentException("Components must be non-null");
    }
    // Make sure all the components have been registered, otherwise we may
    // not update the correct Springs.
    if (springsChanged) {
        registerComponents(horizontalGroup, HORIZONTAL);
        registerComponents(verticalGroup, VERTICAL);
    }
    ComponentInfo info = (ComponentInfo)componentInfos.
            remove(existingComponent);
    if (info == null) {
        throw new IllegalArgumentException("Component must already exist");
    }
    host.removeComponent(existingComponent);
    if (newComponent.getParent() != host) {
        host.addComponent(newComponent);
    }
    info.setComponent(newComponent);
    componentInfos.put(newComponent, info);
    invalidateHost();
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
public void addLayoutComponent(Object constraints, Component comp, Container c) {
    GridBagConstraints cons;
    if (constraints != null) {
        if (!(constraints instanceof GridBagConstraints)) {
            throw new IllegalArgumentException("AddLayoutComponent: constraint object must be GridBagConstraints"); //$NON-NLS-1$
        }
        cons = (GridBagConstraints) constraints;
    } else {
        if (comptable.containsKey(comp)) {
            //  don't replace constraints with default ones
            return;
        }
        cons = defaultConstraints;
    }
    /*try {
        //cons.verify();
    } catch (IllegalArgumentException e) {
        // awt.81=AddLayoutComponent: {0}
        throw new IllegalArgumentException("AddLayoutComponent: " + e.getMessage()); //$NON-NLS-1$
    }*/
    GridBagConstraints consClone = (GridBagConstraints) cons.clone();
    comptable.put(comp, consClone);
    Container parent = comp.getParent();
    updateParentInfo(parent, consClone);
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
private ComponentSpring(Component component, int min, int pref,
        int max) {
    this.component = component;
    if (component == null) {
        throw new IllegalArgumentException(
                "Component must be non-null");
    }
    checkSize(min, pref, max, true);
    
    this.min = min;
    this.max = max;
    this.pref = pref;
    
    // getComponentInfo makes sure component is a child of the
    // Container GroupLayout is the LayoutManager for.
    getComponentInfo(component);
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Returns a mask of the STYLE_* constants of which CodenameOne styles this selector should be applied to
 *
 * @param cmp The component in question
 * @param selector The selector
 * @return a mask of the STYLE_* constants of which CodenameOne styles this selector should be applied to
 */
private int getApplicableStyles(Component cmp,CSSElement selector) {
    int result=0;
    if (cmp instanceof HTMLLink) {
        int pseudoClass=selector.getSelectorPseudoClass();
        boolean done=false;
        if ((pseudoClass & CSSElement.PC_FOCUS)!=0) { // Focused (i.e. CSS focus/hover)
            result|=STYLE_SELECTED;
            done=true;
        }
        if ((pseudoClass & CSSElement.PC_ACTIVE)!=0) { // active in CSS means pressed in CodenameOne
            result|=STYLE_PRESSED;
            done=true;
        }

        if (!done) {
            result|=STYLE_SELECTED|STYLE_UNSELECTED;
        }
    } else {
            result|=STYLE_SELECTED|STYLE_UNSELECTED;
    }
    return result;
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
private Container findEmptyContainer(Container c) {
    int count = c.getComponentCount();
    if(count == 0) {
        return c;
    }
    for(int iter = 0 ; iter < count ; iter++) {
        Component x = c.getComponentAt(iter);
        if(x instanceof Container) {
            Container current = findEmptyContainer((Container)x);
            if(current != null) {
                return current;
            }
        }
    }
    return null;
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Tries to assign the given key string as an access key to the specified component
 * The key string given here is a single key
 *
 * @param keyStr The string representing the key (either a character, a unicode escape sequence or a special key name
 * @param htmlC The HTMLComponent
 * @param ui The component to set the access key on
 * @param override If true overrides other keys assigned previously for this component
 * @return true if successful, false otherwise
 */
private boolean processAccessKey(String keyStr,HTMLComponent htmlC,Component ui,boolean override) {
    if (keyStr.startsWith("\\")) { // Unicode escape sequence, may be used to denote * and # which technically are illegal as values
        try {
            int keyCode=Integer.parseInt(keyStr.substring(1), 16);
            htmlC.addAccessKey((char)keyCode, ui, override);
            return true;
        } catch (NumberFormatException nfe) {
            return false;

        }
    } else if (keyStr.length()==1) {
        htmlC.addAccessKey(keyStr.charAt(0), ui, override);
        return true;
    } else { //special key shortcut
        if (specialKeys!=null) {
            Integer key=(Integer)specialKeys.get(keyStr);
            if (key!=null) {
                htmlC.addAccessKey(key.intValue(), ui, override);
                return true;
            }
        }
        return false;
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
private void launchAd() {
    Component c = getComponentAt(0);
    if (c instanceof HTMLComponent) {
        HTMLComponent h = (HTMLComponent) c;
        h.setSupressExceptions(true);
        HTMLElement dom = h.getDOM();
        Vector links = dom.getDescendantsByTagName("a");
        if (links.size() > 0) {
            HTMLElement e = (HTMLElement) links.elementAt(0);
            String link = e.getAttribute("href");
            if (link != null) {
                Display.getInstance().execute(link);
            }
        }
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
protected Form wrap(String title, Component c){
    c.getStyle().setBgColor(0xff0000);
    Form f = new Form(title);
    f.setLayout(new BorderLayout());
    if (isDrawOnMutableImage()) {
        int dispW = Display.getInstance().getDisplayWidth();
        int dispH = Display.getInstance().getDisplayHeight();
        Image img = Image.createImage((int)(dispW * 0.8), (int)(dispH * 0.8), 0x0);
        Graphics g = img.getGraphics();
        c.setWidth((int)(dispW * 0.8));
        c.setHeight((int)(dispH * 0.8));
        c.paint(g);
        f.addComponent(BorderLayout.CENTER, new Label(img));
    } else {
      f.addComponent(BorderLayout.CENTER, c);
    }
    
    return f;
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
void refreshZoom(Container solitairContainer) {
    int dpi =  DPIS[currentZoom / 5];
    Preferences.set("dpi", dpi);
    Preferences.set("zoom", currentZoom);
    try {
        cards = Resources.open("/gamedata.res",dpi);
        cardImageCache.clear();
        Image cardBack = getCardImage("card_back.png");
        for(Component c : solitairContainer) {
            CardComponent crd = (CardComponent)c;
            crd.setImages(getCardImage(crd.getCard().getFileName()), cardBack);
        }
        solitairContainer.revalidate();
        solitairContainer.getParent().replace(solitairContainer.getParent().getComponentAt(0), createPlacementContainer(solitairContainer), null);
    } catch(IOException e) {
        Log.e(e);
    }        
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
private void paintShiftFadeHierarchy(Container c, int alpha, Graphics g, boolean incoming) {
    int componentCount = c.getComponentCount();
    for(int iter = 0 ; iter < componentCount ; iter++) {
        Component current = c.getComponentAt(iter);
        if(current instanceof Container) {
            paintShiftFadeHierarchy((Container)current, alpha, g, incoming);
            continue;
        }
        g.setAlpha(alpha);
        Motion m = getComponentShiftMotion(current, incoming);
        if(m != null) {
            int tval = m.getValue();
            g.translate(tval, 0);
            current.paintComponent(g, false);
            g.translate(-tval, 0);
        }
        g.setAlpha(255);
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Adds an element representing the preferred gap between the two
 * components.
 * 
 * @param comp1 the first component
 * @param comp2 the second component
 * @param type the type of gap; one of the constants defined by
 *        LayoutStyle
 * @param canGrow true if the gap can grow if more
 *                space is available
 * @return this <code>SequentialGroup</code>
 * @throws IllegalArgumentException if <code>type</code> is not a
 *         valid LayoutStyle constant
 * @see LayoutStyle
 */
public SequentialGroup addPreferredGap(Component comp1,
        Component comp2,
        int type, boolean canGrow) {
    if (type != LayoutStyle.RELATED &&
            type != LayoutStyle.UNRELATED &&
            type != LayoutStyle.INDENT) {
        throw new IllegalArgumentException("Invalid type argument");
    }
    if (comp1 == null || comp2 == null) {
        throw new IllegalArgumentException(
                "Components must be non-null");
    }
    return (SequentialGroup)addSpring(new PaddingSpring(
            comp1, comp2, type, canGrow));
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Returns the component constraint
 * 
 * @param comp the component whose constraint is queried
 * @return one of the constraints defined in this class
 */
public Object getComponentConstraint(Component comp) {
    if (comp == portraitCenter) {
        return CENTER;
    } else if (comp == portraitNorth) {
        return NORTH;
    } else if (comp == portraitSouth) {
        return SOUTH;
    } else if (comp == portraitEast) {
        return EAST;
    } else if (comp == overlay) {
        return OVERLAY;
    } else {
        if(comp == portraitWest) {
            return WEST;
        }
    }
    return null;
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Implements the drawString for the text component and adjust the valign
 * assuming the icon is in one of the sides
 */
private int drawLabelStringValign(AndroidGraphics underlying, 
        CodenameOneTextPaint nativeFont, String str, int x, int y, int textSpaceW,
        boolean isTickerRunning, int tickerShiftText, int textDecoration, boolean rtl,
        boolean endsWith3Points, int textWidth,
        int iconStringHGap, int iconHeight, int fontHeight, int valign, Bitmap textCache) {
    if(str.length() == 0) {
        return 0;
    }
    switch (valign) {
        case Component.TOP:
            return drawLabelString(underlying, nativeFont, str, x, y, textSpaceW, isTickerRunning, tickerShiftText, textDecoration, rtl, endsWith3Points, textWidth, fontHeight, textCache);
        case Component.CENTER:
            return drawLabelString(underlying, nativeFont, str, x, y + iconHeight / 2 - fontHeight / 2, textSpaceW, isTickerRunning, tickerShiftText, textDecoration, rtl, endsWith3Points, textWidth, fontHeight, textCache);
        default:
            return drawLabelString(underlying, nativeFont, str, x, y + iconStringHGap, textSpaceW, isTickerRunning, tickerShiftText, textDecoration, rtl, endsWith3Points, textWidth, fontHeight, textCache);
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
public void removeLayoutComponent(Component comp) {
    if (comp == portraitCenter) {
        portraitCenter = null;
    } else if (comp == portraitNorth) {
        portraitNorth = null;
    } else if (comp == portraitSouth) {
        portraitSouth = null;
    } else if (comp == portraitEast) {
        portraitEast = null;
    } else if (comp == portraitWest) {
        portraitWest = null;
    } else if (comp == overlay) {
        overlay = null;
    }
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
public void onQueueAction(Component c, ActionEvent event) 
{
    event.consume();
    final List list = (List) event.getSource();
    final Map item = (Map)list.getSelectedItem();

    Button clickedButton = ((GenericListCellRenderer)list.getRenderer()).extractLastClickedComponent();
    if (clickedButton != null) {
        // Occurs when touching a button

        if (clickedButton.getName().equals("btnMediaActionFixed")) {
            ArrayList<Command> commands = new ArrayList<Command>();

            Image icon = StateMachine.getResourceFile().getImage("popup_trash_icon.png");
            icon.lock();
            commands.add(new Command(ui.translate("command_remove_item_from_playlist", "[default]Remove item"), icon) {

                @Override
                public void actionPerformed(ActionEvent evt) {
                    ui.player.removeFromQueue((Map) list.getSelectedItem());
                    if(ui.player.isQueueEmpty())
                    {
                        Display.getInstance().getCurrent().setTransitionOutAnimator(CommonTransitions.createEmpty());
                        ui.playerView.setFromMiniPlayer(false);
                        ui.back();
                        ui.back();
                    }
                    else
                        initQueueModel(list);
                }
            });
            ui.dialogOptions.show(commands);
            return;
        }
    }
    
    ui.player.setQueueAndPlay((TrackListModel) list.getModel());
    Display.getInstance().getCurrent().setTransitionOutAnimator(CommonTransitions.createFade(200));
    ui.back();
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
void initSpinnerRenderer() {
    DefaultListCellRenderer render = ((DefaultListCellRenderer) super.getRenderer());
    render.setRTL(false);
    setRTL(false);
    render.setShowNumbers(false);
    render.setUIID("SpinnerRenderer");
    Component bgFocus = render.getListFocusComponent(this);
    bgFocus.setUIID("SpinnerRendererFocus");
    bgFocus.getSelectedStyle().setBgTransparency(0);
    bgFocus.getUnselectedStyle().setBgTransparency(0);
    render.setAlwaysRenderSelection(true);
}
 

import com.codename1.ui.Component; //导入依赖的package包/类
/**
 * Reverses alignment in the case of bidi
 */
private int reverseAlignForBidi(Component c, int align) {
    if(c.isRTL()) {
        switch(align) {
            case Component.RIGHT:
                return Component.LEFT;
            case Component.LEFT:
                return Component.RIGHT;
        }
    }
    return align;
}