开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > J2ME > 查看源码
DefaultLookAndFeel.java
资源名称：LWUIT1.3code.rar　[点击查看]
上传用户：haobig99
上传日期：2022-06-15
资源大小：369k
文件大小：58k
源码类别：

J2ME

开发平台：

Java

DefaultLookAndFeel.java：源码内容
  1. /*
  2.  * Copyright 2008 Sun Microsystems, Inc.  All Rights Reserved.
  3.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4.  *
  5.  * This code is free software; you can redistribute it and/or modify it
  6.  * under the terms of the GNU General Public License version 2 only, as
  7.  * published by the Free Software Foundation.  Sun designates this
  8.  * particular file as subject to the "Classpath" exception as provided
  9.  * by Sun in the LICENSE file that accompanied this code.
  10.  *
  11.  * This code is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14.  * version 2 for more details (a copy is included in the LICENSE file that
  15.  * accompanied this code).
  16.  *
  17.  * You should have received a copy of the GNU General Public License version
  18.  * 2 along with this work; if not, write to the Free Software Foundation,
  19.  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20.  *
  21.  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  22.  * CA 95054 USA or visit www.sun.com if you need additional information or
  23.  * have any questions.
  24.  */
  25. package com.sun.lwuit.plaf;
  27. import com.sun.lwuit.geom.Dimension;
  28. import com.sun.lwuit.Graphics;
  29. import com.sun.lwuit.Image;
  30. import com.sun.lwuit.Button;
  31. import com.sun.lwuit.Component;
  32. import com.sun.lwuit.Display;
  33. import com.sun.lwuit.Label;
  34. import com.sun.lwuit.List;
  35. import com.sun.lwuit.TextArea;
  36. import com.sun.lwuit.list.ListCellRenderer;
  37. import com.sun.lwuit.list.ListModel;
  38. import com.sun.lwuit.Font;
  39. import com.sun.lwuit.TabbedPane;
  40. import com.sun.lwuit.events.FocusListener;
  41. import com.sun.lwuit.geom.Rectangle;
  43. /**
  44.  * Used to render the default look of LWUIT
  45.  *
  46.  * @author Chen Fishbein
  47.  */
  48. public class DefaultLookAndFeel extends LookAndFeel implements FocusListener {
  49.     private Image[] chkBoxImages = null;
  50.     private Image comboImage = null;
  51.     private Image[] rButtonImages = null;
  52.     private boolean tickWhenFocused = true;
  54.     /** Creates a new instance of DefaultLookAndFeel */
  55.     public DefaultLookAndFeel() {
  56.     }
  58.     /**
  59.      * @inheritDoc
  60.      */
  61.     public void bind(Component cmp) {
  62.         if (tickWhenFocused && cmp instanceof Label) {
  63.             ((Label) cmp).addFocusListener(this);
  64.         }
  65.     }
  66.     /**
  67.      * This method allows to set all Labels, Buttons, CheckBoxes, RadioButtons
  68.      * to start ticking when the text is too long. 
  69.      * @param tickWhenFocused
  70.      */
  71.     public void setTickWhenFocused(boolean tickWhenFocused) {
  72.         this.tickWhenFocused = tickWhenFocused;
  73.     }
  75.     /**
  76.      * Sets images for checkbox checked/unchecked modes
  77.      * 
  78.      * @param checked the image to draw in order to represent a checked checkbox
  79.      * @param unchecked the image to draw in order to represent an uncheck checkbox
  80.      */
  81.     public void setCheckBoxImages(Image checked, Image unchecked) {
  82.         if (checked == null || unchecked == null) {
  83.             chkBoxImages = null;
  84.         } else {
  85.             chkBoxImages = new Image[]{unchecked, checked};
  86.         }
  87.     }
  89.     /**
  90.      * Sets image for the combo box dropdown drawing
  91.      * 
  92.      * @param picker picker image
  93.      */
  94.     public void setComboBoxImage(Image picker) {
  95.         comboImage = picker;
  96.     }
  98.     /**
  99.      * Sets images for radio button selected/unselected modes
  100.      * 
  101.      * @param selected the image to draw in order to represent a selected radio button
  102.      * @param unselected the image to draw in order to represent an unselected radio button
  103.      */
  104.     public void setRadioButtonImages(Image selected, Image unselected) {
  105.         if (selected == null || unselected == null) {
  106.             rButtonImages = null;
  107.         } else {
  108.             rButtonImages = new Image[]{unselected, selected};
  109.         }
  110.     }
  112.     /**
  113.      * Returns the images used to represent the radio button (selected followed by unselected).
  114.      * 
  115.      * @return images representing the radio button or null for using the default drawing
  116.      */
  117.     public Image[] getRadioButtonImages() {
  118.         return rButtonImages;
  119.     }
  121.     /**
  122.      * Returns the images used to represent the checkbox (selected followed by unselected).
  123.      *
  124.      * @return images representing the check box or null for using the default drawing
  125.      */
  126.     public Image[] getCheckBoxImages() {
  127.         return chkBoxImages;
  128.     }
  130.     /**
  131.      * @inheritDoc
  132.      */
  133.     public void drawButton(Graphics g, Button b) {
  134.         drawComponent(g, b, b.getIconFromState(), null, 0);
  135.     }
  137.     /**
  138.      * @inheritDoc
  139.      */
  140.     public void drawCheckBox(Graphics g, Button cb) {
  141.         if (chkBoxImages != null) {
  142.             drawComponent(g, cb, cb.getIconFromState(), chkBoxImages[cb.isSelected() ? 1 : 0], 0);
  143.         } else {
  144.             Style style = cb.getStyle();
  146.             // checkbox square needs to be the height and width of the font height even
  147.             // when no text is in the check box this is a good indication of phone DPI
  148.             int height = cb.getStyle().getFont().getHeight();
  150.             drawComponent(g, cb, cb.getIconFromState(), null, height);
  152.             int gradientColor;
  153.             g.setColor(style.getFgColor());
  154.             gradientColor = style.getBgColor();
  156.             int width = height;
  158.             int rectWidth = scaleCoordinate(12f, 16, width);
  159.             int tX = cb.getX();
  160.             if (cb.isRTL()) {
  161.              tX = tX + cb.getWidth() - style.getPadding(cb.isRTL(), Component.LEFT) - rectWidth;
  162.             } else {
  163.              tX += style.getPadding(cb.isRTL(), Component.LEFT);
  164.             }
  166.             int tY = cb.getY() + style.getPadding(false, Component.TOP) + (cb.getHeight() - style.getPadding(false, Component.TOP) - style.getPadding(false, Component.BOTTOM)) / 2 - height / 2;
  167.             g.translate(tX, tY);
  168.             int x = scaleCoordinate(1.04f, 16, width);
  169.             int y = scaleCoordinate(4.0f, 16, height);
  170.             int rectHeight = scaleCoordinate(12f, 16, height);
  172.             // brighten or darken the color slightly
  173.             int destColor = findDestColor(gradientColor);
  175.             g.fillLinearGradient(gradientColor, destColor, x + 1, y + 1, rectWidth - 2, rectHeight - 1, false);
  176.             g.drawRoundRect(x, y, rectWidth, rectHeight, 5, 5);
  178.             if (cb.isSelected()) {
  179.                 int color = g.getColor();
  180.                 g.setColor(0x111111);
  181.                 g.translate(0, 1);
  182.                 fillCheckbox(g, width, height);
  183.                 g.setColor(color);
  184.                 g.translate(0, -1);
  185.                 fillCheckbox(g, width, height);
  186.             }
  187.             g.translate(-tX, -tY);
  188.         }
  189.     }
  191.     private static void fillCheckbox(Graphics g, int width, int height) {
  192.         int x1 = scaleCoordinate(2.0450495f, 16, width);
  193.         int y1 = scaleCoordinate(9.4227722f, 16, height);
  194.         int x2 = scaleCoordinate(5.8675725f, 16, width);
  195.         int y2 = scaleCoordinate(13.921746f, 16, height);
  196.         int x3 = scaleCoordinate(5.8675725f, 16, width);
  197.         int y3 = scaleCoordinate(11f, 16, height);
  198.         g.fillTriangle(x1, y1, x2, y2, x3, y3);
  200.         x1 = scaleCoordinate(14.38995f, 16, width);
  201.         y1 = scaleCoordinate(0, 16, height);
  202.         g.fillTriangle(x1, y1, x2, y2, x3, y3);
  203.     }
  205.     private static int round(float x) {
  206.         int rounded = (int) x;
  207.         if (x - rounded > 0.5f) {
  208.             return rounded + 1;
  209.         }
  210.         return rounded;
  211.     }
  213.     /**
  214.      * Takes a floating point coordinate on a virtual axis and rusterizes it to 
  215.      * a coordinate in the pixel surface. This is a very simple algorithm since
  216.      * anti-aliasing isn't supported.
  217.      * 
  218.      * @param coordinate a position in a theoretical plain
  219.      * @param plain the amount of space in the theoretical plain
  220.      * @param pixelSize the amount of pixels available on the screen
  221.      * @return the pixel which we should color
  222.      */
  223.     private static int scaleCoordinate(float coordinate, float plain, int pixelSize) {
  224.         return round(coordinate / plain * pixelSize);
  225.     }
  227.     /**
  228.      * @inheritDoc
  229.      */
  230.     public void drawLabel(Graphics g, Label l) {
  231.         drawComponent(g, l, l.getIcon(), null, 0);
  232.     }
  234.     /**
  235.      * @inheritDoc
  236.      */
  237.     public void drawRadioButton(Graphics g, Button rb) {
  238.         if (rButtonImages != null) {
  239.             drawComponent(g, rb, rb.getIconFromState(), rButtonImages[rb.isSelected() ? 1 : 0], 0);
  240.         } else {
  241.             Style style = rb.getStyle();
  243.             // radio button radius needs to be of the size of the font height even
  244.             // when no text is in the radio button this is a good indication of phone DPI
  245.             int height = rb.getStyle().getFont().getHeight();
  247.             drawComponent(g, rb, rb.getIconFromState(), null, height + rb.getGap());
  248.             g.setColor(style.getFgColor());
  249.             int x = rb.getX();
  250.             if (rb.isRTL()) {
  251.              x = x + rb.getWidth() - style.getPadding(rb.isRTL(), Component.LEFT) - height;
  252.             } else {
  253.              x += style.getPadding(rb.isRTL(), Component.LEFT);
  254.             }
  256.             int y = rb.getY();
  258.             // center the RadioButton
  259.             y += Math.max(0, rb.getHeight() / 2 - height / 2);
  261.             g.drawArc(x, y, height, height, 0, 360);
  262.             if (rb.isSelected()) {
  263.                 int color = g.getColor();
  264.                 int destColor = findDestColor(color);
  265.                 g.fillRadialGradient(color, destColor, x + 3, y + 3, height - 5, height - 5);
  266.             }
  267.         }
  268.     }
  270.     /**
  271.      * @inheritDoc
  272.      */
  273.     public void drawComboBox(Graphics g, List cb) {
  274.         int border = 2;
  275.         Style style = cb.getStyle();
  276.         int leftPadding = style.getPadding(cb.isRTL(), Component.LEFT);
  277.         int rightPadding = style.getPadding(cb.isRTL(), Component.RIGHT);
  279.         setFG(g, cb);
  281.         ListModel model = cb.getModel();
  282.         ListCellRenderer renderer = cb.getRenderer();
  283.         Object value = model.getItemAt(model.getSelectedIndex());
  284.         int comboImageWidth;
  285.         if (comboImage != null) {
  286.             comboImageWidth = comboImage.getWidth();
  287.         } else {
  288.             comboImageWidth = style.getFont().getHeight();
  289.         }
  290.         
  291.         int cellX = cb.getX() + style.getPadding(false, Component.TOP);
  292.         if(cb.isRTL()){
  293.             cellX += comboImageWidth;
  294.         }
  295.         
  296.         if (model.getSize() > 0) {
  297.             Component cmp = renderer.getListCellRendererComponent(cb, value, model.getSelectedIndex(), cb.hasFocus());
  298.             cmp.setX(cellX);
  299.             cmp.setY(cb.getY() + style.getPadding(false, Component.TOP));
  300.             cmp.setWidth(cb.getWidth() - comboImageWidth - 2 * rightPadding - leftPadding);
  301.             cmp.setHeight(cb.getHeight() - style.getPadding(false, Component.TOP) - style.getPadding(false, Component.BOTTOM));
  302.             cmp.paint(g);
  303.         }
  305.         g.setColor(style.getBgColor());
  306.         int y = cb.getY();
  307.         int height = cb.getHeight();
  308.         int width = comboImageWidth + border;
  309.         int x = cb.getX();
  310.         if (cb.isRTL()) {
  311.          x += leftPadding;
  312.         } else {
  313.          x += cb.getWidth() - comboImageWidth - rightPadding - border;
  314.         }
  316.         if (comboImage != null) {
  317.             g.drawImage(comboImage, x, y + height / 2 - comboImage.getHeight() / 2);
  318.         } else {
  319.             int color = g.getColor();
  321.             // brighten or darken the color slightly
  322.             int destColor = findDestColor(color);
  324.             g.fillLinearGradient(g.getColor(), destColor, x, y, width, height, false);
  325.             g.setColor(color);
  326.             g.drawRect(x, y, width, height - 1);
  328.             width--;
  329.             height--;
  331.             //g.drawRect(x, y, width, height);
  332.             g.translate(x + 1, y + 1);
  333.             g.setColor(0x111111);
  334.             int x1 = scaleCoordinate(2.5652081f, 16, width);
  335.             int y1 = scaleCoordinate(4.4753664f, 16, height);
  336.             int x2 = scaleCoordinate(8.2872691f, 16, width);
  337.             int y2 = scaleCoordinate(10f, 16, height);
  338.             int x3 = scaleCoordinate(13.516078f, 16, width);
  339.             int y3 = y1;
  340.             g.fillTriangle(x1, y1, x2, y2, x3, y3);
  341.             g.translate(-1, -1);
  342.             g.setColor(style.getFgColor());
  343.             g.fillTriangle(x1, y1, x2, y2, x3, y3);
  344.             //g.setColor(style.getFgColor());
  345.             //g.fillTriangle(x1 + 2, y1 + 2, x2, y2 - 2, x3 - 2, y3 + 2);
  347.             g.translate(-x, -y);
  348.         }
  350.     }
  352.     /**
  353.      * Finds a suitable destination color for gradient values
  354.      */
  355.     private int findDestColor(int color) {
  356.         // brighten or darken the color slightly
  357.         int sourceR = color >> 16 & 0xff;
  358.         int sourceG = color >> 8 & 0xff;
  359.         int sourceB = color & 0xff;
  360.         if (sourceR > 128 && sourceG > 128 && sourceB > 128) {
  361.             // darken
  362.             sourceR = Math.max(sourceR >> 1, 0);
  363.             sourceG = Math.max(sourceG >> 1, 0);
  364.             sourceB = Math.max(sourceB >> 1, 0);
  365.         } else {
  366.             // special case for black, since all channels are 0 it can't be brightened properly...
  367.             if(color == 0) {
  368.                 return 0x222222;
  369.             }
  370.             
  371.             // brighten
  372.             sourceR = Math.min(sourceR << 1, 0xff);
  373.             sourceG = Math.min(sourceG << 1, 0xff);
  374.             sourceB = Math.min(sourceB << 1, 0xff);
  375.         }
  376.         return ((sourceR << 16) & 0xff0000) | ((sourceG << 8) & 0xff00) | (sourceB & 0xff);
  377.     }
  379.     /**
  380.      * @inheritDoc
  381.      */
  382.     public void drawList(Graphics g, List l) {
  383.     }
  385.     /**
  386.      * @inheritDoc
  387.      */
  388.     public void drawTextArea(Graphics g, TextArea ta) {
  389.         setFG(g, ta);
  390.         int line = ta.getLines();
  391.         int oX = g.getClipX();
  392.         int oY = g.getClipY();
  393.         int oWidth = g.getClipWidth();
  394.         int oHeight = g.getClipHeight();
  395.         Font f = ta.getStyle().getFont();
  396.         int fontHeight = f.getHeight();
  398.         int align = ta.getAbsoluteAlignment();
  400.         int leftPadding = ta.getStyle().getPadding(ta.isRTL(), Component.LEFT);
  401.         int rightPadding = ta.getStyle().getPadding(ta.isRTL(), Component.RIGHT);
  402.         int topPadding = ta.getStyle().getPadding(false, Component.TOP);
  403.         boolean shouldBreak = false;
  404.         
  405.         for (int i = 0; i < line; i++) {
  406.             int x = ta.getX() + leftPadding;
  407.             int y = ta.getY() +  topPadding +
  408.                     (ta.getRowsGap() + fontHeight) * i;
  409.             if(Rectangle.intersects(x, y, ta.getWidth(), fontHeight, oX, oY, oWidth, oHeight)) {
  410.                 
  411.                 String rowText = (String) ta.getTextAt(i);
  412.                 //display ******** if it is a password field
  413.                 String displayText = "";
  414.                 if ((ta.getConstraint() & TextArea.PASSWORD) != 0) {
  415.                     for (int j = 0; j < rowText.length(); j++) {
  416.                         displayText += "*";
  417.                     }
  418.                 } else {
  419.                     displayText = rowText;
  420.                 }
  422.                 switch(align) {
  423.                     case Component.RIGHT:
  424.                  x = ta.getX() + ta.getWidth() - rightPadding - f.stringWidth(displayText);
  425.                         break;
  426.                     case Component.CENTER:
  427.                         x+= (ta.getWidth()-leftPadding-rightPadding-f.stringWidth(displayText))/2;
  428.                         break;
  429.                 }
  430.             
  431.                 g.drawString(displayText, x, y);
  432.                 shouldBreak = true;
  433.             }else{
  434.                 if(shouldBreak){
  435.                     break;
  436.                 }
  437.             }
  438.         }
  439.     }
  441.     /**
  442.      * @inheritDoc
  443.      */
  444.     public Dimension getButtonPreferredSize(Button b) {
  445.         return getPreferredSize(b, new Image[]{b.getIcon(), b.getRolloverIcon(), b.getPressedIcon()}, null);
  446.     }
  448.     /**
  449.      * @inheritDoc
  450.      */
  451.     public Dimension getCheckBoxPreferredSize(Button cb) {
  452.         if (chkBoxImages != null) {
  453.             return getPreferredSize(cb, new Image[]{cb.getIcon(), cb.getRolloverIcon(), cb.getPressedIcon()}, chkBoxImages[0]);
  454.         }
  455.         Dimension d = getPreferredSize(cb, new Image[]{cb.getIcon(), cb.getRolloverIcon(), cb.getPressedIcon()}, null);
  457.         // checkbox square needs to be the height and width of the font height even
  458.         // when no text is in the check box this is a good indication of phone DPI
  459.         int checkBoxSquareSize = cb.getStyle().getFont().getHeight();
  461.         // allow for checkboxes without a string within them
  462.         d.setHeight(Math.max(checkBoxSquareSize, d.getHeight()));
  464.         d.setWidth(d.getWidth() + checkBoxSquareSize + cb.getGap());
  465.         return d;
  466.     }
  468.     /**
  469.      * @inheritDoc
  470.      */
  471.     public Dimension getLabelPreferredSize(Label l) {
  472.         return getPreferredSize(l, new Image[]{l.getIcon()}, null);
  473.     }
  475.     /**
  476.      * @inheritDoc
  477.      */
  478.     private Dimension getPreferredSize(Label l, Image[] icons, Image stateImage) {
  479.         int prefW = 0;
  480.         int prefH = 0;
  482.         Style style = l.getStyle();
  483.         int gap = l.getGap();
  484.         for (int i = 0; i < icons.length; i++) {
  485.             Image icon = icons[i];
  486.             if (icon != null) {
  487.                 prefW = Math.max(prefW, icon.getWidth());
  488.                 prefH = Math.max(prefH, icon.getHeight());
  489.             }
  490.         }
  491.         String text = l.getText();
  492.         Font font = style.getFont();
  493.         if (font == null) {
  494.             System.out.println("Missing font for " + l);
  495.             font = Font.getDefaultFont();
  496.         }
  497.         if (text != null && text.length() > 0) {
  498.             //add the text size
  499.             switch (l.getTextPosition()) {
  500.                 case Label.LEFT:
  501.                 case Label.RIGHT:
  502.                     prefW += font.stringWidth(text);
  503.                     prefH = Math.max(prefH, font.getHeight());
  504.                     break;
  505.                 case Label.BOTTOM:
  506.                 case Label.TOP:
  507.                     prefW = Math.max(prefW, font.stringWidth(text));
  508.                     prefH += font.getHeight();
  509.                     break;
  510.             }
  511.         }
  512.         //add the state image(relevant for CheckBoxRadioButton)
  513.         if (stateImage != null) {
  514.             prefW += (stateImage.getWidth() + gap);
  515.             prefH = Math.max(prefH, stateImage.getHeight());
  516.         }
  519.         if (icons[0] != null && text != null && text.length() > 0) {
  520.             switch (l.getTextPosition()) {
  521.                 case Label.LEFT:
  522.                 case Label.RIGHT:
  523.                     prefW += gap;
  524.                     break;
  525.                 case Label.BOTTOM:
  526.                 case Label.TOP:
  527.                     prefH += gap;
  528.                     break;
  529.             }
  530.         }
  532.         if (prefH != 0) {
  533.             prefH += (style.getPadding(false, Component.TOP) + style.getPadding(false, Component.BOTTOM));
  534.         }
  535.         if (prefW != 0) {
  536.             prefW += (style.getPadding(l.isRTL(), Component.RIGHT) + style.getPadding(l.isRTL(), Component.LEFT));
  537.         }
  538.         return new Dimension(prefW, prefH);
  539.     }
  541.     /**
  542.      * @inheritDoc
  543.      */
  544.     public Dimension getListPreferredSize(List l) {
  545.         int width = 0;
  546.         int height = 0;
  547.         int selectedHeight;
  548.         int selectedWidth;
  549.         ListModel model = l.getModel();
  550.         int numOfcomponents = Math.max(model.getSize(), l.getMinElementHeight());
  551.         Object prototype = l.getRenderingPrototype();
  553.         Style unselectedEntryStyle = null;
  554.         Style selectedEntryStyle;
  555.         if(prototype != null) {
  556.             ListCellRenderer renderer = l.getRenderer();
  557.             Component cmp = renderer.getListCellRendererComponent(l, prototype, 0, false);
  558.             height = cmp.getPreferredH();
  559.             width = cmp.getPreferredW();
  560.             unselectedEntryStyle = cmp.getStyle();
  561.             cmp = renderer.getListCellRendererComponent(l, prototype, 0, true);
  563.             selectedEntryStyle = cmp.getStyle();
  564.             selectedHeight = Math.max(height, cmp.getPreferredH());
  565.             selectedWidth = Math.max(width, cmp.getPreferredW());
  566.         } else {
  567.             int hightCalcComponents = Math.min(5, numOfcomponents);
  568.             Object dummyProto = l.getRenderingPrototype();
  569.             if(model.getSize() > 0 && dummyProto == null) {
  570.                 dummyProto = model.getItemAt(0);
  571.             }
  572.             ListCellRenderer renderer = l.getRenderer();
  573.             for (int i = 0; i < hightCalcComponents; i++) {
  574.                 Object value;
  575.                 if(i < model.getSize()) {
  576.                     value = model.getItemAt(i);
  577.                 } else {
  578.                     value = dummyProto;
  579.                 }
  580.                 Component cmp = renderer.getListCellRendererComponent(l, value, i, false);
  581.                 unselectedEntryStyle = cmp.getStyle();
  583.                 height = Math.max(height, cmp.getPreferredH());
  584.                 width = Math.max(width, cmp.getPreferredW());
  585.             }
  586.             selectedEntryStyle = unselectedEntryStyle;
  587.             selectedHeight = height;
  588.             selectedWidth = width;
  589.             if (model.getSize() > 0) {
  590.                 Object value = model.getItemAt(0);
  591.                 Component cmp = renderer.getListCellRendererComponent(l, value, 0, true);
  593.                 selectedHeight = Math.max(height, cmp.getPreferredH());
  594.                 selectedWidth = Math.max(width, cmp.getPreferredW());
  595.                 selectedEntryStyle = cmp.getStyle();
  596.             }
  597.         }
  598.         if(unselectedEntryStyle != null) {
  599.             selectedWidth += selectedEntryStyle.getMargin(false, Component.LEFT) + selectedEntryStyle.getMargin(false, Component.RIGHT);
  600.             selectedHeight += selectedEntryStyle.getMargin(false, Component.TOP) + selectedEntryStyle.getMargin(false, Component.BOTTOM);
  601.             width += unselectedEntryStyle.getMargin(false, Component.LEFT) + unselectedEntryStyle.getMargin(false, Component.RIGHT);
  602.             height += unselectedEntryStyle.getMargin(false, Component.TOP) + unselectedEntryStyle.getMargin(false, Component.BOTTOM);
  603.         }
  605.         Style lStyle = l.getStyle();
  606.         int verticalPadding = lStyle.getPadding(false, Component.TOP) + lStyle.getPadding(false, Component.BOTTOM);
  607.         int horizontalPadding = lStyle.getPadding(false, Component.RIGHT) + lStyle.getPadding(false, Component.LEFT);
  609.         if (numOfcomponents == 0) {
  610.             return new Dimension(horizontalPadding, verticalPadding);
  611.         }
  613.         // If combobox without ever importing the ComboBox class dependency
  614.         if(l.getOrientation() > List.HORIZONTAL) {
  615.             int boxWidth = l.getStyle().getFont().getHeight() + 2;
  616.             return new Dimension(boxWidth + selectedWidth + horizontalPadding, selectedHeight + verticalPadding);
  617.         } else {
  618.             if (l.getOrientation() == List.VERTICAL) {
  619.                 return new Dimension(selectedWidth + horizontalPadding, selectedHeight + (height + l.getItemGap()) * (numOfcomponents - 1) + verticalPadding);
  620.             } else {
  621.                 return new Dimension(selectedWidth + (width + l.getItemGap()) * (numOfcomponents - 1) + horizontalPadding, selectedHeight + verticalPadding);
  622.             }
  623.         }
  624.     }
  625.     
  626.     /**
  627.      * @inheritDoc
  628.      */
  629.     public Dimension getRadioButtonPreferredSize(Button rb) {
  630.         if (rButtonImages != null) {
  631.             return getPreferredSize(rb, new Image[]{rb.getIcon(), rb.getRolloverIcon(), rb.getPressedIcon()}, rButtonImages[0]);
  632.         }
  633.         Dimension d = getPreferredSize(rb, new Image[]{rb.getIcon(), rb.getRolloverIcon(), rb.getPressedIcon()}, null);
  635.         // radio button radius needs to be of the size of the font height even
  636.         // when no text is in the radio button this is a good indication of phone DPI
  637.         int height = rb.getStyle().getFont().getHeight();
  639.         // allow for radio buttons without a string within them
  640.         d.setHeight(Math.max(height, d.getHeight()));
  642.         d.setWidth(d.getWidth() + height + rb.getGap());
  643.         return d;
  644.     }
  646.     /**
  647.      * @inheritDoc
  648.      */
  649.     public Dimension getTextAreaSize(TextArea ta, boolean pref) {
  650.         int prefW = 0;
  651.         int prefH = 0;
  652.         Font f = ta.getStyle().getFont();
  654.         //if this is a text field the preferred size should be the text width
  655.         if (ta.getRows() == 1) {
  656.             prefW = f.stringWidth(ta.getText());
  657.         } else {
  658.             prefW = f.charWidth(TextArea.getWidestChar()) * ta.getColumns();
  659.         }
  660.         int rows;
  661.         if(pref) {
  662.             rows = ta.getActualRows();
  663.         } else {
  664.             rows = ta.getLines();
  665.         }
  666.         prefH = (f.getHeight() + 2) * rows;
  667.         int columns = ta.getColumns();
  668.         String str = "";
  669.         for (int iter = 0; iter < columns; iter++) {
  670.             str += TextArea.getWidestChar();
  671.         }
  672.         if(columns > 0) {
  673.             prefW = Math.max(prefW, f.stringWidth(str));
  674.         }
  675.         prefH = Math.max(prefH, rows * f.getHeight());
  677.         return new Dimension(prefW + ta.getStyle().getPadding(false, Component.RIGHT) + ta.getStyle().getPadding(false, Component.LEFT), 
  678.                 prefH + ta.getStyle().getPadding(false, Component.TOP) + ta.getStyle().getPadding(false, Component.BOTTOM));
  679.     }
  681.     /**
  682.      * Reverses alignment in the case of bidi
  683.      */
  684.     private int reverseAlignForBidi(Component c, int align) {
  685.         if(c.isRTL()) {
  686.             switch(align) {
  687.                 case Component.RIGHT:
  688.                     return Component.LEFT;
  689.                 case Component.LEFT:
  690.                     return Component.RIGHT;
  691.             }
  692.         }
  693.         return align;
  694.     }
  696.     private void drawComponent(Graphics g, Label l, Image icon, Image stateIcon, int preserveSpaceForState) {
  697.         setFG(g, l);
  699.         int gap = l.getGap();
  700.         int stateIconSize = 0;
  701.         int stateIconYPosition = 0;
  702.         String text = l.getText();
  703.         Style style = l.getStyle();
  705.         int leftPadding = style.getPadding(l.isRTL(), Component.LEFT);
  706.         int rightPadding = style.getPadding(l.isRTL(), Component.RIGHT);
  707.         
  708.         Font font = style.getFont();
  709.         int fontHeight = 0;
  710.         if (text == null) {
  711.             text = "";
  712.         }
  713.         if(text.length() > 0){
  714.             fontHeight = font.getHeight();
  715.         }
  716.         
  717.         if (stateIcon != null) {
  718.             stateIconSize = stateIcon.getWidth(); //square image width == height
  719.             stateIconYPosition = l.getY() + l.getStyle().getPadding(false, Component.TOP) +
  720.                     (l.getHeight() - l.getStyle().getPadding(false, Component.TOP) -
  721.                     l.getStyle().getPadding(false, Component.BOTTOM)) / 2 - stateIconSize / 2;
  722.             preserveSpaceForState = stateIconSize + gap;
  723.             int tX = l.getX();
  724.             if (l.isRTL()) {
  725.              tX = tX + l.getWidth() - style.getPadding(l.isRTL(), Component.LEFT) - stateIcon.getWidth();
  726.             } else {
  727.              tX += style.getPadding(l.isRTL(), Component.LEFT);
  728.             }
  730.             g.drawImage(stateIcon, tX, stateIconYPosition);
  731.         }
  733.         //default for bottom left alignment
  734.         int x = l.getX() + l.getStyle().getPadding(l.isRTL(), Component.LEFT) + preserveSpaceForState;
  735.         int y = l.getY() + l.getStyle().getPadding(false, Component.TOP);
  737.         int align = reverseAlignForBidi(l, l.getAlignment());
  739.         int textPos= reverseAlignForBidi(l, l.getTextPosition());
  741.         //set initial x,y position according to the alignment and textPosition
  742.         if (align == Component.LEFT) {
  743.             switch (textPos) {
  744.                 case Label.LEFT:
  745.                 case Label.RIGHT:
  746.                     y = y + (l.getHeight() - (l.getStyle().getPadding(false, Component.TOP) + l.getStyle().getPadding(false, Component.BOTTOM) + Math.max(((icon != null) ? icon.getHeight() : 0), fontHeight))) / 2;
  747.                     break;
  748.                 case Label.BOTTOM:
  749.                 case Label.TOP:
  750.                     y = y + (l.getHeight() - (l.getStyle().getPadding(false, Component.TOP) + l.getStyle().getPadding(false, Component.BOTTOM) + ((icon != null) ? icon.getHeight() + gap : 0) + fontHeight)) / 2;
  751.                     break;
  752.             }
  753.         } else if (align == Component.CENTER) {
  754.             switch (textPos) {
  755.                 case Label.LEFT:
  756.                 case Label.RIGHT:
  757.                     x = x + (l.getWidth() - (preserveSpaceForState +
  758.                             leftPadding +
  759.                             rightPadding +
  760.                             ((icon != null) ? icon.getWidth() : 0) +
  761.                             font.stringWidth(text))) / 2;
  762.                     x = Math.max(x, l.getX() + leftPadding + preserveSpaceForState);
  763.                     y = y + (l.getHeight() - (style.getPadding(false, Component.TOP) +
  764.                             style.getPadding(false, Component.BOTTOM) +
  765.                             Math.max(((icon != null) ? icon.getHeight() : 0),
  766.                             fontHeight))) / 2;
  767.                     break;
  768.                 case Label.BOTTOM:
  769.                 case Label.TOP:
  770.                     x = x + (l.getWidth() - (preserveSpaceForState + leftPadding +
  771.                             rightPadding +
  772.                             Math.max(((icon != null) ? icon.getWidth() : 0),
  773.                             font.stringWidth(text)))) / 2;
  774.                     x = Math.max(x, l.getX() + leftPadding + preserveSpaceForState);
  775.                     y = y + (l.getHeight() - (style.getPadding(false, Component.TOP) +
  776.                             style.getPadding(false, Component.BOTTOM) +
  777.                             ((icon != null) ? icon.getHeight() + gap : 0) +
  778.                             fontHeight)) / 2;
  779.                     break;
  780.             }
  781.         } else if (align == Component.RIGHT) {
  782.             switch (textPos) {
  783.                 case Label.LEFT:
  784.                 case Label.RIGHT:
  785.                     x = l.getX() + l.getWidth() - rightPadding -
  786.                             ( ((icon != null) ? (icon.getWidth() + gap) : 0) +
  787.                             font.stringWidth(text));
  788.                     if(l.isRTL()) {
  789.                         x = Math.max(x - preserveSpaceForState, l.getX() + leftPadding);
  790.                     } else {
  791.                         x = Math.max(x, l.getX() + leftPadding + preserveSpaceForState);
  792.                     }
  793.                     y = y + (l.getHeight() - (style.getPadding(false, Component.TOP) +
  794.                             style.getPadding(false, Component.BOTTOM) +
  795.                             Math.max(((icon != null) ? icon.getHeight() : 0),
  796.                             fontHeight))) / 2;
  797.                     break;
  798.                 case Label.BOTTOM:
  799.                 case Label.TOP:
  800.                     x = l.getX() + l.getWidth() - rightPadding -
  801.                              (Math.max(((icon != null) ? (icon.getWidth()) : 0),
  802.                             font.stringWidth(text)));
  803.                     x = Math.max(x, l.getX() + leftPadding + preserveSpaceForState);
  804.                     y = y + (l.getHeight() - (style.getPadding(false, Component.TOP) +
  805.                             style.getPadding(false, Component.BOTTOM) +
  806.                             ((icon != null) ? icon.getHeight() + gap : 0) + fontHeight)) / 2;
  807.                     break;
  808.             }
  809.         }
  812.         int textSpaceW = l.getWidth() - style.getPadding(false, Label.RIGHT) - style.getPadding(false, Label.LEFT);
  814.         if (icon != null && (textPos == Label.RIGHT || textPos == Label.LEFT)) {
  815.             textSpaceW = textSpaceW - icon.getWidth();
  816.         }
  818.         if (stateIcon != null) {
  819.             textSpaceW = textSpaceW - stateIcon.getWidth();
  820.         } else {
  821.             textSpaceW = textSpaceW - preserveSpaceForState;
  822.         }
  824.         if (icon == null) { // no icon only string 
  825.             drawLabelString(g, l, text, x, y, textSpaceW, preserveSpaceForState);
  826.         } else {
  827.             //int strHeight = l.getStyle().getFont().getHeight();
  828.             int strWidth = l.getStyle().getFont().stringWidth(text);
  829.             int iconWidth = icon.getWidth();
  830.             int iconHeight = icon.getHeight();
  831.             int iconStringWGap;
  832.             int iconStringHGap;
  834.             switch (textPos) {
  835.                 case Label.LEFT:
  836.                     if (iconHeight > fontHeight) {
  837.                         iconStringHGap = (iconHeight - fontHeight) / 2;
  838.                         //drawLabelStringValign(g, l, text, x, y, iconStringHGap, iconHeight);
  839.                         strWidth = drawLabelStringValign(g, l, text, x, y, iconStringHGap, iconHeight, textSpaceW, fontHeight, preserveSpaceForState);
  841.                         g.drawImage(icon, x + strWidth + gap, y);
  842.                     } else {
  843.                         iconStringHGap = (fontHeight - iconHeight) / 2;
  844.                         //drawLabelString(g, l, text, x, y);
  845.                         strWidth = drawLabelString(g, l, text, x, y, textSpaceW, preserveSpaceForState);
  847.                         g.drawImage(icon, x + strWidth + gap, y + iconStringHGap);
  848.                     }
  849.                     break;
  850.                 case Label.RIGHT:
  851.                     if (iconHeight > fontHeight) {
  852.                         iconStringHGap = (iconHeight - fontHeight) / 2;
  853.                         g.drawImage(icon, x, y);
  854.                         //drawLabelStringValign(g, l, text, x+ iconWidth + gap, y, iconStringHGap, iconHeight);
  855.                         drawLabelStringValign(g, l, text, x + iconWidth + gap, y, iconStringHGap, iconHeight, textSpaceW, fontHeight, preserveSpaceForState);
  856.                     } else {
  857.                         iconStringHGap = (fontHeight - iconHeight) / 2;
  858.                         g.drawImage(icon, x, y + iconStringHGap);
  859.                         //drawLabelString(g, l, text, x + iconWidth + gap, y);
  860.                         drawLabelString(g, l, text, x + iconWidth + gap, y, textSpaceW, preserveSpaceForState);
  861.                     }
  862.                     break;
  863.                 case Label.BOTTOM:
  864.                     if (iconWidth > strWidth) { //center align the smaller
  866.                         iconStringWGap = (iconWidth - strWidth) / 2;
  867.                         g.drawImage(icon, x, y);
  868.                         //drawLabelString(g, l, text, x + iconStringWGap, y + iconHeight + gap);
  869.                         drawLabelString(g, l, text, x + iconStringWGap, y + iconHeight + gap, textSpaceW, preserveSpaceForState);
  870.                     } else {
  871.                         iconStringWGap = (Math.min(strWidth, textSpaceW) - iconWidth) / 2;
  872.                         g.drawImage(icon, x + iconStringWGap, y);
  873.                         
  874.                         //drawLabelString(g, l, text, x, y + iconHeight + gap);
  875.                         drawLabelString(g, l, text, x, y + iconHeight + gap, textSpaceW, preserveSpaceForState);
  876.                     }
  877.                     break;
  878.                 case Label.TOP:
  879.                     if (iconWidth > strWidth) { //center align the smaller
  881.                         iconStringWGap = (iconWidth - strWidth) / 2;
  882. //                        drawLabelString(g, l, text, x + iconStringWGap, y);
  883.                         drawLabelString(g, l, text, x + iconStringWGap, y, textSpaceW, preserveSpaceForState);
  884.                         g.drawImage(icon, x, y + fontHeight + gap);
  885.                     } else {
  886.                         iconStringWGap = (Math.min(strWidth, textSpaceW) - iconWidth) / 2;
  887. //                        drawLabelString(g, l, text, x, y);
  888.                         drawLabelString(g, l, text, x, y, textSpaceW, preserveSpaceForState);
  889.                         g.drawImage(icon, x + iconStringWGap, y + fontHeight + gap);
  890.                     }
  891.                     break;
  892.             }
  893.         }
  894.     }
  896.     /**
  897.      * Implements the drawString for the text component and adjust the valign
  898.      * assuming the icon is in one of the sides
  899.      */
  900.     private int drawLabelStringValign(Graphics g, Label l, String str, int x, int y,
  901.             int iconStringHGap, int iconHeight, int textSpaceW, int fontHeight, int preserveSpaceForState) {
  902.         switch (l.getVerticalAlignment()) {
  903.             case Component.TOP:
  904.                 return drawLabelString(g, l, str, x, y, textSpaceW, preserveSpaceForState);
  905.             case Component.CENTER:
  906.                 return drawLabelString(g, l, str, x, y + iconHeight / 2 - fontHeight / 2, textSpaceW, preserveSpaceForState);
  907.             default:
  908.                 return drawLabelString(g, l, str, x, y + iconStringHGap, textSpaceW, preserveSpaceForState);
  909.         }
  910.     }
  912.     /**
  913.      * Implements the drawString for the text component and adjust the valign
  914.      * assuming the icon is in one of the sides
  915.      */
  916.     private int drawLabelString(Graphics g, Label l, String text, int x, int y, int textSpaceW, int preserveSpaceForState) {
  917.         Style style = l.getStyle();
  919.         int cx = g.getClipX();
  920.         int cy = g.getClipY();
  921.         int cw = g.getClipWidth();
  922.         int ch = g.getClipHeight();
  924.         g.clipRect(x, cy, textSpaceW, ch);
  926.         if (l.isTickerRunning()) {
  927.             if (l.getShiftText() > 0) {
  928.                 if (l.getShiftText() > textSpaceW) {
  929.                     l.setShiftText(x - l.getX() - style.getFont().stringWidth(text));
  930.                 }
  931.             } else if (l.getShiftText() + style.getFont().stringWidth(text) < 0) {
  932.                 l.setShiftText(textSpaceW);
  933.             }
  934.         }
  935.         int drawnW = drawLabelText(g, l, text, x, y, textSpaceW);
  937.         g.setClip(cx, cy, cw, ch);
  939.         return drawnW;
  940.     }
  942.     /**
  943.      * Draws the text of a label
  944.      * 
  945.      * @param g graphics context
  946.      * @param l label component
  947.      * @param text the text for the label
  948.      * @param x position for the label
  949.      * @param y position for the label
  950.      * @param textSpaceW the width available for the component
  951.      * @return the space used by the drawing
  952.      */
  953.     protected int drawLabelText(Graphics g, Label l, String text, int x, int y, int textSpaceW) {
  954.         Font f = l.getStyle().getFont();
  955.         if ((!l.isTickerRunning()) || l.isRTL()) {
  956.             int txtW = f.stringWidth(text);
  957.             
  958.             //if there is no space to draw the text add ... at the end
  959.             if (txtW > textSpaceW && textSpaceW > 0) {
  960.              // Handling of adding 3 points and in fact all text positioning when the text is bigger than
  961.              // the allowed space is handled differently in RTL, this is due to the reverse algorithm
  962.              // effects - i.e. when the text includes both Hebrew/Arabic and English/numbers then simply
  963.              // trimming characters from the end of the text (as done with LTR) won't do.
  964.              // Instead we simple reposition the text, and draw the 3 points, this is quite simple, but
  965.              // the downside is that a part of a letter may be shown here as well.
  967.              if (l.isRTL()) {
  968.                  if ((!l.isTickerRunning()) && (l.isEndsWith3Points())) {
  969.              String points = "...";
  970.                  int pointsW = f.stringWidth(points);
  971.              g.drawString(points, l.getShiftText() + x, y);
  972.              g.clipRect(pointsW+l.getShiftText() + x, y, textSpaceW - pointsW, f.getHeight());
  973.                  }
  974.              x = x - txtW + textSpaceW;
  975.                 } else {
  976.                     if (l.isEndsWith3Points()) {
  977.                         String points = "...";
  978.                         int index = 1;
  979.                         String tmp = text.substring(0, index);
  980.                         int pointsW = f.stringWidth(points);
  981.                         while (f.stringWidth(tmp) + pointsW < textSpaceW) {
  982.                             index++;
  983.                             if (index >= text.length()) {
  984.                                 break;
  985.                             }
  986.                             tmp = text.substring(0, index);
  987.                         }
  988.                         tmp = text.substring(0, index - 1) + points;
  989.                         text = tmp;
  990.                     }
  991.                 }
  992.             }
  993.         }
  995.         g.drawString(text, l.getShiftText() + x, y);
  996.         return Math.min(f.stringWidth(text), textSpaceW);
  997.     }
  999.     /**
  1000.      * @inheritDoc
  1001.      */
  1002.     public Dimension getComboBoxPreferredSize(List cb) {
  1003.         return getListPreferredSize(cb);
  1004.     }
  1006.     /**
  1007.      * @inheritDoc
  1008.      */
  1009.     public void drawTabbedPane(Graphics g, TabbedPane tp) {
  1010.     }
  1012.     /**
  1013.      * @inheritDoc
  1014.      */
  1015.     public Component getTabbedPaneCell(final TabbedPane tp,
  1016.             final String text, final Image icon, final boolean isSelected,
  1017.             final boolean cellHasFocus, final Style cellStyle, final Style cellSelectedStyle,
  1018.             final Style tabbedPaneStyle, final int cellOffsetX,
  1019.             final int cellOffsetY, final Dimension cellsPreferredSize,
  1020.             final Dimension contentPaneSize) {
  1021.         Label cell = new Label(text) {
  1022.             public void paint(Graphics g) {
  1023.                 int tPBorder = tp.getTabbedPaneBorderWidth();
  1024.                 int focusMarkWidth = tPBorder * 2;
  1025.                 int tabP = tp.getTabPlacement();
  1026.                 // Initialize forground colors before calling to super.paint()
  1027.                 if (isSelected && cellHasFocus) {
  1028.                     focusMarkWidth = tPBorder * 3;
  1029.                     this.getStyle().setFgColor(cellSelectedStyle.getFgColor());
  1030.                 } else {
  1031.                     this.getStyle().setFgColor(cellStyle.getFgColor());
  1032.                 }
  1034.                 super.paint(g);
  1036.                 if (!isSelected) {
  1037.                     g.setColor(0);
  1038.                     g.fillRect(getX(), getY(), getWidth(), getHeight(), (byte) 0x2f);
  1039.                 }
  1040.                 // coloring back the focus mark line
  1041.                 g.setColor(getStyle().getFgColor());
  1042.                 if (tabP == TabbedPane.TOP || tabP == TabbedPane.BOTTOM) {
  1043.                     if (tabP == TabbedPane.TOP) {
  1044.                         if (isSelected) {
  1045.                             g.fillRect(getX(), getY() + tPBorder, getWidth(), focusMarkWidth);// north
  1047.                         }
  1048.                         g.setColor(tabbedPaneStyle.getFgColor());
  1049.                         g.fillRect(getX(), getY(), getWidth(), tPBorder);//north line
  1051.                         g.fillRect(getX(), getY(), tPBorder, getHeight());// west line
  1053.                     } else {
  1054.                         if (isSelected) {
  1055.                             g.fillRect(getX(), getY() + getHeight() - focusMarkWidth, getWidth(), focusMarkWidth);// south
  1057.                         }
  1058.                         g.setColor(tabbedPaneStyle.getFgColor());
  1059.                         g.fillRect(getX(), getY() + getHeight() - tPBorder, getWidth(), tPBorder);//south line
  1061.                         g.fillRect(getX(), getY(), tPBorder, getHeight());// west line
  1063.                     }
  1064.                     int x = getX() - cellOffsetX + getWidth();
  1065.                     if (x == contentPaneSize.getWidth()) {
  1066.                         g.fillRect(x + cellOffsetX - tPBorder, getY(), tPBorder, getHeight());// east line
  1068.                     }
  1069.                     if (cellsPreferredSize.getWidth() < contentPaneSize.getWidth() && (getX() + getWidth() == cellsPreferredSize.getWidth())) {
  1070.                         g.fillRect(getX() + getWidth() - tPBorder, getY(), tPBorder, getHeight());
  1071.                     }
  1072.                 } else { // LEFT or RIGHT
  1074.                     if (isSelected) {
  1075.                         g.fillRect(getX(), getY() + tPBorder, getWidth(), focusMarkWidth);// north
  1077.                     }
  1078.                     g.setColor(tabbedPaneStyle.getFgColor());
  1079.                     g.fillRect(getX(), getY(), getWidth(), tPBorder);
  1080.                     int y = getY() - cellOffsetY + getHeight();
  1081.                     if (y == contentPaneSize.getHeight()) {
  1082.                         g.fillRect(getX(), y + cellOffsetY - tPBorder, getWidth(), tPBorder);
  1083.                     }
  1084.                     if (cellsPreferredSize.getHeight() < contentPaneSize.getHeight() && (getY() + getHeight() == cellsPreferredSize.getHeight())) {
  1085.                         g.fillRect(getX(), getY() + getHeight() - tPBorder, getWidth(), tPBorder);//south line
  1087.                     }
  1088.                     if (!tp.isRTL() && tabP == TabbedPane.LEFT || 
  1089.                             tp.isRTL() && tabP == TabbedPane.RIGHT) {
  1090.                         g.fillRect(getX(), getY(), tPBorder, getHeight());// west border
  1091.                     } else {
  1092.                         g.fillRect(getX() + getWidth() - tPBorder, getY(), tPBorder, getHeight());// east border
  1093.                     }
  1094.                 }
  1095.             }
  1096.         };
  1097.         cell.setUIID("Tab");
  1098.         cell.setCellRenderer(true);
  1099.         cell.getStyle().setBorder(null);
  1100.         cell.getStyle().setMargin(0, 0, 0, 0);
  1101.         cell.setIcon(icon);
  1102.         updateCellLook(tp, (Component) cell, isSelected);
  1103.         if (isSelected) {
  1104.             cellStyle.setBgColor(cellStyle.getBgColor());
  1105.         }
  1107.         cell.setAlignment(Label.CENTER);
  1108.         return cell;
  1109.     }
  1111.     private void updateCellLook(TabbedPane tp, Component c, boolean selected) {
  1112.         c.getStyle().setFgColor(tp.getStyle().getFgColor());
  1113.         c.getStyle().setBgTransparency(tp.getStyle().getBgTransparency());
  1114.         c.getStyle().setFont(tp.getStyle().getFont());
  1115.     }
  1117.     /**
  1118.      * @inheritDoc
  1119.      */
  1120.     public void drawTabbedPaneContentPane(final TabbedPane tp,
  1121.             final Graphics g, final Rectangle rect,
  1122.             final Dimension cellsPreferredSize, final int numOfTabs,
  1123.             final int selectedTabIndex, final Dimension tabsSize,
  1124.             final int cellOffsetX, final int cellOffsetY) {
  1125.         int tPBorder = tp.getTabbedPaneBorderWidth();
  1126.         if(tPBorder < 1) {
  1127.             return;
  1128.         }
  1129.         int x = rect.getX();
  1130.         int y = rect.getY();
  1131.         int w = rect.getSize().getWidth();
  1132.         int h = rect.getSize().getHeight();
  1133.         int listPreferredW = cellsPreferredSize.getWidth();
  1134.         int listPreferredH = cellsPreferredSize.getHeight();
  1135.         int maxTabWidth = tabsSize.getWidth();
  1136.         int maxTabHeight = tabsSize.getHeight();
  1138.         g.setColor(tp.getStyle().getBgColor());
  1139.         g.fillRect(x, y, w, h, tp.getStyle().getBgTransparency());
  1141.         // paint borders for TOP tab placement
  1142.         g.setColor(tp.getStyle().getFgColor());
  1143.         int tabP = tp.getTabPlacement();
  1145.         if (tabP == TabbedPane.TOP || tabP == TabbedPane.BOTTOM) {
  1146.             g.fillRect(x, y, tPBorder, h);// west border
  1148.             g.fillRect(x + w - tPBorder, y, tPBorder, h);// east border
  1150.             int relativeY = y;
  1151.             if (tabP == TabbedPane.BOTTOM) {
  1152.                 relativeY = y + h - tPBorder;
  1153.                 g.fillRect(x, y, w, tPBorder);// north border
  1155.             } else {
  1156.                 g.fillRect(x, y + h - tPBorder, w, tPBorder);// south border
  1158.             }
  1159.             
  1160.             if(tp.isRTL()){
  1161.                 if (listPreferredW < w) {
  1162.                     g.fillRect(x, relativeY, w - listPreferredW, tPBorder);
  1163.                 }
  1164.                 for (int i = 0; i < numOfTabs; i++) {
  1165.                     if (i != selectedTabIndex) {
  1166.                         g.fillRect((x - cellOffsetX + w - (maxTabWidth * (i+1))), relativeY, maxTabWidth + tPBorder, tPBorder);
  1167.                     }
  1168.                 }
  1170.             } else {
  1171.                 if (listPreferredW < w) {
  1172.                     g.fillRect(listPreferredW - tPBorder, relativeY, w - listPreferredW, tPBorder);
  1173.                 }
  1174.                 for (int i = 0; i < numOfTabs; i++) {
  1175.                     if (i != selectedTabIndex) {
  1176.                         g.fillRect((x - cellOffsetX + (maxTabWidth * i)), relativeY, maxTabWidth + tPBorder, tPBorder);
  1177.                     }
  1178.                 }
  1179.             }
  1180.         } else {//if (tabP == LEFT || tabP == RIGHT) {
  1182.             g.fillRect(x, y, w, tPBorder);// north border
  1184.             g.fillRect(x, y + h - tPBorder, w, tPBorder);// south border
  1186.             int relativeX = x;
  1187.             if (!tp.isRTL() && tabP == TabbedPane.RIGHT ||
  1188.                     tp.isRTL() && tabP == TabbedPane.LEFT) {
  1189.                 g.fillRect(x, y, tPBorder, h);// west border
  1191.                 relativeX = x + w - tPBorder;
  1192.             } else {
  1193.                 g.fillRect(x + w - tPBorder, y, tPBorder, h);// east border
  1195.             }
  1197.             if (listPreferredH < h) {
  1198.                 g.fillRect(relativeX, y + listPreferredH - tPBorder, tPBorder, h - listPreferredH + tPBorder);
  1199.             }
  1200.             for (int i = 0; i < numOfTabs; i++) {
  1201.                 if (i != selectedTabIndex) {
  1202.                     g.fillRect(relativeX, (y - cellOffsetY + (maxTabHeight * i)), tPBorder, maxTabHeight + tPBorder);
  1203.                 }
  1204.             }
  1206.         }
  1207.     }
  1209.     /**
  1210.      * Similar to getText() but works properly with password fields
  1211.      */
  1212.     protected String getTextFieldString(TextArea ta) {
  1213.         String text = (String) ta.getText();
  1214.         String displayText = "";
  1215.         if ((ta.getConstraint() & TextArea.PASSWORD) != 0) {
  1216.             // show the last character in a password field
  1217.             if (ta.isPendingCommit()) {
  1218.                 if (text.length() > 0) {
  1219.                     for (int j = 0; j < text.length() - 1; j++) {
  1220.                         displayText += "*";
  1221.                     }
  1222.                     displayText += text.charAt(text.length() - 1);
  1223.                 }
  1224.             } else {
  1225.                 for (int j = 0; j < text.length(); j++) {
  1226.                     displayText += "*";
  1227.                 }
  1228.             }
  1229.         } else {
  1230.             displayText = text;
  1231.         }
  1232.         return displayText;
  1233.     }
  1234.     
  1235.     /**
  1236.      * @inheritDoc
  1237.      */
  1238.     public void drawTextField(Graphics g, TextArea ta) {
  1239.         setFG(g, ta);
  1241.         // display ******** if it is a password field
  1242.         String displayText = getTextFieldString(ta);
  1244.         Style style = ta.getStyle();
  1245.         int x = 0;
  1246.         int cursorCharPosition = ta.getCursorPosition();        
  1247.         Font f = ta.getStyle().getFont();
  1248.         int cursorX = 0;
  1249.         int xPos = 0;
  1250.         
  1251.         int align = ta.getAbsoluteAlignment();
  1252.         int displayX = 0;
  1254.         String inputMode = ta.getInputMode();
  1255.         int inputModeWidth = f.stringWidth(inputMode);
  1257.         // QWERTY devices don't quite have an input mode hide it also when we have a VK
  1258.         if(ta.isQwertyInput() || Display.getInstance().isVirtualKeyboardShowing()) {
  1259.             inputMode = "";
  1260.             inputModeWidth = 0;
  1261.         }
  1263.         // there is currently no support for CENTER aligned text fields
  1264.         if (align == Component.LEFT) {
  1265.             if (cursorCharPosition > 0) {
  1266.                 xPos = f.stringWidth(displayText.substring(0, cursorCharPosition));
  1267.                 cursorX = ta.getX() + style.getPadding(ta.isRTL(), Component.LEFT) + xPos;
  1269.                 // no point in showing the input mode when there is only one input mode...
  1270.                 if(inputModeWidth > 0 && ta.getInputModeOrder() != null && ta.getInputModeOrder().length == 1) {
  1271.                     inputModeWidth = 0;
  1272.                 }
  1273.                 if(ta.isEnableInputScroll()) {
  1274.                     if (ta.getWidth() > (f.getHeight() * 2) && cursorX >= ta.getWidth()-inputModeWidth - style.getPadding(ta.isRTL(), Component.LEFT)) {
  1275.                         while (x + xPos >= ta.getWidth() - inputModeWidth - style.getPadding(ta.isRTL(), Component.LEFT) * 2) {
  1276.                             x--;
  1277.                         }
  1278.                     }
  1279.                 }
  1280.             }
  1281.             displayX = ta.getX() + x + style.getPadding(ta.isRTL(), Component.LEFT);
  1282.         } else {
  1283.      x = 0;
  1284.      cursorX = getTextFieldCursorX(ta);
  1285.      int baseX = ta.getX() + style.getPadding(false, Component.LEFT) + inputModeWidth;
  1286.      int endX = ta.getX() + ta.getWidth() - style.getPadding(false, Component.RIGHT);
  1288.      if(cursorX<baseX) {
  1289.      x = baseX - cursorX;
  1290.      } else {
  1291.                 if (cursorX > endX) {
  1292.          x = endX - cursorX;
  1293.          }
  1294.             }
  1296.      displayX = ta.getX() + ta.getWidth() - style.getPadding(false, Component.RIGHT) - f.stringWidth(displayText)+x;
  1297.         }
  1299.         g.drawString(displayText, displayX, ta.getY() + style.getPadding(false, Component.TOP));
  1301.         // no point in showing the input mode when there is only one input mode...
  1302.         if(inputModeWidth > 0 && ta.getInputModeOrder() != null && ta.getInputModeOrder().length > 1) {
  1303.             
  1304.             if (ta.handlesInput() && ta.getWidth() / 2 > inputModeWidth) {
  1305.             
  1306.                 int drawXPos = ta.getX() + style.getPadding(ta.isRTL(), Component.LEFT);
  1307.                 if((!ta.isRTL() && ta.getAlignment() == Component.LEFT) ||
  1308.                     (ta.isRTL() && ta.getAlignment() == Component.RIGHT)) {
  1309.                     drawXPos = drawXPos + ta.getWidth() - inputModeWidth - style.getPadding(false, Component.RIGHT) - style.getPadding(false, Component.LEFT);
  1310.                 } 
  1311.                 g.setColor(style.getFgColor());
  1312.                 g.fillRect(drawXPos, ta.getY() + style.getPadding(false, Component.TOP), inputModeWidth,
  1313.                         ta.getHeight(), (byte) 140);
  1314.                 g.setColor(style.getBgColor());
  1315.                 g.drawString(inputMode, drawXPos, ta.getY() + style.getPadding(false, Component.TOP));
  1316.             }
  1317.         }
  1318.     }
  1320.     /**
  1321.      * Returns true if the given character is an RTL character or a space
  1322.      * character
  1323.      *
  1324.      * @param c character to test
  1325.      * @return true if bidi is active and this is a
  1326.      */
  1327. private boolean isRTLOrWhitespace(char c) {
  1328.         return (Display.getInstance().isRTL(c)) || c == ' ';
  1329.     }
  1331.     /**
  1332.      * Calculates the position of the text field cursor within the string
  1333.      */
  1334.     private int getTextFieldCursorX(TextArea ta) {
  1335.         Style style = ta.getStyle();
  1336.         Font f = style.getFont();
  1338.         // display ******** if it is a password field
  1339.         String displayText = getTextFieldString(ta);
  1340.         String inputMode = ta.getInputMode();
  1341.         int inputModeWidth = f.stringWidth(inputMode);
  1342.         // QWERTY devices don't quite have an input mode hide it also when we have a VK
  1343.         if(ta.isQwertyInput() || Display.getInstance().isVirtualKeyboardShowing()) {
  1344.             inputMode = "";
  1345.             inputModeWidth = 0;
  1346.         }
  1348.         int xPos = 0;
  1349.         int cursorCharPosition = ta.getCursorPosition();
  1350.         int cursorX=0;
  1351.         int x = 0;
  1353.         if (ta.getAbsoluteAlignment() == Component.RIGHT) {
  1354.          if (Display.getInstance().isBidiAlgorithm()) {
  1355.                 //char[] dest = displayText.toCharArray();
  1356.                 cursorCharPosition = Display.getInstance().getCharLocation(displayText, cursorCharPosition-1);
  1358.                 if (cursorCharPosition==-1) {
  1359.                     xPos = f.stringWidth(displayText);
  1360.                 } else {
  1361.                     displayText = Display.getInstance().convertBidiLogicalToVisual(displayText);
  1362.                     if (!isRTLOrWhitespace((displayText.charAt(cursorCharPosition)))) {
  1363.                         cursorCharPosition++;
  1364.                     }
  1365.                     xPos = f.stringWidth(displayText.substring(0, cursorCharPosition));
  1366.                 } 
  1367.          }
  1368.          int displayX = ta.getX() + ta.getWidth() - style.getPadding(ta.isRTL(), Component.LEFT) - f.stringWidth(displayText);
  1369.          cursorX = displayX + xPos;
  1370.          x=0;
  1371.         } else {
  1372.             if (cursorCharPosition > 0) {
  1373.                 xPos = f.stringWidth(displayText.substring(0, cursorCharPosition));
  1374.             }
  1375.             cursorX = ta.getX() + style.getPadding(ta.isRTL(), Component.LEFT) + xPos;
  1377.             if (ta.getWidth() > (f.getHeight() * 2) && cursorX >= ta.getWidth() - inputModeWidth  -style.getPadding(ta.isRTL(), Component.LEFT)) {
  1378.                 while (x + xPos >= ta.getWidth() - inputModeWidth - style.getPadding(false, Component.LEFT) - style.getPadding(false, Component.RIGHT)) {
  1379.                     x--;
  1380.                 }
  1381.             }
  1382.         }
  1384.         return cursorX+x;
  1386.     }
  1388.     /**
  1389.      * @inheritDoc
  1390.      */
  1391.     public Dimension getTextFieldPreferredSize(TextArea ta) {
  1392.         return getTextAreaSize(ta, true);
  1393.     }
  1395.     /**
  1396.      * @inheritDoc
  1397.      */
  1398.      public void drawTextFieldCursor(Graphics g, TextArea ta) {
  1399.          Style style = ta.getStyle();
  1400.          Font f = style.getFont();
  1403.      int cursorY = ta.getY() + style.getPadding(false, Component.TOP);
  1404.      int cursorX = getTextFieldCursorX(ta);
  1406.         int align=ta.getAbsoluteAlignment();
  1407. int x=0;
  1408.         if (align==Component.RIGHT) {
  1409.             String inputMode = ta.getInputMode();
  1410.             int inputModeWidth = f.stringWidth(inputMode);
  1412.      int baseX=ta.getX()+style.getPadding(false, Component.LEFT)+inputModeWidth;
  1413.      if (cursorX<baseX) {
  1414.      x=baseX-cursorX;
  1415.      }
  1416.         }
  1418.         int oldColor = g.getColor();
  1419.         g.setColor(style.getFgColor());
  1420.         g.drawLine(cursorX + x, cursorY, cursorX + x, cursorY + f.getHeight());
  1421.         g.setColor(oldColor);
  1422.     }
  1424.     /**
  1425.      * @inheritDoc
  1426.      */
  1427.     public void focusGained(Component cmp) {
  1428.         if(cmp instanceof Label) {
  1429.             Label l = (Label) cmp;
  1430.             if (l.shouldTickerStart()) {
  1431.                 ((Label) cmp).startTicker(getTickerSpeed(), true);
  1432.             }
  1433.         }
  1434.     }
  1436.     /**
  1437.      * @inheritDoc
  1438.      */
  1439.     public void focusLost(Component cmp) {
  1440.         if(cmp instanceof Label) {
  1441.             Label l = (Label) cmp;
  1442.             if (l.isTickerRunning()) {
  1443.                 l.stopTicker();
  1444.             }
  1445.         }
  1446.     }
  1447. }