+ /**
+ * Child widgets that this widget contains.
+ */
+ private List<TWidget> children;
+
+ /**
+ * The currently active child widget that will receive keypress events.
+ */
+ private TWidget activeChild = null;
+
+ /**
+ * If true, this widget will receive events.
+ */
+ private boolean active = false;
+
+ /**
+ * The window that this widget draws to.
+ */
+ private TWindow window = null;
+
+ /**
+ * Absolute X position of the top-left corner.
+ */
+ private int x = 0;
+
+ /**
+ * Absolute Y position of the top-left corner.
+ */
+ private int y = 0;
+
+ /**
+ * Width.
+ */
+ private int width = 0;
+
+ /**
+ * Height.
+ */
+ private int height = 0;
+
+ /**
+ * My tab order inside a window or containing widget.
+ */
+ private int tabOrder = 0;
+
+ /**
+ * If true, this widget can be tabbed to or receive events.
+ */
+ private boolean enabled = true;
+
+ /**
+ * If true, this widget will be rendered.
+ */
+ private boolean visible = true;
+
+ /**
+ * If true, this widget has a cursor.
+ */
+ private boolean cursorVisible = false;
+
+ /**
+ * Cursor column position in relative coordinates.
+ */
+ private int cursorX = 0;
+
+ /**
+ * Cursor row position in relative coordinates.
+ */
+ private int cursorY = 0;
+
+ /**
+ * Layout manager.
+ */
+ private LayoutManager layout = null;
+
+ // ------------------------------------------------------------------------
+ // Constructors -----------------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Default constructor for subclasses.
+ */
+ protected TWidget() {
+ children = new ArrayList<TWidget>();
+ }
+
+ /**
+ * Protected constructor.
+ *
+ * @param parent parent widget
+ */
+ protected TWidget(final TWidget parent) {
+ this(parent, true);
+ }
+
+ /**
+ * Protected constructor.
+ *
+ * @param parent parent widget
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param width width of widget
+ * @param height height of widget
+ */
+ protected TWidget(final TWidget parent, final int x, final int y,
+ final int width, final int height) {
+
+ this(parent, true, x, y, width, height);
+ }
+
+ /**
+ * Protected constructor used by subclasses that are disabled by default.
+ *
+ * @param parent parent widget
+ * @param enabled if true assume enabled
+ */
+ protected TWidget(final TWidget parent, final boolean enabled) {
+ this.enabled = enabled;
+ this.parent = parent;
+ children = new ArrayList<TWidget>();
+
+ if (parent != null) {
+ this.window = parent.window;
+ parent.addChild(this);
+ }
+ }
+
+ /**
+ * Protected constructor used by subclasses that are disabled by default.
+ *
+ * @param parent parent widget
+ * @param enabled if true assume enabled
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param width width of widget
+ * @param height height of widget
+ */
+ protected TWidget(final TWidget parent, final boolean enabled,
+ final int x, final int y, final int width, final int height) {
+
+ if (width < 0) {
+ throw new IllegalArgumentException("width cannot be negative");
+ }
+ if (height < 0) {
+ throw new IllegalArgumentException("height cannot be negative");
+ }
+
+ this.enabled = enabled;
+ this.parent = parent;
+ children = new ArrayList<TWidget>();
+
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+
+ if (parent != null) {
+ this.window = parent.window;
+ parent.addChild(this);
+ }
+ }
+
+ /**
+ * Backdoor access for TWindow's constructor. ONLY TWindow USES THIS.
+ *
+ * @param window the top-level window
+ * @param x column relative to parent
+ * @param y row relative to parent
+ * @param width width of window
+ * @param height height of window
+ */
+ protected final void setupForTWindow(final TWindow window,
+ final int x, final int y, final int width, final int height) {
+
+ if (width < 0) {
+ throw new IllegalArgumentException("width cannot be negative");
+ }
+ if (height < 0) {
+ throw new IllegalArgumentException("height cannot be negative");
+ }
+
+ this.parent = window;
+ this.window = window;
+ this.x = x;
+ this.y = y;
+ this.width = width;
+ this.height = height;
+ }
+
+ // ------------------------------------------------------------------------
+ // Event handlers ---------------------------------------------------------
+ // ------------------------------------------------------------------------
+
+ /**
+ * Subclasses should override this method to cleanup resources. This is
+ * called by TWindow.onClose().
+ */
+ protected void close() {
+ // Default: call close() on children.
+ for (TWidget w: getChildren()) {
+ w.close();
+ }
+ }
+
+ /**
+ * Check if a mouse press/release event coordinate is contained in this
+ * widget.
+ *
+ * @param mouse a mouse-based event
+ * @return whether or not a mouse click would be sent to this widget
+ */
+ public final boolean mouseWouldHit(final TMouseEvent mouse) {
+
+ if (!enabled) {
+ return false;
+ }
+
+ if ((this instanceof TTreeItem)
+ && ((y < 0) || (y > parent.getHeight() - 1))
+ ) {
+ return false;
+ }
+
+ if ((mouse.getAbsoluteX() >= getAbsoluteX())
+ && (mouse.getAbsoluteX() < getAbsoluteX() + width)
+ && (mouse.getAbsoluteY() >= getAbsoluteY())
+ && (mouse.getAbsoluteY() < getAbsoluteY() + height)
+ ) {
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Method that subclasses can override to handle keystrokes.
+ *
+ * @param keypress keystroke event
+ */
+ public void onKeypress(final TKeypressEvent keypress) {
+ assert (parent != null);
+
+ if ((children.size() == 0)
+ || (this instanceof TTreeView)
+ || (this instanceof TText)
+ || (this instanceof TComboBox)
+ ) {
+
+ // Defaults:
+ // tab / shift-tab - switch to next/previous widget
+ // left-arrow or up-arrow: same as shift-tab
+ if ((keypress.equals(kbTab))
+ || (keypress.equals(kbDown) && !(this instanceof TComboBox))
+ ) {
+ parent.switchWidget(true);
+ return;
+ } else if ((keypress.equals(kbShiftTab))
+ || (keypress.equals(kbBackTab))
+ || (keypress.equals(kbUp) && !(this instanceof TComboBox))
+ ) {
+ parent.switchWidget(false);
+ return;
+ }
+ }
+
+ if ((children.size() == 0)
+ && !(this instanceof TTreeView)
+ ) {
+
+ // Defaults:
+ // right-arrow or down-arrow: same as tab
+ if (keypress.equals(kbRight)) {
+ parent.switchWidget(true);
+ return;
+ } else if (keypress.equals(kbLeft)) {
+ parent.switchWidget(false);
+ return;
+ }
+ }
+
+ // If I have any buttons on me AND this is an Alt-key that matches
+ // its mnemonic, send it an Enter keystroke.
+ for (TWidget widget: children) {
+ if (widget instanceof TButton) {
+ TButton button = (TButton) widget;
+ if (button.isEnabled()
+ && !keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (Character.toLowerCase(button.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar()))
+ ) {
+
+ widget.onKeypress(new TKeypressEvent(kbEnter));
+ return;
+ }
+ }
+ }
+
+ // If I have any labels on me AND this is an Alt-key that matches
+ // its mnemonic, call its action.
+ for (TWidget widget: children) {
+ if (widget instanceof TLabel) {
+ TLabel label = (TLabel) widget;
+ if (!keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (Character.toLowerCase(label.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar()))
+ ) {
+
+ label.dispatch();
+ return;
+ }
+ }
+ }
+
+ // If I have any radiobuttons on me AND this is an Alt-key that
+ // matches its mnemonic, select it and send a Space to it.
+ for (TWidget widget: children) {
+ if (widget instanceof TRadioButton) {
+ TRadioButton button = (TRadioButton) widget;
+ if (button.isEnabled()
+ && !keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (Character.toLowerCase(button.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar()))
+ ) {
+ activate(widget);
+ widget.onKeypress(new TKeypressEvent(kbSpace));
+ return;
+ }
+ }
+ if (widget instanceof TRadioGroup) {
+ for (TWidget child: widget.getChildren()) {
+ if (child instanceof TRadioButton) {
+ TRadioButton button = (TRadioButton) child;
+ if (button.isEnabled()
+ && !keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (Character.toLowerCase(button.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar()))
+ ) {
+ activate(widget);
+ widget.activate(child);
+ child.onKeypress(new TKeypressEvent(kbSpace));
+ return;
+ }
+ }
+ }
+ }
+ }
+
+ // If I have any checkboxes on me AND this is an Alt-key that matches
+ // its mnemonic, select it and set it to checked.
+ for (TWidget widget: children) {
+ if (widget instanceof TCheckBox) {
+ TCheckBox checkBox = (TCheckBox) widget;
+ if (checkBox.isEnabled()
+ && !keypress.getKey().isFnKey()
+ && keypress.getKey().isAlt()
+ && !keypress.getKey().isCtrl()
+ && (Character.toLowerCase(checkBox.getMnemonic().getShortcut())
+ == Character.toLowerCase(keypress.getKey().getChar()))
+ ) {
+ activate(checkBox);
+ checkBox.setChecked(true);
+ return;
+ }
+ }
+ }
+
+ // Dispatch the keypress to an active widget
+ for (TWidget widget: children) {
+ if (widget.active) {
+ widget.onKeypress(keypress);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle mouse button presses.
+ *
+ * @param mouse mouse button event
+ */
+ public void onMouseDown(final TMouseEvent mouse) {
+ // Default: do nothing, pass to children instead
+ if (activeChild != null) {
+ if (activeChild.mouseWouldHit(mouse)) {
+ // Dispatch to the active child
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - activeChild.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - activeChild.getAbsoluteY());
+ activeChild.onMouseDown(mouse);
+ return;
+ }
+ }
+ for (int i = children.size() - 1 ; i >= 0 ; i--) {
+ TWidget widget = children.get(i);
+ if (widget.mouseWouldHit(mouse)) {
+ // Dispatch to this child, also activate it
+ activate(widget);
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - widget.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - widget.getAbsoluteY());
+ widget.onMouseDown(mouse);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle mouse button releases.
+ *
+ * @param mouse mouse button event
+ */
+ public void onMouseUp(final TMouseEvent mouse) {
+ // Default: do nothing, pass to children instead
+ if (activeChild != null) {
+ if (activeChild.mouseWouldHit(mouse)) {
+ // Dispatch to the active child
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - activeChild.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - activeChild.getAbsoluteY());
+ activeChild.onMouseUp(mouse);
+ return;
+ }
+ }
+ for (int i = children.size() - 1 ; i >= 0 ; i--) {
+ TWidget widget = children.get(i);
+ if (widget.mouseWouldHit(mouse)) {
+ // Dispatch to this child, also activate it
+ activate(widget);
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - widget.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - widget.getAbsoluteY());
+ widget.onMouseUp(mouse);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle mouse movements.
+ *
+ * @param mouse mouse motion event
+ */
+ public void onMouseMotion(final TMouseEvent mouse) {
+ // Default: do nothing, pass it on to ALL of my children. This way
+ // the children can see the mouse "leaving" their area.
+ for (TWidget widget: children) {
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - widget.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - widget.getAbsoluteY());
+ widget.onMouseMotion(mouse);
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle mouse button
+ * double-clicks.
+ *
+ * @param mouse mouse button event
+ */
+ public void onMouseDoubleClick(final TMouseEvent mouse) {
+ // Default: do nothing, pass to children instead
+ if (activeChild != null) {
+ if (activeChild.mouseWouldHit(mouse)) {
+ // Dispatch to the active child
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - activeChild.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - activeChild.getAbsoluteY());
+ activeChild.onMouseDoubleClick(mouse);
+ return;
+ }
+ }
+ for (int i = children.size() - 1 ; i >= 0 ; i--) {
+ TWidget widget = children.get(i);
+ if (widget.mouseWouldHit(mouse)) {
+ // Dispatch to this child, also activate it
+ activate(widget);
+
+ // Set x and y relative to the child's coordinates
+ mouse.setX(mouse.getAbsoluteX() - widget.getAbsoluteX());
+ mouse.setY(mouse.getAbsoluteY() - widget.getAbsoluteY());
+ widget.onMouseDoubleClick(mouse);
+ return;
+ }
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle window/screen resize
+ * events.
+ *
+ * @param resize resize event
+ */
+ public void onResize(final TResizeEvent resize) {
+ // Default: change my width/height.
+ if (resize.getType() == TResizeEvent.Type.WIDGET) {
+ width = resize.getWidth();
+ height = resize.getHeight();
+ if (layout != null) {
+ if (this instanceof TWindow) {
+ layout.onResize(new TResizeEvent(TResizeEvent.Type.WIDGET,
+ width - 2, height - 2));
+ } else {
+ layout.onResize(resize);
+ }
+ }
+ } else {
+ // Let children see the screen resize
+ for (TWidget widget: children) {
+ widget.onResize(resize);
+ }
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle posted command events.
+ *
+ * @param command command event
+ */
+ public void onCommand(final TCommandEvent command) {
+ // Default: do nothing, pass to children instead
+ for (TWidget widget: children) {
+ widget.onCommand(command);
+ }
+ }
+
+ /**
+ * Method that subclasses can override to handle menu or posted menu
+ * events.
+ *
+ * @param menu menu event
+ */
+ public void onMenu(final TMenuEvent menu) {
+
+ // Special case: if a split command comes in, insert a TPanel and
+ // TSplitPane in the hierarchy here.
+ TPanel panel = null;
+ TSplitPane pane = null;
+ List<TWidget> widgets = null;
+ switch (menu.getId()) {
+ case TMenu.MID_SPLIT_VERTICAL:
+ if (children.size() == 0) {
+ break;
+ }
+ panel = new TPanel(null, x, y, width, height);
+ pane = new TSplitPane(null, x, y, width, height, true);
+ widgets = new ArrayList<TWidget>(children);
+ for (TWidget w: widgets) {
+ w.setParent(panel, false);
+ }
+ children.clear();
+ pane.setParent(this, false);
+ pane.setLeft(panel);
+ activate(pane);
+ for (TWidget w: widgets) {
+ assert (w.window != null);
+ assert (w.parent != null);
+ }
+ assert (pane.getWindow() != null);
+ assert (pane.getParent() != null);
+ assert (panel.getWindow() != null);
+ assert (panel.getParent() != null);
+ assert (pane.isActive() == true);
+ assert (panel.isActive() == true);
+ return;
+ case TMenu.MID_SPLIT_HORIZONTAL:
+ if (children.size() == 0) {
+ break;
+ }
+ panel = new TPanel(null, x, y, width, height);
+ pane = new TSplitPane(null, x, y, width, height, false);
+ widgets = new ArrayList<TWidget>(children);
+ for (TWidget w: widgets) {
+ w.setParent(panel, false);
+ }
+ children.clear();
+ pane.setParent(this, false);
+ pane.setTop(panel);
+ activate(pane);
+ for (TWidget w: widgets) {
+ assert (w.window != null);
+ assert (w.parent != null);
+ }
+ assert (pane.getWindow() != null);
+ assert (pane.getParent() != null);
+ assert (panel.getWindow() != null);
+ assert (panel.getParent() != null);
+ assert (pane.isActive() == true);
+ assert (panel.isActive() == true);
+ return;
+ default:
+ break;
+ }
+
+ // Default: do nothing, pass to children instead
+ for (TWidget widget: children) {
+ widget.onMenu(menu);
+ }
+ }
+
+ /**
+ * Method that subclasses can override to do processing when the UI is
+ * idle. Note that repainting is NOT assumed. To get a refresh after
+ * onIdle, call doRepaint().
+ */
+ public void onIdle() {
+ // Default: do nothing, pass to children instead
+ for (TWidget widget: children) {
+ widget.onIdle();
+ }
+ }
+
+ /**
+ * Consume event. Subclasses that want to intercept all events in one go
+ * can override this method.
+ *
+ * @param event keyboard, mouse, resize, command, or menu event
+ */
+ public void handleEvent(final TInputEvent event) {
+ /*
+ System.err.printf("TWidget (%s) event: %s\n", this.getClass().getName(),
+ event);
+ */
+
+ if (!enabled) {
+ // Discard event
+ // System.err.println(" -- discard --");
+ return;
+ }
+
+ if (event instanceof TKeypressEvent) {
+ onKeypress((TKeypressEvent) event);
+ } else if (event instanceof TMouseEvent) {
+
+ TMouseEvent mouse = (TMouseEvent) event;
+
+ switch (mouse.getType()) {
+
+ case MOUSE_DOWN:
+ onMouseDown(mouse);
+ break;
+
+ case MOUSE_UP:
+ onMouseUp(mouse);
+ break;
+
+ case MOUSE_MOTION:
+ onMouseMotion(mouse);
+ break;
+
+ case MOUSE_DOUBLE_CLICK:
+ onMouseDoubleClick(mouse);
+ break;
+
+ default:
+ throw new IllegalArgumentException("Invalid mouse event type: "
+ + mouse.getType());
+ }
+ } else if (event instanceof TResizeEvent) {
+ onResize((TResizeEvent) event);
+ } else if (event instanceof TCommandEvent) {
+ onCommand((TCommandEvent) event);
+ } else if (event instanceof TMenuEvent) {
+ onMenu((TMenuEvent) event);
+ }
+
+ // Do nothing else
+ return;
+ }
+
+ // ------------------------------------------------------------------------
+ // TWidget ----------------------------------------------------------------
+ // ------------------------------------------------------------------------
+