MarqueePanelV - Versionsgeschichte

L-ectron-X am 15. März 2018 um 18:11 Uhr

2018-03-15T18:11:32Z

← Nächstältere Version		Version vom 15. März 2018, 18:11 Uhr
Zeile 3:		Zeile 3:
	This is an adaptation of Rob Camick's code, to scroll components from the bottom edge of the panel to the top edge (instead of right to left).		This is an adaptation of Rob Camick's code, to scroll components from the bottom edge of the panel to the top edge (instead of right to left).

	<~~code~~=java>		<syntaxhighlight lang="java">
	import java.awt.*;		import java.awt.*;
	import java.awt.event.*;		import java.awt.event.*;
Zeile 350:		Zeile 350:
	}		}

	</~~code=java~~>		</syntaxhighlight>
	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Swing]]		[[Kategorie:Swing]]
	[[Kategorie:Java-Codeschnipsel]]		[[Kategorie:Java-Codeschnipsel]]

AndreUhres am 26. November 2011 um 11:22 Uhr

2011-11-26T11:22:55Z

← Nächstältere Version		Version vom 26. November 2011, 11:22 Uhr
Zeile 1:		Zeile 1:
	http://tips4java.wordpress.com/2011/04/24/marquee-panel/		http://tips4java.wordpress.com/2011/04/24/marquee-panel/

	This is adaptation of Rob Camick's code, to scroll components from the bottom edge of the panel to the top edge (instead of right to left).		This is an adaptation of Rob Camick's code, to scroll components from the bottom edge of the panel to the top edge (instead of right to left).

	<code=java>		<code=java>

AndreUhres am 26. November 2011 um 11:16 Uhr

2011-11-26T11:16:23Z

← Nächstältere Version		Version vom 26. November 2011, 11:16 Uhr
Zeile 1:		Zeile 1:
	http://tips4java.wordpress.com/2011/04/24/marquee-panel/		http://tips4java.wordpress.com/2011/04/24/marquee-panel/

			This is adaptation of Rob Camick's code, to scroll components from the bottom edge of the panel to the top edge (instead of right to left).

	<code=java>		<code=java>

AndreUhres am 26. November 2011 um 11:10 Uhr

2011-11-26T11:10:34Z

← Nächstältere Version		Version vom 26. November 2011, 11:10 Uhr
Zeile 204:		Zeile 204:
	* @param wrap when true the start of the text will scroll in from the bottom		* @param wrap when true the start of the text will scroll in from the bottom
	* edge while the end of the text is still scrolling off the top		* edge while the end of the text is still scrolling off the top
	* edge. Otherwise the panel must be clear of text before		* edge. Otherwise the panel must be clear of text before it
	* will begin again from the bottom edge.		* will begin again from the bottom edge.
	*/		*/
Zeile 275:		Zeile 275:
	/**		/**
	* Adjust the offset of the components on the panel so it appears that		* Adjust the offset of the components on the panel so it appears that
	* they are scrolling from ~~right~~ to ~~left~~.		* they are scrolling from bottom to top.
	*/		*/
	@Override		@Override

AndreUhres am 26. November 2011 um 11:06 Uhr

2011-11-26T11:06:20Z

← Nächstältere Version		Version vom 26. November 2011, 11:06 Uhr
Zeile 196:		Zeile 196:
	* Specify the wrapping property. Normal scrolling is such that all the text		* Specify the wrapping property. Normal scrolling is such that all the text
	* will scroll from bottom to top. When the last part of the text scrolls off		* will scroll from bottom to top. When the last part of the text scrolls off
	* the ~~top~~ edge scrolling will start again from the bottom edge. Therefore		* the bottom edge scrolling will start again from the bottom edge. Therefore
	* there is a time when the component is blank as nothing is displayed.		* there is a time when the component is blank as nothing is displayed.
	* Wrapping implies that as the end of the text scrolls off the top edge		* Wrapping implies that as the end of the text scrolls off the top edge

AndreUhres am 26. November 2011 um 11:03 Uhr

2011-11-26T11:03:23Z

← Nächstältere Version		Version vom 26. November 2011, 11:03 Uhr
Zeile 72:		Zeile 72:
	g2d.translate(0, scrollOffset);		g2d.translate(0, scrollOffset);

	// Repaint the start of the components on the ~~right~~ edge of the panel once		// Repaint the start of the components on the bottom edge of the panel once
	// all the components are completely visible on the panel.		// all the components are completely visible on the panel.
	// (Its like the components are in two places at the same time)		// (Its like the components are in two places at the same time)

AndreUhres am 26. November 2011 um 11:01 Uhr

2011-11-26T11:01:47Z

← Nächstältere Version		Version vom 26. November 2011, 11:01 Uhr
Zeile 41:		Zeile 41:

	/**		/**
	* ~~Create an AnimatedIcon that will continuously cycle with the~~		*
	* ~~default (500ms).~~		* @param scrollFrequency
	*		* @param scrollAmount
	* @param ~~component the component the icon will be painted on~~
	* @param ~~icons the Icons to be painted as part of the animation~~
	*/		*/
	@SuppressWarnings("LeakingThisInConstructor")		@SuppressWarnings("LeakingThisInConstructor")
Zeile 349:		Zeile 347:
	}		}
	}		}

	</code=java>		</code=java>
	[[Kategorie:Java]]		[[Kategorie:Java]]
	[[Kategorie:Swing]]		[[Kategorie:Swing]]
	[[Kategorie:Java-Codeschnipsel]]		[[Kategorie:Java-Codeschnipsel]]

AndreUhres: Die Seite wurde neu angelegt: „http://tips4java.wordpress.com/2011/04/24/marquee-panel/ import java.awt.; import java.awt.event.; import javax.swing.; import javax.swing.event.…“

2011-11-26T10:51:42Z

Die Seite wurde neu angelegt: „http://tips4java.wordpress.com/2011/04/24/marquee-panel/ <code=java> import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*…“

Neue Seite

http://tips4java.wordpress.com/2011/04/24/marquee-panel/

<code=java>
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

/**
* The MarqueePanelV is used to scroll components from the bottom edge of the
* panel to the top edge. Scrolling is continuous. To simulate the scrolling
* of text you can simply add a JLabel to the panel.
*
* Various properties control the scrolling of the components on the panel.
* Changes to the properties are dynamic and will take effect the next time
* the components are scrolled.
* @author Rob Camick, André Uhres
*/
public final class MarqueePanelV extends JPanel
implements ActionListener, AncestorListener, WindowListener {

private boolean paintChildren;
private boolean scrollingPaused;
private int scrollOffset;
private int wrapOffset;
private int preferredHeight = -1;
private int scrollAmount;
private int scrollFrequency;
private boolean wrap = false;
private int wrapAmount = 50;
private boolean scrollWhenFocused = true;
private Timer timer = new Timer(1000, this);

/**
* Convenience constructor that sets both the scroll frequency and
* scroll amount to a value of 5.
*/
public MarqueePanelV() {
this(5, 5);
}

/**
* Create an AnimatedIcon that will continuously cycle with the
* default (500ms).
*
* @param component the component the icon will be painted on
* @param icons the Icons to be painted as part of the animation
*/
@SuppressWarnings("LeakingThisInConstructor")
public MarqueePanelV(int scrollFrequency, int scrollAmount) {
setScrollFrequency(scrollFrequency);
setScrollAmount(scrollAmount);
setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
addAncestorListener(this);
}

/*
* Translate the location of the children before they are painted so it
* appears they are scrolling bottom to top
*/
@Override
public void paintChildren(Graphics g) {
// Need this so we don't see a flicker of the text before scrolling

if (!paintChildren) {
return;
}

// Normal painting as the components scroll bottom to top

Graphics2D g2d = (Graphics2D) g;
g2d.translate(0, -scrollOffset);
super.paintChildren(g);
g2d.translate(0, scrollOffset);

// Repaint the start of the components on the right edge of the panel once
// all the components are completely visible on the panel.
// (Its like the components are in two places at the same time)

if (isWrap()) {
wrapOffset = scrollOffset - super.getPreferredSize().height - wrapAmount;
g2d.translate(0, -wrapOffset);
super.paintChildren(g);
g2d.translate(0, wrapOffset);
}
}

/*
* The default preferred size will be half the size of the components added to
* the panel. This will allow room for components to be scrolled on and off
* the panel.
*
* The default height can be overriden by using the setPreferredHeight() method.
*/
@Override
public Dimension getPreferredSize() {
Dimension d = super.getPreferredSize();

d.height = (preferredHeight == -1) ? d.height / 2 : preferredHeight;

return d;
}

@Override
public Dimension getMinimumSize() {
return getPreferredSize();
}

public int getPreferredHeight() {
return preferredHeight;
}

/**
* Specify the preferred height on the panel. A value of -1 will cause the
* default preferred with size calculation to be used.
*
* @param preferredHeight preferred height of the panel in pixels
*/
public void setPreferredHeight(int preferredHeight) {
this.preferredHeight = preferredHeight;
revalidate();
}

/**
* Get the scroll amount.
*
* @return the scroll amount in pixels
*/
public int getScrollAmount() {
return scrollAmount;
}

/**
* Specify the scroll amount. The number of pixels to scroll every time
* scrolling is done.
*
* @param scrollAmount scroll amount in pixels
*/
public void setScrollAmount(int scrollAmount) {
this.scrollAmount = scrollAmount;
}

/**
* Get the scroll frequency.
*
* @return the scroll frequency
*/
public int getScrollFrequency() {
return scrollFrequency;
}

/**
* Specify the scroll frequency. That is the number of times scrolling
* should be performed every second.
*
* @param scrollFrequency scroll frequency
*/
public void setScrollFrequency(int scrollFrequency) {
this.scrollFrequency = scrollFrequency;

int delay = 1000 / scrollFrequency;
timer.setInitialDelay(delay);
timer.setDelay(delay);
}

/**
* Get the scroll only when visible property.
*
* @return the scroll only when visible value
*/
public boolean isScrollWhenFocused() {
return scrollWhenFocused;
}

/**
* Specify the scrolling property for unfocused windows.
*
* @param scrollWhenVisible when true scrolling pauses when the window
* loses focus. Scrolling will continue when
* the window regains focus. When false
* scrolling is continuous unless the window
* is iconified.
*/
public void setScrollWhenFocused(boolean scrollWhenFocused) {
this.scrollWhenFocused = scrollWhenFocused;
}

/**
* Get the wrap property.
*
* @return the wrap value
*/
public boolean isWrap() {
return wrap;
}

/**
* Specify the wrapping property. Normal scrolling is such that all the text
* will scroll from bottom to top. When the last part of the text scrolls off
* the top edge scrolling will start again from the bottom edge. Therefore
* there is a time when the component is blank as nothing is displayed.
* Wrapping implies that as the end of the text scrolls off the top edge
* the beginning of the text will scroll in from the bottom edge. So the end
* and the start of the text is displayed at the same time.
*
* @param wrap when true the start of the text will scroll in from the bottom
* edge while the end of the text is still scrolling off the top
* edge. Otherwise the panel must be clear of text before
* will begin again from the bottom edge.
*/
public void setWrap(boolean wrap) {
this.wrap = wrap;
}

/**
* Get the wrap amount.
*
* @return the wrap amount value
*/
public int getWrapAmount() {
return wrapAmount;
}

/**
* Specify the wrapping amount. This specifies the space between the end of the
* text on the top edge and the start of the text from the bottom edge when
* wrapping is turned on.
*
* @param wrapAmount the amount in pixels
*/
public void setWrapAmount(int wrapAmount) {
this.wrapAmount = wrapAmount;
}

/**
* Start scrolling the components on the panel. Components will start
* scrolling from the bottom edge towards the top edge.
*/
public void startScrolling() {
paintChildren = true;
scrollOffset = -getSize().height;

timer.start();
}

/**
* Stop scrolling the components on the panel. The conponents will be
* cleared from the view of the panel
*/
public void stopScrolling() {
timer.stop();
paintChildren = false;
repaint();
}

/**
* The components will stop scrolling but will remain visible
*/
public void pauseScrolling() {
if (timer.isRunning()) {
timer.stop();
scrollingPaused = true;
}
}

/**
* The components will resume scrolling from where scrolling was stopped.
*/
public void resumeScrolling() {
if (scrollingPaused) {
timer.restart();
scrollingPaused = false;
}
}

// Implement ActionListener
/**
* Adjust the offset of the components on the panel so it appears that
* they are scrolling from right to left.
*/
@Override
public void actionPerformed(ActionEvent ae) {
scrollOffset += scrollAmount;
int height = super.getPreferredSize().height;

if (scrollOffset > height) {
scrollOffset = isWrap() ? wrapOffset + scrollAmount : -getSize().height;
}

repaint();
}

// Implement AncestorListener
/**
* Get notified when the panel is added to a Window so we can use a
* WindowListener to automatically start the scrolling of the components.
*/
@Override
public void ancestorAdded(AncestorEvent e) {
SwingUtilities.windowForComponent(this).addWindowListener(this);
}

@Override
public void ancestorMoved(AncestorEvent e) {
}

@Override
public void ancestorRemoved(AncestorEvent e) {
}

// Implement WindowListener
@Override
public void windowActivated(WindowEvent e) {
if (isScrollWhenFocused()) {
resumeScrolling();
}
}

@Override
public void windowClosed(WindowEvent e) {
stopScrolling();
}

@Override
public void windowClosing(WindowEvent e) {
stopScrolling();
}

@Override
public void windowDeactivated(WindowEvent e) {
if (isScrollWhenFocused()) {
pauseScrolling();
}
}

@Override
public void windowDeiconified(WindowEvent e) {
resumeScrolling();
}

@Override
public void windowIconified(WindowEvent e) {
pauseScrolling();
}

@Override
public void windowOpened(WindowEvent e) {
startScrolling();
}
}
</code=java>
[[Kategorie:Java]]
[[Kategorie:Swing]]
[[Kategorie:Java-Codeschnipsel]]