Java PaintEvent.PAINT属性代码示例

@Override
public void coalescePaintEvent(PaintEvent e) {
    Rectangle r = e.getUpdateRect();
    if (!(e instanceof IgnorePaintEvent)) {
        paintArea.add(r, e.getID());
    }

    if (log.isLoggable(PlatformLogger.Level.FINEST)) {
        switch(e.getID()) {
        case PaintEvent.UPDATE:
            log.finest("coalescePaintEvent: UPDATE: add: x = " +
                r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);
            return;
        case PaintEvent.PAINT:
            log.finest("coalescePaintEvent: PAINT: add: x = " +
                r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);
            return;
        }
    }
}
 

/**
 * Adds a <code>Rectangle</code> to this <code>RepaintArea</code>.
 * PAINT Rectangles are divided into mostly vertical and mostly horizontal.
 * Each group is unioned together.
 * UPDATE Rectangles are unioned.
 *
 * @param   r   the specified <code>Rectangle</code>
 * @param   id  possible values PaintEvent.UPDATE or PaintEvent.PAINT
 * @since   1.3
 */
public synchronized void add(Rectangle r, int id) {
    // Make sure this new rectangle has positive dimensions
    if (r.isEmpty()) {
        return;
    }
    int addTo = UPDATE;
    if (id == PaintEvent.PAINT) {
        addTo = (r.width > r.height) ? HORIZONTAL : VERTICAL;
    }
    if (paintRects[addTo] != null) {
        paintRects[addTo].add(r);
    } else {
        paintRects[addTo] = new Rectangle(r);
    }
}
 

public void coalescePaintEvent(PaintEvent e) {
    Rectangle r = e.getUpdateRect();
    if (!(e instanceof IgnorePaintEvent)) {
        paintArea.add(r, e.getID());
    }
    if (true) {
        switch(e.getID()) {
          case PaintEvent.UPDATE:
              if (log.isLoggable(PlatformLogger.Level.FINER)) {
                  log.finer("XCP coalescePaintEvent : UPDATE : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              }
              return;
          case PaintEvent.PAINT:
              if (log.isLoggable(PlatformLogger.Level.FINER)) {
                  log.finer("XCP coalescePaintEvent : PAINT : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              }
              return;
        }
    }
}
 

/**
 * Adds a {@code Rectangle} to this {@code RepaintArea}.
 * PAINT Rectangles are divided into mostly vertical and mostly horizontal.
 * Each group is unioned together.
 * UPDATE Rectangles are unioned.
 *
 * @param   r   the specified {@code Rectangle}
 * @param   id  possible values PaintEvent.UPDATE or PaintEvent.PAINT
 * @since   1.3
 */
public synchronized void add(Rectangle r, int id) {
    // Make sure this new rectangle has positive dimensions
    if (r.isEmpty()) {
        return;
    }
    int addTo = UPDATE;
    if (id == PaintEvent.PAINT) {
        addTo = (r.width > r.height) ? HORIZONTAL : VERTICAL;
    }
    if (paintRects[addTo] != null) {
        paintRects[addTo].add(r);
    } else {
        paintRects[addTo] = new Rectangle(r);
    }
}
 

public void handleEvent (AWTEvent event)
{
  int id = event.getID();
  KeyEvent ke = null;

  switch (id)
    {
    case PaintEvent.PAINT:
      paintComponent((PaintEvent) event);
      break;
    case PaintEvent.UPDATE:
      updateComponent((PaintEvent) event);
      break;
    case KeyEvent.KEY_PRESSED:
      ke = (KeyEvent) event;
      gtkWidgetDispatchKeyEvent (ke.getID (), ke.getWhen (), ke.getModifiersEx (),
                                 ke.getKeyCode (), ke.getKeyLocation ());
      break;
    case KeyEvent.KEY_RELEASED:
      ke = (KeyEvent) event;
      gtkWidgetDispatchKeyEvent (ke.getID (), ke.getWhen (), ke.getModifiersEx (),
                                 ke.getKeyCode (), ke.getKeyLocation ());
      break;
    }
}
 

public void handleEvent (AWTEvent e)
 {
   int eventID = e.getID();
   Rectangle r;

   switch (eventID)
     {
     case ComponentEvent.COMPONENT_SHOWN:
QtToolkit.repaintThread.queueComponent(this);
       break;
     case PaintEvent.PAINT:
     case PaintEvent.UPDATE:	
r = ((PaintEvent)e).getUpdateRect();
QtToolkit.repaintThread.queueComponent(this, r.x, r.y,
				       r.width, r.height);
       break;
     case KeyEvent.KEY_PRESSED:
break;
     case KeyEvent.KEY_RELEASED:
break;
     }
 }
 

private void processPaintEvent(PaintEvent event) {
    if (redrawManager == null || getIgnoreRepaint()) {
        return;
    }
    Rectangle clipRect = event.getUpdateRect();
    if ((clipRect.width <= 0) || (clipRect.height <= 0)) {
        return;
    }
    Graphics g = getGraphics();
    if (g == null) {
        return;
    }

    initGraphics(g, event);

    if (event.getID() == PaintEvent.PAINT) {
        paint(g);
    } else {
        update(g);
    }
    ((CommonGraphics2D)g).flush();
    g.dispose();
}
 

public void coalescePaintEvent(PaintEvent e) {
    Rectangle r = e.getUpdateRect();
    if (!(e instanceof IgnorePaintEvent)) {
        paintArea.add(r, e.getID());
    }
    if (true) {
        switch(e.getID()) {
          case PaintEvent.UPDATE:
              log.finer("XCP coalescePaintEvent : UPDATE : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              return;
          case PaintEvent.PAINT:
              log.finer("XCP coalescePaintEvent : PAINT : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              return;
        }
    }
}
 

public void coalescePaintEvent(PaintEvent e) {
    Rectangle r = e.getUpdateRect();
    if (!(e instanceof IgnorePaintEvent)) {
        paintArea.add(r, e.getID());
    }

    if (log.isLoggable(PlatformLogger.FINEST)) {
        switch(e.getID()) {
        case PaintEvent.UPDATE:
            log.finest("coalescePaintEvent: UPDATE: add: x = " +
                r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);
            return;
        case PaintEvent.PAINT:
            log.finest("coalescePaintEvent: PAINT: add: x = " +
                r.x + ", y = " + r.y + ", width = " + r.width + ", height = " + r.height);
            return;
        }
    }
}
 

public void coalescePaintEvent(PaintEvent e) {
    Rectangle r = e.getUpdateRect();
    if (!(e instanceof IgnorePaintEvent)) {
        paintArea.add(r, e.getID());
    }
    if (true) {
        switch(e.getID()) {
          case PaintEvent.UPDATE:
              if (log.isLoggable(PlatformLogger.FINER)) {
                  log.finer("XCP coalescePaintEvent : UPDATE : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              }
              return;
          case PaintEvent.PAINT:
              if (log.isLoggable(PlatformLogger.FINER)) {
                  log.finer("XCP coalescePaintEvent : PAINT : add : x = " +
                        r.x + ", y = " + r.y + ", width = " + r.width + ",height = " + r.height);
              }
              return;
        }
    }
}
 

void initGraphics(Graphics g, PaintEvent e) {
    Rectangle clip = e.getUpdateRect();
    if (clip instanceof ClipRegion) {
        g.setClip(((ClipRegion) clip).getClip());
    } else {
        g.setClip(clip);
    }
    if (isPrepainter()) {
        prepaint(g);
    } else if (!isLightweight() && (e.getID() == PaintEvent.PAINT)) {
        g.setColor(getBackground());
        g.fillRect(0, 0, w, h);
    }
    g.setFont(getFont());
    g.setColor(getForeground());
}
 

public void handleEvent (AWTEvent e)
{
  int eventID = e.getID();
  Rectangle r;

  switch (eventID)
    {
    case ComponentEvent.COMPONENT_SHOWN:
      QtToolkit.repaintThread.queueComponent(this);
      break;
    case PaintEvent.PAINT:
    case PaintEvent.UPDATE:
      r = ((PaintEvent)e).getUpdateRect();
      QtToolkit.repaintThread.queueComponent(this, r.x, r.y,
                                             r.width, r.height);
      break;
    case KeyEvent.KEY_PRESSED:
      break;
    case KeyEvent.KEY_RELEASED:
      break;
    }
}
 

private void processPaintEvent(PaintEvent event) {
    if (redrawManager == null) {
        return;
    }
    Rectangle clipRect = event.getUpdateRect();
    if ((clipRect.width <= 0) || (clipRect.height <= 0)) {
        return;
    }
    Graphics g = getGraphics();
    if (g == null) {
        return;
    }
    initGraphics(g, event);
    if (!getIgnoreRepaint()) {
        if (event.getID() == PaintEvent.PAINT) {
            paint(g);
        } else {
            update(g);
        }
    }
    g.dispose();
}
 

@Override
@SuppressWarnings("fallthrough")
public void handleEvent(AWTEvent e) {
    int id = e.getID();

    if ((e instanceof InputEvent) && !((InputEvent)e).isConsumed() &&
        ((Component)target).isEnabled())
    {
        if (e instanceof MouseEvent && !(e instanceof MouseWheelEvent)) {
            handleJavaMouseEvent((MouseEvent) e);
        } else if (e instanceof KeyEvent) {
            if (handleJavaKeyEvent((KeyEvent)e)) {
                return;
            }
        }
    }

    switch(id) {
        case PaintEvent.PAINT:
            // Got native painting
            paintPending = false;
            // Fallthrough to next statement
        case PaintEvent.UPDATE:
            // Skip all painting while layouting and all UPDATEs
            // while waiting for native paint
            if (!isLayouting && ! paintPending) {
                paintArea.paint(target,shouldClearRectBeforePaint());
            }
            return;
        case FocusEvent.FOCUS_LOST:
        case FocusEvent.FOCUS_GAINED:
            handleJavaFocusEvent((FocusEvent)e);
        default:
        break;
    }

    // Call the native code
    nativeHandleEvent(e);
}
 

/**
 * This is called by the EventQueue if two events with the same event id
 * and owner component are queued. Returns a new combined event, or null if
 * no combining is done. The coelesced events are currently mouse moves
 * (intermediate ones are discarded) and paint events (a merged paint is
 * created in place of the two events).
 *
 * @param existingEvent the event on the queue
 * @param newEvent the new event that might be entered on the queue
 * @return null if both events are kept, or the replacement coelesced event
 */
protected AWTEvent coalesceEvents(AWTEvent existingEvent, AWTEvent newEvent)
{
  AWTEvent coalesced = null;
  switch (existingEvent.id)
    {
    case MouseEvent.MOUSE_MOVED:
    case MouseEvent.MOUSE_DRAGGED:
      // Just drop the old (intermediate) event and return the new one.
      MouseEvent me1 = (MouseEvent) existingEvent;
      MouseEvent me2 = (MouseEvent) newEvent;
      if (me1.getModifiers() == me2.getModifiers())
        coalesced = newEvent;
      break;
    case PaintEvent.PAINT:
    case PaintEvent.UPDATE:
      // For heavyweights the EventQueue should ask the peer.
      if (peer == null || peer instanceof LightweightPeer)
        {
          PaintEvent pe1 = (PaintEvent) existingEvent;
          PaintEvent pe2 = (PaintEvent) newEvent;
          Rectangle r1 = pe1.getUpdateRect();
          Rectangle r2 = pe2.getUpdateRect();
          if (r1.contains(r2))
            coalesced = existingEvent;
          else if (r2.contains(r1))
            coalesced = newEvent;
        }
      else
        {
          // Replace the event and let the heavyweight figure out the expanding
          // of the repaint area.
          coalesced = newEvent;
        }
      break;
    default:
      coalesced = null;
    }
  return coalesced;
}