Controller (ktgui 1.1.2-SNAPSHOT API)

java.lang.Object
- ktbyte.gui.EventProcessor
- - ktbyte.gui.Controller

All Implemented Interfaces:

def.processing.core.PConstants

Direct Known Subclasses:

ArrowButton, Bar, Button, Console, InputTextBox, Pane, Panel, ScrollableTextArea, ScrollBar, Slider
```
public abstract class Controller
extends EventProcessor
implements def.processing.core.PConstants
```
This class automatically receives events from PApplet when they happen. Every KTGUI component (controller) should extend this class in order to be able to receive the mouse and keyboard events. One should override only the 'needed' event methods. This allows to save time and decrease the amount of code. One should always overridde the 'draw' method.

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`bgHoveredColor`
`int`	`bgPassiveColor`
`int`	`bgPressedColor`
`ArrayList<Controller>`	`controllers`
`int`	`fgHoveredColor`
`int`	`fgPassiveColor`
`int`	`fgPressedColor`
`int`	`h`
`KTGUI`	`ktgui`
`def.processing.core.PApplet`	`pa`
`Controller`	`parentController`
`Stage`	`parentStage`
`def.processing.core.PGraphics`	`pg`
`int`	`posx`
`int`	`posy`
`int`	`r1`
`int`	`r2`
`int`	`r3`
`int`	`r4`
`static Controller`	`selectedController`
`String`	`title`
`def.processing.core.PGraphics`	`userpg`
`int`	`w`

Fields inherited from class ktbyte.gui.EventProcessor
adapters, handleFocus, isActive, isDragable, isDragged, isHovered, isPressed, isVisible

Fields inherited from interface def.processing.core.PConstants
ADD, ALPHA, ALT, AMBIENT, ARC, ARGB, ARROW, BACKSPACE, BASELINE, BEVEL, BEZIER_VERTEX, BLEND, BLUR, BOTTOM, BOX, BREAK, BURN, CENTER, CHATTER, CHORD, CLAMP, CLOSE, CODED, COMPLAINT, CONTROL, CORNER, CORNERS, CROSS, CURVE_VERTEX, CUSTOM, DARKEST, DEG_TO_RAD, DELETE, DIAMETER, DIFFERENCE, DILATE, DIRECTIONAL, DISABLE_ASYNC_SAVEFRAME, DISABLE_BUFFER_READING, DISABLE_DEPTH_MASK, DISABLE_DEPTH_SORT, DISABLE_DEPTH_TEST, DISABLE_KEY_REPEAT, DISABLE_NATIVE_FONTS, DISABLE_OPENGL_ERRORS, DISABLE_OPTIMIZED_STROKE, DISABLE_STROKE_PERSPECTIVE, DISABLE_STROKE_PURE, DISABLE_TEXTURE_MIPMAPS, DODGE, DOWN, DXF, ELLIPSE, ENABLE_ASYNC_SAVEFRAME, ENABLE_BUFFER_READING, ENABLE_DEPTH_MASK, ENABLE_DEPTH_SORT, ENABLE_DEPTH_TEST, ENABLE_KEY_REPEAT, ENABLE_NATIVE_FONTS, ENABLE_OPENGL_ERRORS, ENABLE_OPTIMIZED_STROKE, ENABLE_STROKE_PERSPECTIVE, ENABLE_STROKE_PURE, ENABLE_TEXTURE_MIPMAPS, ENTER, EPSILON, ERODE, ESC, EXCLUSION, FX2D, GIF, GRAY, GROUP, HALF_PI, HAND, HARD_LIGHT, HINT_COUNT, HSB, IMAGE, INVERT, JAVA2D, JPEG, LANDSCAPE, LEFT, LIGHTEST, LINE, LINE_LOOP, LINE_STRIP, LINES, LINUX, MACOSX, MAX_FLOAT, MAX_INT, MIN_FLOAT, MIN_INT, MITER, MODEL, MODELVIEW, MOVE, MULTIPLY, NORMAL, OPAQUE, OPEN, OPENGL, ORTHOGRAPHIC, OTHER, OVERLAY, P2D, P3D, PATH, PDF, PERSPECTIVE, PI, PIE, platformNames, POINT, POINTS, POLYGON, PORTRAIT, POSTERIZE, PROBLEM, PROJECT, PROJECTION, QUAD, QUAD_BEZIER_VERTEX, QUAD_STRIP, QUADRATIC_VERTEX, QUADS, QUARTER_PI, RAD_TO_DEG, RADIUS, RECT, REPEAT, REPLACE, RETURN, RGB, RIGHT, ROUND, SCREEN, SHAPE, SHIFT, SOFT_LIGHT, SPAN, SPHERE, SPOT, SQUARE, SUBTRACT, SVG, TAB, TARGA, TAU, TEXT, THIRD_PI, THRESHOLD, TIFF, TOP, TRIANGLE, TRIANGLE_FAN, TRIANGLE_STRIP, TRIANGLES, TWO_PI, UP, VERTEX, WAIT, WHITESPACE, WINDOWS, X, Y, Z

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addController(Controller child, int hAlign, int vAlign)`
`void`	`addController(Controller child, int hAlign, int vAlign, int gap)`
`void`	`alignAbout(Controller controller, int hAlign, int vAlign)`
`void`	`alignAbout(Controller controller, int hAlign, int vAlign, int gap)` This method is used to place one controller inside the other (reference) controller.
`void`	`alignAboutCanvas(int hAlign, int vAlign)`
`void`	`alignAboutCanvas(int hAlign, int vAlign, int gap)`
`void`	`attachController(Controller controller)`
`void`	`close()`
`void`	`closeAllChildsRecursively()`
`void`	`closeParent()`
`void`	`detachAllControllers()`
`void`	`detachController(Controller controller)`
`void`	`draw()`
`void`	`drawControllers()`
`void`	`drawUserDefinedGraphics()`
`int`	`getAbsolutePosX()`
`int`	`getAbsolutePosY()`
`ArrayList<String>`	`getFullInfoList(int level)`
`def.processing.core.PGraphics`	`getGraphics()`
`int`	`getHeight()`
`String`	`getInfo()`
`float`	`getPosx()`
`float`	`getPosy()`
`int`	`getWidth()`
`boolean`	`isAnyChildPressed()`
`boolean`	`isPointInside(int x, int y)`
`boolean`	`isSelected(Controller controller)`
`void`	`positionAboutOtherController(Controller controller, int relativePosx, int relativePosy)`
`void`	`processKeyPressed()`
`void`	`processKeyReleased()`
`void`	`processMouseDragged()`
`void`	`processMouseMoved()`
`void`	`processMousePressed()`
`void`	`processMouseReleased()`
`void`	`processMouseWheel(def.processing.event.MouseEvent me)`
`void`	`setBorderRoundings(int r1, int r2, int r3, int r4)`
`void`	`setHandleFocus(boolean val)`
`void`	`setHeight(int h)`
`void`	`setHoveredColor(int c)`
`void`	`setParentController(Controller controller)`
`void`	`setPassiveColor(int c)`
`void`	`setPosx(int posx)`
`void`	`setPosy(int posy)`
`void`	`setPressedColor(int c)`
`void`	`setTitle(String title)`
`void`	`setWidth(int w)`
`void`	`stackAbout(Controller controller, int direction, int align)`
`void`	`stackAbout(Controller controller, int direction, int align, int gap)` This method is used to position one controller outside the other (reference) controller.
`void`	`updateGraphics()`
`void`	`updateUserDefinedGraphics(def.processing.core.PGraphics userpg)`

Methods inherited from class ktbyte.gui.EventProcessor
addEventAdapter

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - title
```
public String title
```
  - posx
```
public int posx
```
  - posy
```
public int posy
```
  - w
```
public int w
```
  - h
```
public int h
```
  - r1
```
public int r1
```
  - r2
```
public int r2
```
  - r3
```
public int r3
```
  - r4
```
public int r4
```
  - controllers
```
public ArrayList<Controller> controllers
```
  - pa
```
public def.processing.core.PApplet pa
```
  - ktgui
```
public KTGUI ktgui
```
  - parentController
```
public Controller parentController
```
  - parentStage
```
public Stage parentStage
```
  - selectedController
```
public static Controller selectedController
```
  - pg
```
public def.processing.core.PGraphics pg
```
  - userpg
```
public def.processing.core.PGraphics userpg
```
  - fgHoveredColor
```
public int fgHoveredColor
```
  - fgPressedColor
```
public int fgPressedColor
```
  - fgPassiveColor
```
public int fgPassiveColor
```
  - bgHoveredColor
```
public int bgHoveredColor
```
  - bgPressedColor
```
public int bgPressedColor
```
  - bgPassiveColor
```
public int bgPassiveColor
```
- Method Detail
  - updateGraphics
```
public void updateGraphics()
```
  - updateUserDefinedGraphics
```
public void updateUserDefinedGraphics(def.processing.core.PGraphics userpg)
```
  - drawUserDefinedGraphics
```
public void drawUserDefinedGraphics()
```
  - drawControllers
```
public void drawControllers()
```
  - draw
```
public void draw()
```
  - setParentController
```
public void setParentController(Controller controller)
```
  - setTitle
```
public void setTitle(String title)
```
  - getInfo
```
public String getInfo()
```
  - getFullInfoList
```
public ArrayList<String> getFullInfoList(int level)
```
  - getWidth
```
public int getWidth()
```
  - setWidth
```
public void setWidth(int w)
```
  - getHeight
```
public int getHeight()
```
  - getAbsolutePosX
```
public int getAbsolutePosX()
```
  - getAbsolutePosY
```
public int getAbsolutePosY()
```
  - setHeight
```
public void setHeight(int h)
```
  - setHoveredColor
```
public void setHoveredColor(int c)
```
  - setPressedColor
```
public void setPressedColor(int c)
```
  - setPassiveColor
```
public void setPassiveColor(int c)
```
  - setBorderRoundings
```
public void setBorderRoundings(int r1,
                               int r2,
                               int r3,
                               int r4)
```
  - setHandleFocus
```
public void setHandleFocus(boolean val)
```
  - getGraphics
```
public def.processing.core.PGraphics getGraphics()
```
  - addController
```
public void addController(Controller child,
                          int hAlign,
                          int vAlign)
```
  - addController
```
public void addController(Controller child,
                          int hAlign,
                          int vAlign,
                          int gap)
```
  - positionAboutOtherController
```
public void positionAboutOtherController(Controller controller,
                                         int relativePosx,
                                         int relativePosy)
```
  - attachController
```
public void attachController(Controller controller)
```
  - detachController
```
public void detachController(Controller controller)
```
  - detachAllControllers
```
public void detachAllControllers()
```
  - closeParent
```
public void closeParent()
```
  - closeAllChildsRecursively
```
public void closeAllChildsRecursively()
```
  - close
```
public void close()
```
  - getPosx
```
public float getPosx()
```
  - setPosx
```
public void setPosx(int posx)
```
  - getPosy
```
public float getPosy()
```
  - setPosy
```
public void setPosy(int posy)
```
  - alignAboutCanvas
```
public void alignAboutCanvas(int hAlign,
                             int vAlign)
```
    Parameters:
    
    hAlign - the horizontal alignment position
    
    vAlign - the vertical alignment position
    
    See Also:
    
    alignAboutCanvas
  - alignAboutCanvas
```
public void alignAboutCanvas(int hAlign,
                             int vAlign,
                             int gap)
```
    Parameters:
    
    hAlign - the horizontal alignment position
    
    vAlign - the vertical alignment position
    
    gap - the gap between the outer boundary of the PApplet canvas and the side of the controller to be aligned.
  - alignAbout
```
public void alignAbout(Controller controller,
                       int hAlign,
                       int vAlign)
```
    Parameters:
    
    controller - the controller whos position is used as a 'reference' for aligning process
    
    hAlign - the horizontal alignment position
    
    vAlign - the vertical alignment position
  - alignAbout
```
public void alignAbout(Controller controller,
                       int hAlign,
                       int vAlign,
                       int gap)
```
    This method is used to place one controller inside the other (reference) controller. By 'aligning' we understand the process of changing the X and Y coordinates so that the controller is placed inside and near one of the walls of the reference controller. The X and Y position, and width and height of the controller being used as a reference are used to calculate the new position of the controller that is to be aligned. The said values identify the 'boundary rectangle' of the reference controller. The named constants LEFT, RIGHT, BOTTOM, TOP and CENTER are used to identify the sides and the center of the bounding rectangle. The sides and center of the reference rectangle are used for calculation of the relative distances that are used to 'shift' the position of the controller to be aligned. The direction of shifting is inward - i.e. the changing of relative position is made from the sides of the bounding rectangle to the center of the bounding rectangle.
    Parameters:
    
    controller - the 'reference' controller.
    hAlign - the horizontal alignment direction. The following named constants can be used:
    
    LEFT - the controller will be placed so that its left side will 'stick' to the left side of the reference controller.
    
    RIGHT - the controller will be placed so that its right side will 'stick' to the right side of the reference controller.
    
    CENTER - the controller will be placed so that its center will 'stick' to the center of the reference controller.
    vAlign - the vertical alignment direction. The following named constants can be used:
    
    TOP - the controller will be placed so that its top side will 'stick' to the top side of the reference controller.
    
    BOTTOM - the controller will be placed so that its bottom side will 'stick' to the bottom side of the reference controller.
    
    CENTER - the controller will be placed so that its center will 'stick' to the center of the reference controller.
    gap - the gap between aligned sides. If the CENTER constant is used as hAlign or vAlign argument then the gap will not be added to that direction.
  - stackAbout
```
public void stackAbout(Controller controller,
                       int direction,
                       int align)
```
  - stackAbout
```
public void stackAbout(Controller controller,
                       int direction,
                       int align,
                       int gap)
```
    This method is used to position one controller outside the other (reference) controller. By 'stacking' we understand the process of changing the X and Y coordinates so that the controller is placed outside and near one of the walls of the reference controller. The X and Y position, and width and height of the controller being used as a reference are used to calculate the new position of the controller to be aligned. The said values identify the 'boundary rectangle' of the reference controller. The named constants LEFT, RIGHT, BOTTOM and TOP are used to identify the sides of the bounding rectangle. They are used for calculation of the relative distances that are used to 'shift' the position of the controller to be aligned. The direction of shifting is outward - i.e. the changing of relative position is made from the sides of the bounding rectangle to the outward direction about the bounding rectangle.
    Parameters:
    
    controller - the 'reference' controller.
    direction - the 'reference' alignment direction. The following named constants can be used:
    
    LEFT - the controller will be placed so that its rigth side will 'stick' to the left side of the reference controller.
    
    RIGHT - the controller will be placed so that its left side will 'stick' to the right side of the reference controller.
    
    TOP - the controller will be placed so that its bottom side will 'stick' to the top side of the reference controller.
    
    BOTTOM - the controller will be placed so that its top side will 'stick' to the bottom side of the reference controller.
    align - the 'orthogonal' alignment direction.
    The following named constants can be used:
    If the 'reference' alignment direction was chosen as LEFT or RIGTH, then the 'orthogonal' direction can be set only fron one of the following constants:
    
    TOP - the controller will be placed so that its top side will be aligned to the top side of the reference controller.
    
    BOTTOM - the controller will be placed so that its bottom side will be aligned to the bottom side of the reference controller.
    
    CENTER - the controller will be placed so that its center will be aligned to the center of the reference controller.
    
    If the 'reference' alignment direction was chosen as BOTTOM or TOP, then the 'orthogonal' direction can be set only from one of the following constants:
    
    LEFT - the controller will be placed so that its left side will be aligned to the left side of the reference controller.
    
    RIGHT - the controller will be placed so that its right side will be aligned to the right side of the reference controller.
    
    CENTER - the controller will be placed so that its center will be aligned to the center of the reference controller.
    gap - the gap of some length between the sides to be aligned. If the CENTER constant is used as 'direction' or 'align' argument then the gap is not added in that direction.
  - isAnyChildPressed
```
public boolean isAnyChildPressed()
```
  - processMouseMoved
```
public void processMouseMoved()
```
    Overrides:
    
    processMouseMoved in class EventProcessor
  - processMousePressed
```
public void processMousePressed()
```
    Overrides:
    
    processMousePressed in class EventProcessor
  - processMouseReleased
```
public void processMouseReleased()
```
    Overrides:
    
    processMouseReleased in class EventProcessor
  - processMouseDragged
```
public void processMouseDragged()
```
    Overrides:
    
    processMouseDragged in class EventProcessor
  - processMouseWheel
```
public void processMouseWheel(def.processing.event.MouseEvent me)
```
    Overrides:
    
    processMouseWheel in class EventProcessor
  - processKeyPressed
```
public void processKeyPressed()
```
    Overrides:
    
    processKeyPressed in class EventProcessor
  - processKeyReleased
```
public void processKeyReleased()
```
    Overrides:
    
    processKeyReleased in class EventProcessor
  - isSelected
```
public boolean isSelected(Controller controller)
```
  - isPointInside
```
public boolean isPointInside(int x,
                             int y)
```
    Overrides:
    
    isPointInside in class EventProcessor

Class Controller

Field Summary

Fields inherited from class ktbyte.gui.EventProcessor

Fields inherited from interface def.processing.core.PConstants

Method Summary

Methods inherited from class ktbyte.gui.EventProcessor

Methods inherited from class java.lang.Object

Field Detail

title

posx

posy

w

h

r1

r2

r3

r4

controllers

pa

ktgui

parentController

parentStage

selectedController

pg

userpg

fgHoveredColor

fgPressedColor

fgPassiveColor

bgHoveredColor

bgPressedColor

bgPassiveColor

Method Detail

updateGraphics

updateUserDefinedGraphics

drawUserDefinedGraphics

drawControllers

draw

setParentController

setTitle

getInfo

getFullInfoList

getWidth

setWidth

getHeight

getAbsolutePosX

getAbsolutePosY

setHeight

setHoveredColor

setPressedColor

setPassiveColor

setBorderRoundings

setHandleFocus

getGraphics

addController

addController

positionAboutOtherController

attachController

detachController

detachAllControllers

closeParent

closeAllChildsRecursively

close

getPosx

setPosx

getPosy

setPosy

alignAboutCanvas

alignAboutCanvas

alignAbout

alignAbout

stackAbout

stackAbout

isAnyChildPressed

processMouseMoved

processMousePressed

processMouseReleased

processMouseDragged

processMouseWheel

processKeyPressed

processKeyReleased