* Copyright (c) 2008, Swedish Institute of Computer Science.

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

*    notice, this list of conditions and the following disclaimer.

* 2. Redistributions in binary form must reproduce the above copyright

*    notice, this list of conditions and the following disclaimer in the

*    documentation and/or other materials provided with the distribution.

* 3. Neither the name of the Institute nor the names of its contributors

*    may be used to endorse or promote products derived from this software

*    without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND

* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE

* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

* SUCH DAMAGE.

*

*/

* The class AreaViewer belongs to the MRM package.

*

* It is used to visualize available radios, traffic between them as well

* as the current radio propagation area of single radios.

* Users may also add background images (such as maps) and color-analyze them

* in order to add simulated obstacles in the radio medium.

*

* For more information about MRM see MRM.java

*

* @see MRM

* @author Fredrik Osterlind

*/

  private static final long serialVersionUID = 1L;

  private static Logger logger = Logger.getLogger(AreaViewer.class);

  private final JPanel canvas;

  ChannelModel.TransmissionData dataTypeToVisualize = ChannelModel.TransmissionData.SIGNAL_STRENGTH;

  ButtonGroup visTypeSelectionGroup;

  // General drawing parameters

  private Point lastHandledPosition = new Point(0,0);

  private double zoomCenterX = 0.0;

  private double zoomCenterY = 0.0;

  private Point zoomCenterPoint = new Point();

  private double currentZoomX = 1.0f;

  private double currentZoomY = 1.0f;

  private double currentPanX = 0.0f;

  private double currentPanY = 0.0f;

  private boolean drawBackgroundImage = true;

  private boolean drawCalculatedObstacles = true;

  private boolean drawChannelProbabilities = true;

  private boolean drawRadios = true;

  //private boolean drawRadioActivity = true;

  private boolean drawScaleArrow = true;

  // Background drawing parameters (meters)

  private double backgroundStartX = 0.0;

  private double backgroundStartY = 0.0;

  private double backgroundWidth = 0.0;

  private double backgroundHeight = 0.0;

  private Image backgroundImage = null;

  private File backgroundImageFile = null;

  // Obstacle drawing parameters (same scale as background)

  private boolean needToRepaintObstacleImage = false;

  private double obstacleStartX = 0.0;

  private double obstacleStartY = 0.0;

  private double obstacleWidth = 0.0;

  private double obstacleHeight = 0.0;

  private Image obstacleImage = null;

  // Channel probabilities drawing parameters (meters)

  private double channelStartX = 0.0;

  private double channelStartY = 0.0;

  private double channelWidth = 0.0;

  private double channelHeight = 0.0;

  private Image channelImage = null;

  private JSlider resolutionSlider;

  private Box controlPanel;

  private JScrollPane scrollControlPanel;

  private Simulation currentSimulation;

  private MRM currentRadioMedium;

  private ChannelModel currentChannelModel;

  private final String antennaImageFilename = "antenna.png";

  private final Image antennaImage;

  private Radio selectedRadio = null;

  private boolean inSelectMode = true;

  private boolean inTrackMode = false;

  private ChannelModel.TrackedSignalComponents trackedComponents = null;

  // Coloring variables

  private JPanel coloringIntervalPanel = null;

  private double coloringHighest = 0;

  private double coloringLowest = 0;

  private boolean coloringIsFixed = true;

  private Thread attenuatorThread = null;

  private JCheckBox showSettingsBox;

  private JCheckBox backgroundCheckBox;

  private JCheckBox obstaclesCheckBox;

  private JCheckBox channelCheckBox;

  private JCheckBox radiosCheckBox;

  private JCheckBox arrowCheckBox;

  private JRadioButton noneButton = null;

  private JRadioButton selectModeButton;

  private JRadioButton panModeButton;

  private JRadioButton zoomModeButton;

  private JRadioButton trackModeButton;

  private Action paintEnvironmentAction;

  /**

   * Initializes an AreaViewer.

   *

   * @param simulationToVisualize Simulation using MRM

   */

  public AreaViewer(Simulation simulationToVisualize, Cooja gui) {

    super("MRM Radio environment", gui);

    currentSimulation = simulationToVisualize;

    currentRadioMedium = (MRM) currentSimulation.getRadioMedium();

    currentChannelModel = currentRadioMedium.getChannelModel();

    // We want to listen to changes both in the channel model as well as in the radio medium

    currentChannelModel.addSettingsObserver(channelModelSettingsObserver);

    currentRadioMedium.addSettingsObserver(radioMediumSettingsObserver);

    currentRadioMedium.addRadioMediumObserver(radioMediumActivityObserver);

    // Set initial size etc.

    setSize(500, 500);

    setVisible(true);

    // Canvas mode radio buttons + show settings checkbox

    showSettingsBox = new JCheckBox ("settings", true);

    showSettingsBox.setAlignmentY(Component.TOP_ALIGNMENT);

    showSettingsBox.setContentAreaFilled(false);

    showSettingsBox.setActionCommand("toggle show settings");

    showSettingsBox.addActionListener(canvasModeHandler);

    selectModeButton = new JRadioButton ("select");

    selectModeButton.setAlignmentY(Component.BOTTOM_ALIGNMENT);

    selectModeButton.setContentAreaFilled(false);

    selectModeButton.setActionCommand("set select mode");

    selectModeButton.addActionListener(canvasModeHandler);

    selectModeButton.setSelected(true);

    panModeButton = new JRadioButton ("pan");

    panModeButton.setAlignmentY(Component.BOTTOM_ALIGNMENT);

    panModeButton.setContentAreaFilled(false);

    panModeButton.setActionCommand("set pan mode");

    panModeButton.addActionListener(canvasModeHandler);

    zoomModeButton = new JRadioButton ("zoom");

    zoomModeButton.setAlignmentY(Component.BOTTOM_ALIGNMENT);

    zoomModeButton.setContentAreaFilled(false);

    zoomModeButton.setActionCommand("set zoom mode");

    zoomModeButton.addActionListener(canvasModeHandler);

    trackModeButton = new JRadioButton ("track rays");

    trackModeButton.setAlignmentY(Component.BOTTOM_ALIGNMENT);

    trackModeButton.setContentAreaFilled(false);

    trackModeButton.setActionCommand("set track rays mode");

    trackModeButton.addActionListener(canvasModeHandler);

    trackModeButton.setEnabled(false);

    ButtonGroup group = new ButtonGroup();

    group.add(selectModeButton);

    group.add(panModeButton);

    group.add(zoomModeButton);

    group.add(trackModeButton);

    // Create canvas

    canvas = new JPanel() {

      private static final long serialVersionUID = 1L;

      public void paintComponent(Graphics g) {

        super.paintComponent(g);

        repaintCanvas((Graphics2D) g);

      }

    };

    canvas.setBorder(BorderFactory.createLineBorder(Color.BLACK));

    canvas.setBackground(Color.WHITE);

    canvas.setLayout(new BorderLayout());

    canvas.addMouseListener(canvasMouseHandler);

    // Create canvas mode panel

    JPanel canvasModePanel = new JPanel();

    canvasModePanel.setOpaque(false);

    canvasModePanel.setLayout(new BoxLayout(canvasModePanel, BoxLayout.Y_AXIS));

    canvasModePanel.setAlignmentY(Component.BOTTOM_ALIGNMENT);

    canvasModePanel.add(showSettingsBox);

    canvasModePanel.add(Box.createVerticalGlue());

    canvasModePanel.add(selectModeButton);

    canvasModePanel.add(panModeButton);

    canvasModePanel.add(zoomModeButton);

    canvasModePanel.add(trackModeButton);

    canvas.add(BorderLayout.EAST, canvasModePanel);

    // Create control graphics panel

    JPanel graphicsComponentsPanel = new JPanel();

    graphicsComponentsPanel.setLayout(new BoxLayout(graphicsComponentsPanel, BoxLayout.Y_AXIS));

    graphicsComponentsPanel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

    graphicsComponentsPanel.setAlignmentX(Component.CENTER_ALIGNMENT);

    graphicsComponentsPanel.add(new JLabel("Show/Hide:"));

    backgroundCheckBox = new JCheckBox("Background image", true);

    backgroundCheckBox.setActionCommand("toggle background");

    backgroundCheckBox.addActionListener(selectGraphicsHandler);

    graphicsComponentsPanel.add(backgroundCheckBox);

    obstaclesCheckBox = new JCheckBox("Obstacles", true);

    obstaclesCheckBox.setActionCommand("toggle obstacles");

    obstaclesCheckBox.addActionListener(selectGraphicsHandler);

    graphicsComponentsPanel.add(obstaclesCheckBox);

    channelCheckBox = new JCheckBox("Channel", true);

    channelCheckBox.setActionCommand("toggle channel");

    channelCheckBox.addActionListener(selectGraphicsHandler);

    graphicsComponentsPanel.add(channelCheckBox);

    radiosCheckBox = new JCheckBox("Radios", true);

    radiosCheckBox.setActionCommand("toggle radios");

    radiosCheckBox.addActionListener(selectGraphicsHandler);

    graphicsComponentsPanel.add(radiosCheckBox);

//    radioActivityCheckBox.setActionCommand("toggle radio activity");

//    radioActivityCheckBox.addActionListener(selectGraphicsHandler);

//    graphicsComponentsPanel.add(radioActivityCheckBox);

    arrowCheckBox = new JCheckBox("Scale arrow", true);

    arrowCheckBox.setActionCommand("toggle arrow");

    arrowCheckBox.addActionListener(selectGraphicsHandler);

    graphicsComponentsPanel.add(arrowCheckBox);

    graphicsComponentsPanel.add(Box.createRigidArea(new Dimension(0,20)));

    graphicsComponentsPanel.add(new JLabel("Obstacle configuration:"));

    noneButton = new JRadioButton("No obstacles");

    noneButton.setActionCommand("set no obstacles");

    noneButton.addActionListener(obstacleHandler);

    noneButton.setSelected(true);

    JRadioButton pre1Button = new JRadioButton("Predefined 1");

    pre1Button.setActionCommand("set predefined 1");

    pre1Button.addActionListener(obstacleHandler);

    JRadioButton pre2Button = new JRadioButton("Predefined 2");

    pre2Button.setActionCommand("set predefined 2");

    pre2Button.addActionListener(obstacleHandler);

    JRadioButton customButton = new JRadioButton("From bitmap");

    customButton.setActionCommand("set custom bitmap");

    customButton.addActionListener(obstacleHandler);

    if (Cooja.isVisualizedInApplet()) {

      customButton.setEnabled(false);

    }

    group = new ButtonGroup();

    group.add(noneButton);

    group.add(pre1Button);

    group.add(pre2Button);

    group.add(customButton);

    graphicsComponentsPanel.add(noneButton);

    graphicsComponentsPanel.add(pre1Button);

    graphicsComponentsPanel.add(pre2Button);

    graphicsComponentsPanel.add(customButton);

    // Create visualize channel output panel

    Box visualizeChannelPanel = Box.createVerticalBox();

    visualizeChannelPanel.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

    visualizeChannelPanel.setAlignmentX(Component.LEFT_ALIGNMENT);

    // Channel coloring intervals

    visualizeChannelPanel.add(new JLabel("Channel coloring:"));

    JPanel fixedVsRelative = new JPanel(new GridLayout(1, 2));

    JRadioButton fixedColoringButton = new JRadioButton("Fixed");

    fixedColoringButton.setSelected(true);

    fixedColoringButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        coloringIsFixed = true;

      }

    });

    fixedVsRelative.add(fixedColoringButton);

    JRadioButton relativeColoringButton = new JRadioButton("Relative");

    relativeColoringButton.setSelected(true);

    relativeColoringButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        coloringIsFixed = false;

      }

    });

    fixedVsRelative.add(relativeColoringButton);

    ButtonGroup coloringGroup = new ButtonGroup();

    coloringGroup.add(fixedColoringButton);

    coloringGroup.add(relativeColoringButton);

    fixedVsRelative.setAlignmentX(Component.LEFT_ALIGNMENT);

    visualizeChannelPanel.add(fixedVsRelative);

    coloringIntervalPanel = new JPanel() {

      private static final long serialVersionUID = 8247374386307237940L;

      public void paintComponent(Graphics g) {

        super.paintComponent(g);

        int width = getWidth();

        int height = getHeight();

        double diff = coloringHighest - coloringLowest;

        int textHeight = g.getFontMetrics().getHeight();

        // If computing

        if (attenuatorThread != null && attenuatorThread.isAlive()) {

          g.setColor(Color.WHITE);

          g.fillRect(0, 0, width, height);

          g.setColor(Color.BLACK);

          String stringToDraw = "[calculating]";

          g.drawString(stringToDraw, width/2 - g.getFontMetrics().stringWidth(stringToDraw)/2, height/2 + textHeight/2);

          return;

        }

        // Check for infinite values

        if (Double.isInfinite(coloringHighest) || Double.isInfinite(coloringLowest)) {

          g.setColor(Color.WHITE);

          g.fillRect(0, 0, width, height);

          g.setColor(Color.BLACK);

          String stringToDraw = "INFINITE VALUES EXIST";

          g.drawString(stringToDraw, width/2 - g.getFontMetrics().stringWidth(stringToDraw)/2, height/2 + textHeight/2);

          return;

        }

        // Check if values are constant

        if (diff == 0) {

          g.setColor(Color.WHITE);

          g.fillRect(0, 0, width, height);

          g.setColor(Color.BLACK);

          NumberFormat formatter = DecimalFormat.getNumberInstance();

          String stringToDraw = "CONSTANT VALUES (" + formatter.format(coloringHighest) + ")";

          g.drawString(stringToDraw, width/2 - g.getFontMetrics().stringWidth(stringToDraw)/2, height/2 + textHeight/2);

          return;

        }

        for (int i=0; i < width; i++) {

          double paintValue = coloringLowest + (double) i / (double) width * diff;

          g.setColor(

              new Color(

                  getColorOfSignalStrength(paintValue, coloringLowest, coloringHighest)));

          g.drawLine(i, 0, i, height);

        }

        if (dataTypeToVisualize == ChannelModel.TransmissionData.PROB_OF_RECEPTION) {

          NumberFormat formatter = DecimalFormat.getPercentInstance();

          g.setColor(Color.BLACK);

          g.drawString(formatter.format(coloringLowest), 3, textHeight);

          String stringToDraw = formatter.format(coloringHighest);

          g.drawString(stringToDraw, width - g.getFontMetrics().stringWidth(stringToDraw) - 3, textHeight);

        } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH ||

            dataTypeToVisualize == ChannelModel.TransmissionData.SIGNAL_STRENGTH_VAR ) {

          NumberFormat formatter = DecimalFormat.getNumberInstance();

          g.setColor(Color.BLACK);

          g.drawString(formatter.format(coloringLowest) + "dBm", 3, textHeight);

          String stringToDraw = formatter.format(coloringHighest) + "dBm";

          g.drawString(stringToDraw, width - g.getFontMetrics().stringWidth(stringToDraw) - 3, textHeight);

        } else if (dataTypeToVisualize == ChannelModel.TransmissionData.SNR ||

            dataTypeToVisualize == ChannelModel.TransmissionData.SNR_VAR) {

          NumberFormat formatter = DecimalFormat.getNumberInstance();

          g.setColor(Color.BLACK);

          g.drawString(formatter.format(coloringLowest) + "dB", 3, textHeight);

          String stringToDraw = formatter.format(coloringHighest) + "dB";

          g.drawString(stringToDraw, width - g.getFontMetrics().stringWidth(stringToDraw) - 3, textHeight);

        } else if (dataTypeToVisualize == ChannelModel.TransmissionData.DELAY_SPREAD_RMS) {

          NumberFormat formatter = DecimalFormat.getNumberInstance();

          g.setColor(Color.BLACK);

          g.drawString(formatter.format(coloringLowest) + "us", 3, textHeight);

          String stringToDraw = formatter.format(coloringHighest) + "us";

          g.drawString(stringToDraw, width - g.getFontMetrics().stringWidth(stringToDraw) - 3, textHeight);

        }

      }

    };

    coloringIntervalPanel.setBorder(BorderFactory.createLineBorder(Color.BLACK));

    Dimension colorPanelSize = new Dimension(200, 20);

    coloringIntervalPanel.setPreferredSize(colorPanelSize);

    coloringIntervalPanel.setMinimumSize(colorPanelSize);

    coloringIntervalPanel.setMaximumSize(colorPanelSize);

    coloringIntervalPanel.setAlignmentX(Component.LEFT_ALIGNMENT);

    visualizeChannelPanel.add(coloringIntervalPanel);

    // Choose channel output to visualize

    visualizeChannelPanel.add(Box.createRigidArea(new Dimension(0,20)));

    visualizeChannelPanel.add(new JLabel("Visualize:"));

    JRadioButton signalStrengthButton = new JRadioButton("Signal strength");

    signalStrengthButton.setActionCommand("signalStrengthButton");

    signalStrengthButton.setSelected(true);

    signalStrengthButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.SIGNAL_STRENGTH;

      }

    });

    visualizeChannelPanel.add(signalStrengthButton);

    JRadioButton signalStrengthVarButton = new JRadioButton("Signal strength variance");

    signalStrengthVarButton.setActionCommand("signalStrengthVarButton");

    signalStrengthVarButton.setSelected(false);

    signalStrengthVarButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.SIGNAL_STRENGTH_VAR;

      }

    });

    visualizeChannelPanel.add(signalStrengthVarButton);

    JRadioButton SNRButton = new JRadioButton("Signal to Noise ratio");

    SNRButton.setActionCommand("SNRButton");

    SNRButton.setSelected(false);

    SNRButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.SNR;

      }

    });

    visualizeChannelPanel.add(SNRButton);

    JRadioButton SNRVarButton = new JRadioButton("Signal to Noise variance");

    SNRVarButton.setActionCommand("SNRVarButton");

    SNRVarButton.setSelected(false);

    SNRVarButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.SNR_VAR;

      }

    });

    visualizeChannelPanel.add(SNRVarButton);

    JRadioButton probabilityButton = new JRadioButton("Probability of reception");

    probabilityButton.setActionCommand("probabilityButton");

    probabilityButton.setSelected(false);

    probabilityButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.PROB_OF_RECEPTION;

      }

    });

    visualizeChannelPanel.add(probabilityButton);

    JRadioButton rmsDelaySpreadButton = new JRadioButton("RMS delay spread");

    rmsDelaySpreadButton.setActionCommand("rmsDelaySpreadButton");

    rmsDelaySpreadButton.setSelected(false);

    rmsDelaySpreadButton.addActionListener(new ActionListener() {

      public void actionPerformed(ActionEvent e) {

        dataTypeToVisualize = ChannelModel.TransmissionData.DELAY_SPREAD_RMS;

      }

    });

    visualizeChannelPanel.add(rmsDelaySpreadButton);

    visTypeSelectionGroup = new ButtonGroup();

    visTypeSelectionGroup.add(signalStrengthButton);

    visTypeSelectionGroup.add(signalStrengthVarButton);

    visTypeSelectionGroup.add(SNRButton);

    visTypeSelectionGroup.add(SNRVarButton);

    visTypeSelectionGroup.add(probabilityButton);

    visTypeSelectionGroup.add(rmsDelaySpreadButton);

    visualizeChannelPanel.add(Box.createRigidArea(new Dimension(0,20)));

    visualizeChannelPanel.add(new JLabel("Resolution:"));

    resolutionSlider = new JSlider(JSlider.HORIZONTAL, 30, 600, 100);

    resolutionSlider.setMajorTickSpacing(100);

    resolutionSlider.setPaintTicks(true);

    resolutionSlider.setPaintLabels(true);

    resolutionSlider.setAlignmentX(Component.LEFT_ALIGNMENT);

    visualizeChannelPanel.add(resolutionSlider);

    visualizeChannelPanel.add(Box.createRigidArea(new Dimension(0,20)));

    JButton recalculateVisibleButton = new JButton("Paint radio channel");

    paintEnvironmentAction = new AbstractAction("Paint radio channel") {

      private static final long serialVersionUID = 1L;

      public void actionPerformed(ActionEvent e) {

        repaintRadioEnvironment();

      }

    };

    paintEnvironmentAction.setEnabled(false);

    recalculateVisibleButton.setAction(paintEnvironmentAction);

    visualizeChannelPanel.add(recalculateVisibleButton);

    // Create control panel

    controlPanel = Box.createVerticalBox();

    graphicsComponentsPanel.setAlignmentX(Component.LEFT_ALIGNMENT);

    controlPanel.add(graphicsComponentsPanel);

    controlPanel.add(new JSeparator());

    controlPanel.add(visualizeChannelPanel);

    controlPanel.setAlignmentX(Component.LEFT_ALIGNMENT);

    scrollControlPanel = new JScrollPane(

        controlPanel,

        JScrollPane.VERTICAL_SCROLLBAR_ALWAYS,

        JScrollPane.HORIZONTAL_SCROLLBAR_NEVER);

    scrollControlPanel.setPreferredSize(new Dimension(250,0));

    // Add everything

    this.setLayout(new BorderLayout());

    this.add(BorderLayout.CENTER, canvas); // Add canvas

    this.add(BorderLayout.EAST, scrollControlPanel);

    // Load external images (antenna)

    Toolkit toolkit = Toolkit.getDefaultToolkit();

    URL imageURL = this.getClass().getClassLoader().getResource(antennaImageFilename);

    antennaImage = toolkit.getImage(imageURL);

    MediaTracker tracker = new MediaTracker(canvas);

    tracker.addImage(antennaImage, 1);

    try {

      tracker.waitForAll();

    } catch (InterruptedException ex) {

      logger.fatal("Interrupted during image loading, aborting");

      return;

    }

    // Try to select current plugin

    try {

      setSelected(true);

    } catch (java.beans.PropertyVetoException e) {

      // Could not select

    }

  }

  /**

   * Listens to mouse event on canvas

   */

  private MouseAdapter canvasMouseHandler = new MouseAdapter() {

    private Popup popUpToolTip = null;

    private boolean temporaryZoom = false;

    private boolean temporaryPan = false;

    private boolean trackedPreviously = false;

    public void mouseReleased(MouseEvent e) {

      if (temporaryZoom) {

        temporaryZoom = false;

        if (trackedPreviously) {

          trackModeButton.doClick();

        } else {

          selectModeButton.doClick();

        }

      }

      if (temporaryPan) {

        temporaryPan = false;

        if (trackedPreviously) {

          trackModeButton.doClick();

        } else {

          selectModeButton.doClick();

        }

      }

      if (popUpToolTip != null) {

        popUpToolTip.hide();

        popUpToolTip = null;

      }

    }

    public void mousePressed(final MouseEvent e) {

      if (e.isControlDown()) {

        temporaryZoom = true;

        trackedPreviously = inTrackMode;

        zoomModeButton.doClick();

      }

      if (e.isAltDown()) {

        temporaryPan = true;

        trackedPreviously = inTrackMode;

        panModeButton.doClick();

        //canvasModeHandler.actionPerformed(new ActionEvent(e, 0, "set zoom mode"));

      }

      if (popUpToolTip != null) {

        popUpToolTip.hide();

        popUpToolTip = null;

      }

      /* Zoom & Pan */

      lastHandledPosition = new Point(e.getX(), e.getY());