Question

Here is my 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;
}

This only allows the track wheel to scroll left and right, but I want up, down, left and right.

my layout is this.

It is a 3 rows x 4 columns.

This code is checking getField(0->10), that’s why it cannot from 0 to 4.

I want it to be movable in all directions. How to implement that?

Updated

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));
    }
}

Answer 1

I just find the solution which is each move +/- column size

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++;
                }
            }
        }