Blackberry 黑莓GridFieldManager边框

我在Blackberry应用程序中创建了一个GridFieldManager，我想为每个单元格设置一个边框，使网格看起来像excel网格

我用过：

gridFieldManager.setBorder（BorderFactory.CreateSimpleOrder（新的XYEdge（0,0,0,0），Border.STYLE_虚线））

但这只是在管理器周围设置边界，而不是每个单元格

---

谢谢您的帮助。

只需为添加到

GridFieldManager

的每个

字段设置边框即可

创建一个方法，该方法首先将边框设置为要添加到管理器的
字段，然后将其传递给add（）。或者从
GridFieldManager
中创建子类，并覆盖
add（Field f）
，将边框设置为正在添加的
字段（
f
），然后调用
super.add（f）
我正在使用以下代码为填字游戏创建ui。。。
我定制了网格
它仍然有一些问题（滚动问题），但它至少应该给你一些关于如何做的想法：

public class GridField extends Field
{

int WIDTH = 0;
int HEIGHT = 0;
int x = 0;
int y = 0;
int numRows = 0;
int GRID_WIDTH = 30;
int GRID_HEIGHT = 30;
int fill_width=20;
int fill_height=20;
int currentColumn = 0;
int currentRow = 0;
public String[][] values = null;
int[][] numbers = null;
private Font numericFont = null;
private Font alphabetFont = null;  
Graphics G;
int clu = 0;
int length=0;
char di;

public GridField(int width) {
    this.WIDTH = width;
    HEIGHT = 3;
}

public GridField(int width, int height) {
    super(Field.FOCUSABLE);
    this.WIDTH = width;
    HEIGHT = height;
}

public GridField(int width, int height, int numRows, String[][] values) {
    super(Field.FOCUSABLE);
    this.WIDTH = width;
    HEIGHT = height;
    this.numRows = numRows;
    this.values = values;
}

public GridField(int width, int height, int numRows, String[][] values,int[][] numbers) {
    super(Field.FOCUSABLE);

    this.WIDTH = width;
    HEIGHT = height;
    this.numRows = numRows;
    this.values = values;
    this.numbers=numbers;
}

public int getPreferredWidth()  
{  
    return WIDTH;  
}  

public int getPreferredHeight()  
{  
    return HEIGHT;  
}  

protected void onFocus(int direction)  
{  
    System.out.println("onfocus direction =====>"+direction);
}  

protected void onUnfocus()  
{  
    System.out.println("onunfocus direction =====>");
}  

protected void layout(int arg0, int arg1)  
{  
    setExtent(getPreferredWidth(), getPreferredHeight());  
}  

public void paint(int clue, int len, char dir)
{
    try {
        clu=clue;
        length=len;
        di=dir;
        FontFamily fontFamily = null;
        try {
            fontFamily = FontFamily.forName("Verdana");
        } catch (ClassNotFoundException cnfe) {
        }   
        numericFont = fontFamily.getFont(FontFamily.SCALABLE_FONT, 9);
        alphabetFont = fontFamily.getFont(FontFamily.SCALABLE_FONT, 13);    
        //G.clear();
        G.setColor(0x00ffffff);
        G.fillRect(0, 0, WIDTH, HEIGHT);
        G.setColor(0x00000000);
        y = 5;
        for(int i = 0; i < numRows; i ++ )
        {
            for(int j = 0; j < numRows; j ++ )
            {
                G.setColor(Color.BLACK);
                G.drawRect(x, y, GRID_WIDTH, GRID_HEIGHT);                 
                G.setColor(Color.BLUE);
                // G.setFont(alphabetFont);
                G.setFont(Utility.getInstance().getGujaratiFont("rekha", 4));
                // if(values[i][j]!=".")
                // G.drawText("" + values[i][j], x + 13, y + 11);
                if(values[i][j]!=".")
                    G.drawText("" + values[i][j], x + 5, y + 11);
                G.setColor(Color.BLACK);
                G.setFont(numericFont);
                if (numbers[i][j] == clue)
                {
                    currentColumn=j;
                    currentRow=i;
                    G.setColor(Color.RED);
                    G.fillRect(x, y, GRID_WIDTH, GRID_HEIGHT);

                    G.setColor(Color.ORANGE); 
                    if(dir=='a'||dir=='A')
                    {

                        G.drawRect(x+GRID_WIDTH, y, 30*(len-1), GRID_HEIGHT);   
                        //                      G.drawRect(x-1, y-1, 30*len+2, GRID_HEIGHT+2); 
                        //                      G.drawRect(x-2, y-2, 30*len+3, GRID_HEIGHT+3);  
                        //                      G.drawRect(x-3, y-3, 30*len+4, GRID_HEIGHT+4); 
                        G.fillRect(x+GRID_WIDTH, y, 30*(len-1), GRID_HEIGHT);
                    }
                    else
                    {
                        G.drawRect(x, y+GRID_HEIGHT, GRID_WIDTH, 30*(len-1));  
                        G.fillRect(x, y+GRID_HEIGHT, GRID_WIDTH, 30*(len-1));
                    }


                }

                G.setColor(Color.BLACK);
                if(numbers[i][j]!=0)
                    G.drawText("" + numbers[i][j],x + 2  ,y + 2);
                if(values[i][j] == "0"){
                    G.setColor(Color.BLACK);
                    G.fillRect(x, y, GRID_WIDTH, GRID_HEIGHT);
                    //Field.VISUAL_STATE_FOCUS;
                }
                x = x + GRID_WIDTH - 1;      
            }
            x = 0;
            y = y + GRID_HEIGHT - 1;    
        }
        //this.invalidate();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

protected void paint(Graphics g)
{

    FontFamily fontFamily = null;
    try {
        fontFamily = FontFamily.forName("Verdana");
    } catch (ClassNotFoundException cnfe) {
    }   
    try {
        numericFont = fontFamily.getFont(FontFamily.SCALABLE_FONT, 9);
        alphabetFont = fontFamily.getFont(FontFamily.SCALABLE_FONT, 13);
        G=g;
        g.setColor(0x00ffffff);
        g.fillRect(0, 0, WIDTH, HEIGHT);
        g.setColor(0x00000000);
        y = 5;
        for(int i = 0; i < numRows; i ++ )
        {
            for(int j = 0; j < numRows; j ++ )
            {
                g.setColor(Color.BLACK);
                g.drawRect(x, y, GRID_WIDTH, GRID_HEIGHT);  
                if (clu != 0)
                {
                    if (numbers[i][j] == clu)
                    {
                        currentColumn=j;
                        currentRow=i;
                        G.setColor(Color.RED);
                        G.fillRect(x, y, GRID_WIDTH, GRID_HEIGHT);

                        G.setColor(Color.ORANGE); 
                        if(di=='a'||di=='A')
                        {

                            G.drawRect(x+GRID_WIDTH, y, 30*(length-1), GRID_HEIGHT);   
                            //                          G.drawRect(x-1, y-1, 30*len+2, GRID_HEIGHT+2); 
                            //                          G.drawRect(x-2, y-2, 30*len+3, GRID_HEIGHT+3);  
                            //                          G.drawRect(x-3, y-3, 30*len+4, GRID_HEIGHT+4); 
                            G.fillRect(x+GRID_WIDTH, y, 30*(length-1), GRID_HEIGHT);
                        }
                        else
                        {
                            G.drawRect(x, y+GRID_HEIGHT, GRID_WIDTH, 30*(length-1));  
                            G.fillRect(x, y+GRID_HEIGHT, GRID_WIDTH, 30*(length-1));
                        }
                    }
                    //clu=0;
                }

                if(i == currentRow && j == currentColumn)
                {
                    g.setColor(Color.RED);
                    g.fillRect(x, y, GRID_WIDTH, GRID_HEIGHT);
                }  
                g.setColor(Color.BLUE);
                g.setFont(Utility.getInstance().getGujaratiFont("rekha", 5));
                if(values[i][j]!=".")
                    g.drawText("" + values[i][j], x + 5, y + 11);
                g.setColor(Color.BLACK);
                g.setFont(numericFont);
                if(numbers[i][j]!=0)
                    g.drawText("" + numbers[i][j],x + 2  ,y + 2);
                if(values[i][j] == "0"){
                    g.setColor(Color.BLACK);
                    g.fillRect(x, y, GRID_WIDTH, GRID_HEIGHT);
                    //Field.VISUAL_STATE_FOCUS;
                }
                x = x + GRID_WIDTH - 1;      
            }
            x = 0;
            y = y + GRID_HEIGHT - 1;  

        }
        //clu=0;
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}


protected  int  moveFocus(int amount, int status, int time) {
    System.out.println("moveFocus -=======>");
    return amount;
}

protected  boolean navigationMovement(int dx, int dy, int status, int time) {
    clu = 0;
    System.out.println("navigationMovement -=======dx>"+dx);
    System.out.println("navigationMovement -=======dy>"+dy);
    if(dx == 1)
    {
        if(currentColumn < numRows - 1)
        {
            currentColumn ++;
        }
    }
    else if(dx == -1)
    {
        if(currentColumn > 0)
        {
            currentColumn --;
        }            
    }
    else if(dy == 1)
    {
        if(currentRow < numRows - 1)
        {
            currentRow ++;
        }
        else
            TabControlScreen.gridfocus();
    }
    else if(dy == -1)
    {
        if(currentRow > 0)
        {
            currentRow --;
        }
    }
    invalidate();
    return true;
}

public void drawText(String string) {

    try {
        System.out.println("inside keyChar ====>" + string);
        System.out.println("CurrentRow:::" + currentRow + "CurrentColumn:::"
                + currentColumn + "Values:::"
                + values[currentRow][currentColumn]);
        if (!values[currentRow][currentColumn].equalsIgnoreCase("0")) {
            values[currentRow][currentColumn] = string;// String.valueOf(string);
            System.out.println("GridField::Values::string::"+string);
            invalidate();
        } else
            Dialog.alert("Invalid Field!");
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    //return true;
}


public String getText() {
    return "";

}

public String returnText() {
    return values[currentRow][currentColumn];

}

公共类GridField扩展字段
{
整数宽度=0；
整数高度=0；
int x=0；
int y=0；
int numRows=0；
int GRID_WITH=30；
int GRID_高度=30；
int fill_width=20；
内部填充高度=20；
int currentColumn=0；
int currentRow=0；
公共字符串[][]值=null；
int[][]数字=空；
私有字体numericFont=null；
私有字体alphabetFont=null；
图形G；
int-clu=0；
整数长度=0；
查尔迪；
公共网格字段（整型宽度）{
这个。宽度=宽度；
高度=3；
}
公共网格字段（整数宽度、整数高度）{
超级（场聚焦）；
这个。宽度=宽度；
高度=高度；
}
公共网格字段（int-width、int-height、int-numRows、字符串[][]值）{
超级（场聚焦）；
这个。宽度=宽度；
高度=高度；
this.numRows=numRows；
这个值=值；
}
公共网格字段（整型宽度、整型高度、整型numRows、字符串[][]值、整型[][]数字）{
超级（场聚焦）；
这个。宽度=宽度；
高度=高度；
this.numRows=numRows；
这个值=值；
这个。数字=数字；
}
public int getPreferredWidth（）
{  
返回宽度；
}  
public int getPreferredHeight（）
{  
返回高度；
}  
受保护的空对焦（整数方向）
{  
System.out.println（“聚焦方向====>”+方向）；
}  
受保护的无效onnfocus（）
{  
System.out.println（“onnfocus方向====>”；
}  
受保护的无效布局（int arg0、int arg1）
{  
setExtent（getPreferredWidth（），getPreferredHeight（））；
}  
公共空白绘制（内部线索、内部长度、字符方向）
{
试一试{
clu=线索；
长度=长度；
di=dir；
FontFamily FontFamily=null；
试一试{
fontFamily=fontFamily.forName（“Verdana”）；
}捕获（ClassNotFoundException cnfe）{
}   
numericFont=fontFamily.getFont（fontFamily.SCALABLE_FONT，9）；
alphabetFont=fontFamily.getFont（fontFamily.SCALABLE_FONT，13）；
//G.清除（）；
G.setColor（0x00ffffff）；
G.fillRect（0，0，宽度，高度）；
G.setColor（0x00000000）；
y=5；
对于（int i=0；i