META-INF.modules.java.desktop.classes.javax.swing.text.html.HRuleView Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of java.desktop Show documentation
Show all versions of java.desktop Show documentation
Bytecoder java.desktop Module
/*
* Copyright (c) 1997, 2008, Oracle and/or its affiliates. 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package javax.swing.text.html;
import java.awt.*;
import javax.swing.event.DocumentEvent;
import javax.swing.text.*;
import java.util.Enumeration;
import java.lang.Integer;
/**
* A view implementation to display an html horizontal
* rule.
*
* @author Timothy Prinzing
* @author Sara Swanson
*/
class HRuleView extends View {
/**
* Creates a new view that represents an <hr> element.
*
* @param elem the element to create a view for
*/
public HRuleView(Element elem) {
super(elem);
setPropertiesFromAttributes();
}
/**
* Update any cached values that come from attributes.
*/
protected void setPropertiesFromAttributes() {
StyleSheet sheet = ((HTMLDocument)getDocument()).getStyleSheet();
AttributeSet eAttr = getElement().getAttributes();
attr = sheet.getViewAttributes(this);
alignment = StyleConstants.ALIGN_CENTER;
size = 0;
noshade = null;
widthValue = null;
if (attr != null) {
// getAlignment() returns ALIGN_LEFT by default, and HR should
// use ALIGN_CENTER by default, so we check if the alignment
// attribute is actually defined
if (attr.getAttribute(StyleConstants.Alignment) != null) {
alignment = StyleConstants.getAlignment(attr);
}
noshade = (String)eAttr.getAttribute(HTML.Attribute.NOSHADE);
Object value = eAttr.getAttribute(HTML.Attribute.SIZE);
if (value != null && (value instanceof String)) {
try {
size = Integer.parseInt((String)value);
} catch (NumberFormatException e) {
size = 1;
}
}
value = attr.getAttribute(CSS.Attribute.WIDTH);
if (value != null && (value instanceof CSS.LengthValue)) {
widthValue = (CSS.LengthValue)value;
}
topMargin = getLength(CSS.Attribute.MARGIN_TOP, attr);
bottomMargin = getLength(CSS.Attribute.MARGIN_BOTTOM, attr);
leftMargin = getLength(CSS.Attribute.MARGIN_LEFT, attr);
rightMargin = getLength(CSS.Attribute.MARGIN_RIGHT, attr);
}
else {
topMargin = bottomMargin = leftMargin = rightMargin = 0;
}
size = Math.max(2, size);
}
// This will be removed and centralized at some point, need to unify this
// and avoid private classes.
private float getLength(CSS.Attribute key, AttributeSet a) {
CSS.LengthValue lv = (CSS.LengthValue) a.getAttribute(key);
float len = (lv != null) ? lv.getValue() : 0;
return len;
}
// --- View methods ---------------------------------------------
/**
* Paints the view.
*
* @param g the graphics context
* @param a the allocation region for the view
* @see View#paint
*/
public void paint(Graphics g, Shape a) {
Rectangle alloc = (a instanceof Rectangle) ? (Rectangle)a :
a.getBounds();
int x = 0;
int y = alloc.y + SPACE_ABOVE + (int)topMargin;
int width = alloc.width - (int)(leftMargin + rightMargin);
if (widthValue != null) {
width = (int)widthValue.getValue((float)width);
}
int height = alloc.height - (SPACE_ABOVE + SPACE_BELOW +
(int)topMargin + (int)bottomMargin);
if (size > 0)
height = size;
// Align the rule horizontally.
switch (alignment) {
case StyleConstants.ALIGN_CENTER:
x = alloc.x + (alloc.width / 2) - (width / 2);
break;
case StyleConstants.ALIGN_RIGHT:
x = alloc.x + alloc.width - width - (int)rightMargin;
break;
case StyleConstants.ALIGN_LEFT:
default:
x = alloc.x + (int)leftMargin;
break;
}
// Paint either a shaded rule or a solid line.
if (noshade != null) {
g.setColor(Color.black);
g.fillRect(x, y, width, height);
}
else {
Color bg = getContainer().getBackground();
Color bottom, top;
if (bg == null || bg.equals(Color.white)) {
top = Color.darkGray;
bottom = Color.lightGray;
}
else {
top = Color.darkGray;
bottom = Color.white;
}
g.setColor(bottom);
g.drawLine(x + width - 1, y, x + width - 1, y + height - 1);
g.drawLine(x, y + height - 1, x + width - 1, y + height - 1);
g.setColor(top);
g.drawLine(x, y, x + width - 1, y);
g.drawLine(x, y, x, y + height - 1);
}
}
/**
* Calculates the desired shape of the rule... this is
* basically the preferred size of the border.
*
* @param axis may be either X_AXIS or Y_AXIS
* @return the desired span
* @see View#getPreferredSpan
*/
public float getPreferredSpan(int axis) {
switch (axis) {
case View.X_AXIS:
return 1;
case View.Y_AXIS:
if (size > 0) {
return size + SPACE_ABOVE + SPACE_BELOW + topMargin +
bottomMargin;
} else {
if (noshade != null) {
return 2 + SPACE_ABOVE + SPACE_BELOW + topMargin +
bottomMargin;
} else {
return SPACE_ABOVE + SPACE_BELOW + topMargin +bottomMargin;
}
}
default:
throw new IllegalArgumentException("Invalid axis: " + axis);
}
}
/**
* Gets the resize weight for the axis.
* The rule is: rigid vertically and flexible horizontally.
*
* @param axis may be either X_AXIS or Y_AXIS
* @return the weight
*/
public int getResizeWeight(int axis) {
if (axis == View.X_AXIS) {
return 1;
} else if (axis == View.Y_AXIS) {
return 0;
} else {
return 0;
}
}
/**
* Determines how attractive a break opportunity in
* this view is. This is implemented to request a forced break.
*
* @param axis may be either View.X_AXIS or View.Y_AXIS
* @param pos the potential location of the start of the
* broken view (greater than or equal to zero).
* This may be useful for calculating tab
* positions.
* @param len specifies the relative length from pos
* where a potential break is desired. The value must be greater
* than or equal to zero.
* @return the weight, which should be a value between
* ForcedBreakWeight and BadBreakWeight.
*/
public int getBreakWeight(int axis, float pos, float len) {
if (axis == X_AXIS) {
return ForcedBreakWeight;
}
return BadBreakWeight;
}
public View breakView(int axis, int offset, float pos, float len) {
return null;
}
/**
* Provides a mapping from the document model coordinate space
* to the coordinate space of the view mapped to it.
*
* @param pos the position to convert
* @param a the allocated region to render into
* @return the bounding box of the given position
* @exception BadLocationException if the given position does not
* represent a valid location in the associated document
* @see View#modelToView
*/
public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException {
int p0 = getStartOffset();
int p1 = getEndOffset();
if ((pos >= p0) && (pos <= p1)) {
Rectangle r = a.getBounds();
if (pos == p1) {
r.x += r.width;
}
r.width = 0;
return r;
}
return null;
}
/**
* Provides a mapping from the view coordinate space to the logical
* coordinate space of the model.
*
* @param x the X coordinate
* @param y the Y coordinate
* @param a the allocated region to render into
* @return the location within the model that best represents the
* given point of view
* @see View#viewToModel
*/
public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
Rectangle alloc = (Rectangle) a;
if (x < alloc.x + (alloc.width / 2)) {
bias[0] = Position.Bias.Forward;
return getStartOffset();
}
bias[0] = Position.Bias.Backward;
return getEndOffset();
}
/**
* Fetches the attributes to use when rendering. This is
* implemented to multiplex the attributes specified in the
* model with a StyleSheet.
*/
public AttributeSet getAttributes() {
return attr;
}
public void changedUpdate(DocumentEvent changes, Shape a, ViewFactory f) {
super.changedUpdate(changes, a, f);
int pos = changes.getOffset();
if (pos <= getStartOffset() && (pos + changes.getLength()) >=
getEndOffset()) {
setPropertiesFromAttributes();
}
}
// --- variables ------------------------------------------------
private float topMargin;
private float bottomMargin;
private float leftMargin;
private float rightMargin;
private int alignment = StyleConstants.ALIGN_CENTER;
private String noshade = null;
private int size = 0;
private CSS.LengthValue widthValue;
private static final int SPACE_ABOVE = 3;
private static final int SPACE_BELOW = 3;
/** View Attributes. */
private AttributeSet attr;
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy