Examples of pivot.wtk.Component

pivot.wtk.Component
Top level abstract base class for all components. In MVC terminology, a component represents the "controller". It has no inherent visual representation and acts as an intermediary between the component's data (the "model") and the skin, an implementation of {@link Skin} which serves asthe "view".
TODO Add a contains() method or some equivalent that will support mouse interaction with non-rectangular components.

    @Override
    public int getPreferredWidth(int height) {
        int preferredWidth = 0;


        Sheet sheet = (Sheet)getComponent();
        Component content = sheet.getContent();


        if (content != null
            && content.isDisplayable()) {
            if (height != -1) {
                height = Math.max(height - (padding.top + padding.bottom + 2), 0);
            }


            preferredWidth = content.getPreferredWidth(height);
        }


        preferredWidth += (padding.left + padding.right + 2);


        return preferredWidth;

View Full Code Here

    @Override
    public int getPreferredHeight(int width) {
        int preferredHeight = 0;


        Sheet sheet = (Sheet)getComponent();
        Component content = sheet.getContent();


        if (content != null
            && content.isDisplayable()) {
            if (width != -1) {
                width = Math.max(width - (padding.left + padding.right + 2), 0);
            }


            preferredHeight = content.getPreferredHeight(width);
        }


        preferredHeight += (padding.top + padding.bottom + 2);


        return preferredHeight;

View Full Code Here

    public Dimensions getPreferredSize() {
        int preferredWidth = 0;
        int preferredHeight = 0;


        Sheet sheet = (Sheet)getComponent();
        Component content = sheet.getContent();


        if (content != null
            && content.isDisplayable()) {
            Dimensions preferredContentSize = content.getPreferredSize();
            preferredWidth = preferredContentSize.width;
            preferredHeight = preferredContentSize.height;
        }


        preferredWidth += (padding.left + padding.right + 2);

View Full Code Here

    public void layout() {
        int width = getWidth();
        int height = getHeight();


        Sheet sheet = (Sheet)getComponent();
        Component content = sheet.getContent();


        if (content != null) {
            if (content.isDisplayable()) {
                content.setVisible(true);


                content.setLocation(padding.left + 1, padding.top + 1);


                int contentWidth = Math.max(width - (padding.left + padding.right + 2), 0);
                int contentHeight = Math.max(height - (padding.top + padding.bottom + 2), 0);


                content.setSize(contentWidth, contentHeight);
            } else {
                content.setVisible(false);
            }
        }
    }

View Full Code Here


        // Preferred width is the max of our childrens' preferred widths, plus
        // the button width, buffer, and padding. If we're collapsed, we only
        // look at the first child.
        for (int i = 0, n = rollup.getLength(); i < n; i++) {
            Component component = rollup.get(i);


            if (component == rollupButton) {
                // Ignore "private" component
                continue;
            }


            if (component.isDisplayable()) {
                int componentPreferredWidth = component.getPreferredWidth(-1);
                preferredWidth = Math.max(preferredWidth, componentPreferredWidth);
            }


            if (!rollup.isExpanded()) {
                // If we're collapsed, we only look at the first child.

View Full Code Here


        int preferredHeight = 0;


        int displayableComponentCount = 0;
        for (int i = 0, n = rollup.getLength(); i < n; i++) {
            Component component = rollup.get(i);


            if (component == rollupButton) {
                // Ignore "private" component
                continue;
            }


            if (component.isDisplayable()) {
                preferredHeight += component.getPreferredHeight(width);
                displayableComponentCount++;
            }


            if (!expanded) {
                // If we're collapsed, we only look at the first child.

View Full Code Here


        int x = rollupButtonSize.width + buffer;
        int y = 0;
        int justifiedWidth = Math.max(getWidth() - rollupButtonSize.width - buffer, 0);


        Component firstComponent = null;


        for (int i = 0, n = rollup.getLength(); i < n; i++) {
            Component component = rollup.get(i);


            if (component == rollupButton) {
                // Ignore "private" component
                continue;
            }


            if (firstComponent == null) {
                firstComponent = component;
            }


            if ((component == firstComponent
                || rollup.isExpanded())
                && component.isDisplayable()) {
                // We lay this child out and make sure it's painted.
                component.setVisible(true);


                int componentWidth, componentHeight;
                if (justify) {
                    componentWidth = justifiedWidth;
                    componentHeight = component.getPreferredHeight(componentWidth);
                } else {
                    Dimensions componentPreferredSize = component.getPreferredSize();
                    componentWidth = componentPreferredSize.width;
                    componentHeight = componentPreferredSize.height;
                }


                component.setLocation(x, y);
                component.setSize(componentWidth, componentHeight);


                y += componentHeight + spacing;
            } else {
                // We make sure this child doesn't get painted.  There's also
                // no need to lay the child out.
                component.setVisible(false);
            }
        }


        int rollupButtonY = (firstComponent == null) ?
            0 : (firstComponent.getHeight() - rollupButtonSize.height) / 2 + 1;

View Full Code Here

        rollupButton.setCursor(cursor);
    }


    private void updateToggleComponent() {
        Rollup rollup = (Rollup)getComponent();
        Component previousToggleComponent = toggleComponent;


        toggleComponent = null;
        if (firstChildToggles) {
            for (int i = 0, n = rollup.getLength(); i < n; i++) {
                Component child = rollup.get(i);
                if (child != rollupButton) {
                    toggleComponent = child;
                    break;
                }
            }

View Full Code Here


        for (int i = 0; i < rowCount; i++) {
            TablePane.Row row = rows.get(i);


            for (int j = 0, n = row.getLength(); j < n && j < columnCount; j++) {
                Component component = row.get(j);


                if (component != null
                    && component.isDisplayable()) {
                    int columnSpan = TablePane.getColumnSpan(component);


                    if (columnSpan > 1) {
                        // We might need to adjust column widths to accomodate
                        // this spanning cell. First, we find out if any of the
                        // spanned cells are default width and how much space
                        // we've allocated thus far for those cells


                        int spannedDefaultWidthCellCount = 0;
                        int spannedRelativeWeight = 0;
                        int spannedWidth = 0;


                        for (int k = 0; k < columnSpan && j + k < columnCount; k++) {
                            if (defaultWidthColumns[j + k]) {
                                spannedDefaultWidthCellCount++;
                            }


                            spannedRelativeWeight += relativeWeights[j + k];
                            spannedWidth += columnWidths[j + k];
                        }


                        if (spannedRelativeWeight > 0
                            || spannedDefaultWidthCellCount > 0) {
                            int rowHeight = row.isRelative() ? -1 : row.getHeight();
                            int componentPreferredWidth = component.getPreferredWidth(rowHeight);


                            if (componentPreferredWidth > spannedWidth) {
                                // The component's preferred width is larger
                                // than the width we've allocated thus far, so
                                // an adjustment is necessary

View Full Code Here


        for (int i = 0; i < rowCount; i++) {
            TablePane.Row row = rows.get(i);


            for (int j = 0, n = row.getLength(); j < n && j < columnCount; j++) {
                Component component = row.get(j);


                if (component != null
                    && component.isDisplayable()) {
                    int rowSpan = TablePane.getRowSpan(component);


                    if (rowSpan > 1) {
                        // We might need to adjust row heights to accomodate
                        // this spanning cell. First, we find out if any of the
                        // spanned cells are default height and how much space
                        // we've allocated thus far for those cells


                        int spannedDefaultHeightCellCount = 0;
                        int spannedRelativeWeight = 0;
                        int spannedHeight = 0;


                        for (int k = 0; k < rowSpan && i + k < rowCount; k++) {
                            if (defaultHeightRows[i + k]) {
                                spannedDefaultHeightCellCount++;
                            }


                            spannedRelativeWeight += relativeWeights[i + k];
                            spannedHeight += rowHeights[i + k];
                        }


                        if (spannedRelativeWeight > 0
                            || spannedDefaultHeightCellCount > 0) {
                            int componentPreferredHeight =
                                component.getPreferredHeight(columnWidths[j]);


                            if (componentPreferredHeight > spannedHeight) {
                                // The component's preferred height is larger
                                // than the height we've allocated thus far, so
                                // an adjustment is necessary

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of pivot.wtk.Component

pivot.beans.BeanDictionary

pivot.demos.tables.FixedColumnTable

pivot.demos.transition.TransitionDemo

pivot.serialization.JSONSerializer

pivot.tutorials.buttons.Checkboxes

pivot.tutorials.buttons.LinkButtons

pivot.tutorials.buttons.PushButtons

pivot.tutorials.buttons.RadioButtons

pivot.tutorials.buttons.ToggleButtons

pivot.tutorials.Demo

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.