Display Calendar in Blackberry

The following code will display Calendar in blackberry.

public class CalendarPopupScreen extends MainScreen {

    private static SimpleDateFormat sdfWeekDay = new SimpleDateFormat("E");
    private static SimpleDateFormat sdfMonth = new SimpleDateFormat("MMMM yyyy");
    private static String SINGLE_BLANK = " ";
    private static String FIELD_SIZE_STRING = " 30 ";
    private int _selectedDay = -1;
    private int _currentFocusDay;
    private int _currentMonth;
    private String _currentMonthString;
    private int _currentYear;
    private Calendar _cl = Calendar.getInstance();
    private ButtonBorderedLabelField _prevMonthButton;
    private LabelField _currentMonthField;
    private ButtonBorderedLabelField _nextMonthButton;
    private static int [] tableStyles = new int [] {
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH,
        TableLayoutManager.FIXED_WIDTH
    };

    private int [] tableSizes = new int [7] ;
    private TableLayoutManager _monthManager;
    private Field _initialFocusField = null;
    private Font _normalFont;
    private Font _boldFont;

    public CalendarPopupScreen() {
        this(new Date());
    }

    public CalendarPopupScreen(long dateMilliSecs) {
        this(new Date(dateMilliSecs));
    }

    public CalendarPopupScreen(Date selectedDate) {
       _cl.setTime(selectedDate);
        createScreen(_cl.get(Calendar.DAY_OF_MONTH), _cl.get(Calendar.MONTH) + 1, _cl.get(Calendar.YEAR));
    }

    public CalendarPopupScreen(int focusDay, int startMonth, int startYear) {
        createScreen(focusDay, startMonth, startYear);
    }

    protected void onDisplay() {
        if ( _initialFocusField != null ) {
            _initialFocusField.setFocus();
            _initialFocusField = null;
        }
        super.onDisplay();
    }

    private void createScreen(int focusDay, int startMonth, int startYear) {
        _currentFocusDay = focusDay;
        _currentMonth = startMonth;
        _currentYear = startYear;

        _normalFont = this.getFont().derive(Font.PLAIN);
        if ( _normalFont.getAdvance(FIELD_SIZE_STRING) > Display.getWidth()/10 ) {
            do {
                _normalFont = _normalFont.derive(Font.PLAIN, _normalFont.getHeight()-1);
            } while ( _normalFont.getAdvance(FIELD_SIZE_STRING) > Display.getWidth()/10 );
            this.setFont(_normalFont);
        }
        _boldFont = _normalFont.derive(Font.BOLD);

        HorizontalFieldManager hfm = new HorizontalFieldManager(HorizontalFieldManager.FIELD_HCENTER);
        _prevMonthButton = new ButtonBorderedLabelField(SINGLE_BLANK + Characters.BLACK_LEFT_POINTING_TRIANGLE + SINGLE_BLANK,LabelField.FOCUSABLE);
        hfm.add(_prevMonthButton);
        _currentMonthField = new LabelField(SINGLE_BLANK + _currentMonthString + SINGLE_BLANK);
        hfm.add(_currentMonthField);
        _nextMonthButton = new ButtonBorderedLabelField(SINGLE_BLANK + Characters.BLACK_RIGHT_POINTING_TRIANGLE + SINGLE_BLANK,LabelField.FOCUSABLE);
        hfm.add(_nextMonthButton);
        this.add(hfm);
        this.add(new VerticalSpacerField(3));

        int columnSize = this.getFont().getAdvance(FIELD_SIZE_STRING);
        for ( int i = 0; i < tableSizes.length; i++ ) {
            tableSizes[i] = columnSize;
        }
        _monthManager = new TableLayoutManager(tableStyles, tableSizes, 0, TableLayoutManager.FIELD_HCENTER);
        this.add(_monthManager);
        this.setBorder(BorderFactory.createSimpleBorder(new XYEdges()));
      
        displayMonth();

    }

    private void displayMonth() {

        _monthManager.deleteAll();
       
       
        _cl.set(Calendar.DAY_OF_MONTH, 1);
        _cl.set(Calendar.MONTH, _currentMonth - 1);
        _cl.set(Calendar.YEAR, _currentYear);
        _cl.set(Calendar.HOUR_OF_DAY, 12);
        _cl.set(Calendar.MINUTE, 0);
        _cl.set(Calendar.SECOND, 0);
        _cl.set(Calendar.MILLISECOND, 1);
        long startOfMonth = _cl.getTime().getTime(); 

        _currentMonthString = sdfMonth.formatLocal(_cl.getTime().getTime());
        _currentMonthField.setText(SINGLE_BLANK + _currentMonthString + SINGLE_BLANK);

       int workDay = _cl.get(Calendar.DAY_OF_WEEK);
     
        int startAt = 0;
        switch (workDay) {
            case(Calendar.MONDAY): {
                startAt = -1;
                break;
            }
            case(Calendar.TUESDAY): {
                startAt = -2;
                break;
            }
            case(Calendar.WEDNESDAY): {
                startAt = -3;
                break;
            }
            case(Calendar.THURSDAY): {
                startAt = -4;
                break;
            }
            case(Calendar.FRIDAY): {
                startAt = -5;
                break;
            }
            case(Calendar.SATURDAY): {
                startAt = -6;
                break;
            }
            case(Calendar.SUNDAY): {
                startAt = -6;
                break;
            }
        }
        Date workDate = _cl.getTime();
        long workDateTime;
    
        if(workDay==1){
            workDateTime = workDate.getTime() + ((long)startAt);
       }else{
            workDateTime = workDate.getTime() + ((long)startAt) * ((long)DateTimeUtilities.ONEDAY);
       }
      
        long dayTime = workDateTime;
        for ( int i = 0; i < 7; i++ ) {
            String weekDay = sdfWeekDay.formatLocal(dayTime);
            HeaderBorderedLabelField hblf = new HeaderBorderedLabelField(weekDay.substring(0,1), LabelField.USE_ALL_WIDTH | DrawStyle.HCENTER);
            hblf.setFont(_boldFont);
            _monthManager.add(hblf);
            dayTime = dayTime + DateTimeUtilities.ONEDAY;
        }
        for ( int i = 0; i < 42; i++ ) {
            workDate.setTime(workDateTime);
            _cl.setTime(workDate);
            workDateTime = workDateTime + DateTimeUtilities.ONEDAY;
            BorderedLabelField blf = null;
            int actualDate = _cl.get(Calendar.DAY_OF_MONTH);
            String tempDateString = Integer.toString(actualDate);
            if ( _cl.get(Calendar.MONTH) == _currentMonth - 1 ) {
                blf = new BorderedLabelField(tempDateString, LabelField.USE_ALL_WIDTH | DrawStyle.HCENTER | LabelField.FOCUSABLE);
                if ( _currentFocusDay == actualDate ) {
                    _initialFocusField = blf;
                }
            } else
            if ( (i % 7 == 0) && (startOfMonth < _cl.getTime().getTime()) ) {
                break;
            } else {
                blf = new UnfocusableBorderedLabelField(tempDateString, LabelField.USE_ALL_WIDTH | DrawStyle.HCENTER);
            }
            _monthManager.add(blf);
        }
        if ( this.isDisplayed() && _initialFocusField != null ) {
            _initialFocusField.setFocus();
            _initialFocusField = null;
        }
    }

    public boolean keyChar(char key, int status, int time) {
        boolean retval = false;
        switch (key) {
            case Characters.ENTER: {
                processFocus();
                retval = true;
                break;
            }
            case Characters.ESCAPE: {
                close();
                retval = true;
                break;
            }
            default:
                retval = super.keyChar(key, status, time);
                break;
       }
       return retval;
    }


    private boolean processFocus() {
        // Should deal with whatever the focsu is currently on
        Field focusField = this.getDelegate().getLeafFieldWithFocus();
        if ( focusField instanceof ButtonBorderedLabelField ) {
            _currentFocusDay = -1; // Leave focus on 'button'
            _initialFocusField = focusField;
            int monthIncrement = 33;
            if ( focusField == _prevMonthButton ) {
                monthIncrement = -3;
            }
            _cl.set(Calendar.DAY_OF_MONTH, 1);
            _cl.set(Calendar.MONTH, _currentMonth-1);
            _cl.set(Calendar.YEAR, _currentYear);
            Date workDate = _cl.getTime();
            workDate.setTime(workDate.getTime() + (((long)monthIncrement) * ((long)DateTimeUtilities.ONEDAY)));
            _cl.setTime(workDate);
            _currentMonth = _cl.get(Calendar.MONTH) + 1;
            _currentYear = _cl.get(Calendar.YEAR);
            displayMonth();
            return true;
        } else
        if ( focusField instanceof BorderedLabelField ) {
            LabelField lab = (LabelField) focusField;
            _selectedDay = Integer.parseInt(lab.getText());
            close();
            return true;
        }
        return false;
    }
    protected boolean trackwheelClick( int status, int time ) {
        if ( processFocus() ) {
           
            Field focusField = this.getDelegate().getLeafFieldWithFocus();
            if ( focusField instanceof ButtonBorderedLabelField ) {
               
            }else{
                Dialog.alert( getSelectedDate().getTime()+"");
            }
           
            return true;
           
           
           
        }
        return super.trackwheelClick(status, time);
    }
  
    public void close() {
        UiApplication.getUiApplication().popScreen(this);
    }

    public Date getSelectedDate() {
        if ( _selectedDay == -1 ) {
            return null;
        }
        Calendar cl = Calendar.getInstance();
        cl.set(Calendar.YEAR, _currentYear);
        cl.set(Calendar.MONTH, _currentMonth - 1);
        cl.set(Calendar.DAY_OF_MONTH, _selectedDay);
        cl.set(Calendar.HOUR_OF_DAY, 0);
        cl.set(Calendar.MINUTE, 0);
        cl.set(Calendar.SECOND, 0);
        cl.set(Calendar.MILLISECOND, 1);
        return cl.getTime();
    }

}

class BorderedLabelField extends LabelField {
    int width;
    int height;
    public BorderedLabelField(String text, long style) {
        super(text, style);
    }
    public void paint(Graphics g) {
        super.paint(g);
        width = this.getWidth();
        height = this.getHeight();
        g.drawRect(0, 0, width, height);
    }
}

class HeaderBorderedLabelField extends BorderedLabelField {
    public HeaderBorderedLabelField(String text, long style) {
        super(text, style | LabelField.NON_FOCUSABLE);
    }
    public void paint(Graphics g) {
        g.setBackgroundColor(Color.LIGHTBLUE);
        g.clear();
        super.paint(g);
    }
}

class UnfocusableBorderedLabelField extends BorderedLabelField {
    public UnfocusableBorderedLabelField(String text, long style) {
        super(text, style | LabelField.NON_FOCUSABLE);
    }
    public void paint(Graphics g) {
        g.setBackgroundColor(Color.LIGHTGREY);
        g.clear();
        super.paint(g);
    }
}

class ButtonBorderedLabelField extends BorderedLabelField {
    public ButtonBorderedLabelField(String text, long style) {
        super(text, style);
    }
    public void paint(Graphics g) {
        g.setBackgroundColor(Color.LIGHTGREEN);
        g.clear();
        super.paint(g);
    }
}

class VerticalSpacerField extends Field {
    // Only for VerticalFieldManagers
    private int _height;
    public VerticalSpacerField(int height) {
        super(Field.NON_FOCUSABLE);
        _height = height;
    }
    public void layout(int widht, int hieght) {
        setExtent(10, _height);
    }
    public void paint(Graphics g) {
    }
}

The TableLayoutManager class is given below -


public class TableLayoutManager extends Manager {

        int _columnWidths[];
        int _suggestedColumnWidths[];
        int _rowHeights[];
        int _columnStyles[];
 public static final int USE_PREFERRED_SIZE = 1;
        public static final int USE_PREFERRED_WIDTH_WITH_MAXIMUM = 2;
       public static final int SPLIT_REMAINING_WIDTH = 4;
        public static final int FIXED_WIDTH = 8;
  private static int BITMASK_USE_PREFERRED = USE_PREFERRED_WIDTH_WITH_MAXIMUM | USE_PREFERRED_SIZE;
 public static int DEFAULT_PADDING = 5;
        int _rows;
        int _columns;
        private int _horizPadding;

        public TableLayoutManager(int columnStyles[], long style) {
                this(columnStyles, null, DEFAULT_PADDING, style);
        }
        public TableLayoutManager(int columnStyles[], int columnWidths[], long style) {
                this(columnStyles, columnWidths, DEFAULT_PADDING, style);
        }

        public TableLayoutManager(int columnStyles[], int columnWidths[], int horizontalPadding, long style) {
                super(style);

                _horizPadding = horizontalPadding;

                _columnStyles = columnStyles;
                if (_columnStyles == null)
                        throw new IllegalArgumentException("not column styles");

                if (columnWidths != null) {
                        _suggestedColumnWidths = Arrays.copy(columnWidths, 0, columnWidths.length);
                        if (_suggestedColumnWidths.length < _columnStyles.length) {
                                int oldLength = _suggestedColumnWidths.length;
                                int increase = columnStyles.length - oldLength;
                                _suggestedColumnWidths = Arrays.copy(columnWidths, 0, columnStyles.length);
                                Arrays.fill(_suggestedColumnWidths, 0, oldLength, increase);
                        }
                } else
                        _suggestedColumnWidths = new int[_columnStyles.length];
        }

        private Field getField(int x, int y) {
                int i = x + (y * _columns);
                if (i >= getFieldCount())
                        return null;
                return getField(i);
        }

        private boolean isColumnStyle(int value, int flag) {
                return ((value) & (flag)) > 0;
        }

        public int getPreferredWidth() {
                int numberFields = getFieldCount();
                if (numberFields == 0)
                        return 0;
                int rows = numberFields / _columnStyles.length;
                int prefferedWidth = 0;

                int styles[] = _columnStyles;
                int[] columnWidths = new int[_columns];
                Arrays.fill(columnWidths, -1);

                for (int i = 0; i < _columns; i++) {
                        if (isColumnStyle(styles[i], FIXED_WIDTH)) {
                                columnWidths[i] = _suggestedColumnWidths[i];
                        } else {
                                if (isColumnStyle(styles[i], BITMASK_USE_PREFERRED)) {
                                        for (int j = 0; j < rows; j++) {
                                                Field field = getField(i, j);
                                                if (field != null) {

                                                        int actualWidth = getPreferredWidthOfChild(field) + field.getMarginLeft() + field.getMarginRight();
                                                        if (isColumnStyle(styles[i], USE_PREFERRED_WIDTH_WITH_MAXIMUM)) {
                                                                actualWidth = Math.min(actualWidth, _suggestedColumnWidths[i]);
                                                        }
                                                        columnWidths[i] = Math.max(actualWidth, columnWidths[i]);
                                                }
                                        }
                                }
                        }
                }
                for (int n = 0; n < _columns; n++) {
                        prefferedWidth += columnWidths[n];
                }
                return prefferedWidth;
        }

        public int getPreferredHeight() {
                int numberFields = getFieldCount();
                if (numberFields == 0)
                        return 0;

                int rows = numberFields / _columnStyles.length;
                int prefferedHeight = 0;

                int[] rowHeights = new int[rows];
                Arrays.fill(rowHeights, -1);

                for (int i = 0; i < _columns; i++) {
                        for (int j = 0; j < rows; j++) {
                                Field field = getField(i, j);
                                if (field != null) {
                                        int actualHeight = getPreferredHeightOfChild(field) + field.getMarginBottom() + field.getMarginTop();
                                        rowHeights[j] = Math.max(actualHeight, rowHeights[j]);
                                }
                        }
                }

                for (int n = 0; n < rows; n++) {
                        prefferedHeight += rowHeights[n];
                }
                return prefferedHeight;
        }

      
        protected void sublayout(int layoutWidth, int layoutHeight) {
                int numberFields = getFieldCount();
                if (numberFields == 0)
                        return;
                layoutWidth -= getPaddingLeft() + getPaddingRight();
                layoutHeight -= getPaddingTop() + getPaddingBottom();
                _columns = _columnStyles.length;
                int styles[] = _columnStyles;
                if (isStyle(Field.USE_ALL_WIDTH)) {
                        boolean found = false;
                        for (int n = 0; n < _columns; n++) {
                                if (styles[n] == SPLIT_REMAINING_WIDTH) {
                                        found = true;
                                        break;
                                }
                        }
                        if (!found) {
                                styles[_columns - 1] = SPLIT_REMAINING_WIDTH;
                        }
                }
                _rows = numberFields / _columns;
                if ((numberFields % _columns) > 0)
                        _rows++;
                _columnWidths = new int[_columns];
               _rowHeights = new int[_rows];

                Arrays.fill(_columnWidths, -1);
                Arrays.fill(_rowHeights, -1);


                for (int i = 0; i < _columns; i++) {
                        if (isColumnStyle(styles[i], FIXED_WIDTH)) {
                                _columnWidths[i] = _suggestedColumnWidths[i];
                        } else {
                                if (isColumnStyle(styles[i], BITMASK_USE_PREFERRED)) {
                                        for (int j = 0; j < _rows; j++) {
                                                Field field = getField(i, j);
                                                if (field != null) {
                                                        layoutChild(field, Math.max(0, layoutWidth - (field.getMarginLeft() + field.getMarginRight())),
                                                                                                        Math.max(0, layoutHeight - (field.getMarginBottom() + field.getMarginTop())));

                                                        int actualWidth = getPreferredWidthOfChild(field) + field.getMarginLeft() + field.getMarginRight();
                                                        int actualHeight = getPreferredHeightOfChild(field) + field.getMarginBottom() + field.getMarginTop();

                                                        if (isColumnStyle(styles[i], USE_PREFERRED_WIDTH_WITH_MAXIMUM)) {
                                                                actualWidth = Math.min(actualWidth, _suggestedColumnWidths[i]);
                                                        }
                                                        _columnWidths[i] = Math.max(actualWidth, _columnWidths[i]);
                                                        _rowHeights[j] = Math.max(actualHeight, _rowHeights[j]);
                                                }
                                        }
                                }
                        }
                }

                int usedColumnWidth = 0;
                int numUnassignedColumnWidths = 0;

                for (int i = 0; i < _columns; i++) {
                        if (_columnWidths[i] >= 0) {
                                usedColumnWidth += _columnWidths[i] + ((i < (_columns - 1)) ? _horizPadding : 0);
                        } else {
                                numUnassignedColumnWidths++;
                        }
                }

               
                if (numUnassignedColumnWidths > 0) {
                        int remainingWidthToAssign = layoutWidth - usedColumnWidth;
                        if (remainingWidthToAssign < 0) {
                                remainingWidthToAssign = 0;
                        }

                        int splitRemainingWidth = (remainingWidthToAssign - ((numUnassignedColumnWidths - 1) * _horizPadding))
                        / numUnassignedColumnWidths;
                        for (int i = 0; i < _columns; i++) {
                                int assignedWidth = Math.min(remainingWidthToAssign,
                                                splitRemainingWidth);
                                if (_columnWidths[i] < 0) {
                                        _columnWidths[i] = assignedWidth;
                                        remainingWidthToAssign -= assignedWidth;
                                }
                        }
                }

                int currentRow = 0;
                int currentColumn = 0;
                int y = getPaddingTop();
                for (int n = 0; n < numberFields; n++) {
                        Field field = getField(n);

                        if (!isColumnStyle(styles[currentColumn], USE_PREFERRED_SIZE)) {
                             
                                layoutChild( field,
                                                Math.max(0, _columnWidths[currentColumn] - (field.getMarginLeft() + field.getMarginRight())),
                                                                                          Math.max(0, layoutHeight - y - (field.getMarginBottom() + field.getMarginTop())));
                        }

                        _rowHeights[currentRow] =Math.max(_rowHeights[currentRow], field.getExtent().height + field.getMarginBottom() + field.getMarginTop());

                        currentColumn++;
                        if ((n == (numberFields - 1)) || (currentColumn >= _columns)) {
                              
                                int x = getPaddingLeft();
                                for (int i = 0; i < currentColumn; i++) {
                                        Field field1 = getField(i, currentRow);
                                        XYPoint offset = calcAlignmentOffset(field1,
                                                        Math.max( 0, _columnWidths[i] - (field1.getMarginLeft() + field1.getMarginRight())),
                                                        Math.max(0, _rowHeights[currentRow] - (field1.getMarginBottom() + field1.getMarginTop())));
                                        setPositionChild(field1, x + offset.x + field1.getMarginLeft(), y + offset.y + field1.getMarginTop());
                                        x += _columnWidths[i] + _horizPadding;
                                }

                                y += _rowHeights[currentRow];
                                currentColumn = 0;
                                currentRow++;
                        }
                }

                int totalWidth = 0;
                if (isStyle(Field.USE_ALL_WIDTH)) {
                        totalWidth = layoutWidth;
                } else {
                        for (int i = 0; i < _columns; i++) {
                                totalWidth += _columnWidths[i] + ((i < (_columns - 1)) ? _horizPadding : 0);
                        }
                }
                totalWidth += getPaddingLeft() + getPaddingRight();
                y += getPaddingBottom();
                setExtent(totalWidth, Math.min(y, layoutHeight));
        }

        protected boolean navigationMovement(int dx, int dy, int status, int time) {
                int focusIndex = getFieldWithFocusIndex();
                int dirY = (dy > 0) ? 1 : -1;
                int absY = Math.abs(dy);

                for (int y = 0; y < absY; y++) {
                        focusIndex += _columns * dirY;
                        if (focusIndex < 0 || focusIndex >= getFieldCount()) {
                                return false;
                        } else {
                                Field f = getField(focusIndex);
                                if (f.isFocusable()) {
                                        f.setFocus();
                                } else
                                        y--;
                        }
                }

                int dirX = (dx > 0) ? 1 : -1;
                int absX = Math.abs(dx);
                for (int x = 0; x < absX; x++) {
                        focusIndex += dirX;
                        if (focusIndex < 0 || focusIndex >= getFieldCount()) {
                                return false;
                        } else {
                                Field f = getField(focusIndex);
                                if (f.isFocusable()) {
                                        f.setFocus();
                                } else
                                        x--;
                        }
                }
                return true;
        }

      
        private XYPoint calcAlignmentOffset(Field field, int width, int height) {
                XYPoint offset = new XYPoint(0, 0);
                long fieldStyle = field.getStyle();
                long field_x_style = fieldStyle & Field.FIELD_HALIGN_MASK;

                if (field_x_style == Field.FIELD_RIGHT) {
                        offset.x = width - field.getExtent().width;
                } else if (field_x_style == Field.FIELD_HCENTER) {
                        offset.x = (width - field.getExtent().width) / 2;
                }
                long field_y_style = fieldStyle & Field.FIELD_VALIGN_MASK;
                if (field_y_style == Field.FIELD_BOTTOM) {
                        offset.y = height - field.getExtent().height;
                } else if (field_y_style == Field.FIELD_VCENTER) {
                        offset.y = (height - field.getExtent().height) / 2;
                }
                return offset;
        }
}




        

Changing Background color in Blackberry

    // Solid Background
    Background back=BackgroundFactory.createSolidBackground(Color.ANTIQUEWHITE);
    setBackground(back);

   
    // Solid Background with Transperancy    
    Background back=BackgroundFactory.createSolidTransparentBackground(Color.AZURE,180);
    setBackground(back);
   

    // Gradient Background
    Background back = BackgroundFactory.createLinearGradientBackground(
    Color.AZURE,Color.BISQUE,Color.AZURE, Color.BISQUE);
    setBackground(back);

    // Bitmap Background
    Background back = BackgroundFactory.createBitmapBackground(your_image, 0, 0,0);
    setBackground(back);
   


        

Auto Hide field (EyelidFieldManager) in Blackberry

         EyelidFieldManager manager = new EyelidFieldManager();
         manager.addTop(new LabelField("Hello World"));
         HorizontalFieldManager buttonPanel = new HorizontalFieldManager(Field.FIELD_HCENTER |            Field.USE_ALL_WIDTH);
         buttonPanel.add(new ButtonField("Button 1"));
         buttonPanel.add(new ButtonField("Button 2"));
         manager.addBottom(buttonPanel);
         manager.setEyelidDisplayTime(3000);
         add(manager);
The fields will automatically hide after the specified time .


        

Creating Table (TableLayoutManager) in Blackberry

   The following will create a table with 3 rows and 3 columns.


TableLayoutManager outerTable = new TableLayoutManager(new int[]
        {
        TableLayoutManager.USE_PREFERRED_SIZE,
        TableLayoutManager.USE_PREFERRED_SIZE,
        TableLayoutManager.USE_PREFERRED_SIZE
        }, 0);

             for(int i= 0;i < 9;i++) {
             outerTable.add(new ButtonField(i));
           
             }

       add(outerTable);



The TableLayoutManager class is given below -


import net.rim.device.api.ui.Field;
import net.rim.device.api.ui.Manager;
import net.rim.device.api.ui.XYPoint;
import net.rim.device.api.util.Arrays;
/**
 * TableLayoutManager can be used to create multi column table
 * views. You can even embed table within another table to create
 * complex tabular views.
 */
public class TableLayoutManager extends Manager
{

    int _columnWidths[];
    int _suggestedColumnWidths[];
    int _rowHeights[];
    int _columnStyles[];

    /** Let the field use up ALL the space that it needs **/
    public static final int USE_PREFERRED_SIZE = 1;
    /** let the field use up as much space as it needs UP TO a maximum */
    public static final int USE_PREFERRED_WIDTH_WITH_MAXIMUM = 2;
    /** the fields should use up the remaining space evenly */
    public static final int SPLIT_REMAINING_WIDTH = 4;
    /** the column is fixed width **/
    public static final int FIXED_WIDTH = 8;

    private static int BITMASK_USE_PREFERRED =
            USE_PREFERRED_WIDTH_WITH_MAXIMUM
            | USE_PREFERRED_SIZE;

    public static int DEFAULT_PADDING = 5;
    int _rows;
    int _columns;
    private int _horizPadding;

    public TableLayoutManager(int columnStyles[], long style)
    {
        this(columnStyles, null, DEFAULT_PADDING, style);
    }

    /**
     * creates a table with the specified column styles
     *
     * @param columnStyles
     *           - array of styles for all the columns. The size
     *           of this array determines the number of columns.
     * @param columnWidths
     *           - array of widths. This is used for the FIXED_WIDTH,
     *           and USE_PREFERRED_WIDTH_WITH_MAXIMUM styles.
     *           the value is ignored for the other styles.
     * @param horizontalPadding
     *           - space between columns
     * @param style
     */

    public TableLayoutManager(int columnStyles[], int columnWidths[],
        int horizontalPadding, long style)
    {
        super(style);

        _horizPadding = horizontalPadding;

        _columnStyles = columnStyles;
        if (_columnStyles == null)
              throw new IllegalArgumentException("No column styles");

        if (columnWidths != null)
        {
            _suggestedColumnWidths = Arrays.copy(columnWidths,
                                     0,columnWidths.length);
            if (_suggestedColumnWidths.length < _columnStyles.length)
            {
                int oldLength = _suggestedColumnWidths.length;
                int increase = columnStyles.length - oldLength;
               _suggestedColumnWidths = Arrays.copy(columnWidths, 0,
                            columnStyles.length);
               Arrays.fill(_suggestedColumnWidths, 0,
                           oldLength, increase);
            }
        }
        else
            _suggestedColumnWidths = new int[_columnStyles.length];
    }

    private Field getField(int x, int y)
    {
        int i = x + (y * _columns);
        if (i >= getFieldCount()) return null;
        return getField(i);
    }

    private boolean isColumnStyle(int value, int flag)
    {
        return ((value) & (flag)) > 0;
    }

    /**
     * Implements the getPreferredWidth call to return the
     * expected width for this manager. The expected width is
     * the Max(Sum (Column Widths))
     */
    public int getPreferredWidth()
    {
        int numberFields = getFieldCount();
        if (numberFields == 0) return 0;
        int rows = numberFields / _columnStyles.length;
        int prefferedWidth = 0;

        int styles[] = _columnStyles;
        int[] columnWidths = new int[_columns];
        Arrays.fill(columnWidths, -1);

        for (int i = 0; i < _columns; i++)
        {
            // assign the fixed widths
            if (isColumnStyle(styles[i], FIXED_WIDTH))
            {
                columnWidths[i] = _suggestedColumnWidths[i];
            }
            else
            {
                if (isColumnStyle(styles[i], BITMASK_USE_PREFERRED))
                {
                    for (int j = 0; j < rows; j++)
                    {
                        Field field = getField(i, j);
                        if (field != null)
                        {

                            int actualWidth = getPreferredWidthOfChild(field)
                                     + field.getMarginLeft()
                                     + field.getMarginRight();
                            if (isColumnStyle(styles[i],
                                USE_PREFERRED_WIDTH_WITH_MAXIMUM))
                            {
                                actualWidth = Math.min(actualWidth,
                                  _suggestedColumnWidths[i]);
                            }

                            columnWidths[i] =
                               Math.max(actualWidth,columnWidths[i]);
                        }
                    }
                }
            }
        }

        for (int n = 0; n < _columns; n++)
        {
            prefferedWidth += columnWidths[n];
        }
       
        return prefferedWidth;
    }

    /**
     * implements the preferred height for this layout
     */
    public int getPreferredHeight()
    {
        int numberFields = getFieldCount();
        if (numberFields == 0) return 0;

        int rows = numberFields / _columnStyles.length;
        int prefferedHeight = 0;

        int[] rowHeights = new int[rows];
        Arrays.fill(rowHeights, -1);
       
        _columns = _columnStyles.length;
        for (int i = 0; i < _columns; i++)
        {
            for (int j = 0; j < rows; j++)
            {
                Field field = getField(i, j);
                if (field != null)
                {
                int actualHeight = getPreferredHeightOfChild(field)
                            + field.getMarginBottom()
                            + field.getMarginTop();
                rowHeights[j] = Math.max(actualHeight, rowHeights[j]);
                }
            }
        }

        for (int n = 0; n < rows; n++)
        {
            prefferedHeight += rowHeights[n];
        }
        return prefferedHeight;
    }

    /**
     * Defines how Fields for this manager needs to be handled.
     */
    protected void sublayout(int layoutWidth, int layoutHeight)
    {
        int numberFields = getFieldCount();
        if (numberFields == 0) {  
            if ( this._columnStyles != null ) { //At least one field was added and removed from this manager
                setExtent( 0 ,  0 );
            }
            return;
        }
        layoutWidth -= getPaddingLeft() + getPaddingRight();
        layoutHeight -= getPaddingTop() + getPaddingBottom();
        _columns = _columnStyles.length;
        int styles[] = _columnStyles;
        if (isStyle(Field.USE_ALL_WIDTH))
        {
            boolean found = false;
            // if the field should take maximum space, at least
            // the last field
            // should be SPLIT_REMAINING_WIDTH
           for (int n = 0; n < _columns; n++)
           {
               if (styles[n] == SPLIT_REMAINING_WIDTH)
               {
                   found = true;
                   break;
               }
           }
           if (!found)
           {
               styles[_columns - 1] = SPLIT_REMAINING_WIDTH;
           }
        }
        _rows = numberFields / _columns;
        if ((numberFields % _columns) > 0) _rows++;
        _columnWidths = new int[_columns];  // arrays that keep track of
                                            // maximum widths
        _rowHeights = new int[_rows];

        // widths and heights are -1 if unassigned, we use this
        // fact to assign the column widths
        Arrays.fill(_columnWidths, -1);
        Arrays.fill(_rowHeights, -1);

        /*
         * there are three types of columns, fixed width, split
         * remaining width, and use preferred size step 1) we
         * need to look at the columns that are marked as "use
         * preferred size", find the widest element, then
         * record that maximum width step 2) as well, we can
         * assign the column widths for the columns that are
         * fixed width
         */

        for (int i = 0; i < _columns; i++)
        {
            // assign the fixed widths
            if (isColumnStyle(styles[i], FIXED_WIDTH))
            {
                _columnWidths[i] = _suggestedColumnWidths[i];
            }
            else
            {
                if (isColumnStyle(styles[i], BITMASK_USE_PREFERRED))
                {
                    for (int j = 0; j < _rows; j++)
                    {
                        Field field = getField(i, j);
                        if (field != null)
                        {
                            layoutChild(field, Math.max(0, layoutWidth
                               - (field.getMarginLeft()
                               + field.getMarginRight())),
                                 Math.max(0,layoutHeight
                               - (field.getMarginBottom()
                               + field.getMarginTop())));

                            int actualWidth = getPreferredWidthOfChild(field)
                                 + field.getMarginLeft()
                                 + field.getMarginRight();
                            int actualHeight = getPreferredHeightOfChild(field)
                                 + field.getMarginBottom()
                                 + field.getMarginTop();

                            if (isColumnStyle(styles[i],
                                  USE_PREFERRED_WIDTH_WITH_MAXIMUM))
                            {
                                actualWidth = Math.min(actualWidth,
                                   _suggestedColumnWidths[i]);
                            }

                            _columnWidths[i] = Math.max(actualWidth,
                                _columnWidths[i]);
                            _rowHeights[j] = Math.max(actualHeight,
                                _rowHeights[j]);
                        }
                    }
                }
            }
        }

        /*
         * step 3 - find out the total width used up by the
         * fields that have known widths
         */
        int usedColumnWidth = 0;
        int numUnassignedColumnWidths = 0;

        for (int i = 0; i < _columns; i++)
        {
            if (_columnWidths[i] >= 0)
            {
                usedColumnWidth += _columnWidths[i]
                        + ((i < (_columns - 1)) ? _horizPadding : 0);
            }
            else
            {
                numUnassignedColumnWidths++;
            }
        }

        /*
         * assign the remaining space evenly amongst the
         * unassigned columns
         */
        if (numUnassignedColumnWidths > 0)
        {
            int remainingWidthToAssign = layoutWidth - usedColumnWidth;
            if (remainingWidthToAssign < 0)
            {
                remainingWidthToAssign = 0;
            }

            int splitRemainingWidth = (remainingWidthToAssign -
                                      ((numUnassignedColumnWidths - 1)
                                      * _horizPadding))
                                         / numUnassignedColumnWidths;
           
            int[] evenlySpacedColumnPosition = new int [_columnWidths.length];
            Arrays.fill(evenlySpacedColumnPosition, -1);
           
            for (int i = 0; i < _columns; i++)
            {
                int assignedWidth = Math.min(remainingWidthToAssign,
                     splitRemainingWidth);
                if (_columnWidths[i] < 0)
                {
                    _columnWidths[i] = assignedWidth;
                    remainingWidthToAssign -= assignedWidth;
                    evenlySpacedColumnPosition[i] = 1; //mark the current column as assigned
                }
            }
          
            /*
             * We should assign the rest of the integer division to the evenly spaced columns:
             * splitRemainingWidth = remainingWidthToAssign  / numUnassignedColumnWidths 
             * */
            if ( this.isStyle(Field.USE_ALL_WIDTH) && remainingWidthToAssign > 0 ) {
                for (int i = 0; i < evenlySpacedColumnPosition.length; i++) {
                    if ( evenlySpacedColumnPosition[i] == 1 ) {
                        _columnWidths[i] += 1;
                        remainingWidthToAssign--;
                    }
                  
                    if ( remainingWidthToAssign == 0) break;
                }    
            }
        }

        int currentRow = 0;
        int currentColumn = 0;
        int y = getPaddingTop();
        for (int n = 0; n < numberFields; n++)
        {            Field field = getField(n);

            if (!isColumnStyle(styles[currentColumn], USE_PREFERRED_SIZE))
            { // do
                // the others we missed from above
                layoutChild(field, Math.max(0, _columnWidths[currentColumn]
                        - (field.getMarginLeft()
                        + field.getMarginRight())),
                        Math.max(0, layoutHeight
                                - y
                                - (field.getMarginBottom()
                                + field.getMarginTop())));
            }

            _rowHeights[currentRow] = Math.max(_rowHeights[currentRow], field
                     .getExtent().height
                     + field.getMarginBottom()
                     + field.getMarginTop());

            currentColumn++;
            if ((n == (numberFields - 1)) || (currentColumn >= _columns))
            {
                // we are at the end of the row or list, so now
                // go and actually do the positioning for each row
                int x = getPaddingLeft();
                for (int i = 0; i < currentColumn; i++)
                {
                    Field field1 = getField(i, currentRow);
                    XYPoint offset = calcAlignmentOffset(field1, Math.max(0,
                             _columnWidths[i]
                                    - (field1.getMarginLeft() + field1
                                            .getMarginRight())), Math.max(0,
                            _rowHeights[currentRow]
                                  - (field1.getMarginBottom()
                                  + field1.getMarginTop())));
                     setPositionChild(field1, x + offset.x
                        + field1.getMarginLeft(), y + offset.y
                        + field1.getMarginTop());
                     x += _columnWidths[i] + _horizPadding;
                }

                y += _rowHeights[currentRow];
                currentColumn = 0;
                currentRow++;
            }
        }

        int totalWidth = 0;
        if (isStyle(Field.USE_ALL_WIDTH))
        {
            totalWidth = layoutWidth;
        }
        else
        {
            for (int i = 0; i < _columns; i++)
            {
                totalWidth += _columnWidths[i]
                      + ((i < (_columns - 1)) ? _horizPadding : 0);
            }
        }

        totalWidth += getPaddingLeft() + getPaddingRight();

        y += getPaddingBottom();
        setExtent(totalWidth, Math.min(y, layoutHeight));
    }

    /**
     * Navigation movement to allow for both cell to cell within
     * a columns and row movement
     */
    protected boolean navigationMovement(int dx, int dy, int status, int time)
    {
        int focusIndex = getFieldWithFocusIndex();
        int dirY = (dy > 0) ? 1 : -1;
        int absY = Math.abs(dy);

        for (int y = 0; y < absY; y++)
        {
            focusIndex += _columns * dirY;
            if (focusIndex < 0 || focusIndex >= getFieldCount())
            {
                //#ifdef BlackBerrySDK4.5.0
                this.invalidate(); //ref #217
                //#endif
                return false;
            }
            else
            {
                Field f = getField(focusIndex);
                if (f.isFocusable())
                {
                    f.setFocus();
                }
                else
                    y--; // do it over again
            }
        }

        int dirX = (dx > 0) ? 1 : -1;
        int absX = Math.abs(dx);
        for (int x = 0; x < absX; x++)
        {
            focusIndex += dirX;
            if (focusIndex < 0 || focusIndex >= getFieldCount())
            {
                //#ifdef BlackBerrySDK4.5.0
                this.invalidate(); //Ref #217
                //#endif
                return false;
            }
            else
            {
                Field f = getField(focusIndex);
                if (f.isFocusable())
                {
                    f.setFocus();
                }
                else
                    x--; // do it over again
            }
        }
       
        //#ifdef BlackBerrySDK4.5.0
        this.invalidate(); //ref #217
        //#endif
       
        return true;
    }

    /**
     * Calculate the styles and return appropriate XY offset
     * locations within the cell.
     * @param field
     * @param width
     * @param height
     * @return
     */
    private XYPoint calcAlignmentOffset(Field field, int width, int height)
    {
        XYPoint offset = new XYPoint(0, 0);
        long fieldStyle = field.getStyle();
        long field_x_style = fieldStyle & Field.FIELD_HALIGN_MASK;

        if (field_x_style == Field.FIELD_RIGHT)
        {
            offset.x = width - field.getExtent().width;
        }
        else if (field_x_style == Field.FIELD_HCENTER)
        {
            offset.x = (width - field.getExtent().width) / 2;
        }
        long field_y_style = fieldStyle & Field.FIELD_VALIGN_MASK;
        if (field_y_style == Field.FIELD_BOTTOM)
        {
            offset.y = height - field.getExtent().height;
        }
        else if (field_y_style == Field.FIELD_VCENTER)
        {
            offset.y = (height - field.getExtent().height) / 2;
        }
        return offset;
    }
}