gt:     protected void handleEvent(AWTEvent event) {
context: /*
   * Copyright (c) 2002, 2014, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  package sun.awt.X11;
  
  import java.awt.*;
  import java.awt.peer.*;
  import java.awt.event.*;
  
  import java.util.Vector;
  import sun.util.logging.PlatformLogger;
  import sun.awt.AWTAccessor;
  
  public class XMenuBarPeer extends XBaseMenuWindow implements MenuBarPeer {
  
      /************************************************
       *
       * Data members
       *
       ************************************************/
  
      private static PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XMenuBarPeer");
  
      /*
       * Primary members
       */
      private XFramePeer framePeer;
      private MenuBar menuBarTarget;
  
      /*
       * Index of help menu
       */
      private XMenuPeer helpMenu = null;
  
      /*
       * dimension constants
       */
      private final static int BAR_SPACING_TOP = 3;
      private final static int BAR_SPACING_BOTTOM = 3;
      private final static int BAR_SPACING_LEFT = 3;
      private final static int BAR_SPACING_RIGHT = 3;
      private final static int BAR_ITEM_SPACING = 2;
      private final static int BAR_ITEM_MARGIN_LEFT = 10;
      private final static int BAR_ITEM_MARGIN_RIGHT = 10;
      private final static int BAR_ITEM_MARGIN_TOP = 2;
      private final static int BAR_ITEM_MARGIN_BOTTOM = 2;
  
      /************************************************
       *
       * Mapping data
       *
       ************************************************/
  
      /**
       * XBaseMenuWindow's mappingData is extended with
       * desired height of menu bar
       */
      static class MappingData extends XBaseMenuWindow.MappingData {
          int desiredHeight;
  
          MappingData(XMenuItemPeer[] items, int desiredHeight) {
              super(items);
              this.desiredHeight = desiredHeight;
          }
  
          /**
           * Constructs MappingData without items
           * This constructor should be used in case of errors
           */
          MappingData() {
              this.desiredHeight = 0;
          }
  
          public int getDesiredHeight() {
              return this.desiredHeight;
          }
      }
  
      /************************************************
       *
       * Construction
       *
       ************************************************/
      XMenuBarPeer(MenuBar menuBarTarget) {
          this.menuBarTarget = menuBarTarget;
      }
  
      /************************************************
       *
       * Implementaion of interface methods
       *
       ************************************************/
  
      /*
       * From MenuComponentPeer
       */
      public void setFont(Font f) {
          resetMapping();
          setItemsFont(f);
          postPaintEvent();
      }
  
      /*
       * From MenuBarPeer
       */
  
      /*
       * Functions addMenu, delMenu, addHelpMenu
       * need to have somewhat strange behaivour
       * deduced from java.awt.MenuBar.
       * We can not get index of particular item in
       * MenuBar.menus array, because MenuBar firstly
       * performs array operations and then calls peer.
       * So we need to synchronize indicies in 'items'
       * array with MenuBar.menus. We have to follow
       * these rules:
       * 1. Menus are always added to the end of array,
       * even when helpMenu is present
       * 2. Removal of any menu item acts as casual
       * remove from array
       * 3. MenuBar.setHelpMenu _firstly_ removes
       * previous helpMenu by calling delMenu() if
       * necessary, then it performs addMenu(),
       * and then - addHelpMenu().
       *
       * Note that these functions don't perform
       * type checks and checks for nulls or duplicates
       */
      public void addMenu(Menu m) {
          addItem(m);
          postPaintEvent();
      }
  
      public void delMenu(int index) {
          synchronized(getMenuTreeLock()) {
              XMenuItemPeer item = getItem(index);
              if (item != null && item == helpMenu) {
                  helpMenu = null;
              }
              delItem(index);
          }
          postPaintEvent();
      }
  
      @SuppressWarnings("deprecation")
      public void addHelpMenu(Menu m) {
          XMenuPeer mp = (XMenuPeer)m.getPeer();
          synchronized(getMenuTreeLock()) {
              helpMenu = mp;
          }
          postPaintEvent();
      }
  
      /************************************************
       *
       * Initialization
       *
       ************************************************/
      /**
       * called from XFramePeer.setMenuBar
       */
      @SuppressWarnings("deprecation")
      public void init(Frame frame) {
          this.target = frame;
          this.framePeer = (XFramePeer)frame.getPeer();
          XCreateWindowParams params = getDelayedParams();
          params.remove(DELAYED);
          params.add(PARENT_WINDOW, framePeer.getShell());
          params.add(TARGET, frame);
          init(params);
      }
  
      /**
       * Overriden initialization
       */
      void postInit(XCreateWindowParams params) {
          super.postInit(params);
          // Get menus from the target.
          Vector<Menu> targetMenuVector = AWTAccessor.getMenuBarAccessor()
                                                     .getMenus(menuBarTarget);
          Menu targetHelpMenu = AWTAccessor.getMenuBarAccessor()
                                           .getHelpMenu(menuBarTarget);
          reloadItems(targetMenuVector);
          if (targetHelpMenu != null) {
              addHelpMenu(targetHelpMenu);
          }
          xSetVisible(true);
          toFront();
      }
  
      /************************************************
       *
       * Implementation of abstract methods
       *
       ************************************************/
  
      /**
       * Menu bar is always root window in menu window's
       * hierarchy
       */
      protected XBaseMenuWindow getParentMenuWindow() {
          return null;
      }
  
      /**
       * @see XBaseMenuWindow.map
       */
      protected MappingData map() {
          XMenuItemPeer[] itemVector = copyItems();
          int itemCnt = itemVector.length;
          XMenuItemPeer helpMenu = this.helpMenu;
          int helpMenuPos = -1;
          //find helpMenu and move it to the end of array
          if (helpMenu != null) {
              //Fixed 6270847: PIT: HELP menu is not shown at the right place when normal menus added to MB are removed, XToolkit
              for (int i = 0; i < itemCnt; i++) {
                  if (itemVector[i] == helpMenu) {
                      helpMenuPos = i;
                      break;
                  }
              }
              if (helpMenuPos != -1 && helpMenuPos != itemCnt - 1) {
                  System.arraycopy(itemVector, helpMenuPos + 1, itemVector, helpMenuPos, itemCnt - 1 - helpMenuPos);
                  itemVector[itemCnt - 1] = helpMenu;
              }
          }
          //We need maximum height before calculating item's bounds
          int maxHeight = 0;
          XMenuItemPeer.TextMetrics[] itemMetrics = new XMenuItemPeer.TextMetrics[itemCnt];
          for (int i = 0; i < itemCnt; i++) {
              itemMetrics[i] = itemVector[i].getTextMetrics();
              Dimension dim = itemMetrics[i].getTextDimension();
              if (dim != null) {
                  maxHeight = Math.max(maxHeight, dim.height);
              }
          }
          //Calculate bounds
          int nextOffset = 0;
          int itemHeight = BAR_ITEM_MARGIN_TOP + maxHeight + BAR_ITEM_MARGIN_BOTTOM;
          int mappedCnt = itemCnt;
          for (int i = 0; i < itemCnt; i++) {
              XMenuItemPeer item = itemVector[i];
              XMenuItemPeer.TextMetrics metrics = itemMetrics[i];
              Dimension dim = metrics.getTextDimension();
              if (dim != null) {
                  int itemWidth = BAR_ITEM_MARGIN_LEFT + dim.width + BAR_ITEM_MARGIN_RIGHT;
                  //Fix for 6270757: PIT: Menus and Sub-menus are shown outside the frame, XToolkit
                  //Cut-off items that don't fit in window
                  //At least one item must remain in menu
                  if ((nextOffset + itemWidth > this.width) && (i > 0)) {
                      mappedCnt = i;
                      break;
                  }
                  //If this item is help menu, move it to the right edge
                  if ((i == itemCnt - 1) && helpMenuPos != -1) {
                      nextOffset = Math.max(nextOffset, this.width - itemWidth - BAR_SPACING_RIGHT);
                  }
                  Rectangle bounds = new Rectangle(nextOffset, BAR_SPACING_TOP, itemWidth, itemHeight);
                  //text should be centered vertically in menu item's bounds
                  int y = (maxHeight + dim.height) / 2  - metrics.getTextBaseline();
                  Point textOrigin = new Point(nextOffset + BAR_ITEM_MARGIN_LEFT, BAR_SPACING_TOP + BAR_ITEM_MARGIN_TOP + y);
                  nextOffset += itemWidth + BAR_ITEM_SPACING;
                  item.map(bounds, textOrigin);
              } else {
                  Rectangle bounds = new Rectangle(nextOffset, BAR_SPACING_TOP, 0, 0);
                  Point textOrigin = new Point(nextOffset + BAR_ITEM_MARGIN_LEFT, BAR_SPACING_TOP + BAR_ITEM_MARGIN_TOP);
              }
          }
          XMenuItemPeer mappedVector[] = new XMenuItemPeer[mappedCnt];
          System.arraycopy(itemVector, 0, mappedVector, 0, mappedCnt);
          MappingData mappingData = new MappingData(mappedVector, BAR_SPACING_TOP + itemHeight + BAR_SPACING_BOTTOM);
          return mappingData;
      }
  
      /**
       * @see XBaseMenuWindow.getSubmenuBounds
       */
      protected Rectangle getSubmenuBounds(Rectangle itemBounds, Dimension windowSize) {
          Rectangle globalBounds = toGlobal(itemBounds);
          Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
          Rectangle res;
          res = fitWindowBelow(globalBounds, windowSize, screenSize);
          if (res != null) {
              return res;
          }
          res = fitWindowAbove(globalBounds, windowSize, screenSize);
          if (res != null) {
              return res;
          }
          res = fitWindowRight(globalBounds, windowSize, screenSize);
          if (res != null) {
              return res;
          }
          res = fitWindowLeft(globalBounds, windowSize, screenSize);
          if (res != null) {
              return res;
          }
          return fitWindowToScreen(windowSize, screenSize);
      }
  
      /**
       * This function is called when it's likely that
       * size of items has changed.
       * Invokes framePeer's updateChildrenSizes()
       */
      protected void updateSize() {
          resetMapping();
          if (framePeer != null) {
              framePeer.reshapeMenubarPeer();
          }
      }
  
      /************************************************
       *
       * Utility functions
       *
       ************************************************/
  
      /**
       * Returns desired height of menu bar
       */
      int getDesiredHeight() {
          MappingData mappingData = (MappingData)getMappingData();
          return mappingData.getDesiredHeight();
      }
  
      /**
       * Returns true if framePeer is not null and is enabled
       * Used to fix 6185057: Disabling a frame does not disable
       * the menus on the frame, on solaris/linux
       */
      boolean isFramePeerEnabled() {
          if (framePeer != null) {
              return framePeer.isEnabled();
          }
          return false;
      }
  
      /************************************************
       *
       * Overriden XBaseMenuWindow functions
       *
       ************************************************/
  
      /**
       * @see XBaseMenuWindow.doDispose()
       */
      protected void doDispose() {
          super.doDispose();
          XToolkit.targetDisposedPeer(menuBarTarget, this);
      }
  
      /************************************************
       *
       * Overriden XWindow general-purpose functions
       *
       ************************************************/
  
      /**
       * For menu bars this function is called from framePeer's
       * reshape(...) and updateChildrenSizes()
       */
      public void reshape(int x, int y, int width, int height) {
          if ((width != this.width) || (height != this.height)) {
              resetMapping();
          }
          super.reshape(x, y, width, height);
      }
  
      /**
       * Performs ungrabbing of input
       * @see XBaseWindow.ungrabInputImpl()
       */
      void ungrabInputImpl() {
          selectItem(null, false);
          super.ungrabInputImpl();
          postPaintEvent();
      }
  
      /************************************************
       *
       * Overriden XWindow painting & printing
       *
       ************************************************/
      public void paintPeer(Graphics g) {
          resetColors();
          /* Calculate menubar dimension. */
          int width = getWidth();
          int height = getHeight();
  
          flush();
          //Fill background of rectangle
          g.setColor(getBackgroundColor());
          g.fillRect(1, 1, width - 2, height - 2);
  
          draw3DRect(g, 0, 0, width, height, true);
  
          //Paint menus
          MappingData mappingData = (MappingData)getMappingData();
          XMenuItemPeer[] itemVector = mappingData.getItems();
          XMenuItemPeer selectedItem = getSelectedItem();
          for (int i = 0; i < itemVector.length; i++) {
              XMenuItemPeer item = itemVector[i];
              //paint item
              g.setFont(item.getTargetFont());
              Rectangle bounds = item.getBounds();
              Point textOrigin = item.getTextOrigin();
              if (item == selectedItem) {
                  g.setColor(getSelectedColor());
                  g.fillRect(bounds.x, bounds.y, bounds.width, bounds.height);
                  draw3DRect(g, bounds.x, bounds.y, bounds.width, bounds.height, false);
              }
              if (isFramePeerEnabled() && item.isTargetItemEnabled()) {
                  g.setColor(getForegroundColor());
              } else {
                  g.setColor(getDisabledColor());
              }
              g.drawString(item.getTargetLabel(), textOrigin.x, textOrigin.y);
          }
          flush();
      }
  
      static final int W_DIFF = (XFramePeer.CROSSHAIR_INSET + 1) * 2;
      static final int H_DIFF = XFramePeer.BUTTON_Y + XFramePeer.BUTTON_H;
  
      void print(Graphics g) {
          //TODO:Implement
      }
  
      /************************************************
       *
       * Overriden XBaseMenuWindow event handling
       *
       ************************************************/
  