controls/flyout/FlyoutControlComposite.java

/*******************************************************************************
 * Copyright (c) 2011 Google, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Google, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.wb.core.controls.flyout;

import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.MouseTrackAdapter;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Tracker;
import org.eclipse.wb.core.controls.Messages;
import org.eclipse.wb.draw2d.IColorConstants;
import org.eclipse.wb.draw2d.ICursorConstants;
import org.eclipse.wb.internal.core.utils.ui.DrawUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * {@link FlyoutControlComposite} is container for two {@link Control}'s. One (client control) is
 * used to fill client area. Second (flyout control) can be docked to any enabled position or
 * temporary hidden.
 *
 * @author scheglov_ke
 * @coverage core.control
 */
public final class FlyoutControlComposite extends Composite {
  private static final int RESIZE_WIDTH = 5;
  private static final int TITLE_LINES = 30;
  private static final int TITLE_MARGIN = 5;
  private static final Font TITLE_FONT = JFaceResources.getFontRegistry().getBold(
      JFaceResources.DEFAULT_FONT);
  ////////////////////////////////////////////////////////////////////////////
  //
  // Images
  //
  ////////////////////////////////////////////////////////////////////////////
  private static final Image PIN = loadImage("icons/pin.gif");
  private static final Image ARROW_LEFT = loadImage("icons/arrow_left.gif");
  private static final Image ARROW_RIGHT = loadImage("icons/arrow_right.gif");
  private static final Image ARROW_TOP = loadImage("icons/arrow_top.gif");
  private static final Image ARROW_BOTTOM = loadImage("icons/arrow_bottom.gif");

  private static Image loadImage(String path) {
    return DrawUtils.loadImage(FlyoutControlComposite.class, path);
  }

  ////////////////////////////////////////////////////////////////////////////
  //
  // Instance fields
  //
  ////////////////////////////////////////////////////////////////////////////
  private final IFlyoutPreferences m_preferences;
  private final FlyoutContainer m_flyoutContainer;
  private int m_minWidth = 150;
  private int m_validDockLocations = -1;
  private final List<IFlyoutMenuContributor> m_menuContributors =
      new ArrayList<IFlyoutMenuContributor>();

  ////////////////////////////////////////////////////////////////////////////
  //
  // Constructor
  //
  ////////////////////////////////////////////////////////////////////////////
  public FlyoutControlComposite(Composite parent, int style, IFlyoutPreferences preferences) {
    super(parent, style);
    m_preferences = preferences;
    // add listeners
    addListener(SWT.Resize, new Listener() {
      @Override
    public void handleEvent(Event event) {
        if (getShell().getMinimized()) {
          return;
        }
        layout();
      }
    });
    // create container for flyout control
    m_flyoutContainer = new FlyoutContainer(this, SWT.NO_BACKGROUND);
  }

  ////////////////////////////////////////////////////////////////////////////
  //
  // Parents
  //
  ////////////////////////////////////////////////////////////////////////////
  /**
   * @return the parent {@link Composite} for flyout {@link Control}.
   */
  public Composite getFlyoutParent() {
    return m_flyoutContainer;
  }

  /**
   * @return the parent {@link Composite} for client {@link Control}.
   */
  public Composite getClientParent() {
    return this;
  }

  /**
   * Sets the bit set with valid docking locations.
   */
  public void setValidDockLocations(int validDockLocations) {
    m_validDockLocations = validDockLocations;
  }

  ////////////////////////////////////////////////////////////////////////////
  //
  // Access
  //
  ////////////////////////////////////////////////////////////////////////////
  /**
   * Sets the minimal width of flyout.
   */
  public void setMinWidth(int minWidth) {
    m_minWidth = minWidth;
  }

  /**
   * Sets the text of title.
   */
  public void setTitleText(String text) {
    m_flyoutContainer.setTitleText(text);
  }

  /**
   * Adds new {@link IFlyoutMenuContributor}.
   */
  public void addMenuContributor(IFlyoutMenuContributor contributor) {
    if (!m_menuContributors.contains(contributor)) {
      m_menuContributors.add(contributor);
    }
  }

  ////////////////////////////////////////////////////////////////////////////
  //
  // Layout
  //
  ////////////////////////////////////////////////////////////////////////////
  @Override
  public void layout() {
    Rectangle clientArea = getClientArea();
    int state = m_preferences.getState();
    Control client = getChildren()[1];
    // check, may be "clientArea" is empty, for example because CTabFolder page is not visible
    if (clientArea.width == 0 || clientArea.height == 0) {
      return;
    }
    // check, maybe flyout has no Control, so "client" should fill client area
    if (m_flyoutContainer.getControl() == null
            // BEGIN ADT MODIFICATIONS
            || !m_flyoutContainer.getControl().getVisible()
            // END ADT MODIFICATIONS
            ) {
      m_flyoutContainer.setBounds(0, 0, 0, 0);
      client.setBounds(clientArea);
      return;
    }
    // prepare width to display
    int width;
    int offset;
    if (state == IFlyoutPreferences.STATE_OPEN) {
      width = m_preferences.getWidth();
      // limit maximum value
      if (isHorizontal()) {
        width = Math.min(clientArea.width / 2, width);
      } else {
        width = Math.min(clientArea.height / 2, width);
      }
      // limit minimum value
      width = Math.max(width, m_minWidth);
      width = Math.max(width, 2 * m_flyoutContainer.m_titleHeight + m_flyoutContainer.m_titleWidth);
      // remember actual width
      m_preferences.setWidth(width);
      //
      offset = width;
    } else if (state == IFlyoutPreferences.STATE_EXPANDED) {
      offset = m_flyoutContainer.m_titleHeight;
      width = m_preferences.getWidth();
    } else {
      width = m_flyoutContainer.m_titleHeight;
      offset = width;
    }
    // change bounds for flyout container and client control
    {
      if (isWest()) {
        m_flyoutContainer.setBounds(0, 0, width, clientArea.height);
        client.setBounds(offset, 0, clientArea.width - offset, clientArea.height);
      } else if (isEast()) {
        m_flyoutContainer.setBounds(clientArea.width - width, 0, width, clientArea.height);
        client.setBounds(0, 0, clientArea.width - offset, clientArea.height);
      } else if (isNorth()) {
        m_flyoutContainer.setBounds(0, 0, clientArea.width, width);
        client.setBounds(0, offset, clientArea.width, clientArea.height - offset);
      } else if (isSouth()) {
        m_flyoutContainer.setBounds(0, clientArea.height - width, clientArea.width, width);
        client.setBounds(0, 0, clientArea.width, clientArea.height - offset);
      }
    }
  }

  ////////////////////////////////////////////////////////////////////////////
  //
  // Internal utils
  //
  ////////////////////////////////////////////////////////////////////////////
  private boolean isHorizontal() {
    return isWest() || isEast();
  }

  private boolean isWest() {
    return getDockLocation() == IFlyoutPreferences.DOCK_WEST;
  }

  private boolean isEast() {
    return getDockLocation() == IFlyoutPreferences.DOCK_EAST;
  }

  private boolean isNorth() {
    return getDockLocation() == IFlyoutPreferences.DOCK_NORTH;
  }

  private boolean isSouth() {
    return getDockLocation() == IFlyoutPreferences.DOCK_SOUTH;
  }

  /**
   * @return <code>true</code> if given docking location is valid.
   */
  private boolean isValidDockLocation(int location) {
    return (location & m_validDockLocations) == location;
  }

  /**
   * @return current docking location.
   */
  private int getDockLocation() {
    return m_preferences.getDockLocation();
  }

  /**
   * Sets new docking location.
   */
  private void setDockLocation(int dockLocation) {
    m_preferences.setDockLocation(dockLocation);
    layout();
  }

  // BEGIN ADT MODIFICATIONS
  /**
   * Applies the given preferences into the preferences of this flyout
   * control. This does not cause any visual updates; call {@link #layout()}
   * to update the widget.
   *
   * @param preferences the preferences to apply
   */
  public void apply(IFlyoutPreferences preferences) {
    m_preferences.setDockLocation(preferences.getDockLocation());
    m_preferences.setState(preferences.getState());
    m_preferences.setWidth(preferences.getWidth());
  }

  /** If the flyout hover is showing, dismiss it */
  public void dismissHover() {
    if (m_flyoutContainer != null) {
      m_flyoutContainer.dismissHover();
    }
  }

  /** Sets a listener to be modified when windows are opened, collapsed and expanded */
  public void setListener(IFlyoutListener listener) {
    assert m_listener == null; // Only one listener supported
    m_listener = listener;
  }
  private IFlyoutListener m_listener;
  // END ADT MODIFICATIONS

  ////////////////////////////////////////////////////////////////////////////
  //
  // FlyoutContainer
  //
  ////////////////////////////////////////////////////////////////////////////
  /**
   * Container for flyout {@link Control}.
   *
   * @author scheglov_ke
   */
  private final class FlyoutContainer extends Composite {
    ////////////////////////////////////////////////////////////////////////////
    //
    // Container
    //
    ////////////////////////////////////////////////////////////////////////////
    public FlyoutContainer(Composite parent, int style) {
      super(parent, style);
      configureMenu();
      updateTitleImage("Flyout");
      // add listeners
      addListener(SWT.Dispose, new Listener() {
        @Override
        public void handleEvent(Event event) {
          if (m_titleImage != null) {
            m_titleImage.dispose();
            m_titleImageRotated.dispose();
            m_titleImage = null;
            m_titleImageRotated = null;
          }
          if (m_backImage != null) {
            m_backImage.dispose();
            m_backImage = null;
          }
        }
      });
      {
        Listener listener = new Listener() {
          @Override
        public void handleEvent(Event event) {
            layout();
          }
        };
        addListener(SWT.Move, listener);
        addListener(SWT.Resize, listener);
      }
      addListener(SWT.Paint, new Listener() {
        @Override
        public void handleEvent(Event event) {
          handlePaint(event.gc);
        }
      });
      // mouse listeners
      addMouseListener(new MouseAdapter() {
        @Override
        public void mouseDown(MouseEvent event) {
          if (event.button == 1) {
            handle_mouseDown(event);
          }
        }

        @Override
        public void mouseUp(MouseEvent event) {
          if (event.button == 1) {
            handle_mouseUp(event);
          }
        }
      });
      addMouseTrackListener(new MouseTrackAdapter() {
        @Override
        public void mouseExit(MouseEvent e) {
          m_stateHover = false;
          redraw();
          setCursor(null);
        }

        @Override
        public void mouseHover(MouseEvent e) {
          handle_mouseHover();
        }
      });
      addMouseMoveListener(new MouseMoveListener() {
        @Override
        public void mouseMove(MouseEvent event) {
          handle_mouseMove(event);
        }
      });
    }

    // BEGIN ADT MODIFICATIONS
    private void dismissHover() {
      int state = m_preferences.getState();
      if (state == IFlyoutPreferences.STATE_EXPANDED) {
        state = IFlyoutPreferences.STATE_COLLAPSED;
        m_preferences.setState(state);
        redraw();
        FlyoutControlComposite.this.layout();
        if (m_listener != null) {
            m_listener.stateChanged(IFlyoutPreferences.STATE_EXPANDED, state);
        }
      }
    }
    // END END MODIFICATIONS

    ////////////////////////////////////////////////////////////////////////////
    //
    // Events: mouse
    //
    ////////////////////////////////////////////////////////////////////////////
    private boolean m_resize;
    private boolean m_stateHover;

    /**
     * Handler for {@link SWT#MouseDown} event.
     */
    private void handle_mouseDown(MouseEvent event) {
      if (m_stateHover) {
        int state = m_preferences.getState();
        // BEGIN ADT MODIFICATIONS
        int oldState = state;
        // END ADT MODIFICATIONS
        if (state == IFlyoutPreferences.STATE_OPEN) {
          state = IFlyoutPreferences.STATE_COLLAPSED;
        } else {
          state = IFlyoutPreferences.STATE_OPEN;
        }
        m_preferences.setState(state);
        redraw();
        FlyoutControlComposite.this.layout();
        // BEGIN ADT MODIFICATIONS
        if (m_listener != null) {
          m_listener.stateChanged(oldState, state);
        }
        // END ADT MODIFICATIONS
      } else if (getCursor() == ICursorConstants.SIZEWE || getCursor() == ICursorConstants.SIZENS) {
        m_resize = true;
      } else if (getCursor() == ICursorConstants.SIZEALL) {
        handleDocking();
      }
    }

    /**
     * Handler for {@link SWT#MouseUp} event.
     */
    private void handle_mouseUp(MouseEvent event) {
      if (m_resize) {
        m_resize = false;
        handle_mouseMove(event);
      }
    }

    /**
     * Handler for {@link SWT#MouseMove} event.
     */
    private void handle_mouseMove(MouseEvent event) {
      final FlyoutControlComposite container = FlyoutControlComposite.this;
      if (m_resize) {
        // prepare width
        int width;
        if (isHorizontal()) {
          width = getSize().x;
        } else {
          width = getSize().y;
        }
        // prepare new width
        int newWidth = width;
        if (isWest()) {
          newWidth = event.x + RESIZE_WIDTH / 2;
        } else if (isEast()) {
          newWidth = width - event.x + RESIZE_WIDTH / 2;
        } else if (isNorth()) {
          newWidth = event.y + RESIZE_WIDTH / 2;
        } else if (isSouth()) {
          newWidth = width - event.y + RESIZE_WIDTH / 2;
        }
        // update width
        if (newWidth != width) {
          m_preferences.setWidth(newWidth);
          redraw();
          container.layout();
        }
      } else {
        Rectangle clientArea = getClientArea();
        boolean inside = clientArea.contains(event.x, event.y);
        int x = event.x;
        int y = event.y;
        if (inside) {
          // check for state
          {
            boolean oldStateHover = m_stateHover;
            if (isEast()) {
              m_stateHover = x > clientArea.width - m_titleHeight && y < m_titleHeight;
            } else {
              m_stateHover = x < m_titleHeight && y < m_titleHeight;
            }
            if (m_stateHover != oldStateHover) {
              redraw();
            }
            if (m_stateHover) {
              setCursor(null);
              return;
            }
          }
          // check for resize band
          if (isOpenExpanded()) {
            if (isWest() && x >= clientArea.width - RESIZE_WIDTH) {
              setCursor(ICursorConstants.SIZEWE);
            } else if (isEast() && x <= RESIZE_WIDTH) {
              setCursor(ICursorConstants.SIZEWE);
            } else if (isNorth() && y >= clientArea.height - RESIZE_WIDTH) {
              setCursor(ICursorConstants.SIZENS);
            } else if (isSouth() && y <= RESIZE_WIDTH) {
              setCursor(ICursorConstants.SIZENS);
            } else {
              setCursor(null);
            }
          }
          // check for docking
          if (getCursor() == null) {
            setCursor(ICursorConstants.SIZEALL);
          }
        } else {
          setCursor(null);
        }
      }
    }

    /**
     * Handler for {@link SWT#MouseHover} event - temporary expands flyout and collapse again when
     * mouse moves above client.
     */
    private void handle_mouseHover() {
      if (m_preferences.getState() == IFlyoutPreferences.STATE_COLLAPSED && !m_stateHover) {
        m_preferences.setState(IFlyoutPreferences.STATE_EXPANDED);
        //
        final FlyoutControlComposite container = FlyoutControlComposite.this;
        container.layout();
        // BEGIN ADT MODIFICATIONS
        if (m_listener != null) {
            m_listener.stateChanged(IFlyoutPreferences.STATE_COLLAPSED,
                    IFlyoutPreferences.STATE_EXPANDED);
        }
        // END ADT MODIFICATIONS
        // add listeners
        Listener listener = new Listener() {
          @Override
        public void handleEvent(Event event) {
            if (event.type == SWT.Dispose) {
              getDisplay().removeFilter(SWT.MouseMove, this);
            } else {
              Point p = ((Control) event.widget).toDisplay(event.x, event.y);
              // during resize mouse can be temporary outside of flyout - ignore
              if (m_resize) {
                return;
              }
              // mouse in in flyout container - ignore
              if (getClientArea().contains(toControl(p.x, p.y))) {
                return;
              }
              // mouse is in full container - collapse
              if (container.getClientArea().contains(container.toControl(p.x, p.y))) {
                getDisplay().removeFilter(SWT.MouseMove, this);
                // it is possible, that user restored (OPEN) flyout, so collapse only if we still in expand state
                if (m_preferences.getState() == IFlyoutPreferences.STATE_EXPANDED) {
                  m_preferences.setState(IFlyoutPreferences.STATE_COLLAPSED);
                  container.layout();
                  // BEGIN ADT MODIFICATIONS
                  if (m_listener != null) {
                      m_listener.stateChanged(IFlyoutPreferences.STATE_EXPANDED,
                              IFlyoutPreferences.STATE_COLLAPSED);
                  }
                  // END ADT MODIFICATIONS
                }
              }
            }
          }
        };
        addListener(SWT.Dispose, listener);
        getDisplay().addFilter(SWT.MouseMove, listener);
      }
    }

    /**
     * Handler for docking.
     */
    private void handleDocking() {
      final FlyoutControlComposite container = FlyoutControlComposite.this;
      final int width = m_preferences.getWidth();
      final int oldDockLocation = getDockLocation();
      final int[] newDockLocation = new int[]{oldDockLocation};
      final Tracker dockingTracker = new Tracker(container, SWT.NONE);
      dockingTracker.setRectangles(new Rectangle[]{getBounds()});
      dockingTracker.setStippled(true);
      dockingTracker.addListener(SWT.Move, new Listener() {
        @Override
        public void handleEvent(Event event2) {
          Rectangle clientArea = container.getClientArea();
          Point location = container.toControl(event2.x, event2.y);
          int h3 = clientArea.height / 3;
          // check locations
          if (location.y < h3 && isValidDockLocation(IFlyoutPreferences.DOCK_NORTH)) {
            dockingTracker.setRectangles(new Rectangle[]{new Rectangle(0,
                0,
                clientArea.width,
                width)});
            newDockLocation[0] = IFlyoutPreferences.DOCK_NORTH;
          } else if (location.y > 2 * h3 && isValidDockLocation(IFlyoutPreferences.DOCK_SOUTH)) {
            dockingTracker.setRectangles(new Rectangle[]{new Rectangle(0,
                clientArea.height - width,
                clientArea.width,
                width)});
            newDockLocation[0] = IFlyoutPreferences.DOCK_SOUTH;
          } else if (location.x < clientArea.width / 2
              && isValidDockLocation(IFlyoutPreferences.DOCK_WEST)) {
            dockingTracker.setRectangles(new Rectangle[]{new Rectangle(0,
                0,
                width,
                clientArea.height)});
            newDockLocation[0] = IFlyoutPreferences.DOCK_WEST;
          } else if (isValidDockLocation(IFlyoutPreferences.DOCK_EAST)) {
            dockingTracker.setRectangles(new Rectangle[]{new Rectangle(clientArea.width - width,
                0,
                width,
                clientArea.height)});
            newDockLocation[0] = IFlyoutPreferences.DOCK_EAST;
          } else {
            dockingTracker.setRectangles(new Rectangle[]{getBounds()});
            newDockLocation[0] = oldDockLocation;
          }
        }
      });
      // start tracking
      if (dockingTracker.open()) {
        setDockLocation(newDockLocation[0]);
      }
      // dispose tracker
      dockingTracker.dispose();
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Access
    //
    ////////////////////////////////////////////////////////////////////////////
    /**
     * @return the {@link Control} installed on this {@link FlyoutControlComposite}, or
     *         <code>null</code> if there are no any {@link Control}.
     */
    private Control getControl() {
      Control[] children = getChildren();
      return children.length == 1 ? children[0] : null;
    }

    /**
     * Sets the text of title.
     */
    public void setTitleText(String text) {
      updateTitleImage(text);
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Layout
    //
    ////////////////////////////////////////////////////////////////////////////
    @Override
    public void layout() {
      Control control = getControl();
      if (control == null) {
        return;
      }
      // OK, we have control, so can continue layout
      Rectangle clientArea = getClientArea();
      if (isOpenExpanded()) {
        if (isWest()) {
          int y = m_titleHeight;
          control.setBounds(0, y, clientArea.width - RESIZE_WIDTH, clientArea.height - y);
        } else if (isEast()) {
          int y = m_titleHeight;
          control.setBounds(RESIZE_WIDTH, y, clientArea.width - RESIZE_WIDTH, clientArea.height - y);
        } else if (isNorth()) {
          int y = m_titleHeight;
          control.setBounds(0, y, clientArea.width, clientArea.height - y - RESIZE_WIDTH);
        } else if (isSouth()) {
          int y = RESIZE_WIDTH + m_titleHeight;
          control.setBounds(0, y, clientArea.width, clientArea.height - y);
        }
      } else {
        control.setBounds(0, 0, 0, 0);
      }
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Paint
    //
    ////////////////////////////////////////////////////////////////////////////
    private Image m_backImage;

    /**
     * Handler for {@link SWT#Paint} event.
     */
    private void handlePaint(GC paintGC) {
      Rectangle clientArea = getClientArea();
      // prepare back image
      GC gc;
      {
        if (m_backImage == null || !m_backImage.getBounds().equals(clientArea)) {
          if (m_backImage != null) {
            m_backImage.dispose();
          }
          m_backImage = new Image(getDisplay(), clientArea.width, clientArea.height);
        }
        // prepare GC
        gc = new GC(m_backImage);
        gc.setBackground(paintGC.getBackground());
        gc.setForeground(paintGC.getForeground());
        gc.fillRectangle(clientArea);
      }
      //
      if (isOpenExpanded()) {
        // draw header
        {
          // draw title
          if (isWest()) {
            drawStateImage(gc, 0, 0);
            gc.drawImage(m_titleImage, m_titleHeight, 0);
          } else if (isEast()) {
            int x = clientArea.width - m_titleHeight;
            drawStateImage(gc, x, 0);
            gc.drawImage(m_titleImage, x - m_titleWidth, 0);
          } else if (isNorth()) {
            drawStateImage(gc, 0, 0);
            gc.drawImage(m_titleImage, m_titleHeight, 0);
          } else if (isSouth()) {
            int y = RESIZE_WIDTH;
            drawStateImage(gc, 0, y);
            gc.drawImage(m_titleImage, m_titleHeight, y);
          }
        }
        // draw resize band
        drawResizeBand(gc);
      } else {
        if (isHorizontal()) {
          drawStateImage(gc, 0, 0);
          gc.drawImage(m_titleImageRotated, 0, m_titleHeight);
        } else {
          drawStateImage(gc, 0, 0);
          gc.drawImage(m_titleImage, m_titleHeight, 0);
        }
        DrawUtils.drawHighlightRectangle(gc, 0, 0, clientArea.width, clientArea.height);
      }
      // flush back image
      {
        gc.dispose();
        paintGC.drawImage(m_backImage, 0, 0);
      }
    }

    /**
     * Draws the state image (arrow) at given location.
     */
    private void drawStateImage(GC gc, int x, int y) {
      DrawUtils.drawImageCHCV(gc, getStateImage(), x, y, m_titleHeight, m_titleHeight);
      if (m_stateHover) {
        DrawUtils.drawHighlightRectangle(gc, x, y, m_titleHeight, m_titleHeight);
      }
    }

    /**
     * @return the {@link Image} corresponding to current state (open or collapsed).
     */
    private Image getStateImage() {
      int location = getDockLocation();
      int state = m_preferences.getState();
      if (state == IFlyoutPreferences.STATE_OPEN) {
        switch (location) {
          case IFlyoutPreferences.DOCK_WEST :
            return ARROW_LEFT;
          case IFlyoutPreferences.DOCK_EAST :
            return ARROW_RIGHT;
          case IFlyoutPreferences.DOCK_NORTH :
            return ARROW_TOP;
          case IFlyoutPreferences.DOCK_SOUTH :
            return ARROW_BOTTOM;
        }
      } else if (state == IFlyoutPreferences.STATE_EXPANDED) {
        return PIN;
      } else {
        switch (location) {
          case IFlyoutPreferences.DOCK_WEST :
            return ARROW_RIGHT;
          case IFlyoutPreferences.DOCK_EAST :
            return ARROW_LEFT;
          case IFlyoutPreferences.DOCK_NORTH :
            return ARROW_BOTTOM;
          case IFlyoutPreferences.DOCK_SOUTH :
            return ARROW_TOP;
        }
      }
      //
      return null;
    }

    /**
     * Draws that resize band, {@link Sash} like.
     */
    private void drawResizeBand(GC gc) {
      Rectangle clientArea = getClientArea();
      // prepare locations
      int x, y, width, height;
      if (isHorizontal()) {
        if (isWest()) {
          x = clientArea.width - RESIZE_WIDTH;
        } else {
          x = 0;
        }
        y = 0;
        width = RESIZE_WIDTH;
        height = clientArea.height;
      } else {
        x = 0;
        if (isNorth()) {
          y = clientArea.height - RESIZE_WIDTH;
        } else {
          y = 0;
        }
        width = clientArea.width;
        height = RESIZE_WIDTH;
      }
      // draw band
      DrawUtils.drawHighlightRectangle(gc, x, y, width, height);
    }

    /**
     * @return <code>true</code> if flyout is open or expanded.
     */
    private boolean isOpenExpanded() {
      int state = m_preferences.getState();
      return state == IFlyoutPreferences.STATE_OPEN || state == IFlyoutPreferences.STATE_EXPANDED;
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Title image
    //
    ////////////////////////////////////////////////////////////////////////////
    private int m_titleWidth;
    private int m_titleHeight;
    private Image m_titleImage;
    private Image m_titleImageRotated;

    /**
     * Creates {@link Image} for given title text.
     */
    private void updateTitleImage(String text) {
      // prepare size of text
      Point textSize;
      {
        GC gc = new GC(this);
        gc.setFont(TITLE_FONT);
        textSize = gc.textExtent(text);
        gc.dispose();
      }
      // dispose existing image
      if (m_titleImage != null) {
        m_titleImage.dispose();
        m_titleImageRotated.dispose();
      }
      // prepare new image
      {
        m_titleWidth = textSize.x + 2 * TITLE_LINES + 4 * TITLE_MARGIN;
        m_titleHeight = textSize.y;
        m_titleImage = new Image(getDisplay(), m_titleWidth, m_titleHeight);
        GC gc = new GC(m_titleImage);
        try {
          gc.setBackground(getBackground());
          gc.fillRectangle(0, 0, m_titleWidth, m_titleHeight);
          int x = 0;
          // draw left lines
          {
            x += TITLE_MARGIN;
            drawTitleLines(gc, x, m_titleHeight, TITLE_LINES);
            x += TITLE_LINES + TITLE_MARGIN;
          }
          // draw text
          {
            gc.setForeground(IColorConstants.black);
            gc.setFont(TITLE_FONT);
            gc.drawText(text, x, 0);
            x += textSize.x;
          }
          // draw right lines
          {
            x += TITLE_MARGIN;
            drawTitleLines(gc, x, m_titleHeight, TITLE_LINES);
          }
        } finally {
          gc.dispose();
        }
      }
      // prepare rotated image
      m_titleImageRotated = DrawUtils.createRotatedImage(m_titleImage);
    }

    /**
     * Draws two title lines.
     */
    private void drawTitleLines(GC gc, int x, int height, int width) {
      drawTitleLine(gc, x, height / 3, width);
      drawTitleLine(gc, x, 2 * height / 3, width);
    }

    /**
     * Draws single title line.
     */
    private void drawTitleLine(GC gc, int x, int y, int width) {
      int right = x + TITLE_LINES;
      //
      gc.setForeground(IColorConstants.buttonLightest);
      gc.drawLine(x, y, right - 2, y);
      gc.drawLine(x, y + 1, right - 2, y + 1);
      //
      gc.setForeground(IColorConstants.buttonDarker);
      gc.drawLine(right - 2, y, right - 1, y);
      gc.drawLine(x + 2, y + 1, right - 2, y + 1);
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Menu
    //
    ////////////////////////////////////////////////////////////////////////////
    private void configureMenu() {
      final MenuManager manager = new MenuManager();
      manager.setRemoveAllWhenShown(true);
      manager.addMenuListener(new IMenuListener() {
        @Override
        public void menuAboutToShow(IMenuManager menuMgr) {
          addDockActions();
          for (IFlyoutMenuContributor contributor : m_menuContributors) {
            contributor.contribute(manager);
          }
        }

        private void addDockActions() {
          MenuManager dockManager = new MenuManager(Messages.FlyoutControlComposite_dockManager);
          addDockAction(
              dockManager,
              Messages.FlyoutControlComposite_dockLeft,
              IFlyoutPreferences.DOCK_WEST);
          addDockAction(
              dockManager,
              Messages.FlyoutControlComposite_dockRight,
              IFlyoutPreferences.DOCK_EAST);
          addDockAction(
              dockManager,
              Messages.FlyoutControlComposite_dockTop,
              IFlyoutPreferences.DOCK_NORTH);
          addDockAction(
              dockManager,
              Messages.FlyoutControlComposite_dockBottom,
              IFlyoutPreferences.DOCK_SOUTH);
          manager.add(dockManager);
        }

        private void addDockAction(MenuManager dockManager, String text, int location) {
          if ((m_validDockLocations & location) != 0) {
            dockManager.add(new DockAction(text, location));
          }
        }
      });
      // set menu
      setMenu(manager.createContextMenu(this));
      // dispose it later
      addDisposeListener(new DisposeListener() {
        @Override
        public void widgetDisposed(DisposeEvent e) {
          manager.dispose();
        }
      });
    }
  }
  ////////////////////////////////////////////////////////////////////////////
  //
  // DockAction
  //
  ////////////////////////////////////////////////////////////////////////////
  private class DockAction extends Action {
    private final int m_location;

    ////////////////////////////////////////////////////////////////////////////
    //
    // Constructor
    //
    ////////////////////////////////////////////////////////////////////////////
    public DockAction(String text, int location) {
      super(text, AS_RADIO_BUTTON);
      m_location = location;
    }

    ////////////////////////////////////////////////////////////////////////////
    //
    // Action
    //
    ////////////////////////////////////////////////////////////////////////////
    @Override
    public boolean isChecked() {
      return getDockLocation() == m_location;
    }

    @Override
    public void run() {
      setDockLocation(m_location);
    }
  }
}