case "Minimized": if (parent == null && getSurface() != null) return B(getSurface().minimized);
default: return super.get(name);
//#end
- return null;
+ throw new Error("unreachable"); // unreachable
}
public void put(Object name, Object value) {
if (name instanceof Number) { put(toInt(name), value); return; }
-
//#switch(name)
case "text": CHECKSET_STRING(text); MARK_RESIZE; dirty();
case "strokecolor": value = N(stringToColor((String)value)); CHECKSET_INT(strokecolor); MARK_RESIZE; dirty();
case "fontsize": font = Font.getFont(font == null ? null : font.res, toInt(value)); MARK_RESIZE; dirty();
case "x": if (test(PACKED) && parent != null) return; CHECKSET_INT(x); dirty(); MARK_RESIZE; dirty();
case "y": if (test(PACKED) && parent != null) return; CHECKSET_INT(y); dirty(); MARK_RESIZE; dirty();
- case "KeyPressed": // prevent stuff from hitting the Hash
- case "KeyReleased": // prevent stuff from hitting the Hash
- case "PosChange": // prevent stuff from hitting the Hash
- case "SizeChange": // prevent stuff from hitting the Hash
- case "childadded": // prevent stuff from hitting the Hash
- case "childremoved": // prevent stuff from hitting the Hash
+ case "KeyPressed": return; // prevent stuff from hitting the Hash
+ case "KeyReleased": return; // prevent stuff from hitting the Hash
+ case "PosChange": return; // prevent stuff from hitting the Hash
+ case "SizeChange": return; // prevent stuff from hitting the Hash
+ case "childadded": return; // prevent stuff from hitting the Hash
+ case "childremoved": return; // prevent stuff from hitting the Hash
+ default: super.put(name, value);
//#end
}
public final Box peerTree_rightmost() { for (Box p = this; ; p = p.right) if (p.right == null) return p; }
static Box peerTree_parent(Box p) { return (p == null)? null: p.peerTree_parent; }
- public Box insertBeforeMe(Box cell) { left = cell; cell.peerTree_parent = this; return cell.fixAfterInsertion(); }
- public Box insertAfterMe(Box cell) { right = cell; cell.peerTree_parent = this; return cell.fixAfterInsertion(); }
+ public void insertBeforeMe(Box cell) { left = cell; cell.peerTree_parent = this; cell.fixAfterInsertion(); }
+ public void insertAfterMe(Box cell) { right = cell; cell.peerTree_parent = this; cell.fixAfterInsertion(); }
static boolean colorOf(Box p) { return (p == null) ? BLACKbool : p.test(BLACK); }
static void setColor(Box p, boolean c) { if (p != null) { if (c) p.set(BLACK); else p.clear(BLACK); } }
}
}
- public Box removeNode() {
- Box root = peerTree_parent.rootChild;
+ public void removeNode() {
// handle case where we are only node
- if (left == null && right == null && peerTree_parent == null) return null;
+ if (left == null && right == null && peerTree_parent == null) return;
// if strictly internal, swap places with a successor
if (left != null && right != null) {
// To work nicely with arbitrary subclasses of Box, we don't want to
// just copy successor's fields. since we don't know what
// they are. Instead we swap positions in the tree.
- root = swapPosition(this, s);
+ swapPosition(this, s);
}
// Start fixup at replacement node (normally a child).
if (left == null && right == null) {
- if (test(BLACK)) root = this.fixAfterDeletion();
+ if (test(BLACK)) fixAfterDeletion();
// Unlink (Couldn't before since fixAfterDeletion needs peerTree_parent ptr)
// link replacement to peerTree_parent
replacement.peerTree_parent = peerTree_parent;
- if (peerTree_parent == null) root = replacement;
+ if (peerTree_parent == null) parent.rootChild = replacement;
else if (this == peerTree_parent.left) peerTree_parent.left = replacement;
- else peerTree_parent.right = replacement;
+ else peerTree_parent.right = replacement;
left = null;
right = null;
peerTree_parent = null;
// fix replacement
- if (test(BLACK)) root = replacement.fixAfterDeletion();
+ if (test(BLACK)) replacement.fixAfterDeletion();
}
-
- return root;
}
/**
* Swap the linkages of two nodes in a tree.
* Return new root, in case it changed.
**/
- Box swapPosition(Box x, Box y) {
- Box root = peerTree_parent.rootChild;
+ void swapPosition(Box x, Box y) {
/* Too messy. TODO: find sequence of assigments that are always OK */
if (y.test(BLACK)) x.set(BLACK); else x.clear(BLACK);
if (c) y.set(BLACK); else y.clear(BLACK);
- if (root == x) root = y;
- else if (root == y) root = x;
- return parent.rootChild = root;
+ if (parent.rootChild == x) parent.rootChild = y;
+ else if (parent.rootChild == y) parent.rootChild = x;
}
- Box rotateLeft() {
- Box root = parent.rootChild;
+ void rotateLeft() {
Box r = right;
right = r.left;
if (r.left != null) r.left.peerTree_parent = this;
r.peerTree_parent = peerTree_parent;
- if (peerTree_parent == null) root = r;
+ if (peerTree_parent == null) parent.rootChild = r;
else if (peerTree_parent.left == this) peerTree_parent.left = r;
else peerTree_parent.right = r;
r.left = this;
peerTree_parent = r;
- return parent.rootChild = root;
}
- Box rotateRight() {
- Box root = parent.rootChild;
+ void rotateRight() {
Box l = left;
left = l.right;
if (l.right != null) l.right.peerTree_parent = this;
l.peerTree_parent = peerTree_parent;
- if (peerTree_parent == null) root = l;
+ if (peerTree_parent == null) parent.rootChild = l;
else if (peerTree_parent.right == this) peerTree_parent.right = l;
else peerTree_parent.left = l;
l.right = this;
peerTree_parent = l;
- return parent.rootChild;
}
- Box fixAfterInsertion() {
- Box root = parent.rootChild;
+ void fixAfterInsertion() {
clear(BLACK);
Box x = this;
- while (x != null && x != root && !x.peerTree_parent.test(BLACK)) {
+ while (x != null && x != parent.rootChild && !x.peerTree_parent.test(BLACK)) {
if (peerTree_parent(x) == leftOf(peerTree_parent(peerTree_parent(x)))) {
Box y = rightOf(peerTree_parent(peerTree_parent(x)));
if (colorOf(y) == REDbool) {
else {
if (x == rightOf(peerTree_parent(x))) {
x = peerTree_parent(x);
- root = x.rotateLeft();
+ x.rotateLeft();
}
setColor(peerTree_parent(x), BLACKbool);
setColor(peerTree_parent(peerTree_parent(x)), REDbool);
if (peerTree_parent(peerTree_parent(x)) != null)
- root = peerTree_parent(peerTree_parent(x)).rotateRight();
+ peerTree_parent(peerTree_parent(x)).rotateRight();
}
}
else {
else {
if (x == leftOf(peerTree_parent(x))) {
x = peerTree_parent(x);
- root = x.rotateRight();
+ x.rotateRight();
}
setColor(peerTree_parent(x), BLACKbool);
setColor(peerTree_parent(peerTree_parent(x)), REDbool);
if (peerTree_parent(peerTree_parent(x)) != null)
- root = peerTree_parent(peerTree_parent(x)).rotateLeft();
+ peerTree_parent(peerTree_parent(x)).rotateLeft();
}
}
}
- root.set(BLACK);
- return parent.rootChild = root;
+ parent.rootChild.set(BLACK);
}
/** From CLR **/
- Box fixAfterDeletion() {
- Box root = peerTree_parent.rootChild;
+ void fixAfterDeletion() {
Box x = this;
- while (x != root && colorOf(x) == BLACKbool) {
+ while (x != parent.rootChild && colorOf(x) == BLACKbool) {
if (x == leftOf(peerTree_parent(x))) {
Box sib = rightOf(peerTree_parent(x));
if (colorOf(sib) == REDbool) {
setColor(sib, BLACKbool);
setColor(peerTree_parent(x), REDbool);
- root = peerTree_parent(x).rotateLeft();
+ peerTree_parent(x).rotateLeft();
sib = rightOf(peerTree_parent(x));
}
if (colorOf(leftOf(sib)) == BLACKbool && colorOf(rightOf(sib)) == BLACKbool) {
if (colorOf(rightOf(sib)) == BLACKbool) {
setColor(leftOf(sib), BLACKbool);
setColor(sib, REDbool);
- root = sib.rotateRight();
+ sib.rotateRight();
sib = rightOf(peerTree_parent(x));
}
setColor(sib, colorOf(peerTree_parent(x)));
setColor(peerTree_parent(x), BLACKbool);
setColor(rightOf(sib), BLACKbool);
- root = peerTree_parent(x).rotateLeft();
- x = root;
+ peerTree_parent(x).rotateLeft();
+ x = parent.rootChild;
}
}
else {
if (colorOf(sib) == REDbool) {
setColor(sib, BLACKbool);
setColor(peerTree_parent(x), REDbool);
- root = peerTree_parent(x).rotateRight();
+ peerTree_parent(x).rotateRight();
sib = leftOf(peerTree_parent(x));
}
if (colorOf(rightOf(sib)) == BLACKbool && colorOf(leftOf(sib)) == BLACKbool) {
if (colorOf(leftOf(sib)) == BLACKbool) {
setColor(rightOf(sib), BLACKbool);
setColor(sib, REDbool);
- root = sib.rotateLeft();
+ sib.rotateLeft();
sib = leftOf(peerTree_parent(x));
}
setColor(sib, colorOf(peerTree_parent(x)));
setColor(peerTree_parent(x), BLACKbool);
setColor(leftOf(sib), BLACKbool);
- root = peerTree_parent(x).rotateRight();
- x = root;
+ peerTree_parent(x).rotateRight();
+ x = parent.rootChild;
}
}
}
setColor(x, BLACKbool);
- return parent.rootChild = root;
}
// Tree Manipulation /////////////////////////////////////////////////////////////////////