Custom TitleBar

in Blackberry aplications sometimes we need to write the custom title bars rather than basic title bar which is appearing on a blackberry screen. for this purpose firstly we need to remove the basic titlebar, for this purpose just write a line of code as follows

this.setTitle((LabelField) null);

now please copy the code given below and use it in yours code :)


import net.rim.device.api.system.Bitmap;
import net.rim.device.api.system.DeviceInfo;
import net.rim.device.api.system.Display;
import net.rim.device.api.ui.Color;
import net.rim.device.api.ui.DrawStyle;
import net.rim.device.api.ui.Field;
import net.rim.device.api.ui.Graphics;



public class TitleBar extends Field implements DrawStyle {
private int fieldWidth;
private int fieldHeight;
private int fontColour;
private int backgroundColor;

Bitmap titleImage, logo;

public TitleBar(Bitmap logo_, int height, int BACKGROUND_COLOR) {
super(Field.NON_FOCUSABLE);

ImageResigeUtility img = new ImageResigeUtility();
titleImage = img
.createBitmap("top_bar.png", Display.getWidth(), height);
fieldHeight = titleImage.getHeight();
fieldWidth = Display.getWidth();
logo = logo_;
backgroundColor = BACKGROUND_COLOR;
}

public void setBackgroundColour(int _backgroundColour) {
backgroundColor = _backgroundColour;
invalidate();
}

protected void layout(int width, int height) {
setExtent(getPreferredWidth(), getPreferredHeight());
}

public int getPreferredWidth() {
return fieldWidth;
}

public int getPreferredHeight() {
return fieldHeight;
}

public void paint(Graphics graphics) {

int w = this.getPreferredWidth();
int h = this.getPreferredHeight();

graphics.setColor(backgroundColor);
graphics.fillRect(0, 0, w, h);

graphics.drawBitmap(0, 0, w, h, titleImage, 0, 0);
graphics.drawBitmap((Display.getWidth() - logo.getWidth()) / 2,
(titleImage.getHeight() - logo.getHeight()) / 2,
logo.getWidth(), logo.getHeight(), logo, 0, 0);

}
}

for the ImageResigeUtility  please copy the code ==>


import net.rim.device.api.math.Fixed32;
import net.rim.device.api.system.Bitmap;
import net.rim.device.api.system.EncodedImage;
import net.rim.device.api.ui.Color;
import net.rim.device.api.ui.Graphics;

public class ImageResigeUtility {

public  Bitmap resizeBitmap(Bitmap image, int width, int height) {
int imageWidth = image.getWidth();
int imageHeight = image.getHeight();

// Need an array (for RGB, with the size of original image)
int rgb[] = new int[imageWidth * imageHeight];

// Get the RGB array of image into "rgb"
image.getARGB(rgb, 0, imageWidth, 0, 0, imageWidth, imageHeight);

// Call to rescaleArray() function and obtain rgb2
int rgb2[] = rescaleArray(rgb, imageWidth, imageHeight, width, height);

// Create an image with that RGB array
Bitmap temp2 = new Bitmap(width, height);

temp2.setARGB(rgb2, 0, width, 0, 0, width, height);

return temp2;
}

private  int[] rescaleArray(int[] ini, int x, int y, int x2, int y2) {
int out[] = new int[x2 * y2];
for (int yy = 0; yy < y2; yy++) {
int dy = yy * y / y2;
for (int xx = 0; xx < x2; xx++) {
int dx = xx * x / x2;
out[(x2 * yy) + xx] = ini[(x * dy) + dx];
}
}
return out;
}

public  EncodedImage resizeImage(EncodedImage image, int newWidth,
int newHeight) {
int scaleFactorX = Fixed32.div(Fixed32.toFP(image.getWidth()),
Fixed32.toFP(newWidth));
int scaleFactorY = Fixed32.div(Fixed32.toFP(image.getHeight()),
Fixed32.toFP(newHeight));
return image.scaleImage32(scaleFactorX, scaleFactorY);
}

public Bitmap createBitmap(String imagePath, int newWidth, int newHeight) {
EncodedImage image = EncodedImage.getEncodedImageResource(imagePath);
int widthNumerator = Fixed32.toFP(image.getWidth());
int widthDenominator = Fixed32.toFP(newWidth);
int scaleWidth = Fixed32.div(widthNumerator, widthDenominator);
int heightNumerator = Fixed32.toFP(image.getHeight());
int heightDenominator = Fixed32.toFP(newHeight);
int scaleHeight = Fixed32.div(heightNumerator, heightDenominator);
image = image.scaleImage32(scaleWidth, scaleHeight);
return image.getBitmap();
}

public static Graphics resizeGraphics(Graphics g, int left, int top,
Bitmap bitmap, int width, int hight, int crop)

{

int tmpw = 0, tmph = 0, dw = 0;
int rw = 0, rh = 0, dh = 0;

try {

g.drawBitmap(left, top, crop, crop, bitmap, 0, 0);
g.drawBitmap(left + width - crop, top, crop, crop, bitmap,
bitmap.getWidth() - crop, 0);
g.drawBitmap(left, top + hight - crop, crop, crop, bitmap, 0,
bitmap.getHeight() - crop);
g.drawBitmap(left + width - crop, top + hight - crop, crop, crop,
bitmap, bitmap.getWidth() - crop, bitmap.getHeight() - crop);

tmpw = (bitmap.getWidth() - (crop * 2));
rw = ((width - (crop * 2)) / tmpw);
if (((width - (crop * 2)) % tmpw) != 0) {
rw++;
dw = ((width - (crop * 2)) % tmpw);
} else
dw = tmpw;
if (rw >= 1) {
for (int i = 0; i < rw; i++) {
if (i == rw - 1) {
g.drawBitmap(left + crop + i * tmpw, top, dw, crop,
bitmap, crop, 0);
g.drawBitmap(left + crop + i * tmpw,
top + hight - crop, dw, crop, bitmap, crop,
bitmap.getHeight() - crop);
} else {
g.drawBitmap(left + crop + i * tmpw, top, tmpw, crop,
bitmap, crop, 0);
g.drawBitmap(left + crop + i * tmpw,
top + hight - crop, tmpw, crop, bitmap, crop,
bitmap.getHeight() - crop);
}

}
}

tmph = (bitmap.getHeight() - (crop * 2));
rh = ((hight - (crop * 2)) / tmph);
if (((hight - (crop * 2)) % tmph) != 0)

{
rh++;
dh = ((hight - (crop * 2)) % tmph);
} else
dh = tmph;
if (rh >= 1) {
for (int i = 0; i < rh; i++) {

if (i == rh - 1) {
g.drawBitmap(left, top + crop + i * tmph, crop, dh,
bitmap, 0, crop);
g.drawBitmap(left + width - crop,
top + crop + i * tmph, crop, dh, bitmap,
bitmap.getWidth() - crop, crop);
} else {
g.drawBitmap(left, top + crop + i * tmph, crop, tmph,
bitmap, 0, crop);
g.drawBitmap(left + width - crop,
top + crop + i * tmph, crop, tmph, bitmap,
bitmap.getWidth() - crop, crop);
}
}
}

for (int i = 0; i < rh; i++) {
for (int j = 0; j < rw; j++) {
if (i == rh - 1 && j == rw - 1) {
g.drawBitmap(left + crop + j * tmpw, top + crop + i
* tmph, dw, dh, bitmap, crop, crop);
} else {
if (i == rh - 1 || j == rw - 1) {
if (j == rw - 1) {
g.drawBitmap(left + crop + j * tmpw, top + crop
+ i * tmph, dw, tmph, bitmap, crop,
crop);
} else {
g.drawBitmap(left + crop + j * tmpw, top + crop
+ i * tmph, tmpw, dh, bitmap, crop,
crop);
}
} else {
g.drawBitmap(left + crop + j * tmpw, top + crop + i
* tmph, tmpw, tmph, bitmap, crop, crop);

}
}

}
}

} catch (Exception e) {
System.out.println("==>falt in argument==>" + e);
}
return g;
}
public static Bitmap ResizeTransparentBitmap(Bitmap bmpSrc, 
    int nWidth, int nHeight, int nFilterType, int nAspectRatio)
   {
       if(bmpSrc== null)
           return null;

       //Get the original dimensions of the bitmap
       int nOriginWidth = bmpSrc.getWidth();
       int nOriginHeight = bmpSrc.getHeight();
       if(nWidth == nOriginWidth && nHeight == nOriginHeight)
           return bmpSrc;

       //Prepare a drawing bitmap and graphic object
       Bitmap bmpOrigin = new Bitmap(nOriginWidth, nOriginHeight);
       Graphics graph = Graphics.create(bmpOrigin);

       //Create a line of transparent pixels for later use
       int[] aEmptyLine = new int[nWidth];
       for(int x = 0; x < nWidth; x++)
           aEmptyLine[x] = 0x00000000;
       //Create two scaled bitmaps
       Bitmap[] bmpScaled = new Bitmap[2];
       for(int i = 0; i < 2; i++)
       {
           //Draw the bitmap on a white background first, 
           //then on a black background
           graph.setColor((i == 0) ? Color.WHITE : Color.BLACK);
           graph.fillRect(0, 0, nOriginWidth, nOriginHeight);
           graph.drawBitmap(0, 0, nOriginWidth, nOriginHeight, bmpSrc, 0, 0);

           //Create a new bitmap with the desired size
           bmpScaled[i] = new Bitmap(nWidth, nHeight);
           if(nAspectRatio == Bitmap.SCALE_TO_FIT)
           {
               //Set the alpha channel of all pixels to 0 
               //to ensure transparency is
               //applied around the picture, if needed by the transformation
               for(int y = 0; y < nHeight; y++)
                   bmpScaled[i].setARGB(aEmptyLine, 0, nWidth, 
                     0, y, nWidth, 1);
           }

           //Scale the bitmap
           bmpOrigin.scaleInto(bmpScaled[i], nFilterType, nAspectRatio);
       }

       //Prepare objects for final iteration
       Bitmap bmpFinal = bmpScaled[0];
       int[][] aPixelLine = new int[2][nWidth];

       //Iterate every line of the two scaled bitmaps
       for(int y = 0; y < nHeight; y++)
       {
           bmpScaled[0].getARGB(aPixelLine[0], 0, nWidth, 0, y, nWidth, 1);
           bmpScaled[1].getARGB(aPixelLine[1], 0, nWidth, 0, y, nWidth, 1);

           //Check every pixel one by one
           for(int x = 0; x < nWidth; x++)
           {
               //If the pixel was untouched (alpha channel still at 0), 
               //keep it transparent
               if(((aPixelLine[0][x] >> 24) & 0xff) == 0)
                   aPixelLine[0][x] = 0x00000000;
               else
               {
                   //Compute the alpha value based on the difference 
                   //of intensity in the red channel
                   int nAlpha = ((aPixelLine[1][x] >> 16) & 0xff) -
                                   ((aPixelLine[0][x] >> 16) & 0xff) + 255;
                   if(nAlpha == 0)
                       aPixelLine[0][x] = 0x00000000; //Completely transparent
                   else if(nAlpha >= 255)
                       aPixelLine[0][x] |= 0xff000000; //Completely opaque
                   else
                   {
                       //Compute the value of the each channel one by one
                       int nRed = ((aPixelLine[0][x] >> 16 ) & 0xff);
                       int nGreen = ((aPixelLine[0][x] >> 8 ) & 0xff);
                       int nBlue = (aPixelLine[0][x] & 0xff);

                       nRed = (int)(255 + 
                         (255.0 * ((double)(nRed-255)/(double)nAlpha)));
                       nGreen = (int)(255 + 
                         (255.0 * ((double)(nGreen-255)/(double)nAlpha)));
                       nBlue = (int)(255 + 
                         (255.0 * ((double)(nBlue-255)/(double)nAlpha)));

                       if(nRed < 0) nRed = 0;
                       if(nGreen < 0) nGreen = 0;
                       if(nBlue < 0) nBlue = 0;
                       aPixelLine[0][x] = nBlue | (nGreen<<8) | 
                         (nRed<<16) | (nAlpha<<24);
                   }
               }
           }

           //Change the pixels of this line to their final value
           bmpFinal.setARGB(aPixelLine[0], 0, nWidth, 0, y, nWidth, 1);
       }
       return bmpFinal;
   }
}