1

这是我的navigationMovement()：

protected boolean navigationMovement(int dx, int dy, int status, int time) {

        int focusIndex = getFieldWithFocusIndex();

        while (dy > 0) {
            if (focusIndex >= getFieldCount()) {
                return false;
            } else {
                Field f = getField(focusIndex);
                if (f.isFocusable()) {
                    f.setFocus();
                    dy--;
                }
            }
        }

        while (dy < 0) {
            if (focusIndex < 0) {
                return false;
            } else {
                Field f = getField(focusIndex);

                if (f.isFocusable()) {
                    f.setFocus();
                    dy++;
                }
            }
        }

        while (dx > 0) {
            focusIndex++;

            if (focusIndex >= getFieldCount()) {
                return false;
            } else {
                Field f = getField(focusIndex);

                if (f.isFocusable()) {
                    f.setFocus();
                    dx--;
                }
            }
        }

        while (dx < 0) {
            focusIndex--;

            if (focusIndex < 0) {
                return false;
            } else {
                Field f = getField(focusIndex);

                if (f.isFocusable()) {
                    f.setFocus();
                    dx++;
                }
            }
        }

        return true;
}

这只允许滚轮左右滚动，但我想要上、下、左和右。

我的布局是这样的。

它是 3 行 x 4 列。

这段代码正在检查getField(0->10)，这就是为什么它不能从 0 到 4。

我希望它可以在各个方向移动。如何实施？

更新

protected void sublayout(int width, int height) {
        int y = 0;

        Field[] fields = new Field[columnWidths.length];
        int currentColumn = 0;
        int rowHeight = 0;

        for (int i = 0; i < getFieldCount(); i++) {
            fields[currentColumn] = getField(i);
            fields[currentColumn]
                    .setChangeListener(new FieldChangeListener() {
                        public void fieldChanged(Field field, int context) {
                            final int focusIndex = getFieldWithFocusIndex();
                            if (focusIndex == position) {
                                Main.getUiApplication().popScreen(
                                        mainscreen);
                            } else {
                                Main.getUiApplication().popScreen(
                                        mainscreen);
                                Main.getUiApplication().pushScreen(
                                        new Custom_LoadingScreen(1));
                                Main.getUiApplication().invokeLater(
                                        new Runnable() {
                                            public void run() {
                                                if (focusIndex == 0)
                                                    Main.getUiApplication()
                                                            .pushScreen(
                                                                    new Main_AllLatestNews());
                                                else
                                                    Main.getUiApplication()
                                                            .pushScreen(
                                                                    new Main_ParticularCategoryAllNews(
                                                                            catnewsid[focusIndex],
                                                                            focusIndex,
                                                                            cattitle[focusIndex]));
                                            }
                                        }, 1 * 1000, false);
                            }
                        }
                    });
            layoutChild(fields[currentColumn], columnWidths[currentColumn],
                    height - y);

            if (fields[currentColumn].getHeight() > rowHeight) {
                rowHeight = fields[currentColumn].getHeight() + 10;
            }

            currentColumn++;

            if ((currentColumn == columnWidths.length)
                    || (i == (getFieldCount() - 1))) {
                int x = 0;

                if (this.allRowHeight >= 0) {
                    rowHeight = this.allRowHeight;
                }

                for (int c = 0; c < currentColumn; c++) {
                    long fieldStyle = fields[c].getStyle();
                    int fieldXOffset = 0;
                    long fieldHalign = fieldStyle & Field.FIELD_HALIGN_MASK;

                    if (fieldHalign == Field.FIELD_RIGHT) {
                        fieldXOffset = columnWidths[c]
                                - fields[c].getWidth();
                    } else if (fieldHalign == Field.FIELD_HCENTER) {
                        fieldXOffset = (columnWidths[c] - fields[c]
                                .getWidth()) / 2;
                    }

                    int fieldYOffset = 0;
                    long fieldValign = fieldStyle & Field.FIELD_VALIGN_MASK;

                    if (fieldValign == Field.FIELD_BOTTOM) {
                        fieldYOffset = rowHeight - fields[c].getHeight();
                    } else if (fieldValign == Field.FIELD_VCENTER) {
                        fieldYOffset = (rowHeight - fields[c].getHeight()) / 2;
                    }

                    setPositionChild(fields[c], x + fieldXOffset, y
                            + fieldYOffset);
                    x += columnWidths[c];
                }

                currentColumn = 0;
                y += rowHeight;
            }

            if (y >= height) {
                break;
            }
        }

        int totalWidth = 0;

        for (int i = 0; i < columnWidths.length; i++) {
            totalWidth += columnWidths[i];
        }

        if (position > -1) {
            Field f = getField(position);
            f.setFocus();
        }

        setExtent(totalWidth, Math.min(y, height));
    }
}
4

3 回答 3

1

您以相同方式处理 dx 和 dy 的代码问题。您需要以不同方式计算下一个前一个索引，具体取决于它是水平滚动还是垂直。

顺便说一句，你用什么经理？FlowFieldManager? 因为我认为它应该在默认navigationMovement实现中按预期工作。

于 2012-08-01T12:35:32.330 回答
0

我只是找到了每次移动+/-列大小的解决方案

while (dy > 0) {
            if (focusIndex + columnwidth.length >= getFieldCount()) {
                return false;
            } else {
                Field f = getField(focusIndex + columnwidth.length);
                if (f.isFocusable()) {
                    f.setFocus();
                    dy--;
                }
            }
        }

while (dy < 0) {
            if (focusIndex - columnwidth.length < 0) {
                return false;
            } else {
                Field f = getField(focusIndex - columnwidth.length);

                if (f.isFocusable()) {
                    f.setFocus();
                    dy++;
                }
            }
        }
于 2012-08-02T06:28:02.773 回答
0

navigationMovement默认将提供对所有可聚焦组件的焦点。重要的是您使用了什么布局以及如何安排这些管理器。你有行、列的结构，所以如果你对一行使用水平管理器，它的元素将获得焦点，在完成所有元素后，焦点将下降到第二个水平管理器。

于 2012-08-01T19:05:38.547 回答