Java 类java.awt.event.AdjustmentEvent 实例源码

/**
 * Listens to changes of the scroll bar of the text are showing the EULA text, enables the check
 * box once the user scrolled to the end of the document.
 */
@Override
public void adjustmentValueChanged(AdjustmentEvent e) {
    JScrollBar scrollBar = this.scrollPane.getVerticalScrollBar();
    if (e.getSource() == scrollBar) {
        // the maximum value of the scroll bar assumes that the content is
        // not visible anymore, since this is not the case when scrolling
        // to the end of the document (the last part is still visible),
        // we have to include the visible amount in the comparison
        int currentValue = scrollBar.getValue() + scrollBar.getVisibleAmount();
        if (currentValue >= scrollBar.getMaximum()) {
            // the user scrolled to the end of the document
            this.acceptCheckBox.setEnabled(true);
            this.acceptCheckBox.requestFocusInWindow();
        }
    }
}

@Override
public void adjustmentValueChanged(final AdjustmentEvent evt) {
    if (!scrollBarsInitialized) {
        return;
    }

    // If this is not done, mousePressed events accumilate
    // and the result is that scrolling doesn't stop after
    // the mouse is released
    SwingUtilities.invokeLater(new Runnable() {

        @Override
        public void run() {
            if (evt.getAdjustable() == vertical) {
                setFirstLine(vertical.getValue());
            } else {
                setHorizontalOffset(-horizontal.getValue());
            }
        }
    });
}

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustementEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

public JScrollPane generateScrollPane()
{   
    JScrollPane newScroll = new JScrollPane();
    JList list = new JList(listModel);
    list.setFont( new Font("monospaced", Font.PLAIN, 12) );
    newScroll.setViewportView(list);

    Dimension listSize = new Dimension(400, 150);
    newScroll.setSize(listSize);
    newScroll.setMaximumSize(listSize);
    newScroll.setPreferredSize(listSize);

    newScroll.getVerticalScrollBar().addAdjustmentListener(new AdjustmentListener() {  
        public void adjustmentValueChanged(AdjustmentEvent e) {  
            e.getAdjustable().setValue(e.getAdjustable().getMaximum());  
        }
    }); 
    return newScroll;
}

/**
 * Method description
 * 
 * @see
 * @param objPadjustmentEvent
 */
@Override final public void adjustmentValueChanged(AdjustmentEvent objPadjustmentEvent) {

    final byte bytLpreviousValue = this.objGcontrolJFrame.getControlValue(Constants.bytS_BYTE_LOCAL_SPEED);
    final byte bytLcurrentValue = (byte) objPadjustmentEvent.getValue();
    if (bytLcurrentValue != bytLpreviousValue) {
        this.objGcontrolJFrame.saveControlValue(Constants.bytS_BYTE_LOCAL_SPEED, bytLcurrentValue);

        // TODO : si pas de doRestartJuggling
        // this.objGcontrolJFrame.setSpeedControls();
        // this.objGcontrolJFrame.doAddAction(Constants.intS_ACTION_INIT_TITLES | Constants.intS_ACTION_INIT_ANIMATION_PROPERTIES);

        Tools.debug("SpeedJScrollBar.adjustmentValueChanged(): ControlJFrame.doRestartJuggling()");
        this.objGcontrolJFrame.doRestartJuggling();
    }
}

/**
 * Method description
 * 
 * @see
 * @param objPadjustmentEvent
 */
@Override final public void adjustmentValueChanged(AdjustmentEvent objPadjustmentEvent) {

    Tools.debug("StrobeJScrollBar.adjustmentValueChanged()");
    final byte bytLcurrentValue = (byte) objPadjustmentEvent.getValue();
    final byte bytLpreviousValue = this.objGcontrolJFrame.getControlValue(Constants.bytS_BYTE_LOCAL_STROBE);
    if (bytLcurrentValue != bytLpreviousValue) {
        this.objGcontrolJFrame.saveControlValue(Constants.bytS_BYTE_LOCAL_STROBE, bytLcurrentValue);
        if ((this.objGcontrolJFrame.isControlSelected(Constants.bytS_BOOLEAN_LOCAL_FLASH) || this.objGcontrolJFrame.isControlSelected(Constants.bytS_BOOLEAN_LOCAL_ROBOT))
            && this.objGcontrolJFrame.isControlSelected(Constants.bytS_BOOLEAN_LOCAL_BALLS)
            && this.objGcontrolJFrame.getControlValue(Constants.bytS_BYTE_LOCAL_BALLS_TRAIL) == Constants.bytS_BYTE_LOCAL_BALLS_TRAIL_FULL) {
            this.objGcontrolJFrame.doAddAction(Constants.intS_ACTION_INIT_TITLES | Constants.intS_ACTION_CLEAR_ANIMATION_IMAGE
                                                | Constants.intS_ACTION_RECREATE_JUGGLER_TRAILS_IMAGES
                                                | Constants.intS_ACTION_RECREATE_BALLS_TRAILS_IMAGES);
        }
        this.objGcontrolJFrame.setStrobeControls();
    }
}

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustementEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustmentEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

public void adjustmentValueChanged(AdjustmentEvent ae) {
    if ( sp != null && 
            ae.getSource() == sp.getVerticalScrollBar()  &&
            ! adjustment && 
            coreDisp != null)   {
        adjustGraphs( coreDisp.getZScale(), 
                coreDisp.getVisibleRect().getCenterY(), 
                "FOSSIL DISPLAY" );
    }
    else if ( sedimentSP != null && 
            ae.getSource() == sedimentSP.getVerticalScrollBar() &&
            !adjustment && 
            sedimentGraph != null) {
        adjustGraphs( sedimentGraph.getZoom(), 
                sedimentGraph.getVisibleRect().getCenterY(), 
                "SEDIMENT GRAPH" );
    }
}

public void adjustmentValueChanged(AdjustmentEvent e)
{
    if ( isAllowEvent )
    {
        if ( e.getValue() == -1 )
        {
            jsHour.setValue(23);
            return;
        }
        else if ( e.getValue() == 24 )
        {
            jsHour.setValue(0);
            return;
        }

        setHour(e.getValue());
    }
}

public void adjustmentValueChanged(AdjustmentEvent e)
{
    if ( isAllowEvent )
    {
        if ( e.getValue() == -1 )
        {
            jsMinute.setValue(59);
            return;
        }
        else if ( e.getValue() == 60 )
        {
            jsMinute.setValue(0);
            return;
        }

        setMinute(e.getValue());
    }
}

public void adjustmentValueChanged(AdjustmentEvent e)
{
    if ( isAllowEvent )
    {
        if ( e.getValue() == -1 )
        {
            jsSecond.setValue(59);
            return;
        }
        else if ( e.getValue() == 60 )
        {
            jsSecond.setValue(0);
            return;
        }

        setSecond(e.getValue());
    }
}

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustmentEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

@Override
        public void adjustmentValueChanged(AdjustmentEvent e) {
            if (horizontalScrollUnit == HorizontalScrollUnit.CHARACTER) {
                scrollPosition.setScrollCharPosition(scrollPanel.getHorizontalScrollBar().getValue());
            } else {
                if (characterWidth > 0) {
                    int horizontalScroll = scrollPanel.getHorizontalScrollBar().getValue();
                    scrollPosition.setScrollCharPosition(horizontalScroll / characterWidth);
                    scrollPosition.setScrollCharOffset(horizontalScroll % characterWidth);
                }
            }

            worker.getCodeArea().repaint();
//            dataViewScrolled(codeArea.getGraphics());
            notifyScrolled();
        }

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustementEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustementEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

/**
 * Sets the value of this scrollbar to the specified value.
 * <p>
 * If the value supplied is less than the current minimum or
 * greater than the current maximum, then one of those values is
 * substituted, as appropriate. Also, creates and dispatches
 * the AdjustementEvent with specified type and value.
 *
 * @param v the new value of the scrollbar
 * @param type the type of the scrolling operation occurred
 */
private void setTypedValue(int v, int type) {
    v = Math.max(v, minimum);
    v = Math.min(v, maximum - visibleAmount);

    if (v != value) {
        value = v;
        // Synchronously notify the listeners so that they are
        // guaranteed to be up-to-date with the Adjustable before
        // it is mutated again.
        AdjustmentEvent e =
            new AdjustmentEvent(this,
                    AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                    type, value, isAdjusting);
        adjustmentListener.adjustmentValueChanged(e);
    }
}

void dragEnd(final int value) {
    final Scrollbar sb = (Scrollbar)target;

    if (!dragInProgress) {
        return;
    }

    dragInProgress = false;
    WToolkit.executeOnEventHandlerThread(sb, new Runnable() {
        public void run() {
            // NB: notification only, no sb.setValue()
            // last TRACK event will have done it already
            sb.setValueIsAdjusting(false);
            postEvent(new AdjustmentEvent(sb,
                            AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED,
                            AdjustmentEvent.TRACK, value, false));
        }
    });
}

void trackMouseDraggedScroll(int mouseX, int mouseY, int listWidth, int listHeight){

        if (!mouseDraggedOutVertically){
            if (vsb.beforeThumb(mouseX, mouseY)) {
                vsb.setMode(AdjustmentEvent.UNIT_DECREMENT);
            } else {
                vsb.setMode(AdjustmentEvent.UNIT_INCREMENT);
            }
        }

        if(!mouseDraggedOutVertically && (mouseY < 0 || mouseY >= listHeight)){
            mouseDraggedOutVertically = true;
            vsb.startScrollingInstance();
        }

        if (mouseDraggedOutVertically && mouseY >= 0 && mouseY < listHeight && mouseX >= 0 && mouseX < listWidth){
            mouseDraggedOutVertically = false;
            vsb.stopScrollingInstance();
        }
    }

private JScrollBar getScrollBar()
{
    if (popupScrollBar == null)
    {
        popupScrollBar = new JScrollBar(JScrollBar.VERTICAL);
        popupScrollBar.addAdjustmentListener(new AdjustmentListener()
        {
            @Override
            public void adjustmentValueChanged(AdjustmentEvent e)
            {
                doLayout();
                repaint();
            }
        });

        popupScrollBar.setVisible(false);
    }

    return popupScrollBar;
}

/**
 * Returns a scroll bar adjustment listener bound to the given <code>scrollPane</code> view
 * that updates view tool tip when its vertical scroll bar is adjusted.
 */
public static AdjustmentListener createAdjustmentListenerUpdatingScrollPaneViewToolTip(final JScrollPane scrollPane)
{
    return new AdjustmentListener()
    {
        public void adjustmentValueChanged(AdjustmentEvent ev)
        {
            Point screenLocation = MouseInfo.getPointerInfo().getLocation();
            Point point = new Point(screenLocation);
            Component view = scrollPane.getViewport().getView();
            SwingUtilities.convertPointFromScreen(point, view);
            if (scrollPane.isShowing() && scrollPane.getViewport().getViewRect().contains(point))
            {
                MouseEvent mouseEvent = new MouseEvent(view, MouseEvent.MOUSE_MOVED, System.currentTimeMillis(), 0,
                        point.x, point.y, 0, false, MouseEvent.NOBUTTON);
                if (isToolTipShowing())
                {
                    ToolTipManager.sharedInstance().mouseMoved(mouseEvent);
                }
            }
        }
    };
}

/**
 * Package private method to determine whether to call
 * processEvent() or not.  Will handle events from peer and update
 * the current value.
 */
void dispatchEventImpl(AWTEvent e)
{
  if (e.id <= AdjustmentEvent.ADJUSTMENT_LAST
      && e.id >= AdjustmentEvent.ADJUSTMENT_FIRST)
    {
      AdjustmentEvent ae = (AdjustmentEvent) e;
      boolean adjusting = ae.getValueIsAdjusting();
      if (adjusting)
        setValueIsAdjusting(true);
      try
        {
          setValue(((AdjustmentEvent) e).getValue());
          if (adjustment_listeners != null
              || (eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0)
            processEvent(e);
        }
      finally
        {
          if (adjusting)
            setValueIsAdjusting(false);
        }
    }
  else
    super.dispatchEventImpl(e);
}

public void adjustmentValueChanged(AdjustmentEvent evt) {
    try {
        if (!noScrollbarEvents) {
            // get values
            int lv = scrLower.getValue(), uv = scrUpper.getValue(), gv = scrGreyscale.getValue();

            // assure lower value is not higher than upper value
            if (lv >= uv) {
                scrLower.setValue(uv - 1);
                lv = uv - 1;
            }
            // replot
            ctrl.eventReplot(lv / 100f, uv / 100f, gv / 100f);
        }
    } catch (Exception e) {
        e.printStackTrace();
        ClientGlobals.unexpectedError(e, ctrl);
    }

}

protected JScrollBar getScrollBar() {
    if (popupScrollBar == null) {
        popupScrollBar = new JScrollBar(JScrollBar.VERTICAL);
        popupScrollBar.addAdjustmentListener(new AdjustmentListener() {
            @Override
            public void adjustmentValueChanged(AdjustmentEvent e) {
                doLayout();
                repaint();
            }
        });

        popupScrollBar.setVisible(false);
    }

    return popupScrollBar;
}

protected JScrollBar getScrollBar() {
    if (popupScrollBar == null) {
        popupScrollBar = new JScrollBar(JScrollBar.VERTICAL);
        popupScrollBar.addAdjustmentListener(new AdjustmentListener() {
            @Override
            public void adjustmentValueChanged(AdjustmentEvent e) {
                doLayout();
                repaint();
            }
        });

        popupScrollBar.setVisible(false);
    }

    return popupScrollBar;
}

/**
 * Listens to changes of the scroll bar of the text are showing the EULA text, enables the check
 * box once the user scrolled to the end of the document.
 */
@Override
public void adjustmentValueChanged(AdjustmentEvent e) {
    JScrollBar scrollBar = this.scrollPane.getVerticalScrollBar();
    if (e.getSource() == scrollBar) {
        // the maximum value of the scroll bar assumes that the content is
        // not visible anymore, since this is not the case when scrolling
        // to the end of the document (the last part is still visible),
        // we have to include the visible amount in the comparison
        int currentValue = scrollBar.getValue() + scrollBar.getVisibleAmount();
        if (currentValue >= scrollBar.getMaximum()) {
            // the user scrolled to the end of the document
            this.acceptCheckBox.setEnabled(true);
            this.acceptCheckBox.requestFocusInWindow();
        }
    }
}

public void adjustmentValueChanged(AdjustmentEvent e) {
    LayerWidget mainLayer = glassPane.getMainLayer();
    List<Widget> listaWidget = mainLayer.getChildren();
    Iterator iteratore = listaWidget.iterator();
    this.jLayeredPane.moveToFront(this.glassPane);
    while (iteratore.hasNext()) {
        Widget widget = (Widget) iteratore.next();
        ICaratteristicheWidget caratteristicheWidget = (ICaratteristicheWidget) mainLayer.getChildConstraint(widget);
        Point newPoint = null;
        if (caratteristicheWidget.getTreeType().equalsIgnoreCase(Costanti.TREE_SOURCE) || caratteristicheWidget.getTreeType().equalsIgnoreCase(Costanti.TREE_TARGET)) {
            newPoint = findNewLocationForTree(caratteristicheWidget, (JTree) connectedComponent);
        } else if (caratteristicheWidget.getTreeType().equalsIgnoreCase(Costanti.FOREIGN_KEY) || caratteristicheWidget.getTreeType().equalsIgnoreCase(Costanti.KEY)) {

            newPoint = findNewLocationForOther(caratteristicheWidget, widget);
        }
        if (newPoint != null) {
            widget.setPreferredLocation(newPoint);
        }
        glassPane.getScene().validate();
        this.jLayeredPane.moveToFront(this.glassPane);
        glassPane.updateUI();
    }
    glassPane.updateUI();
}

/**
  * Package private method to determine whether to call
  * processEvent() or not.  Will handle events from peer and update
  * the current value.
  */
 void dispatchEventImpl(AWTEvent e)
 {
   if (e.id <= AdjustmentEvent.ADJUSTMENT_LAST 
&& e.id >= AdjustmentEvent.ADJUSTMENT_FIRST)
     {
AdjustmentEvent ae = (AdjustmentEvent) e;
boolean adjusting = ae.getValueIsAdjusting();
if (adjusting)
  setValueIsAdjusting(true);
try
  {
    setValue(((AdjustmentEvent) e).getValue());
    if (adjustment_listeners != null 
    || (eventMask & AWTEvent.ADJUSTMENT_EVENT_MASK) != 0)
      processEvent(e);
  }
finally
  {
    if (adjusting)
      setValueIsAdjusting(false);
  }
     }
   else
     super.dispatchEventImpl(e);
 }

private void initComponents() {
    this.setPreferredSize(new Dimension(200, 100));
    this.setLayout(new BorderLayout());
    this.setBackground(Color.white);

    _vScrollBar = new JScrollBar(JScrollBar.VERTICAL);
    _vScrollBar.addAdjustmentListener(new AdjustmentListener() {
        @Override
        public void adjustmentValueChanged(AdjustmentEvent e) {
            onScrollValueChanged(e);
        }
    });
    this.add(_vScrollBar, BorderLayout.EAST);
    //this._vScrollBar.setSize(this._vScrollBar.getWidth(), this.getHeight());
    this._vScrollBar.setSize(20, this.getHeight());
    this._vScrollBar.setLocation(this.getWidth() - this._vScrollBar.getWidth(), 0);
}

public void onScrollValueChanged(AdjustmentEvent e) {
    if (e.getSource() == _vScrollBar) {
        //_vScrollBar.setValue(e.getValue());            
        //this._yShift = - this._vScrollBar.getValue();
        int y = -e.getValue();
        if (y == 1) {
            y = 0;
        }
        this._pageLocation.Y = y;
    }
    if (e.getSource() == _hScrollBar) {
        //_hScrollBar.setValue(e.getValue());       
        //this._xShift = - this._hScrollBar.getValue();
        int x = -e.getValue();
        if (x == 1) {
            x = 0;
        }
        this._pageLocation.X = x;
    }
    this.paintGraphics();
    //this.repaint();
}