lsd_rails 0.1

data/Packages/mootools-more/Docs/Interface/HtmlTable.md

@@ -0,0 +1,250 @@
+Class: HtmlTable {#HtmlTable}
+=============================
+
+Builds table elements with methods to add rows quickly.
+
+### Tutorial/Demo
+
+* [Online Tutorial/Demo][]
+[Online Tutorial/Demo]:http://www.clientcide.com/wiki/cnet-libraries/08-layout/00-htmltable
+
+### Implements
+
+* [Options][], [Events][], [Class.Occlude][]
+
+HtmlTable Method: constructor
+-----------------------------
+
+### Syntax
+
+	new HtmlTable([table, options]);
+
+### Arguments
+
+1. table - (*mixed*; optional) - a Table DOM element or it's id; if you do not specify one, one will be created.
+1. options - (*object*; optional) a key/value set of options.
+
+### Options
+
+* properties - (*object*) a set of properties for the Table element; defaults to *{cellpadding:0, cellspacing:0, border:0}*
+* rows - (*array*) an array of row objects (see [HtmlTable.push][])
+* headers - (*array*) a row that is injected in the *thead*; required for sorting.
+
+### Example
+
+	var myTable = new HtmlTable({
+		properties: {
+			border: 1,
+			cellspacing: 3
+		},
+		headers: ['fruits', 'colors'],
+		rows: [
+			['apple', 'red'],
+			['lemon', 'yellow']
+		]
+	});
+	myTable.inject($('someContainer'));
+
+	//ALSO
+
+	var myTable = new HtmlTable($('existingTable'));
+	myTable.push(['data','goes','here']);
+
+HtmlTable Method: push {#HtmlTable:push}
+----------------------------------------
+
+Inserts a new table row. To push several at once, see (see [HtmlTable.pushMany](#HtmlTable:pushMany))
+
+### Syntax
+
+	myHtmlTable.push(row, rowProperties, target, tag, where);
+
+### Arguments
+
+1. row - (*array* or *element*) the data for the row or *TR* element.
+2. rowProperties - (*object*; optional) the properties for the row (class, id, styles, etc)
+3. target - (*element*; optional) The element that the row is injected into, before, after, etc. Defaults to the table body.
+4. tag - (*string*; optional) The type of element to create (`td` or `th`); defaults to `td`.
+5. where - (*string*; optional) the argument passed to `Element.inject` that specifies where the row is inserted relative to the specified target (`before`, `after`, `top`, `bottom`, etc)
+
+### Row data
+
+Row data can be in either of two formats. Note that they can be mixed and matched.
+
+* simple - (*array*) an array of strings, elements and element collections that will be inserted into each table data
+
+**OR**
+
+* detailed - (*array*) an array of objects with definitions for content and properties for each table data
+
+Note that it can also be an actual *TR* element.
+
+### Examples
+
+	//example of 'simple' rows
+	myTable.push(['value 1', 'value 2', 'value 3'], {
+		'class': 'tableRowClass'
+	}); //new row
+
+
+	//detailed rows
+	myTable.push([
+		{ //can specify data AND properties
+			content: 'value 4',
+			properties: {
+				colspan: 2,
+				'class': 'doubleWide',
+				style: '1px solid blue'
+			}
+		},
+		'value 5' //can just be data; mixing and the two in the same row is fine
+	]);
+
+
+	//RESULT:
+	<table cellpadding="0" cellspacing="0" border="0">
+		<tr class="tableRowClass">
+			<td>value 1</td>
+			<td>value 2</td>
+			<td>value 3</td>
+		</tr>
+		<tr>
+			<td colspan="2" class="doubleWide" style="1px solid blue">value 4</td>
+			<td>value 5</td>
+		</tr>
+	</table>
+
+### Returns
+
+* (*object*) an object containing the tr and td tags.
+
+### Example of Object Returned
+
+	{tr: theTableRow, tds: [td, td, td]}
+
+
+HtmlTable Method: pushMany {#HtmlTable:pushMany}
+----------------------------------------
+
+Inserts a group of rows into the table.
+
+### Syntax
+
+	myHtmlTable.push(rows, rowProperties, target, tag, where);
+
+### Arguments
+
+1. rows - (*array*) An array of row data objects (see [HtmlTable.push](#HtmlTable:push))
+2. rowProperties - (*object*; optional) the properties for the row (class, id, styles, etc)
+3. target - (*element*; optional) The element that the row is injected into, before, after, etc. Defaults to the table body.
+4. tag - (*string*; optional) The type of element to create (`td` or `th`); defaults to `td`.
+5. where - (*string*; optional) the argument passed to `Element.inject` that specifies where the row is inserted relative to the specified target (`before`, `after`, `top`, `bottom`, etc)
+
+### Example
+
+	//example of 'simple' rows
+	myTable.push([
+			[1, 'one'],
+			[2, 'two'],
+			[3, 'three']
+		], {
+		'class': 'tableRowClass'
+	});
+
+The above example would produce a table with 3 rows each with the class `tableRowClass`.
+
+### Returns
+
+* (*array*) An array of row results returned by [HtmlTable.push](#HtmlTable:push).
+
+HtmlTable method: empty {#HtmlTable:empty}
+------------------------------------------
+
+Empties the *tbody* of the table.
+
+### Syntax
+
+	myTable.empty();
+
+### Returns
+
+* (*object*) This instance of HtmlTable.
+
+HtmlTable method: set {#HtmlTable:set}
+----------------------------------------------------
+
+Sets the contents of the header or footer.
+
+### Syntax
+
+	myTable.set(what, rowArray);
+
+### Arguments
+
+1. what - (*string*) either 'headers' or 'footers'
+2. rowArray - (*array*) an array of header information; same as the row data sent to [HtmlTable.push][]
+
+### Returns
+
+* (*object*) The row data (same as returned by the *push* method).
+
+
+HtmlTable method: toElement {#HtmlTable:toElement}
+-----------------------------------------
+
+If you pass an instance of HtmlTable into the `$` or `document.id` function
+it will return the actual table Element.
+
+### Examples
+
+	document.id(myHtmlTable).setStyle('color', 'blue');
+
+	$(myHtmlTable) == myHtmlTable.table; // true
+
+HtmlTable methods: Element methods {#HtmlTable:Element-Methods}
+---------------------------------------------------------------
+
+This class implements the following [Element][] methods:
+
+* adopt
+* inject
+* wraps
+* grab
+* replaces
+* empty
+* dispose
+
+These will execute these methods on the table element.
+
+### Arguments
+
+Each method accepts exactly the same arguments as the [Element][] equivalent.
+
+### Returns
+
+* (*object*) This instance of HtmlTable.
+
+### Example
+
+	myHtmlTable.inject(document.body);
+	//same as:
+	document.id(myHtmlTable).inject(document.body);
+
+Type: Element {#Element}
+==========================
+
+Extends the Element Type with a reference to its [HtmlTable][] instance.
+
+Element property: HtmlTable {#Element:HtmlTable}
+--------------------------------------
+
+### Syntax
+
+	myElement.retrieve('HtmlTable'); //the instance of HtmlTable for the element
+
+[HtmlTable]: #HtmlTable
+[HtmlTable.push]: #HtmlTable:push
+[Options]: /core/Class/Class.Extras#Options
+[Events]: /core/Class/Class.Extras#Events
+[Class.Occlude]: /more/Class/Class.Occlude
+[Element]: /core/Element/Element

data/Packages/mootools-more/Docs/Interface/Keyboard.Extras.md

@@ -0,0 +1,163 @@
+Class: Keyboard {#Keyboard}
+===========================
+
+Adds some methods for creating shortcuts to the [Keyboard][] Class.
+
+Keyboard Method: addShortcut {#Keyboard:addShortcut}
+----------------------------------------
+
+Associates a event handler with a name and description.
+
+### Syntax
+
+	myKeyboard.addShortcut('save', {
+		'keys': 'ctrl+s',
+		'description': 'Save the current document',
+		'handler': doSaveFunc
+	});
+
+### Arguments
+
+1. name - (*string*) The name of the shortcut.
+2. shortcut - (*object*)
+	- keys - (*string (optional)*) Same as the argument that you would pass to addEvent. If not passed it will not automatically add it as an event on the Keyboard.
+  - description - (*string*) A brief description of the functionality.
+  - handler - (*function*) The event handler function.
+
+### Returns
+
+* (*object*) A new instance of [Keyboard][]
+
+
+Keyboard Method: addShortcuts {#Keyboard:addShortcuts}
+----------------------------------------
+
+Same as addShortcut but can send many as key, value pairs.
+
+### Syntax
+
+	myKeyboard.addShortcut({
+		'save', {
+	    	'keys': 'ctrl+s',
+	    	'description': 'Save the current document',
+	    	'handler': doSaveFunc
+		},
+		'open', {
+			'keys': 'ctrl+o',
+			'description': 'Open a document',
+			'handler': doOpenFunc
+		}
+	});
+
+### Arguments
+
+* obj - (*object*) An object of key value pairs to be sent to addShortcut.
+
+### Returns
+
+* (*object*) A new instance of [Keyboard][]
+
+
+Keyboard Method: getShortcuts {#Keyboard:getShortcuts}
+----------------------------------------
+
+Gets all shortcuts on the Keyboard instance.
+
+### Syntax
+
+	myKeyboard.getShortcuts();
+
+### Returns
+
+* (*array*) An array of shortcuts on the Keyboard.
+
+
+Keyboard Method: getShortcut {#Keyboard:getShortcut}
+----------------------------------------
+
+Get a shortcut with the name passed in.
+
+### Syntax
+
+	myKeyboard.getShortcut('save');
+
+### Arguments
+
+* name - (*string*) The name of the shortcut to lookup.
+
+### Returns
+
+* (*object* or *null*) The shortcut with the name if found.
+
+
+Static Method: Keyboard.rebind {#Keyboard:rebind}
+------------------------------------
+
+Unbinds the shortcuts passed in and rebinds them to the keys that are passed in.
+
+### Syntax
+
+	myKeyboard.rebind('shift+s', shortcutObjs);
+
+### Arguments
+
+* keys - (*string*) The new shortcut for the shortcuts.
+* shortcuts - (*object* or *array[object]*) One or more shortcuts to rebind.
+
+
+Static Method: Keyboard.getActiveShortcuts {#Keyboard:getActiveShortcuts}
+------------------------------------
+
+Gets all active shortcuts using the passed in Keyboard or Keyboard.manager as a starting point.
+
+### Syntax
+
+	myKeyboard.getActiveShortcuts();
+
+### Arguments
+
+* keyboard - (*object*: optional) The Keyboard object used to start looking. Keyboard.manager by default.
+
+### Returns
+
+* (*array*) An array containing all of the active shortcuts.
+
+
+Static Method: Keyboard.getShortcut {#Keyboard:getShortcut}
+------------------------------------
+
+Goes through all active keyboards using the passed in keyboard or Keyboard.manager as a starting point and attempts to find a shortcut with the name passed in.
+
+### Syntax
+
+	Keyboard.getShortcut('save');
+
+### Arguments
+
+* name - (*string*) The name of the shortcut to lookup.
+* keyboard - (*object (optional)*) The keyboard to start looking on.
+
+### Returns
+
+* (*object* or *null*) The shortcut with the name if found.
+
+
+Static Method: Keyboard.getShortcuts {#Keyboard:getShortcuts}
+------------------------------------
+
+Same as Keyboard.getShortcut but gets all that match the name.
+
+### Syntax
+
+	myKeyboard.getShortcuts('save');
+
+### Arguments
+
+* name - (*string*) The name of the shortcut to lookup.
+* keyboard - (*object (optional)*) The keyboard to start looking on.
+
+### Returns
+
+* (*array*) An array of shortcuts with the name passed in.
+
+[Keyboard]: /more/Interface/Keyboard

data/Packages/mootools-more/Docs/Interface/Keyboard.md

@@ -0,0 +1,226 @@
+Class: Keyboard {#Keyboard}
+===========================
+
+Keyboard takes out the need to have logic in key events to check which buttons are pressed.  The class fires individual events for keys (individual key events are referred to as sub-events in this documentation) and provides methodology to disable and enable the listeners assigned to a Keyboard instance. Modifiers are allowed.
+
+### Extends
+
+* [Events][]
+
+### Implements
+
+* [Options][]
+
+### Simple Usage
+
+Keyboard has both a simple and advanced use cases. The advanced usage is intended for situations where more than one Keyboard instance is required (see next section). But for simple direct usage, you can just create an instance, attach events, and that's all. If you need more than one instance, it gets more complicated.
+
+### Advanced Usage
+
+Keyboard instances are nodes of a tree based hierarchy (similar to the DOM) that allow complex keyboard driven functionality. The root node of the tree is Keyboard.manager, an instance of Keyboard itself.  When a key event is fired the root node keyboard (Keyboard.manager) gets a chance to handle the event.  The event is then propagated from the currently active leaf node back towards the root.
+
+For example. Let's say you have the following application:
+
+	Desktop UI = Keyboard.manager*
+	|------------------------------|
+	v                              v
+	Window 1 w/ hotkeys*           Window 2 w/ hotkeys
+	|                              |--------------------------------|
+	v                              v                                v
+	HTML Editor w/ hotkeys*        Slideshow w/ hotkeys*    Tagging UI w/ hotkeys
+
+(* = active)
+
+When the user hits a key command, Keyboard.manager gets the first option to handle it. If the user hits Command+Tab you might, for instance, switch window focus (this is just an analogy to a desktop UI; obviously in the real world the operating system would handle this key combo before it got to the browser). If the Keyboard.manager does not handle the event and stop it with [Keyboard.stop][], the event is passed to the deepest instance that has focus (the editor). If the user hits Command+B you might bold the text and stop the event from going further (with [Keyboard.stop][]). If the user hits Command+W the event would go to Keyboard.manager, then to the editor, and when neither of them stop the event, the Window UI instance would have the option of handling it. It might, for example, close the window.
+
+Keyboards are enabled and disabled with their [enable][] method. So if the user were to switch focus to Window 2 in the diagram above, that instance would call its *enable* method, stealing focus from Window 1. If the Keyboard for Slideshow is enabled, it will automatically receive events from the Window 2 manager. This nesting can go as deep as is required. No two siblings can be enabled at a time, and if a Keyboard's parent is not enabled, it will not receive events.
+
+In the diagram above, you can see that Slideshow's Keyboard instance is active, but because it's parent (Window 2) is not, it does not receive events. This allows for a nested state. So if the user switches to Window 2, the Slideshow will start receiving events. If the user focuses on the Tagging UI and your code enables the Tagging Keyboard, stealing from SlideShow, the event order will be Desktop UI > Tagging UI > Window 2. Switching back to Window 1 will restore Desktop UI > HTML Editor > Window 1. The point is that focus is always stolen from siblings, and the state of children remains even when the parent looses that focus.
+
+As an additional note, this means you can add keyboard events to Keyboard.manager. This is how you add "top level" events.
+
+Keyboard Method: constructor
+----------------------------
+
+### Syntax
+
+	var myKeyboardEvents = new Keyboard([options]);
+
+### Arguments
+
+1. options - (*object*, optional) The options for the class detailed below.
+
+#### Options
+
+* defaultEventType: - (*string*; defaults to 'keydown') The event type that should trigger the subevents (this can be changed per key rule, so this is only the default).
+* active: - (*boolean*; defaults to *false*) When not active the events will be suppressed.
+* events: - (*object*; defaults to *{}*) object keys are event names, values should be the function to fire. Same as calling addEvents({...}) on the instance after creation
+
+### Returns
+
+* (*object*) A new instance of [Keyboard][].
+
+### Events
+
+* onActivate - (*function*) callback executed when the keyboard is activated.
+* onDeactivate - (*function*) callback executed when the keyboard is deactivated.
+
+### Examples
+
+	var myKeyboardEvents = new Keyboard({
+		defaultEventType: 'keyup',
+		events: {
+			'shift+h': fn1,
+			'ctrl+shift+h': fn2,
+			'shift+ctrl+h': fn3,
+			'h': fn4,
+			'keydown:shift+d': fn5
+		}
+	});
+
+	var myKeyboardEvents1 = new Keyboard({
+		defaultEventType: 'keydown'
+	});
+	myKeyBoardEvents1.addEvents({
+		'shift+h': fn1,
+		'ctrl+shift+h': fn2,
+		'shift+ctrl+h': fn3,
+		'h': fn4
+	});
+
+### Notes
+
+* In Example both myKeyboardEvents and myKeyboardEvents1 achieve the same ends.
+* The order of key modifiers does not matter. ctrl+shift+h and shift+ctrl+h are the same.
+* In Example pressing 'ctrl+shift+h' will *not* trigger 'shift+h' or 'h'. Likewise with 'shift+h' will not trigger 'h'.
+* The example 'keydown:shift+d' shows how to override the defaultEventType options. You can do this technique on any addEvent type methods.
+
+Keyboard Method: activate {#Keyboard:activate}
+------------------------------------
+
+Activates the events managed by this instance. Note that this steals focus from any sibling keyboard, effectively deactivating it and its children.
+
+### Syntax
+
+	myKeyboard.activate()
+
+### Returns
+
+* (*object*) This instance of [Keyboard][]
+
+Keyboard Method: deactivate {#Keyboard:deactivate}
+------------------------------------
+
+Deactivates the events managed by this instance.
+
+### Syntax
+
+	myKeyboard.deactivate()
+
+### Returns
+
+* (*object*) This instance of [Keyboard][]
+
+Keyboard Method: toggleActive {#Keyboard:toggleActive}
+------------------------------------
+
+Toggles the active state of the events managed by the keyboard.
+
+### Syntax
+
+	myKeyboard.toggleActive()
+
+### Returns
+
+* (*object*) This instance of [Keyboard][]
+
+Keyboard Method: relinquish {#Keyboard:relinquish}
+------------------------------------
+
+Attempts to give control to the previously active keyboard. Will not do anything if there is no previously active keyboard.
+
+### Syntax
+
+	myKeyboard.relinquish()
+
+### Returns
+
+	* (*object*) This instance of [Keyboard][]
+
+
+Keyboard Method: isActive {#Keyboard:isActive}
+------------------------------------
+
+Returns *true* if the instance is active.
+
+### Syntax
+
+	myKeyboard.isActive()
+
+### Returns
+
+	* (*boolean*) *true* if the instance is active.
+
+
+Keyboard Method: manage {#Keyboard:manage}
+------------------------------------
+
+The keyboard will become the parent of the passed in keyboard. By default the manager is the Keybard.manager instance.
+
+### Syntax
+
+	myKeyboard.manage(childKeyboard)
+
+
+### Arguments
+
+	1. childKeyboard - (*object*) an instance of Keyboard that this instance should manage.
+
+### Returns
+
+	* (*object*) This instance of [Keyboard][]
+
+### Note
+
+When myKeyboard is active childKeyboard will receive the event first then as long as childKeyboard did not call Keyboard.stop(event) then the event will bubble up to myKeyboard. If myKeyboard manages more than one Keyboard instance, which ever one is active will receive the events as they bubble.
+
+
+Keyboard Method: drop {#Keyboard:drop}
+------------------------------------
+
+Drops an instance of a keyboard from being managed.
+
+### Syntax
+
+	myKeyboard.drop(childKeyboard)
+
+### Arguments
+
+1. childKeyboard - (*object*) an instance of Keyboard managed by this instance.
+
+### Returns
+
+	* (*object*) This instance of [Keyboard][]
+
+### Note
+
+The result
+
+Static Method: Keyboard.stop {#Keyboard:stop}
+------------------------------------
+
+Stops propagation of the passed in event to other keyboard instances. Note this is not a method on an instance of Keyboard; it is a static method on the Keyboard namespace.
+
+### Syntax
+
+	Keyboard.stop(event)
+
+### Returns
+
+* nothing.
+
+[Keyboard.stop]: #Keyboard:stop
+[enable]: #Keyboard:enable
+[Keyboard]: #Keyboard
+[Options]: /core/Class/Class.Extras#Options
+[Events]: /core/Class/Class.Extras#Events