Gradient in MHP

Question

Hi,
does anybody knows a way to fill, let's say HStaticText elements, with a gradient color?
Is it possible, since Graphics2D is not available on MHP?
Thank you for your all replies.
Regards.
Alex.

Answer 1

Thank you, Roger for your soon reply, you've confirmed my suspicions.
I've coded this class to solve my problem. It extends the HTextLook and paints a vertical gradient from one color to another. Maybe could be handful for someone, so, I put the code:
import java.awt.Color;
import java.awt.Graphics;
import org.havi.ui.HTextLook;
import org.havi.ui.HVisible;
// Look para los HStaticText que establece un degradado vertical como fondo
// Se indica el color
public class GradientLook extends HTextLook {
     private Color startColor, endColor;
     private int startOffset, endOffset;     
     private int redDistance, greenDistance, blueDistance;
     private int redStep, greenStep, blueStep;
     private int redDelta, greenDelta, blueDelta;
     private int redCorrection, greenCorrection, blueCorrection;     
     private boolean verbose;
     GradientLook(Color startColor, Color endColor, int startOffset, int endOffset) {
          this.startColor = startColor;
          this.endColor = endColor;
          this.startOffset = startOffset;
          this.endOffset = endOffset;
          verbose = false;
     public void showLook(Graphics g, HVisible visible, int state) {
          if ((visible != null) && (g != null)) {
               if (verbose) System.out.println("Entering GradientLook...");
              int alturaGradiente = visible.getHeight() - startOffset - endOffset;
              g.setColor(startColor);
              g.fillRect(0, 0, visible.getWidth(), startOffset);                                      
              g.setColor(endColor);
              g.fillRect(0, visible.getHeight() - endOffset, visible.getWidth(), endOffset);                                      
              if (alturaGradiente > 0) {
                   redDistance = Math.abs(startColor.getRed() - endColor.getRed());
                   greenDistance = Math.abs(startColor.getGreen() - endColor.getGreen());
                   blueDistance = Math.abs(startColor.getBlue() - endColor.getBlue());             
                   if (verbose) System.out.println("Gradient lines: " + alturaGradiente );
                   if (verbose) System.out.println("Distances: (R)" + redDistance + " (G)" + greenDistance + " (B)" + blueDistance);
                   int step;
                   int delta;
                   if (redDistance > alturaGradiente) {
                            redStep = 1;                             
                        delta = 1;
                        while (alturaGradiente*delta < redDistance) delta++;
                        redDelta = delta;
                        // es mejor aproximaci�n con el delta inmediatamente inferior 
                        if (redDistance - alturaGradiente*(delta-1) < alturaGradiente*delta - redDistance) redDelta = delta-1;                             
                   if (redDistance < alturaGradiente) {
                        redDelta = 1;
                        step=1;
                        while (alturaGradiente/step > redDistance) step++;
                        redStep = step;
                        // es mejor aproximaci�n con el step inmediatamente inferior 
                        if (alturaGradiente/(step-1) - redDistance < redDistance - alturaGradiente/step ) redStep = step-1;                                                     
                   if (redDistance == 0) {
                        redDelta = 0;
                        redStep = 1;
                   if (startColor.getRed() - endColor.getRed() < 0) redDelta = redDelta*(-1);                        
                   if (greenDistance > alturaGradiente) {
                            greenStep = 1;                             
                        delta = 1;
                        while (alturaGradiente*delta < greenDistance) delta++;
                        greenDelta = delta;
                        // es mejor aproximaci�n con el delta inmediatamente inferior 
                        if (greenDistance - alturaGradiente*(delta-1) < alturaGradiente*delta - greenDistance) greenDelta = delta-1;                             
                   if (greenDistance < alturaGradiente) {
                        greenDelta = 1;
                        step=1;
                        while (alturaGradiente/step > greenDistance) step++;
                        greenStep = step;
                        // es mejor aproximaci�n con el step inmediatamente inferior 
                        if (alturaGradiente/(step-1) - greenDistance < greenDistance - alturaGradiente/step ) greenStep = step-1;                                                                             
                   if (greenDistance == 0) {
                        greenDelta = 0;
                        greenStep = 1;
                   if (startColor.getGreen() - endColor.getGreen() < 0) greenDelta = greenDelta*(-1);                        
                   if (blueDistance > alturaGradiente) {
                            blueStep = 1;                             
                        delta = 1;
                        while (alturaGradiente*delta < blueDistance) delta++;
                        blueDelta = delta;
                        // es mejor aproximaci�n con el delta inmediatamente inferior 
                        if (blueDistance - alturaGradiente*(delta-1) < alturaGradiente*delta - blueDistance) blueDelta = delta-1;                             
                   if (blueDistance < alturaGradiente) {
                        blueDelta = 1;
                        step=1;
                        while (alturaGradiente/step > blueDistance) step++;
                        blueStep = step;
                        // es mejor aproximaci�n con el step inmediatamente inferior 
                        if (alturaGradiente/(step-1) - blueDistance < blueDistance - alturaGradiente/step ) blueStep = step-1;                             
                   if (blueDistance == 0) {
                        blueDelta = 0;
                        blueStep = 1;
                   if (startColor.getBlue() - endColor.getBlue() < 0) blueDelta = blueDelta*(-1);                        
                   redCorrection = redDistance - ( alturaGradiente/redStep*Math.abs(redDelta) );
                   greenCorrection = greenDistance - ( alturaGradiente/greenStep*Math.abs(greenDelta) );
                   blueCorrection = blueDistance - ( alturaGradiente/blueStep*Math.abs(blueDelta) );
                   if (verbose) System.out.println("R: Step=" + redStep + "  Delta=" + redDelta + "  Correction=" + redCorrection);
                   if (verbose) System.out.println("G: Step=" + greenStep + "  Delta=" + greenDelta + "  Correction=" + greenCorrection);
                   if (verbose) System.out.println("B: Step=" + blueStep + "  Delta=" + blueDelta + "  Correction=" + blueCorrection);
                   if (verbose) System.out.println("Initial: " + startColor.getRed() + " " + startColor.getGreen() + " " + startColor.getBlue());
                   int green = startColor.getGreen();
                   int red = startColor.getRed();
                   int blue = startColor.getBlue();
                   for (int i = 0; i < alturaGradiente; i++) {                   
                        if (i % redStep == 0) red -= redDelta;
                        if (i % greenStep == 0) green -= greenDelta;
                        if (i % blueStep == 0) blue -= blueDelta;
                        // Corrector 1 (se queda corto)
                        if (i > alturaGradiente - redCorrection) red -= redDelta/(Math.abs(redDelta));
                        if (i > alturaGradiente - greenCorrection) green -= greenDelta/(Math.abs(greenDelta));
                        if (i > alturaGradiente - blueCorrection) blue -= blueDelta/(Math.abs(blueDelta));
                        // Corrector 2 (se pasa)
                        if (i*redDelta/redStep > redDistance - redDelta) red = endColor.getRed();
                        if (i*greenDelta/greenStep > greenDistance - greenDelta) green = endColor.getGreen();
                        if (i*Math.abs(blueDelta)/blueStep > blueDistance - Math.abs(blueDelta)) blue = endColor.getBlue();
                        //if (verbose) System.out.println("         " + red + " " + green + " " + blue + "    gradient line="+ (i+1));
                        g.setColor(new Color(red, green, blue));
                        g.fillRect(0, startOffset + i, visible.getWidth(), 1);                                      
                   if (verbose) System.out.println("Final:   " + endColor.getRed() + " " + endColor.getGreen() + " " + endColor.getBlue());
}The usage is quite simple:
HStaticText gradientLabel;
// whatever with gradientLabel...
try{
               gradientLabel.setLook(new GradientLook(Color.BLUE, Color.BLUE.darker().darker(), 20, 1));
} catch(HInvalidLookException e) {}