Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-1263608

tremendous numbers of repaints are done

    XMLWordPrintable

    Details

    • Subcomponent:
    • Resolved In Build:
      1.0.k
    • CPU:
      sparc
    • OS:
      generic
    • Verification:
      Not verified

      Description

        drawButton(g, getButtonFromKey(evt.key), true);
              g.dispose();
              break;

            case Event.LOST_FOCUS:
              getParent().postEvent(new Event(this, ESCAPED, null));
            break;

            default:
              return super.handleEvent( evt );

          }
          return true;
        }

        private int asc;
        private int selectedButton;
        private boolean buttonDown;
        private boolean entered;
        public String value;

        static private int cellSize = 30;
        static private int nButton = 14;
        static private int buttonX[] = { 1, cellSize+1, cellSize*2+1, 1, cellSize+1, cellSize*2+1, 1, cellSize+1, cellSize*2+1, 1, cellSize+1, cellSize*2+1, cellSize*3+1, cellSize*3+1 };
        static private int buttonY[] = { 1, 1, 1, cellSize+1, cellSize+1, cellSize+1, cellSize*2+1, cellSize*2+1, cellSize*2+1, cellSize*3+1, cellSize*3+1, cellSize*3+1, cellSize*3+1, 1 };
        static private char buttonTitle1[] = { '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'C', '.', 'A', 'E' };

        static int paintAll = 0;
        static int paintSelected = 1;

      };

      Run the following program and then click on the window. A
      numeric keypad should appear. On Mr. Coffee, the keypad
      generates continual repaints.

      The program works fine under Win95. Under Solaris,
      the numeric keypad does not display at all.
      import java.awt.*;
      import java.applet.*;

      public class mousepos extends Applet
      {
        public static void main (String args[])
        {
          MyFrame myFrame = new MyFrame();
          myFrame.show();
        }

        public void init()
        {
          MyFrame myFrame = new MyFrame();
          myFrame.show();
        }
      }

      class MyFrame extends Frame
      {
        public MyFrame()
        {
          super("Secondary Window Placement");
          GroupBox g = new GroupBox("Mouse Position Testcase");
          setLayout(null);
          g.reshape( 10, 10, 100, 100 );
          add("center", g );

          resize(283,190);
        }

        public boolean handleEvent( Event evt )
        {
          switch (evt.id)
          {
            case Event.MOUSE_UP:
              NumericPad np = new NumericPad( this, evt.x, evt.y );
              System.out.println( "GroupBox: The mouse up position is x = " + evt.x + ", y = " + evt.y );
            break;
          }
          return super.handleEvent( evt );
        }

      }

      /**************************************************************************
      *
      * Class: GroupBox
      *
      * Purpose: Draw a 3d border around a collection of controls or a single
      * component. The name of the group box is drawn in the upper
      * right hand corner using the group boxes current font and
      * foreground color.
      *
      * Example: GroupBox checkBoxes = new GroupBox("Group Box Title");
      * checkBoxes.setLayout(new FlowLayout());
      * checkBoxes.add(new Checkbox("option1"));
      * checkBoxes.add(new Checkbox("option2"));
      * checkBoxes.add(new Checkbox("option3"));
      *
      **************************************************************************/
      class GroupBox extends Panel
      {
        /**************************************************************************
        *
        * Public
        *
        **************************************************************************/

        /**************************************************************************
        *
        * GroupBox
        *
        **************************************************************************/
        public GroupBox(String name)
        {
          // call the super class ctor
          super();
          setLayout(null);
          grpName = name;
        }

        /**************************************************************************
        *
        * setGroupName
        *
        **************************************************************************/
        public void setGroupName(String newName)
        {
          grpName = newName;
        }

        /**************************************************************************
        *
        * groupName
        *
        **************************************************************************/
        public String groupName()
        {
          return grpName;
        }

        /**************************************************************************
        *
        * paint
        *
        **************************************************************************/
        public void paint(Graphics g)
        {
          FontMetrics fm = g.getFontMetrics();
          int asc = fm.getAscent();
          int stringWidth = fm.stringWidth( " " + grpName + " " );
          int stringHeight = fm.getHeight();
          Rectangle r = bounds();

          g.setColor( Color.white );
          g.drawLine( 1, r.height-3, 1, asc/2 );
          g.drawLine( 1, asc/2, r.width-3, asc/2 );
          g.drawLine( r.width-1, asc/2-1, r.width-1, r.height-1 );
          g.drawLine( r.width-1, r.height-1, 0, r.height-1 );

          g.setColor( Color.gray );
          g.drawLine( r.width-2, asc/2-1, r.width-2, r.height-2 );
          g.drawLine( r.width-2, r.height-2, 0, r.height-2 );
          g.drawLine( 0, r.height-2, 0, asc/2-1 );
          g.drawLine( 0, asc/2-1, r.width-2, asc/2-1 );

          g.setColor( this.getBackground() );
          g.fillRect( 10, 0, stringWidth, stringHeight );
          g.setColor( Color.black );
          g.drawString( " " + grpName + " ", 10, asc );
        }

        /**************************************************************************
        *
        * insets
        *
        * Overridden so that the layout manager makes room for the 3d border
        * and the group box text.
        *
        **************************************************************************/
        public Insets insets( )
        {
          Graphics g = this.getGraphics();
          FontMetrics fm = g.getFontMetrics();
          int stringHeight = fm.getHeight();

          Insets i = super.insets();
          return new Insets( stringHeight + i.top, 5 + i.left, 3 + i.bottom, 5 + i.right );
        }

        // debug

        public boolean handleEvent( Event evt )
        {
          switch (evt.id)
          {
            case Event.MOUSE_UP:
              System.out.println( "GroupBox: The mouse up position is x = " + evt.x + ", y = " + evt.y );
            break;
          }
          return super.handleEvent( evt );
        }

        /**************************************************************************
        *
        * Private
        *
        **************************************************************************/
        private
          String grpName;
      }

      /**
       * This is a NumericPad class that is used to record a numeric value or
       * Anestesia specific alpha numeric code. The NumericPad is a basic Window
       * that displays a set a buttons for the user the click on. The NumericPad
       * buttons include 0 - 9, C(to clear the existing value), .(decimal point),
       * A/#(to switch between alpha and numeric) and E(the enter key). When the
       * NumericPad is switched to the alpha mode, the 1 - 9 buttons are replaced
       * by another set of buttons that represent Anestesia specific mnemonic
       * codes. The NumericPad also generates the ENTERED, ESCAPED and MODIFIED
       * events that can be handled at its parent level.
       *
       * @version 1.0, July 1996
       * @author George Clement
       */
      class NumericPad extends Window
      {
        /* Base for all NumericPad events */
        private static final int NUMERICPAD_EVENT = 5000;

        /**
         * The Entered event.
         */
        public final static int ENTERED = 1 + NUMERICPAD_EVENT;

        /**
         * The Escaped event.
         */
        public final static int ESCAPED = 2 + NUMERICPAD_EVENT;

        /**
         * The Modified event.
         */
        public final static int MODIFIED = 3 + NUMERICPAD_EVENT;

        /**
        * Create a Numeric object.
        *
        * @param parentWin The parent window of the NumericPad.
        * @param x The x location of the NumericPad with respect to its parent.
        * @param y The y location of the NumericPad with respect to its parent.
        */
        public NumericPad(Component parentWin, int x, int y)
        {
          super(GetFrame(parentWin));

          /* initialize object variables */
          selectedButton = -1;
          buttonDown = false;
          entered = false;
          value = new String();

          setBackground(Color.lightGray);
          Component curParent = parentWin;

          /* Calculate the absolute location of the parent window. */
          while (curParent != null)
          {
            x += curParent.location().x;
            y += curParent.location().y;
            if (curParent instanceof Frame)
            {
              break;
            }

            curParent = curParent.getParent();
          }

          this.addNotify();
          reshape(x, y, cellSize*4+2, cellSize*4+2);

          System.out.println( "The translated coordinates are: x = " + x + " y = " + y );

          setLayout(null);
          show();
          requestFocus();
        }

        /**
        * Query the Numeric pad to see if an enter was keyed on the NumericPad.
        * @return Returns a true if enter was keyed, false otherwise.
        */
        public boolean isEntered()
        {
          return entered;
        }

        /**
        * Shows the NumericPad. Calls the super.show and also disables
        * its parent window which make it behave like a model window.
        */
        public void show()
        {
          super.show();
          Component parentFrame = GetFrame(this);
      // if (parentFrame != null) {
      // parentFrame.disable();
      // }
        }

        /**
        * Dispose the NumericPad. Calls the super.dispose and also enable
        * its parent window. Called when the NumericPad is destroyed to
        * give back the control to its parent window.
        */
        public void dispose()
        {
          Component parentFrame = GetFrame(this);
      // if (parentFrame != null) {
      // parentFrame.enable();
      // }
          super.dispose();
        }

        /**
        * Gets the parent Frame window of a given component.
        */
        private static Frame GetFrame (Component curComp)
        {
          Component curParent = curComp;
          Frame theFrame = null;

          while (curParent != null) {
            if (curParent instanceof Frame) {
              theFrame = (Frame) curParent;
              break;
            }
            curParent = curParent.getParent();
          }
          return theFrame;
        }

        /**
        * Paints the NumericPad object. Paints all the buttons or the one
        * that is currently selected.
        * @param g The almighty Graphics object.
        * @param howToPaint The kind of paint that needs to performed.
        */
        public void paint(Graphics g, int howToPaint)
        {
          FontMetrics fm = g.getFontMetrics();
          asc = fm.getAscent();

          setForeground(Color.black);
          g.drawRect(0, 0, cellSize*4+1, cellSize*4+1);

          if (howToPaint == paintAll) {
            for (int i=0; i<nButton; i++) {
              drawButton(g, i, false);
            }
          }
          else {
              drawButton(g, selectedButton, buttonDown);
          }

        }

        /**
        * Paints the NumericPad object. This basically routes paint request to
        * private paint method.
        * @param g The almighty Graphics object.
        */
        public void paint(Graphics g)
        {
          paint( g, paintAll );
        }



        /**
        * Draws a button on the Numeric pad. The look-and-feel of a button
        * is achived by drawing a rectangle with top and left edges in dark
        * shade and bottom and right edges in light shade. The depression of
        * the button itself is simulated by drawing the same rectangle with
        * the shades of the edges inverted.
        * @param g The almighty Graphics object.
        * @param id The index of the button that neds to be drawn.
        * @param pressed The flag that specifies if the button needs to
        * be drawn depressed.
        */
        private void drawButton(Graphics g, int id, boolean pressed)
        {
          String text = new String();
          int x = buttonX[id];
          int y = buttonY[id];
          char c = buttonTitle1[id];
          int cellWidth = cellSize-1;
          int cellHeight = cellSize-1;

          if (id == 13)
            cellHeight = cellSize*3-1;

          if (pressed)
            g.setColor( Color.black );
          else
            g.setColor( Color.white );
          g.drawLine( x, y, x, y+cellHeight );
          g.drawLine( x+cellWidth, y, x, y );

          if (pressed)
            g.setColor( Color.white );
          else
            g.setColor( Color.black );
          g.drawLine( x, y+cellHeight, x+cellWidth, y+cellHeight );
          g.drawLine( x+cellWidth, y+cellHeight, x+cellWidth, y );

          g.drawString( ""+c, x+7, y+asc+3);
        }

        /**
        * Calculates the button index for a given x-y location on the
        * NumericPad.
        * @param x The x coordinate of the location.
        * @param y The y coordinate of the location.
        * @return Returns the index of the button.
        */
        private int getButtonFromLocation(int x, int y)
        {
          int id = (x / cellSize) + (y / cellSize)*3;
           if (x > cellSize*3) {
             if (y > cellSize*3)
               id = 12;
             else
               id = 13;
            }

          return id;
        }

        /**
        * Calculates the button index the corresponds to a given key value.
        * @param key The ascii key value.
        * @return Returns the index of the button.
        */
        private int getButtonFromKey(int key)
        {
          if (key==10) return 13;
          key = (char)Character.toUpperCase((char)key);
          for (int i=0; i<14; i++)
            if (buttonTitle1[i]==key) return i;
          return -1;
         }


        /**
        * Handles all input events for the numeric pad.
        * @param evt The awt generated event.
        * @return Return true to indicate the event has been processed.
        */
        public boolean handleEvent( Event evt )
        {
          Graphics g;
          switch (evt.id)
          {
      // case Event.LOST_FOCUS:
      // getParent().postEvent(new Event(this, ESCAPED, null));
      // System.out.println("Lost Focus");
      // return true;
            case Event.MOUSE_DOWN:
      // if (true || (evt.modifiers & Event.META_MASK) != 0)
              selectedButton = getButtonFromLocation(evt.x, evt.y);
              buttonDown = true;
              g = getGraphics();
              paint(g, paintSelected);
              g.dispose();
              break;

            case Event.MOUSE_UP:
              if (selectedButton == -1) break;
              buttonDown = false;
              if (selectedButton == getButtonFromLocation(evt.x, evt.y)) {
                g = getGraphics();
                paint(g, paintSelected);
                g.dispose();
                if (selectedButton>=0 && selectedButton<=12)
                  postEvent(new Event(this, evt.when,
                                      Event.KEY_RELEASE, 0, 0,
                                      (int)buttonTitle1[selectedButton],
                                      evt.modifiers, null));
                else
                  postEvent(new Event(this, evt.when, Event.KEY_RELEASE, 0, 0, 10, evt.modifiers, null));
              }

              selectedButton = -1;
              break;

            case Event.MOUSE_DRAG:
              if (selectedButton == -1) break;
              if (selectedButton == getButtonFromLocation(evt.x, evt.y)) {
                if (buttonDown==false) {
                  buttonDown = true;
                  g = getGraphics();
                  paint(g, paintSelected);
                  g.dispose();
                }
              }
              else {
                if (buttonDown==true) {
                  buttonDown = false;
                  g = getGraphics();
                  paint(g, paintSelected);
                  g.dispose();
                }
              }
              break;

            case Event.KEY_ACTION:
            case Event.KEY_ACTION_RELEASE:
            case Event.KEY_RELEASE:
              // If the enter key was pressed...
              switch (evt.key) {
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case '0':
                case '.':
                  value = value + (char)evt.key;
                  break;
                case 'C':
                case 'c':
                  value = "";
                  break;
                case 'A':
                case 'a':
                  break;
                case 10:
                  entered = true;
                  break;
                case 27:
                  getParent().postEvent(new Event(this, ESCAPED, null));
                  return true;
                default:
                  return super.handleEvent( evt );
              };
              g = getGraphics();
              drawButton(g, getButtonFromKey(evt.key), false);
              g.dispose();
              if (entered==true)
                getParent().postEvent(new Event(this, ENTERED, null));
              else
                getParent().postEvent(new Event(this, MODIFIED, null));
              break;

            case Event.KEY_PRESS:

              // If the enter key was pressed...
              switch (evt.key) {
                case '1':
                case '2':
                case '3':
                case '4':
                case '5':
                case '6':
                case '7':
                case '8':
                case '9':
                case '0':
                case '.':
                case 'C':
                case 'c':
                case 'A':
                case 'a':
                case 10:
                  break;
                default:
                  return super.handleEvent( evt );
              };
              g = getGraphics();
            

        Attachments

          Activity

            People

            Assignee:
            duke J. Duke (Inactive)
            Reporter:
            mechew Maureen Chew (Inactive)
            Votes:
            0 Vote for this issue
            Watchers:
            0 Start watching this issue

              Dates

              Created:
              Updated:
              Resolved:
              Imported:
              Indexed: