/** * 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)); } }
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; }
/** * 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()); } } } }
/** * 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); } }
/** * 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); }
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(); } }
private void moveScrollBar(int k) { myBoundedRangeModel.setValue(myBoundedRangeModel.getValue() + k); }
private void scrollToBottom() { myBoundedRangeModel.setValue(myTermSize.height); }
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(); }
/** * 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; }
/** * 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()); }