@@ -182,7 +182,7 @@ TInt BBitmap::NextUnusedColor() {
   return -1;
 }
 
-TInt BBitmap::FindColor(TRGB &aColor) {
+TInt BBitmap::FindColor(const TRGB &aColor) {
   for (TInt ndx = 0; ndx < 256; ndx++) {
     if (mColorsUsed[ndx] && mPalette[ndx] == aColor) {
       return ndx;
@@ -641,9 +641,30 @@ TBool BBitmap::DrawStringShadow(BViewPort *aViewPort, const char *aStr,
     : EFalse;
 }
 
+TBool BBitmap::DrawStringShadow(BViewPort *aViewPort, const char *aStr, const BFont *aFont,
+                                TInt aX, TInt aY, const TRGB &aFgColor, const TRGB &aShadowColor,
+                                const TRGB &aBgColor, TInt aLetterSpacing) {
+  const TInt32 bg = aBgColor == -1 ? -1 : aBgColor.rgb888();
+  return DrawString(aViewPort, aStr, aFont, aX, aY, aShadowColor.rgb888(), bg, aLetterSpacing)
+    ? DrawString(aViewPort, aStr, aFont, aX - 1, aY - 1, aFgColor.rgb888(), bg, aLetterSpacing)
+    : EFalse;
+}
+
+TBool BBitmap::DrawString(BViewPort *aViewPort, const char *aStr, const BFont *aFont,
+                          TInt aX, TInt aY, const TRGB &aFgColor, const TRGB &aBgColor,
+                          TInt aLetterSpacing) {
+  const TInt32 bg = aBgColor == -1 ? -1 : aBgColor.rgb888();
+  return DrawString(aViewPort, aStr, aFont, aX, aY, aFgColor.rgb888(), bg, aLetterSpacing);
+}
+
 TBool BBitmap::DrawString(BViewPort *aViewPort, const char *aStr,
                           const BFont *aFont, TInt aX, TInt aY, TUint32 aFgColor, TInt32 aBgColor,
                           TInt aLetterSpacing) {
+  if (gDisplay.renderBitmap->mDepth == 32) {
+    aFgColor = mPalette[aFgColor].rgb888();
+    aBgColor = aBgColor == -1 ? -1 : mPalette[aBgColor].rgb888();
+  }
+
   const TInt    fontWidth   = aFont->mWidth,
                 fontHeight  = aFont->mHeight,
                 charOffset  = fontWidth + aLetterSpacing;
@@ -696,7 +717,6 @@ TBool BBitmap::DrawString(BViewPort *aViewPort, const char *aStr,
 
     for (TInt y = charRect.y1; y < charRect.y2; y++, pixels += nextRow) {
       for (TInt x = charRect.x1; x < charRect.x2; x++, pixels++) {
-        // TUint32 pix = fontBitmap->ReadPixel(x, y);
         TUint32 pix = (fontBitmap->*ReadPixelByDepth)(x, y);
         // Write background and foreground pixels
         if (pix == 0) {
@@ -716,10 +736,53 @@ TBool BBitmap::DrawString(BViewPort *aViewPort, const char *aStr,
   return drawn;
 }
 
-void BBitmap::Clear(TUint32 aColor) {
+void BBitmap::Clear(const TRGB &aColor) {
+  const TInt len = mPitch * mHeight;
+
+  if (aColor == 0) {
+    memset(mPixels, 0, len * sizeof(TUint32));
+    return;
+  }
+
+  TUint32 color = aColor.rgb888();
+  for (TInt i = 0; i < len; i++) {
+    WritePixel(i, 0, color);
+  }
+}
+
+void BBitmap::Clear(TUint8 aIndex) {
   const TInt len = mPitch * mHeight;
+
+  if (gDisplay.renderBitmap->mDepth == 32) {
+    Clear(mPalette[aIndex]);
+    return;
+  }
+
+  if (aIndex == 0) {
+    memset(mPixels, aIndex, len * sizeof(TUint32));
+    return;
+  }
+
   for (TInt i = 0; i < len; i++) {
-    WritePixel(i, 0, aColor);
+    WritePixel(i, 0, aIndex);
+  }
+}
+
+void BBitmap::WritePixel(TInt aX, TInt aY, TUint8 aIndex) {
+  if (gDisplay.renderBitmap->mDepth == 32) {
+    WritePixel(aX, aY, mPalette[aIndex]);
+    return;
+  }
+  mPixels[aY * mPitch + aX] = aIndex;
+}
+
+void BBitmap::SafeWritePixel(TInt aX, TInt aY, TUint8 aIndex) {
+  if (mDimensions.PointInRect(aX, aY)) {
+    if (gDisplay.renderBitmap->mDepth == 32) {
+      WritePixel(aX, aY, mPalette[aIndex]);
+      return;
+    }
+    WritePixel(aX, aY, aIndex);
   }
 }
 
 
@@ -118,11 +118,10 @@ class BBitmap : public BBase {
    *
    * Return index in palette of found color, or -1 if not found.
    */
-  TInt FindColor(TRGB &aColor);
+  TInt FindColor(const TRGB &aColor);
 
   TInt FindColor(TInt aRed, TInt aGreen, TInt aBlue) {
-    TRGB color(aRed, aGreen, aBlue);
-    return FindColor(color);
+    return FindColor(TRGB(aRed, aGreen, aBlue));
   }
 
   /**
@@ -151,7 +150,7 @@ class BBitmap : public BBase {
     mPalette[index].Set(r, g, b);
   }
 
-  void SetColor(TUint8 index, TRGB aColor) {
+  void SetColor(TUint8 index, const TRGB &aColor) {
 #ifndef PRODUCTION
 #if (defined(__XTENSA__) && defined(DEBUGME)) || !defined(__XTENSA__)
     printf("SetColor %d, %02x%02x%02x\n", index, aColor.r, aColor.g, aColor.b);
@@ -173,22 +172,27 @@ class BBitmap : public BBase {
 
   TUint32 ReadPixel(TInt aX, TInt aY) { return mPixels[aY * mPitch + aX]; }
 
-  void WritePixel(TInt aX, TInt aY, TUint32 aColor) {
-    mPixels[aY * mPitch + aX] = aColor;
+  void WritePixel(TInt aX, TInt aY, const TRGB &aColor) {
+    mPixels[aY * mPitch + aX] = aColor.rgb888();
   }
 
-  void SafeWritePixel(TInt aX, TInt aY, TUint32 aColor) {
+  void SafeWritePixel(TInt aX, TInt aY, const TRGB &aColor) {
     if (mDimensions.PointInRect(aX, aY)) {
-      WritePixel(aX, aY, aColor);
+      WritePixel(aX, aY, aColor.rgb888());
     }
   }
 
+  void WritePixel(TInt aX, TInt aY, TUint8 aColor);
+
+  void SafeWritePixel(TInt aX, TInt aY, TUint8 aColor);
+
 public:
   // DRAWING PRIMITIVES
   /**
    * Erase bitmap to specified color
    */
-  void Clear(TUint32 aColor = 0);
+  void Clear(TUint8 aIndex = 0);
+  void Clear(const TRGB &aColor);
 
   /**
    * Copy the pixels from one bitmap to another.
@@ -279,6 +283,14 @@ class BBitmap : public BBase {
       TInt aDstX, TInt aDstY, TUint32 aFgColor, TInt32 aBgColor = -1,
       TInt aLetterSpacing = 0);
 
+  TBool DrawString(BViewPort *aViewPort, const char *aStr, const BFont *aFont,
+      TInt aDstX, TInt aDstY, const TRGB &aFgColor, const TRGB &aBgColor,
+      TInt aLetterSpacing = 0);
+
+  TBool DrawStringShadow(BViewPort *aViewPort, const char *aStr,
+      const BFont *aFont, TInt aDstX, TInt aDstY, const TRGB &aFgColor,
+      const TRGB &aShadowColor, const TRGB &aBgColor = -1, TInt aLetterSpacing = 0);
+
   TBool DrawStringShadow(BViewPort *aViewPort, const char *aStr,
       const BFont *aFont, TInt aDstX, TInt aDstY, TUint32 aFgColor,
       TUint32 aShadowColor, TInt32 aBgColor = -1, TInt aLetterSpacing = 0);
 
@@ -5,13 +5,17 @@
 #include "BTypes.h"
 
 struct TRGB {
-  TUint8 r, g, b;
+  TInt16 r, g, b;
 
 public:
   TRGB() {
     r = g = b = 0;
   }
 
+  TRGB(TInt aVal) {
+    r = g = b = aVal;
+  }
+
   TRGB(TUint32 aColor) {
     r = TUint8((aColor >> 16) & 0xff);
     g = TUint8((aColor >> 8) & 0xff);
@@ -24,7 +28,7 @@ struct TRGB {
     b = aBlue;
   }
 
-  TRGB(TRGB &aOther) {
+  TRGB(const TRGB &aOther) {
     r = aOther.r;
     g = aOther.g;
     b = aOther.b;
@@ -37,7 +41,7 @@ struct TRGB {
     b = aBlue;
   }
 
-  void Set(TRGB &aOther) {
+  void Set(const TRGB &aOther) {
     r = aOther.r;
     g = aOther.g;
     b = aOther.b;
@@ -62,24 +66,28 @@ struct TRGB {
   }
 
 public:
-  TUint32 rgb888() { return (r << 16) | (g << 8) | (b << 0); }
+  TUint32 rgb888() const { return (TUint8(r) << 16) | (TUint8(g) << 8) | (TUint8(b) << 0); }
 
-  TUint16 rgb565() {
+  TUint16 rgb565() const {
     return ((TUint16(r & 0b11111000) << 8)) | ((TUint16(g & 0b11111100) << 3)) | (TUint16(b) >> 3);
   }
 
-  TUint16 bgr565() {
+  TUint16 bgr565() const {
     return ((b & 0b11111000) << 8) | ((g & 0b11111100) << 3) | (r >> 3);
   }
 
-  TUint16 brg565() {
+  TUint16 brg565() const {
     return ((b & 0b11111000) << 8) | ((r & 0b11111100) << 3) | (g >> 3);
   }
 
-  TBool operator==(TRGB &aOther) {
+  TBool operator==(const TRGB &aOther) {
     return (r == aOther.r && g == aOther.g && b == aOther.b);
   }
 
+  TBool operator==(TInt aInt) const {
+    return (r == aInt && g == aInt && b == aInt);
+  }
+
 public:
   void Dump() {
 #ifndef PRODUCTION