Exemplo n.º 1
0
  /**
   * Sets the model's {@code valueIsAdjusting} property. Slider look and feel implementations should
   * set this property to {@code true} when a knob drag begins, and to {@code false} when the drag
   * ends.
   *
   * @param b the new value for the {@code valueIsAdjusting} property
   * @see #getValueIsAdjusting
   * @see BoundedRangeModel#setValueIsAdjusting
   * @beaninfo expert: true description: True if the slider knob is being dragged.
   */
  public void setValueIsAdjusting(boolean b) {
    BoundedRangeModel m = getModel();
    boolean oldValue = m.getValueIsAdjusting();
    m.setValueIsAdjusting(b);

    if ((oldValue != b) && (accessibleContext != null)) {
      accessibleContext.firePropertyChange(
          AccessibleContext.ACCESSIBLE_STATE_PROPERTY,
          ((oldValue) ? AccessibleState.BUSY : null),
          ((b) ? AccessibleState.BUSY : null));
    }
  }
Exemplo n.º 2
0
 private void updateScrolling() {
   if (myScrollingEnabled) {
     myBoundedRangeModel.setRangeProperties(
         0,
         myTermSize.height,
         -myTerminalTextBuffer.getHistoryBuffer().getLineCount(),
         myTermSize.height,
         false);
   } else {
     myBoundedRangeModel.setRangeProperties(0, myTermSize.height, 0, myTermSize.height, false);
   }
 }
  /**
   * This determines the amount of the progress bar that should be filled based on the percent done
   * gathered from the model. This is a common operation so it was abstracted out. It assumes that
   * your progress bar is linear. That is, if you are making a circular progress indicator, you will
   * want to override this method.
   */
  protected int getAmountFull(Insets b, int width, int height) {
    int amountFull = 0;
    BoundedRangeModel model = progressBar.getModel();

    if ((model.getMaximum() - model.getMinimum()) != 0) {
      if (progressBar.getOrientation() == JProgressBar.HORIZONTAL) {
        amountFull = (int) Math.round(width * progressBar.getPercentComplete());
      } else {
        amountFull = (int) Math.round(height * progressBar.getPercentComplete());
      }
    }
    return amountFull;
  }
Exemplo n.º 4
0
  /**
   * Sets the slider's current value to {@code n}. This method forwards the new value to the model.
   *
   * <p>The data model (an instance of {@code BoundedRangeModel}) handles any mathematical issues
   * arising from assigning faulty values. See the {@code BoundedRangeModel} documentation for
   * details.
   *
   * <p>If the new value is different from the previous value, all change listeners are notified.
   *
   * @param n the new value
   * @see #getValue
   * @see #addChangeListener
   * @see BoundedRangeModel#setValue
   * @beaninfo preferred: true description: The sliders current value.
   */
  public void setValue(int n) {
    BoundedRangeModel m = getModel();
    int oldValue = m.getValue();
    if (oldValue == n) {
      return;
    }
    m.setValue(n);

    if (accessibleContext != null) {
      accessibleContext.firePropertyChange(
          AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
          Integer.valueOf(oldValue),
          Integer.valueOf(m.getValue()));
    }
  }
 public synchronized void setPlayer(Player player) {
   if (this.player != null) {
     this.player.removeChangeListener(this);
     player.removePropertyChangeListener(this);
   }
   this.player = player;
   //        boundedRangeModel = player == null ? null : player.getBoundedRangeModel();
   boundedRangeModel = player == null ? null : player.getTimeModel();
   slider.setModel(boundedRangeModel);
   if (player != null) {
     if (player.getState() >= Player.REALIZED
         && boundedRangeModel != null
         && boundedRangeModel.getMaximum() == 0) {
       setPlayerControlsVisible(false);
     }
     slider.setProgressModel(player.getCachingModel());
     startButton.setSelected(player.isActive());
     player.addChangeListener(this);
     player.addPropertyChangeListener(this);
     audioButton.setVisible(player.isAudioAvailable());
     audioButton.setSelected(player.isAudioEnabled());
     colorCyclingButton.setVisible(
         (player instanceof ColorCyclePlayer)
             ? ((ColorCyclePlayer) player).isColorCyclingAvailable()
             : false);
     colorCyclingButton.setSelected(
         (player instanceof ColorCyclePlayer)
             ? ((ColorCyclePlayer) player).isColorCyclingStarted()
             : false);
     validate();
     repaint();
     BoundedRangeModel cachingControlModel = slider.getProgressModel();
   }
 }
    // ChangeListener
    public void stateChanged(ChangeEvent e) {
      BoundedRangeModel model = progressBar.getModel();
      int newRange = model.getMaximum() - model.getMinimum();
      int newPercent;
      int oldPercent = getCachedPercent();

      if (newRange > 0) {
        newPercent = (int) ((100 * (long) model.getValue()) / newRange);
      } else {
        newPercent = 0;
      }

      if (newPercent != oldPercent) {
        setCachedPercent(newPercent);
        progressBar.repaint();
      }
    }
  public void actionPerformed(ActionEvent event) {
    Object source = event.getSource();
    if (boundedRangeModel != null) {
      int value = boundedRangeModel.getValue();
      if (source == forwardButton) {
        boundedRangeModel.setValue(
            value == boundedRangeModel.getMaximum() ? boundedRangeModel.getMinimum() : value + 1);
      } else if (source == rewindButton) {
        boundedRangeModel.setValue(
            value == boundedRangeModel.getMinimum() ? boundedRangeModel.getMaximum() : value - 1);
      } else if (source == startButton) {
        if (startButton.isSelected() != player.isActive()) {
          if (startButton.isSelected()) {
            player.start();
          } else {
            player.stop();
          }
        }
      } else if (source == audioButton) {

        player.setAudioEnabled(audioButton.isSelected());
      } else if (source == colorCyclingButton) {
        if (player instanceof ColorCyclePlayer) {
          ((ColorCyclePlayer) player).setColorCyclingStarted(colorCyclingButton.isSelected());
        }
      }
    }
  }
Exemplo n.º 8
0
 /**
  * Update the visibility model with the associated JTextField (if there is one) to reflect the
  * current visibility as a result of changes to the document model. The bounded range properties
  * are updated. If the view hasn't yet been shown the extent will be zero and we just set it to be
  * full until determined otherwise.
  */
 void updateVisibilityModel() {
   Component c = getContainer();
   if (c instanceof JTextField) {
     JTextField field = (JTextField) c;
     BoundedRangeModel vis = field.getHorizontalVisibility();
     int hspan = (int) getPreferredSpan(X_AXIS);
     int extent = vis.getExtent();
     int maximum = Math.max(hspan, extent);
     extent = (extent == 0) ? maximum : extent;
     int value = maximum - extent;
     int oldValue = vis.getValue();
     if ((oldValue + extent) > maximum) {
       oldValue = maximum - extent;
     }
     value = Math.max(0, Math.min(value, oldValue));
     vis.setRangeProperties(value, extent, 0, maximum, false);
   }
 }
Exemplo n.º 9
0
  /**
   * Sets the {@code BoundedRangeModel} that handles the slider's three fundamental properties:
   * minimum, maximum, value.
   *
   * <p>Attempts to pass a {@code null} model to this method result in undefined behavior, and, most
   * likely, exceptions.
   *
   * @param newModel the new, {@code non-null} <code>BoundedRangeModel</code> to use
   * @see #getModel
   * @see BoundedRangeModel
   * @beaninfo bound: true description: The sliders BoundedRangeModel.
   */
  public void setModel(BoundedRangeModel newModel) {
    BoundedRangeModel oldModel = getModel();

    if (oldModel != null) {
      oldModel.removeChangeListener(changeListener);
    }

    sliderModel = newModel;

    if (newModel != null) {
      newModel.addChangeListener(changeListener);
    }

    if (accessibleContext != null) {
      accessibleContext.firePropertyChange(
          AccessibleContext.ACCESSIBLE_VALUE_PROPERTY,
          (oldModel == null ? null : Integer.valueOf(oldModel.getValue())),
          (newModel == null ? null : Integer.valueOf(newModel.getValue())));
    }

    firePropertyChange("model", oldModel, sliderModel);
  }
Exemplo n.º 10
0
  private void clearBuffer() {
    if (!myTerminalTextBuffer.isUsingAlternateBuffer()) {
      myTerminalTextBuffer.clearHistory();

      if (myCoordsAccessor != null && myCoordsAccessor.getY() > 0) {
        TerminalLine line = myTerminalTextBuffer.getLine(myCoordsAccessor.getY() - 1);

        myTerminalTextBuffer.clearAll();

        myCoordsAccessor.setY(0);
        myCursor.setY(1);
        myTerminalTextBuffer.addLine(line);
      }

      updateScrolling();

      myClientScrollOrigin = myBoundedRangeModel.getValue();
    }
  }
Exemplo n.º 11
0
 private void moveScrollBar(int k) {
   myBoundedRangeModel.setValue(myBoundedRangeModel.getValue() + k);
 }
Exemplo n.º 12
0
 private void scrollToBottom() {
   myBoundedRangeModel.setValue(myTermSize.height);
 }
Exemplo n.º 13
0
  public void init() {
    initFont();

    setUpClipboard();

    setPreferredSize(new Dimension(getPixelWidth(), getPixelHeight()));

    setFocusable(true);
    enableInputMethods(true);
    setDoubleBuffered(true);

    setFocusTraversalKeysEnabled(false);

    addMouseMotionListener(
        new MouseMotionAdapter() {
          @Override
          public void mouseDragged(final MouseEvent e) {
            if (!isLocalMouseAction(e)) {
              return;
            }

            final Point charCoords = panelToCharCoords(e.getPoint());

            if (mySelection == null) {
              // prevent unlikely case where drag started outside terminal panel
              if (mySelectionStartPoint == null) {
                mySelectionStartPoint = charCoords;
              }
              mySelection = new TerminalSelection(new Point(mySelectionStartPoint));
            }
            repaint();
            mySelection.updateEnd(charCoords);
            if (mySettingsProvider.copyOnSelect()) {
              handleCopy(false);
            }

            if (e.getPoint().y < 0) {
              moveScrollBar((int) ((e.getPoint().y) * SCROLL_SPEED));
            }
            if (e.getPoint().y > getPixelHeight()) {
              moveScrollBar((int) ((e.getPoint().y - getPixelHeight()) * SCROLL_SPEED));
            }
          }
        });

    addMouseWheelListener(
        new MouseWheelListener() {
          @Override
          public void mouseWheelMoved(MouseWheelEvent e) {
            if (isLocalMouseAction(e)) {
              int notches = e.getWheelRotation();
              moveScrollBar(notches);
            }
          }
        });

    addMouseListener(
        new MouseAdapter() {
          @Override
          public void mousePressed(final MouseEvent e) {
            if (e.getButton() == MouseEvent.BUTTON1) {
              if (e.getClickCount() == 1) {
                mySelectionStartPoint = panelToCharCoords(e.getPoint());
                mySelection = null;
                repaint();
              }
            }
          }

          @Override
          public void mouseReleased(final MouseEvent e) {
            requestFocusInWindow();
            repaint();
          }

          @Override
          public void mouseClicked(final MouseEvent e) {
            requestFocusInWindow();
            if (e.getButton() == MouseEvent.BUTTON1 && isLocalMouseAction(e)) {
              int count = e.getClickCount();
              if (count == 1) {
                // do nothing
              } else if (count == 2) {
                // select word
                final Point charCoords = panelToCharCoords(e.getPoint());
                Point start = SelectionUtil.getPreviousSeparator(charCoords, myTerminalTextBuffer);
                Point stop = SelectionUtil.getNextSeparator(charCoords, myTerminalTextBuffer);
                mySelection = new TerminalSelection(start);
                mySelection.updateEnd(stop);

                if (mySettingsProvider.copyOnSelect()) {
                  handleCopy(false);
                }
              } else if (count == 3) {
                // select line
                final Point charCoords = panelToCharCoords(e.getPoint());
                int startLine = charCoords.y;
                while (startLine > -getScrollBuffer().getLineCount()
                    && myTerminalTextBuffer.getLine(startLine - 1).isWrapped()) {
                  startLine--;
                }
                int endLine = charCoords.y;
                while (endLine < myTerminalTextBuffer.getHeight()
                    && myTerminalTextBuffer.getLine(endLine).isWrapped()) {
                  endLine++;
                }
                mySelection = new TerminalSelection(new Point(0, startLine));
                mySelection.updateEnd(new Point(myTermSize.width, endLine));

                if (mySettingsProvider.copyOnSelect()) {
                  handleCopy(false);
                }
              }
            } else if (e.getButton() == MouseEvent.BUTTON2
                && mySettingsProvider.pasteOnMiddleMouseClick()
                && isLocalMouseAction(e)) {
              handlePaste();
            } else if (e.getButton() == MouseEvent.BUTTON3) {
              JPopupMenu popup = createPopupMenu();
              popup.show(e.getComponent(), e.getX(), e.getY());
            }
            repaint();
          }
        });

    addComponentListener(
        new ComponentAdapter() {
          @Override
          public void componentResized(final ComponentEvent e) {
            sizeTerminalFromComponent();
          }
        });

    addFocusListener(
        new FocusAdapter() {
          @Override
          public void focusGained(FocusEvent e) {
            myCursor.cursorChanged();
          }

          @Override
          public void focusLost(FocusEvent e) {
            myCursor.cursorChanged();
          }
        });

    myBoundedRangeModel.addChangeListener(
        new ChangeListener() {
          public void stateChanged(final ChangeEvent e) {
            myClientScrollOrigin = myBoundedRangeModel.getValue();
            repaint();
          }
        });

    createRepaintTimer();
  }
Exemplo n.º 14
0
  /**
   * Adjusts the allocation given to the view to be a suitable allocation for a text field. If the
   * view has been allocated more than the preferred span vertically, the allocation is changed to
   * be centered vertically. Horizontally the view is adjusted according to the horizontal alignment
   * property set on the associated JTextField (if that is the type of the hosting component).
   *
   * @param a the allocation given to the view, which may need to be adjusted.
   * @return the allocation that the superclass should use.
   */
  protected Shape adjustAllocation(Shape a) {
    if (a != null) {
      Rectangle bounds = a.getBounds();
      int vspan = (int) getPreferredSpan(Y_AXIS);
      int hspan = (int) getPreferredSpan(X_AXIS);
      if (bounds.height != vspan) {
        int slop = bounds.height - vspan;
        bounds.y += slop / 2;
        bounds.height -= slop;
      }

      // horizontal adjustments
      Component c = getContainer();
      if (c instanceof JTextField) {
        JTextField field = (JTextField) c;
        BoundedRangeModel vis = field.getHorizontalVisibility();
        int max = Math.max(hspan, bounds.width);
        int value = vis.getValue();
        int extent = Math.min(max, bounds.width - 1);
        if ((value + extent) > max) {
          value = max - extent;
        }
        vis.setRangeProperties(value, extent, vis.getMinimum(), max, false);
        if (hspan < bounds.width) {
          // horizontally align the interior
          int slop = bounds.width - 1 - hspan;

          int align = ((JTextField) c).getHorizontalAlignment();
          if (Utilities.isLeftToRight(c)) {
            if (align == LEADING) {
              align = LEFT;
            } else if (align == TRAILING) {
              align = RIGHT;
            }
          } else {
            if (align == LEADING) {
              align = RIGHT;
            } else if (align == TRAILING) {
              align = LEFT;
            }
          }

          switch (align) {
            case SwingConstants.CENTER:
              bounds.x += slop / 2;
              bounds.width -= slop;
              break;
            case SwingConstants.RIGHT:
              bounds.x += slop;
              bounds.width -= slop;
              break;
          }
        } else {
          // adjust the allocation to match the bounded range.
          bounds.width = hspan;
          bounds.x -= vis.getValue();
        }
      }
      return bounds;
    }
    return null;
  }
Exemplo n.º 15
0
 /**
  * Get the maximum accessible value of this object.
  *
  * @return The maximum value of this object.
  */
 public Number getMaximumAccessibleValue() {
   // TIGER - 4422362
   BoundedRangeModel model = JSlider.this.getModel();
   return Integer.valueOf(model.getMaximum() - model.getExtent());
 }