/*
* Copyright 1996-2003 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*/
package sun.awt.motif;
import java.awt.*;
import java.awt.event.AdjustmentEvent;
import java.awt.peer.ScrollPanePeer;
import java.util.logging.*;
import sun.awt.PeerEvent;
class MScrollPanePeer extends MPanelPeer implements ScrollPanePeer {
private static final Logger log = Logger.getLogger("sun.awt.motif.MScrollPanePeer");
final static int UNIT_INCREMENT = 0;
final static int BLOCK_INCREMENT = 1;
boolean ignore;
native void create(MComponentPeer parent);
static {
initIDs();
}
/**
* Initialize JNI field and method IDs
*/
private static native void initIDs();
MScrollPanePeer(Component target) {
init(target);
scrollPaneInit();
}
MScrollPanePeer(Component target, Object arg) {
init(target, arg);
scrollPaneInit();
}
void scrollPaneInit() {
ignore = false;
ScrollPane sp = (ScrollPane)target;
Adjustable vadj, hadj;
if ((vadj = sp.getVAdjustable()) != null) {
pSetIncrement(Adjustable.VERTICAL, UNIT_INCREMENT, vadj.getUnitIncrement());
}
if ((hadj = sp.getHAdjustable()) != null) {
pSetIncrement(Adjustable.HORIZONTAL, UNIT_INCREMENT, hadj.getUnitIncrement());
}
super.pSetScrollbarBackground(sp.getBackground());
}
public void setScrollChild(MComponentPeer child) {
pSetScrollChild(child);
}
public void setBackground(Color c) {
super.setBackground(c);
pSetScrollbarBackground(c);
}
public void setForeground(Color c) {
super.setForeground(c);
pSetInnerForeground(c);
}
native void pSetScrollChild(MComponentPeer child);
native void pSetIncrement(int orient, int type, int incr);
native int pGetScrollbarSpace(int orient);
native int pGetBlockIncrement(int orient);
native Insets pInsets(int w, int h, int childw, int childh);
native int pGetShadow();
public int getHScrollbarHeight() {
ScrollPane sp = (ScrollPane)target;
if (sp.getScrollbarDisplayPolicy() == ScrollPane.SCROLLBARS_NEVER) {
return 0;
} else {
return pGetScrollbarSpace(Adjustable.HORIZONTAL);
}
}
public int getVScrollbarWidth() {
ScrollPane sp = (ScrollPane)target;
if (sp.getScrollbarDisplayPolicy() == ScrollPane.SCROLLBARS_NEVER) {
return 0;
} else {
return pGetScrollbarSpace(Adjustable.VERTICAL);
}
}
public Insets insets() {
ScrollPane sp = (ScrollPane)target;
Dimension d = sp.size();
Dimension cd;
Component c = getScrollChild();
if (c != null) {
cd = c.size();
} else {
cd = new Dimension(0, 0);
}
return pInsets(d.width, d.height, cd.width, cd.height);
}
public void setUnitIncrement(Adjustable adj, int u) {
ScrollPane sp = (ScrollPane)target;
if (sp.getScrollbarDisplayPolicy() != ScrollPane.SCROLLBARS_NEVER) {
pSetIncrement(adj.getOrientation(), UNIT_INCREMENT, u);
}
}
public void setValue(Adjustable adj, int v) {
if (! ignore) {
Point p;
Component c = getScrollChild();
if (c == null) {
return;
}
p = c.getLocation();
switch(adj.getOrientation()) {
case Adjustable.VERTICAL:
setScrollPosition(-(p.x), v);
break;
case Adjustable.HORIZONTAL:
setScrollPosition(v, -(p.y));
break;
}
}
}
public native void setScrollPosition(int x, int y);
public void childResized(int w, int h) {
// REMIND AIM: May need to revisit this...
if (((ScrollPane)target).getScrollbarDisplayPolicy() != ScrollPane.SCROLLBARS_NEVER) {
ScrollPane sp = (ScrollPane)target;
Adjustable vAdj = sp.getVAdjustable();
Adjustable hAdj = sp.getHAdjustable();
pSetIncrement(Scrollbar.VERTICAL, UNIT_INCREMENT, vAdj.getUnitIncrement());
pSetIncrement(Scrollbar.HORIZONTAL, UNIT_INCREMENT, hAdj.getUnitIncrement());
pSetIncrement(Scrollbar.VERTICAL, BLOCK_INCREMENT, vAdj.getBlockIncrement());
pSetIncrement(Scrollbar.HORIZONTAL, BLOCK_INCREMENT, hAdj.getBlockIncrement());
}
}
// NOTE: This method may be called by privileged threads.
// DO NOT INVOKE CLIENT CODE ON THIS THREAD!
private void postScrollEvent(int orient, int type,
int pos, boolean isAdjusting)
{
Runnable adjustor = new Adjustor(orient, type, pos, isAdjusting);
MToolkit.executeOnEventHandlerThread(new ScrollEvent(target, adjustor));
}
/**
* This is used to change the adjustable on dispatch thread to
* represent a change made in the native scrollbar. Since the
* change was reflected immediately at the native level,
* notification from the adjustable is temporarily ignored.
*/
class ScrollEvent extends PeerEvent {
ScrollEvent(Object source, Runnable runnable) {
super(source, runnable, 0L);
}
public PeerEvent coalesceEvents(PeerEvent newEvent) {
if (log.isLoggable(Level.FINEST)) {
log.log(Level.FINEST, "ScrollEvent coalesced " + newEvent);
}
if (newEvent instanceof ScrollEvent) {
return newEvent;
}
return null;
}
}
native void setTypedValue(ScrollPaneAdjustable adjustable, int value, int type);
/**
* Runnable for the ScrollEvent that performs the adjustment.
*/
class Adjustor implements Runnable {
int orient; // selects scrollbar
int type; // adjustment type
int pos; // new position (only used for absolute)
boolean isAdjusting; // isAdjusting status
Adjustor(int orient, int type, int pos, boolean isAdjusting) {
this.orient = orient;
this.type = type;
this.pos = pos;
this.isAdjusting = isAdjusting;
}
public void run() {
ScrollPane sp = (ScrollPane)MScrollPanePeer.this.target;
ScrollPaneAdjustable adj = null;
// ScrollPaneAdjustable made public in 1.4, but
// get[HV]Adjustable can't be declared to return
// ScrollPaneAdjustable because it would break backward
// compatibility -- hence the cast
if (orient == Adjustable.VERTICAL) {
adj = (ScrollPaneAdjustable)sp.getVAdjustable();
} else if (orient == Adjustable.HORIZONTAL) {
adj = (ScrollPaneAdjustable)sp.getHAdjustable();
} else {
if (log.isLoggable(Level.FINE)) {
log.log(Level.FINE, "Assertion failed: unknown orient");
}
}
if (adj == null) {
return;
}
int newpos = adj.getValue();
switch (type) {
case AdjustmentEvent.UNIT_DECREMENT:
newpos -= adj.getUnitIncrement();
break;
case AdjustmentEvent.UNIT_INCREMENT:
newpos += adj.getUnitIncrement();
break;
case AdjustmentEvent.BLOCK_DECREMENT:
newpos -= adj.getBlockIncrement();
break;
case AdjustmentEvent.BLOCK_INCREMENT:
newpos += adj.getBlockIncrement();
break;
case AdjustmentEvent.TRACK:
newpos = this.pos;
break;
default:
if (log.isLoggable(Level.FINE)) {
log.log(Level.FINE, "Assertion failed: unknown type");
}
return;
}
// keep scroll position in acceptable range
newpos = Math.max(adj.getMinimum(), newpos);
newpos = Math.min(adj.getMaximum(), newpos);
// set value; this will synchronously fire an AdjustmentEvent
try {
MScrollPanePeer.this.ignore = true;
adj.setValueIsAdjusting(isAdjusting);
// Fix for 4075484 - consider type information when creating AdjustmentEvent
// We can't just call adj.setValue() because it creates AdjustmentEvent with type=TRACK
// Instead, we call private method setTypedValue of ScrollPaneAdjustable.
// Because ScrollPaneAdjustable is in another package we should call it through native code.
setTypedValue(adj, newpos, type);
} finally {
MScrollPanePeer.this.ignore = false;
}
}
} // class Adjustor
private Component getScrollChild() {
ScrollPane sp = (ScrollPane)target;
Component child = null;
try {
child = sp.getComponent(0);
} catch (ArrayIndexOutOfBoundsException e) {
// do nothing. in this case we return null
}
return child;
}
final static int MARGIN = 1;
final static int SCROLLBAR = 16;
int hsbSpace;
int vsbSpace;
int vval;
int hval;
int vmax;
int hmax;
/*
* Print the native component by rendering the Motif look ourselves.
* ToDo(aim): needs to query native motif for more accurate size and
* color information.
*/
public void print(Graphics g) {
ScrollPane sp = (ScrollPane)target;
Dimension d = sp.size();
Color bg = sp.getBackground();
Color fg = sp.getForeground();
Point p = sp.getScrollPosition();
Component c = getScrollChild();
Dimension cd;
if (c != null) {
cd = c.size();
} else {
cd = new Dimension(0, 0);
}
int sbDisplay = sp.getScrollbarDisplayPolicy();
int vvis, hvis, vmin, hmin, vmax, hmax, vval, hval;
switch (sbDisplay) {
case ScrollPane.SCROLLBARS_NEVER:
hsbSpace = vsbSpace = 0;
break;
case ScrollPane.SCROLLBARS_ALWAYS:
hsbSpace = vsbSpace = SCROLLBAR;
break;
case ScrollPane.SCROLLBARS_AS_NEEDED:
hsbSpace = (cd.width <= (d.width - 2*MARGIN)? 0 : SCROLLBAR);
vsbSpace = (cd.height <= (d.height - 2*MARGIN)? 0 : SCROLLBAR);
if (hsbSpace == 0 && vsbSpace != 0) {
hsbSpace = (cd.width <= (d.width - SCROLLBAR - 2*MARGIN)? 0 : SCROLLBAR);
}
if (vsbSpace == 0 && hsbSpace != 0) {
vsbSpace = (cd.height <= (d.height - SCROLLBAR - 2*MARGIN)? 0 : SCROLLBAR);
}
}
vvis = hvis = vmin = hmin = vmax = hmax = vval = hval = 0;
if (vsbSpace > 0) {
vmin = 0;
vvis = d.height - (2*MARGIN) - hsbSpace;
vmax = Math.max(cd.height - vvis, 0);
vval = p.y;
}
if (hsbSpace > 0) {
hmin = 0;
hvis = d.width - (2*MARGIN) - vsbSpace;
hmax = Math.max(cd.width - hvis, 0);
hval = p.x;
}
// need to be careful to add the margins back in here because
// we're drawing the margin border, after all!
int w = d.width - vsbSpace;
int h = d.height - hsbSpace;
g.setColor(bg);
g.fillRect(0, 0, d.width, d.height);
if (hsbSpace > 0) {
int sbw = d.width - vsbSpace;
g.fillRect(1, d.height - SCROLLBAR - 3, sbw - 1, SCROLLBAR - 3);
Graphics ng = g.create();
try {
ng.translate(0, d.height - (SCROLLBAR - 2));
drawScrollbar(ng, bg, SCROLLBAR - 2, sbw,
hmin, hmax, hval, hvis, true);
} finally {
ng.dispose();
}
}
if (vsbSpace > 0) {
int sbh = d.height - hsbSpace;
g.fillRect(d.width - SCROLLBAR - 3, 1, SCROLLBAR - 3, sbh - 1);
Graphics ng = g.create();
try {
ng.translate(d.width - (SCROLLBAR - 2), 0);
drawScrollbar(ng, bg, SCROLLBAR - 2, sbh,
vmin, vmax, vval, vvis, false);
} finally {
ng.dispose();
}
}
draw3DRect(g, bg, 0, 0, w - 1, h - 1, false);
target.print(g);
sp.printComponents(g);
}
/**
* @see ContainerPeer#restack
*/
public void restack() {
// Since ScrollPane can only have one child its restacking does nothing.
// Also, it is dangerous, since SP child is actually not a child of SP widget
// but the child of SP content widget.
}
}