Added documentation

application.go

@@ -62,11 +62,14 @@ func (application *Application) SetTitle (title string) (err error) {
 	return 
 }
 
+// Title returns the application's title.
 func (application *Application) Title () (title string) {
 	title = application.title
 	return
 }
 
+// SetIcon takes in a list of different sizes of an icon, and sets it as the
+// application's icon.
 func (application *Application) SetIcon (sizes []image.Image) (err error) {
 	application.icons = sizes
 	if application.backend != nil {
@@ -76,6 +79,8 @@ func (application *Application) SetIcon (sizes []image.Image) (err error) {
 	return
 }
 
+// Icon returns all available sizes of the application's icon. If there is no
+// icon, nil is returned.
 func (application *Application) Icon () (sizes []image.Image) {
 	sizes = application.icons
 	return

buffer.go

@@ -1,5 +1,6 @@
 package stone
 
+// Color represents all the different colors a cell can be.
 type Color uint8
 
 const (
@@ -9,6 +10,8 @@ const (
 	ColorApplication Color = 0x3
 )
 
+// Style contains styling information about cells. These properties can be or'd
+// together to combine them.
 type Style uint8
 
 const (
@@ -18,27 +21,33 @@ const (
 	StyleBoldItalic Style = StyleBold | StyleItalic
 )
 
+// Cell is a grid-aligned rune in a buffer with associated styling and color
+// informaiton.
 type Cell struct {
 	color   Color
 	style   Style
 	content rune
 }
 
+// Color returns the cell's color.
 func (cell Cell) Color (color Color) {
 	color = cell.color
 	return
 }
 
+// Style returns the styling information associated with the cell
 func (cell Cell) Style (style Style) {
 	style = cell.style
 	return
 }
 
+// Rune returns the rune in the cell
 func (cell Cell) Rune () (content rune) {
 	content = cell.content
 	return
 }
 
+// Buffer is a basic grid of cells.
 type Buffer struct {
 	content []Cell
 	width  int
@@ -58,12 +67,15 @@ func (buffer *Buffer) isOutOfBounds (x, y int) (outOfBounds bool) {
 	return
 }
 
+// Size returns the width and height of the buffer.
 func (buffer *Buffer) Size () (width, height int) {
 	width  = buffer.width
 	height = buffer.height
 	return
 }
 
+// SetSize sets the width and height of the buffer. This clears all data in the
+// buffer. If the width or height is negative, this method does nothing.
 func (buffer *Buffer) SetSize (width, height int) {
 	if width < 0 || height < 0 { return }
 	buffer.width   = width
@@ -71,27 +83,34 @@ func (buffer *Buffer) SetSize (width, height int) {
 	buffer.content = make([]Cell, width * height)
 }
 
+// Cell returns the cell at the specified x and y coordinates. If the
+// coordinates are out of bounds, this method will return a blank cell.
 func (buffer *Buffer) Cell (x, y int) (cell Cell) {
 	if buffer.isOutOfBounds(x, y) { return }
 	cell = buffer.content[x + y * buffer.width]
 	return
 }
 
+// SetColor sets the color of the cell at the specified x and y coordinates.
 func (buffer *Buffer) SetColor (x, y int, color Color) {
 	if buffer.isOutOfBounds(x, y) { return }
 	buffer.content[x + y * buffer.width].color = color
 }
 
+// SetStyle sets the style of the cell at the specified x and y coordinates.
 func (buffer *Buffer) SetStyle (x, y int, style Style) {
 	if buffer.isOutOfBounds(x, y) { return }
 	buffer.content[x + y * buffer.width].style = style
 }
 
+// SetRune sets the rune of the cell at the specified x and y coordinates.
 func (buffer *Buffer) SetRune (x, y int, content rune) {
 	if buffer.isOutOfBounds(x, y) { return }
 	buffer.content[x + y * buffer.width].content = content
 }
 
+// Write writes data stored in a byte slice to the buffer at the current dot
+// position. This makes Buffer an io.Writer.
 func (buffer *Buffer) Write (bytes []byte) (bytesWritten int, err error) {
 	text := string(bytes)
 	bytesWritten = len(bytes)
@@ -105,22 +124,30 @@ func (buffer *Buffer) Write (bytes []byte) (bytesWritten int, err error) {
 	return
 }
 
+// ResetDot is a convenience method to reset the dot to the buffer origin point
+// (0, 0).
 func (buffer *Buffer) ResetDot () {
 	buffer.Dot.X = 0
 	buffer.Dot.Y = 0
 }
 
+// DamageBuffer is a special buffer that keeps track of damage information.
+// Cells are dirty by default, are only clean when marked as clean, and become
+// dirty again when they are altered in some way.
 type DamageBuffer struct {
 	Buffer
 	clean []bool
 }
 
+// SetSize sets the width and height of the buffer. This clears all data in the
+// buffer. If the width or height is negative, this method does nothing.
 func (buffer *DamageBuffer) SetSize (width, height int) {
 	if width < 0 || height < 0 { return }
 	buffer.Buffer.SetSize(width, height)
 	buffer.clean = make([]bool, width * height)
 }
 
+// SetColor sets the color of the cell at the specified x and y coordinates.
 func (buffer *DamageBuffer) SetColor (x, y int, color Color) {
 	if buffer.isOutOfBounds(x, y) { return }
 	index := x + y * buffer.width
@@ -128,6 +155,7 @@ func (buffer *DamageBuffer) SetColor (x, y int, color Color) {
 	buffer.Buffer.SetColor(x, y, color)
 }
 
+// SetStyle sets the style of the cell at the specified x and y coordinates.
 func (buffer *DamageBuffer) SetStyle (x, y int, style Style) {
 	if buffer.isOutOfBounds(x, y) { return }
 	index := x + y * buffer.width
@@ -135,6 +163,7 @@ func (buffer *DamageBuffer) SetStyle (x, y int, style Style) {
 	buffer.Buffer.SetStyle(x, y, style)
 }
 
+// SetRune sets the rune of the cell at the specified x and y coordinates.
 func (buffer *DamageBuffer) SetRune (x, y int, content rune) {
 	if buffer.isOutOfBounds(x, y) { return }
 	index := x + y * buffer.width
@@ -142,6 +171,8 @@ func (buffer *DamageBuffer) SetRune (x, y int, content rune) {
 	buffer.Buffer.SetRune(x, y, content)
 }
 
+// Write writes data stored in a byte slice to the buffer at the current dot
+// position. This makes DamageBuffer an io.Writer.
 func (buffer *DamageBuffer) Write (bytes []byte) (bytesWritten int, err error) {
 	text := string(bytes)
 	bytesWritten = len(bytes)
@@ -155,12 +186,15 @@ func (buffer *DamageBuffer) Write (bytes []byte) (bytesWritten int, err error) {
 	return
 }
 
+// Clean returns whether or not the cell at the specified x and y coordinates is
+// clean.
 func (buffer *DamageBuffer) Clean (x, y int) (clean bool) {
 	if buffer.isOutOfBounds(x, y) { return }
 	clean = buffer.clean[x + y * buffer.width]
 	return
 }
 
+// MarkClean marks the cell at the specified x and y coordinates as clean.
 func (buffer *DamageBuffer) MarkClean (x, y int) {
 	if buffer.isOutOfBounds(x, y) { return }
 	buffer.clean[x + y * buffer.width] = true

event.go

@@ -1,11 +1,26 @@
 package stone
 
+// Event can be any event.
 type Event interface { }
 
-type EventQuit      struct { }
-type EventPress     struct { Button }
-type EventRelease   struct { Button }
-type EventResize    struct { }
+// EventQuit is sent when the backend shuts down due to a window close, error,
+// or something else.
+type EventQuit struct { }
+
+// EventPress is sent when a button is pressed, or a key repeat event is
+// triggered.
+type EventPress struct { Button }
+
+// Release is sent when a button is released.
+type EventRelease struct { Button }
+
+// Resize is sent when the application window is resized by the user. This event
+// must be handled, as it implies that the buffer has been resized and therefore
+// cleared. Application.Draw() must be called after this event is recieved.
+type EventResize struct { }
+
+// EventMouseMove is sent when the mouse changes position. It contains the X and
+// Y position of the mouse.
 type EventMouseMove struct {
 	X int
 	Y int

input.go

@@ -2,6 +2,7 @@ package stone
 
 import "unicode"
 
+// Button represents a keyboard or mouse button.
 type Button int
 
 const (
@@ -72,6 +73,9 @@ const (
 	KeyF12 Button = 155
 )
 
+// Printable returns whether or not the character could show up on screen. If
+// this function returns true, the button can be cast to a rune and used as
+// such.
 func (button Button) Printable () (printable bool) {
 	printable = unicode.IsPrint(rune(button))
 	return