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

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

J2ME

开发平台：

Java

EditControl.java：源码内容
  1. /*
  2.  * EditControl.java
  3.  *
  4.  * Created on April 23, 2010, 10:20 AM
  5.  *
  6.  * To change this template, choose Tools | Template Manager
  7.  * and open the template in the editor.
  8.  */
  10. package com.framework;
  12. import java.util.Vector;
  13. import javax.microedition.lcdui.Canvas;
  14. import javax.microedition.lcdui.Graphics;
  16. /**
  17.  *
  18.  * @author Tejaswi
  19.  */
  20. public class EditControl  extends UIControl implements TimerInterface {
  21.      long timeHolder;
  22.     final int DELAY = 350;
  23.     final int CHAR_INSERT_DELAY = 1300;
  24.     boolean showCursor = false;
  25.     GTantra font;
  26.     Vector textVector = new Vector();
  27.     int totalHeight = 0;;
  28.     int cursorXPosition = 0;
  29.     int cursorYPosition = 0;
  30.     int cursorLocation = 0;
  31.     int fontHeight;
  32.     int currentSelectedRow;
  33.     int leftPadding = 3;
  34.     private StringBuffer actulText = new StringBuffer("");
  35.     int scrollHeight = 0;
  36.     BaseTimer timeTask,insertCharTask;
  37.     int horScrolled = 0;
  38.     boolean isMultiline = true;
  39.     //--------color related variables---------------
  40.     
  41.      int cursorColor =0;
  42.      private int scrollBarBgColor = 0xffffff;
  43.      private int scrollBarArrowColol = 0;
  44.     
  45.      //-------- variables might need to re config. ----------
  46.     
  47.     private static final int ERROR_WARP = 4;
  48.     private static final int SCROLL_BAR_WIDTH = 13;
  49.     private boolean m_editable = true;
  50.     public static final int SMART_KEY_PAD = 0;
  51.     public static final int QWERTY_KEY_PAD = 1;
  52.     static int keyPadType =SMART_KEY_PAD;
  53.     public static final int NUMERIC = 0;
  54.     public static final int ALPHA_NUMERIC = 1;
  55.     int editType = ALPHA_NUMERIC;
  56.     int oldKeyCode = -1;
  57.     private static final char[][] charArry = {
  58.         {' ', '0'},
  59.         {'.', ',', ''', '?', '!', '"', '_', '-', '(', ')', '@', '/', ':', '1'},
  60.         {'a', 'b', 'c', '2'},
  61.         {'d', 'e', 'f', '3'},
  62.         {'g', 'h', 'i', '4'},
  63.         {'j', 'k', 'l', '5'},
  64.         {'m', 'n', 'o', '6'},
  65.         {'p', 'q', 'r', 's', '7'},
  66.         {'t', 'u', 'v', '8'},
  67.         {'w', 'x', 'y', 'z', '9'}
  68.     };
  69.     int count = 0;
  70.     char currentChar;
  71.     int max_limit = 0;
  72.     /** Creates a new instance of EditControl */
  73.     public EditControl(GTantra font,int width,int height,int max_limit,boolean isMultiline) {
  74.          this.max_limit = max_limit;
  75.         this.isMultiline = isMultiline;
  76.         this.font = font;
  77.        
  78.         //this.width = width;
  79.         //this.height = height;
  80.         fontHeight = font.getFontHeight();
  81.         textVector.addElement("");
  82.         setWidth(width);
  83.         if(height != -1)
  84.         {
  85.             setHeight(height);
  86.         }else
  87.             resize();
  88.         
  89.         setCursorPosition();
  90.     }
  91.      public void setSelected(boolean selected) {
  92.         super.setSelected(selected);
  93.         if(!selected)
  94.         {
  95.              if(timeTask != null)
  96.              {
  97.                  timeTask.cancel();
  98.                  timeTask = null;
  99.              }
  100.              showCursor = false;
  101.         }else
  102.         {
  103.             if(m_editable)
  104. {
  105.                 if(timeTask != null)
  106.                  {
  107.                      timeTask.cancel();
  108.                      timeTask = null;
  109.                  }
  110.         timeTask = BaseTimer.schedule(DELAY, DELAY, this,0);
  111. }
  112.         }
  113.     }
  114.      
  115.    
  117.     public void setEditable(boolean editable)
  118.     {
  119.             m_editable = editable;
  120.     }
  122.     
  123.     
  124.     public void setHeight(int height) {
  125.      super.setHeight(height);
  126.       reParseText();
  127.     }
  129.     public void setWidth(int width) {
  130.      super.setWidth(width);
  131.          reParseText();
  132.     }
  133.    
  134.    public String getText()
  135.    {
  136.        return actulText.toString();
  137.    }
  138.    public void setText(String str)
  139.    {
  140.    try
  141.    {
  142.    if(isMultiline)
  143.    {
  144.        textVector.removeAllElements();
  145.        actulText.delete(0, actulText.length());
  146.        actulText.append(str);
  147.        cursorLocation = str.length();
  148.        reParseText();
  149.    }else
  150.    {
  151.    actulText.delete(0, actulText.length());
  152.        actulText.append(str);
  153.        cursorLocation = str.length();
  154.        setScrollHeight();
  155.        setCursorPosition();
  156.    }
  157.    }
  158.    catch (Exception e) {
  159. e.printStackTrace();
  160. }
  161.    }
  162.    //-------------------------------------------------------
  163.     private void drawCursor(Graphics g) {
  164.         if (showCursor && m_editable && insertCharTask == null) {
  165.             g.setColor(cursorColor);
  166.             g.drawLine(cursorXPosition, cursorYPosition - (fontHeight >> 1), cursorXPosition, cursorYPosition + (fontHeight >> 1));
  167.         }
  169.     }
  170.     private void drawScrollBar(Graphics g)
  171.     {
  172.         if(totalHeight > height)
  173.         {
  174.             g.setColor(scrollBarBgColor);
  175. //            g.fillRect(width - SCROLL_BAR_WIDTH, 0, SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH);
  176. //            g.fillRect(width - SCROLL_BAR_WIDTH, height - SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH, SCROLL_BAR_WIDTH);
  177. //            g.drawRect(width - SCROLL_BAR_WIDTH, 0, SCROLL_BAR_WIDTH, height);
  178.             g.fillRect(width - SCROLL_BAR_WIDTH, 0, SCROLL_BAR_WIDTH, height);
  179.             int arrowPadding = 2;
  180.             g.setColor(scrollBarArrowColol);
  181.             int scrollBarArrowWidth =SCROLL_BAR_WIDTH -(arrowPadding << 1); 
  182.             if(scrollHeight > 0 )
  183.              drawFilledTriangle(g, width - scrollBarArrowWidth - arrowPadding , (scrollBarArrowWidth >> 1) + arrowPadding , true,scrollBarArrowWidth );
  184.             if(scrollHeight + height < totalHeight)
  185.              drawFilledTriangle(g, width - scrollBarArrowWidth - arrowPadding ,height- (scrollBarArrowWidth >> 1) - arrowPadding , false,scrollBarArrowWidth );
  186.             
  187.         }
  188.         
  189.     }
  190.     public static void drawFilledTriangle(Graphics g, int startPtX, int startPtY, boolean arrowDirection, int arrowWidth) {
  191.         int wdth = arrowWidth;
  192.         /**vertical arrow is to be drawn*/
  193.        int i = 0;
  194.        boolean var = true;
  196.             while (var == true) {
  197.                 /**up arrow is to be drawn*/
  198.                 if (arrowDirection == true) {
  199.                     g.drawLine(startPtX + i, startPtY - i, startPtX + wdth - i, startPtY - i);
  200.                 /**down arrow is to be drawn*/
  201.                 } else {
  202.                     g.drawLine(startPtX + i, startPtY + i, startPtX + wdth - i, startPtY + i);
  203.                 }
  204.                 if (wdth - i == arrowWidth >> 1) {
  205.                     var = false;
  206.                 }
  207.                 i++;
  208.             }
  209.         }
  210.     int clipX, clipY,clipWidth,clipHeight;
  211.     private void setClip(Graphics g,int _x, int _y,int _width,int _height)
  212.     {
  213.         clipX = g.getClipX();
  214.         clipY = g.getClipY();
  215.         clipWidth = g.getClipWidth();
  216.         clipHeight = g.getClipHeight(); 
  217.         g.setClip(_x, _y, _width, _height);
  218.     }
  219.     private void resumeSetClip(Graphics g)
  220.     {
  221.         g.setClip(clipX, clipY, clipWidth, clipHeight);
  222.     }
  223.      private void resize()
  224.     {
  225.         setHeight(fontHeight + 4);
  226.     }
  227.      public static void setKeyPadType(int keyType) {
  228.         keyPadType = keyType;
  229.     }
  230.     public void setCursorColor(int cursorColor) {
  231.         this.cursorColor = cursorColor;
  232.     }
  233.     public void paint(Graphics g) {
  234.         if(textVector.size() == 0 && textVector.elementAt(0).toString().length() == 0 && isMultiline)
  235.      {
  236.             reParseText();
  237.      }
  238.         if(insertCharTask != null)
  239.         {
  240.             g.setColor(0x00FF00);
  241.             int _y = (height - fontHeight) >> 1;
  242.             if(isMultiline)
  243.             {
  244.                 _y = currentSelectedRow * fontHeight;
  245.             }
  246.             g.fillRect(cursorXPosition, _y, font.getCharWidth(currentChar) + 1 , font.getCharHeight(currentChar) + 1);
  247.         }
  248.         if(isMultiline)
  249.         {
  250.             g.translate(0, -scrollHeight);
  251.             for (int i = 0; i < textVector.size(); i++) {
  252.                 String string = textVector.elementAt(i).toString();
  253.                 if(i == currentSelectedRow && insertCharTask != null && getCursorLocationInRow() <= string.length())
  254.                 {
  255.                     StringBuffer buffer = new StringBuffer(string );
  256.                     
  257.                     buffer.insert(getCursorLocationInRow(), currentChar);
  258.                     font.drawString(g, buffer.toString(), leftPadding,  i * fontHeight, GTantra.TEXT_LEFT);
  259.                 }else
  260.                     font.drawString(g, string, leftPadding,  i * fontHeight, GTantra.TEXT_LEFT);
  261.             }
  262.             drawCursor(g);
  263.             g.translate(0, scrollHeight); 
  264.         }else{
  266.              g.translate(-horScrolled,0);
  267.              StringBuffer buffer = new StringBuffer(actulText.toString());
  268.              if(insertCharTask != null)
  269.              {
  270.                  buffer.insert(cursorLocation, currentChar);
  271.              }
  272.              font.drawString(g, buffer.toString(), leftPadding, (height - fontHeight) >> 1, GTantra.TEXT_LEFT);
  273.              drawCursor(g);
  274.              g.translate(horScrolled,0);
  275.         }
  276. //        if(insertCharTask != null)
  277. //        {
  278. //            g.setColor(0x00FF00);
  279. //            int _y = (height - fontHeight) >> 1;
  280. //            if(isMultiline)
  281. //            {
  282. //                _y = currentSelectedRow * fontHeight;
  283. //            }
  284. //            g.fillRect(cursorXPosition, _y, font.getCharWidth(currentChar) +1, font.getCharHeight(currentChar)+1);
  285. //            font.drawString(g, currentChar+"", cursorXPosition, _y , GTantra.TEXT_LEFT);
  286. //        }
  287.       //  resumeSetClip(g);
  288.         drawScrollBar(g);
  289.     }
  291.   public String[] divideString(String text, GTantra font, int width)
  292.   {
  293.       if(width <= 0)
  294.       {
  295.               return new String[]{text};
  296.       }
  297.       String str[] = Util.divideString(text,font,width);
  298.       if(str.length <= 1)
  299.           return str;
  300.       String strRet[] = new String[str.length - 1];
  301.       System.arraycopy(str, 1, strRet, 0, strRet.length);
  302.       str = null;
  303.       return strRet;
  304.       
  305.   }
  306.    public boolean keyPressed(int keycode) {
  307.     
  308.        int gameKey = DisplayManager.getInst().getGameAction(keycode);
  309.      if(!m_editable)
  310.      return false;
  311.         showCursor = true;
  312.         if ((gameKey == Canvas.LEFT || gameKey == Canvas.RIGHT || gameKey == Canvas.UP || gameKey == Canvas.DOWN) && isMightGameKey(keycode)) {
  313.          int tmp = cursorLocation;
  314.             if(insertCharTask != null)
  315.             {
  316.                 task(1);
  317.             }
  318.             moveCursor(gameKey);
  319.             if(tmp == cursorLocation)
  320.             {
  321.              return false;
  322.             }
  323.             return true;
  324.         } else if (keycode == KeyEvent.BACK_KEY) {
  325.             if (cursorLocation > 0) {
  326.                 cursorLocation--;
  327.                 actulText.deleteCharAt(cursorLocation);
  328.                 reParseText();
  329.                 setCursorPosition();
  330.                 setScrollHeight();
  331.                  return true;
  332.             }
  333.         } else if(gameKey != Canvas.FIRE || !isMightGameKey(keycode) ){
  334.             if(max_limit > 0 && actulText.length() >= max_limit)
  335.             {
  336.                 return true;
  337.             }
  338.             if(editType == NUMERIC)
  339.             {
  340.                 if(keycode >= DisplayManager.KEY_NUM0 && keycode <= DisplayManager.KEY_NUM9)
  341.                 {
  342.                     char ch = (char) keycode;
  343.                     actulText.insert(cursorLocation, ch);
  344.                     cursorLocation++;
  345.                     reParseText();
  346.                     setCursorPosition();
  347.                     setScrollHeight();
  348.                 }
  349.             }
  350.             else if(keyPadType == QWERTY_KEY_PAD)
  351.             {
  352.                 char ch = (char) keycode;
  353.                 actulText.insert(cursorLocation, ch); 
  354.                 cursorLocation++;
  355.                 reParseText();
  356.                 setCursorPosition();
  357.                 setScrollHeight();
  358.             }else
  359.             {
  360.                 if(keycode != -1 && keycode != oldKeyCode && insertCharTask != null)
  361.                 {
  362.                     task(1);
  363.                     oldKeyCode = -1;
  364.                 }
  365.                 if(insertCharTask != null)
  366.                 {
  367.                     insertCharTask.cancel();
  368.                     insertCharTask = null;
  369.                 }else
  370.                     oldKeyCode = keycode;
  371.                 
  372.                 insertCharTask = BaseTimer.schedule(CHAR_INSERT_DELAY, this,1);
  373.                 if(keycode == Canvas.KEY_STAR)
  374.                 {
  375.                     currentChar = '*' ;
  376.                     task(1);
  377.                 }else if(keycode == Canvas.KEY_POUND)
  378.                 {
  379.                    currentChar = '#' ;
  380.                    task(1);
  381.                 }else
  382.                 {
  383.                      currentChar = charArry[keycode - DisplayManager.KEY_NUM0][count];
  384.                 }
  385.                
  386.                 count++;
  387.                 if(count >= charArry[keycode - DisplayManager.KEY_NUM0].length )
  388.                 {
  389.                     count = 0;
  390.                 }
  391.             }
  392.             
  393.             return true;
  394.         }
  395.         return false;
  396.     }
  397.     
  398.     private void reParseText() {
  400.         if(isMultiline){
  401.         int extraWidth = 0;
  402.         if(totalHeight > height)
  403.             extraWidth = SCROLL_BAR_WIDTH;
  404.         String arry[] = divideString(actulText.toString(), font, width - (leftPadding << 1) - ERROR_WARP - extraWidth);
  405.         textVector.removeAllElements();
  406.         
  407.         for (int i = 0; i < arry.length; i++) {
  408.             
  409.             textVector.addElement(arry[i]);
  410.         }
  411.         totalHeight = textVector.size() * fontHeight;
  412.         if(textVector.size() == 1)
  413.         {
  414.          totalHeight = height;
  415.         }
  416. //        String currentText = (textVector.elementAt(currentSelectedRow).toString());
  417. //         if(currentSelectedRow >= textVector.size())
  418. //         {
  419. //             currentSelectedRow--;
  420. //             setCursorPosition();
  421. //           
  422. //         }else if(getCursorLocationInRow() > currentText.length()){
  423. //            currentSelectedRow++;
  424. //         }
  425.         setAutoCurrentRow();
  426.         setCursorPosition();
  427.         }
  429.     }
  430.    private void setAutoCurrentRow()
  431.    {
  432.        if(isMultiline)
  433.        {
  434.            int count = 0;
  435.            for (int i = 0; i < textVector.size(); i++) {
  436.                String line = textVector.elementAt(i).toString();
  437.                count += line.length();
  438.                if(cursorLocation <= count)
  439.                {
  440.                    currentSelectedRow = i;
  441.                    setScrollHeight();
  442.                    break;
  443.                }
  445.            }
  446.        }
  447.        
  448.    }
  449.    private void setScrollHeight()
  450.    {
  451.        if(isMultiline){
  452.            int _y = currentSelectedRow * fontHeight;
  453.            if(totalHeight > height)
  454.            {
  455.                if(_y + fontHeight >= height + scrollHeight  )
  456.                {
  457.                     scrollHeight = _y + fontHeight - height;
  458.                }else if(_y < scrollHeight){
  459.                    scrollHeight = _y;
  460.                }
  461.            }else{
  462.                scrollHeight = 0;
  463.            }
  464.        }else{
  465.         
  466.            int allowedWidth = width - (leftPadding << 1 ) - leftPadding;
  467.            if(allowedWidth <= 0)
  468.            {
  469.             horScrolled = 0;
  470.             return;
  471.            }
  472.            int subStringWidth = font.getStringWidth(actulText.toString().substring(0, cursorLocation));
  473.            if(subStringWidth < horScrolled )
  474.            {
  475.                horScrolled = subStringWidth;
  476.            }else if(subStringWidth - horScrolled >= allowedWidth )
  477.            {
  478.                horScrolled = subStringWidth - allowedWidth;
  479.            }
  480.           
  481.            if(horScrolled < 0)
  482.                horScrolled = 0;
  483.        }
  484.        
  485.    }
  486.     private void moveCursor(int direction) {
  487.        
  488.         if (direction == Canvas.LEFT) {
  489.             if (cursorLocation > 0) {
  490.                 cursorLocation--;
  492.             }
  493.         } else if (direction == Canvas.RIGHT) {
  494.             if (cursorLocation < actulText.length()) {
  495.                 cursorLocation++;
  496.             }
  497.         } else if (direction == Canvas.DOWN && isMultiline) {
  498.             if (currentSelectedRow < textVector.size() - 1) {
  499.                String downString = textVector.elementAt(currentSelectedRow + 1).toString();
  500.                currentSelectedRow++;
  501.                
  502.                if(font.getStringWidth(downString) < cursorXPosition)
  503.                {
  504.                   setCursorLocationInRow(downString.length());
  505.                }else{
  506.                     setCursorLocationInRow(getCharLocationOnWidth(downString,cursorXPosition));
  507.                }
  508.                 if(cursorLocation > actulText.length())
  509.                 {
  510.                     cursorLocation = actulText.length();
  511.                 }
  512.                
  513.             }
  514.         } else if (direction == Canvas.UP && isMultiline) {
  515.             if (currentSelectedRow > 0) {
  516.                 String upString = textVector.elementAt(currentSelectedRow - 1).toString();
  517.                currentSelectedRow--;
  518.                if(font.getStringWidth(upString) < cursorXPosition)
  519.                {
  520.                   setCursorLocationInRow(upString.length());
  521.                }else{
  522.                     setCursorLocationInRow(getCharLocationOnWidth(upString,cursorXPosition));
  523.                }
  524.                 if(cursorLocation < 0)
  525.                 {
  526.                     cursorLocation = 0;
  527.                 }
  528.             }
  529.         }
  530.         setAutoCurrentRow();
  531.         setCursorPosition();
  532.         setScrollHeight();
  533.     }
  534.    
  536.     
  537.     private int getCharLocationOnWidth(String str,int width)
  538.     {
  539.         int tmp_width = 0;
  540.         int char_loc = 0;
  541.         if(width >= font.getStringWidth(str))
  542.             char_loc = str.length();
  543.         else{
  544.             while(true)
  545.             {
  546.                 tmp_width = font.getStringWidth(str.substring(0, char_loc));
  547.                 if(tmp_width > width || char_loc >=  str.length())
  548.                 {
  549.                     char_loc--;
  550.                     break;
  551.                 }
  552.                 char_loc++;
  553.             }
  554.         }
  555.         return char_loc ;
  556.     }
  557.  
  558.     private boolean isMightGameKey(int keycode) {
  559.         if (!(keycode >= 65 && keycode <= 65 + 26) && !(keycode >= 97 && keycode <= 97 + 26) && !(keycode >= Canvas.KEY_NUM0 && keycode <= Canvas.KEY_NUM9)) {
  560.             return true;
  561.         } else {
  562.             return false;
  563.         }
  564.     }
  566.    
  568.     private void setCursorPosition() {
  569.         if(isMultiline)
  570.         {
  571.             String currentRowText = textVector.elementAt(currentSelectedRow).toString();
  572.             if(getCursorLocationInRow() >= 0 && getCursorLocationInRow() <= currentRowText.length())
  573.             {
  574.                 cursorXPosition = leftPadding + font.getStringWidth(textVector.elementAt(currentSelectedRow).toString().substring(0, getCursorLocationInRow()));
  575.                 cursorYPosition = (fontHeight >> 1) + (currentSelectedRow * fontHeight);
  576.             }    
  577.             
  578.         }else{
  579.             cursorXPosition = leftPadding + font.getStringWidth(actulText.toString().substring(0, cursorLocation)); 
  580.             cursorYPosition = (height >> 1);
  581.             
  582.         }
  583.         
  584.     }
  585.     private void setCursorLocationInRow(int location)
  586.     {
  587.         int chars = 0;
  588.         for (int idx = 0; idx < currentSelectedRow; idx++) {
  589.             chars += textVector.elementAt(idx).toString().length();
  590.         }
  591.         cursorLocation = location  + chars;
  592.         
  593.     }
  595.     private int getCursorLocationInRow()
  596.     {
  597.         int chars = 0;
  598.         for (int idx = 0; idx < currentSelectedRow; idx++) {
  599.             chars += textVector.elementAt(idx).toString().length();
  600.         }
  601.         return (cursorLocation - chars);
  602.     }
  603.   
  605.     public void task(int data) {
  606.         if(data == 1)
  607.         {
  608.             actulText.insert(cursorLocation, currentChar);
  609.             cursorLocation++;
  610.             reParseText();
  611.             setCursorPosition();
  612.             setScrollHeight();
  613.             count = 0;
  614.             if(insertCharTask != null)
  615.             {
  616.                 insertCharTask.cancel();
  617.                 insertCharTask = null;
  618.             }
  619.             
  620.         }else
  621.         {
  622.             showCursor = !showCursor;
  623.             DisplayManager.getInst().invalidate();
  624.         }
  625.        
  626.     }
  627.     
  628. }